/// <summary>
/// Constructor.
/// </summary>
/// <param name="endpointDefinition">The endpoint definition to create the listener for.</param>
/// <param name="tcpListener">The TCP listener for the endpoint.</param>
/// <param name="disposeAction">The action to execute when the listener has been disposed.</param>
internal EndpointListener(IEndpointDefinition endpointDefinition, TcpListener tcpListener, Action disposeAction)
{
_endpointDefinition = endpointDefinition;
_tcpListener = tcpListener;
_disposeAction = disposeAction;
}
/// <summary>
/// We may want to have a builder/endpoint context that could store things like management endpoint, etc. to configure
/// filters and add configuration interfaces for things like concurrency limit and prefetch count
/// </summary>
/// <param name="configurator"></param>
/// <param name="definition"></param>
/// <param name="configure">The callback to invoke after the definition configuration has been applied</param>
internal static void Apply(this IAmazonSqsReceiveEndpointConfigurator configurator, IEndpointDefinition definition,
Action <IAmazonSqsReceiveEndpointConfigurator> configure = null)
{
if (definition.IsTemporary)
{
configurator.AutoDelete = true;
configurator.Durable = false;
}
if (definition.PrefetchCount.HasValue)
{
configurator.PrefetchCount = (ushort)definition.PrefetchCount.Value;
}
if (definition.ConcurrentMessageLimit.HasValue)
{
var concurrentMessageLimit = definition.ConcurrentMessageLimit.Value;
// if there is a prefetchCount, and it's greater than the concurrent message limit, we need a filter
if (!definition.PrefetchCount.HasValue || definition.PrefetchCount.Value > concurrentMessageLimit)
{
configurator.UseConcurrencyLimit(concurrentMessageLimit);
// we should determine a good value to use based upon the concurrent message limit
if (definition.PrefetchCount.HasValue == false)
{
var calculatedPrefetchCount = concurrentMessageLimit * 12 / 10;
configurator.PrefetchCount = (ushort)calculatedPrefetchCount;
}
}
}
definition.Configure(configurator);
configure?.Invoke(configurator);
}
public abstract HostReceiveEndpointHandle ConnectReceiveEndpoint(IEndpointDefinition definition, IEndpointNameFormatter endpointNameFormatter,
Action <IReceiveEndpointConfigurator> configureEndpoint = null);
/// <summary>
/// Adds a definition for an endpoint to listen on.
/// </summary>
/// <param name="value">The endpoint to listen on.</param>
/// <returns>A OptionsBuilder to continue building on.</returns>
public SmtpServerOptionsBuilder Endpoint(IEndpointDefinition value)
{
_setters.Add(options => options.Endpoints.Add(value));
return(this);
}
HostReceiveEndpointHandle IReceiveConnector.ConnectReceiveEndpoint(IEndpointDefinition definition, IEndpointNameFormatter endpointNameFormatter,
Action <IReceiveEndpointConfigurator> configureEndpoint)
{
return(_host.ConnectReceiveEndpoint(definition, endpointNameFormatter, configureEndpoint));
}
public override IEndpointListener CreateListener(IEndpointDefinition endpointDefinition)
{
return(new CustomEndpointListener(base.CreateListener(endpointDefinition)));
}
public EndpointExecuteActivityDefinition(IEndpointDefinition <IExecuteActivity <TArguments> > endpointDefinition)
{
_endpointDefinition = endpointDefinition;
}
public override HostReceiveEndpointHandle ConnectReceiveEndpoint(IEndpointDefinition definition, IEndpointNameFormatter endpointNameFormatter, Action <IReceiveEndpointConfigurator> configureEndpoint = null)
{
throw new NotImplementedException();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="endPointDefinition">The endpoint definition.</param>
/// <param name="localEndPoint">The locally bound endpoint.</param>
public EndPointEventArgs(IEndpointDefinition endPointDefinition, EndPoint localEndPoint)
{
EndPointDefinition = endPointDefinition;
LocalEndPoint = localEndPoint;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="serviceProvider">The service provider instance.</param>
/// <param name="options">The server options.</param>
/// <param name="endpointDefinition">The endpoint definition.</param>
internal SmtpSessionContext(IServiceProvider serviceProvider, ISmtpServerOptions options, IEndpointDefinition endpointDefinition)
{
ServiceProvider = serviceProvider;
ServerOptions = options;
EndpointDefinition = endpointDefinition;
Transaction = new SmtpMessageTransaction();
Properties = new Dictionary <string, object>();
}
public EndpointActivityDefinition(IEndpointDefinition <ExecuteActivity <TArguments> > endpointDefinition,
IEndpointDefinition <CompensateActivity <TLog> > compensateEndpointDefinition)
: base(endpointDefinition)
{
_compensateEndpointDefinition = compensateEndpointDefinition;
}
public ServiceControlEndpointDefinition(IEndpointDefinition definition)
{
_definition = definition;
}
public HostReceiveEndpointHandle ConnectReceiveEndpoint(IEndpointDefinition definition, IEndpointNameFormatter endpointNameFormatter, Action <IInMemoryReceiveEndpointConfigurator> configureEndpoint = null)
{
var queueName = definition.GetEndpointName(endpointNameFormatter ?? DefaultEndpointNameFormatter.Instance);
return(ConnectReceiveEndpoint(queueName, x => x.Apply(definition, configureEndpoint)));
}
public EndpointSagaDefinition(IEndpointDefinition <TSaga> endpointDefinition)
{
_endpointDefinition = endpointDefinition;
}
/// <summary>
/// Declare a ReceiveEndpoint using a unique generated queue name. This queue defaults to auto-delete
/// and non-durable. By default all services bus instances include a default receiveEndpoint that is
/// of this type (created automatically upon the first receiver binding).
/// </summary>
/// <param name="configurator"></param>
/// <param name="host"></param>
/// <param name="definition"></param>
/// <param name="configure"></param>
public static void ReceiveEndpoint(this IRabbitMqBusFactoryConfigurator configurator, IRabbitMqHost host, IEndpointDefinition definition,
Action <IRabbitMqReceiveEndpointConfigurator> configure = null)
{
configurator.ReceiveEndpoint(host, definition, DefaultEndpointNameFormatter.Instance, configure);
}
HostReceiveEndpointHandle IReceiveConnector <IServiceBusReceiveEndpointConfigurator> .ConnectReceiveEndpoint(IEndpointDefinition definition,
IEndpointNameFormatter endpointNameFormatter, Action <IServiceBusReceiveEndpointConfigurator> configureEndpoint)
{
if (_host == null)
{
throw new InvalidOperationException("The host is not ready.");
}
return(_host.ConnectReceiveEndpoint(definition, endpointNameFormatter, configureEndpoint));
}
public HostReceiveEndpointHandle ConnectReceiveEndpoint(IEndpointDefinition definition, IEndpointNameFormatter endpointNameFormatter,
Action <IBusRegistrationContext, IReceiveEndpointConfigurator> configure = null)
{
return(_instance.ConnectReceiveEndpoint(definition, endpointNameFormatter, configure));
}
/// <summary>
/// Declare a ReceiveEndpoint using a unique generated queue name. This queue defaults to auto-delete
/// and non-durable. By default all services bus instances include a default receiveEndpoint that is
/// of this type (created automatically upon the first receiver binding).
/// </summary>
/// <param name="configurator"></param>
/// <param name="definition"></param>
/// <param name="configure"></param>
public static void ReceiveEndpoint(this IAmazonSqsBusFactoryConfigurator configurator, IEndpointDefinition definition,
Action <IAmazonSqsReceiveEndpointConfigurator> configure = null)
{
configurator.ReceiveEndpoint(definition, DefaultEndpointNameFormatter.Instance, configure);
}
/// <summary>
/// We may want to have a builder/endpoint context that could store things like management endpoint, etc. to configure
/// filters and add configuration interfaces for things like concurrency limit and prefetch count
/// </summary>
/// <param name="configurator"></param>
/// <param name="definition"></param>
/// <param name="configure">The callback to invoke after the definition configuration has been applied</param>
internal static void Apply(this IInMemoryReceiveEndpointConfigurator configurator, IEndpointDefinition definition,
Action <IInMemoryReceiveEndpointConfigurator> configure = null)
{
if (definition.ConcurrentMessageLimit.HasValue)
{
configurator.ConcurrencyLimit = definition.ConcurrentMessageLimit.Value;
}
definition.Configure(configurator);
configure?.Invoke(configurator);
}
void IReceiveConfigurator.ReceiveEndpoint(IEndpointDefinition definition, IEndpointNameFormatter endpointNameFormatter,
Action <IReceiveEndpointConfigurator> configureEndpoint)
{
ReceiveEndpoint(definition, endpointNameFormatter, x => configureEndpoint(x));
}
/// <summary>
/// We may want to have a builder/endpoint context that could store things like management endpoint, etc. to configure
/// filters and add configuration interfaces for things like concurrency limit and prefetch count
/// </summary>
/// <param name="configurator"></param>
/// <param name="definition"></param>
/// <param name="configure">The callback to invoke after the definition configuration has been applied</param>
internal static void Apply(this IActiveMqReceiveEndpointConfigurator configurator, IEndpointDefinition definition,
Action <IActiveMqReceiveEndpointConfigurator> configure = null)
{
if (definition.IsTemporary)
{
configurator.AutoDelete = true;
configurator.Durable = false;
}
if (definition.ConcurrentMessageLimit.HasValue)
{
configurator.UseConcurrencyLimit(definition.ConcurrentMessageLimit.Value);
}
definition.Configure(configurator);
configure?.Invoke(configurator);
}
public void ReceiveEndpoint(IEndpointDefinition definition, IEndpointNameFormatter endpointNameFormatter,
Action <IReceiveEndpointConfigurator> configureEndpoint = null)
{
_hostConfiguration.ReceiveEndpoint(definition, endpointNameFormatter, configureEndpoint);
}
public InstanceEndpointDefinition(IEndpointDefinition definition, IServiceInstance instance)
{
_definition = definition;
_instance = instance;
}
public override HostReceiveEndpointHandle ConnectReceiveEndpoint(IEndpointDefinition definition, IEndpointNameFormatter endpointNameFormatter,
Action <IReceiveEndpointConfigurator> configureEndpoint = null)
{
return(ConnectReceiveEndpoint(definition, endpointNameFormatter, configureEndpoint));
}
public EndpointConsumerDefinition(IEndpointDefinition <TConsumer> endpointDefinition)
{
_endpointDefinition = endpointDefinition;
}
/// <summary>
/// We may want to have a builder/endpoint context that could store things like management endpoint, etc. to configure
/// filters and add configuration interfaces for things like concurrency limit and prefetch count
/// </summary>
/// <param name="configurator"></param>
/// <param name="definition"></param>
/// <param name="configure">The callback to invoke after the definition configuration has been applied</param>
internal static void Apply(this IServiceBusReceiveEndpointConfigurator configurator, IEndpointDefinition definition,
Action <IServiceBusReceiveEndpointConfigurator> configure = null)
{
if (definition.IsTemporary)
{
configurator.AutoDeleteOnIdle = Defaults.TemporaryAutoDeleteOnIdle;
configurator.RemoveSubscriptions = true;
}
if (definition.PrefetchCount.HasValue)
{
configurator.PrefetchCount = (ushort)definition.PrefetchCount.Value;
}
if (definition.ConcurrentMessageLimit.HasValue)
{
var concurrentMessageLimit = definition.ConcurrentMessageLimit.Value;
// if there is a prefetchCount, and it's greater than the concurrent message limit, we need a filter
if (!definition.PrefetchCount.HasValue || definition.PrefetchCount.Value > concurrentMessageLimit)
{
configurator.MaxConcurrentCalls = concurrentMessageLimit;
// we should determine a good value to use based upon the concurrent message limit
if (definition.PrefetchCount.HasValue == false)
{
var calculatedPrefetchCount = concurrentMessageLimit * 12 / 10;
configurator.PrefetchCount = (ushort)calculatedPrefetchCount;
}
}
}
definition.Configure(configurator);
configure?.Invoke(configurator);
}
/// <summary>
/// Listen for SMTP traffic on the given endpoint.
/// </summary>
/// <param name="endpointDefinition">The definition of the endpoint to listen on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A task which performs the operation.</returns>
async Task ListenAsync(IEndpointDefinition endpointDefinition, CancellationToken cancellationToken)
{
// keep track of the running tasks for disposal
var sessions = new ConcurrentDictionary <SmtpSession, SmtpSession>();
using (var endpointListener = _options.EndpointListenerFactory.CreateListener(endpointDefinition))
{
while (cancellationToken.IsCancellationRequested == false)
{
var sessionContext = new SmtpSessionContext(_options, endpointDefinition);
try
{
// wait for a client connection
var stream = await endpointListener.GetStreamAsync(sessionContext, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
sessionContext.NetworkClient = new NetworkClient(stream, _options.NetworkBufferSize, _options.NetworkBufferReadTimeout);
if (endpointDefinition.IsSecure && _options.ServerCertificate != null)
{
await sessionContext.NetworkClient.UpgradeAsync(_options.ServerCertificate, _options.SupportedSslProtocols, cancellationToken).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
}
// create a new session to handle the connection
var session = new SmtpSession(sessionContext);
sessions.TryAdd(session, session);
OnSessionCreated(new SessionEventArgs(sessionContext));
session.Run(cancellationToken);
#pragma warning disable 4014
session.Task
.ContinueWith(t =>
{
if (sessions.TryRemove(session, out var s))
{
sessionContext.NetworkClient.Dispose();
}
if (t.Exception != null)
{
OnSessionFaulted(new SessionFaultedEventArgs(sessionContext, t.Exception));
}
OnSessionCompleted(new SessionEventArgs(sessionContext));
},
cancellationToken);
#pragma warning restore 4014
}
catch (OperationCanceledException) { }
catch (Exception ex)
{
OnSessionFaulted(new SessionFaultedEventArgs(sessionContext, ex));
}
}
// the server has been cancelled, wait for the tasks to complete
await Task.WhenAll(sessions.Keys.Select(s => s.Task)).ConfigureAwait(false);
}
}
