/// <summary>
        ///     有可能会报错转换失败
        /// </summary>
        /// <param name="execution"></param>
        public void Execute(IBaseDelegateExecution execution)
        {
            var delexecution = (IDelegateExecution)execution;

            ModelInstance = delexecution.BpmnModelInstance;                      // IBpmnModelInstance;//  IExecution.IBpmnModelInstance;
            ServiceTask   = (IServiceTask)delexecution.BpmnModelElementInstance; //BpmnModelElementInstance;
        }
        private void ExecuteServiceTask(ServiceTask task)
        {
            TaskRunnerLog runnerLog = new TaskRunnerLog()
            {
                DateStarted = DateTime.Now,
                TaskName    = task.Name,
                TaskResult  = "RUNNING"
            };

            try
            {
                IRepository <TaskRunnerLog> taskRunnerLogRepository = new EfRepository <TaskRunnerLog>(new DatabaseContext());
                taskRunnerLogRepository.GetMany(l => l.TaskResult == "RUNNING" && l.TaskName == task.Name).ToList().ForEach(l => {
                    l.DateEnded  = DateTime.Now;
                    l.TaskResult = "STOPPED";
                });
                taskRunnerLogRepository.Save();
                taskRunnerLogRepository.Insert(runnerLog);
                taskRunnerLogRepository.Save();
                IServiceTask serviceTask = (IServiceTask)Activator.CreateInstance(task.ExecuteAssembly, task.ExecuteModule).Unwrap();
                serviceTask.Run(task.Settings);
                runnerLog.TaskResult = "COMPLETE";
                runnerLog.DateEnded  = DateTime.Now;
                taskRunnerLogRepository.Save();
            }
            catch (Exception ex)
            {
                Logging.LogException(ex);
                runnerLog.TaskResult = "ERROR";
                runnerLog.DateEnded  = DateTime.Now;
            }
        }
        public ScheduledTaskRunner(
            string name,
            ITaskScheduler scheduler,
            IServiceTask scheduledTask,
            ITaskRepository taskRepository,
            IDateTimeProvider dateTimeProvider,
            IExceptionLogger exceptionLogger,
            ICancellationTokenProvider cancellationTokenProvider,
            ILogger logger)
        {
            this.Name              = name;
            this.Scheduler         = scheduler;
            this.ServiceTask       = scheduledTask;
            this.taskRepository    = taskRepository;
            this.dateTimeProvider  = dateTimeProvider;
            this.exceptionLogger   = exceptionLogger;
            this.logger            = logger;
            this.CancellationToken = cancellationTokenProvider.CancellationToken;

            var lastRunTime = this.taskRepository.GetLastExecution(this.Name);

            this.LastRunTime = lastRunTime ?? DateTime.MinValue;

            this.FailureCount = 0;
        }
        public string ProcessRequest(string request)
        {
            IServiceTask task = mManager.getTaskByName(RESOLVER_NAME);

            // check params
            string param = ServiceHelpers.ExtractRequestParams(request);

            // check action (start/stop/pause)
            string action = ServiceHelpers.ExtractRequestParams(request);

            // check
            if (null == task)
            {
                task = mManager.AddTask(RESOLVER_NAME, param);
            }
            else
            {
                task.SetParams(param);
            }

            string response = "<task name='" + RESOLVER_NAME + "'>" + task.GetResult() + "</task>";

            //mManager.RemoveTask ();
            return(response);
        }
