Java Code Examples for org.elasticsearch.common.io.stream.Writeable#Reader

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 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()
    );
}
 

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 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);
    };
}
 

@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());
}
 

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);
}
 

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);
}
 

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;
}
 

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

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 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);
}
 

Type(Writeable.Reader<ExecutionPhase> reader) {
    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
public Writeable.Reader<ListAlgorithmsActionResponse> getResponseReader() {
    return ListAlgorithmsActionResponse::new;
}
 

/**
 * Create a copy of an original {@link Writeable} object by running it through a {@link BytesStreamOutput} and
 * reading it in again using a provided {@link Writeable.Reader}. The stream that is wrapped around the {@link StreamInput}
 * potentially need to use a {@link NamedWriteableRegistry}, so this needs to be provided too (although it can be
 * empty if the object that is streamed doesn't contain any {@link NamedWriteable} objects itself.
 */
public static <T extends Writeable> T copyWriteable(T original, NamedWriteableRegistry namedWriteableRegistry,
        Writeable.Reader<T> reader) throws IOException {
    return copyWriteable(original, namedWriteableRegistry, reader, Version.CURRENT);
}
 

/**
 * Returns a {@link Writeable.Reader} that can be used to de-serialize the instance
 */
protected abstract Writeable.Reader<T> instanceReader();