Ejemplo n.º 1
0
        public Task <ICommandResult> ExecuteAsync(ICommand command, CommandReturnMode returnType, int timeoutMs)
        {
            var request = new Request()
            {
                Body = _serializer.Serialize(command)
            };

            request.Header = new Dictionary <string, string>()
            {
                { "Protocol", "1" },
                { "Type", command.GetType().Name },
                { "Model", ((int)returnType).ToString() },
                { "Timeout", timeoutMs.ToString() },
            };

            var channel = _channelFactory.GetChannel(commandClientConfigurationName, ProtocolCode.Command);

            if (channel == null)
            {
                throw new CommunicationException("Unable to connect to remote host.");
            }

            return
                (Task.Factory.FromAsync <Request, Response>(channel.BeginExecute, channel.EndExecute, request, null)
                 .ContinueWith <ICommandResult>(this.Parse));
        }
Ejemplo n.º 2
0
        public Task <ICommandResult> RegisterProcessingCommand(string commandId, ICommand command,
                                                               CommandReturnMode commandReturnMode, int timeoutMs)
        {
            var taskCompletionSource =
                new CommandTaskCompletionSource(commandReturnMode, timeoutMs, commandId, _commandTaskDict.Remove);

            if (!_commandTaskDict.TryAdd(commandId, taskCompletionSource))
            {
                taskCompletionSource.Dispose();
                throw new ApplicationException(
                          string.Format("Duplicate processing command registration, type:{0}, id:{1}", command.GetType().Name,
                                        commandId));
            }

            return(taskCompletionSource.Task);
        }
Ejemplo n.º 3
0
        public Task <ICommandResult> ExecuteAsync(ICommand command, CommandReturnMode returnMode, int timeoutMs)
        {
            var traceId     = ObjectId.GenerateNewId().ToString();
            var commandTask = _resultManger.RegisterProcessingCommand(traceId, command, returnMode, timeoutMs);

            Task.Factory.StartNew(() =>
            {
                try
                {
                    _commandBus.Send(command, new TraceInfo(traceId, ConfigurationSettings.InnerAddress));
                    _resultManger.SetCommandResult(traceId, CommandResult.SentSuccess);
                }
                catch (Exception ex)
                {
                    LogManager.Default.Error("send commands failed. ", ex);
                    _resultManger.SetCommandResult(traceId, CommandResult.SentFailed);
                }
            });

            return(commandTask);
        }
Ejemplo n.º 4
0
 public ICommandResult Execute(ICommand command, CommandReturnMode returnMode, int timeoutMs)
 {
     return(ExecuteAsync(command, returnMode, timeoutMs).Result);
 }
Ejemplo n.º 5
0
 public CommandTaskCompletionSource(CommandReturnMode returnMode, int timeoutMs, string commandId,
                                    Action <string> callback)
     : base(timeoutMs, commandId, callback)
 {
     ReturnMode = returnMode;
 }