public void Stop()
{
var rawPublisher = _rawPublisher;
if (rawPublisher == null)
{
return;
}
_rawPublisher = null;
try
{
_deferredMessagesManager?.Stop();
_queueMonitor.Stop();
rawPublisher.Stop();
}
finally
{
SaveQueue(rawPublisher.GetBufferedMessages());
rawPublisher.Dispose();
}
}
public void Constructor_NullMessageTypeTopicMap_ThrowsNullArgument(
[Frozen] IRawMessagePublisher rawMessagePublisher,
[Frozen] ISerializer serializer)
{
var ex = Assert.Throws <ArgumentNullException>(() =>
new SerializedMessagePublisher(null, serializer, rawMessagePublisher));
Assert.Equal("typeTopicMap", ex.ParamName);
}
public SerializedMessagePublisher(
IMessageTypeTopicMap typeTopicMap,
ISerializer serializer,
IRawMessagePublisher rawMessagePublisher)
{
_typeTopicMap = typeTopicMap ?? throw new ArgumentNullException(nameof(typeTopicMap));
_rawMessagePublisher = rawMessagePublisher ?? throw new ArgumentNullException(nameof(rawMessagePublisher));
_serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
}
public void Start()
{
if (_rawPublisher != null)
{
return;
}
// Check configuration
if (_queueRepository == null ^ _disableQueuePersistence)
{
throw new InvalidOperationException($"Please, do one of - setup queue repository, using {nameof(SetQueueRepository)}() method, or disable queue persistence using {nameof(DisableInMemoryQueuePersistence)}() method, before start publisher");
}
if (_serializer == null)
{
throw new InvalidOperationException($"Please, setup message serializer, using {nameof(SetSerializer)}() method, before start publisher");
}
// Set defaults
if (_queueMonitor == null)
{
MonitorInMemoryQueue();
}
if (_publishStrategy == null)
{
SetPublishStrategy(new DefaultFanoutPublishStrategy(_settings));
}
var messagesBuffer = _bufferOverriding ?? LoadQueue();
_rawPublisher = new RawMessagePublisher(
Name,
_loggerFactory.CreateLogger <RawMessagePublisher>(),
messagesBuffer,
_publishStrategy,
_settings,
_publishSynchronously,
_submitTelemetry);
_queueMonitor.WatchThis(_rawPublisher);
_queueMonitor.Start();
if (_deferredMessagesManager != null)
{
_deferredMessagesManager.Start();
_deferredMessagesManager.PublishUsing(_rawPublisher);
}
}
private static TypedMessagePublisher <string, IRawMessagePublisher <string> > CreateTypedMessagePublisher(
IRawMessagePublisher <string>?publisher = null, IMessageSerializer <string>?serializer = null,
IMessageEncoder?encoder = null, bool ignoreEncoding = false)
{
publisher ??= Mock.Of <IRawMessagePublisher <string> >();
serializer ??= Mock.Of <IMessageSerializer <string> >();
if (encoder is null)
{
var fakeEncoder = new Mock <IMessageEncoder>();
fakeEncoder.SetupGet(c => c.Encoding).Returns("someEncoder");
encoder = fakeEncoder.Object;
}
var encodingOptions = new ContentEncodingOptions {
IgnoreEncoding = ignoreEncoding
};
return(new TypedMessagePublisher <string, IRawMessagePublisher <string> >(null, publisher, serializer,
Options.Create(encodingOptions), encoder));
}
public async Task Publish_SerializedMessage_CallsRawPublisher(
string topic,
bool message,
byte[] serializedMessage,
[Frozen] IRawMessagePublisher rawMessagePublisher,
[Frozen] IMessageTypeTopicMap messageTypeTopicMap,
[Frozen] ISerializer serializer,
SerializedMessagePublisher sut)
{
// Arrange
var messageType = message.GetType();
messageTypeTopicMap.Get(messageType).Returns(topic);
serializer.Serialize(message).Returns(serializedMessage);
// Act
await sut.Publish(message, None);
// Assert
await rawMessagePublisher.Received().Publish(topic, serializedMessage, None);
}
public void PublishUsing(IRawMessagePublisher publisher)
{
_publisher = publisher ?? throw new ArgumentNullException(nameof(publisher));
}
public void WatchThis(IRawMessagePublisher publisher)
{
_publisher = publisher ?? throw new ArgumentNullException(nameof(publisher));
}
