/// <inheritdoc />
public void Dispose()
{
// Because the tasks returned from ProduceAsync might not be finished, wait for all messages to be sent
_producer?.Flush(TimeSpan.FromSeconds(5));
_producer?.Dispose();
_queueSubscriptionStorage?.Dispose();
}
private void CloseProducer()
{
if (Producer != null)
{
Producer?.Flush(TimeSpan.FromSeconds(60));
Producer?.Dispose();
}
Producer = null;
}
private void DisposeConfluentProducer()
{
// Dispose only if still in cache to avoid ObjectDisposedException
if (!ProducersCache.TryRemove(Endpoint.Configuration.ConfluentConfig, out _))
{
return;
}
_confluentProducer?.Flush(TimeSpan.FromSeconds(10));
_confluentProducer?.Dispose();
_confluentProducer = null;
}
private void Stop()
{
try
{
_producer?.Flush(TimeSpan.FromSeconds(30));
_producer?.Dispose();
_producer = null;
}
catch (Exception ex)
{
ErrorHandler.Error("Error while stopping producer", ex);
}
}
public override void PostStop()
{
Log.Debug("Stage completed");
_producer.OnError -= OnProducerError;
if (_stage.CloseProducerOnStop)
{
_producer.Flush(_stage.Settings.FlushTimeout);
_producer.Dispose();
Log.Debug($"Producer closed: {_producer.Name}");
}
base.PostStop();
}
public async Task StartAsync(CancellationToken cancellationToken)
{
for (int i = 0; i < 100; i++)
{
var value = $"Hello world {i}";
_logger.LogInformation(value);
await _producer.ProduceAsync(topic : "demo", message : new Message <Null, string>()
{
Value = value
}, cancellationToken);
_producer.Flush(timeout: TimeSpan.FromSeconds(10));
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
for (var i = 0; i < 100; ++i)
{
var value = $"Hello World {i}";
_logger.LogInformation(value);
await _producer.ProduceAsync("demo", new Message <Null, string>()
{
Value = value
}, cancellationToken);
}
_producer.Flush(TimeSpan.FromSeconds(10));
}
private static DeliveryResult <Null, string> ProduceMessage(string topic, IProducer <Null, string> producer, string testString)
{
var result = producer.ProduceAsync(topic, new Message <Null, string> {
Value = testString
}).Result;
Assert.NotNull(result?.Message);
Assert.Equal(topic, result.Topic);
Assert.NotEqual <long>(result.Offset, Offset.Unset);
Assert.Equal(TimestampType.CreateTime, result.Message.Timestamp.Type);
Assert.True(Math.Abs((DateTime.UtcNow - result.Message.Timestamp.UtcDateTime).TotalMinutes) < 1.0);
Assert.Equal(0, producer.Flush(TimeSpan.FromSeconds(10)));
return(result);
}
private DeliveryResult <Null, string> ProduceMessage(string messageString)
{
var result =
producerAsync.ProduceAsync(
currentTopic,
new Message <Null, string> {
Value = messageString
}
).Result;
producerAsync.Flush(TimeSpan.FromSeconds(10));
return(result);
}
public void Flush()
{
log.Debug($"{logPrefix}Flusing producer");
if (producer != null)
{
try
{
producer.Flush();
}catch (ObjectDisposedException)
{
// has been disposed
}
}
}
public void Dispose()
{
if (_isDisposing)
{
return;
}
_isDisposing = true;
_logger.LogDebug("Disposing Kafka Producer [{producerName}] ...", _producer.Name);
_producer.Flush(TimeSpan.FromSeconds(5));
_producer?.Dispose();
}
public async void StartAsync(string guid, string accountId)
{
var transaction = new Transaction(guid);
var valJson = JsonConvert.SerializeObject(transaction);
var key = accountId;
var topic = "firstTopic";
var deliveryResult = await _producer.ProduceAsync(topic, new Message <string, string>
{
Value = valJson,
Key = key
});
_producer.Flush(TimeSpan.FromSeconds(10));
}
void Dispose()
{
_log.Info("Flushing and Disposing Kafka Producer ");
try
{
_producer.Flush(TimeSpan.FromSeconds(10));
_producer.Dispose();
}
catch (Exception e)
{
_log.Error("EXCEPTION: Flushing and Disposing Kafka Producer", e);
throw;
}
}
/* public void StartConsumer()
* {
* var conf = new ConsumerConfig
* {
* GroupId = _grupo,
* BootstrapServers = _servidoresMensageria,
* AutoOffsetReset = AutoOffsetReset.Earliest
* };
*
* _consumer = new ConsumerBuilder<Ignore, string>(conf).Build();
* _consumer.Subscribe(_topicos);
* }*/
/// <summary>
/// Para execução
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public Task StopAsync(CancellationToken cancellationToken)
{
using (var scope = _services.CreateScope())
{
var logger = scope.ServiceProvider.GetRequiredService <ILogger <MensageriaWorker> >();
logger.LogInformation("PARANDO: Job de Mensageria");
_timer?.Change(Timeout.Infinite, 0);
_producer?.Flush();
return(Task.CompletedTask);
}
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
Producer?.Flush();
Producer?.Dispose();
}
_disposed = true;
}
private void CreateProducer()
{
if (Interlocked.CompareExchange(ref _created, 1, 0) == 0)
{
_producer = new ProducerBuilder <Null, WrapperMessage>(_producerConfig)
.SetValueSerializer(new ProducerValueSerializer <WrapperMessage>())
.Build();
_disposable = Disposable.Create(() =>
{
_disposed = true;
_producer.Flush();
_producer.Dispose();
});
}
}
protected virtual void Dispose(bool disposing)
{
if (!_disposedValue)
{
if (disposing)
{
if (_producer != null)
{
_producer.Flush(TimeSpan.FromMilliseconds(_producerConfig.MessageTimeoutMs.Value + 5000));
_producer.Dispose();
_producer = null;
}
}
_disposedValue = true;
}
}
// DUVIDA: O nome do método é Async dentro de uma classe Sync, talvez juntar esse método no ProducerAsyncSender e renome-lo para
// ProducerSender com os dois métodos?
public async Task SendAsync(TKey key, TValue value, string topicName, Headers headers = null, CancellationToken cancellationToken = default)
{
var message = new Message <TKey, TValue>
{
Key = key,
Value = value,
Headers = headers
};
var produceTask = producer.ProduceAsync(topicName, message);
producerClient.MessageSent(message);
producerClient.MessageDelivered(await produceTask);
// DUVIDA: Faz sentido ter o flush no método asyncrono tb? talvez deixar isso no ProducerSettings.
producer.Flush(cancellationToken);
this.logger.Log($"[To queue]: Message delivered: {topicName}, {message.Key}");
}
public void SendImageRequest(int display_x, int display_y, double min_x, double min_y, double max_x, double max_y, int depth, string connectionId)
{
var _request = new avro.imageRequest();
_request.display_x = display_x;
_request.display_y = display_y;
_request.min_x = min_x;
_request.min_y = min_y;
_request.max_x = max_x;
_request.max_y = max_y;
_request.depth = depth;
_request.connectionId = connectionId;
_producer.ProduceAsync("imageReq", new Message <Null, imageRequest> {
Value = _request
});
_producer.Flush();
Console.WriteLine($"Sent image build request for {_request.display_x} - {_request.display_y} from connection {_request.connectionId}");
}
/// <summary>
/// Agenda execução
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task StartAsync(CancellationToken cancellationToken)
{
try
{
//if (cancellationToken.IsCancellationRequested)
// return Task.CompletedTask;
StartProducer();
//Inicializa o timer que dispara o job
while (true)
{
var intervalTime = _configurationSection.GetValue <int>("SegundosExecucaoJob");
//_timer = new Timer(async (state) => await TimerTick(state), cancellationToken, TimeSpan.Zero, TimeSpan.FromSeconds(intervalTime));
var result = await _producer.ProduceAsync(_topicos[0], new Message <Null, string> {
Value = "Hello world " + DateTime.Now.ToString("HH:mm:ss")
});
if (result == null) //Deu o timeout, volta a executar apenas no proximo tick do timer
{
return;
}
Thread.Sleep(intervalTime * 1000);
_producer.Flush(TimeSpan.FromSeconds(intervalTime));
HandleMessage(result);
}
}
catch (Exception ex)
{
_logger.LogCritical("Erro ao inicializar o Job de Mensageria. Verifique se a configuração esta válida no appsettings!",
//rotina: nameof(MensageriaWorker),
ex);
}
//return Task.CompletedTask;
}
public async void StartAsync(int val, string guid, string fromId, string toId)
{
var transaction = new Transaction(guid, toId, val, 0);
var valJson = JsonConvert.SerializeObject(transaction);
var key = fromId;
var topic = "firstTopic";
var deliveryResult = await _producer.ProduceAsync(topic, new Message <string, string>
{
Value = valJson,
Key = key
});
// informacja zwrotna
// await Console.Out.WriteLineAsync("received data\n" +
// "Topic: " + deliveryResult.Topic +
// "\nPartition: " + deliveryResult.Partition +
// "\noffset: " + deliveryResult.Offset +
// "\ntimestamp: " + deliveryResult.Timestamp.ToString());
_producer.Flush(TimeSpan.FromSeconds(10));
}
public void Dispose()
{
var timeoutTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(30));
var cts = CancellationTokenSource.CreateLinkedTokenSource(timeoutTokenSource.Token, _cancellationTokenSource.Token);
try
{
_producer.Flush(cts.Token);
}
catch (OperationCanceledException)
{
}
catch (Exception e)
{
_logContext.Error?.Log(e, "Failed to dispose producer: {producerName}", _producer.Name);
}
finally
{
timeoutTokenSource.Dispose();
_cancellationTokenSource.Dispose();
_producer.Dispose();
}
}
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
public async Task PublishAsync <TK, T>(IList <DomainEvent <TK, T> > domainEvents) where TK : struct
#pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
{
if (domainEvents == null || !domainEvents.Any())
{
throw new ArgumentNullException(nameof(domainEvents));
}
foreach (var domainEvent in domainEvents)
{
var data = JsonConvert.SerializeObject(domainEvent, Formatting.Indented);
var msg = new Message <string, string>
{
Key = domainEvent.Id.ToString(),
Value = data
};
_producer.Produce(domainEvent.EventName, msg, (deliveryReport) =>
{
if (deliveryReport.Error.Code != ErrorCode.NoError)
{
//_failedEventsEventRepository.SaveAsync(new FailedEvent
//{
// EventId = deliveryReport.Message.Key,
// Content = deliveryReport.Message.Value,
// EventName = deliveryReport.Topic
//}).ConfigureAwait(false).GetAwaiter().GetResult();
Console.WriteLine($"Failed to deliver message: {deliveryReport.Error.Reason}");
}
else
{
Console.WriteLine($"Produced message to: {deliveryReport.TopicPartitionOffset}");
}
});
}
_producer.Flush(TimeSpan.FromSeconds(10)); // wait for up to 10 seconds for any inflight messages to be delivered.
}
public static void sendCarRecordMessage(string message)
{
int len = message.Length;
//if (configMess == null) { configMess = new ProducerConfig { BootstrapServers = brokerList}; }
if (configMess == null)
{
ClientConfig clientfig = new ClientConfig();
clientfig.BootstrapServers = brokerList;
//clientfig.MessageMaxBytes = 92914560;
clientfig.MessageMaxBytes = 100000000;
//clientfig.MessageCopyMaxBytes = 1000000000;
//clientfig.ReceiveMessageMaxBytes = 800000000;
//clientfig.SocketSendBufferBytes = 100000000;
//clientfig.MetadataRequestTimeoutMs = 1000 * 60;
configMess = new ProducerConfig(clientfig);
//configMess.
//configMess.MessageTimeoutMs = 300000;
}
FileWorker.LogHelper.WriteLog("正在向kafka发送MessComm消息:" + message);
try
{
if (producerMess == null)
{
producerMess = new ProducerBuilder <Null, string>(configMess).Build();
}
producerMess.Produce(messageTopicName, new Message <Null, string> {
Value = message
}, handler);
producerMess.Flush(TimeSpan.FromSeconds(5));
}
catch (Exception e)
{
FileWorker.LogHelper.WriteLog("alarm error " + e.Message);
}
}
public static void sendAccessMessage(string message)
{
if (configAccess == null)
{
configAccess = new ProducerConfig {
BootstrapServers = brokerList
};
}
try
{
if (producerAccess == null)
{
producerAccess = new ProducerBuilder <Null, string>(configAccess).Build();
}
producerAccess.Produce(accessTopicName, new Message <Null, string> {
Value = message
}, handler);
producerAccess.Flush(TimeSpan.FromSeconds(5));
}
catch (Exception e)
{
FileWorker.LogHelper.WriteLog("access error " + e.Message);
}
}
public void Flush(CancellationToken token = default) => _producer.Flush(token);
public void Flush() => producer.Flush();
public void Flush(TimeSpan span)
{
producer.Flush(span);
}
public void Dispose()
{
_producer.Flush(TimeSpan.FromSeconds(10));
_producer.Dispose();
}
public void Close()
{
_producer.Flush();
_producer.Dispose();
}
