org.elasticsearch.common.io.stream.Writeable Java Examples

protected TransportShardAction(String actionName,
                               TransportService transportService,
                               IndexNameExpressionResolver indexNameExpressionResolver,
                               ClusterService clusterService,
                               IndicesService indicesService,
                               ThreadPool threadPool,
                               ShardStateAction shardStateAction,
                               Writeable.Reader<Request> reader,
                               SchemaUpdateClient schemaUpdateClient) {
    super(
        actionName,
        transportService,
        clusterService,
        indicesService,
        threadPool,
        shardStateAction,
        indexNameExpressionResolver,
        reader,
        reader,
        ThreadPool.Names.WRITE
    );
    this.mappingUpdate = (update, shardId, type) -> {
        validateMapping(update.root().iterator(), false);
        schemaUpdateClient.blockingUpdateOnMaster(shardId.getIndex(), update);
    };
}
 

protected void registerRequestHandlers(String actionName,
                                       TransportService transportService,
                                       Writeable.Reader<Request> reader,
                                       Writeable.Reader<ReplicaRequest> replicaRequestReader,
                                       String executor) {
    transportService.registerRequestHandler(actionName, reader, ThreadPool.Names.SAME, new OperationTransportHandler());
    transportService.registerRequestHandler(
        transportPrimaryAction, in -> new ConcreteShardRequest<>(in, reader), executor, new PrimaryOperationTransportHandler());
    // we must never reject on because of thread pool capacity on replicas
    transportService.registerRequestHandler(
        transportReplicaAction,
        in -> new ConcreteReplicaRequest<>(in, replicaRequestReader),
        executor,
        true,
        true,
        new ReplicaOperationTransportHandler());
}
 

protected TransportReplicationAction(String actionName,
                                     TransportService transportService,
                                     ClusterService clusterService,
                                     IndicesService indicesService,
                                     ThreadPool threadPool,
                                     ShardStateAction shardStateAction,
                                     IndexNameExpressionResolver indexNameExpressionResolver,
                                     Writeable.Reader<Request> reader,
                                     Writeable.Reader<ReplicaRequest> replicaReader,
                                     String executor,
                                     boolean syncGlobalCheckpointAfterOperation) {
    super(actionName, threadPool, indexNameExpressionResolver, transportService.getTaskManager());
    this.transportService = transportService;
    this.clusterService = clusterService;
    this.indicesService = indicesService;
    this.shardStateAction = shardStateAction;
    this.executor = executor;

    this.transportPrimaryAction = actionName + "[p]";
    this.transportReplicaAction = actionName + "[r]";
    registerRequestHandlers(actionName, transportService, reader, replicaReader, executor);

    this.transportOptions = transportOptions();

    this.syncGlobalCheckpointAfterOperation = syncGlobalCheckpointAfterOperation;
}
 

protected TransportNodesAction(String actionName,
                               ThreadPool threadPool,
                               ClusterService clusterService,
                               TransportService transportService,
                               IndexNameExpressionResolver indexNameExpressionResolver,
                               Writeable.Reader<NodesRequest> nodesRequestReader,
                               Writeable.Reader<NodeRequest> nodeRequestReader,
                               String nodeExecutor,
                               Class<NodeResponse> nodeResponseClass) {
    super(actionName, threadPool, transportService, nodesRequestReader, indexNameExpressionResolver);
    this.clusterService = Objects.requireNonNull(clusterService);
    this.transportService = Objects.requireNonNull(transportService);
    this.nodeResponseClass = Objects.requireNonNull(nodeResponseClass);

    this.transportNodeAction = actionName + "[n]";

    transportService.registerRequestHandler(
        transportNodeAction, nodeRequestReader, nodeExecutor, new NodeTransportHandler());
}
 

protected TransportWriteAction(String actionName,
                               TransportService transportService,
                               ClusterService clusterService,
                               IndicesService indicesService,
                               ThreadPool threadPool,
                               ShardStateAction shardStateAction,
                               IndexNameExpressionResolver indexNameExpressionResolver,
                               Writeable.Reader<Request> reader,
                               Writeable.Reader<ReplicaRequest> replicaReader,
                               String executor) {
    super(
        actionName,
        transportService,
        clusterService,
        indicesService,
        threadPool,
        shardStateAction,
        indexNameExpressionResolver,
        reader,
        replicaReader,
        executor,
        true);
}
 

