Beispiel #1
0
        private TaskExecutionMetaRequest CreateTaskExecutionMetaRequest(int numberToRetrieve)
        {
            var request = new TaskExecutionMetaRequest();

            request.TaskId = new TaskId(_taskExecutionInstance.ApplicationName, _taskExecutionInstance.TaskName);
            request.ExecutionsToRetrieve = numberToRetrieve;

            return(request);
        }
        public async Task <TaskExecutionMetaResponse> GetLastExecutionMetasAsync(TaskExecutionMetaRequest taskExecutionMetaRequest)
        {
            var response       = new TaskExecutionMetaResponse();
            var taskDefinition = await _taskRepository.EnsureTaskDefinitionAsync(taskExecutionMetaRequest.TaskId).ConfigureAwait(false);

            using (var connection = await CreateNewConnectionAsync(taskExecutionMetaRequest.TaskId).ConfigureAwait(false))
            {
                var command = connection.CreateCommand();
                command.CommandTimeout = ConnectionStore.Instance.GetConnection(taskExecutionMetaRequest.TaskId).QueryTimeoutSeconds;
                command.CommandText    = TaskQueryBuilder.GetLastExecutionQuery;
                command.Parameters.Add("Top", SqlDbType.Int).Value = taskExecutionMetaRequest.ExecutionsToRetrieve;
                command.Parameters.Add("TaskDefinitionId", SqlDbType.Int).Value = taskDefinition.TaskDefinitionId;

                using (var reader = await command.ExecuteReaderAsync().ConfigureAwait(false))
                {
                    while (await reader.ReadAsync().ConfigureAwait(false))
                    {
                        var executionMeta = new TaskExecutionMetaItem();
                        executionMeta.StartedAt = (DateTime)reader["StartedAt"];

                        if (reader["CompletedAt"] != DBNull.Value)
                        {
                            executionMeta.CompletedAt = (DateTime)reader["CompletedAt"];

                            bool failed  = (bool)reader["Failed"];
                            bool blocked = (bool)reader["Blocked"];

                            if (failed)
                            {
                                executionMeta.Status = TaskExecutionStatus.Failed;
                            }
                            else if (blocked)
                            {
                                executionMeta.Status = TaskExecutionStatus.Blocked;
                            }
                            else
                            {
                                executionMeta.Status = TaskExecutionStatus.Completed;
                            }
                        }
                        else
                        {
                            TaskDeathMode taskDeathMode = (TaskDeathMode)(byte)reader["TaskDeathMode"];
                            if (taskDeathMode == TaskDeathMode.KeepAlive)
                            {
                                var lastKeepAlive      = (DateTime)reader["LastKeepAlive"];
                                var keepAliveThreshold = (TimeSpan)reader["KeepAliveDeathThreshold"];
                                var dbServerUtcNow     = (DateTime)reader["DbServerUtcNow"];

                                var timeSinceLastKeepAlive = dbServerUtcNow - lastKeepAlive;
                                if (timeSinceLastKeepAlive > keepAliveThreshold)
                                {
                                    executionMeta.Status = TaskExecutionStatus.Dead;
                                }
                                else
                                {
                                    executionMeta.Status = TaskExecutionStatus.InProgress;
                                }
                            }
                        }

                        if (reader["ExecutionHeader"] != DBNull.Value)
                        {
                            executionMeta.Header = reader["ExecutionHeader"].ToString();
                        }

                        if (reader["ReferenceValue"] != DBNull.Value)
                        {
                            executionMeta.ReferenceValue = reader["ReferenceValue"].ToString();
                        }

                        response.Executions.Add(executionMeta);
                    }
                }
            }

            return(response);
        }