Esempio n. 1
0
        /// <summary>
        /// 执行计划任务。
        /// </summary>
        protected override void ScheduleCallback()
        {
            while (true)
            {
                while (ScheduledTasks.TaskExecuting)
                {
                    Thread.Sleep(1000);
                }
                try
                {
                    ScheduledTasks.TaskExecuting = true;
                    base.ExecuteTask();

                    ScheduledTaskLog.WriteLog(Config);
                }
                catch (Exception exception)
                {
                    ExceptionHandler.HandleException(exception);
                }
                finally
                {
                    ScheduledTasks.TaskExecuting = false;
                }
                Thread.Sleep((int)(Config.ThreadSleepSecond * 1000));
            }
        }
        /// <summary>
        /// 处理单个定时任务
        /// </summary>
        /// <param name="executor">定时任务执行器</param>
        protected virtual void HandleTask(IScheduledTask executor)
        {
            // 执行任务并捕捉错误
            bool   executed = false;
            bool   success  = false;
            string error    = null;

            try
            {
                executed = HandleTaskInner(executor);
                success  = true;
            }
            catch (Exception e)
            {
                error = e.ToString();
            }
            if (!executed && error == null)
            {
                return;
            }
            // 记录日志
            using (UnitOfWork.Scope())
            {
                var logRepository = ZKWeb.Application.Ioc.Resolve <IRepository <ScheduledTaskLog, Guid> >();
                var log           = new ScheduledTaskLog()
                {
                    Task       = Get(executor.Key),
                    CreateTime = DateTime.UtcNow,
                    Success    = success,
                    Error      = error
                };
                logRepository.Save(ref log);
            }
        }
Esempio n. 3
0
 /// <summary>
 /// 执行计划任务。
 /// </summary>
 protected override void ScheduleCallback()
 {
     while (true)
     {
         if (this.lastExecuteTime.AddDays(1.0) < DateTime.Now)
         {
             while (ScheduledTasks.TaskExecuting)
             {
                 Thread.Sleep(1000);
             }
             try
             {
                 ScheduledTasks.TaskExecuting = true;
                 base.ExecuteTask();
                 this.lastExecuteTime = DateTime.Today;
                 ScheduledTaskLog.WriteLog(base.Config);
             }
             catch (Exception exception)
             {
                 ExceptionHandler.HandleException(exception);
             }
             finally
             {
                 ScheduledTasks.TaskExecuting = false;
             }
         }
         Thread.Sleep((int)(base.Config.ThreadSleepSecond * 1000));
     }
 }
Esempio n. 4
0
        public void CreateScheduleTaskLog(ScheduledTask task)
        {
            var log = new ScheduledTaskLog();

            log.RunDate         = DateTime.UtcNow;
            log.Successful      = true;
            log.ScheduledTaskId = task.ScheduledTaskId;

            _scheduledTaskLogRepository.SaveOrUpdate(log);
        }
Esempio n. 5
0
        public async Task <ScheduledTaskLog> CreateScheduleTaskLogAsync(ScheduledTask task, CancellationToken cancellationToken = default(CancellationToken))
        {
            var log = new ScheduledTaskLog();

            log.RunDate         = DateTime.UtcNow;
            log.Successful      = true;
            log.ScheduledTaskId = task.ScheduledTaskId;

            return(await _scheduledTaskLogRepository.SaveOrUpdateAsync(log, cancellationToken));
        }
Esempio n. 6
0
        public ScheduledTaskLog WriteTaskLog(ScheduledTask task, string message, LogSeverity severity = LogSeverity.Normal)
        {
            ScheduledTaskLog log = new ScheduledTaskLog {
                ScheduledTask = task,
                Severity      = (int)severity,
                LogDate       = DateTime.Now,
                Message       = message
            };

            db.InsertOrUpdateScheduledTaskLog(log);

            return(log);
        }
