コード例 #1
0
        public async Task Renew(TaskOrchestrationWorkItem workItem)
        {
            var request = new TaskOrchestrationRequest
            {
                RenewRequest = new RenewTaskOrchestrationWorkItemLockRequest()
            };

            await _stream.RequestStream.WriteAsync(request);

            var cts = new CancellationTokenSource(_renewResponseTimeout);

            if (!await _stream.ResponseStream.MoveNext(cts.Token))
            {
                throw new Exception("Session aborted");
            }

            if (_stream.ResponseStream.Current.MessageCase != TaskOrchestrationResponse.MessageOneofCase.RenewResponse)
            {
                throw new Exception("Unexpected response");
            }

            var renewResponse = _stream.ResponseStream.Current.RenewResponse;

            workItem.LockedUntilUtc = renewResponse.LockedUntilUtc.ToDateTime();
        }
コード例 #2
0
        public async Task Release(TaskOrchestrationWorkItem workItem)
        {
            var request = new TaskOrchestrationRequest
            {
                ReleaseRequest = new ReleaseTaskOrchestrationWorkItemRequest()
            };

            await _stream.RequestStream.WriteAsync(request);

            var cts = new CancellationTokenSource(_releaseResponseTimeout);

            if (!await _stream.ResponseStream.MoveNext(cts.Token))
            {
                throw new Exception("Session aborted");
            }

            if (_stream.ResponseStream.Current.MessageCase != TaskOrchestrationResponse.MessageOneofCase.ReleaseResponse)
            {
                throw new Exception("Unexpected response");
            }

            await _stream.RequestStream.CompleteAsync();

            // Last read to close stream
            await _stream.ResponseStream.MoveNext(cts.Token);

            _stream.Dispose();
        }
コード例 #3
0
        public async Task <IList <TaskMessage> > FetchNewOrchestrationMessagesAsync(
            TaskOrchestrationWorkItem workItem)
        {
            var request = new TaskOrchestrationRequest
            {
                FetchRequest = new FetchNewOrchestrationMessagesRequest()
            };

            await _stream.RequestStream.WriteAsync(request);

            var cts = new CancellationTokenSource(_fetchResponseTimeout);

            if (!await _stream.ResponseStream.MoveNext(cts.Token))
            {
                throw new Exception("Session aborted");
            }

            if (_stream.ResponseStream.Current.MessageCase != TaskOrchestrationResponse.MessageOneofCase.FetchResponse)
            {
                throw new Exception("Unexpected response");
            }

            var fetchResponse = _stream.ResponseStream.Current.FetchResponse;

            if (fetchResponse.NewMessages == null)
            {
                return(null);
            }

            return(fetchResponse.NewMessages.Messages
                   .Select(x => _options.DataConverter.Deserialize <TaskMessage>(x))
                   .ToArray());
        }
コード例 #4
0
        public async Task Complete(
            TaskOrchestrationWorkItem workItem,
            OrchestrationRuntimeState newOrchestrationRuntimeState,
            IList <TaskMessage> outboundMessages,
            IList <TaskMessage> orchestratorMessages,
            IList <TaskMessage> timerMessages,
            TaskMessage continuedAsNewMessage,
            OrchestrationState orchestrationState)
        {
            var request = new TaskOrchestrationRequest
            {
                CompleteRequest = new CompleteTaskOrchestrationWorkItemRequest
                {
                    NewEvents = { workItem.OrchestrationRuntimeState.NewEvents.Select(_options.DataConverter.Serialize) },
                    NewStatus = workItem.OrchestrationRuntimeState.Status,
                    NewOrchestrationEvents = { newOrchestrationRuntimeState == workItem.OrchestrationRuntimeState
                        ? Enumerable.Empty <string>()
                        : newOrchestrationRuntimeState.NewEvents.Select(_options.DataConverter.Serialize) },
                    NewOrchestrationStatus = newOrchestrationRuntimeState == workItem.OrchestrationRuntimeState
                        ? null
                        : newOrchestrationRuntimeState.Status,
                    OutboundMessages      = { outboundMessages.Select(_options.DataConverter.Serialize) },
                    OrchestratorMessages  = { orchestratorMessages.Select(_options.DataConverter.Serialize) },
                    TimerMessages         = { timerMessages.Select(_options.DataConverter.Serialize) },
                    ContinuedAsNewMessage = continuedAsNewMessage == null
                        ? string.Empty
                        : _options.DataConverter.Serialize(continuedAsNewMessage),
                    OrchestrationState = _options.DataConverter.Serialize(orchestrationState)
                }
            };

            await _stream.RequestStream.WriteAsync(request);

            var cts = new CancellationTokenSource(_completeResponseTimeout);

            if (!await _stream.ResponseStream.MoveNext(cts.Token))
            {
                throw new Exception("Session aborted");
            }

            if (_stream.ResponseStream.Current.MessageCase != TaskOrchestrationResponse.MessageOneofCase.CompleteResponse)
            {
                throw new Exception("Unexpected response");
            }
        }
