Example #1
0
        public async Task <ApplicationCommandResult <TPayload> > ExecuteCommandAsync <TPayload>(IApplicationCommand command,
                                                                                                ApplicationCommandReplySchemes replyScheme = ApplicationCommandReplySchemes.OnDomainCommandHandled,
                                                                                                CancellationToken token = default)
        {
            PreConditions.NotNull(command, nameof(command));

            await PublishAsync(command, replyScheme, token);

            var promise = new ApplicationCommandExecutionPromise <TPayload>(command);

            _commandResultListener.AddExecutingPromise(promise);

            return(await promise.Future.ConfigureAwait(false));
        }
        public void AddExecutingPromise <TPayload>(ApplicationCommandExecutionPromise <TPayload> promise)
        {
            var command = promise.ApplicationCommand;

            if (ExecutingPromiseDict.TryAdd(command.Id, promise))
            {
                var delay = _commandOptions.ExecutionOptions.TimeOutInSeconds;

                _timer.NewTimeout(new ActionTimerTask(it => CancelApplicationCommand(promise, delay)), TimeSpan.FromSeconds(delay));
            }
            else
            {
                _logger.LogWarning($"The application command registered,Id:{command.Id}, Type:{command.GetType().FullName}, ReplyScheme:{command.ReplyScheme}.");
            }
        }
        private void CancelApplicationCommand(ApplicationCommandExecutionPromise promise, int delay)
        {
            var command     = promise.ApplicationCommand;
            var commandId   = command.Id;
            var commandType = command.GetType().FullName;

            if (!ExecutingPromiseDict.TryRemove(commandId, out var executionPromise))
            {
                _logger.LogTrace($"Over execution timeout upper limit: {delay} seconds, Cancelling application Command, Id:{commandId}, Type:{commandType}, but task source does not exist.");

                return;
            }

            var replyScheme = command.ReplyScheme;
            var result      = ApplicationCommandResult.TimeOuted(commandId, commandType, "The execution of application command timeout, please try again.");

            _logger.LogWarning(executionPromise.TrySetResult(result)
                ? $"Over execution timeout upper limit: {delay} seconds, cancelled application Command, Id:{commandId}, Type:{commandType}, ReplyScheme:{replyScheme}."
                : $"Over execution timeout upper limit: {delay} seconds, Failed to cancel application Command, Id:{commandId}, Type:{commandType}, ReplyScheme:{replyScheme}.");
        }