/// <summary>
/// Adds the specified batch handler
/// </summary>
/// <typeparam name="T">The type that the handler handles</typeparam>
/// <typeparam name="TBatchHandler">The type of the batch handler to add</typeparam>
/// <param name="messagingBuilder">The OpenMessageBuilder</param>
/// <returns>The OpenMessageBuilder</returns>
public static IMessagingBuilder ConfigureBatchHandler <T, TBatchHandler>(this IMessagingBuilder messagingBuilder)
where TBatchHandler : class, IBatchHandler <T>
{
messagingBuilder.Services.AddScoped <IBatchHandler <T>, TBatchHandler>();
return(messagingBuilder);
}
public static IKafkaMessagingBuilder WithKafkaTransport(this IMessagingBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (builder.Container == null)
{
throw new ArgumentNullException(nameof(builder.Container));
}
if (builder.HasProducer)
{
builder.Container.RegisterSingleton <SchemaSerializerProvider>();
builder.Container.AppendToCollection(typeof(ISchemaSerializerFactory), typeof(DefaultSchemaSerdesFactory));
builder.Container.Register(typeof(ISchemaProducerFactory), typeof(SchemaProducerFactory), Lifestyle.Singleton);
builder.Container.AppendToCollection(typeof(IProducer), typeof(KafkaProducer));
}
if (builder.HasConsumer)
{
builder.Container.RegisterSingleton <IConsumerService, KafkaConsumerService>();
builder.Container.RegisterSingleton <SchemaDeserializerProvider>();
builder.Container.AppendToCollection(typeof(ISchemaDeserializerFactory), typeof(DefaultSchemaSerdesFactory));
builder.Container.Register(typeof(ISchemaConsumerFactory), typeof(SchemaConsumerFactory), Lifestyle.Singleton);
}
return(new KafkaMessagingBuilder(builder));
}
/// <summary>
/// Adds the ServiceStackJson serializer
/// </summary>
/// <param name="messagingBuilder">The host to configure</param>
/// <returns>The modified builder</returns>
public static IMessagingBuilder ConfigureServiceStackJsonSerializer(this IMessagingBuilder messagingBuilder)
{
messagingBuilder.Services.TryAddSingleton <ServiceStackSerializer>();
messagingBuilder.Services.AddSerialization()
.AddSingleton <ISerializer>(sp => sp.GetRequiredService <ServiceStackSerializer>());
return(messagingBuilder);
}
/// <summary>
/// Configures a default pipeline
/// </summary>
/// <param name="messagingBuilder">The OpenMessage builder</param>
/// <typeparam name="T">The type that the handler handles</typeparam>
public static void TryConfigureDefaultPipeline <T>(this IMessagingBuilder messagingBuilder)
{
if (messagingBuilder.Services.Any(x => x.ServiceType == typeof(IPipelineBuilder <T>)))
{
return;
}
messagingBuilder.Services.TryAddSingleton <IPipelineBuilder <T> >(new PipelineBuilder <T>(messagingBuilder).UseDefaultMiddleware());
}
/// <summary>
/// Adds the Protobuf deserializer
/// </summary>
/// <param name="messagingBuilder">The host to configure</param>
/// <returns>The modified builder</returns>
public static IMessagingBuilder ConfigureProtobufDeserializer(this IMessagingBuilder messagingBuilder)
{
messagingBuilder.Services.TryAddSingleton <ProtobufSerializer>();
messagingBuilder.Services.AddSerialization()
.AddSingleton <IDeserializer>(sp => sp.GetRequiredService <ProtobufSerializer>());
return(messagingBuilder);
}
/// <summary>
/// Adds both the JsonDotNet serializer & deserializer
/// </summary>
/// <param name="builder">The service collection to modify</param>
/// <param name="serializerConfigurator">Configure the serializer options</param>
/// <param name="deserializerConfigurator">Configure the deserializer options</param>
/// <returns>The modified service collection</returns>
public static IMessagingBuilder ConfigureJsonDotNet(this IMessagingBuilder builder, Action <JsonSerializerSettings>?serializerConfigurator = null, Action <JsonSerializerSettings>?deserializerConfigurator = null)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
return(builder.ConfigureJsonDotNetDeserializer(deserializerConfigurator)
.ConfigureJsonDotNetSerializer(serializerConfigurator));
}
public static IMessagingBuilder WithHttpTransport(this IMessagingBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (builder.Container == null)
{
throw new ArgumentNullException(nameof(builder.Container));
}
builder.Container.AppendToCollection(typeof(IProducer), typeof(HttpProducer));
return(builder);
}
public static IMessagingBuilder Configure(this IMessagingBuilder messagingBuilder, Action <MessagingOptions> configuration)
{
if (messagingBuilder == null)
{
throw new ArgumentNullException(nameof(messagingBuilder));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
messagingBuilder.Services.Configure(configuration);
return(messagingBuilder);
}
/// <summary>
/// Adds the JsonDotNet serializer only.
/// </summary>
/// <param name="builder">The service collection to modify</param>
/// <param name="configurator">Configure the serializer options</param>
/// <returns>The modified service collection</returns>
public static IMessagingBuilder ConfigureJsonDotNetSerializer(this IMessagingBuilder builder, Action <JsonSerializerSettings>?configurator = null)
{
if (builder is null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Services.AddSerialization()
.AddSerializer <JsonDotNetSerializer>()
.Configure <JsonSerializerSettings>(SerializationConstants.SerializerSettings, settings =>
{
settings.NullValueHandling = NullValueHandling.Ignore;
configurator?.Invoke(settings);
});;
return(builder);
}
/// <summary> /// ctor /// </summary> public Builder(IMessagingBuilder hostBuilder) => HostBuilder = hostBuilder ?? throw new ArgumentNullException(nameof(hostBuilder));
/// <summary>
/// Adds a kafka dispatcher
/// </summary>
/// <param name="messagingBuilder">The host builder</param>
/// <param name="options">Options for the dispatcher</param>
/// <typeparam name="T">The type to dispatch</typeparam>
/// <returns>The modified builder</returns>
public static IMessagingBuilder ConfigureKafkaDispatcher <T>(this IMessagingBuilder messagingBuilder, Action <KafkaOptions <T> >?options = null)
{
if (options is {})
/// <summary> /// Adds a kafka consumer /// </summary> /// <param name="messagingBuilder">The host builder</param> /// <typeparam name="TKey">The type of the key</typeparam> /// <typeparam name="TValue">The type of the message</typeparam> /// <returns>The modified builder</returns> public static IKafkaConsumerBuilder <TKey, TValue> ConfigureKafkaConsumer <TKey, TValue>(this IMessagingBuilder messagingBuilder) => new KafkaConsumerBuilder <TKey, TValue>(messagingBuilder);
/// <summary> /// Adds a kafka consumer /// </summary> /// <param name="messagingBuilder">The host builder</param> /// <typeparam name="T">The type to consume</typeparam> /// <returns>The modified builder</returns> public static IKafkaConsumerBuilder <string, T> ConfigureKafkaConsumer <T>(this IMessagingBuilder messagingBuilder) => messagingBuilder.ConfigureKafkaConsumer <string, T>();
/// <summary> /// Adds the Wire serializer & deserializer /// </summary> /// <param name="messagingBuilder">The host to configure</param> /// <returns>The modified builder</returns> public static IMessagingBuilder ConfigureWire(this IMessagingBuilder messagingBuilder) => messagingBuilder.ConfigureWireDeserializer() .ConfigureWireSerializer();
/// <summary>
/// Adds the specified handler
/// </summary>
/// <param name="messagingBuilder">The OpenMessage builder</param>
/// <param name="instance">The handler to use</param>
/// <typeparam name="T">The type that the handler handles</typeparam>
/// <returns>The OpenMessageBuilder</returns>
public static IMessagingBuilder ConfigureHandler <T>(this IMessagingBuilder messagingBuilder, IHandler <T> instance)
{
messagingBuilder.Services.AddSingleton(instance);
return(messagingBuilder);
}
public PipelineBuilder(IMessagingBuilder builder)
{
_builder = builder;
_builder.Services.AddSingleton <IPipelineBuilder <T> >(this);
}
/// <summary>
/// Adds the specified handler
/// </summary>
/// <param name="messagingBuilder">The OpenMessage builder</param>
/// <param name="action">The implementation of the handler</param>
/// <typeparam name="T">The type that the handler handles</typeparam>
/// <returns>The OpenMessageBuilder</returns>
public static IMessagingBuilder ConfigureHandler <T>(this IMessagingBuilder messagingBuilder, Func <Message <T>, Task> action)
{
messagingBuilder.Services.AddSingleton <IHandler <T> >(sp => ActivatorUtilities.CreateInstance <ActionHandler <T> >(sp, action));
return(messagingBuilder);
}
/// <summary>
/// Configures the pipeline for a specified type.
/// </summary>
/// <param name="messagingBuilder">The OpenMessage builder</param>
/// <param name="configurator">The configuration to use</param>
/// <typeparam name="T">The type that the handler handles</typeparam>
/// <returns>The OpenMessage builder</returns>
public static IPipelineBuilder <T> ConfigurePipeline <T>(this IMessagingBuilder messagingBuilder, Action <PipelineOptions <T> >?configurator = null)
{
return(ConfigurePipeline <T>(messagingBuilder, (_, options) => configurator?.Invoke(options)));
}
/// <summary>
/// Configures the pipeline for a specified type.
/// </summary>
/// <param name="messagingBuilder">The OpenMessage builder</param>
/// <param name="configurator">The configuration to use</param>
/// <typeparam name="T">The type that the handler handles</typeparam>
/// <returns>The OpenMessage builder</returns>
public static IPipelineBuilder <T> ConfigurePipeline <T>(this IMessagingBuilder messagingBuilder, Action <HostBuilderContext, PipelineOptions <T> > configurator)
{
if (configurator is {})
public KafkaMessagingBuilder(IMessagingBuilder builder)
{
Container = builder.Container;
HasConsumer = builder.HasConsumer;
HasProducer = builder.HasProducer;
}
/// <summary> /// Adds the Jil serializer & deserializer /// </summary> /// <param name="messagingBuilder">The host to configure</param> /// <returns>The modified builder</returns> public static IMessagingBuilder ConfigureJil(this IMessagingBuilder messagingBuilder) => messagingBuilder.ConfigureJilDeserializer() .ConfigureJilSerializer();
public SqsConsumerBuilder(IMessagingBuilder hostBuilder)
: base(hostBuilder)
{
}
public SqsDispatcherBuilder(IMessagingBuilder hostBuilder)
: base(hostBuilder)
{
}
/// <summary>
/// Adds an InMemory consumer and dispatcher
/// </summary>
/// <param name="builder">The current host builder</param>
/// <typeparam name="T">The type to handle</typeparam>
/// <returns>An instance of <see cref="IMemoryProviderBuilder{T}" /></returns>
public static IMemoryProviderBuilder <T> ConfigureMemory <T>(this IMessagingBuilder builder) => new MemoryProviderBuilder <T>(builder);
/// <summary> /// Adds the ServiceStackJson serializer & deserializer /// </summary> /// <param name="messagingBuilder">The host to configure</param> /// <returns>The modified builder</returns> public static IMessagingBuilder ConfigureServiceStackJson(this IMessagingBuilder messagingBuilder) => messagingBuilder.ConfigureServiceStackJsonDeserializer() .ConfigureServiceStackJsonSerializer();
/// <summary> /// Returns an SQS consumer builder /// </summary> /// <param name="messagingBuilder">The host the consumer belongs to</param> /// <typeparam name="T">The type of message to consume</typeparam> /// <returns>An SQS consumer builder</returns> public static ISqsConsumerBuilder <T> ConfigureSqsConsumer <T>(this IMessagingBuilder messagingBuilder) => new SqsConsumerBuilder <T>(messagingBuilder);
/// <summary> /// Returns an SQS dispatcher builder /// </summary> /// <param name="messagingBuilder">The host the dispatcher belongs to</param> /// <typeparam name="T">The type of message to dispatch</typeparam> /// <returns>An SQS dispatcher builder</returns> public static ISqsDispatcherBuilder <T> ConfigureSqsDispatcher <T>(this IMessagingBuilder messagingBuilder) => new SqsDispatcherBuilder <T>(messagingBuilder);
/// <summary> /// Adds the Protobuf serializer & deserializer /// </summary> /// <param name="messagingBuilder">The host to configure</param> /// <returns>The modified builder</returns> public static IMessagingBuilder ConfigureProtobuf(this IMessagingBuilder messagingBuilder) => messagingBuilder.ConfigureProtobufDeserializer() .ConfigureProtobufSerializer();
public KafkaConsumerBuilder(IMessagingBuilder hostBuilder)
: base(hostBuilder)
{
}
/// <summary> /// Adds a kafka consumer /// </summary> /// <param name="messagingBuilder">The host builder</param> /// <typeparam name="TKey">The type of the key</typeparam> /// <typeparam name="TValue">The type of the message</typeparam> /// <returns>The modified builder</returns> public static IKafkaConsumerBuilder <TKey, TValue> ConfigureKafkaConsumer <TKey, TValue>(this IMessagingBuilder messagingBuilder) where TKey : class where TValue : class => new KafkaConsumerBuilder <TKey, TValue>(messagingBuilder);