public TransportBroadcastByNodeAction(
        String actionName,
        ThreadPool threadPool,
        ClusterService clusterService,
        TransportService transportService,
        IndexNameExpressionResolver indexNameExpressionResolver,
        Writeable.Reader<Request> reader,
        String executor,
        boolean canTripCircuitBreaker) {
    super(actionName, canTripCircuitBreaker, threadPool, transportService, reader, indexNameExpressionResolver);

    this.clusterService = clusterService;
    this.transportService = transportService;

    transportNodeBroadcastAction = actionName + "[n]";

    transportService.registerRequestHandler(transportNodeBroadcastAction, NodeRequest::new, executor, false, canTripCircuitBreaker,
        new BroadcastByNodeTransportRequestHandler());
}
 

@Override
protected void registerRequestHandlers(String actionName,
                                       TransportService transportService,
                                       Writeable.Reader<ResyncReplicationRequest> reader,
                                       Writeable.Reader<ResyncReplicationRequest> replicaReader,
                                       String executor) {
    transportService.registerRequestHandler(actionName, reader, ThreadPool.Names.SAME, new OperationTransportHandler());
    // we should never reject resync because of thread pool capacity on primary
    transportService.registerRequestHandler(
        transportPrimaryAction,
        in -> new ConcreteShardRequest<>(in, reader),
        executor,
        true,
        true,
        new PrimaryOperationTransportHandler());
    transportService.registerRequestHandler(
        transportReplicaAction,
        in -> new ConcreteReplicaRequest<>(in, replicaReader),
        executor,
        true,
        true,
        new ReplicaOperationTransportHandler());
}
 

protected HandledTransportAction(String actionName,
                                 boolean canTripCircuitBreaker,
                                 ThreadPool threadPool,
                                 TransportService transportService,
                                 Writeable.Reader<Request> requestReader,
                                 IndexNameExpressionResolver indexNameExpressionResolver) {
    super(actionName, threadPool, indexNameExpressionResolver, transportService.getTaskManager());
    transportService.registerRequestHandler(
        actionName,
        ThreadPool.Names.SAME,
        false,
        canTripCircuitBreaker,
        requestReader,
        new TransportHandler()
    );
}
 

TransportKillNodeAction(String name,
                        TasksService tasksService,
                        ClusterService clusterService,
                        TransportService transportService,
                        Writeable.Reader<Request> reader) {
    this.tasksService = tasksService;
    this.clusterService = clusterService;
    this.transportService = transportService;
    this.reader = reader;
    this.name = name;
    transportService.registerRequestHandler(
        name,
        reader,
        ThreadPool.Names.GENERIC,
        new NodeActionRequestHandler<>(this));
}
 

protected TransportMasterNodeAction(String actionName,
                                    boolean canTripCircuitBreaker,
                                    TransportService transportService,
                                    ClusterService clusterService,
                                    ThreadPool threadPool,
                                    Writeable.Reader<Request> request,
                                    IndexNameExpressionResolver indexNameExpressionResolver) {
    super(actionName, canTripCircuitBreaker, threadPool, transportService, request, indexNameExpressionResolver);
    this.transportService = transportService;
    this.clusterService = clusterService;
    this.executor = executor();
}
 

protected TransportReplicationAction(String actionName,
                                     TransportService transportService,
                                     ClusterService clusterService,
                                     IndicesService indicesService,
                                     ThreadPool threadPool,
                                     ShardStateAction shardStateAction,
                                     IndexNameExpressionResolver indexNameExpressionResolver,
                                     Writeable.Reader<Request> reader,
                                     Writeable.Reader<ReplicaRequest> replicaReader,
                                     String executor) {
    this(actionName, transportService, clusterService, indicesService, threadPool, shardStateAction,
            indexNameExpressionResolver, reader, replicaReader, executor, false);
}
 

protected HandledTransportAction(String actionName,
                                 ThreadPool threadPool,
                                 TransportService transportService,
                                 Writeable.Reader<Request> reader,
                                 IndexNameExpressionResolver indexNameExpressionResolver) {
    this(actionName, true, threadPool, transportService, reader, indexNameExpressionResolver);
}
 

protected TransportMasterNodeAction(String actionName,
                                    TransportService transportService,
                                    ClusterService clusterService,
                                    ThreadPool threadPool,
                                    Writeable.Reader<Request> request,
                                    IndexNameExpressionResolver indexNameExpressionResolver) {
    this(actionName, true, transportService, clusterService, threadPool, request, indexNameExpressionResolver);
}
 

