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)); }