public override void Initialize(Dictionary <string, object> settings)
{
string pluginNamespace = GetContainerNamespace();
Debug.Assert(pluginNamespace != null);
TypeContainer tc = TypeContainer.Instance;
//"IotHubConfigFile", "MessageExchange", "ExchangeToIotHubMessageConverter", "Logger"
//configure receiver
IProcessor messageReceiver = tc.GetInstance <IReceiver>(pluginNamespace) as IProcessor;
IConverter <object, Msg> receivedMessageConverter = tc.GetInstance <IConverter <object, Msg> >(pluginNamespace);
settings["MessageConverter.OpcUa"] = receivedMessageConverter;
if (messageReceiver != null)
{
this.AddReceiver("MessageReceiver", messageReceiver);
}
//configure sender
IProcessor messageSender = tc.GetInstance <ISender>(pluginNamespace) as IProcessor;
IConverter <object, Msg> messageConverter = tc.GetInstance <IConverter <object, Msg> >(pluginNamespace);
IMessageExchange <Msg> messageExchange = tc.GetInstance <IMessageExchange <Msg> >(pluginNamespace);
settings["MessageExchange.Messaging"] = messageExchange;
settings["MessageConverter.IotHub"] = messageConverter;
settings["Logger"] = tc.GetInstance <ILogger>();
if (messageSender != null)
{
this.AddSender("MessageSender", messageSender);
}
base.Initialize(settings);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="exchange">Details on how the exchange should be declared and information
/// for the queues that should be created.</param>
/// <param name="messageType"> The message type associated with the exchange.</param>
public MessageExchangeDefinition(IMessageExchange exchange, Type messageType = null)
{
Check.NotNull(exchange, nameof(exchange));
MessageType = messageType;
Exchange = exchange;
}
/// <summary>
/// Makes sure the exchange has been initialized. This method
/// should be invoked before asserting the exchange in a test.
/// </summary>
/// <param name="value"></param>
public static void Setup(this IMessageExchange value)
{
var mockConn = new Mock <IModel>();
value.InitializeSettings(new BrokerSettings());
value.Declare(mockConn.Object);
}
/// <summary>
/// Возвращает точку обмена сообщениями.
/// </summary>
public IMessageExchange GetExchange()
{
if (_messageExchange == null)
{
var exchangeName = GetName();
_messageExchange = MessageBus.GetExchange(exchangeName);
}
return(_messageExchange);
}
/// <summary>
/// Applies all externally defined queue properties to all defined exchange queues.
/// </summary>
/// <param name="exchange">Exchange configuration.</param>
public void ApplyQueueSettings(IMessageExchange exchange)
{
Check.NotNull(exchange, nameof(exchange));
foreach (QueuePropertiesSettings queueProps in GetBrokerQueueProperties(exchange.BrokerName))
{
ExchangeQueue queue = exchange.Queues.FirstOrDefault(q => q.QueueName == queueProps.QueueName);
if (queue != null)
{
queue.RouteKeys = queueProps.RouteKeys.ToArray();
}
}
}
public void Initialize(Dictionary <string, object> settings)
{
string[] fieldNames = new string[] { "IotHubConfigFile", "MessageConverter.OpcUa", "MessageExchange.Messaging", "MessageConverter.IotHub", "Logger" };
FieldValidator.CheckMissingFields(settings, fieldNames);
string iotHubConfigFile = settings.GetValueOrNull("IotHubConfigFile") as string;
_iotHubConfig = ConfigUtility.ReadConfig <IotHubConfig>(iotHubConfigFile);
_toIotHubDataConverter = settings.GetValueOrNull("MessageConverter.IotHub") as IConverter <TExchangeMsg, object>;
_alarmMessageExchange = settings.GetValueOrNull("MessageExchange.Messaging") as IMessageExchange <TExchangeMsg>;
_logger = settings.GetValueOrNull("Logger") as ILogger;
_deviceClienPool = new DeviceClientPool();
_deviceClienPool.Initialize(_iotHubConfig.IotHubHostName, _iotHubConfig.AlarmDevicePool);
}
IMessageExchange GetOrAddExchange(NodeContext context, string name, ExchangeType exchangeType)
{
IMessageExchange created = null;
var exchange = _exchanges.GetOrAdd(name, x =>
{
created = exchangeType switch
{
ExchangeType.FanOut => new MessageFanOutExchange(name),
ExchangeType.Direct => new MessageDirectExchange(name),
ExchangeType.Topic => new MessageTopicExchange(name),
_ => throw new ArgumentException($"Unsupported exchange type: {exchangeType}", nameof(exchangeType))
};
return(created);
});
private async Task PublishAsync(MessageExchangeDefinition exchangeDef, IMessage message)
{
if (!await SatisfiesExchangeCriteria(exchangeDef, message))
{
return;
}
IMessageExchange exchange = exchangeDef.Exchange;
string[] orderedContentTypes =
{
message.GetContentType(),
exchange.Settings.ContentType
};
byte[] messageBody = _serializationMgr.Serialize(message, orderedContentTypes);
LogPublishingExchangeMessage(message, exchangeDef);
using (var channel = _connMgr.CreateChannel(exchange.BrokerName))
{
exchangeDef.Exchange.Publish(channel, message, messageBody);
}
}
protected GrpcMoveTransport(IMessageExchange exchange)
{
_exchange = exchange;
}
public ExchangeGrpcSendTransportContext(IHostConfiguration hostConfiguration, IMessageExchange exchange)
: base(hostConfiguration)
{
Exchange = exchange;
}
public GrpcErrorTransport(IMessageExchange exchange)
: base(exchange)
{
}
public GrpcDeadLetterTransport(IMessageExchange exchange)
: base(exchange)
{
}
