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