private void HandleExternalTaskException(string workerId, ExternalTask externalTask, ExternalTaskException ex)
        {
            var externalTaskBpmnError = new ExternalTaskBpmnError
            {
                WorkerId  = workerId,
                ErrorCode = ex.BusinessErrorCode
            };

            _engineClient.Client().ExternalTasks[externalTask.Id].HandleBpmnError(externalTaskBpmnError);
        }
Ejemplo n.º 2
0
        public void Execute(LockedExternalTask lockedExternalTask)
        {
            var resultVariables = new Dictionary <string, VariableValue>();

            Console.WriteLine($"Executing External Task {lockedExternalTask.Id} from topic {topicManagerInfo.TopicName}");
            try
            {
                topicManagerInfo.TaskAdapter.Execute(lockedExternalTask, ref resultVariables);
                var completeExternalTask = new CompleteExternalTask()
                {
                    WorkerId  = workerId,
                    Variables = resultVariables
                };
                policyManager.completePolicy().Execute(() =>
                {
                    externalTaskService[lockedExternalTask.Id].Complete(completeExternalTask).Wait();
                    Console.WriteLine($"Finished External Task {lockedExternalTask.Id} from topic {topicManagerInfo.TopicName}...");
                });
            }
            catch (UnrecoverableBusinessErrorException ex)
            {
                Console.WriteLine($"Failed with business error code {ex.BusinessErrorCode} for External Task  {lockedExternalTask.Id} in topic {topicManagerInfo.TopicName}...");
                var externalTaskBpmnError = new ExternalTaskBpmnError
                {
                    WorkerId     = workerId,
                    ErrorCode    = ex.BusinessErrorCode,
                    ErrorMessage = ex.Message
                };
                policyManager.handleBpmnErrorPolicy().Execute(() => externalTaskService[lockedExternalTask.Id].HandleBpmnError(externalTaskBpmnError).Wait());
            }
            catch (UnlockTaskException ex)
            {
                Console.WriteLine($"Unlock requested for External Task  {lockedExternalTask.Id} in topic {topicManagerInfo.TopicName}...");
                policyManager.unlockPolicy().Execute(() => externalTaskService[lockedExternalTask.Id].Unlock().Wait());
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed External Task  {lockedExternalTask.Id} in topic {topicManagerInfo.TopicName}...");
                var retriesLeft = topicManagerInfo.Retries;              // start with default
                if (lockedExternalTask.Retries.HasValue)                 // or decrement if retries are already set
                {
                    retriesLeft = lockedExternalTask.Retries.Value - 1;
                }
                var externalTaskFailure = new ExternalTaskFailure()
                {
                    WorkerId     = workerId,
                    Retries      = retriesLeft,
                    ErrorMessage = ex.Message,
                    ErrorDetails = ex.StackTrace
                };
                policyManager.handleFailurePolicy().Execute(() => externalTaskService[lockedExternalTask.Id].HandleFailure(externalTaskFailure).Wait());
            }
        }
        private void Execute(LockedExternalTask lockedExternalTask, Type type)
        {
            ExternalTask externalTask    = lockedExternalTask.ToExternalTask();
            var          resultVariables = new Dictionary <string, object>();

            try
            {
                LogEventToConsole($"{externalTask.ProcessDefinitionId} {externalTask.TopicName} Started", "INFO");

                CreateAdapterInstanceAndExecute(externalTask, ref resultVariables, type);

                LogEventToConsole($"{externalTask.ProcessDefinitionId} {externalTask.TopicName} Finished", "INFO");

                CompleteExternalTask completeExternalTask = new CompleteExternalTask()
                {
                    WorkerId  = _workerId,
                    Variables = resultVariables.ToVariableDictionary()
                };
                _camundaClient.ExternalTasks[externalTask.Id].Complete(completeExternalTask);
            }
            catch (ExternalTaskException ex)
            {
                LogEventToConsole($"{externalTask.ProcessDefinitionId} {externalTask.TopicName} {ex.Message}", "ERROR");

                ExternalTaskBpmnError externalTaskBpmnError = new ExternalTaskBpmnError()
                {
                    WorkerId  = _workerId,
                    ErrorCode = ex.BusinessErrorCode
                };
                _camundaClient.ExternalTasks[externalTask.Id].HandleBpmnError(externalTaskBpmnError);
            }
            catch (Exception ex)
            {
                LogEventToConsole($"{externalTask.ProcessDefinitionId} {externalTask.TopicName} {ex.Message}", "ERROR");

                var retriesLeft = _externalTaskWorkerInfo.Retries; // start with default
                if (externalTask.Retries.HasValue)                 // or decrement if retries are already set
                {
                    retriesLeft = externalTask.Retries.Value - 1;
                }

                ExternalTaskFailure externalTaskFailure = new ExternalTaskFailure()
                {
                    WorkerId     = _workerId,
                    ErrorMessage = ex.Message,
                    ErrorDetails = ex.StackTrace,
                    RetryTimeout = _externalTaskWorkerInfo.RetryTimeout,
                    Retries      = retriesLeft
                };

                _camundaClient.ExternalTasks[externalTask.Id].HandleFailure(externalTaskFailure);
            }
        }