Ejemplo n.º 1
0
        /// <summary>
        /// 停止节点任务(停止LAST_TASK_ID字段中值对应的任务)
        /// </summary>
        /// <param name="nodeID">节点ID</param>
        /// <param name="message">返回信息</param>
        /// <returns>是否执行成功</returns>
        public bool Stop(int nodeID, ref string message)
        {
            try
            {
                Entity ne = GetEntityByKey <Entity>(nodeID);
                if (ne == null)
                {
                    message = "未找到节点【" + nodeID + "】";
                    return(false);
                }
                if (ne.RUN_STATUS == (short)Enums.RunStatus.结束 || ne.LAST_TASK_ID < 1)
                {
                    message = "节点当前未执行任务或当前任务已经停止";
                    return(false);
                }

                //节点节点最新任务运行状态
                SetLastTaskResult(nodeID, 0, false);

                //对应的任务
                BF_ST_TASK.Entity te = BF_ST_TASK.Instance.GetEntityByKey <BF_ST_TASK.Entity>(ne.LAST_TASK_ID);
                if (te == null)
                {
                    message = "未找到节点的最新任务【" + ne.LAST_TASK_ID + "】";
                    return(false);
                }
                if (te.RUN_STATUS == (short)Enums.RunStatus.结束)
                {
                    message = "节点的最新任务【" + ne.LAST_TASK_ID + "】已经停止";
                    return(false);
                }

                //停止任务
                return(BF_ST_TASK.Instance.Stop(ne.LAST_TASK_ID, ref message));
            }
            catch (Exception ex)
            {
                message = "停止节点任务出错,详见日志";
                BLog.Write(BLog.LogLevel.WARN, "停止节点【" + nodeID + "】任务出错:" + ex.ToString());
            }

            return(false);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// 停止脚本任务(停止LAST_TASK_ID字段中值对应的任务)
        /// </summary>
        /// <param name="flowID">脚本ID</param>
        /// <param name="message">返回信息</param>
        /// <returns>是否执行成功</returns>
        public bool Stop(int flowID, ref string message)
        {
            try
            {
                Entity fe = GetEntityByKey <Entity>(flowID);
                if (fe == null)
                {
                    message = "未找到脚本【" + flowID + "】";
                    return(false);
                }
                if (fe.RUN_STATUS == (short)Enums.RunStatus.结束 || fe.LAST_TASK_ID < 1)
                {
                    message = "脚本未执行任务或当前任务已经停止";
                    return(false);
                }
                //设置脚本最新任务的状态
                SetLastTaskResult(flowID, false);

                //对应的任务
                BF_ST_TASK.Entity te = BF_ST_TASK.Instance.GetEntityByKey <BF_ST_TASK.Entity>(fe.LAST_TASK_ID);
                if (te == null)
                {
                    message = "未找到脚本的最新任务【" + fe.LAST_TASK_ID + "】";
                    return(false);
                }
                if (te.RUN_STATUS == (short)Enums.RunStatus.结束)
                {
                    message = "脚本的最新任务【" + fe.LAST_TASK_ID + "】已经停止";
                    return(false);
                }

                //停止任务
                return(BF_ST_TASK.Instance.Stop(fe.LAST_TASK_ID, ref message));
            }
            catch (Exception ex)
            {
                message = "停止脚本任务出错,详见日志";
                BLog.Write(BLog.LogLevel.WARN, "停止脚本【" + flowID + "】任务出错:" + ex.ToString());
            }

            return(false);
        }
Ejemplo n.º 3
0
        /// <summary>
        /// 根据任务创建任务节点
        /// </summary>
        /// <param name="taskEntity">任务</param>
        /// <returns></returns>
        public int AddFromTask(BF_ST_TASK.Entity taskEntity)
        {
            if (taskEntity == null)
            {
                throw new Exception("任务不存在");
            }

            DataTable dt = GetTable("TASK_ID=?", taskEntity.ID);

            if (dt != null && dt.Rows.Count > 0)
            {
                SetWait(taskEntity.ID);
                CS.Base.Log.BLog.Write(Base.Log.BLog.LogLevel.WARN, string.Format("任务【{0}】已经有【{1}】个节点实例,将不创建新的实例", taskEntity.ID, dt.Rows.Count));
                return(dt.Rows.Count);
            }

            //单节点任务
            if (taskEntity.NODE_ID > 0)
            {
                BF_ST_NODE.Entity ne = BF_ST_NODE.Instance.GetEntityByKey <BF_ST_NODE.Entity>(taskEntity.NODE_ID);
                if (ne == null)
                {
                    throw new Exception(string.Format("任务【{0}】的节点【{1}】不存在", taskEntity.ID, taskEntity.NODE_ID));
                }
                Entity entity = new Entity();
                entity.TASK_ID        = taskEntity.ID;
                entity.FLOW_ID        = 0;
                entity.NODE_ID        = taskEntity.NODE_ID;
                entity.CONTENT        = ne.CONTENT;
                entity.RUN_STATUS     = (Int16)Enums.RunStatus.等待.GetHashCode();
                entity.RETRY_TIMES    = 0;
                entity.REFERENCE_DATE = taskEntity.REFERENCE_DATE;
                entity.BEGIN_DATE     = taskEntity.BEGIN_DATE;
                entity.END_DATE       = taskEntity.END_DATE;
                entity.PARAMETER      = taskEntity.PARAMETER;

                return(Add(entity));
            }

            //脚本流任务
            int i = 0;

            BF_ST_FLOW.Entity fe = BF_ST_FLOW.Instance.GetEntityByKey <BF_ST_FLOW.Entity>(taskEntity.FLOW_ID);
            if (fe == null)
            {
                throw new Exception(string.Format("任务【{0}】没有配置有效脚本", taskEntity.ID));
            }

            IList <BF_ST_FLOW_NODE.Entity> fnList = BF_ST_FLOW_NODE.Instance.GetListByFlowID(taskEntity.FLOW_ID);

            if (fnList == null || fnList.Count < 1)
            {
                throw new Exception(string.Format("任务【{0}】没有配置有效节点", taskEntity.ID));
            }

            //添加相关节点
            foreach (BF_ST_FLOW_NODE.Entity fn in fnList)
            {
                BF_ST_NODE.Entity ne = BF_ST_NODE.Instance.GetEntityByKey <BF_ST_NODE.Entity>(fn.NODE_ID);
                if (ne == null)
                {
                    throw new Exception(string.Format("任务【{0}】的相关节点【{1}】不存在", taskEntity.ID, fn.NODE_ID));
                }

                Entity entity = new Entity();
                entity.TASK_ID = taskEntity.ID;
                entity.FLOW_ID = taskEntity.FLOW_ID;
                entity.NODE_ID = fn.NODE_ID;
                if (string.IsNullOrWhiteSpace(fn.PRE_NODE_IDS) == false)
                {
                    entity.PRE_NODE_IDS = fn.PRE_NODE_IDS.Trim(new char[] { ',', ' ' });
                }
                entity.DIV_X          = fn.DIV_X;
                entity.DIV_Y          = fn.DIV_Y;
                entity.CONTENT        = ne.CONTENT;
                entity.RUN_STATUS     = (Int16)Enums.RunStatus.等待.GetHashCode();
                entity.RETRY_TIMES    = fe.RETRY_TIMES;
                entity.REFERENCE_DATE = taskEntity.REFERENCE_DATE;
                entity.BEGIN_DATE     = taskEntity.BEGIN_DATE;
                entity.END_DATE       = taskEntity.END_DATE;
                entity.PARAMETER      = taskEntity.PARAMETER;

                i += Add(entity);
            }
            return(i);
        }