protected TransportMasterNodeReadAction(Settings settings,
                                        String actionName,
                                        boolean checkSizeLimit,
                                        TransportService transportService,
                                        ClusterService clusterService,
                                        ThreadPool threadPool,
                                        IndexNameExpressionResolver indexNameExpressionResolver,
                                        Writeable.Reader<Request> request) {
    super(actionName, checkSizeLimit, transportService, clusterService, threadPool, request, indexNameExpressionResolver);
    this.forceLocal = FORCE_LOCAL_SETTING.get(settings);
}
 

/**
 * Simulates sending diffs over the wire
 */
public static <T extends Writeable> T copyInstance(T diffs, NamedWriteableRegistry namedWriteableRegistry,
                                                              Reader<T> reader) throws IOException {
    try (BytesStreamOutput output = new BytesStreamOutput()) {
        diffs.writeTo(output);
        try (StreamInput in = new NamedWriteableAwareStreamInput(output.bytes().streamInput(), namedWriteableRegistry)) {
            return reader.read(in);
        }
    }
}
 

protected static <T> T copyInstance(T original, NamedWriteableRegistry namedWriteableRegistry, Writeable.Writer<T> writer,
                                  Writeable.Reader<T> reader, Version version) throws IOException {
    try (BytesStreamOutput output = new BytesStreamOutput()) {
        output.setVersion(version);
        writer.write(output, original);
        try (StreamInput in = new NamedWriteableAwareStreamInput(output.bytes().streamInput(), namedWriteableRegistry)) {
            in.setVersion(version);
            return reader.read(in);
        }
    }
}
 

public AbstractDDLTransportAction(String actionName,
                                  TransportService transportService,
                                  ClusterService clusterService,
                                  ThreadPool threadPool,
                                  IndexNameExpressionResolver indexNameExpressionResolver,
                                  Writeable.Reader<Request> requestReader,
                                  Writeable.Reader<Response> responseReader,
                                  Function<Boolean, Response> ackedResponseFunction,
                                  String source) {
    super(actionName, transportService, clusterService, threadPool, requestReader, indexNameExpressionResolver);
    this.reader = responseReader;
    this.ackedResponseFunction = ackedResponseFunction;
    this.source = source;
}
 

public TransportBroadcastReplicationAction(String name,
                                           Writeable.Reader<Request> reader,
                                           ThreadPool threadPool,
                                           ClusterService clusterService,
                                           TransportService transportService,
                                           IndexNameExpressionResolver indexNameExpressionResolver,
                                           TransportReplicationAction replicatedBroadcastShardAction) {
    super(name, threadPool, transportService, reader, indexNameExpressionResolver);
    this.replicatedBroadcastShardAction = replicatedBroadcastShardAction;
    this.clusterService = clusterService;
}
 

/**
 * Asserts that testInstance can be correctly.
 */
public static  <T extends Writeable> T assertSerialization(T testInstance, NamedWriteableRegistry namedWriteableRegistry,
                                                      Reader<T> reader) throws IOException {
    T deserializedInstance = copyInstance(testInstance, namedWriteableRegistry, reader);
    assertEquals(testInstance, deserializedInstance);
    assertEquals(testInstance.hashCode(), deserializedInstance.hashCode());
    assertNotSame(testInstance, deserializedInstance);
    return deserializedInstance;
}
 

public ActionListenerResponseHandler(ActionListener<? super Response> listener,
                                     Writeable.Reader<Response> reader,
                                     String executor) {
    this.listener = Objects.requireNonNull(listener);
    this.reader = Objects.requireNonNull(reader);
    this.executor = Objects.requireNonNull(executor);
}
 

public RequestHandlerRegistry(String action, Writeable.Reader<Request> requestReader, TaskManager taskManager,
                              TransportRequestHandler<Request> handler, String executor, boolean forceExecution,
                              boolean canTripCircuitBreaker) {
    this.action = action;
    this.requestReader = requestReader;
    this.handler = handler;
    this.forceExecution = forceExecution;
    this.canTripCircuitBreaker = canTripCircuitBreaker;
    this.executor = executor;
    this.taskManager = taskManager;
}
 

/**
 * Registers a new request handler
 *
 * @param action                The action the request handler is associated with
 * @param requestReader               The request class that will be used to construct new instances for streaming
 * @param executor              The executor the request handling will be executed on
 * @param forceExecution        Force execution on the executor queue and never reject it
 * @param canTripCircuitBreaker Check the request size and raise an exception in case the limit is breached.
 * @param handler               The handler itself that implements the request handling
 */
