public IBinaryConnection Create(BinaryConnectionConfig config, IMessageValidator validator)
{
IBinaryConnection connection = null;
if (config is TcpClientConfig)
{
connection = new TcpClientConnection(validator)
{
Logger = _logger
}
}
;
if (config is TcpListenerConfig)
{
connection = new TcpListenerConnection(validator)
{
Logger = _logger
}
}
;
connection?.Initialize(config);
return(connection);
}
public HomeController(IMessageEncryptor encryptor, IMessageRepository repository,
IMessageValidator validator, IMessageMapper mapper)
{
this.encryptor = encryptor;
this.repository = repository;
this.validator = validator;
this.mapper = mapper;
}
public MessageProcessor(IMessageValidator validator, IMessageMapper mapper, IIdDeDuplicator idDeDuplicator,
MessageProcessorOptions options)
{
this.mapper = mapper;
this.idDeDuplicator = idDeDuplicator;
this.options = options;
this.validator = validator;
}
public ItemOutValidator(IMessageValidator <ItemAsset> itemValidator)
{
this.itemValidator = itemValidator ?? throw new ArgumentNullException(nameof(itemValidator));
// Define the validation rules.
this.RuleFor(message => message.Assets)
.Cascade(CascadeMode.StopOnFirstFailure)
.NotNull().WithErrorCode(ErrorCode.ValueIsRequired)
.Must(item => item.Count <= ItemOutValidator.MaxitemItemCount).WithErrorCode(ErrorCode.SetCountIsInvalid)
.SetCollectionValidator((FluentValidation.IValidator <ItemAsset>)itemValidator);
}
/// <summary>
/// Creates a message handler
/// </summary>
/// <param name="channel"> name of a channel from that a message is received and processed</param>
/// <param name="messageValidator">validator checking each message received whether it is out of order based on its sequence number</param>
/// <param name="messageLoader">provides capability to directly get messages stored in Redis server</param>
/// <param name="messageHandler">a handler responsible for processing a message received</param>
/// <param name="log">logger tracing internal activity of this subscriber</param>
public MessageProcessor(
string channel,
IMessageValidator messageValidator,
IMessageLoader messageLoader,
IMessageHandler messageHandler,
ILogger <MessageProcessor> log = default)
{
Channel = channel;
_messageValidator = messageValidator;
_messageLoader = messageLoader;
_messageHandler = messageHandler;
_log = log ?? NullLogger <MessageProcessor> .Instance;
}
/// <summary>
/// The class initialize.
/// </summary>
protected static void ClassInitialize()
{
//EffortProviderConfiguration.RegisterProvider();
var containerBuilder = new DependencyContainerBuilder(new HostUnityContainer());
var container = containerBuilder.BuildUnityContainer();
var dependencyResolver = container.Resolve(typeof(IDependencyResolver), string.Empty) as IDependencyResolver;
//DbInitializer dbInitializer = dependencyResolver.Resolve(typeof(DbInitializer)) as DbInitializer;
//Database.SetInitializer(dbInitializer);
MessageValidator = dependencyResolver.Resolve <IMessageValidator>();
}
/// <summary>
/// Creates a QbManager. The main program which handles all the WebConnector interations.
/// </summary>
/// <param name="authenticator">An authenticator.</param>
/// <param name="messageValidator">A message validator.</param>
/// <param name="webConnectorHandler">A WebConnectorHandler.</param>
/// <param name="stepRequest">A list of step requests.</param>
/// <param name="stepResponse">A list of step responses.</param>
/// <param name="logger">Logger.</param>
public QbManager(
IAuthenticator authenticator,
IMessageValidator messageValidator,
IWebConnectorHandler webConnectorHandler,
IEnumerable <IStepQueryRequest> stepRequest,
IEnumerable <IStepQueryResponse> stepResponse,
ILogger <QbManager> logger
)
{
this.authenticator = authenticator;
this.messageValidator = messageValidator;
this.webConnectorHandler = webConnectorHandler;
this.stepRequest = stepRequest;
this.stepResponse = stepResponse;
this.logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="OrderFulfillmentMessageValidator" /> class.
/// </summary>
///
/// <param name="headerValidator">The validator to use for validaiton of the order header.</param>
/// <param name="itemOutValidator">The validator to use for valdiation of the item items assocaited with the order.</param>
///
public OrderFulfillmentMessageValidator(IMessageValidator <OrderHeader> headerValidator,
IMessageValidator <LineItem> itemOutValidator)
{
// Initialize the class.
this.headerValidator = headerValidator ?? throw new ArgumentNullException(nameof(headerValidator));
this.itemOutValidator = itemOutValidator ?? throw new ArgumentNullException(nameof(itemOutValidator));
// Define the validation rules.
this.RuleFor(message => message.OrderRequestHeader)
.Cascade(CascadeMode.StopOnFirstFailure)
.NotEmpty().WithErrorCode(ErrorCode.ValueIsRequired)
.SetValidator((FluentValidation.IValidator <OrderHeader>) this.headerValidator);
this.RuleFor(message => message.LineItems)
.Cascade(CascadeMode.StopOnFirstFailure)
.NotNull().WithErrorCode(ErrorCode.ValueIsRequired)
.SetCollectionValidator((FluentValidation.IValidator <LineItem>)itemOutValidator);
}
/// <summary>
/// The on action executing.
/// </summary>
/// <param name="actionContext">
/// The action context.
/// </param>
public override void OnActionExecuting(HttpActionContext actionContext)
{
this.MessageValidator = (IMessageValidator)actionContext.Request.GetDependencyScope().GetService(typeof(IMessageValidator));
this.Logger = (ILogger)actionContext.Request.GetDependencyScope().GetService(typeof(ILogger));
this.DependencyResolver =
(IDependencyResolver)actionContext.Request.GetDependencyScope().GetService(typeof(IDependencyResolver));
this.Logger.Debug(() => "ValidateFilterAttribute.OnActionExecuting");
var validationInstance = actionContext.ActionArguments.Values.FirstOrDefault();
if (validationInstance == null)
{
var errors = new List <ExceptionMessage>();
errors.Add(new ExceptionMessage(BaseErrorCodes.CommandValidation, "Command should not be null."));
throw this.DependencyResolver.Resolve <ValidationException>()
.GetException(errors, isTopAsRoot: true);
}
var validationNotification = this.MessageValidator.Validate(validationInstance);
if (!actionContext.ModelState.IsValid || !validationNotification.IsValid)
{
throw this.DependencyResolver.Resolve <ValidationException>()
.GetException(
this.BuildNestedMessages(validationNotification.Errors),
"Validation failed",
BaseErrorCodes.CommandValidation);
//ObjectContent<List<ValidationResult>> content = new ObjectContent<List<ValidationResult>>(validationNotification.Errors, new JsonMediaTypeFormatter());
//var resp = new HttpResponseMessage(HttpStatusCode.BadRequest)
//{
// Content = content,
// ReasonPhrase = "Validation failed",
// RequestMessage = actionContext.Request
//};
//actionContext.Response = resp;
}
}
/// <summary>
/// Create a new instance of the
/// </summary>
/// <param name="validator"></param>
public TcpClientConnection(IMessageValidator validator)
{
_validator = validator;
}
public SendingControl()
{
_validator = new MessageValidator();
}
/// <summary>
/// Добавляет еще одного обработчика сообщений.
/// </summary>
/// <param name="label">
/// Метка сообщения, которое может быть обработано.
/// </param>
/// <param name="consumer">
/// Обработчик сообщения.
/// </param>
/// <param name="validator">
/// Механизм проверки входящего сообщения.
/// </param>
/// <typeparam name="T">
/// Тип входящего сообщения.
/// </typeparam>
public void RegisterConsumer <T>(MessageLabel label, IConsumerOf <T> consumer, IMessageValidator validator) where T : class
{
ConsumingAction consumingAction = delivery =>
{
IConsumingContext <T> context = delivery.BuildConsumingContext <T>(label);
if (validator != null)
{
validator.Validate(context.Message).ThrowIfBroken();
}
else
{
this.validatorRegistry.Validate(context.Message);
}
var sw = Stopwatch.StartNew();
consumer.Handle(context);
this.MetricsCollector?.Histogram("contour.rmq.consuming.duration", sw.ElapsedMilliseconds, 1D, new[] { "endpoint:" + this.busContext.Endpoint.Address, "label:" + label.ToString() });
};
this.consumers[label] = consumingAction;
}
/// <summary>
/// The register validator.
/// </summary>
/// <param name="validator">
/// The validator.
/// </param>
public void RegisterValidator(IMessageValidator validator)
{
this.ValidatorRegistry.Register(validator);
}
/// <summary>
/// Create listener connection
/// </summary>
/// <param name="validator">Validator for this listener</param>
public TcpListenerConnection(IMessageValidator validator)
{
Validator = validator;
}
/// <summary>
/// Constructor taking the object to use as interface to an outbound
/// message queue
/// </summary>
/// <param name="queue">The outbound message queue</param>
/// <param name="validator">The object that knows how to validate
/// incoming messages</param>
public OutputQueueFecsAdapter(FecsBecsOutputWrapper queue, IMessageValidator validator)
{
_outQueue = queue;
_validator = validator;
}
/// <summary>
/// Регистрирует механизм проверки входящего сообщения.
/// </summary>
/// <param name="validator">Механизм проверки входящего сообщения.</param>
/// <returns>Конфигуратор получателя с установленным механизмом проверки входящих сообщений.</returns>
public IReceiverConfigurator WhenVerifiedBy(IMessageValidator validator)
{
this.Validator = validator;
return(this);
}
public MimeMessageConverter(IOptions <AppConfig> config, IMessageValidator messageValidator, ILogger <MimeMessageConverter> logger)
{
this.config = config;
this.messageValidator = messageValidator;
this.logger = logger;
}
/// <summary>
/// Добавляет еще одного обработчика сообщений.
/// </summary>
/// <param name="label">
/// Метка сообщения, которое может быть обработано.
/// </param>
/// <param name="consumer">
/// Обработчик сообщения.
/// </param>
/// <param name="validator">
/// Механизм проверки входящего сообщения.
/// </param>
/// <typeparam name="T">
/// Тип входящего сообщения.
/// </typeparam>
public void RegisterConsumer <T>(MessageLabel label, IConsumerOf <T> consumer, IMessageValidator validator) where T : class
{
ConsumingAction consumingAction = delivery =>
{
IConsumingContext <T> context = delivery.BuildConsumingContext <T>(label);
if (validator != null)
{
validator.Validate(context.Message).ThrowIfBroken();
}
else
{
this.validatorRegistry.Validate(context.Message);
}
consumer.Handle(context);
};
this.consumers[label] = consumingAction;
}
/// <summary>
/// Добавляет еще одного обработчика сообщений.
/// </summary>
/// <param name="label">
/// Метка сообщения, которое может быть обработано.
/// </param>
/// <param name="consumer">
/// Обработчик сообщения.
/// </param>
/// <param name="validator">
/// Механизм проверки входящего сообщения.
/// </param>
/// <typeparam name="T">
/// Тип входящего сообщения.
/// </typeparam>
public void RegisterConsumer <T>(MessageLabel label, IConsumerOf <T> consumer, IMessageValidator validator) where T : class
{
ConsumingAction consumingAction = delivery =>
{
IConsumingContext <T> context = delivery.BuildConsumingContext <T>(label);
if (validator != null)
{
validator.Validate(context.Message).ThrowIfBroken();
}
else
{
this.validatorRegistry.Validate(context.Message);
}
this.logger.Trace(
m => m($"{typeof(T)}: получил сообщение " +
$"[{JsonConvert.SerializeObject(context.Message.Payload)}] на обработку"));
consumer.Handle(context);
};
this.consumers[label] = consumingAction;
}
public MessageStore(IMessageValidator messageValidator, ApplicationDatabase applicationDatabase)
{
_messageValidator = messageValidator;
_applicationDatabase = applicationDatabase;
}
/// <summary>
/// Create connection instance
/// </summary>
public SerialBinaryConnection(IMessageValidator validator)
{
_validator = validator;
}
/// <summary>
/// Creates and starts a listener on the server. There has to be one listener for each clients that shall connect.
/// </summary>
/// <param name="ipAdress">The ip adress.</param>
/// <param name="port">The port.</param>
/// <param name="id">The identifier. This identifier has to be matched be the client that connects to this listener. The listener will be determined, when the first message is received</param>
/// <param name="messageValidator">The message validator to be used</param>
protected ConnectionBuffer <TMessage> CreateAndStartServer(IPAddress ipAdress, int port, int id, IMessageValidator messageValidator)
{
var server = new ConnectionBuffer <TMessage>
{
Id = id,
Connection = _binaryConnectionFactory.Create(CreateServerConfig(ipAdress, port), messageValidator)
};
server.Connection.Received += (sender, message) => server.Received.Add((TMessage)message);
server.Connection.NotifyConnectionState += (sender, message) => server.LastStateChangeEvents.Add(message);
// Server should be disconnected
Assert.AreEqual(server.Connection.CurrentState, BinaryConnectionState.Disconnected,
$"server is not in the state '{BinaryConnectionState.Disconnected:G}'. CurrentState: {server.Connection.CurrentState:G}");
server.Connection.Start();
// Server should be listening
Assert.AreEqual(BinaryConnectionState.AttemptingConnection, server.Connection.CurrentState,
$"server is not in the state '{BinaryConnectionState.AttemptingConnection:G}'. CurrentState: {server.Connection.CurrentState:G}");
_serverConnections.Add(server);
return(server);
}
/// <summary>
/// Конфигурирует клиента шины сообщений.
/// </summary>
/// <param name="endpointName">
/// Имя точки подключения к шине.
/// </param>
/// <param name="cfg">
/// Конфигуратор клиента шины.
/// </param>
/// <returns>
/// Конфигуратор клиента шины, после применения к нему всех настроек.
/// </returns>
public IBusConfigurator Configure(string endpointName, IBusConfigurator cfg)
{
if (cfg == null)
{
throw new ArgumentNullException("cfg", "Файл конфигурации не может быть null");
}
var endpointConfig = this.GetEndPointByName(endpointName);
IConnectionStringProvider connectionStringProvider = null;
if (!string.IsNullOrEmpty(endpointConfig.ConnectionStringProvider))
{
connectionStringProvider = this.GetConnectionStringProvider(endpointConfig.ConnectionStringProvider);
}
cfg.SetEndpoint(endpointConfig.Name);
cfg.SetConnectionString(endpointConfig.ConnectionString);
cfg.SetExcludedIncomingHeaders(endpointConfig.ExcludedHeaders);
if (endpointConfig.ReuseConnection.HasValue)
{
cfg.ReuseConnection(endpointConfig.ReuseConnection.Value);
}
if (!string.IsNullOrWhiteSpace(endpointConfig.LifecycleHandler))
{
cfg.HandleLifecycleWith(this.ResolveLifecycleHandler(endpointConfig.LifecycleHandler));
}
if (endpointConfig.ParallelismLevel.HasValue)
{
cfg.UseParallelismLevel(endpointConfig.ParallelismLevel.Value);
}
if (endpointConfig.FaultQueueTtl.HasValue)
{
cfg.UseFaultQueueTtl(endpointConfig.FaultQueueTtl.Value);
}
if (endpointConfig.FaultQueueLimit.HasValue)
{
cfg.UseFaultQueueLimit(endpointConfig.FaultQueueLimit.Value);
}
if (endpointConfig.Dynamic != null)
{
if (endpointConfig.Dynamic.Outgoing.HasValue)
{
if (endpointConfig.Dynamic.Outgoing.Value)
{
cfg.Route(MessageLabel.Any)
.ConfiguredWith(
builder => new LambdaRouteResolver(
(endpoint, label) =>
{
builder.Topology.Declare(Exchange.Named(label.Name).Durable.Fanout);
return(new RabbitRoute(label.Name));
}));
}
}
}
if (endpointConfig.Qos != null)
{
if (endpointConfig.Qos.PrefetchCount.HasValue)
{
cfg.SetDefaultQoS(endpointConfig.Qos.PrefetchCount.Value);
}
}
foreach (ValidatorElement validator in endpointConfig.Validators)
{
if (validator.Group)
{
MessageValidatorGroup v = this.ResolveValidatorGroup(validator.Name);
cfg.RegisterValidators(v);
}
else
{
IMessageValidator v = this.ResolveValidator(validator.Name);
cfg.RegisterValidator(v);
}
}
foreach (OutgoingElement outgoingElement in endpointConfig.Outgoing)
{
var configurator = cfg.Route(outgoingElement.Label).WithAlias(outgoingElement.Key);
if (outgoingElement.Confirm)
{
configurator.WithConfirmation();
}
if (outgoingElement.Persist)
{
configurator.Persistently();
}
if (outgoingElement.Ttl.HasValue)
{
configurator.WithTtl(outgoingElement.Ttl.Value);
}
if (outgoingElement.CallbackEndpoint.Default)
{
configurator.WithDefaultCallbackEndpoint();
}
if (outgoingElement.Timeout.HasValue)
{
configurator.WithRequestTimeout(outgoingElement.Timeout);
}
if (outgoingElement.Delayed || outgoingElement.Delay.HasValue || endpointConfig.Delayed)
{
configurator.WithDelay(outgoingElement.Delay ?? TimeSpan.Zero);
}
// Connection string
var connectionString = endpointConfig.ConnectionString;
if (!string.IsNullOrEmpty(outgoingElement.ConnectionString))
{
connectionString = outgoingElement.ConnectionString;
}
connectionString = connectionStringProvider?.GetConnectionString(outgoingElement.Label.ToMessageLabel()) ?? connectionString;
configurator.WithConnectionString(connectionString);
// Reuse connection
if (outgoingElement.ReuseConnection.HasValue)
{
configurator.ReuseConnection(outgoingElement.ReuseConnection.Value);
}
}
foreach (IncomingElement incomingElement in endpointConfig.Incoming)
{
var configurator = cfg.On(incomingElement.Label).WithAlias(incomingElement.Key);
uint size = 0;
ushort count = 50;
// This should be the default values provided by RabbitMQ configurator (BusConsumerConfigurationEx);
var qos = configurator.GetQoS();
if (qos.HasValue)
{
size = qos.Value.PrefetchSize;
count = qos.Value.PrefetchCount;
}
// Prefetch size
if (endpointConfig.Qos.PrefetchSize.HasValue)
{
size = endpointConfig.Qos.PrefetchSize.Value;
}
if (incomingElement.Qos.PrefetchSize.HasValue)
{
size = incomingElement.Qos.PrefetchSize.Value;
}
// Prefetch count
if (endpointConfig.Qos.PrefetchCount.HasValue)
{
count = endpointConfig.Qos.PrefetchCount.Value;
}
if (incomingElement.Qos.PrefetchCount.HasValue)
{
count = incomingElement.Qos.PrefetchCount.Value;
}
configurator.WithQoS(new QoSParams(count, size));
// Parallelism level
if (endpointConfig.ParallelismLevel.HasValue)
{
configurator.WithParallelismLevel(endpointConfig.ParallelismLevel.Value);
}
if (incomingElement.ParallelismLevel.HasValue)
{
configurator.WithParallelismLevel(incomingElement.ParallelismLevel.Value);
}
// Accept
if (incomingElement.RequiresAccept)
{
configurator.RequiresAccept();
}
if (incomingElement.Delayed)
{
configurator.Delayed();
}
// Connection string
var connectionString = endpointConfig.ConnectionString;
if (!string.IsNullOrEmpty(incomingElement.ConnectionString))
{
connectionString = incomingElement.ConnectionString;
}
connectionString = connectionStringProvider?.GetConnectionString(incomingElement.Label.ToMessageLabel()) ?? connectionString;
configurator.WithConnectionString(connectionString);
// Reuse connection
if (incomingElement.ReuseConnection.HasValue)
{
configurator.ReuseConnection(incomingElement.ReuseConnection.Value);
}
Type messageType = typeof(ExpandoObject);
if (!string.IsNullOrWhiteSpace(incomingElement.Type))
{
messageType = ResolveType(incomingElement.Type);
}
var consumerFactory = this.BuildConsumerFactory(incomingElement, messageType, endpointName);
object consumer = BuildConsumer(consumerFactory, messageType, incomingElement.Lifestyle);
RegisterConsumer(configurator, messageType, consumer);
if (!string.IsNullOrWhiteSpace(incomingElement.Validate))
{
IMessageValidator validator = this.ResolveValidator(incomingElement.Validate, messageType);
configurator.WhenVerifiedBy(validator);
}
}
var collectorType = endpointConfig.Metrics?.Collector;
if (!string.IsNullOrEmpty(collectorType))
{
try
{
var metricsCollector = (IMetricsCollector)this.dependencyResolver.Resolve(collectorType, typeof(IMetricsCollector));
cfg.CollectMetrics(metricsCollector);
}
catch (Exception e)
{
Log.Warn(m => m("Could not load metric collector '{0}'", collectorType), e);
}
}
else
{
Log.Trace(m => m("Metric collector is not specified"));
}
foreach (var configurator in this.childConfigurators)
{
configurator.Configure(endpointName, cfg);
}
return(cfg);
}
/// <summary>
/// Creates and starts a client.
/// </summary>
/// <param name="ipAdress">The ip adress.</param>
/// <param name="port">The port.</param>
/// <param name="connectRetryWaitMs">The connect retry wait ms.</param>
/// <param name="id">The identifier. This identifier has to be matched be the listener this client will connect to. The listener will be determined, when the first msg is send.</param>
/// <returns></returns>
protected int CreateAndStartClient(IPAddress ipAdress, int port, int connectRetryWaitMs, int id, IMessageValidator messageValidator)
{
var client = new ConnectionBuffer <TMessage>
{
Id = id,
Connection = _binaryConnectionFactory.Create(CreateClientConfig(ipAdress, port, connectRetryWaitMs), messageValidator)
};
client.Connection.Received +=
(sender, message) => client.Received.Add((TMessage)message);
client.Connection.NotifyConnectionState += (sender, message) => client.LastStateChangeEvents.Add(message);
var clientIdx = _clients.Count;
_clients.Add(client);
_overallClients.Add(client);
Console.WriteLine("CreateAndStartClient Added Client idx: {0}.", clientIdx);
// Client should be disconnected
Assert.AreEqual(_clients[clientIdx].Connection.CurrentState, BinaryConnectionState.Disconnected,
$"Client is not in the state '{BinaryConnectionState.Disconnected:G}'. CurrentState: {_clients[clientIdx].Connection.CurrentState:G}");
_clients[clientIdx].Connection.Start();
// In some tests the client shall be connected at this point and in some tests it shall not be connected,
// so check the connection-state somewhere else...
return(clientIdx);
}
public MessagesService(IOperationResult operationResult, IMessageValidator messageValidator, IMessagesBusinessLogic messagesBussinessLogic) : base(operationResult)
{
_messageValidator = messageValidator;
_messagesBussinessLogic = messagesBussinessLogic;
}
/// <summary>
/// The register.
/// </summary>
/// <param name="validator">
/// The validator.
/// </param>
public void Register(IMessageValidator validator)
{
IList <Type> supportedTypes = Reflection.GetGenericTypeParameterOf(typeof(IMessageValidatorOf <>), validator);
supportedTypes.ForEach(t => this._validators[t] = validator);
}
/// <summary>
/// Конфигурирует клиента шины сообщений.
/// </summary>
/// <param name="endpointName">
/// Имя точки подключения к шине.
/// </param>
/// <param name="cfg">
/// Конфигуратор клиента шины.
/// </param>
/// <returns>
/// Конфигуратор клиента шины, после применения к нему всех настроек.
/// </returns>
public IBusConfigurator Configure(string endpointName, IBusConfigurator cfg)
{
if (cfg == null)
{
throw new ArgumentNullException("cfg", "Файл конфигурации не может быть null");
}
EndpointElement endpointConfig = this.GetEndPointByName(endpointName);
cfg.SetEndpoint(endpointConfig.Name);
cfg.SetConnectionString(endpointConfig.ConnectionString);
if (!string.IsNullOrWhiteSpace(endpointConfig.LifecycleHandler))
{
cfg.HandleLifecycleWith(this.ResolveLifecycleHandler(endpointConfig.LifecycleHandler));
}
if (endpointConfig.Caching != null && endpointConfig.Caching.Enabled)
{
cfg.EnableCaching();
}
if (endpointConfig.ParallelismLevel.HasValue)
{
cfg.UseParallelismLevel(endpointConfig.ParallelismLevel.Value);
}
if (endpointConfig.Dynamic != null)
{
if (endpointConfig.Dynamic.Outgoing.HasValue)
{
if (endpointConfig.Dynamic.Outgoing.Value)
{
cfg.Route(MessageLabel.Any)
.ConfiguredWith(builder => new LambdaRouteResolver(
(endpoint, label) =>
{
builder.Topology.Declare(
Exchange.Named(label.Name)
.Durable.Fanout);
return(new RabbitRoute(label.Name));
}));
}
}
}
if (endpointConfig.Qos != null)
{
if (endpointConfig.Qos.PrefetchCount.HasValue)
{
cfg.SetDefaultQoS(endpointConfig.Qos.PrefetchCount.Value);
}
}
foreach (ValidatorElement validator in endpointConfig.Validators)
{
if (validator.Group)
{
MessageValidatorGroup v = this.ResolveValidatorGroup(validator.Name);
cfg.RegisterValidators(v);
}
else
{
IMessageValidator v = this.ResolveValidator(validator.Name);
cfg.RegisterValidator(v);
}
}
foreach (OutgoingElement message in endpointConfig.Outgoing)
{
ISenderConfigurator senderCfg = cfg.Route(message.Label).
WithAlias(message.Key);
if (message.Confirm)
{
senderCfg.WithConfirmation();
}
if (message.Persist)
{
senderCfg.Persistently();
}
if (message.Ttl.HasValue)
{
senderCfg.WithTtl(message.Ttl.Value);
}
if (message.CallbackEndpoint.Default)
{
senderCfg.WithDefaultCallbackEndpoint();
}
if (message.Timeout.HasValue)
{
senderCfg.WithRequestTimeout(message.Timeout);
}
}
foreach (IncomingElement message in endpointConfig.Incoming)
{
IReceiverConfigurator receiver = cfg.On(message.Label).
WithAlias(message.Key);
if (message.RequiresAccept)
{
receiver.RequiresAccept();
}
Type messageType = typeof(ExpandoObject);
if (!string.IsNullOrWhiteSpace(message.Type))
{
messageType = ResolveType(message.Type);
}
var consumerFactory = this.BuildConsumerFactory(message.React, messageType);
object consumer = BuildConsumer(consumerFactory, messageType, message.Lifestyle);
RegisterConsumer(receiver, messageType, consumer);
if (!string.IsNullOrWhiteSpace(message.Validate))
{
IMessageValidator validator = this.ResolveValidator(message.Validate, messageType);
receiver.WhenVerifiedBy(validator);
}
}
return(cfg);
}
/// <summary>
/// Регистрирует механизм проверки входящего сообщения.
/// </summary>
/// <param name="validator">Механизм проверки входящего сообщения.</param>
/// <returns>Конфигуратор получателя с установленным механизмом проверки входящих сообщений.</returns>
public IReceiverConfigurator WhenVerifiedBy(IMessageValidator validator)
{
this.configuration.WhenVerifiedBy(validator);
return(this);
}