Esempio n. 7
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="context"></param>
 public void Execute(IJobExecutionContext context)
 {
     try {
         _task = (ScheduledTask)context.MergedJobDataMap["ScheduledTask"];
         DateTime planingTime = context.ScheduledFireTimeUtc.HasValue ? context.ScheduledFireTimeUtc.Value.LocalDateTime : DateTime.Now;
         planingTime = new DateTime(planingTime.Ticks - (planingTime.Ticks % TimeSpan.TicksPerMinute), planingTime.Kind);
         if (_task.OnlyWorkingDays)
         {
             if (HolidayCalculator.Instance.IsHoliday(planingTime, _task.RunAtHalfPublicHoliday))
             {
                 return;
             }
         }
         _action = Toolkit.Instance.CreateInstance <IPxTaskAction>(_task.Action);
         using (PeakDbContext dbContext = new PeakDbContext()) {
             if (dbContext.ScheduledTaskLogs.FirstOrDefault(x => x.ScheduledTaskId == _task.Id && x.ScheduledTime == planingTime) != null)
             {
                 return;
             }
             ScheduledTaskLog taskLog = new ScheduledTaskLog()
             {
                 ScheduledTaskId = _task.Id,
                 State           = Dal.Enums.ScheduleState.Running,
                 ScheduledTime   = planingTime,
                 StartTime       = DateTime.Now
             };
             dbContext.ScheduledTaskLogs.Add(taskLog);
             dbContext.SaveChanges();
             bool succeed = executeAction(planingTime, 0);
             taskLog.EndTime = DateTime.Now;
             if (succeed)
             {
                 taskLog.State = Dal.Enums.ScheduleState.Succeed;
             }
             else
             {
                 taskLog.State = Dal.Enums.ScheduleState.Failed;
                 if (_lastError != null)
                 {
                     taskLog.ErrorMessage = _lastError.Message;
                     taskLog.ErrorDetail  = _lastError.ToString();
                     _lastError           = null;
                 }
             }
             dbContext.SaveChanges();
         }
     }
     catch (Exception ex) {
         PxErrorLogger.Log(ex);
     }
 }
        public async Task SaveScheduledTaskLogAsync(ScheduledTaskLog scheduledTaskLog)
        {
            if (scheduledTaskLog.ScheduledTaskLogId == Guid.Empty)
            {
                _context.Add(scheduledTaskLog);
            }
            else
            {
                if (ScheduledTaskLogExists(scheduledTaskLog.ScheduledTaskLogId))
                {
                    _context.Update(scheduledTaskLog);
                }
            }

            await _context.SaveChangesAsync();
        }
        // == EVENT(S)
        // ======================================================================

        /// <summary>
        /// Event called before the start of the task execution.
        /// </summary>
        protected virtual void onStart()
        {
            this._message = new JObject();

            // == CREATES THE SCOPE & DATABASE CONTEXT

            this._scope           = this._scopeFactory.CreateScope();
            this._databaseContext = this._scope.ServiceProvider.GetRequiredService <DatabaseContext>();

            // == CREATES THE ENTRY OF THIS SCAN ON DATABASE

            var currentTime = DateTime.Now;

            this._databaseTransaction = this._databaseContext.Database.BeginTransaction();

            // SCHEDULED_TASK_LOG

            if (!this._newTentative)
            {
                this._taskLog           = new ScheduledTaskLog();
                this._taskLog.StartTime = currentTime;
                this._taskLog.ScheduledTaskNavigation = this._scheduledTask;
                this._databaseContext.Entry(this._taskLog.ScheduledTaskNavigation).State = EntityState.Unchanged;
                this._taskLog.ScheduledTask = this._scheduledTask.Id;
                this._databaseContext.ScheduledTaskLog.Add(this._taskLog);
            }
            else
            {
                this._taskLog = this._databaseContext.ScheduledTaskLog.Where(log => log.ScheduledTask == this._scheduledTask.Id).OrderByDescending(log => log.StartTime).FirstOrDefault();

                if (this._taskLog == null)
                {
                    throw new AuctionMasterTaskException(ExceptionType.WARNING, "Last log not found");
                }
            }

            this._databaseContext.SaveChanges();
            this._databaseTransaction.Commit();

            this._logService = new ScheduledTaskLogService(this.GetType(), this._taskLog);

            this._logService.start();
            this._logService.writeLine(LogType.INFO, $"Scheduled task [{this._scheduledTask.Name}] has started.", true);
        }
        // == CONSTRUCTOR(S)
        // ======================================================================

        public ScheduledTaskLogService(Type origin, ScheduledTaskLog log)
        {
            this._origin = origin;
            this._log    = log;
        }
        // == EVENT(S)
        // ======================================================================

        private void onTimedEvent(object source, ElapsedEventArgs evtArgs)
        {
            try
            {
                this._cycleCount++;
                LogUtil.writeLog(this.GetType(), LogType.INFO, $"TASK ORCHESTRATION CYCLE ({this._cycleCount}) STARTED");

                foreach (KeyValuePair <int, GenericScheduledTask> entry in this._scheduledTasks)
                {
                    if (entry.Value.task.Enabled == 1)
                    {
                        if (entry.Value.state == ScheduledTaskState.IDLE)
                        {
                            if (entry.Value.task.SheduledTaskFrequencyNavigation.Id == 1 && entry.Value.task.ScheduledTaskInterval != null)
                            {
                                // INTERVAL

                                ScheduledTaskLog lastTaskLog = null;

                                using (var scope = this._scopeFactory.CreateScope())
                                {
                                    DatabaseContext databaseContext = scope.ServiceProvider.GetRequiredService <DatabaseContext>();
                                    lastTaskLog = databaseContext.ScheduledTaskLog.Where(log => log.ScheduledTask == entry.Value.task.Id).OrderByDescending(log => log.StartTime).FirstOrDefault();
                                }

                                if (lastTaskLog == null)
                                {
                                    entry.Value.start();
                                }
                                else
                                {
                                    if ((DateTime.Now - lastTaskLog.StartTime).TotalSeconds > entry.Value.task.ScheduledTaskInterval.First().Interval)
                                    {
                                        entry.Value.start();
                                    }
                                }
                            }
                        }
                        if (entry.Value.state == ScheduledTaskState.ERROR)
                        {
                            ScheduledTaskLog lastTaskLog = null;

                            using (var scope = this._scopeFactory.CreateScope())
                            {
                                DatabaseContext databaseContext = scope.ServiceProvider.GetRequiredService <DatabaseContext>();
                                lastTaskLog = databaseContext.ScheduledTaskLog.Where(log => log.ScheduledTask == entry.Value.task.Id).OrderByDescending(log => log.StartTime).FirstOrDefault();
                            }

                            if (lastTaskLog != null)
                            {
                                if (lastTaskLog.Tentatives < entry.Value.task.MaxTentatives)
                                {
                                    entry.Value.start();
                                }
                                else
                                {
                                    entry.Value.state = ScheduledTaskState.IDLE;
                                    LogUtil.writeLog(this.GetType(), LogType.WARNING, $"Scheduled task '{entry.Value.task.Name}' has excceded the max number of tentatives to execution ({entry.Value.task.MaxTentatives})");
                                }
                            }
                            else
                            {
                                entry.Value.state = ScheduledTaskState.DEAD;
                                throw new AuctionMasterTaskException(ExceptionType.FATAL, $"Scheduled task '{entry.Value.task.Name}' has thrown an error in the last execution but no logs are written in database");
                            }
                        }
                    }
                }
            }
            catch (System.Exception e)
            {
                LogUtil.writeLog(this.GetType(), LogType.WARNING, $"Error occured during execution of cycle {this._cycleCount}");
            }
        }
        private async Task RunDbTasks()
        {
            using (var scope = _serviceProvider.CreateScope())
            {
                var taskRepository     = scope.ServiceProvider.GetRequiredService <ScheduledTaskRepository> ();
                var applicationWrapper = scope.ServiceProvider.GetRequiredService <ConsoleApplicationWrapper <MinecraftMessageParser> > ();

                foreach (var task in _scheduledTasks.Where(task => task.Enabled))
                {
                    CrontabSchedule schedule = null;

                    try
                    {
                        schedule = CrontabSchedule.Parse(task.CronString);
                    } catch (CrontabException ex)
                    {
                        Log.Error(ex, $"Error occurred while running ScheduledTaskId={task.ScheduledTaskId}");
                        continue;
                    }

                    // In this one instance we're going to use server local time, because that's
                    // how an end user would expect the app to work and timezones are hard.
                    var next = schedule.GetNextOccurrence(DateTime.Now.AddMinutes(-1));

                    if (DateTime.Now >= next)
                    {
                        var lastLog = await taskRepository.GetLastLogForTask(task.ScheduledTaskId);

                        if (lastLog == null || lastLog.StartTime < next)
                        {
                            var nextLog = new ScheduledTaskLog
                            {
                                StartTime       = DateTime.Now,
                                ScheduledTaskId = task.ScheduledTaskId
                            };

                            await taskRepository.SaveScheduledTaskLogAsync(nextLog);

                            try
                            {
                                switch (task.ScheduledTaskType)
                                {
                                case ScheduledTaskType.Backup:
                                    await CreateBackup(false);

                                    break;

                                case ScheduledTaskType.Command:
                                    applicationWrapper.SendInput(task.Command, null);
                                    break;
                                }

                                nextLog.CompletedTime    = DateTime.Now;
                                nextLog.CompletionStatus = "SUCCESS";

                                await taskRepository.SaveScheduledTaskLogAsync(nextLog);
                            }
                            catch (Exception ex)
                            {
                                Log.Error(ex, $"Exception occurred while running ScheduledTaskId={task.ScheduledTaskId}");

                                nextLog.CompletedTime    = DateTime.Now;
                                nextLog.CompletionStatus = "FAILED";

                                await taskRepository.SaveScheduledTaskLogAsync(nextLog);
                            }
                        }
                    }
                }
            }
        }