public ReaderChannelFactory(
Guid correlationId,
IRegisterEvent eventRegister,
IConnectionPool connectionPool,
IExecute executor,
ReaderOptions options)
{
_correlationId = correlationId;
_eventRegister = eventRegister;
_connectionPool = connectionPool;
_executor = executor;
_messagePrefetchCount = options.MessagePrefetchCount;
_subscribe = new CommandSubscribe
{
ConsumerName = options.ReaderName,
Durable = false,
ReadCompacted = options.ReadCompacted,
StartMessageId = options.StartMessageId.Data,
Subscription = "Reader-" + Guid.NewGuid().ToString("N"),
Topic = options.Topic
};
_batchHandler = new BatchHandler(false);
}
public ConsumerChannelFactory(
Guid correlationId,
IRegisterEvent eventRegister,
IConnectionPool connectionPool,
IExecute executor,
ConsumerOptions options)
{
_correlationId = correlationId;
_eventRegister = eventRegister;
_connectionPool = connectionPool;
_executor = executor;
_messagePrefetchCount = options.MessagePrefetchCount;
_subscribe = new CommandSubscribe
{
ConsumerName = options.ConsumerName,
InitialPosition = (CommandSubscribe.InitialPositionType)options.InitialPosition,
PriorityLevel = options.PriorityLevel,
ReadCompacted = options.ReadCompacted,
Subscription = options.SubscriptionName,
Topic = options.Topic,
Type = (CommandSubscribe.SubType)options.SubscriptionType
};
_batchHandler = new BatchHandler(true);
}
/// <summary>
/// Create a reader.
/// </summary>
public IReader CreateReader(ReaderOptions options)
{
ThrowIfDisposed();
var correlationId = Guid.NewGuid();
var executor = new Executor(correlationId, _processManager, _exceptionHandler);
var subscribe = new CommandSubscribe
{
ConsumerName = options.ReaderName,
Durable = false,
ReadCompacted = options.ReadCompacted,
StartMessageId = options.StartMessageId.ToMessageIdData(),
Subscription = $"Reader-{Guid.NewGuid():N}",
Topic = options.Topic
};
var messagePrefetchCount = options.MessagePrefetchCount;
var batchHandler = new BatchHandler(false);
var decompressorFactories = CompressionFactories.DecompressorFactories();
var factory = new ConsumerChannelFactory(correlationId, _processManager, _connectionPool, executor, subscribe, messagePrefetchCount, batchHandler, decompressorFactories);
var stateManager = new StateManager <ReaderState>(ReaderState.Disconnected, ReaderState.Closed, ReaderState.ReachedEndOfTopic, ReaderState.Faulted);
var reader = new Reader(correlationId, ServiceUrl, options.Topic, _processManager, new NotReadyChannel(), executor, stateManager);
if (options.StateChangedHandler is not null)
{
_ = StateMonitor.MonitorReader(reader, options.StateChangedHandler);
}
var process = new ReaderProcess(correlationId, stateManager, factory, reader);
_processManager.Add(process);
process.Start();
return(reader);
}
public Task <BaseCommand> Outgoing(CommandSubscribe command)
{
command.RequestId = _requestId.FetchNext();
var request = StandardRequest.WithConsumerId(command.RequestId, command.ConsumerId);
return(_requests.CreateTask(request));
}
/// <summary>
/// Create a consumer.
/// </summary>
public IConsumer CreateConsumer(ConsumerOptions options)
{
ThrowIfDisposed();
var correlationId = Guid.NewGuid();
var executor = new Executor(correlationId, _processManager, _exceptionHandler);
var subscribe = new CommandSubscribe
{
ConsumerName = options.ConsumerName,
InitialPosition = (CommandSubscribe.InitialPositionType)options.InitialPosition,
PriorityLevel = options.PriorityLevel,
ReadCompacted = options.ReadCompacted,
Subscription = options.SubscriptionName,
Topic = options.Topic,
Type = (CommandSubscribe.SubType)options.SubscriptionType
};
var messagePrefetchCount = options.MessagePrefetchCount;
var batchHandler = new BatchHandler(true);
var decompressorFactories = CompressionFactories.DecompressorFactories();
var factory = new ConsumerChannelFactory(correlationId, _processManager, _connectionPool, executor, subscribe, messagePrefetchCount, batchHandler, decompressorFactories);
var stateManager = new StateManager <ConsumerState>(ConsumerState.Disconnected, ConsumerState.Closed, ConsumerState.ReachedEndOfTopic, ConsumerState.Faulted);
var consumer = new Consumer(correlationId, ServiceUrl, options.SubscriptionName, options.Topic, _processManager, new NotReadyChannel(), executor, stateManager);
if (options.StateChangedHandler is not null)
{
_ = StateMonitor.MonitorConsumer(consumer, options.StateChangedHandler);
}
var process = new ConsumerProcess(correlationId, stateManager, factory, consumer, options.SubscriptionType == SubscriptionType.Failover);
_processManager.Add(process);
process.Start();
return(consumer);
}
public static BaseCommand AsBaseCommand(this CommandSubscribe command)
{
return(new BaseCommand
{
CommandType = BaseCommand.Type.Subscribe,
Subscribe = command
});
}
public static BaseCommand ToBaseCommand(this CommandSubscribe value)
{
return(new BaseCommand
{
type = BaseCommand.Type.Subscribe,
Subscribe = value
});
}
public static ReadOnlySequence <byte> NewSubscribe(string topic, string subscription, long consumerId, long requestId, CommandSubscribe.SubType subType, int priorityLevel, string consumerName, bool isDurable, MessageIdData startMessageId, IDictionary <string, string> metadata, bool readCompacted, bool isReplicated, CommandSubscribe.InitialPosition subscriptionInitialPosition, long startMessageRollbackDurationInSec, ISchemaInfo schemaInfo, bool createTopicIfDoesNotExist, KeySharedPolicy keySharedPolicy)
{
var subscribe = new CommandSubscribe
{
Topic = topic,
Subscription = subscription,
subType = subType,
ConsumerId = (ulong)consumerId,
ConsumerName = consumerName,
RequestId = (ulong)requestId,
PriorityLevel = priorityLevel,
Durable = isDurable,
ReadCompacted = readCompacted,
initialPosition = subscriptionInitialPosition,
ReplicateSubscriptionState = isReplicated,
ForceTopicCreation = createTopicIfDoesNotExist
};
if (keySharedPolicy != null)
{
var keySharedMeta = new KeySharedMeta
{
allowOutOfOrderDelivery = keySharedPolicy.AllowOutOfOrderDelivery,
keySharedMode = ConvertKeySharedMode(keySharedPolicy.KeySharedMode)
};
if (keySharedPolicy is KeySharedPolicy.KeySharedPolicySticky sticky)
{
var ranges = sticky.GetRanges().Ranges;
foreach (var range in ranges)
{
keySharedMeta.hashRanges.Add(new IntRange {
Start = range.Start, End = range.End
});
}
}
subscribe.keySharedMeta = keySharedMeta;
}
if (startMessageId != null)
{
subscribe.StartMessageId = startMessageId;
}
if (startMessageRollbackDurationInSec > 0)
{
subscribe.StartMessageRollbackDurationSec = (ulong)startMessageRollbackDurationInSec;
}
subscribe.Metadatas.AddRange(CommandUtils.ToKeyValueList(metadata));
if (schemaInfo != null)
{
var schema = GetSchema(schemaInfo);
subscribe.Schema = schema;
}
return(Serializer.Serialize(subscribe.ToBaseCommand()));
}
public async Task <SubscribeResponse> Send(CommandSubscribe command, IChannel channel, CancellationToken cancellationToken)
{
ThrowIfDisposed();
Task <SubscribeResponse>?responseTask;
using (await _lock.Lock(cancellationToken).ConfigureAwait(false))
{
responseTask = _channelManager.Outgoing(command, channel);
var sequence = Serializer.Serialize(command.AsBaseCommand());
await _stream.Send(sequence).ConfigureAwait(false);
}
return(await responseTask.ConfigureAwait(false));
}
public async Task <SubscribeResponse> Send(CommandSubscribe command, IChannel channel)
{
Task <SubscribeResponse>?responseTask = null;
using (await _lock.Lock())
{
var baseCommand = command.AsBaseCommand();
var requestResponseTask = _requestResponseHandler.Outgoing(baseCommand);
responseTask = _channelManager.Outgoing(command, requestResponseTask, channel);
var sequence = Serializer.Serialize(baseCommand);
await _stream.Send(sequence);
}
return(await responseTask);
}
public Task <SubscribeResponse> Outgoing(CommandSubscribe command, Task <BaseCommand> response, IChannel channel)
{
var consumerId = _consumerChannels.Add(channel);
command.ConsumerId = consumerId;
return(response.ContinueWith(result =>
{
if (result.Result.CommandType == BaseCommand.Type.Error)
{
_consumerChannels.Remove(consumerId);
result.Result.Error.Throw();
}
channel.Connected();
return new SubscribeResponse(consumerId);
}, TaskContinuationOptions.OnlyOnRanToCompletion));
}
public ConsumerStreamFactory(ConnectionPool connectionPool, ReaderOptions options, IFaultStrategy faultStrategy)
{
_connectionPool = connectionPool;
_faultStrategy = faultStrategy;
_messagePrefetchCount = options.MessagePrefetchCount;
_batchHandler = new BatchHandler(false);
_subscribe = new CommandSubscribe
{
ConsumerName = options.ReaderName,
Durable = false,
ReadCompacted = options.ReadCompacted,
StartMessageId = options.StartMessageId.Data,
Subscription = "Reader-" + Guid.NewGuid().ToString("N"),
Topic = options.Topic
};
}
public ConsumerStreamFactory(ConnectionPool connectionPool, ConsumerOptions options, IFaultStrategy faultStrategy)
{
_connectionPool = connectionPool;
_faultStrategy = faultStrategy;
_messagePrefetchCount = options.MessagePrefetchCount;
_batchHandler = new BatchHandler(true);
_subscribe = new CommandSubscribe
{
ConsumerName = options.ConsumerName,
initialPosition = (CommandSubscribe.InitialPosition)options.InitialPosition,
PriorityLevel = options.PriorityLevel,
ReadCompacted = options.ReadCompacted,
Subscription = options.SubscriptionName,
Topic = options.Topic,
Type = (CommandSubscribe.SubType)options.SubscriptionType
};
}
public ConsumerChannelFactory(
Guid correlationId,
IRegisterEvent eventRegister,
IConnectionPool connectionPool,
CommandSubscribe subscribe,
uint messagePrefetchCount,
BatchHandler <TMessage> batchHandler,
IMessageFactory <TMessage> messageFactory,
IEnumerable <IDecompressorFactory> decompressorFactories)
{
_correlationId = correlationId;
_eventRegister = eventRegister;
_connectionPool = connectionPool;
_subscribe = subscribe;
_messagePrefetchCount = messagePrefetchCount;
_batchHandler = batchHandler;
_messageFactory = messageFactory;
_decompressorFactories = decompressorFactories;
}
public async Task <SubscribeResponse> Send(CommandSubscribe command, IConsumerProxy proxy)
{
Task <BaseCommand>?responseTask = null;
using (await _lock.Lock())
{
_consumerManager.Outgoing(command, proxy);
var baseCommand = command.AsBaseCommand();
responseTask = _requestResponseHandler.Outgoing(baseCommand);
var sequence = Serializer.Serialize(baseCommand);
await _stream.Send(sequence);
}
var response = await responseTask;
if (response.CommandType == BaseCommand.Type.Error)
{
_consumerManager.Remove(command.ConsumerId);
response.Error.Throw();
}
return(new SubscribeResponse(command.ConsumerId));
}
public static IDictionary <string, string> MetadataFromCommand(CommandSubscribe commandSubscribe)
{
return(ToMap(commandSubscribe.Metadatas));
}
