private async Task SendToProcessor(IEndpointConfiguration ep, IMessage[] toSend) { this.LogDebug($"Sending {toSend.Length} messages to {ep.Id}"); await ep.AddToProcessing(toSend).ConfigureFalse(); _auditor.SentToLocal(ep.Id, toSend); }
protected BusFactoryConfigurator(IEndpointConfiguration configuration) { _configuration = configuration; _specifications = new List <IBusFactorySpecification <TBuilder> >(); _endpointSpecifications = new List <IReceiveEndpointSpecification <TBuilder> >(); }
protected void SetWorkflowMessage(IEndpointConfiguration endpointConfiguration, IWorkflowMessage workflowMessage, CancellationToken cancellationToken) { if (!WorkflowMessages.ContainsKey(workflowMessage.WorkflowMessageId)) { WorkflowMessages[workflowMessage.WorkflowMessageId] = workflowMessage; } }
protected ReceiveSpecification(IEndpointConfiguration configuration) { Configuration = configuration; Specifications = new List <IReceiveEndpointSpecification>(); ReceivePipeConfigurator = new PipeConfigurator <ReceiveContext>(); }
public async Task Send <TWorkflowMessage>(IEndpointConfiguration endpointConfiguration, TWorkflowMessage workflowMessage, CancellationToken cancellationToken) where TWorkflowMessage : class, IWorkflowMessage { var sendEndpoint = await _busControl.GetSendEndpoint(endpointConfiguration.Address).ConfigureAwait(false); await sendEndpoint.Send(workflowMessage, cancellationToken).ConfigureAwait(false); }
public DispatcherClientTests() { _server = Substitute.For<ITalkToServer>(); _err = Substitute.For<IDeliveryErrorsQueue>(); _sut =new DispatcherClient(Setup.TestEndpoint.Host,_server,_err,new BusAuditor(new InMemoryAuditStorage())); _config = SetupFakeConfig(); _sut.SubscribeToServer(new []{_config}); }
public DispatcherClientTests() { _server = Substitute.For <ITalkToServer>(); _err = Substitute.For <IDeliveryErrorsQueue>(); _sut = new DispatcherClient(Setup.TestEndpoint.Host, _server, _err, new BusAuditor(new InMemoryAuditStorage())); _config = SetupFakeConfig(); _sut.SubscribeToServer(new [] { _config }); }
protected ReceiveEndpointBuilder(IBusBuilder builder, IEndpointConfiguration configuration) { _configuration = configuration; _consumePipe = configuration.Consume.CreatePipe(); _serializerBuilder = builder.CreateSerializerBuilder(); }
protected ReceiveEndpointConfiguration(IEndpointConfiguration configuration) { _configuration = configuration; _consumePipe = new Lazy <IConsumePipe>(() => _configuration.Consume.CreatePipe()); _specifications = new List <IReceiveEndpointSpecification>(); _lateConfigurationKeys = new List <string>(); }
protected EndpointConfiguration(IEndpointConfiguration parentConfiguration, ITopologyConfiguration topology, IConsumePipe consumePipe = null) { Topology = topology; Consume = new ConsumePipeConfiguration(parentConfiguration.Consume.Specification, consumePipe); Send = new SendPipeConfiguration(parentConfiguration.Send.Specification); Publish = new PublishPipeConfiguration(parentConfiguration.Publish.Specification); }
/// <summary> /// Creates bus control instance for consuming the messagedata from the queue. /// Queuename and related container to be wrapped in the IEndpointConfiguration. /// </summary> /// <param name="endpointConfiguration"></param> /// <returns></returns> public IBusControl CreateBus(IEndpointConfiguration endpointConfiguration) { return(Bus.Factory.CreateUsingRabbitMq(x => { x.UseDelayedExchangeMessageScheduler(); x.Host(new Uri(this.rabbitMQHost), h => { h.Username(this.queueUserName); h.Password(this.queuePassword); if (this.hasCluster) { h.UseCluster(c => { if (!string.IsNullOrEmpty(this.hostNames)) { string[] hostnames = this.hostNames.Split(';'); c.ClusterMembers = hostnames; } }); } if (this.hasSSL) { h.UseSsl(s => { s.ServerName = System.Net.Dns.GetHostName(); s.CertificatePath = this.certificatePath; s.CertificatePassphrase = this.certificatePassphrase; }); } }); if (this.hasConsumer) { foreach (var listener in endpointConfiguration.ListenerInfo) { if (this.prefetchCount > 0) { x.PrefetchCount = (ushort)this.prefetchCount; } x.ReceiveEndpoint(listener.Key, ec => { if (this.hasRetry) { ec.UseScheduledRedelivery(r => r.Incremental( this.retryLimit, TimeSpan.FromSeconds(this.initialInterval), TimeSpan.FromSeconds(this.intervalIncrement))); } ec.LoadFrom(listener.Value); }); } } })); }
public async Task <TManagerCommandResponse> Request <TManagerCommandRequest, TManagerCommandResponse>( IEndpointConfiguration endpointConfiguration, TManagerCommandRequest request, CancellationToken cancellationToken) where TManagerCommandRequest : ManagerCommandRequest where TManagerCommandResponse : ManagerCommandResponse { var requestClient = CreateRequestClient <TManagerCommandRequest, TManagerCommandResponse>(endpointConfiguration); return(await requestClient.Request(request, cancellationToken).ConfigureAwait(false)); }
public MessageReceiver( ILogger <MessageReceiver> logger, IEndpointConfiguration endpointConfiguration, IDummyEventHandler dummyEventHandler) { _logger = logger; _endpointConfiguration = endpointConfiguration; _dummyEventHandler = dummyEventHandler; }
protected BusFactoryConfigurator(IBusConfiguration configuration, IEndpointConfiguration busEndpointConfiguration) { _configuration = configuration; _busEndpointConfiguration = busEndpointConfiguration; BusObservable = new BusObservable(); _specifications = new List <IBusFactorySpecification>(); _endpointSpecifications = new List <IReceiveEndpointSpecification <IBusBuilder> >(); }
protected BaseHttpClient(System.Net.Http.HttpClient httpClient, IEndpointConfiguration configuration) { httpClient.BaseAddress = new Uri(configuration.BaseUrl); httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); httpClient.DefaultRequestHeaders.AcceptEncoding.Add(new StringWithQualityHeaderValue("gzip")); _httpClient = httpClient; Configuration = configuration; }
protected ReceiveEndpointBuilder(IReceiveEndpointConfiguration configuration) { _configuration = configuration; _consumePipe = configuration.ConsumePipe; ReceiveObservers = new ReceiveObservable(); TransportObservers = new ReceiveTransportObservable(); EndpointObservers = new ReceiveEndpointObservable(); }
protected ReceiverConfiguration(IEndpointConfiguration endpointConfiguration) : base(endpointConfiguration) { Specifications = new List <IReceiveEndpointSpecification>(); if (LogContext.Current == null) { LogContext.ConfigureCurrentLogContext(); } }
public async Task <TResponseWorkflowMessage> Request <TRequestWorkflowMessage, TResponseWorkflowMessage>( IEndpointConfiguration endpointConfiguration, TRequestWorkflowMessage workflowMessage, CancellationToken cancellationToken) where TRequestWorkflowMessage : class, IWorkflowMessage where TResponseWorkflowMessage : class, IWorkflowMessage { // TODO: need to find a way to dispose <ClientRequestHandle> under the hood to avoid <RequestTimeoutException> to be thrown var requestClient = CreateRequestClient <TRequestWorkflowMessage, TResponseWorkflowMessage>(endpointConfiguration); return(await requestClient.Request(workflowMessage, cancellationToken).ConfigureAwait(false)); }
protected EndpointConfiguration(IEndpointConfiguration endpointConfiguration) { Topology = endpointConfiguration.Topology; Consume = endpointConfiguration.Consume; Send = endpointConfiguration.Send; Publish = endpointConfiguration.Publish; Receive = endpointConfiguration.Receive; Serialization = endpointConfiguration.Serialization; }
protected EndpointConfiguration(IEndpointConfiguration parentConfiguration, ITopologyConfiguration topology) { Topology = topology; Consume = new ConsumePipeConfiguration(parentConfiguration.Consume.Specification); Send = new SendPipeConfiguration(parentConfiguration.Send.Specification); Publish = new PublishPipeConfiguration(parentConfiguration.Publish.Specification); Receive = new ReceivePipeConfiguration(); Serialization = parentConfiguration.Serialization.CreateSerializationConfiguration(); }
private void SetAuthenticationParameters(IEndpointConfiguration endpointConfiguration) { if (null == endpointConfiguration.Authentication || endpointConfiguration.Authentication.Type == ConfigurationAuthenticationType.None) { return; } if (endpointConfiguration.Authentication.Type == ConfigurationAuthenticationType.Basic) { SetBasicAuthenticationParameters(endpointConfiguration); } }
protected ReceiveEndpointSpecification(IEndpointConfiguration configuration) { _configuration = configuration; _specifications = new List <IReceiveEndpointSpecification>(); _receiveConfigurator = new PipeConfigurator <ReceiveContext>(); _lateConfigurationKeys = new List <string>(); _inputAddress = new Lazy <Uri>(GetInputAddress); _errorAddress = new Lazy <Uri>(GetErrorAddress); _deadLetterAddress = new Lazy <Uri>(GetDeadLetterAddress); }
public async Task Send <TWorkflowMessage>(IEndpointConfiguration endpointConfiguration, TWorkflowMessage workflowMessage, CancellationToken cancellationToken) where TWorkflowMessage : class, IWorkflowMessage { VerifyEndpointConfiguration(endpointConfiguration); SetAuthenticationParameters(endpointConfiguration); var uriBuilder = new WorkflowMessageHttpUriBuilder(endpointConfiguration.Address); var httpAddress = uriBuilder.Build(workflowMessage.State.JsonState); var httpMethod = GetHttpMethod(endpointConfiguration); await MakeHttpCall(httpMethod, httpAddress, workflowMessage.State.JsonState, cancellationToken).ConfigureAwait(false); }
private static void VerifyEndpointConfiguration(IEndpointConfiguration endpointConfiguration) { Guard.ArgumentNotNull(endpointConfiguration, nameof(endpointConfiguration)); Guard.ArgumentNotNull(endpointConfiguration.Address, nameof(endpointConfiguration.Address)); var scheme = endpointConfiguration.Address.Scheme; if (!(string.Equals(Uri.UriSchemeHttp, scheme, StringComparison.OrdinalIgnoreCase) || string.Equals(Uri.UriSchemeHttps, scheme, StringComparison.OrdinalIgnoreCase))) { throw new ApplicationException($"Endpoint [{endpointConfiguration.Code}] uses Type = 'Http' but Address scheme is '{scheme}'"); } }
protected ReceiveEndpointConfiguration(IEndpointConfiguration endpointConfiguration) { _endpointConfiguration = endpointConfiguration; _consumePipe = new Lazy <IConsumePipe>(() => _endpointConfiguration.Consume.CreatePipe()); _specifications = new List <IReceiveEndpointSpecification>(); _lateConfigurationKeys = new List <string>(); _dependencies = new List <IReceiveEndpointDependency>(); EndpointObservers = new ReceiveEndpointObservable(); ReceiveObservers = new ReceiveObservable(); TransportObservers = new ReceiveTransportObservable(); }
public ManagedSocketListener( IScheduler scheduler, IEndpointConfiguration endpoint, IServerConfiguration configuration ) { try { Scheduler = scheduler; Configuration = configuration; Connection = Bind( endpoint ); } catch (Exception ex) { Console.WriteLine( ex ); } }
public async Task SendWithDelay <TWorkflowMessage>(IEndpointConfiguration endpointConfiguration, TWorkflowMessage workflowMessage, CancellationToken cancellationToken) where TWorkflowMessage : class, IDelayedWorkflowMessage { var addressEndpoint = string.Format(CultureInfo.InvariantCulture, "{0}://{1}{2}/{3}?type=topic", endpointConfiguration.Address.Scheme, endpointConfiguration.Address.Host, endpointConfiguration.Address.Port == -1 ? string.Empty : ":" + endpointConfiguration.Address.Port.ToString(CultureInfo.InvariantCulture), workflowMessage.Delay.ToRabbitMqDelayedExchangeName("workflow.exchange.delay-")); var sendEndpoint = await _busControl.GetSendEndpoint(new Uri(addressEndpoint)); await sendEndpoint.Send(workflowMessage, cancellationToken).ConfigureAwait(false); }
protected BusBuilder(IBusHostCollection hosts, IEndpointConfiguration configuration) { _hosts = hosts; _configuration = configuration; _serializerBuilder = new SerializerBuilder(); _busObservable = new BusObservable(); _inputAddress = new Lazy <Uri>(GetInputAddress); _consumePipe = _configuration.Consume.CreatePipe(); }
protected ReceiveEndpointConfiguration(IHostConfiguration hostConfiguration, IEndpointConfiguration configuration) { _hostConfiguration = hostConfiguration; _configuration = configuration; _consumePipe = new Lazy <IConsumePipe>(() => _configuration.Consume.CreatePipe()); _specifications = new List <IReceiveEndpointSpecification>(); _lateConfigurationKeys = new List <string>(); EndpointObservers = new ReceiveEndpointObservable(); ReceiveObservers = new ReceiveObservable(); TransportObservers = new ReceiveTransportObservable(); }
public Win32SocketAdapter( IEndpointConfiguration endpoint, IServerConfiguration configuration ) { try { Configuration = configuration; Connection = Bind( endpoint ); Bytes = new byte[configuration.ReadBufferSize]; OnDisconnect = new List<Action>(); } catch (Exception ex) { Console.WriteLine( ex ); } }
private void SetBasicAuthenticationParameters(IEndpointConfiguration endpointConfiguration) { if (!TryGetParameter(endpointConfiguration.Authentication.Parameters, "UserName", out var username)) { throw new ApplicationException($"Endpoint {endpointConfiguration.Code} is configured to use 'Basic' authentication but no UserName has been provided"); } if (!TryGetParameter(endpointConfiguration.Authentication.Parameters, "Password", out var password)) { throw new ApplicationException($"Endpoint {endpointConfiguration.Code} is configured to use 'Basic' authentication but no Password has been provided"); } var authorization = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{username}:{password}")); _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", authorization); }
protected ReceiveEndpointConfiguration(IHostConfiguration hostConfiguration, IEndpointConfiguration endpointConfiguration) : base(endpointConfiguration) { _consumePipe = new Lazy <IConsumePipe>(() => Consume.Specification.BuildConsumePipe()); _specifications = new List <IReceiveEndpointSpecification>(); _lateConfigurationKeys = new List <string>(); _dependencies = new List <IReceiveEndpointDependency>(); EndpointObservers = new ReceiveEndpointObservable(); ReceiveObservers = new ReceiveObservable(); TransportObservers = new ReceiveTransportObservable(); ConnectConsumerConfigurationObserver(hostConfiguration.BusConfiguration); ConnectSagaConfigurationObserver(hostConfiguration.BusConfiguration); ConnectHandlerConfigurationObserver(hostConfiguration.BusConfiguration); ConnectActivityConfigurationObserver(hostConfiguration.BusConfiguration); }
public SynchSourcesConfiguration( [NotNull] IEndpointConfiguration <T1, TId> type1EndpointConfiguration, [NotNull] IEndpointConfiguration <T2, TId> type2EndpointConfiguration, [NotNull] ITranslator <T1, T2> typeTranslator) { if (type1EndpointConfiguration == null) { throw new ArgumentNullException(nameof(type1EndpointConfiguration)); } if (type2EndpointConfiguration == null) { throw new ArgumentNullException(nameof(type2EndpointConfiguration)); } Type1EndpointConfiguration = type1EndpointConfiguration; Type2EndpointConfiguration = type2EndpointConfiguration; TypeTranslator = typeTranslator; }
public void AddEndPoint( IEndpointConfiguration endpoint ) { Endpoints.Add( endpoint ); }
public HttpHostConfiguration AddEndpointConfiguration(IEndpointConfiguration configureEndpoint) { this.endpointConfiguration.Add(configureEndpoint); return this; }
public SOCKET Bind( IEndpointConfiguration configuration ) { SOCKET socket = INVALID_SOCKET; "Binding to endpoint {0}:{1}" .ToDebug<ISocketServer>( configuration.BindTo ?? "0.0.0.0", configuration.Port ); try { WSAPROTOCOL_INFO info = new WSAPROTOCOL_INFO(); Native.WSASocket( (int) AddressFamily.InterNetworkv4, (int) SocketType.Stream, (int) ProtocolType.Tcp, out info, 0, (int) SocketFlags.Overlapped ); var address = Native.inet_addr( configuration.AnyInterface ? "0.0.0.0" : configuration.BindTo ); var port = Native.htons( (ushort) configuration.Port ); sockaddr_in socket_address = new sockaddr_in(); socket_address.sin_addr.S_addr = address; socket_address.sin_port = port; socket_address.sin_family = (short) AddressFamily.InterNetworkv4; Native.bind( socket, &socket_address, sizeof ( sockaddr_in ) ); Native.listen( socket, 10000 ); return socket; } catch (Exception e) { "Binding to endpoint {0}:{1} FAILED." .ToDebug<ISocketServer>( configuration.BindTo ?? "0.0.0.0", configuration.Port ); } return socket; }
public ISocketListener CreateListener( IScheduler scheduler, IEndpointConfiguration endpoint, IServerConfiguration server ) { return Listener; }
public ISocketListener CreateListener( IScheduler scheduler, IEndpointConfiguration endpoint, IServerConfiguration server ) { return new ManagedSocketListener( scheduler, endpoint, server ); }
public Socket Bind( IEndpointConfiguration configuration ) { try { var socket = new Socket( AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.IP ); var address = configuration.AnyInterface ? IPAddress.Any : IPAddress.Parse( configuration.BindTo ); var endpoint = new IPEndPoint( address, configuration.Port ); socket.Bind( endpoint ); socket.Listen( 1000 ); return socket; } catch ( Exception ex ) { "Binding to endpoint {0}:{1} FAILED." .ToError<ISocketServer>( configuration.BindTo ?? "0.0.0.0", configuration.Port ); throw ex; } return null; }