/// <summary>
/// Метод отправки сообщения.
/// </summary>
/// <param name="paramObject">Объект, содержащий параметры отправки сообщений.</param>
/// <returns>Успешно ли было отправлено сообщение.</returns>
private bool SendMessage(object paramObject)
{
var param = (SendingTaskParam)paramObject;
IMessageSender messageSender = MessageSenderCreator.GetMessageSender(param.Subscription);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
var send = messageSender.SendMessage(param.Message);
stopwatch.Stop();
long time = stopwatch.ElapsedMilliseconds;
_statisticsService.NotifyAvgTimeSent(param.Subscription, (int)time);
if (!send)
{
_statisticsService.NotifyErrorOccurred(param.Subscription);
return(false);
}
_logger.LogOutgoingMessage(param.Message);
_statisticsService.NotifyMessageSent(param.Subscription);
return(true);
}
public async Task Should_throw_exception_for_a_message_that_exceeds_maximum_size()
{
// default settings
var settings = DefaultConfigurationValues.Apply(SettingsHolderFactory.BuildWithSerializer());
settings.Set(new TopologySettings());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("namespace", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceLifecycleManager = new NamespaceManagerLifeCycleManagerInternal(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceLifecycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new OutgoingBatchRouter(new BatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, new ThrowOnOversizedBrokeredMessages());
// create the queue
var creator = new AzureServiceBusQueueCreator(settings.Get <TopologySettings>().QueueSettings, settings);
var namespaceManager = namespaceLifecycleManager.Get("namespace");
await creator.Create("myqueue", namespaceManager);
// setup the batch
var @namespace = new RuntimeNamespaceInfo("namespace", AzureServiceBusConnectionString.Value);
var bytes = Enumerable.Range(0, settings.Get <int>(WellKnownConfigurationKeys.Connectivity.MessageSenders.MaximumMessageSizeInKilobytes) * 1024).Select(x => (byte)(x % 256)).ToArray();
var batch = new BatchInternal
{
Destinations = new TopologySectionInternal
{
Entities = new List <EntityInfoInternal>
{
new EntityInfoInternal
{
Namespace = @namespace,
Path = "MyQueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperationInternal>
{
new BatchedOperationInternal
{
Message = new OutgoingMessage("Id-1", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
}
}
};
// perform the test
Assert.That(async() => await router.RouteBatch(batch, null, DispatchConsistency.Default), Throws.Exception.TypeOf <MessageTooLargeException>());
}
public RmqSendingManager(ILogger logger, ISubscriptionsManager esbSubscriptionsManager, IConnectionFactory connectionFactory, IManagementClient managementClient, IMessageConverter converter, AmqpNamingManager namingManager, string vhost = "/", bool useLegacySenders = true)
{
this._logger = logger;
this._esbSubscriptionsManager = esbSubscriptionsManager;
this._connectionFactory = connectionFactory;
this._managementClient = managementClient;
this._converter = converter;
this._namingManager = namingManager;
this.MessageSenderCreator = new MessageSenderCreator(_logger, useLegacySenders);
this._vhostName = vhost;
this.useLegacySenders = useLegacySenders;
this._consumers = new List <RmqConsumer>();
}
/// <summary>
/// Метод для выполнения отправки сообщения в отдельном потоке. Свойство <see cref="Сообщение.Отправляется"/> должно быть
/// установлено в <c>true</c> заранее.
/// </summary>
/// <param name="state">Параметры для задачи отправки сообщения.</param>
/// <returns>Была ли выполнена отправка сообщения.</returns>
private static bool SendMessageWithFailHandling(object state, IStatisticsService statisticsService, IDataService dataService, ILogger logger)
{
var parameters = (SendingTaskParams)state;
Message message = null;
Stopwatch stopwatch = null;
long time;
Action loadMessageDelegate = () =>
{
message = new Message();
message.SetExistObjectPrimaryKey(parameters.MessagePk);
stopwatch = new Stopwatch();
stopwatch.Start();
dataService.LoadObject(Message.Views.MessageEditView, message);
stopwatch.Stop();
time = stopwatch.ElapsedMilliseconds;
statisticsService.NotifyAvgTimeSql(null, (int)time, "SubscriptionThread.SendMessageWithFailHandling() load Messages.");
};
if (!ServiceHelper.TryWithExceptionLogging(loadMessageDelegate, null, "Ошибка при отправке сообщения по callback", parameters.Subscription.Client, null, logger))
{
return(false);
}
IMessageSender messageSender = new MessageSenderCreator(logger, true).GetMessageSender(parameters.Subscription);
statisticsService.NotifyIncConnectionCount(parameters.Subscription);
stopwatch = new Stopwatch();
stopwatch.Start();
var send = messageSender.SendMessage(message);
stopwatch.Stop();
time = stopwatch.ElapsedMilliseconds;
statisticsService.NotifyAvgTimeSent(parameters.Subscription, (int)time);
statisticsService.NotifyDecConnectionCount(parameters.Subscription);
if (!send)
{
statisticsService.NotifyErrorOccurred(parameters.Subscription);
return(false);
}
logger.LogOutgoingMessage(message);
statisticsService.NotifyMessageSent(parameters.Subscription);
return(true);
}
public async Task Should_throw_exception_for_a_message_that_exceeds_maximum_size_and_not_handle_fallback_on_message_too_large_Exception()
{
// default settings
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("primary", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
namespacesDefinition.Add("fallback", AzureServiceBusConnectionString.Fallback, NamespacePurpose.Partitioning);
var oversizedHandler = new MyThrowingOversizedBrokeredMessageHandler();
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceManagerLifeCycleManager = new NamespaceManagerLifeCycleManager(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceManagerLifeCycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new DefaultOutgoingBatchRouter(new DefaultBatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, oversizedHandler);
// create the queue
var creator = new AzureServiceBusQueueCreator(settings);
var namespaceManager = namespaceManagerLifeCycleManager.Get("primary");
await creator.Create("myqueue", namespaceManager);
// setup the batch
var @namespace = new RuntimeNamespaceInfo("primary", AzureServiceBusConnectionString.Value);
var fallback = new RuntimeNamespaceInfo("fallback", AzureServiceBusConnectionString.Value, mode: NamespaceMode.Passive);
var bytes = Enumerable.Range(0, settings.Get <int>(WellKnownConfigurationKeys.Connectivity.MessageSenders.MaximumMessageSizeInKilobytes) * 1024).Select(x => (byte)(x % 256)).ToArray();
var batch = new Batch
{
Destinations = new TopologySection
{
Entities = new List <EntityInfo>
{
new EntityInfo
{
Namespace = @namespace,
Path = "MyQueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace,
fallback
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperation>
{
new BatchedOperation
{
Message = new OutgoingMessage("Id-1", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
}
}
};
// perform the test
Assert.That(async() => await router.RouteBatch(batch, null, DispatchConsistency.Default), Throws.Exception.TypeOf <MessageTooLargeException>());
Assert.True(oversizedHandler.InvocationCount == 1);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
public async Task Can_route_a_batch_of_large_messages_that_total_size_exceeds_256KB()
{
// default settings
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("namespace", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceManagerLifeCycleManager = new NamespaceManagerLifeCycleManager(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceManagerLifeCycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new DefaultOutgoingBatchRouter(new DefaultBatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, new ThrowOnOversizedBrokeredMessages());
// create the queue
var creator = new AzureServiceBusQueueCreator(settings);
var namespaceManager = namespaceManagerLifeCycleManager.Get("namespace");
await creator.Create("myqueue", namespaceManager);
// setup the batch
var @namespace = new RuntimeNamespaceInfo("namespace", AzureServiceBusConnectionString.Value);
var bytes = Enumerable.Range(0, 220 * 1024).Select(x => (byte)(x % 256)).ToArray();
var batch = new Batch
{
Destinations = new TopologySection
{
Entities = new List <EntityInfo>
{
new EntityInfo
{
Namespace = @namespace,
Path = "MyQueue",
Type = EntityType.Queue
}
},
Namespaces = new List <RuntimeNamespaceInfo>
{
@namespace
}
},
RequiredDispatchConsistency = DispatchConsistency.Default,
Operations = new List <BatchedOperation>
{
new BatchedOperation
{
Message = new OutgoingMessage("Id-1", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
},
new BatchedOperation
{
Message = new OutgoingMessage("Id-2", new Dictionary <string, string>(), bytes),
DeliveryConstraints = new List <DeliveryConstraint>()
}
}
};
// perform the test
await router.RouteBatch(batch, null, DispatchConsistency.Default);
//validate
var queue = await namespaceManager.GetQueue("myqueue");
Assert.IsTrue(queue.MessageCount == 2);
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}