コード例 #5
0
        public async Task Abandon(TaskOrchestrationWorkItem workItem)
        {
            var request = new TaskOrchestrationRequest
            {
                AbandonRequest = new AbandonTaskOrchestrationWorkItemLockRequest()
            };

            await _stream.RequestStream.WriteAsync(request);

            var cts = new CancellationTokenSource(_abandonResponseTimeout);

            if (!await _stream.ResponseStream.MoveNext(cts.Token))
            {
                throw new Exception("Session aborted");
            }

            if (_stream.ResponseStream.Current.MessageCase != TaskOrchestrationResponse.MessageOneofCase.AbandonResponse)
            {
                throw new Exception("Unexpected response");
            }
        }
        private async Task <TaskOrchestrationWorkItem> LockNextTaskOrchestrationWorkItemAsync(
            TimeSpan receiveTimeout,
            INameVersionInfo[] orchestrations,
            bool allOrchesrations,
            CancellationToken cancellationToken)
        {
            var stream = _client.LockNextTaskOrchestrationWorkItem(cancellationToken: cancellationToken);

            try
            {
                var request = new TaskOrchestrationRequest
                {
                    LockRequest = new LockNextTaskOrchestrationWorkItemRequest
                    {
                        ReceiveTimeout = Duration.FromTimeSpan(receiveTimeout),
                        Orchestrations =
                        {
                            orchestrations
                            .Select(nv => new NameVersion {
                                Name = nv.Name, Version = nv.Version
                            })
                        },
                        AllOrchestrations = allOrchesrations
                    }
                };

                await stream.RequestStream.WriteAsync(request);

                if (!await stream.ResponseStream.MoveNext(cancellationToken))
                {
                    throw new Exception("Session aborted");
                }

                if (stream.ResponseStream.Current.MessageCase != TaskOrchestrationResponse.MessageOneofCase.LockResponse)
                {
                    throw new Exception("Didn't receive lock response");
                }

                var lockResponse = stream.ResponseStream.Current.LockResponse;

                if (lockResponse.WorkItem == null)
                {
                    return(null);
                }

                return(new TaskOrchestrationWorkItem
                {
                    InstanceId = lockResponse.WorkItem.InstanceId,
                    OrchestrationRuntimeState = new OrchestrationRuntimeState(
                        lockResponse.WorkItem.Events
                        .Select(e => _options.DataConverter.Deserialize <HistoryEvent>(e))
                        .ToArray()),
                    LockedUntilUtc = lockResponse.WorkItem.LockedUntilUtc.ToDateTime(),
                    NewMessages = lockResponse.WorkItem.NewMessages.Select(m => _options.DataConverter.Deserialize <TaskMessage>(m)).ToArray(),
                    Session = new GrpcClientOrchestrationSession(_options, stream, _logger)
                });
            }
            catch
            {
                stream.Dispose();
                throw;
            }
        }