/// <summary>
/// Registers a middleware to deserialize avro messages using schema registry
/// </summary>
/// <param name="middlewares">The middleware configuration builder</param>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddSchemaRegistryAvroSerializer(
this IConsumerMiddlewareConfigurationBuilder middlewares)
{
return(middlewares.AddSerializer(
resolver => new ConfluentAvroSerializer(resolver),
resolver => new SchemaRegistryTypeResolver(new ConfluentAvroTypeNameResolver(resolver.Resolve <ISchemaRegistryClient>()))));
}
/// <summary>
/// Registers a middleware to deserialize json messages using schema registry
/// </summary>
/// <param name="middlewares">The middleware configuration builder</param>
/// <typeparam name="TMessage">The message type</typeparam>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddSchemaRegistryJsonSerializer <TMessage>(
this IConsumerMiddlewareConfigurationBuilder middlewares)
{
return(middlewares.AddSerializer(
resolver => new ConfluentJsonSerializer(resolver),
_ => new SingleMessageTypeResolver(typeof(TMessage))));
}
/// <summary>
/// Registers a middleware to decompress the message
/// </summary>
/// <param name="middlewares"></param>
/// <param name="factory">A factory to create the <see cref="IMessageCompressor"/> instance</param>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddCompressor <T>(
this IConsumerMiddlewareConfigurationBuilder middlewares,
Factory <T> factory)
where T : class, IMessageCompressor
{
return(middlewares.Add(resolver => new CompressorConsumerMiddleware(factory(resolver))));
}
/// <summary>
/// Registers a middleware to deserialize messages
/// </summary>
/// <typeparam name="TSerializer">A class that implements <see cref="IMessageSerializer"/></typeparam>
public static IConsumerMiddlewareConfigurationBuilder AddSerializer <TSerializer>(
this IConsumerMiddlewareConfigurationBuilder consumer)
where TSerializer : class, IMessageSerializer
{
return(consumer.AddSerializer(
resolver => resolver.Resolve <TSerializer>(),
resolver => resolver.Resolve <DefaultMessageTypeResolver>()));
}
/// <summary>
/// Register a middleware to deserialize the message to a fixed type
/// </summary>
/// <param name="middlewares">The middleware configuration builder</param>
/// <param name="serializerFactory">A factory to create a <see cref="ISerializer"/></param>
/// <typeparam name="TMessage">The message type</typeparam>
/// <typeparam name="TSerializer">A class that implements <see cref="ISerializer"/></typeparam>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddSingleTypeSerializer <TMessage, TSerializer>(
this IConsumerMiddlewareConfigurationBuilder middlewares,
Factory <TSerializer> serializerFactory)
where TSerializer : class, ISerializer
{
return(middlewares.AddSerializer(
serializerFactory,
_ => new SingleMessageTypeResolver(typeof(TMessage))));
}
/// <summary>
/// Register a middleware to deserialize messages
/// </summary>
/// <typeparam name="TSerializer">A class that implements <see cref="IMessageSerializer"/></typeparam>
/// <param name="middlewares"></param>
/// <param name="serializerFactory">A factory to create a <see cref="IMessageSerializer"/></param>
public static IConsumerMiddlewareConfigurationBuilder AddSerializer <TSerializer>(
this IConsumerMiddlewareConfigurationBuilder middlewares,
Factory <TSerializer> serializerFactory)
where TSerializer : class, IMessageSerializer
{
return(middlewares.AddSerializer(
serializerFactory,
resolver => new DefaultMessageTypeResolver()));
}
/// <summary>
/// Register a middleware to deserialize the message to a fixed type
/// </summary>
/// <param name="consumer"></param>
/// <param name="serializerFactory">A factory to create a <see cref="IMessageSerializer"/></param>
/// <typeparam name="TMessage">The message type</typeparam>
/// <typeparam name="TSerializer">A class that implements <see cref="IMessageSerializer"/></typeparam>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddSingleTypeSerializer <TMessage, TSerializer>(
this IConsumerMiddlewareConfigurationBuilder consumer,
Factory <TSerializer> serializerFactory)
where TSerializer : class, IMessageSerializer
{
return(consumer.AddSerializer(
serializerFactory,
resolver => resolver.Resolve <SingleMessageTypeResolver <TMessage> >()));
}
/// <summary>
/// Registers a middleware to deserialize messages
/// </summary>
/// <typeparam name="TSerializer">A class that implements <see cref="IMessageSerializer"/></typeparam>
public static IConsumerMiddlewareConfigurationBuilder AddSerializer <TSerializer>(
this IConsumerMiddlewareConfigurationBuilder middlewares)
where TSerializer : class, IMessageSerializer
{
middlewares.DependencyConfigurator.AddTransient <TSerializer>();
return(middlewares.AddSerializer(
resolver => resolver.Resolve <TSerializer>(),
resolver => new DefaultMessageTypeResolver()));
}
/// <summary>
/// Register a middleware to deserialize the message to a fixed type
/// </summary>
/// <param name="middlewares">The middleware configuration builder</param>
/// <param name="messageType">The message type</param>
/// <typeparam name="TSerializer">A class that implements <see cref="ISerializer"/></typeparam>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddSingleTypeSerializer <TSerializer>(
this IConsumerMiddlewareConfigurationBuilder middlewares,
Type messageType)
where TSerializer : class, ISerializer
{
middlewares.DependencyConfigurator.AddTransient <TSerializer>();
return(middlewares.AddSerializer(
resolver => resolver.Resolve <TSerializer>(),
_ => new SingleMessageTypeResolver(messageType)));
}
/// <summary>
/// Register a middleware to decompress the message
/// </summary>
/// <typeparam name="T">A class that implements <see cref="IMessageCompressor"/></typeparam>
/// <param name="middlewares"></param>
/// <param name="factory">A factory to create the <see cref="IMessageCompressor"/> instance</param>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddCompressor <T>(
this IConsumerMiddlewareConfigurationBuilder middlewares,
Factory <T> factory)
where T : class, IMessageCompressor
{
middlewares.DependencyConfigurator.AddSingleton <IMessageCompressor, T>();
middlewares.DependencyConfigurator.AddSingleton <T>();
return(middlewares.Add(
provider => new CompressorConsumerMiddleware(factory(provider))));
}
/// <summary>
/// Accumulates a group of messages to be passed as a batch to the next middleware as just one message
/// </summary>
/// <param name="builder">The configuration builder</param>
/// <param name="batchSize">The maximum size of the batch, when this limit is reached the next middleware will be called</param>
/// <param name="batchTimeout">The maximum time the middleware will wait to call the next middleware</param>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder BatchConsume(
this IConsumerMiddlewareConfigurationBuilder builder,
int batchSize,
TimeSpan batchTimeout)
{
return(builder.Add(
resolver => new BatchConsumeMiddleware(
batchSize,
batchTimeout,
resolver.Resolve <ILogHandler>()),
MiddlewareLifetime.Worker));
}
/// <summary>
/// Register a middleware to deserialize messages
/// </summary>
/// <typeparam name="TSerializer">A class that implements <see cref="IMessageSerializer"/></typeparam>
/// <typeparam name="TResolver">A class that implements <see cref="IMessageTypeResolver"/></typeparam>
/// <param name="middlewares"></param>
/// <param name="serializerFactory">A factory to create a <see cref="IMessageSerializer"/></param>
/// <param name="resolverFactory">A factory to create a <see cref="IMessageTypeResolver"/></param>
public static IConsumerMiddlewareConfigurationBuilder AddSerializer <TSerializer, TResolver>(
this IConsumerMiddlewareConfigurationBuilder middlewares,
Factory <TSerializer> serializerFactory,
Factory <TResolver> resolverFactory)
where TSerializer : class, IMessageSerializer
where TResolver : class, IMessageTypeResolver
{
return(middlewares.Add(
resolver => new SerializerConsumerMiddleware(
serializerFactory(resolver),
resolverFactory(resolver))));
}
/// <summary>
/// Adds typed handler middleware
/// </summary>
/// <param name="builder">Instance of <see cref="IConsumerMiddlewareConfigurationBuilder"/></param>
/// <param name="configure">A handler to configure the middleware</param>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddTypedHandlers(
this IConsumerMiddlewareConfigurationBuilder builder,
Action <TypedHandlerConfigurationBuilder> configure)
{
var typedHandlerBuilder = new TypedHandlerConfigurationBuilder(builder.DependencyConfigurator);
configure(typedHandlerBuilder);
var configuration = typedHandlerBuilder.Build();
builder.DependencyConfigurator.AddSingleton(configuration);
builder.Add(resolver => new TypedHandlerMiddleware(resolver, configuration));
return(builder);
}
/// <summary>
/// Register a middleware to deserialize messages
/// </summary>
/// <typeparam name="TSerializer">A class that implements <see cref="IMessageSerializer"/></typeparam>
/// <typeparam name="TResolver">A class that implements <see cref="IMessageTypeResolver"/></typeparam>
/// <param name="middlewares"></param>
/// <param name="serializerFactory">A factory to create a <see cref="IMessageSerializer"/></param>
/// <param name="resolverFactory">A factory to create a <see cref="IMessageTypeResolver"/></param>
public static IConsumerMiddlewareConfigurationBuilder AddSerializer <TSerializer, TResolver>(
this IConsumerMiddlewareConfigurationBuilder middlewares,
Factory <TSerializer> serializerFactory,
Factory <TResolver> resolverFactory)
where TSerializer : class, IMessageSerializer
where TResolver : class, IMessageTypeResolver
{
middlewares.DependencyConfigurator.AddSingleton <IMessageSerializer, TSerializer>();
middlewares.DependencyConfigurator.AddSingleton <IMessageTypeResolver, TResolver>();
middlewares.DependencyConfigurator.AddSingleton <TSerializer>();
middlewares.DependencyConfigurator.AddSingleton <TResolver>();
return(middlewares.Add(
provider => new SerializerConsumerMiddleware(
serializerFactory(provider),
resolverFactory(provider))));
}
public ConsumerConfigurationBuilder(IDependencyConfigurator dependencyConfigurator)
{
this.DependencyConfigurator = dependencyConfigurator;
this.middlewareConfigurationBuilder = new ConsumerMiddlewareConfigurationBuilder(dependencyConfigurator);
}
/// <summary>
/// Register a middleware to decompress the message
/// </summary>
/// <typeparam name="T">A class that implements <see cref="IMessageCompressor"/></typeparam>
public static IConsumerMiddlewareConfigurationBuilder AddCompressor <T>(
this IConsumerMiddlewareConfigurationBuilder middlewares)
where T : class, IMessageCompressor
{
return(middlewares.AddCompressor(resolver => resolver.Resolve <T>()));
}
/// <summary>
/// Register a middleware to deserialize the message to a fixed type
/// </summary>
/// <param name="middlewares"></param>
/// <typeparam name="TSerializer">A class that implements <see cref="IMessageSerializer"/></typeparam>
/// <typeparam name="TMessage">The message type</typeparam>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddSingleTypeSerializer <TMessage, TSerializer>(
this IConsumerMiddlewareConfigurationBuilder middlewares)
where TSerializer : class, IMessageSerializer
{
return(middlewares.AddSerializer <TSerializer, SingleMessageTypeResolver <TMessage> >());
}
/// <summary>
/// Registers a middleware to decompress the message
/// </summary>
public static IConsumerMiddlewareConfigurationBuilder AddCompressor <T>(this IConsumerMiddlewareConfigurationBuilder middlewares)
where T : class, IMessageCompressor
{
middlewares.DependencyConfigurator.AddTransient <T>();
return(middlewares.AddCompressor(resolver => resolver.Resolve <T>()));
}
/// <summary>
/// Register a middleware to deserialize the message to a fixed type
/// </summary>
/// <param name="middlewares">The middleware configuration builder</param>
/// <typeparam name="TMessage">The message type</typeparam>
/// <typeparam name="TSerializer">A class that implements <see cref="ISerializer"/></typeparam>
/// <returns></returns>
public static IConsumerMiddlewareConfigurationBuilder AddSingleTypeSerializer <TMessage, TSerializer>(
this IConsumerMiddlewareConfigurationBuilder middlewares)
where TSerializer : class, ISerializer
{
return(middlewares.AddSingleTypeSerializer <TSerializer>(typeof(TMessage)));
}
