public virtual void TestSeparatedGetProducerDataAssigned() { var fooSchema = AvroSchema <SchemaTestUtils.Foo> .Of(ISchemaDefinition <SchemaTestUtils.Foo> .Builder().WithPojo(typeof(SchemaTestUtils.Foo)).Build()); var barSchema = AvroSchema <SchemaTestUtils.Bar> .Of(ISchemaDefinition <SchemaTestUtils.Bar> .Builder().WithPojo(typeof(SchemaTestUtils.Bar)).Build()); var keyValueSchema = ISchema <int> .KeyValue(fooSchema, barSchema, KeyValueEncodingType.SEPARATED); var foo = new SchemaTestUtils.Foo { Field1 = "field1", Field2 = "field2", Field3 = 3 }; var bar = new SchemaTestUtils.Bar { Field1 = true }; // Check kv.encoding.type SPRAERATE var encodeBytes = keyValueSchema.Encode(new KeyValue <SchemaTestUtils.Foo, SchemaTestUtils.Bar>(foo, bar)); var builder = new MessageMetadata(); builder.ProducerName = "separated"; builder.PartitionKey = Convert.ToBase64String(fooSchema.Encode(foo)); builder.PartitionKeyB64Encoded = true; var msg = Message <KeyValue <SchemaTestUtils.Foo, SchemaTestUtils.Bar> > .Create(builder, new ReadOnlySequence <byte>(encodeBytes), keyValueSchema); var keyValue = msg.Value; Assert.Equal(keyValue.Key, foo); Assert.Equal(keyValue.Value, bar); Assert.True(builder.ShouldSerializePartitionKey()); }
public virtual async Task ReaderSourceTaggedTest() { var topic = $"reader-topics-{Guid.NewGuid()}"; var ids = PublishMessages(topic, 50); var start = MessageIdUtils.GetOffset(ids.First()); var end = MessageIdUtils.GetOffset(ids.Last()); var conf = new ReaderConfigBuilder <DataOp>().Topic(topic); var reader = _pulsarSystem.EventSource("public", "default", topic, start, end, "http://127.0.0.1:8080") .Reader(_clientConfigurationData, conf, AvroSchema <DataOp> .Of(typeof(DataOp))) .SourceMethod() .CurrentTaggedEvents(new Messages.Consumer.Tag("twitter", "mestical")); //let leave some time to wire everything up await Task.Delay(TimeSpan.FromSeconds(20)); var receivedCount = 0; while (receivedCount == 0) { await foreach (var response in reader.CurrentEvents(TimeSpan.FromSeconds(5))) { receivedCount++; _output.WriteLine(JsonSerializer.Serialize(response, new JsonSerializerOptions { WriteIndented = true })); } await Task.Delay(TimeSpan.FromSeconds(1)); } Assert.True(receivedCount > 0); }
public virtual void TestAllowNullBytesSchemaEncodeAndDecode() { var fooAvroSchema = AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).Build()); var barAvroSchema = AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).Build()); var bar = new Bar { Field1 = true }; var foo = new Foo { Field1 = "field1", Field2 = "field2", Field3 = "3", Field4 = bar, Color = Color.RED }; var fooBytes = fooAvroSchema.Encode(foo); var barBytes = barAvroSchema.Encode(bar); var encodeBytes = ISchema <object> .KvBytes().Encode(new KeyValue <byte[], byte[]>(fooBytes, barBytes)); var decodeKV = ISchema <object> .KvBytes().Decode(encodeBytes); var fooBack = fooAvroSchema.Decode(decodeKV.Key); var barBack = barAvroSchema.Decode(decodeKV.Value); Assert.True(foo.Equals(fooBack)); Assert.True(bar.Equals(barBack)); }
public virtual void TestFillParametersToSchemainfo() { var fooSchema = AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).Build()); var barSchema = AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).Build()); fooSchema.SchemaInfo.Name = "foo"; fooSchema.SchemaInfo.Type = SchemaType.AVRO; IDictionary <string, string> keyProperties = new Dictionary <string, string> { ["foo.key1"] = "value", ["foo.key2"] = "value" }; fooSchema.SchemaInfo.Properties = keyProperties; barSchema.SchemaInfo.Name = "bar"; barSchema.SchemaInfo.Type = SchemaType.AVRO; IDictionary <string, string> valueProperties = new Dictionary <string, string> { ["bar.key"] = "key" }; barSchema.SchemaInfo.Properties = valueProperties; var keyValueSchema1 = ISchema <object> .KeyValue(fooSchema, barSchema); Assert.Equal("foo", keyValueSchema1.SchemaInfo.Properties["key.schema.name"]); Assert.Equal(SchemaType.AVRO.ToString(), keyValueSchema1.SchemaInfo.Properties["key.schema.type"]); Assert.Equal(@"{""foo.key1"":""value"",""foo.key2"":""value""}", keyValueSchema1.SchemaInfo.Properties["key.schema.properties"]); Assert.Equal("bar", keyValueSchema1.SchemaInfo.Properties["value.schema.name"]); Assert.Equal(SchemaType.AVRO.ToString(), keyValueSchema1.SchemaInfo.Properties["value.schema.type"]); Assert.Equal(@"{""bar.key"":""key""}", keyValueSchema1.SchemaInfo.Properties["value.schema.properties"]); }
public virtual void TestInlineKeyValueEncodingTypeSchemaEncodeAndDecode() { var fooSchema = AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).Build()); var barSchema = AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).Build()); var keyValueSchema = ISchema <object> .KeyValue(fooSchema, barSchema, KeyValueEncodingType.INLINE); var bar = new Bar { Field1 = true }; var foo = new Foo { Field1 = "field1", Field2 = "field2", Field3 = "3", Field4 = bar, Color = Color.RED }; // Check kv.encoding.type INLINE var encodeBytes = keyValueSchema.Encode(new KeyValue <Foo, Bar>(foo, bar)); Assert.True(encodeBytes.Length > 0); var keyValue = keyValueSchema.Decode(encodeBytes); var fooBack = keyValue.Key; var barBack = keyValue.Value; Assert.True(foo.Equals(fooBack)); Assert.True(bar.Equals(barBack)); }
private ISet <MessageId> PublishMessages(string topic, int count) { var ids = new HashSet <MessageId>(); var builder = new ProducerConfigBuilder <DataOp>() .Topic(topic); var producer = _client.NewProducer(AvroSchema <DataOp> .Of(typeof(DataOp)), builder); for (var i = 0; i < count; i++) { var key = "key" + i; MessageId id = null; if (i % 2 == 0) { id = producer.NewMessage().Key(key).Property("twitter", "mestical").Value(new DataOp { Text = "my-event-message-" + i, EventTime = DateTimeHelper.CurrentUnixTimeMillis() }).Send(); } else { id = producer.NewMessage().Key(key).Value(new DataOp { Text = "my-event-message-" + i, EventTime = DateTimeHelper.CurrentUnixTimeMillis() }).Send(); } ids.Add(id); } return(ids); }
public GenericAvroReaderTest() { fooSchema = AvroSchema <SchemaTestUtils.Foo> .Of(typeof(SchemaTestUtils.Foo)); fooV2Schema = AvroSchema <SchemaTestUtils.FooV2> .Of(typeof(SchemaTestUtils.FooV2)); fooSchemaNotNull = AvroSchema <SchemaTestUtils.Foo> .Of(ISchemaDefinition <SchemaTestUtils.Foo> .Builder().WithAlwaysAllowNull(false).WithPojo(typeof(SchemaTestUtils.Foo)).Build()); fooOffsetSchema = AvroSchema <SchemaTestUtils.Foo> .Of(typeof(SchemaTestUtils.Foo)); fooOffsetSchema.SchemaInfo.Properties.Add(GenericAvroSchema.OFFSET_PROP, "5"); var prop = fooOffsetSchema.AvroSchema.GetProperty(GenericAvroSchema.OFFSET_PROP); foo = new SchemaTestUtils.Foo { Field1 = "foo1", Field2 = "bar1", Field4 = new SchemaTestUtils.Bar(), FieldUnableNull = "notNull" }; fooV2 = new SchemaTestUtils.FooV2 { Field1 = ("foo1"), Field3 = (10) }; }
public virtual void TestSchemaDefinition() { var schema1 = typeof(DefaultStruct).GetSchema(); var schema2 = AvroSchema <StructWithAnnotations> .Of(typeof(StructWithAnnotations)); var schemaDef1 = schema1.ToString(); var schemaDef2 = Encoding.UTF8.GetString(schema2.SchemaInfo.Schema); Assert.NotEqual(schemaDef1, schemaDef2); var schema3 = AvroSchema <StructWithAnnotations> .Of(ISchemaDefinition <StructWithAnnotations> .Builder().WithJsonDef(schemaDef1).Build()); var schemaDef3 = Encoding.UTF8.GetString(schema3.SchemaInfo.Schema); Assert.True(schemaDef1.Contains("DefaultStruct") && schemaDef3.Contains("DefaultStruct")); Assert.NotEqual(schemaDef2, schemaDef3); var @struct = new StructWithAnnotations { Field1 = 5678 }; // schema2 is using the schema generated from POJO, // it allows field2 to be nullable, and field3 has default value. schema2.Encode(@struct); // schema3 is using the schema passed in, which doesn't allow nullable schema3.Encode(@struct); }
public virtual void TestDefaultGetProducerDataAssigned() { var fooSchema = AvroSchema <SchemaTestUtils.Foo> .Of(ISchemaDefinition <SchemaTestUtils.Foo> .Builder().WithPojo(typeof(SchemaTestUtils.Foo)).Build()); var barSchema = AvroSchema <SchemaTestUtils.Bar> .Of(ISchemaDefinition <SchemaTestUtils.Bar> .Builder().WithPojo(typeof(SchemaTestUtils.Bar)).Build()); var keyValueSchema = ISchema <object> .KeyValue(fooSchema, barSchema); var foo = new SchemaTestUtils.Foo { Field1 = "field1", Field2 = "field2", Field3 = 3 }; var bar = new SchemaTestUtils.Bar { Field1 = true }; // // Check kv.encoding.type default, not set value var encodeBytes = keyValueSchema.Encode(new KeyValue <SchemaTestUtils.Foo, SchemaTestUtils.Bar>(foo, bar)); var builder = new MessageMetadata(); builder.ProducerName = "default"; var msg = Message <KeyValue <SchemaTestUtils.Foo, SchemaTestUtils.Bar> > .Create(builder, new ReadOnlySequence <byte>(encodeBytes), keyValueSchema); var keyValue = msg.Value; Assert.Equal(keyValue.Key, foo); Assert.Equal(keyValue.Value, bar); Assert.False(builder.ShouldSerializePartitionKey()); }
public void ProduceAndConsume() { var record1 = AvroSchema <SimpleRecord> .Of(typeof(SimpleRecord)); var consumerBuilder = new ConsumerConfigBuilder <SimpleRecord>() .Topic(_topic) .ConsumerName("avroUpgradeSchema1") .SubscriptionName("test-sub"); var consumer = _client.NewConsumer(record1, consumerBuilder); var producerBuilder = new ProducerConfigBuilder <SimpleRecord>() .Topic(_topic) .ProducerName("avroUpgradeSchema1"); var producer = _client.NewProducer(record1, producerBuilder); producer.NewMessage() .Value(new SimpleRecord { Name = "Ebere Abanonu", Age = int.MaxValue }) .Send(); Thread.Sleep(TimeSpan.FromSeconds(10)); var message = consumer.Receive(); Assert.NotNull(message); consumer.Acknowledge(message); consumer.Unsubscribe(); var record2 = AvroSchema <SimpleRecord2> .Of(typeof(SimpleRecord2)); var consumerBuilder2 = new ConsumerConfigBuilder <SimpleRecord2>() .Topic(_topic) .ConsumerName("avroUpgradeSchema2") .SubscriptionName("test-sub"); var consumer1 = _client.NewConsumer(record2, consumerBuilder2); var producerBuilder2 = new ProducerConfigBuilder <SimpleRecord2>() .Topic(_topic) .ProducerName("avroUpgradeSchema2"); var producer2 = _client.NewProducer(record2, producerBuilder2); producer2.NewMessage() .Value(new SimpleRecord2 { Name = "Ebere", Age = int.MaxValue, Surname = "Abanonu" }) .Send(); Thread.Sleep(TimeSpan.FromSeconds(10)); var msg = consumer1.Receive(); Assert.NotNull(msg); consumer1.Acknowledge(msg); consumer1.Unsubscribe(); producer.Close(); producer2.Close(); consumer.Close(); consumer1.Close(); }
public GenericAvroSchemaTest() { var avroFooV2Schema = AvroSchema <SchemaTestUtils.FooV2> .Of(ISchemaDefinition <SchemaTestUtils.FooV2> .Builder().WithAlwaysAllowNull(false).WithPojo(typeof(SchemaTestUtils.FooV2)).Build()); //var avroFooSchema = AvroSchema<SchemaTestUtils.Foo>.Of(ISchemaDefinition<SchemaTestUtils.Foo>.Builder().WithAlwaysAllowNull(false).WithPojo(typeof(SchemaTestUtils.Foo)).Build()); writerSchema = new GenericAvroSchema(avroFooV2Schema.SchemaInfo); readerSchema = new GenericAvroSchema(avroFooV2Schema.SchemaInfo); }
public void Start() { var clientConfig = new PulsarClientConfigBuilder() .ServiceUrl(_pulsarSettings.ServiceUrl) .ConnectionsPerBroker(1) .UseProxy(_pulsarSettings.UseProxy) .OperationTimeout(_pulsarSettings.OperationTimeout) .AllowTlsInsecureConnection(false) .ProxyServiceUrl(_pulsarSettings.ProxyServiceUrl, ProxyProtocol.SNI) .Authentication(new AuthenticationDisabled()) .ClientConfigurationData; _pulsarSystem = PulsarSystem.GetInstance(clientConfig); _schema = AvroSchema.Of(typeof(Echo.Common.Echo)); _producer = CreateProducer(); }
public void TestDateTimeDecimalLogicalType() { var avroSchema = AvroSchema <LogicalMessage> .Of(ISchemaDefinition <LogicalMessage> .Builder().WithPojo(typeof(LogicalMessage)).WithJSR310ConversionEnabled(true).Build()); var logMsg = new LogicalMessage { Schema = Avro.Schema.Parse(avroSchema.SchemaInfo.SchemaDefinition), CreatedTime = DateTime.Now, DayOfWeek = "Saturday", Size = new AvroDecimal(102.65M) }; var bytes1 = avroSchema.Encode(logMsg); Assert.True(bytes1.Length > 0); var msg = avroSchema.Decode(bytes1); Assert.NotNull(msg); Assert.True(msg.Size == 102.65M); }
private ISet <string> PublishMessages(string topic, int count) { ISet <string> keys = new HashSet <string>(); var builder = new ProducerConfigBuilder <DataOp>() .Topic(topic); var producer = _client.NewProducer(AvroSchema <DataOp> .Of(typeof(DataOp)), builder); for (var i = 0; i < count; i++) { var key = "key" + i; producer.NewMessage().Key(key).Value(new DataOp { Text = "my-sql-message-" + i }).Send(); keys.Add(key); } return(keys); }
public virtual void TestSeparatedKeyValueEncodingTypeSchemaEncodeAndDecode() { var fooSchema = AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).Build()); var barSchema = AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).Build()); var keyValueSchema = ISchema <object> .KeyValue(fooSchema, barSchema, KeyValueEncodingType.SEPARATED); var bar = new Bar { Field1 = true }; var foo = new Foo { Field1 = "field1", Field2 = "field2", Field3 = "3", Field4 = bar, Color = Color.RED }; // Check kv.encoding.type SEPARATED var encodeBytes = keyValueSchema.Encode(new KeyValue <Foo, Bar>(foo, bar)); Assert.True(encodeBytes.Length > 0); try { keyValueSchema.Decode(encodeBytes); Assert.True(false, "This method cannot be used under this SEPARATED encoding type"); } catch (SchemaSerializationException e) { Assert.Contains("This method cannot be used under this SEPARATED encoding type", e.Message); } var keyValue = ((KeyValueSchema <Foo, Bar>)keyValueSchema).Decode(fooSchema.Encode(foo), encodeBytes, null); var fooBack = keyValue.Key; var barBack = keyValue.Value; Assert.True(foo.Equals(fooBack)); Assert.True(bar.Equals(barBack)); }
public Worker(ILogger <Worker> logger, IHubContext <EchoHub> echo, PulsarSettings pulsarSettings) { _echo = echo; _logger = logger; var clientConfig = new PulsarClientConfigBuilder() .ServiceUrl(pulsarSettings.ServiceUrl) .ConnectionsPerBroker(1) .UseProxy(pulsarSettings.UseProxy) .OperationTimeout(pulsarSettings.OperationTimeout) .AllowTlsInsecureConnection(false) .ProxyServiceUrl(pulsarSettings.ProxyServiceUrl, ProxyProtocol.SNI) .Authentication(new AuthenticationDisabled()) .ClientConfigurationData; _topic = pulsarSettings.Topic; _pulsarSystem = PulsarSystem.GetInstance(clientConfig); _schema = AvroSchema.Of(typeof(Echo.Common.Echo)); _consumer = Consumer(pulsarSettings); }
public void TestAvroSchemaUserDefinedReadAndWriter() { var reader = new JsonReader <Foo>(); var writer = new JsonWriter <Foo>(); var schemaDefinition = ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Bar)).WithSchemaReader(reader).WithSchemaWriter(writer).Build(); var schema = AvroSchema <Foo> .Of(schemaDefinition); var foo = new Foo(); foo.Color = Color.RED; var field1 = "test"; foo.Field1 = field1; var encoded = schema.Encode(foo); foo = schema.Decode(encoded); Assert.Equal(Color.RED, foo.Color); Assert.Equal(field1, foo.Field1); }
public void TestLogicalType() { var avroSchema = AvroSchema <SchemaLogicalType> .Of(ISchemaDefinition <SchemaLogicalType> .Builder().WithPojo(typeof(SchemaLogicalType)).WithJSR310ConversionEnabled(true).Build()); var schemaLogicalType = new SchemaLogicalType { TimestampMicros = DateTimeHelper.CurrentUnixTimeMillis() * 1000, TimestampMillis = DateTime.Parse("2019-03-26T04:39:58.469Z").Ticks, Decimal = 12.34D, Date = DateTimeOffset.Now.ToUnixTimeMilliseconds(), TimeMicros = DateTimeHelper.CurrentUnixTimeMillis() * 1000, TimeMillis = (DateTime.Now - DateTime.Today).Ticks }; var bytes1 = avroSchema.Encode(schemaLogicalType); Assert.True(bytes1.Length > 0); var object1 = avroSchema.Decode(bytes1); Assert.True(schemaLogicalType.Equals(object1)); }
public virtual void TestAvroSchemaCreate() { var fooSchema = AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).WithAlwaysAllowNull(false).Build()); var barSchema = AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).WithAlwaysAllowNull(false).Build()); var keyValueSchema1 = ISchema <object> .KeyValue(fooSchema, barSchema); var keyValueSchema2 = ISchema <object> .KeyValue(AvroSchema <Foo> .Of(ISchemaDefinition <Foo> .Builder().WithPojo(typeof(Foo)).WithAlwaysAllowNull(false).Build()), AvroSchema <Bar> .Of(ISchemaDefinition <Bar> .Builder().WithPojo(typeof(Bar)).WithAlwaysAllowNull(false).Build())); Assert.Equal(keyValueSchema1.SchemaInfo.Type, SchemaType.KeyValue); Assert.Equal(keyValueSchema2.SchemaInfo.Type, SchemaType.KeyValue); Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema1).KeySchema.SchemaInfo.Type, SchemaType.AVRO); Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema1).ValueSchema.SchemaInfo.Type, SchemaType.AVRO); Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema2).KeySchema.SchemaInfo.Type, SchemaType.AVRO); Assert.Equal(((KeyValueSchema <Foo, Bar>)keyValueSchema2).ValueSchema.SchemaInfo.Type, SchemaType.AVRO); var schemaInfo1 = Encoding.UTF8.GetString(keyValueSchema1.SchemaInfo.Schema); var schemaInfo2 = Encoding.UTF8.GetString(keyValueSchema2.SchemaInfo.Schema); Assert.Equal(schemaInfo1, schemaInfo2); }
public void TestGenericTopic() { var schema = AvroSchema <ComplexGenericData> .Of(typeof(ComplexGenericData)); var genericSchema = GenericAvroSchema.Of(schema.SchemaInfo); _output.WriteLine(schema.SchemaInfo.SchemaDefinition); var pBuilder = new ProducerConfigBuilder <IGenericRecord>() .Topic(_topic); var producer = _client.NewProducer(genericSchema, pBuilder); const int messageCount = 10; for (var i = 0; i < messageCount; i++) { var dataForWriter = new GenericRecord((Avro.RecordSchema)genericSchema.AvroSchema); dataForWriter.Add("Feature", "Education"); dataForWriter.Add("StringData", new Dictionary <string, string> { { "Index", i.ToString() }, { "FirstName", "Ebere" }, { "LastName", "Abanonu" } }); dataForWriter.Add("ComplexData", ToBytes(new ComplexData { ProductId = i, Point = i * 2, Sales = i * 2 * 5 })); var record = new GenericAvroRecord(null, genericSchema.AvroSchema, genericSchema.Fields, dataForWriter); var receipt = producer.Send(record); _output.WriteLine(JsonSerializer.Serialize(receipt, new JsonSerializerOptions { WriteIndented = true })); } var messageReceived = 0; var builder = new ConsumerConfigBuilder <IGenericRecord>() .Topic(_topic) .ForceTopicCreation(true) .SubscriptionName($"generic_sub"); var consumer = _client.NewConsumer(ISchema <object> .AutoConsume(), builder); Thread.Sleep(TimeSpan.FromSeconds(5)); for (var i = 0; i < messageCount; ++i) { var m = consumer.Receive(); Assert.NotNull(m); var receivedMessage = m.Value; var feature = receivedMessage.GetField("Feature").ToString(); var strinData = (Dictionary <string, object>)receivedMessage.GetField("StringData"); var complexData = FromBytes <ComplexData>((byte[])receivedMessage.GetField("ComplexData")); _output.WriteLine(feature); _output.WriteLine(JsonSerializer.Serialize(strinData, new JsonSerializerOptions { WriteIndented = true })); _output.WriteLine(JsonSerializer.Serialize(complexData, new JsonSerializerOptions { WriteIndented = true })); messageReceived++; consumer.Acknowledge(m); } Assert.Equal(10, messageReceived); producer.Close(); consumer.Close(); }
private void PlainAvroProducer(string topic) { var jsonSchem = AvroSchema <JournalEntry> .Of(typeof(JournalEntry)); var builder = new ConsumerConfigBuilder <JournalEntry>() .Topic(topic) .SubscriptionName($"my-subscriber-name-{DateTimeHelper.CurrentUnixTimeMillis()}") .AckTimeout(TimeSpan.FromMilliseconds(20000)) .ForceTopicCreation(true) .AcknowledgmentGroupTime(0); var consumer = _client.NewConsumer(jsonSchem, builder); var producerConfig = new ProducerConfigBuilder <JournalEntry>() .ProducerName(topic.Split("/").Last()) .Topic(topic) .Schema(jsonSchem) .SendTimeout(10000); var producer = _client.NewProducer(jsonSchem, producerConfig); for (var i = 0; i < 10; i++) { var student = new Students { Name = $"[{i}] Ebere: {DateTimeOffset.Now.ToUnixTimeMilliseconds()} - presto-ed {DateTime.Now.ToString(CultureInfo.InvariantCulture)}", Age = 202 + i, School = "Akka-Pulsar university" }; var journal = new JournalEntry { Id = $"[{i}]Ebere: {DateTimeOffset.Now.ToUnixTimeMilliseconds()}", PersistenceId = "sampleActor", IsDeleted = false, Ordering = 0, Payload = Encoding.UTF8.GetBytes(JsonSerializer.Serialize(student)), SequenceNr = 0, Tags = "root" }; var metadata = new Dictionary <string, string> { ["Key"] = "Single", ["Properties"] = JsonSerializer.Serialize(new Dictionary <string, string> { { "Tick", DateTime.Now.Ticks.ToString() } }, new JsonSerializerOptions { WriteIndented = true }) }; var id = producer.NewMessage().Properties(metadata).Value(journal).Send(); } Thread.Sleep(TimeSpan.FromSeconds(5)); for (var i = 0; i < 10; i++) { var msg = consumer.Receive(); if (msg != null) { var receivedMessage = msg.Value; _output.WriteLine(JsonSerializer.Serialize(receivedMessage, new JsonSerializerOptions { WriteIndented = true })); } } }
public static ISchema <T> NewAvroSchema <T>(ISchemaDefinition <T> schemaDefinition) { return(AvroSchema <T> .Of(schemaDefinition)); }