public async Task ExecuteAsync(ISendEndpointProvider endpointProvider, ProducerOptions options, CancellationToken stoppingToken)
{
var endpoint = await endpointProvider.GetSendEndpoint(new Uri(@"queue:record-timestamp"));
while (!stoppingToken.IsCancellationRequested && _executionCount < options.MaxSendCount)
{
Task[] tasks = new Task[options.MaxSendConcurrency];
for (int i = 0; i < tasks.Length; i++)
{
_logger.LogInformation("Sending message {Index}/{Total}, total = {ExecutionCount} ...", i, options.MaxSendConcurrency, _executionCount);
tasks[i] = endpoint.Send <RecordTimestamp>(new
{
TaskId = i,
ThreadId = Thread.CurrentThread.ManagedThreadId,
ProducerId = Id,
SentTime = DateTime.UtcNow
});
_executionCount++;
}
Task.WaitAll(tasks);
if (options.Interval > 0)
{
await Task.Delay(options.Interval, stoppingToken);
}
}
}
public ProducerStreamFactory(ConnectionPool connectionPool, ProducerOptions options, IFaultStrategy faultStrategy)
{
_connectionPool = connectionPool;
_options = options;
_faultStrategy = faultStrategy;
_sequenceId = new SequenceId(options.InitialSequenceId);
}
protected ProducerOptions GetProducerOptions()
{
var options = new ProducerOptions();
options.PostProcess();
return(options);
}
public Producer(
Uri serviceUrl,
ProducerOptions <TMessage> options,
ProcessManager processManager,
IHandleException exceptionHandler,
IConnectionPool connectionPool,
ICompressorFactory?compressorFactory)
{
_operationName = $"{options.Topic} send";
_tags = new KeyValuePair <string, object?>[]
{
new KeyValuePair <string, object?>("messaging.destination", options.Topic),
new KeyValuePair <string, object?>("messaging.destination_kind", "topic"),
new KeyValuePair <string, object?>("messaging.system", "pulsar"),
new KeyValuePair <string, object?>("messaging.url", serviceUrl),
};
_sequenceId = new SequenceId(options.InitialSequenceId);
_state = new StateManager <ProducerState>(ProducerState.Disconnected, ProducerState.Closed, ProducerState.Faulted);
ServiceUrl = serviceUrl;
Topic = options.Topic;
_isDisposed = 0;
_options = options;
_exceptionHandler = exceptionHandler;
_connectionPool = connectionPool;
_compressorFactory = compressorFactory;
_processManager = processManager;
_messageRouter = options.MessageRouter;
_cts = new CancellationTokenSource();
_executor = new Executor(Guid.Empty, this, _exceptionHandler);
_producers = new ConcurrentDictionary <int, SubProducer <TMessage> >();
_ = Setup();
}
protected ProducerOptions GetProducerOptions(string bindingName)
{
var options = new ProducerOptions();
options.PostProcess(bindingName);
return(options);
}
public void CompressionType_ShouldThrowsException_WhenValueIsNotDefineInEnum(CompressionType value)
{
// Arrange
var options = new ProducerOptions();
// Act + Assert
Assert.Throws <ArgumentOutOfRangeException>(() => options.CompressionType = value);
}
public void MaxMessagesInBufferingQueue_ShouldThrowsException_WhenValueIsNotPositive(int value)
{
// Arrange
var options = new ProducerOptions();
// Act + Assert
Assert.Throws <ArgumentOutOfRangeException>(() => options.MaxMessagesInBufferingQueue = value);
}
public void RetryCount_ShouldThrowsException_WhenValueIsNegative(int value)
{
// Arrange
var options = new ProducerOptions();
// Act + Assert
Assert.Throws <ArgumentOutOfRangeException>(() => options.RetryCount = value);
}
public void RetryAfter_ShouldThrowsException_WhenValueIsNotPositive(TimeSpan value)
{
// Arrange
var options = new ProducerOptions();
// Act + Assert
Assert.Throws <ArgumentOutOfRangeException>(() => options.RetryAfter = value);
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="connection">连接对象</param>
/// <param name="options">配置对象</param>
/// <param name="consumerOptions">消费者配置对象</param>
/// <param name="producerOptions">生产者配置对象</param>
/// <param name="loggerFactory">日志工厂</param>
public ConnectionObject(IConnection connection, RabbitMQOptions options, ConsumerOptions consumerOptions, ProducerOptions producerOptions, ILoggerFactory loggerFactory)
{
channels = new List <ChannelObject>();
this.connection = connection;
RabbitMQOptions = options;
ConsumerOptions = consumerOptions;
ProducerOptions = producerOptions;
this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
logger = loggerFactory.CreateLogger <ConnectionObject>();
}
public void TestSetupProducerThrowsOnNonExistentExchange()
{
var producerOptions = new ProducerOptions();
producerOptions.ExchangeName = null;
Assert.Throws <ArgumentException>(() => _testAdapter.SetupProducer(producerOptions));
producerOptions.ExchangeName = "TEST.DoesNotExistExchange";
Assert.Throws <ApplicationException>(() => _testAdapter.SetupProducer(producerOptions));
}
public static ProducerConfiguration ToConfiguration(this ProducerOptions producerOptions)
{
return(new ProducerConfiguration
{
MessagePriority = producerOptions.MessagePriority,
MessageDurabilityMode = producerOptions.MessageDurabilityMode,
MessageIdPolicy = producerOptions.MessageIdPolicy,
SetMessageCreationTime = producerOptions.SetMessageCreationTime,
});
}
protected BindingOptions CreateProducerBindingOptions(ProducerOptions producerOptions)
{
var bindingOptions = new BindingOptions()
{
ContentType = BindingOptions.DEFAULT_CONTENT_TYPE.ToString()
};
bindingOptions.Producer = producerOptions;
return(bindingOptions);
}
public void MaxMessagesInBufferingQueue_ShouldNotThrowsException_WhenValueIsPosistive(int value)
{
// Arrange
var options = new ProducerOptions();
// Act
options.MaxMessagesInBufferingQueue = value;
// Assert
Assert.Equal(value, options.MaxMessagesInBufferingQueue);
}
public void MessageBatchSize_ShouldNotThrowsException_WhenValueIsPositive(int value)
{
// Arrange
var options = new ProducerOptions();
// Act
options.MessageBatchSize = value;
// Assert
Assert.Equal(value, options.MessageBatchSize);
}
public void MessageTimeoutSetter_shouldNotThrowsException_WhenValueIsPositive(TimeSpan value)
{
// Arrange
var options = new ProducerOptions();
// Act
options.MessageTimeout = value;
// Assert
Assert.Equal(value, options.MessageTimeout);
}
public void CompressionType_ShouldNotThrowsException_WhenValueIsDefineInEnum(CompressionType value)
{
// Arrange
var options = new ProducerOptions();
// Act
options.CompressionType = value;
// Assert
Assert.Equal(value, options.CompressionType);
}
public MicroserviceTester(RabbitOptions rabbitOptions, params ConsumerOptions[] peopleYouWantToSendMessagesTo)
{
CleanUpAfterTest = true;
_adapter = new RabbitMqAdapter(rabbitOptions.CreateConnectionFactory(), "TestHost");
Factory = new ConnectionFactory
{
HostName = rabbitOptions.RabbitMqHostName,
Port = rabbitOptions.RabbitMqHostPort,
VirtualHost = rabbitOptions.RabbitMqVirtualHost,
UserName = rabbitOptions.RabbitMqUserName,
Password = rabbitOptions.RabbitMqPassword
};
using (var con = Factory.CreateConnection())
using (var model = con.CreateModel())
{
//get rid of old exchanges
model.ExchangeDelete(rabbitOptions.RabbitMqControlExchangeName);
//create a new one
model.ExchangeDeclare(rabbitOptions.RabbitMqControlExchangeName, ExchangeType.Topic, true);
//setup a sender chanel for each of the consumers you want to test sending messages to
foreach (ConsumerOptions consumer in peopleYouWantToSendMessagesTo)
{
if (!consumer.QueueName.Contains("TEST."))
{
consumer.QueueName = consumer.QueueName.Insert(0, "TEST.");
}
var exchangeName = consumer.QueueName.Replace("Queue", "Exchange");
//terminate any old queues / exchanges
model.ExchangeDelete(exchangeName);
model.QueueDelete(consumer.QueueName);
_declaredExchanges.Add(exchangeName);
//Create a binding between the exchange and the queue
model.ExchangeDeclare(exchangeName, ExchangeType.Direct, true); //durable seems to be needed because RabbitMQAdapter wants it?
model.QueueDeclare(consumer.QueueName, true, false, false); //shared with other users
model.QueueBind(consumer.QueueName, exchangeName, "");
_declaredQueues.Add(consumer.QueueName);
//Create a producer which can send to the
var producerOptions = new ProducerOptions
{
ExchangeName = exchangeName
};
_sendToConsumers.Add(consumer, _adapter.SetupProducer(producerOptions, true));
}
}
}
public void RetryCount_ShouldNotThrowsException_WhenValueIsPositive(int value)
{
// Arrange
var options = new ProducerOptions();
// Act
options.RetryCount = value;
// Assert
Assert.Equal(value, options.RetryCount);
}
public void RetryAfter_ShouldNotThrowsException_WhenValueIsPositive(TimeSpan value)
{
// Arrange
var options = new ProducerOptions();
// Act
options.RetryAfter = value;
// Arrange
Assert.Equal(value, options.RetryAfter);
}
public DefaultProducer(ProducerOptions options, IntPtr handle, IProducerNativeMethodsFacade producerFacade = null, DiagnosticListener diagnosticListener = null)
{
this.Options = options ?? throw new ArgumentNullException(nameof(options));
if (handle == IntPtr.Zero)
{
throw new ArgumentOutOfRangeException(nameof(handle));
}
this.Handle = new HandleRef(this, handle);
this._producerFacade = producerFacade ?? new ProducerNativeMethodsFacade();
this._diagnosticListener = diagnosticListener;
}
static async Task Main(string[] args)
{
var client = PulsarClient.Builder().Build();
var producerOptions = new ProducerOptions("persistent://public/default/mytopic");
var producer = client.CreateProducer(producerOptions);
while (true)
{
Console.Write("Please Enter Message: ");
var message = Console.ReadLine();
var data = Encoding.UTF8.GetBytes(message);
var result = await producer.Send(data);
}
}
/// <summary>
/// Loads logging, sets up fatal behaviour, subscribes rabbit etc.
/// </summary>
/// <param name="globals">Settings for the microservice (location of rabbit, queue names etc)</param>
/// <param name="rabbitMqAdapter"></param>
/// <param name="threaded"></param>
protected MicroserviceHost(
[NotNull] GlobalOptions globals,
IRabbitMqAdapter rabbitMqAdapter = null,
bool threaded = false)
{
if (globals == null || globals.FileSystemOptions == null || globals.RabbitOptions == null || globals.LoggingOptions == null)
{
throw new ArgumentException("All or part of the global options are null");
}
HostProcessName = SmiCliInit.HostProcessName;
Logger = LogManager.GetLogger(GetType().Name);
Logger.Info("Host logger created");
HostProcessID = Process.GetCurrentProcess().Id;
Logger.Info($"Starting {HostProcessName} (Host={Environment.MachineName} PID={HostProcessID} User={Environment.UserName})");
// log centrally
Globals = globals;
Logger.Debug("Loaded global options:\n" + globals);
// should also be centralized for non-host uses
// Ensure this is false in case the default changes
DicomTypeTranslater.SerializeBinaryData = false;
_fatalLoggingProducerOptions = new ProducerOptions
{
ExchangeName = Globals.RabbitOptions.FatalLoggingExchange
};
//TODO This won't pass for testing with mocked filesystems
//if(!Directory.Exists(options.FileSystemRoot))
// throw new ArgumentException("Could not locate the FileSystemRoot \"" + options.FileSystemRoot + "\"");
OnFatal += (sender, args) => Fatal(args.Message, args.Exception);
RabbitMqAdapter = rabbitMqAdapter;
if (RabbitMqAdapter == null)
{
ConnectionFactory connectionFactory = globals.RabbitOptions.CreateConnectionFactory();
RabbitMqAdapter = new RabbitMqAdapter(connectionFactory, HostProcessName + HostProcessID, OnFatal, threaded);
_controlMessageConsumer = new ControlMessageConsumer(connectionFactory, HostProcessName, HostProcessID, globals.RabbitOptions.RabbitMqControlExchangeName, this.Stop);
}
ObjectFactory = new MicroserviceObjectFactory();
ObjectFactory.FatalHandler = (s, e) => Fatal(e.Message, e.Exception);
}
/// <summary>
/// 初始化
/// </summary>
/// <param name="rabbitMQOptions">配置对象</param>
/// <param name="consumerOptions">消费者配置</param>
/// <param name="producerOptions">生产者配置</param>
/// <param name="loggerFactory">日志工厂对象</param>
public ChannelPooledObjectPolicy(IOptions <RabbitMQOptions> rabbitMQOptions, IOptions <ConsumerOptions> consumerOptions, IOptions <ProducerOptions> producerOptions, ILoggerFactory loggerFactory)
{
this.rabbitMQOptions = rabbitMQOptions?.Value ?? throw new ArgumentNullException(nameof(rabbitMQOptions));
this.producerOptions = producerOptions?.Value ?? throw new ArgumentNullException(nameof(rabbitMQOptions));
this.consumerOptions = consumerOptions?.Value ?? throw new ArgumentNullException(nameof(rabbitMQOptions));
this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
logger = this.loggerFactory.CreateLogger <ChannelPooledObjectPolicy>();
connectionObjects = new List <ConnectionObject>();
connectionFactory = new ConnectionFactory
{
UserName = this.rabbitMQOptions.UserName,
Password = this.rabbitMQOptions.Password,
VirtualHost = this.rabbitMQOptions.VirtualHost,
AutomaticRecoveryEnabled = true,
TopologyRecoveryEnabled = true,
ClientProvidedName = this.rabbitMQOptions.ExchangeName,
};
}
public ProducerChannelFactory(
Guid correlationId,
IRegisterEvent eventRegister,
IConnectionPool connectionPool,
IExecute executor,
ProducerOptions options)
{
_correlationId = correlationId;
_eventRegister = eventRegister;
_connectionPool = connectionPool;
_executor = executor;
_commandProducer = new CommandProducer
{
ProducerName = options.ProducerName,
Topic = options.Topic
};
}
internal void Run(string[] args)
{
_logger.LogInformation(
$"Os serviços da aplicação foram iniciados com sucesso no ambiente de {_hostEnvironment.EnvironmentName} por {System.Environment.UserName}");
ProducerOptions options = _options.Value;
if (args.Length == 0)
{
_app.Run(string.IsNullOrEmpty(options.DefaultCommand) ? "help" : options.DefaultCommand);
}
else
{
_app.Run(args);
}
_logger.LogInformation(
$"A encerrar aplicação no ambiente de {_hostEnvironment.EnvironmentName} por {System.Environment.UserName}");
}
protected ProducerOptions GetProducerOptions(string bindingName, RabbitBindingsOptions bindingsOptions, RabbitBindingOptions bindingOptions = null)
{
var rabbitProducerOptions = new RabbitProducerOptions();
rabbitProducerOptions.PostProcess();
bindingOptions ??= new RabbitBindingOptions();
bindingOptions.Producer = rabbitProducerOptions;
bindingsOptions.Bindings.Add(bindingName, bindingOptions);
var producerOptions = new ProducerOptions()
{
BindingName = bindingName
};
producerOptions.PostProcess(bindingName);
return(producerOptions);
}
public void TestVerifyPopulatedChecks()
{
var producerOptions = new ProducerOptions();
Assert.False(producerOptions.VerifyPopulated());
producerOptions.ExchangeName = "";
Assert.False(producerOptions.VerifyPopulated());
producerOptions.ExchangeName = "Test.ExchangeName";
Assert.True(producerOptions.VerifyPopulated());
var consumerOptions = new ConsumerOptions();
Assert.False(consumerOptions.VerifyPopulated());
consumerOptions.QueueName = "Test.QueueName";
Assert.False(consumerOptions.VerifyPopulated());
consumerOptions.QoSPrefetchCount = 1234;
Assert.True(consumerOptions.VerifyPopulated());
}
public void SetUp()
{
_testOptions = new GlobalOptionsFactory().Load();
_testProducerOptions = new ProducerOptions
{
ExchangeName = "TEST.TestExchange"
};
_testConsumerOptions = new ConsumerOptions
{
QueueName = "TEST.TestQueue",
QoSPrefetchCount = 1,
AutoAck = false
};
_mockConsumer = Mock.Of <Consumer <IMessage> >();
_testAdapter = new RabbitMqAdapter(_testOptions.RabbitOptions.CreateConnectionFactory(), "RabbitMqAdapterTests");
_tester = new MicroserviceTester(_testOptions.RabbitOptions, _testConsumerOptions);
}
public Producer(
Uri serviceUrl,
ProducerOptions <TMessage> options,
ProcessManager processManager,
IHandleException exceptionHandler,
IConnectionPool connectionPool,
ICompressorFactory?compressorFactory)
{
_state = new StateManager <ProducerState>(ProducerState.Disconnected, ProducerState.Closed, ProducerState.Faulted);
ServiceUrl = serviceUrl;
Topic = options.Topic;
_isDisposed = 0;
_options = options;
_exceptionHandler = exceptionHandler;
_connectionPool = connectionPool;
_compressorFactory = compressorFactory;
_processManager = processManager;
_messageRouter = options.MessageRouter;
_cts = new CancellationTokenSource();
_executor = new Executor(Guid.Empty, this, _exceptionHandler);
_producers = new ConcurrentDictionary <int, IProducer <TMessage> >();
_ = Setup();
}