Example #5
0
        private void RunTask(Object _task)
        {
            IServiceTask task = (IServiceTask)_task;

            task.Run();
            //Logger.LogInfo("ServiceExecutor.RunTask", "任务【" + task.GetTaskName() + "】所在工作线程退出");
        }
 public IService CreateService(IServiceTask messageObj) 
 {
     if(serviceCreators.Contains(messageObj.GetType()) 
     {
          return serviceCreators[messageObj.GetType()];
     }
     return new DefaultService();
 }
        public TaskServiceEnumerator(IServiceTask task)
        {
            DBC.Tasks.Check.Require((task is IEnumerable == false) && (task is IEnumerator == false), "Tasks and IEnumerators are mutually exclusive");

            this.task = task;

            DBC.Tasks.Check.Ensure(task != null, "a valid task must be assigned");
        }
Example #8
0
        public void Execute()
        {
            var handledMissedSlot = false;

            while (serviceState != ServiceState.ShuttingDown)
            {
                if (serviceState == ServiceState.Started)
                {
                    bool missedSlot;
                    var  run = Scheduler.RunTask(LastRunTime, dateTimeProvider.Now, out missedSlot);

                    if (!handledMissedSlot && missedSlot)
                    {
                        Log("Previous execution slot missed. Please check for consistency issues.");
                        handledMissedSlot = true;
                    }

                    if (run)
                    {
                        try
                        {
                            if (serviceTask == null)
                            {
                                serviceTask = CreateServiceTask();
                            }

                            Log("Executing task");

                            var watch = Stopwatch.StartNew();
                            serviceTask.ExecuteTask();
                            watch.Stop();

                            Log("Execution completed in {0}", watch.Elapsed);
                            LastRunTime = dateTimeProvider.Now;

                            handledMissedSlot = false;

                            PersistLastExecutionTime(LastRunTime, watch.Elapsed);
                            ResetFailureCount();
                        }
                        catch (Exception ex)
                        {
                            serviceTask = null;
                            LogException(ex);
                            IncrementFailureCount();
                        }
                    }

                    Sleep();
                }
            }

            Log("Shut down");
            Thread.CurrentThread.Abort();
        }
Example #9
0
        public bool RemoveTask(string name)
        {
            IServiceTask task = getTaskByName(name);

            if (null == task)
            {
                // task already removed or has not been launched
                return(false);
            }
            task.Stop(false);
            mEntities.Remove(name);
            return(true);
        }
 private void ExecuteServiceTask(ServiceTask task)
 {
     try
     {
         IServiceTask    serviceTask = (IServiceTask)Activator.CreateInstance(task.ExecuteAssembly, task.ExecuteModule).Unwrap();
         DatabaseContext context     = new DatabaseContext();
         serviceTask.Run(context, log, task.Settings);
     }
     catch (Exception ex)
     {
         log.LogException(ex);
     }
 }
Example #11
0
        public int Execute(IServiceTask task)
        {
            int ret = -1;

            if (task == null)
            {
                return((int)CurrentExecutorState.ADD_TASK_IS_NULL);
            }

            lock (this.addTaskLock)
            {
                currentTaskCount = taskDict.Count;
                if (currentTaskCount == allowedTaskNumber)
                {
                    return((int)CurrentExecutorState.REACH_MAX_TASK_LIMIT);
                }

                if (task.IsRunning)
                {
                    return((int)CurrentExecutorState.TASK_IS_ON_RUNNING);
                }

                if (task.GetTaskName() == null || task.GetTaskName().Equals(""))
                {
                    return((int)CurrentExecutorState.TASK_NAME_IS_EMPTY);
                }

                if (this.taskDict.ContainsKey(task.GetTaskName()))
                {
                    //Logger.LogInfo("ServiceExecutor.Execute", "工作任务【" + task.GetTaskName() + "】已经添加,不能重复添加相同任务");
                    return((int)CurrentExecutorState.HAS_SAME_NAME_TASK_IN_QUEUE);
                }

                this.taskDict.Add(task.GetTaskName(), task);
                task.OnServiceTaskEndHandler += this.OnServiceTaskEndHandler;

                if (task.StartTask() != 0)
                {
                    this.taskDict.Remove(task.GetTaskName());
                    task.OnServiceTaskEndHandler -= this.OnServiceTaskEndHandler;
                }

                ThreadPool.QueueUserWorkItem(new WaitCallback(RunTask), task);
                ret = (int)CurrentExecutorState.ADD_TASK_SUCCESS;

                //Logger.LogInfo("ServiceExecutor.Execute", "工作任务添加成功【" + task.GetTaskName() + "】");
            }

            return(ret);
        }
Example #12
0
        public string ProcessRequest(string request)
        {
            IServiceTask task = mManager.getTaskByName(RESOLVER_NAME);

            if (null == task)
            {
                task = mManager.AddTask(RESOLVER_NAME, ServiceHelpers.ExtractRequestParams(request));
            }

            string response = "<task name='" + RESOLVER_NAME + "'>" + task.GetResult() + "</task>";

            //mManager.RemoveTask ();
            return(response);
        }
Example #13
0
        public bool TryEnqueue(IServiceTask step)
        {
            try
            {
                this.queue.Add(step);
                return(true);
            }
            catch (InvalidOperationException)
            {
                // We called queue.CompleteAdding()
            }

            return(false);
        }
Example #14
0
        public bool IsTaskRunning(String taskName)
        {
            bool         ret  = false;
            IServiceTask task = ServiceManager.Instance.CurrentExecutor.GetTaskByName(taskName);

            if (task != null && task.IsRunning)
            {
                ret = true;
            }
            else
            {
                ret = false;
            }
            return(ret);
        }
Example #15
0
        public IServiceTask GetTaskByName(String taskName)
        {
            IServiceTask retTask = null;

            if (taskName == null || taskName.Equals(""))
            {
                return(retTask);
            }

            if (this.taskDict.ContainsKey(taskName))
            {
                retTask = this.taskDict[taskName];
            }

            return(retTask);
        }
Example #16
0
        public bool RemoveAllTasks()
        {
            bool res = true;

            foreach (KeyValuePair <string, IServiceTask> taskPair in mEntities)
            {
                IServiceTask task = taskPair.Value;
                if (null == task)
                {
                    res = false;
                    continue;
                }

                task.Stop(false);
            }
            mEntities.Clear();
            return(res);
        }
Example #17
0
        private void addServiceTaskCompensationHandler(IBpmnModelInstance modelInstance, string boundaryEventId, string compensationHandlerId)
        {
            IBoundaryEvent boundaryEvent = (IBoundaryEvent)modelInstance.GetModelElementById/*<IBoundaryEvent>*/ (boundaryEventId);
            IBaseElement   scope         = (IBaseElement)boundaryEvent.ParentElement;

            IServiceTask compensationHandler = modelInstance.NewInstance <IServiceTask>(typeof(IServiceTask));

            compensationHandler.Id = compensationHandlerId;
            compensationHandler.ForCompensation = true;
            //JAVA TO C# CONVERTER WARNING: The .NET Type.FullName property will not always yield results identical to the Java Class.GetName method:
            compensationHandler.CamundaClass = typeof(IncreaseCurrentTimeServiceTask).FullName;
            scope.AddChildElement(compensationHandler);

            IAssociation association = modelInstance.NewInstance <IAssociation>(typeof(IAssociation));

            association.AssociationDirection = AssociationDirection.One;
            association.Source = boundaryEvent;
            association.Target = compensationHandler;
            scope.AddChildElement(association);
        }
Example #18
0
        public IServiceTask AddTask(string name, string parameters)
        {
            IServiceTask task = getTaskByName(name);

            if (null != task)
            {
                // task already launched
                return(task);
            }

            if (name == StatusResolver.RESOLVER_NAME)
            {
                task = new StatusTask(mLogger);
            }
            else if (name == MemoryMonitorResolver.RESOLVER_NAME)
            {
                task = new MemoryMonitorTask(mLogger);
            }
            else if (name == ProcessorMonitorResolver.RESOLVER_NAME)
            {
                task = new ProcessorMonitorTask(mLogger);
            }
            else if (name == AppPoolMonitorResolver.RESOLVER_NAME)
            {
                task = new AppPoolMonitorTask(mLogger);
            }
            else if (name == ClearFolderResolver.RESOLVER_NAME)
            {
                task = new ClearFolderTask(mLogger);
            }
            else if (name == RecycleAppPoolResolver.RESOLVER_NAME)
            {
                task = new RecycleAppPoolTask(mLogger);
            }

            mEntities.Add(name, task);
            task.SetParams(parameters);
            task.Start();

            return(task);
        }
Example #19
0
        private void OnServiceTaskEndHandler(Object sender, ServiceTaskEndEventArgs args)
        {
            try
            {
                if (args == null || args.Task == null)
                {
                    return;
                }

                IServiceTask task = args.Task;

                if (this.taskDict.ContainsKey(task.GetTaskName()))
                {
                    this.taskDict.Remove(task.GetTaskName());
                }
                task.OnServiceTaskEndHandler -= this.OnServiceTaskEndHandler;
                //Logger.LogInfo("ServiceExecutor.OnServiceTaskEndHandler", "工作任务清理成功 : " + task.GetTaskName());
            }
            catch (System.Exception ex)
            {
                //Logger.LogError(methodStr, "在Service Executor的事件函数中捕获未知异常" + ex.Message);
                QueueInstance.Instance.AddMyLogList(System.DateTime.Now.ToString() + "创建Socket对象时捕获异常" + ex.Message);
            }
        }
Example #20
0
        /// <summary>
        /// Checks if a serviceTask is due to be executed
        /// </summary>
        /// <param name="serviceTask">Service task to execute</param>
        /// <returns>bool indicating if it is due to be executed <c>(value=true)</c> or not<c>(value=false)</c></returns>
        private static bool IsRunRequired(IServiceTask serviceTask)
        {
            // if it is currently running then it is not required to run
            if (serviceTask.State == TaskState.Running)
            {
                return false;
            }

            // If a retry is scheduled, ignore all other schedules for this task until the retry is resolved
            if (currentRetriesTimes.ContainsKey(serviceTask.TaskName))
            {
                return currentRetriesTimes[serviceTask.TaskName].CompareTo(DateTime.UtcNow) < 0 &&
                        currentRetryCounts[serviceTask.TaskName] > 0;
            }

            // Get the date it was last executed
            DateTime lastEx = GetDateTimeLastExecuted(serviceTask);

            // first check for time-of-day schedule, if the service is scheduled for a time-of-day ignore interval executions
            if (executionTimings.ContainsKey(serviceTask.TaskName))
            {
                foreach (string time in executionTimings[serviceTask.TaskName])
                {
                    // Get today's date based on the execution time from config
                    DateTime exTime = ToTodaysDate(time);

                    // Should task have run by now i.e. has the scheduled time passed
                    if (exTime.CompareTo(DateTime.UtcNow) > 0)
                    {
                        continue;
                    }

                    // Had task run already i.e. has the task run for this schedules execute time yet
                    if (exTime.CompareTo(lastEx) < 0)
                    {
                        continue;
                    }

                    // Run required
                    return true;
                }
            }
            else
            {
                if (executionIntervals.ContainsKey(serviceTask.TaskName))
                {
                    // If the time since last run plus the timespan is less than now
                    if (lastEx.Add(executionIntervals[serviceTask.TaskName]) <= DateTime.UtcNow)
                    {
                        return true;
                    }
                }
                else
                {
                    if (log.IsWarnEnabled)
                    {
                        log.LogWarn("No interval or scheduled time could be found for service {0}", serviceTask.TaskName);
                    }
                }
            }

            // Run is not required
            return false;
        }
 public static void Clear()
 {
     ModelInstance = null;
     ServiceTask   = null;
 }
Example #22
0
 /// <summary>
 /// Returns the last time the service executed.
 /// </summary>
 /// <param name="serviceTask">Name of the service</param>
 /// <returns>Date it last executed</returns>
 private static DateTime GetDateTimeLastExecuted(IServiceTask serviceTask)
 {
     if (!taskLastExecuted.ContainsKey(serviceTask.TaskName))
     {
         return DateTime.MinValue;
     }
     return taskLastExecuted[serviceTask.TaskName];
 }
Example #23
0
 /// <summary>
 /// Schedules a retry on the tasks configured retry interval
 /// </summary>
 /// <remarks>
 /// Only hit if service fails or a non-queue based service
 /// </remarks>
 /// <param name="serviceTask"></param>
 private static void ScheduleRetry(IServiceTask serviceTask)
 {
     // Check if a retry is configured
     if (retryIntervalSettings.ContainsKey(serviceTask.TaskName))
     {
         if (currentRetriesTimes.ContainsKey(serviceTask.TaskName) &&
             currentRetryCounts.ContainsKey(serviceTask.TaskName))
         {
             if (currentRetryCounts[serviceTask.TaskName] > 0)
             {
                 currentRetriesTimes[serviceTask.TaskName] =
                     DateTime.UtcNow.Add(retryIntervalSettings[serviceTask.TaskName].Interval.Value);
                 // deduct one retry
                 currentRetryCounts[serviceTask.TaskName] = currentRetryCounts[serviceTask.TaskName] - 1;
             }
             else
             {
                 // remove and fail?
             }
         }
         else
         {
             currentRetriesTimes.TryAdd(serviceTask.TaskName, DateTime.UtcNow.Add(retryIntervalSettings[serviceTask.TaskName].Interval.Value));
             currentRetryCounts.TryAdd(serviceTask.TaskName, retryIntervalSettings[serviceTask.TaskName].RetryCount);
         }
     }
 }
Example #24
0
 public HomeController(IUnitOfWork unitOfWork, IServiceTask serviceTask) : base(unitOfWork)
 {
     _serviceTask = serviceTask;
 }
Example #25
0
        /// <summary>
        /// Updates internal collections and the database with the last time the service executed
        /// </summary>
        /// <param name="serviceTask"></param>
        private static void UpdateLastExecutionDate(IServiceTask serviceTask, DateTime? date)
        {
            if (date == null)
            {
                date = DateTime.UtcNow;
            }
            // Try updating the database. This enables the services to keep running. 
            try
            {
                string sbSqlStatement = @"UPDATE Control.ServiceTaskLastExecution
                                       SET LastExecutedLT = @LastRunTimeLT WHERE ServiceTaskName = @ServiceTaskName ;
                                       IF (@@ROWCOUNT = 0)
                                       BEGIN
                                         INSERT INTO Control.ServiceTaskLastExecution VALUES(@ServiceTaskName,@LastRunTimeLT) 
                                       END ";
                List<SqlParameter> parameters = new List<SqlParameter>();
                parameters.Add(DbHelper.CreateParameter("ServiceTaskName", serviceTask.TaskName));
                parameters.Add(DbHelper.CreateParameter("LastRunTimeLT", date.Value));
                DbHelper.ExecuteNonQueryCommand(sbSqlStatement, parameters: parameters);
            }
            catch (Exception ex)
            {
                log.LogError("Failed to update database with last run date for service: " + serviceTask.TaskName, null, ex);
            }

            // Update the local collection
            if (!taskLastExecuted.ContainsKey(serviceTask.TaskName))
            {
                taskLastExecuted.TryAdd(serviceTask.TaskName, date.Value);
            }
            else
            {
                taskLastExecuted[serviceTask.TaskName] = date.Value;
            }
        }
Example #26
0
 public ServiceTaskEndEventArgs(IServiceTask _task)
 {
     this.task = _task;
 }
Example #27
0
 /// <summary>
 /// Set up the tasks with their retry settings and add them to the list of service tasks
 /// </summary>
 /// <param name="serviceTask">service task to initialize</param>
 private static void InitialiseServiceTask(IServiceTask serviceTask)
 {
     serviceTaskList.Add(serviceTask);
     // set retry interval (so inner service task can deal with it if needed)
     ServiceTaskRetryInterval resultValue;
     if (retryIntervalSettings.TryGetValue(serviceTask.TaskName, out resultValue))
     {
         serviceTask.RetryIntervalSettings = resultValue;
     }
 }
Example #28
0
 public ServiceTaskBuilder(IBpmnModelInstance modelInstance, IServiceTask element) : base(modelInstance, element)
 {
 }