public <Request extends TransportRequest> void registerRequestHandler(String action,
                                                                      String executor, boolean forceExecution,
                                                                      boolean canTripCircuitBreaker,
                                                                      Writeable.Reader<Request> requestReader,
                                                                      TransportRequestHandler<Request> handler) {
    validateActionName(action);
    handler = interceptor.interceptHandler(action, executor, forceExecution, handler);
    RequestHandlerRegistry<Request> reg = new RequestHandlerRegistry<>(
        action, requestReader, taskManager, handler, executor, forceExecution, canTripCircuitBreaker);
    transport.registerRequestHandler(reg);
}
 

/**
 * Registers a new request handler
 *
 * @param action                The action the request handler is associated with
 * @param reader               The request class that will be used to construct new instances for streaming
 * @param executor              The executor the request handling will be executed on
 * @param forceExecution        Force execution on the executor queue and never reject it
 * @param canTripCircuitBreaker Check the request size and raise an exception in case the limit is breached.
 * @param handler               The handler itself that implements the request handling
 */
public <Request extends TransportRequest> void registerRequestHandler(String action,
                                                                      Writeable.Reader<Request> reader,
                                                                      String executor,
                                                                      boolean forceExecution,
                                                                      boolean canTripCircuitBreaker,
                                                                      TransportRequestHandler<Request> handler) {
    validateActionName(action);
    handler = interceptor.interceptHandler(action, executor, forceExecution, handler);
    RequestHandlerRegistry<Request> reg = new RequestHandlerRegistry<>(
        action, reader, taskManager, handler, executor, forceExecution, canTripCircuitBreaker);
    transport.registerRequestHandler(reg);
}
 

/**
 * Registers a new request handler
 *
 * @param action         The action the request handler is associated with
 * @param requestReader  a callable to be used construct new instances for streaming
 * @param executor       The executor the request handling will be executed on
 * @param handler        The handler itself that implements the request handling
 */
public <Request extends TransportRequest> void registerRequestHandler(String action, String executor,
                                                                      Writeable.Reader<Request> requestReader,
                                                                      TransportRequestHandler<Request> handler) {
    validateActionName(action);
    handler = interceptor.interceptHandler(action, executor, false, handler);
    RequestHandlerRegistry<Request> reg = new RequestHandlerRegistry<>(
        action, requestReader, taskManager, handler, executor, false, true);
    transport.registerRequestHandler(reg);
}
 

/**
 * Registers a new request handler
 *
 * @param action         The action the request handler is associated with
 * @param reader a callable to be used construct new instances for streaming
 * @param executor       The executor the request handling will be executed on
 * @param handler        The handler itself that implements the request handling
 */
public <Request extends TransportRequest> void registerRequestHandler(String action,
                                                                      Writeable.Reader<Request> reader,
                                                                      String executor,
                                                                      TransportRequestHandler<Request> handler) {
    validateActionName(action);
    handler = interceptor.interceptHandler(action, executor, false, handler);
    RequestHandlerRegistry<Request> reg = new RequestHandlerRegistry<>(
        action, reader, taskManager, handler, executor, false, true);
    transport.registerRequestHandler(reg);
}
 

public TransportChannelResponseHandler(Logger logger,
                                       TransportChannel channel,
                                       String extraInfoOnError,
                                       Writeable.Reader<T> reader) {
    this.logger = logger;
    this.channel = channel;
    this.extraInfoOnError = extraInfoOnError;
    this.reader = reader;
}
 

/**
 * Same as {@link #copyWriteable(Writeable, NamedWriteableRegistry, Writeable.Reader)} but also allows to provide
 * a {@link Version} argument which will be used to write and read back the object.
 */
public static <T extends Writeable> T copyWriteable(T original, NamedWriteableRegistry namedWriteableRegistry,
                                                    Writeable.Reader<T> reader, Version version) throws IOException {
    return copyInstance(original, namedWriteableRegistry, (out, value) -> value.writeTo(out), reader, version);
}
 

@Override
protected Writeable.Reader<Diff<Custom>> diffReader() {
    return SnapshotsInProgress::readDiffFrom;
}
 

@Override
protected Writeable.Reader<Custom> instanceReader() {
    return SnapshotsInProgress::new;
}
 

@Override
public Writeable.Reader<ClusteringActionResponse> getResponseReader() {
   return ClusteringActionResponse::new;
}