public void TestTlsClientAuthOverBinaryProtocol()
{
_output.WriteLine($"-- Starting 'TestTlsClientAuthOverBinaryProtocol' test --");
InternalSetUpForNamespace();
// Test 1 - Using TLS on binary protocol without sending certs - expect failure
InternalSetUpForClient(false, "pulsar.BrokerServiceUrlTls");
try
{
_common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsClientAuthOverBinaryProtocol", "my-subscriber-name")); //pulsarClient.newConsumer().topic("persistent://my-property/use/my-ns/my-topic1").subscriptionName("my-subscriber-name").subscriptionType(SubscriptionType.Exclusive).subscribe();
//Assert.fail("Server should have failed the TLS handshake since client didn't .");
}
catch (Exception)
{
// OK
}
// Test 2 - Using TLS on binary protocol - sending certs
InternalSetUpForClient(true, "pulsar.BrokerServiceUrlTls");
try
{
_common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsClientAuthOverBinaryProtocol", "my-subscriber-name")); //pulsarClient.newConsumer().topic("persistent://my-property/use/my-ns/my-topic1").subscriptionName("my-subscriber-name").subscriptionType(SubscriptionType.Exclusive).subscribe();
}
catch (Exception)
{
//Assert.fail("Should not fail since certs are sent.");
}
}
/// <summary>
/// Builds a <see cref="BytesSchema" />.
/// </summary>
/// <returns>
/// A successful <see cref="SchemaBuilderCaseResult" /> with a <see cref="BytesSchema" />
/// if <paramref name="type" /> is <see cref="T:System.Byte[]" />; an unsuccessful
/// <see cref="SchemaBuilderCaseResult" /> with an <see cref="UnsupportedTypeException" />
/// otherwise.
/// </returns>
/// <inheritdoc />
public virtual SchemaBuilderCaseResult BuildSchema(Type type, SchemaBuilderContext context)
{
if (type == typeof(byte[]))
{
var bytesSchema = new BytesSchema();
Schema schema = bytesSchema;
if (!type.IsValueType && NullableReferenceTypeBehavior == NullableReferenceTypeBehavior.All)
{
if (!context.Schemas.TryGetValue(NullableType, out var nullSchema))
{
context.Schemas.Add(NullableType, nullSchema = new NullSchema());
}
schema = new UnionSchema(new[] { nullSchema, schema });
}
try
{
context.Schemas.Add(type, schema);
}
catch (ArgumentException exception)
{
throw new InvalidOperationException($"A schema for {type} already exists on the schema builder context.", exception);
}
return(SchemaBuilderCaseResult.FromSchema(schema));
}
else
{
return(SchemaBuilderCaseResult.FromException(new UnsupportedTypeException(type, $"{nameof(BytesSchemaBuilderCase)} can only be applied to the {typeof(byte[])} type.")));
}
}
/// <summary>
/// Builds a <see cref="BytesSchema" /> with a <see cref="DecimalLogicalType" />.
/// </summary>
/// <returns>
/// A successful <see cref="SchemaBuilderCaseResult" /> with a <see cref="BytesSchema" />
/// and associated <see cref="DecimalLogicalType" /> if <paramref name="type" /> is
/// <see cref="decimal" />; an unsuccessful <see cref="SchemaBuilderCaseResult" /> with an
/// <see cref="UnsupportedTypeException" /> otherwise.
/// </returns>
/// <inheritdoc />
public virtual SchemaBuilderCaseResult BuildSchema(Type type, SchemaBuilderContext context)
{
if (type == typeof(decimal))
{
var decimalSchema = new BytesSchema
{
// default precision/scale to .NET limits:
LogicalType = new DecimalLogicalType(29, 14),
};
try
{
context.Schemas.Add(type, decimalSchema);
}
catch (ArgumentException exception)
{
throw new InvalidOperationException($"A schema for {type} already exists on the schema builder context.", exception);
}
return(SchemaBuilderCaseResult.FromSchema(decimalSchema));
}
else
{
return(SchemaBuilderCaseResult.FromException(new UnsupportedTypeException(type, $"{nameof(DecimalSchemaBuilderCase)} can only be applied to the {typeof(decimal)} type.")));
}
}
public void UnresolvedSchema()
{
var writerSchema = new IntSchema();
var readerSchema = new BytesSchema();
Assert.Throws <AvroException>(() => new DatumWriter <string>(writerSchema));
Assert.Throws <AvroException>(() => new DatumReader <IList <byte> >(readerSchema, writerSchema));
}
public void ByteArrayValues(byte[] value)
{
var schema = new BytesSchema();
var deserializer = DeserializerBuilder.BuildDeserializer <byte[]>(schema);
var serializer = SerializerBuilder.BuildSerializer <byte[]>(schema);
Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value)));
}
public void NullableGuidValues(Guid value)
{
var schema = new BytesSchema();
var deserializer = DeserializerBuilder.BuildDeserializer <Guid?>(schema);
var serializer = SerializerBuilder.BuildSerializer <Guid>(schema);
Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value)));
}
public void BoundaryDecimalValues(decimal value)
{
var schema = new BytesSchema()
{
LogicalType = new DecimalLogicalType(29, 14)
};
var deserializer = DeserializerBuilder.BuildDeserializer <decimal>(schema);
var serializer = SerializerBuilder.BuildSerializer <decimal>(schema);
Assert.Equal(value, deserializer.Deserialize(serializer.Serialize(value)));
}
public void ResizedDecimalValues(int precision, int scale, decimal value, decimal rounded)
{
var schema = new BytesSchema()
{
LogicalType = new DecimalLogicalType(precision, scale)
};
var deserializer = DeserializerBuilder.BuildDeserializer <decimal>(schema);
var serializer = SerializerBuilder.BuildSerializer <decimal>(schema);
Assert.Equal(rounded, deserializer.Deserialize(serializer.Serialize(value)));
}
/// <summary>
/// Builds a byte array schema.
/// </summary>
/// <param name="resolution">
/// A type resolution.
/// </param>
/// <param name="cache">
/// A schema cache.
/// </param>
/// <returns>
/// A <see cref="BytesSchema" /> that matches the type resolution.
/// </returns>
/// <exception cref="ArgumentException">
/// Thrown when the resolution is not a <see cref="ByteArrayResolution" />.
/// </exception>
public override Schema BuildSchema(TypeResolution resolution, IDictionary <Type, Schema> cache)
{
if (!(resolution is ByteArrayResolution bytes))
{
throw new ArgumentException("The byte array case can only be applied to byte array resolutions.", nameof(resolution));
}
var schema = new BytesSchema();
cache.Add(bytes.Type, schema);
return(schema);
}
public void ZeroScaleDecimalValues(decimal value, byte[] encoding)
{
var schema = new BytesSchema()
{
LogicalType = new DecimalLogicalType(12, 0)
};
var serializer = SerializerBuilder.BuildSerializer <decimal>(schema);
Assert.Equal(encoding, serializer.Serialize(value));
var deserializer = DeserializerBuilder.BuildDeserializer <decimal>(schema);
Assert.Equal(value, deserializer.Deserialize(encoding));
}
public void EncodedDecimalValues(int precision, int scale, decimal value, byte[] encoding, decimal resizing)
{
var schema = new BytesSchema()
{
LogicalType = new DecimalLogicalType(precision, scale)
};
var serializer = SerializerBuilder.BuildSerializer <decimal>(schema);
Assert.Equal(encoding, serializer.Serialize(value));
var deserializer = DeserializerBuilder.BuildDeserializer <decimal>(schema);
Assert.Equal(resizing, deserializer.Deserialize(encoding));
}
/// <summary>
/// Writes an <see cref="PrimitiveSchema" />.
/// </summary>
/// <inheritdoc />
public virtual JsonSchemaWriterCaseResult Write(Schema schema, Utf8JsonWriter json, bool canonical, JsonSchemaWriterContext context)
{
if (schema is PrimitiveSchema primitiveSchema)
{
json.WriteStringValue(primitiveSchema switch
{
BooleanSchema _ => JsonSchemaToken.Boolean,
BytesSchema _ => JsonSchemaToken.Bytes,
DoubleSchema _ => JsonSchemaToken.Double,
FloatSchema _ => JsonSchemaToken.Float,
IntSchema _ => JsonSchemaToken.Int,
LongSchema _ => JsonSchemaToken.Long,
NullSchema _ => JsonSchemaToken.Null,
StringSchema _ => JsonSchemaToken.String,
_ => throw new UnsupportedSchemaException(schema, $"Unknown primitive schema {schema}."),
});
public void NullableGuidValues(Guid value)
{
var schema = new BytesSchema();
var deserialize = deserializerBuilder.BuildDelegate <Guid?>(schema);
var serialize = serializerBuilder.BuildDelegate <Guid>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void DynamicByteArrayValues(byte[] value)
{
var schema = new BytesSchema();
var deserialize = deserializerBuilder.BuildDelegate <dynamic>(schema);
var serialize = serializerBuilder.BuildDelegate <dynamic>(schema);
using (stream)
{
serialize(value, new BinaryWriter(stream));
}
var reader = new BinaryReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
/// <summary>
/// Builds a decimal schema.
/// </summary>
/// <param name="resolution">
/// A type resolution.
/// </param>
/// <param name="cache">
/// A schema cache.
/// </param>
/// <returns>
/// A <see cref="BytesSchema" /> with a <see cref="DecimalLogicalType" /> that matches the
/// type resolution.
/// </returns>
/// <exception cref="ArgumentException">
/// Thrown when the resolution is not a <see cref="DecimalResolution" />.
/// </exception>
public override Schema BuildSchema(TypeResolution resolution, IDictionary <Type, Schema> cache)
{
if (!(resolution is DecimalResolution @decimal))
{
throw new ArgumentException("The decimal case can only be applied to decimal resolutions.", nameof(resolution));
}
var schema = new BytesSchema()
{
LogicalType = new DecimalLogicalType(@decimal.Precision, @decimal.Scale)
};
cache.Add(@decimal.Type, schema);
return(schema);
}
public void TestTlsCertsFromDynamicStreamExpiredAndRenewCert()
{
AtomicInteger certIndex = new AtomicInteger(1);
AtomicInteger keyIndex = new AtomicInteger(0);
MemoryStream certStream = CreateByteInputStream(TlsClientCertFilePath);
MemoryStream keyStream = CreateByteInputStream(TlsClientKeyFilePath);
Func <MemoryStream> certProvider = () => GetStream(certIndex, certStream, keyStream);
Func <MemoryStream> keyProvider = () => GetStream(keyIndex, keyStream);
AuthenticationTls auth = new AuthenticationTls(certProvider, keyProvider);
_common.GetPulsarSystem(auth, 1000, enableTls: true, brokerService: "pulsar.BrokerServiceUrlTls");
_common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsCertsFromDynamicStreamExpiredAndRenewCert", "my-subscriber-name"));
certIndex.SetValue(0);
_common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsCertsFromDynamicStreamExpiredAndRenewCert", "my-subscriber-name"));
}
public void ResizedDecimalValues(int precision, int scale, decimal value, decimal resizing)
{
var schema = new BytesSchema()
{
LogicalType = new DecimalLogicalType(precision, scale),
};
var deserialize = deserializerBuilder.BuildDelegate <decimal>(schema);
var serialize = serializerBuilder.BuildDelegate <decimal>(schema);
using (stream)
{
serialize(value, new Utf8JsonWriter(stream));
}
var reader = new Utf8JsonReader(stream.ToArray());
Assert.Equal(resizing, deserialize(ref reader));
}
public void DynamicDecimalValues(decimal value)
{
var schema = new BytesSchema()
{
LogicalType = new DecimalLogicalType(29, 14),
};
var deserialize = deserializerBuilder.BuildDelegate <dynamic>(schema);
var serialize = serializerBuilder.BuildDelegate <dynamic>(schema);
using (stream)
{
serialize(value, new Utf8JsonWriter(stream));
}
var reader = new Utf8JsonReader(stream.ToArray());
Assert.Equal(value, deserialize(ref reader));
}
public void TestTlsCertsFromDynamicStream()
{
string topicName = "persistent://my-property/use/my-ns/my-topic1";
AtomicInteger index = new AtomicInteger(0);
MemoryStream certStream = CreateByteInputStream(TlsClientCertFilePath);
MemoryStream keyStream = CreateByteInputStream(TlsClientKeyFilePath);
Func <MemoryStream> certProvider = () => GetStream(index, certStream);
Func <MemoryStream> keyProvider = () => GetStream(index, keyStream);
AuthenticationTls auth = new AuthenticationTls(certProvider, keyProvider);
_common.GetPulsarSystem(auth, 1000, enableTls: true, brokerService: "pulsar.BrokerServiceUrlTls");
_common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), topicName, "TestTlsCertsFromDynamicStream", "my-subscriber-name"));
// unload the topic so, new connection will be made and read the cert streams again
var producer = _common.PulsarSystem.PulsarProducer(_common.CreateProducer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", ""));
for (int i = 0; i < 10; i++)
{
var send = new Send(("test" + i).GetBytes(), ImmutableDictionary <string, object> .Empty);
_common.PulsarSystem.Send(send, producer.Producer);
}
ConsumedMessage msg = null;
for (var i = 0; i < 10; i++)
{
msg = _common.PulsarSystem.Receive("TestTlsCertsFromDynamicStream", 5000);
var exepctedMsg = "test" + i;
var data = (byte[])(object)msg.Message.Data;
Assert.Equal(exepctedMsg.GetBytes(), data);
}
// Acknowledge the consumption of all messages at once
_common.PulsarSystem.AcknowledgeCumulative(msg);
}
public void TestBytesSchemaOf()
{
TestBytesSchema(BytesSchema.Of());
}
private void VisitCore(BytesSchema s)
{
s.Serializer = new ByteArraySerializer(s);
}
public void TestTlsLargeSizeMessage()
{
_output.WriteLine($"-- Starting 'TestTlsLargeSizeMessage' test --");
const int messageSize = 16 * 1024 + 1;
InternalSetUpForClient(true, "pulsar.BrokerServiceUrlTls");
InternalSetUpForNamespace();
var consumer = _common.PulsarSystem.PulsarConsumer(_common.CreateConsumer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsLargeSizeMessage", "my-subscriber-name"));
var producer = _common.PulsarSystem.PulsarProducer(_common.CreateProducer(BytesSchema.Of(), "persistent://my-property/use/my-ns/my-topic1", "TestTlsLargeSizeMessage"));
for (int i = 0; i < 10; i++)
{
var message = new byte[messageSize];
Array.Fill(message, (byte)i);
var send = new Send(message, ImmutableDictionary <string, object> .Empty);
_common.PulsarSystem.Send(send, producer.Producer);
}
ConsumedMessage msg = null;
for (int i = 0; i < 10; i++)
{
msg = _common.PulsarSystem.Receive("", 5000);
var expected = new byte[messageSize];
Array.Fill(expected, (byte)i);
var data = (byte[])(object)msg.Message.Data;
Assert.Equal(expected, data);
}
// Acknowledge the consumption of all messages at once
_common.PulsarSystem.AcknowledgeCumulative(msg);
_output.WriteLine($"-- Exiting 'TestTlsLargeSizeMessage' test --");
}
