Esempio n. 1
0
        public void Delete(Models.SchedulingTaskModel job)
        {
            var connection = _store.Configuration.ConnectionFactory.CreateConnection();

            connection.Open();
            var transaction = connection.BeginTransaction(_store.Configuration.IsolationLevel);

            try
            {
                var table = $"{_tablePrefix}{nameof(SchedulingTaskModel)}";

                connection.Execute($"delete from [{table}] where  [Id]=@Id", new { Id = job.Id }, transaction);
            }
            catch (Exception e)
            {
                Logger.LogError("An error occured while reading indexing tasks", e);
                throw;
            }
            finally
            {
                transaction.Commit();
                transaction.Dispose();

                if (_store.Configuration.ConnectionFactory.Disposable)
                {
                    connection.Dispose();
                }
                else
                {
                    connection.Close();
                }
            }
        }
Esempio n. 2
0
        private void ProcessMessage(Models.SchedulingTaskModel task)
        {
            Logger.LogDebug("Processing task {0}.", task.Id);

            try {
                if (task == null)
                {
                    return;
                }
                var payload    = JObject.Parse(task.Parameters);
                var parameters = payload.ToDictionary();

                _eventBus.NotifyAsync(task.Message, parameters);

                Logger.LogDebug("Processed task Id {0}.", task.Id);
            }
            catch (Exception e) {
                Logger.LogError("An unexpected error while processing task {0}. Error message: {1}.", task.Id, e);
            }
            finally {
                switch (task.Frequency)
                {
                case -2:
                    task.ScheduledUtc = task.ScheduledUtc.AddMinutes(task.SpaceNum);
                    _schedulingTaskService.EditTaskAsync(task);
                    break;

                case -1:
                    task.ScheduledUtc = task.ScheduledUtc.AddHours(task.SpaceNum);
                    _schedulingTaskService.EditTaskAsync(task);
                    break;

                case 1:
                    task.ScheduledUtc = task.ScheduledUtc.AddDays(task.SpaceNum);
                    _schedulingTaskService.EditTaskAsync(task);
                    break;

                case 2:
                    task.ScheduledUtc = task.ScheduledUtc.AddDays(task.SpaceNum * 7);
                    _schedulingTaskService.EditTaskAsync(task);
                    break;

                case 3:
                    task.ScheduledUtc = task.ScheduledUtc.AddMonths(task.SpaceNum);
                    _schedulingTaskService.EditTaskAsync(task);
                    break;

                default:
                    _schedulingTaskManager.Delete(task);
                    break;
                }
            }
        }
Esempio n. 3
0
        public Task EnqueueAsync(string taskName, string message, int priority, DateTime scheduledUtc, object parameters)
        {
            var schedulingTask = new Models.SchedulingTaskModel {
                Parameters   = JsonConvert.SerializeObject(parameters),
                Message      = message,
                CreatedUtc   = _clock.UtcNow,
                Priority     = priority,
                ScheduledUtc = scheduledUtc,
                CanExecute   = true,
                TaskName     = taskName
            };


            lock (_tasksQueue)
            {
                _tasksQueue.Add(schedulingTask);
            }

            return(Task.CompletedTask);
        }