public ConnectHandle ConnectRequestHandler(IRequestPipeConnector consumePipe, Guid requestId, MessageHandler <TMessage> handler,
IBuildPipeConfigurator <ConsumeContext <TMessage> > configurator)
{
configurator.AddPipeSpecification(new HandlerPipeSpecification <TMessage>(handler));
return(consumePipe.ConnectRequestPipe(requestId, configurator.Build()));
}
/// <summary>
/// Creates a message request client for the bus and endpoint specified
/// </summary>
/// <param name="sendEndpointProvider"></param>
/// <param name="connector">The bus instance</param>
/// <param name="responseAddress">The response address of the connector</param>
/// <param name="serviceAddress">The service endpoint address</param>
/// <param name="timeout">The request timeout</param>
/// <param name="timeToLive">The time that the request will live for</param>
/// <param name="callback"></param>
public MessageRequestClient(ISendEndpointProvider sendEndpointProvider, IRequestPipeConnector connector, Uri responseAddress, Uri serviceAddress,
TimeSpan timeout, TimeSpan?timeToLive = default(TimeSpan?), Action <SendContext <TRequest> > callback = null)
: base(connector, responseAddress, timeout, timeToLive, callback)
{
_sendEndpointProvider = sendEndpointProvider;
_serviceAddress = serviceAddress;
}
public SendRequestConfigurator(IRequestPipeConnector connector, SendContext <TRequest> context, TaskScheduler taskScheduler,
Action <IRequestConfigurator <TRequest> > callback)
{
if (connector == null)
{
throw new ArgumentNullException(nameof(connector));
}
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (!context.RequestId.HasValue)
{
throw new ArgumentException("The requestId must be initialized");
}
_connections = new Dictionary <Type, RequestHandlerHandle>();
_requestId = context.RequestId.Value;
_connector = connector;
_context = context;
_taskScheduler = taskScheduler;
_requestTask = new TaskCompletionSource <TRequest>(context.CancellationToken);
HandleFault();
callback(this);
if (Timeout > TimeSpan.Zero)
{
_timeoutToken = new CancellationTokenSource(Timeout);
_timeoutToken.Token.Register(TimeoutExpired);
}
}
public HandlerConnectHandle <TResponse> Connect(IRequestPipeConnector connector, Guid requestId)
{
MessageHandler <TResponse> messageHandler = _handler != null ? (MessageHandler <TResponse>)AsyncMessageHandler : MessageHandler;
var connectHandle = connector.ConnectRequestHandler(requestId, messageHandler, _pipeConfigurator);
return(new ResponseHandlerConnectHandle <TResponse>(connectHandle, _completed, _requestTask));
}
public SendRequest(IRequestPipeConnector connector, Uri responseAddress, TaskScheduler taskScheduler, Action <IRequestConfigurator <TRequest> > callback)
{
_taskScheduler = taskScheduler;
_callback = callback;
_connector = connector;
_responseAddress = responseAddress;
_requestId = NewId.NextGuid();
}
protected RequestClient(IRequestPipeConnector connector, Uri responseAddress, TimeSpan timeout, TimeSpan?timeToLive = default(TimeSpan?),
Action <SendContext <TRequest> > callback = null)
{
_connector = connector;
_responseAddress = responseAddress;
_timeout = timeout;
_timeToLive = timeToLive;
_callback = callback;
}
public ConnectHandle ConnectRequestPipe <T>(Guid requestId, IPipe <ConsumeContext <T> > pipe)
where T : class
{
if (pipe == null)
{
throw new ArgumentNullException(nameof(pipe));
}
IRequestPipeConnector <T> messagePipe = GetPipe <T, IRequestPipeConnector <T> >();
return(messagePipe.ConnectRequestPipe(requestId, pipe));
}
public MessageRequestClientFactory(HostReceiveEndpointHandle endpointHandle, IRequestPipeConnector connector, Uri responseAddress,
Uri destinationAddress, TimeSpan timeout, TimeSpan?timeToLive,
Action <SendContext <TRequest> > callback)
{
_endpointHandle = endpointHandle;
_connector = connector;
_responseAddress = responseAddress;
_destinationAddress = destinationAddress;
_timeout = timeout;
_timeToLive = timeToLive;
_callback = callback;
}
public ConnectHandle ConnectRequestHandler(IRequestPipeConnector consumePipe, Guid requestId, MessageHandler <TMessage> handler,
params IPipeSpecification <ConsumeContext <TMessage> >[] pipeSpecifications)
{
IPipe <ConsumeContext <TMessage> > pipe = Pipe.New <ConsumeContext <TMessage> >(x =>
{
foreach (var specification in pipeSpecifications)
{
x.AddPipeSpecification(specification);
}
x.AddPipeSpecification(new HandlerPipeSpecification <TMessage>(handler));
});
return(consumePipe.ConnectRequestPipe(requestId, pipe));
}
public ConnectHandle ConnectRequestObserver(IRequestPipeConnector consumePipe, Guid requestId, IObserver <ConsumeContext <TMessage> > observer,
params IFilter <ConsumeContext <TMessage> >[] filters)
{
IPipe <ConsumeContext <TMessage> > pipe = Pipe.New <ConsumeContext <TMessage> >(x =>
{
foreach (IFilter <ConsumeContext <TMessage> > filter in filters)
{
x.UseFilter(filter);
}
x.AddPipeSpecification(new ObserverPipeSpecification <TMessage>(observer));
});
return(consumePipe.ConnectRequestPipe(requestId, pipe));
}
/// <summary>
/// Subscribe a request handler to the bus's endpoint
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connector"></param>
/// <param name="requestId"></param>
/// <param name="handler"></param>
/// <param name="configurator"></param>
/// <returns></returns>
public static ConnectHandle ConnectRequestHandler <T>(this IRequestPipeConnector connector, Guid requestId, MessageHandler <T> handler,
IBuildPipeConfigurator <ConsumeContext <T> > configurator)
where T : class
{
return(HandlerConnectorCache <T> .Connector.ConnectRequestHandler(connector, requestId, handler, configurator));
}
/// <summary>
/// Subscribe a request handler to the bus's endpoint
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="connector"></param>
/// <param name="requestId"></param>
/// <param name="handler"></param>
/// <param name="specifications"></param>
/// <returns></returns>
public static ConnectHandle ConnectRequestHandler <T>(this IRequestPipeConnector connector, Guid requestId, MessageHandler <T> handler,
params IPipeSpecification <ConsumeContext <T> >[] specifications)
where T : class
{
return(HandlerConnectorCache <T> .Connector.ConnectRequestHandler(connector, requestId, handler, specifications));
}
/// <summary>
/// Creates a message request client for the bus and endpoint specified
/// </summary>
/// <param name="publishEndpoint"></param>
/// <param name="connector">The bus instance</param>
/// <param name="responseAddress">The response address of the connector</param>
/// <param name="serviceAddress">The service endpoint address</param>
/// <param name="timeout">The request timeout</param>
/// <param name="timeToLive">The time that the request will live for</param>
/// <param name="callback"></param>
public PublishRequestClient(IPublishEndpoint publishEndpoint, IRequestPipeConnector connector, Uri responseAddress,
TimeSpan timeout, TimeSpan?timeToLive = default(TimeSpan?), Action <SendContext <TRequest> > callback = null)
: base(connector, responseAddress, timeout, timeToLive, callback)
{
_publishEndpoint = publishEndpoint;
}
/// <summary>
/// Creates a message request client for the bus and endpoint specified
/// </summary>
/// <param name="sendEndpointProvider"></param>
/// <param name="connector">The bus instance</param>
/// <param name="responseAddress">The response address of the connector</param>
/// <param name="serviceAddress">The service endpoint address</param>
/// <param name="timeout">The request timeout</param>
/// <param name="timeToLive">The time that the request will live for</param>
/// <param name="callback"></param>
public MessageRequestClient(ISendEndpointProvider sendEndpointProvider, IRequestPipeConnector connector, Uri responseAddress, Uri serviceAddress,
TimeSpan timeout, TimeSpan?timeToLive = default(TimeSpan?), Action <SendContext <TRequest> > callback = null)
: base(connector, responseAddress, timeout, timeToLive, callback)
{
_requestEndpoint = new Lazy <Task <ISendEndpoint> >(async() => await sendEndpointProvider.GetSendEndpoint(serviceAddress).ConfigureAwait(false));
}
/// <summary>
/// Creates a request client that uses the bus to retrieve the endpoint and send the request.
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="connector"></param>
/// <param name="sendEndpointProvider"></param>
/// <param name="responseAddress"></param>
/// <param name="address">The service address that handles the request</param>
/// <param name="timeout">The timeout before the request is cancelled</param>
/// <param name="ttl">THe time to live for the request message</param>
/// <param name="callback">Callback when the request is sent</param>
/// <returns></returns>
public static IRequestClient <TRequest, TResponse> CreateRequestClient <TRequest, TResponse>(this IRequestPipeConnector connector,
ISendEndpointProvider sendEndpointProvider, Uri responseAddress, Uri address, TimeSpan timeout,
TimeSpan?ttl = default(TimeSpan?), Action <SendContext <TRequest> > callback = null)
where TRequest : class
where TResponse : class
{
return(new MessageRequestClient <TRequest, TResponse>(sendEndpointProvider, connector, responseAddress, address, timeout, ttl, callback));
}
/// <summary>
/// Creates a request client that uses the bus to publish a request.
/// </summary>
/// <typeparam name="TRequest">The request type</typeparam>
/// <typeparam name="TResponse">The response type</typeparam>
/// <param name="responseAddress"></param>
/// <param name="timeout">The timeout before the request is cancelled</param>
/// <param name="callback">Callback when the request is sent</param>
/// <param name="ttl">The time that the request will live for</param>
/// <param name="connector"></param>
/// <param name="publishEndpoint"></param>
/// <returns></returns>
public static IRequestClient <TRequest, TResponse> CreatePublishRequestClient <TRequest, TResponse>(this IRequestPipeConnector connector,
IPublishEndpoint publishEndpoint, Uri responseAddress, TimeSpan timeout,
TimeSpan?ttl = default(TimeSpan?), Action <SendContext <TRequest> > callback = null)
where TRequest : class
where TResponse : class
{
return(new PublishRequestClient <TRequest, TResponse>(publishEndpoint, connector, responseAddress, timeout, ttl, callback));
}
public ConnectHandle Connect(IRequestPipeConnector connector, Guid requestId)
{
var connectHandle = connector.ConnectRequestHandler(requestId, _handler, _specifications.ToArray());
return(connectHandle);
}
