@dolittle/sdk.services/Distribution/ReverseCallClient.d.ts

Dolittle is a decentralized, distributed, event-driven microservice platform built to harness the power of events.

import { Logger } from 'winston';
import { Observable } from 'rxjs';
import { ExecutionContext } from '@dolittle/sdk.execution';
import { Cancellation } from '@dolittle/sdk.resilience';
import { Ping, Pong } from '@dolittle/contracts/Services/Ping_pb';
import { ReverseCallArgumentsContext, ReverseCallRequestContext, ReverseCallResponseContext } from '@dolittle/contracts/Services/ReverseCallContext_pb';
import { IReverseCallClient, ReverseCallCallback } from './IReverseCallClient';
/**
 * Represents an implementation of {@link IReverseCallClient}.
 * @template TClientMessage The type of the messages from the client to the server.
 * @template TServerMessage The type of the messages from the server to the client.
 * @template TConnectArguments The type of the connect arguments message.
 * @template TConnectResponse The type of the connect response message.
 * @template TRequest The type of the request messages.
 * @template TResponse The type of the response messages.
 */
export declare class ReverseCallClient<TClientMessage, TServerMessage, TConnectArguments, TConnectResponse, TRequest, TResponse> extends IReverseCallClient<TConnectResponse> {
    private _establishConnection;
    private _messageConstructor;
    private _setConnectArguments;
    private _getConnectResponse;
    private _getMessageRequest;
    private _setMessageResponse;
    private _setArgumentsContext;
    private _getRequestContext;
    private _setResponseContext;
    private _getMessagePing;
    private _setMessagePong;
    private _executionContext;
    private _connectArguments;
    private _pingInterval;
    private _callback;
    private _cancellation;
    private _logger;
    /**
     * Creates a new instance of the {@link ReverseCallClient} class.
     * @param {(Observable, Cancellation) => Observable<TServerMessage>} _establishConnection - The callback to use to establish a new connection.
     * @param {() => TClientMessage} _messageConstructor - The constructor to use to create a new {@link TClientMessage}.
     * @param {(TClientMessage, TConnectArguments) => void} _setConnectArguments - The callback to use to set the connect arguments to a client message.
     * @param {(TServerMessage) => TRequest | undefined} _getConnectResponse - The callback to use to get the connect response from a server message.
     * @param {(TServerMessage) => TRequest | undefined} _getMessageRequest - The callback to use to get a request from a server message.
     * @param {(TClientMessage, TResponse) => void} _setMessageResponse - The callback to use to set a response to a client message.
     * @param {(TConnectArguments, ReverseCallArgumentsContext) => void} _setArgumentsContext - The callback to use to set the call context in a connect arguments message.
     * @param {(TRequest) => ReverseCallRequestContext | undefined} _getRequestContext - The callback to use to get the call context from a request message.
     * @param {(TResponse, ReverseCallResponseContext) => void} _setResponseContext - The callback to use to set the call context in a response message.
     * @param {(TServerMessage) => Ping | undefined} _getMessagePing - The callback to use to get a ping from a server message.
     * @param {(TClientMessage, Pong) => void} _setMessagePong - The callback to use to set a pong in a client message.
     * @param {ExecutionContext} _executionContext - The execution context of the client.
     * @param {TConnectArguments} _connectArguments - The connect arguments to use to initiate the reverse call client.
     * @param {number} _pingInterval - The interval to request the server to send pings (in seconds).
     * @param {ReverseCallCallback<TRequest, TResponse>} _callback - The callback to use to handle requests from the server to the client.
     * @param {Cancellation} _cancellation - The cancellation token to use to cancel the reverse call client.
     * @param {Logger} _logger - The logger to use for logging.
     */
    constructor(_establishConnection: (requests: Observable<TClientMessage>, cancellation: Cancellation) => Observable<TServerMessage>, _messageConstructor: new () => TClientMessage, _setConnectArguments: (message: TClientMessage, connectArguments: TConnectArguments) => void, _getConnectResponse: (message: TServerMessage) => TConnectResponse | undefined, _getMessageRequest: (message: TServerMessage) => TRequest | undefined, _setMessageResponse: (message: TClientMessage, reponse: TResponse) => void, _setArgumentsContext: (connectArguments: TConnectArguments, context: ReverseCallArgumentsContext) => void, _getRequestContext: (request: TRequest) => ReverseCallRequestContext | undefined, _setResponseContext: (response: TResponse, context: ReverseCallResponseContext) => void, _getMessagePing: (message: TServerMessage) => Ping | undefined, _setMessagePong: (message: TClientMessage, pong: Pong) => void, _executionContext: ExecutionContext, _connectArguments: TConnectArguments, _pingInterval: number, _callback: ReverseCallCallback<TRequest, TResponse>, _cancellation: Cancellation, _logger: Logger);
    /**
     * Sets up the connection, pinging and response handling from the set/get methods.
     * @param {Subscriber<TConnectResponse>} subscriber - The subscriber that started the reverse call.
     */
    private start;
    private isPingOrRequests;
    private isPingMessage;
    private isValidMessage;
    private handleServerRequests;
    private isConnectResponse;
    private handleConnectionResponse;
}
//# sourceMappingURL=ReverseCallClient.d.ts.map