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