//
// Async callbacks
//
private void MessagesReceived(ConsumerRecord <K, V> message)
{
_buffer.Enqueue(message);
if (IsAvailable(_out))
{
Push(_out, _buffer.Dequeue());
}
}
//
// Async callbacks
//
private void MessagesReceived(ConsumerRecord <K, V> message)
{
var consumer = _consumer;
var commitableOffset = new CommitableOffset(
() => consumer.Commit(),
new PartitionOffset("groupId", message.Topic, message.Partition, message.Offset));
_buffer.Enqueue(new CommittableMessage <K, V>(message, commitableOffset));
if (IsAvailable(_out))
{
Push(_out, _buffer.Dequeue());
}
}
public static void DoExperiment3()
{
var file = MemoryMappedFile.CreateOrOpen("testFile-headers", HeaderSize);
var accessor = file.CreateViewAccessor(0, HeaderSize);
ulong readOffset = 0;
accessor.Read <ulong>(0, out readOffset);
var x = 3;
ConsumerRecord[] readConsumerRecords = new ConsumerRecord[x];
accessor.ReadArray <ConsumerRecord>(MaxWriteOffsetHeaderSize, readConsumerRecords, 0, 1);
Console.WriteLine($"returnedOffset: {readOffset}, consumer record id: {readConsumerRecords.ToString()}");
}
private async Task HandleMessage(ConsumerRecord <byte[], byte[]> message)
{
var value = stringDeserializer.Deserialize(message.Topic, message.Value);
var eventEnvelope = JsonConvert.DeserializeObject <EventEnvelope>(value, jsonSerializerSettingsProvider.GetJsonSerializerSettings());
if (eventEnvelope != null)
{
try
{
await eventDispatcher.Dispatch(eventEnvelope);
}
catch (Exception exception)
{
logger.LogError(exception, "Error during event processing of event {0}. {1}", eventEnvelope.Event.GetType().Name, exception.Message);
}
}
}
public static void DoExperiment1()
{
var file = MemoryMappedFile.CreateOrOpen("testFile-headers", HeaderSize);
ulong offset = 34534;
var MaxWriteOffsetStream = file.CreateViewStream(0, HeaderSize);
var offsetBytes = BitConverter.GetBytes(offset);
MaxWriteOffsetStream.Write(offsetBytes, 0, offsetBytes.Length);
var accessor = file.CreateViewAccessor(0, HeaderSize);
accessor.Write(0, offset);
var consumerRecords = new List <ConsumerRecord>()
{
new ConsumerRecord()
{
id = 12,
lastConsumedIndex = 24
},
new ConsumerRecord()
{
id = 32532,
lastConsumedIndex = 36
}
};
accessor.WriteArray <ConsumerRecord>(MaxWriteOffsetHeaderSize, consumerRecords.ToArray(), 0, consumerRecords.Count);
ulong readOffset = 0;
accessor.Read <ulong>(0, out readOffset);
var x = 3;
ConsumerRecord[] readConsumerRecords = new ConsumerRecord[x];
accessor.ReadArray <ConsumerRecord>(MaxWriteOffsetHeaderSize, readConsumerRecords, 0, 1);
Console.WriteLine($"returnedOffset: {readOffset}, consumer record id: {readConsumerRecords.ToString()}");
}
private void HandleConsumeError(object sender, ConsumerRecord message)
{
Log.Error(message.Error.Reason);
var exception = new SerializationException(message.Error.Reason);
switch (_decider(exception))
{
case Directive.Stop:
// Throw
_completion.TrySetException(exception);
FailStage(exception);
break;
case Directive.Resume:
// keep going
break;
case Directive.Restart:
// keep going
break;
}
}
public abstract Task ProcessMessageAsync(ConsumerRecord <string, string> message);
//
// Consumer's events
//
private void HandleOnMessage(object sender, ConsumerRecord <K, V> message) => _messagesReceived(message);
public CommittableMessage(ConsumerRecord <K, V> record, CommitableOffset commitableOffset)
{
Record = record;
CommitableOffset = commitableOffset;
}