protected override void Run()
{
try
{
var req = new UpdateNodeRefreshCommandQueueStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Web, RefreshStatus = RefreshCommandQueueStatus.Refreshing, MonitorClassName = this.GetType().Name
};
var r = NodeProxy.PostToServer <EmptyResponse, UpdateNodeRefreshCommandQueueStatusRequest>(ProxyUrl.UpdateNodeRefreshCmdQueueStatus_Url, req);
if (r.Status != ResponesStatus.Success)
{
string title = "节点(编号):" + GlobalNodeConfig.NodeInfo.nodename + "(" + GlobalNodeConfig.NodeInfo.id.ToString() + ")上报监听命令状态失败,请及时处理!";
StringBuilder strContent = new StringBuilder();
strContent.AppendLine("请求地址:" + ProxyUrl.UpdateNodeRefreshCmdQueueStatus_Url + "<br/>");
strContent.AppendLine("请求参数:" + JsonConvert.SerializeObject(req) + "<br/>");
strContent.AppendLine("响应结果:" + JsonConvert.SerializeObject(r) + "<br/>");
AlarmHelper.AlarmAsync(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, title, strContent.ToString());
LogProxy.AddNodeErrorLog(strContent.ToString());
}
}
catch (Exception ex)
{
LogProxy.AddNodeErrorLog("节点(" + GlobalNodeConfig.NodeInfo.nodename + "(" + GlobalNodeConfig.NodeInfo.id.ToString() + ")" + ")监听命令队列监控异常:" + ex.Message + ",异常:" + JsonConvert.SerializeObject(ex));
AlarmHelper.AlarmAsync(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, "节点(" + GlobalNodeConfig.NodeInfo.nodename + "(" + GlobalNodeConfig.NodeInfo.id.ToString() + ")" + ")监听命令队列监控异常", JsonConvert.SerializeObject(ex));
}
}
protected override void Run()
{
var res = NodeProxy.PostToServer <EmptyResponse, UpdateNodeMonitorRequest>(ProxyUrl.UpdateNodeMonitorRequest_Url, new UpdateNodeMonitorRequest()
{
MonitorClassName = this.GetType().Name, MonitorStatus = (int)MonitorStatus.Monitoring, NodeId = GlobalNodeConfig.NodeID, Source = Source.Node
});
if (res.Status != ResponesStatus.Success)
{
LogProxy.AddNodeErrorLog(this.GetType().Name + "监控组件上报监控信息失败,请求地址:" + ProxyUrl.UpdateNodeMonitorRequest_Url + ",返回结果:" + JsonConvert.SerializeObject(res));
}
foreach (var taskruntimeinfo in TaskPoolManager.CreateInstance().GetList())
{
try
{
if (taskruntimeinfo == null)
{
continue;
}
string fileinstallpath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\" + GlobalNodeConfig.TaskDllDir + @"\" + taskruntimeinfo.TaskModel.id;
double dirsizeM = -1;
if (System.IO.Directory.Exists(fileinstallpath))
{
long dirsize = IOHelper.DirSize(new DirectoryInfo(fileinstallpath));
dirsizeM = (double)dirsize / 1024 / 1024;
}
try
{
if (taskruntimeinfo.Domain != null)
{
//上报性能
AddPerformanceRequest addperformance = new AddPerformanceRequest()
{
NodeId = GlobalNodeConfig.NodeID,
Cpu = taskruntimeinfo.Domain.MonitoringTotalProcessorTime.TotalSeconds.ToString(),
Memory = ((double)taskruntimeinfo.Domain.MonitoringSurvivedMemorySize / 1024 / 1024).ToString(),//AppDomain当前正在使用的字节数（只保证在上一次垃圾回收时是准确的）
InstallDirsize = dirsizeM.ToString(),
TaskId = taskruntimeinfo.TaskModel.id,
Lastupdatetime = (DateTime.Now).ToString(),
Source = Source.Node,
};
var r = NodeProxy.PostToServer <EmptyResponse, AddPerformanceRequest>(ProxyUrl.AddPerformance_Url, addperformance);
if (r.Status != ResponesStatus.Success)
{
LogProxy.AddTaskErrorLog("任务性能上报出错,请求地址:" + ProxyUrl.AddPerformance_Url + ",请求内容:" + JsonConvert.SerializeObject(addperformance) + ",返回结果:" + JsonConvert.SerializeObject(r), taskruntimeinfo.TaskModel.id);
}
}
}
catch (Exception ex)
{
LogProxy.AddTaskErrorLog("任务性能监控时出错:taskid=" + taskruntimeinfo.TaskModel.id + ",异常信息:" + JsonConvert.SerializeObject(ex), taskruntimeinfo.TaskModel.id);
}
}
catch (Exception exp)
{
LogProxy.AddNodeErrorLog("任务性能监控异常,异常信息:" + JsonConvert.SerializeObject(exp));
}
}
}
/// <summary>
/// 扫描命令队列并添加到任务池
/// </summary>
private static void ScanCommandAndExecute()
{
//1.扫描分配给该节点的任务命令（读库或者直接读webapi）
//2.遍历命令集合，并从命令池中找寻命令并执行，执行成功，更新命令队列，执行失败也更新命令状态
var r = NodeProxy.PostToServer <LoadCommandQueueListResponse, LoadCommandQueueListRequest>(ProxyUrl.LoadCommandQueueList_Url, new LoadCommandQueueListRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, LastMaxId = lastMaxID
});
if (r.Status != ResponesStatus.Success)
{
onInitTaskPool("读取命令失败,服务器返回:" + JsonConvert.SerializeObject(r));
return;
}
if (r.Data.CommandQueueList.Count > 0)
{
onInitTaskPool("当前节点扫描到" + r.Data.CommandQueueList.Count + "条命令,并执行中");
}
foreach (var item in r.Data.CommandQueueList)
{
try
{
CommandPoolManager.CreateInstance().Get(item.commanddetailid.ToString()).commandBase.Execute();
//更新命令队列节点状态
var r2 = NodeProxy.PostToServer <EmptyResponse, UpdateCommandQueueStatusRequest>(ProxyUrl.UpdateCommandQueueStatus_Url, new UpdateCommandQueueStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, CommandQueueId = item.id, CommandStatus = CommandQueueStatus.ExecuteSuccess
});
if (r2.Status != ResponesStatus.Success)
{
onInitTaskPool("更新命令状态(成功)失败,服务器返回:" + JsonConvert.SerializeObject(r));
//记录节点错误日志
return;
}
//更新命令状态为成功
onInitTaskPool(string.Format("当前节点执行命令成功! id:{0},命令名:{1},命令参数:{2}", item.id, item.commandmainclassname, item.commandparams));
}
catch (Exception ex)
{
//更新命令状态为错误
var r2 = NodeProxy.PostToServer <EmptyResponse, UpdateCommandQueueStatusRequest>(ProxyUrl.UpdateCommandQueueStatus_Url, new UpdateCommandQueueStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, CommandQueueId = item.id, CommandStatus = CommandQueueStatus.ExecuteError
});
if (r2.Status != ResponesStatus.Success)
{
onInitTaskPool("执行节点命令异常,更新命令状态为错误,服务器返回:" + JsonConvert.SerializeObject(r));
//记录节点错误日志
return;
}
//添加任务执行失败日志
onInitTaskPool("执行节点命令异常:任务id:" + item.taskid + ",命令名称:" + item.commandmainclassname + "(" + item.id + ")", ex);
}
}
}
protected override void Run()
{
try
{
var res = NodeProxy.PostToServer <EmptyResponse, UpdateNodeMonitorRequest>(ProxyUrl.UpdateNodeMonitorRequest_Url, new UpdateNodeMonitorRequest()
{
MonitorClassName = this.GetType().Name, MonitorStatus = (int)MonitorStatus.Monitoring, NodeId = GlobalNodeConfig.NodeID, Source = Source.Node
});
if (res.Status != ResponesStatus.Success)
{
LogProxy.AddNodeErrorLog(this.GetType().Name + "监控组件上报监控信息失败,请求地址:" + ProxyUrl.UpdateNodeMonitorRequest_Url + ",返回结果:" + JsonConvert.SerializeObject(res));
}
LoadTaskIdListRequest req = new LoadTaskIdListRequest()
{
Source = Source.Node, TaskScheduleStatus = (int)TaskScheduleStatus.Scheduling, NodeId = GlobalNodeConfig.NodeID
};
var r = NodeProxy.PostToServer <LoadTaskIdListResponse, LoadTaskIdListRequest>(ProxyUrl.LoadTaskIdList_Url, req);
List <int> taskschdulinglist = TaskPoolManager.CreateInstance().GetList().Select(x => x.TaskModel.id).ToList();
if (r.Status != ResponesStatus.Success)
{
//如果服务端没有调度中的，则把本地在调度中的上报状态
if (taskschdulinglist.Count > 0)
{
UploadLocalTask(taskschdulinglist);
}
return;
}
List <int> taskidnotserver = taskschdulinglist.Where(x => !(r.Data.TaskIdList.Contains(x))).ToList();
r.Data.TaskIdList.ForEach(x =>
{
var taskruntimeInfo = TaskPoolManager.CreateInstance().Get(x.ToString());
if (taskruntimeInfo == null)//如果等于空值则报警,说明该任务再
{
string title = "节点(id):" + GlobalNodeConfig.NodeInfo.nodename + "(" + GlobalNodeConfig.NodeInfo.id.ToString() + "),任务id:(" + x + ")" + ",调度异常,请及时处理!";
StringBuilder strContent = new StringBuilder();
strContent.AppendLine("所在节点名称(编号):" + GlobalNodeConfig.NodeInfo.nodename + "(" + GlobalNodeConfig.NodeID + ")<br/>");
strContent.AppendLine("任务编号:" + x + "<br/>");
strContent.AppendLine("服务端任务状态:调度中<br/>");
strContent.AppendLine("节点端任务状态:任务池中已不存在该任务,调度异常<br/>");
AlarmHelper.AlarmAsync(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, title, strContent.ToString());
LogProxy.AddNodeErrorLog(strContent.ToString());
}
});
if (taskidnotserver.Count > 0)
{
UploadLocalTask(taskidnotserver);
}
}
catch (Exception ex)
{
LogProxy.AddNodeErrorLog("节点(" + GlobalNodeConfig.NodeInfo.nodename + "(" + GlobalNodeConfig.NodeInfo.id.ToString() + ")" + ")监控调度中任务异常:" + ex.Message + ",异常:" + JsonConvert.SerializeObject(ex));
AlarmHelper.AlarmAsync(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, "节点(" + GlobalNodeConfig.NodeInfo.nodename + "(" + GlobalNodeConfig.NodeInfo.id.ToString() + ")" + ")监控调度中任务异常", JsonConvert.SerializeObject(ex));
}
}
/// <summary>
/// 构建命令池
/// </summary>
public void BuildCommandPool()
{
try
{
//读取库中命令，然后反射创建对象，封装命令运行时信息，并添加到命令池中
var r = NodeProxy.PostToServer <LoadCommandListResponse, LoadCommandListRequest>(ProxyUrl.LoadCommandList_Url, new LoadCommandListRequest()
{
NodeId = GlobalNodeConfig.NodeID.ToString(), Source = Source.Node
});
if (r.Status != ResponesStatus.Success)
{
onInit("读取命令失败,服务器返回:" + JsonConvert.SerializeObject(r));
return;
}
if (r.Data.CommandLibDetailList.Count <= 0)
{
onInit("读取到0条命令,无法构建命令池");
return;
}
int commandCount = r.Data.CommandLibDetailList.Count;
onInit("读取到" + commandCount.ToString() + "条命令");
onInit("开始创建命令对象,并添加到命令池");
int sucess = 0;
int failed = 0;
foreach (var item in r.Data.CommandLibDetailList)
{
try
{
var cmdruntime = CommandFactory.Create(item);
if (cmdruntime != null)
{
CommandPoolManager.CreateInstance().Add(item.id.ToString(), cmdruntime);
sucess += 1;
}
else
{
onInit("命令:" + item.commandname + "(" + item.id.ToString() + "),添加到命令池失败!创建命令对象为null");
failed += 1;
}
}
catch (Exception ex)
{
onInit("命令:" + item.commandname + "(" + item.id.ToString() + "),添加到命令池失败!", ex);
failed += 1;
}
}
onInit("构建命令池完成,命令总数量:" + commandCount + ",成功数量:" + sucess.ToString() + ",失败数量:" + failed.ToString());
}
catch (Exception ex)
{
onInit("命令池构建失败：" + ex.Message, ex);
}
}
/// <summary>
/// 上报任务调度状态
/// </summary>
/// <param name="taskid"></param>
/// <param name="taskversionid"></param>
/// <param name="status"></param>
private void UploadStatus(string taskid, string taskversionid, TaskScheduleStatus status, string nextruntime = "")
{
var req2 = new UpdateTaskScheduleStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, ScheduleStatus = status, TaskId = int.Parse(taskid), TaskVersionId = int.Parse(taskversionid), NextRunTime = nextruntime
};
var r3 = NodeProxy.PostToServer <EmptyResponse, UpdateTaskScheduleStatusRequest>(ProxyUrl.UpdateTaskScheduleStatus_Url, req2);
if (r3.Status != ResponesStatus.Success)
{
ShowCommandLog("更新任务调度状态(" + status.description() + ")失败,请求Url：" + ProxyUrl.UpdateTaskScheduleStatus_Url + ",请求参数:" + JsonConvert.SerializeObject(req2) + ",返回参数:" + JsonConvert.SerializeObject(r3));
}
}
/// <summary>
/// 执行
/// </summary>
public override RunCommandResult Execute()
{
try
{
RefreshCommandQueueStatus refreshStatus = RefreshCommandQueueStatus.Refreshing;
if (CommandQueueScanManger.IsStopCommandQueue())
{
refreshStatus = RefreshCommandQueueStatus.NoRefresh;
}
else
{
bool isStop = CommandQueueScanManger.StopScanCommandQueue();
if (isStop)
{
refreshStatus = RefreshCommandQueueStatus.NoRefresh;
}
else
{
refreshStatus = RefreshCommandQueueStatus.Refreshing;
}
}
var r = NodeProxy.PostToServer <EmptyResponse, UpdateNodeRefreshCommandQueueStatusRequest>(ProxyUrl.UpdateNodeRefreshCmdQueueStatus_Url, new UpdateNodeRefreshCommandQueueStatusRequest()
{
NodeId = int.Parse(this.AppConfig["nodeid"]), Source = (Source)int.Parse(this.AppConfig["source"]), RefreshStatus = refreshStatus
});
if (r.Status != ResponesStatus.Success)
{
ShowCommandLog("停止节点刷新命令队列失败,服务器返回:" + JsonConvert.SerializeObject(r));
}
//添加日志
ShowCommandLog("停止节点刷新命令队列成功");
return(new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteSucess
});
}
catch (Exception ex)
{
ShowCommandLog("停止节点刷新命令队列失败,异常信息:" + JsonConvert.SerializeObject(ex));
return(new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteException, Ex = ex, Message = ex.Message
});
}
}
///// <summary>
///// 上一次日志扫描的最大id
///// </summary>
//public static int lastMaxID = -1;
#region 开启任务扫描
/// <summary>
/// 开启任务扫描
/// </summary>
/// <returns></returns>
public override bool StartScanCommandQueue()
{
//1.扫描分配给该节点的任务命令（读库或者直接读webapi）
//2.遍历命令集合，并从命令池中找寻命令并执行，执行成功，更新命令队列，执行失败也更新命令状态
var r = NodeProxy.PostToServer <LoadCommandQueueListResponse, LoadCommandQueueListRequest>(ProxyUrl.LoadCommandQueueList_Url, new LoadCommandQueueListRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, LastMaxId = GlobalNodeConfig.NodeInfo.lastmaxid, CommandStatus = (int)Model.enums.ExecuteStatus.NoExecute
});
if (r.Status != ResponesStatus.Success)
{
onScanMsg("读取命令失败,服务器返回:" + JsonConvert.SerializeObject(r));
return(false);
}
int sucess = 0;
int failed = 0;
List <string> cmdQueueIdList = new List <string>();
r.Data.CommandQueueList.ForEach(x => cmdQueueIdList.Add(x.id.ToString()));
if (r.Data.CommandQueueList.Count > 0)
{
onScanMsg("当前节点扫描到" + r.Data.CommandQueueList.Count + "条命令(" + string.Join(",", cmdQueueIdList.ToArray()) + "),并执行中");
}
foreach (var item in r.Data.CommandQueueList)
{
try
{
GlobalNodeConfig.NodeInfo.lastmaxid = item.id > GlobalNodeConfig.NodeInfo.lastmaxid ? item.id : GlobalNodeConfig.NodeInfo.lastmaxid;
CommandPoolManager.CreateInstance().Get(item.commanddetailid.ToString()).commandBase.CommandQueue = item;
CommandPoolManager.CreateInstance().Get(item.commanddetailid.ToString()).commandBase.TryExecute();
sucess += 1;
//更新命令状态为成功
onScanMsg(string.Format("当前节点执行命令成功! id:{0},命令名:{1},命令参数:{2}", item.id, item.commandmainclassname, item.commandparams));
}
catch (Exception ex)
{
failed += 1;
//添加任务执行失败日志
onScanMsg("执行节点命令异常:任务id:" + item.taskid + ",命令名称:" + item.commandmainclassname + "(" + item.id + ")", ex);
}
}
onScanMsg("当前循环扫描命令队列完成,保存上次最大命令队列id值:" + GlobalNodeConfig.NodeInfo.lastmaxid + ",扫描到命令个数:" + r.Data.CommandQueueList.Count + ",执行成功个数:" + sucess + ",执行失败个数:" + failed);
return(true);
}
private void UploadLocalTask(List <int> taskidnotserver)
{
taskidnotserver.ForEach(x =>
{
var taskruntimeInfo = TaskPoolManager.CreateInstance().Get(x.ToString());
//上报所在在本地节点运行的任务,但是在服务端未在调度中,更新服务端的任务调度状态为调度中
var req2 = new UpdateTaskScheduleStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, ScheduleStatus = TaskScheduleStatus.Scheduling, TaskId = x, TaskVersionId = taskruntimeInfo.TaskVersionModel.id, NextRunTime = Convert.ToString(taskruntimeInfo.TaskModel.nextruntime)
};
var r3 = NodeProxy.PostToServer <EmptyResponse, UpdateTaskScheduleStatusRequest>(ProxyUrl.UpdateTaskScheduleStatus_Url, req2);
if (r3.Status != ResponesStatus.Success)
{
LogProxy.AddNodeErrorLog("任务id:" + x.ToString() + ",任务名称:" + taskruntimeInfo.TaskModel.taskname + ",在服务端为停止调度状态,在本地节点下为调度中。上报本地节点下的任务状态(调度中)失败");
// ShowCommandLog("更新任务调度状态(" + status.description() + ")失败,请求Url：" + ProxyUrl.UpdateTaskScheduleStatus_Url + ",请求参数:" + JsonConvert.SerializeObject(req2) + ",返回参数:" + JsonConvert.SerializeObject(r3));
}
});
}
protected override void Run()
{
try
{
var r = NodeProxy.PostToServer <EmptyResponse, UpdateNodeHeatbeatRequest>(ProxyUrl.UpdateNodeHeatbeat_Url, new UpdateNodeHeatbeatRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, MonitorClassName = this.GetType().Name
});
if (r.Status != ResponesStatus.Success)
{
LogProxy.AddNodeErrorLog("上报心跳失败,请求地址:" + ProxyUrl.UpdateNodeHeatbeat_Url + ",返回内容:" + JsonConvert.SerializeObject(r));
}
}
catch (Exception ex)
{
string msg = "上传心跳异常,信息:" + ex.Message + ",异常:" + JsonConvert.SerializeObject(ex);
LogProxy.AddNodeErrorLog(msg);
}
}
public void Stop()
{
try
{
OnInit("----------------------" + DateTime.Now + ":停止节点开始-----------------------------------------");
//1.停止所有监控扫描
GlobalNodeConfig.Monitors.ForEach(x =>
{
x.CancelRun();
});
OnInit(DateTime.Now + ":监控停止完成");
//2.停止刷新命令队列
CommandQueueScanManger.StopScanCommandQueue();
OnInit(DateTime.Now + ":停止命令队列监听完成");
//刷新节点运行状态
var r2 = NodeProxy.PostToServer <EmptyResponse, UpdateNodeStatusRequest>(ProxyUrl.UpdateNodeStatus_Url, new UpdateNodeStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, NodeStatus = Model.enums.NodeStatus.NoRun
});
if (r2.Status != ResponesStatus.Success)
{
string msg = "更新节点运行状态失败,请求地址:" + ProxyUrl.UpdateNodeStatus_Url + ",服务器返回参数:" + JsonConvert.SerializeObject(r2);
OnInit(msg);
AlarmHelper.Alarm(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, "节点(" + GlobalNodeConfig.NodeID.ToString() + ")停止,更新运行状态失败", msg);
}
AlarmHelper.Alarm(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, "节点(" + GlobalNodeConfig.NodeID.ToString() + ")停止,请及时处理", DateTime.Now + ":当前节点(" + GlobalNodeConfig.NodeID.ToString() + ")已停止运行,如正常停止请忽略此预警");
OnInit("节点服务停止");
}
catch (Exception ex)
{
string exemsg = "节点停止异常:" + JsonConvert.SerializeObject(ex);
OnInit(exemsg);
AlarmHelper.Alarm(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, "节点(" + GlobalNodeConfig.NodeID.ToString() + ")停止异常,请及时处理!", exemsg + ",节点停止日志:" + strLog.ToString());
}
finally
{
OnInit("----------------------" + DateTime.Now + ":停止节点结束-----------------------------------------");
LogProxy.AddNodeLog(strLog.ToString(), LogType.NodeStopLog);
strLog.Clear();
}
}
/// <summary>
/// 执行
/// </summary>
public override RunCommandResult Execute()
{
try
{
string taskid = CommandQueue.taskid.ToString();
int taskversionid = CommandQueue.taskversionid;
var taskruntimeinfo = TaskPoolManager.CreateInstance().Get(taskid.ToString());
if (taskruntimeinfo == null)
{
ShowCommandLog("任务不在运行中");
//return new RunCommandResult() { RunStatus = CommandRunStatus.Normal };
}
else
{
var r = TaskDisposer.DisposeTask(CommandQueue.taskid, taskruntimeinfo, false, ShowCommandLog);
}
//上报任务已停止日志,并更新任务执行状态和调度状态(待调度)
var req = new UpdateTaskScheduleStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, ScheduleStatus = Model.enums.TaskScheduleStatus.StopSchedule, TaskId = int.Parse(taskid), TaskVersionId = taskversionid
};
var r2 = NodeProxy.PostToServer <EmptyResponse, UpdateTaskScheduleStatusRequest>(ProxyUrl.UpdateTaskScheduleStatus_Url, req);
if (r2.Status != ResponesStatus.Success)
{
ShowCommandLog("更新任务调度状态(停止调度)失败,请求Url：" + ProxyUrl.UpdateTaskScheduleStatus_Url + ",请求参数:" + JsonConvert.SerializeObject(req) + ",返回参数:" + JsonConvert.SerializeObject(r2));
}
return(new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteSucess
});
}
catch (Exception ex)
{
ShowCommandLog("停止执行节点任务失败,异常信息:" + JsonConvert.SerializeObject(ex));
return(new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteException, Ex = ex, Message = ex.Message
});
}
}
public virtual bool StopScanCommandQueue()
{
try
{
var r = NodeProxy.PostToServer <EmptyResponse, UpdateNodeRefreshCommandQueueStatusRequest>(ProxyUrl.UpdateNodeRefreshCmdQueueStatus_Url, new UpdateNodeRefreshCommandQueueStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Web, RefreshStatus = RefreshCommandQueueStatus.NoRefresh
});
if (r.Status != ResponesStatus.Success)
{
onScanMsg("更新节点刷新命令队列状态(停止刷新)失败,服务器返回:" + JsonConvert.SerializeObject(r));
}
isHaveStartThread = false;
importCts.Cancel();
return(true);
}
catch (Exception ex)
{
onScanMsg("停止线程刷新命令队列失败,异常信息:" + JsonConvert.SerializeObject(ex));
return(false);
}
}
public override Model.RunCommandResult Execute()
{
try
{
string taskid = CommandQueue.taskid.ToString();
var taskruntimeinfo = TaskPoolManager.CreateInstance().Get(taskid.ToString());
if (taskruntimeinfo == null)
{
ShowCommandLog("当前任务不存在于本地节点中,恢复任务调度失败");
return(new Model.RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteFailed, Message = "当前任务不存在于本地节点中,暂停任务失败"
});
}
TaskPoolManager.CreateInstance().UpdateTaskSchduleStatus(taskid, TaskScheduleStatus.RecoverSchedule);
var req = new UpdateTaskScheduleStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, ScheduleStatus = Model.enums.TaskScheduleStatus.RecoverSchedule, TaskId = int.Parse(taskid), TaskVersionId = taskruntimeinfo.TaskVersionModel.id
};
var r2 = NodeProxy.PostToServer <EmptyResponse, UpdateTaskScheduleStatusRequest>(ProxyUrl.UpdateTaskScheduleStatus_Url, req);
if (r2.Status != ResponesStatus.Success)
{
ShowCommandLog("更新任务调度状态(恢复调度)失败,请求Url：" + ProxyUrl.UpdateTaskScheduleStatus_Url + ",请求参数:" + JsonConvert.SerializeObject(req) + ",返回参数:" + JsonConvert.SerializeObject(r2));
}
return(new Model.RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteSucess
});
}
catch (Exception ex)
{
return(new Model.RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteException, Message = ex.Message, Ex = ex
});
}
}
private void TryRun()
{
var r = NodeProxy.PostToServer <EmptyResponse, AddNodeMonitorRequest>(ProxyUrl.AddNodeMonitorRequest_Url, new AddNodeMonitorRequest()
{
NodeId = GlobalNodeConfig.NodeID, Name = Name, Discription = Discription, Internal = this.Interval, ClassName = this.GetType().Name, ClassNameSpace = this.GetType().FullName, MonitorStatus = (int)MonitorStatus.Monitoring, Source = Source.Node
});
if (r.Status != ResponesStatus.Success)
{
//记录日志，并抛出异常
LogProxy.AddNodeErrorLog("请求" + ProxyUrl.AddNodeMonitorRequest_Url + "上报节点信息失败,服务端返回信息:" + JsonConvert.SerializeObject(r));
}
while (true)
{
try
{
if (importCts.Token.IsCancellationRequested)//如果要是已取消则break
{
//LogProxy.AddNodeLog(this.GetType().Name + "监控组件收到取消请求,已取消监控!");
var r2 = NodeProxy.PostToServer <EmptyResponse, UpdateNodeMonitorRequest>(ProxyUrl.UpdateNodeMonitorRequest_Url, new UpdateNodeMonitorRequest()
{
NodeId = GlobalNodeConfig.NodeID, MonitorClassName = this.GetType().Name, MonitorStatus = (int)MonitorStatus.NoMonitor, Source = Source.Node
});
if (r2.Status != ResponesStatus.Success)
{
//记录日志，并抛出异常
LogProxy.AddNodeErrorLog("请求" + ProxyUrl.UpdateNodeMonitorRequest_Url + "上报节点监控(停止监控)信息失败,服务端返回信息:" + JsonConvert.SerializeObject(r));
}
break;
}
Run();
System.Threading.Thread.Sleep(Interval);
}
catch (Exception exp)
{
LogProxy.AddNodeErrorLog(this.GetType().Name + "监控严重错误,异常信息:" + JsonConvert.SerializeObject(exp));
}
}
}
protected override void Run()
{
try
{
if (GlobalNodeConfig.NodeInfo.ifmonitor == 0)
{
return;
}
if (pcounts.Count <= 0)
{
return;
}
tb_nodeperformance model = new tb_nodeperformance();
string fileinstallpath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\');
double dirsizeM = -1;
if (System.IO.Directory.Exists(fileinstallpath))
{
long dirsize = IOHelper.DirSize(new DirectoryInfo(fileinstallpath));
dirsizeM = (double)dirsize / 1024 / 1024;
model.installdirsize = (double)dirsizeM;
}
foreach (var p in pcounts)
{
var c = p.Collect();
if (p.Name.Contains("cpu"))
{
model.cpu = (double)c;
}
else if (p.Name.Contains("内存"))
{
model.memory = (double)c;
}
else if (p.Name.Contains("网络发送"))
{
model.networkupload = (double)c;
}
else if (p.Name.Contains("网络下载"))
{
model.networkdownload = (double)c;
}
else if (p.Name.Contains("物理磁盘读"))
{
model.ioread = (double)c;
}
else if (p.Name.Contains("物理磁盘写"))
{
model.iowrite = (double)c;
}
else if (p.Name.Contains("IIS请求"))
{
model.iisrequest = (double)c;
}
}
model.nodeid = GlobalNodeConfig.NodeID;
model.lastupdatetime = DateTime.Now;
AddNodePerformanceRequest req = new AddNodePerformanceRequest()
{
NodePerformance = model, Source = Source.Node, MonitorClassName = this.GetType().Name
};
var r = NodeProxy.PostToServer <EmptyResponse, AddNodePerformanceRequest>(ProxyUrl.AddNodePerformance_Url, req);
if (r.Status != ResponesStatus.Success)
{
LogProxy.AddNodeErrorLog("节点性能上报出错,请求地址:" + ProxyUrl.AddNodePerformance_Url + ",请求内容:" + JsonConvert.SerializeObject(req) + ",返回结果:" + JsonConvert.SerializeObject(r));
}
}
catch (Exception ex)
{
LogProxy.AddNodeErrorLog("节点性能监控时出错:nodeid=" + GlobalNodeConfig.NodeID + ",异常信息:" + JsonConvert.SerializeObject(ex));
}
}
/// <summary>
/// 执行
/// </summary>
public override RunCommandResult Execute()
{
string taskid = CommandQueue.taskid.ToString();
string taskversionid = CommandQueue.taskversionid.ToString();
try
{
var taskruntimeinfo = TaskPoolManager.CreateInstance().Get(taskid.ToString());
if (taskruntimeinfo != null)
{
ShowCommandLog("任务已在运行中");
UploadStatus(taskid, taskversionid, TaskScheduleStatus.Scheduling, "");
return(new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteFailed, Message = "任务已在运行中"
});
}
taskruntimeinfo = new NodeTaskRunTimeInfo();
taskruntimeinfo.TaskLock = new TaskLock();
//读取任务版本信息
var taskversionreq = new LoadTaskVersionRequest()
{
TaskId = CommandQueue.taskid, TaskVersionId = CommandQueue.taskversionid, Source = Source.Node
};
var r = NodeProxy.PostToServer <LoadTaskVersionResponse, LoadTaskVersionRequest>(ProxyUrl.TaskVersionDetail_Url, taskversionreq);
if (r.Status != ResponesStatus.Success)
{
ShowCommandLog("获取任务版本号详情失败,请求Url：" + ProxyUrl.TaskVersionDetail_Url + ",请求参数:" + JsonConvert.SerializeObject(taskversionreq) + ",返回参数:" + JsonConvert.SerializeObject(r));
return(new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteFailed, Message = "获取任务版本号详情失败"
});
}
taskruntimeinfo.TaskVersionModel = r.Data.TaskVersionDetail;
taskruntimeinfo.TaskModel = r.Data.TaskDetail;
ShowCommandLog("开始创建缓存目录,域安装目录,拷贝共享程序集...");
string filelocalcachepath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\" + GlobalNodeConfig.TaskDllCompressFileCacheDir + @"\" + taskid + @"\" + r.Data.TaskVersionDetail.version + @"\" + r.Data.TaskVersionDetail.zipfilename;
string domaininstallpath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\" + GlobalNodeConfig.TaskDllDir + "\\" + taskid + "\\";
// string domaininstallmainclassdllpath = domaininstallpath + @"\" + taskruntimeinfo.TaskModel.taskclassname;
string taskshareddlldir = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\" + GlobalNodeConfig.TaskSharedDllsDir;
//通知节点TaskProvider任务执行
IOHelper.CreateDirectory(filelocalcachepath);
IOHelper.CreateDirectory(domaininstallpath);
File.WriteAllBytes(filelocalcachepath, taskruntimeinfo.TaskVersionModel.zipfile);
CompressHelper.UnCompress(filelocalcachepath, domaininstallpath);
IOHelper.CopyDirectory(taskshareddlldir, domaininstallpath);//拷贝共享程序集到域安装路径
ShowCommandLog("目录操作完成,拷贝共享程序集完成,开始创建任务的AppDomain域");
try
{
var dllpath = Path.Combine(domaininstallpath, taskruntimeinfo.TaskVersionModel.zipfilename + ".dll");
AbstractTask dllTask = new AppDomainLoaderHelper <AbstractTask>().CreateDomain(dllpath.Replace(".rar", "").Replace("zip", ""), taskruntimeinfo.TaskModel.taskclassname, out taskruntimeinfo.Domain);
dllTask.SetAlarmList(r.Data.AlarmEmailList, r.Data.AlarmMobileList);//设置任务报警信息
tb_task cloneTaskModel = taskruntimeinfo.TaskModel.CloneObj <tb_task>();
tb_taskversion cloneTaskVersionModel = taskruntimeinfo.TaskVersionModel.CloneObj <tb_taskversion>();
dllTask.TaskDetail = cloneTaskModel;
dllTask.TaskVersionDetail = cloneTaskVersionModel;
dllTask.AppConfig = new TaskAppConfigInfo();
//CommandParams cmdparams= JsonConvert.DeserializeObject<CommandParams>(CommandQueue.commandparams);
//if (!string.IsNullOrEmpty(cmdparams.TaskParams))
//{
// dllTask.AppConfig = JsonConvert.DeserializeObject<TaskAppConfigInfo>(cmdparams.TaskParams);
//}
//else
//{
if (!string.IsNullOrEmpty(taskruntimeinfo.TaskVersionModel.taskparams))
{
dllTask.AppConfig = JsonConvert.DeserializeObject <TaskAppConfigInfo>(taskruntimeinfo.TaskVersionModel.taskparams);
}
//}
taskruntimeinfo.DllTask = dllTask;
string nextruntime = "2099-12-30";
TaskPoolManager.CreateInstance().Add(taskid.ToString(), taskruntimeinfo, ref nextruntime);
ShowCommandLog("加载AppDomain域成功,开始添加到任务池等待执行");
//上报任务执行日志，并更新调度状态为调度中
UploadStatus(taskid, taskversionid, TaskScheduleStatus.Scheduling, nextruntime);
ShowCommandLog("添加到任务池成功,开启任务成功");
return(new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteSucess
});
}
catch (Exception ex)
{
ShowCommandLog("加载任务应用程序域异常,异常信息:" + JsonConvert.SerializeObject(ex));
UploadStatus(taskid, taskversionid, TaskScheduleStatus.StopSchedule);
return(new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteException, Message = ex.Message, Ex = ex
});
}
}
catch (Exception ex)
{
ShowCommandLog("开启任务命令异常,异常信息:" + JsonConvert.SerializeObject(ex));
UploadStatus(taskid, taskversionid, TaskScheduleStatus.StopSchedule);
return(new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteException, Message = ex.Message, Ex = ex
});
}
}
} //从左到右,第一位:代表大版本迭代 ，第二位：代表大版本下的大更新 第三位:代表bug修复次数
/// <summary>
/// 命令执行方法约定
/// </summary>
public void TryExecute()
{
try
{
ShowCommandLog("----------------------" + DateTime.Now + ":开始执行命令-----------------------------------------");
DateTime startTime = DateTime.Now;
Stopwatch sw = new Stopwatch();
RunCommandResult r;
sw.Start();
try
{
r = Execute();
int retryCount = 0;
while (r.ExecuteStatus == ExecuteStatus.ExecuteException && retryCount < this.CommandDetail.maxexeceptionretrycount)
{
int ct = retryCount + 1;
ShowCommandLog("**********第" + ct + "次重试 Start**********");
r = Execute();
retryCount += 1;
ShowCommandLog("**********第" + ct + "次重试 End**********");
}
r.RetryCount += retryCount;
}
catch (Exception ex)
{
r = new RunCommandResult()
{
ExecuteStatus = ExecuteStatus.ExecuteException, Message = ex.Message, Ex = ex
};
ShowCommandLog("执行命令异常,异常信息:" + JsonConvert.SerializeObject(ex));
}
sw.Stop();
ShowCommandLog("----------------------" + DateTime.Now + ":执行命令完成-----------------------------------------");
DateTime endTime = DateTime.Now;
TimeSpan ts = sw.Elapsed;
long times = sw.ElapsedMilliseconds / 1000;//秒
AddCommandExecuteLogRequest addLogReq = new AddCommandExecuteLogRequest()
{
NodeId = GlobalNodeConfig.NodeID,
Source = Source.Node,
CommandEndTime = endTime.ToString("yyyy-MM-dd HH:mm:ss"),
CommandExecuteLog = strLog.ToString(),
CommandParams = JsonConvert.SerializeObject(this.AppConfig),
CommandQueueId = CommandQueue.id,
CommandResult = JsonConvert.SerializeObject(r),
ExecuteStatus = (int)r.ExecuteStatus,
CommandStartTime = startTime.ToString("yyyy-MM-dd HH:mm:ss"),
TotalTime = times.ToString(),
CommandDetailId = CommandDetail.id,
};
//上报命令执行日志和执行结果
var r2 = NodeProxy.PostToServer <EmptyResponse, AddCommandExecuteLogRequest>(ProxyUrl.AddCommandExecuteLog_Url, addLogReq);
if (r2.Status != ResponesStatus.Success)
{
ShowCommandLog("上报命令(" + CommandDetail.commandmainclassname + ")的执行日志失败,请求地址:" + ProxyUrl.AddCommandExecuteLog_Url + ",请求参数:" + JsonConvert.SerializeObject(addLogReq) + ",服务器返回参数:" + JsonConvert.SerializeObject(r2));
}
if (r.ExecuteStatus == ExecuteStatus.ExecuteException)//命令执行异常,报警
{
string title = "当前命令队列(" + CommandQueue.id + ")执行失败,请及时处理";
StringBuilder strContent = new StringBuilder();
strContent.AppendLine("节点编号:" + GlobalNodeConfig.NodeID);
strContent.AppendLine("命令队列编号/命令编号:" + CommandQueue.id + "/" + CommandDetail.id.ToString());
strContent.AppendLine("命令执行参数:" + JsonConvert.SerializeObject(this.AppConfig));
strContent.AppendLine("命令执行起/止时间:" + startTime.ToString("yyyy-MM-dd HH:mm:ss") + "/" + endTime.ToString("yyyy-MM-dd HH:mm:ss"));
strContent.AppendLine("命令执行耗时(s):" + times.ToString());
strContent.AppendLine("命令执行结果,状态:" + r.ExecuteStatus.description() + ",执行结果:" + JsonConvert.SerializeObject(r));
AlarmHelper.AlarmAsync(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, title, strContent.ToString());
}
}
catch (Exception ex)
{
ShowCommandLog("执行命令异常,异常信息:" + JsonConvert.SerializeObject(ex));
ShowCommandLog("----------------------" + DateTime.Now + ":执行命令完成-----------------------------------------");
log.Error(strLog.ToString());
}
finally
{
strLog.Clear();//正常执行完情况strLog日志
}
}
public void Execute(JobExecutionContext context)
{
//lock (lockobj)
//{
int taskid = Convert.ToInt32(context.JobDetail.Name);
try
{
var taskruntimeinfo = TaskPoolManager.CreateInstance().Get(taskid.ToString());
taskruntimeinfo.DllTask.ClearLog();
if (taskruntimeinfo == null || taskruntimeinfo.DllTask == null)
{
// LogHelper.AddTaskError("当前任务信息为空引用", taskid, new Exception());
return;
}
taskruntimeinfo.TaskLock.Invoke(() =>
{
// int runCount = 0;
try
{
int taskid2 = taskruntimeinfo.TaskModel.id;
int taskversionid = taskruntimeinfo.TaskVersionModel.id;
string nextrunTime = Convert.ToDateTime(context.NextFireTimeUtc).ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss");
nextrunTime = nextrunTime.IndexOf("0001-01") > -1 ? "2099-12-30" : nextrunTime;
if (taskruntimeinfo.TaskModel.ispauseschedule == 0) //等于0 说明没有停止调度，否则停止调度
{
taskruntimeinfo.DllTask.TryRunTask(nextrunTime, taskruntimeinfo); //执行完，判断是否需要释放
try
{
if (taskruntimeinfo.TaskModel.tasktype == (int)TaskType.OnceTask)
{
bool disposeflag = TaskDisposer.DisposeTask(taskid2, taskruntimeinfo, false, null);
if (disposeflag) //如果释放成功则上报
{
var req = new UpdateTaskScheduleStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, ScheduleStatus = Model.enums.TaskScheduleStatus.StopSchedule, TaskId = taskid2, TaskVersionId = taskversionid
};
var r2 = NodeProxy.PostToServer <EmptyResponse, UpdateTaskScheduleStatusRequest>(ProxyUrl.UpdateTaskScheduleStatus_Url, req);
if (r2.Status != ResponesStatus.Success)
{
LogProxy.AddTaskErrorLog("更新任务调度状态(停止调度)失败,请求Url：" + ProxyUrl.UpdateTaskScheduleStatus_Url + ",请求参数:" + JsonConvert.SerializeObject(req) + ",返回参数:" + JsonConvert.SerializeObject(r2), taskid);
}
}
else
{
LogProxy.AddTaskErrorLog("taskid=" + taskid + ",释放单次执行任务资源失败", taskid);
}
}
}
catch (Exception ex)
{
LogProxy.AddTaskErrorLog("taskid=" + taskid + ",释放单次执行任务资源异常:" + JsonConvert.SerializeObject(ex), taskid);
}
}
}
catch (Exception exp)
{
LogProxy.AddTaskErrorLog("任务:" + taskid + ",TaskJob回调时执行异常,异常信息:" + JsonConvert.SerializeObject(exp), taskid);
}
});
}
catch (Exception exp)
{
LogProxy.AddTaskErrorLog("任务调度组件回调时发生严重异常,异常信息:" + JsonConvert.SerializeObject(exp), taskid);
}
}
public void Start()
{
//OnInit("\r\n");
// OnInit("\r\n");
OnInit("----------------------" + DateTime.Now + ":初始化节点开始-----------------------------------------");
try
{
OnInit("**开始请求节点配置信息**");
if (System.Configuration.ConfigurationSettings.AppSettings.AllKeys.Contains("NodeID"))
{
GlobalNodeConfig.NodeID = Convert.ToInt32(System.Configuration.ConfigurationSettings.AppSettings["NodeID"]);
}
var r = NodeProxy.PostToServer <LoadNodeConfigResponse, LoadNodeConfigRequest>(ProxyUrl.LoadNodeConfig_Url, new LoadNodeConfigRequest()
{
NodeId = GlobalNodeConfig.NodeID.ToString(), Source = Source.Node
});
if (r.Status != ResponesStatus.Success)
{
//记录日志，并抛出异常
LogProxy.AddNodeErrorLog("请求" + ProxyUrl.LoadNodeConfig_Url + "获取节点配置失败,服务端返回信息:" + JsonConvert.SerializeObject(r));
throw new Exception("请求" + ProxyUrl.LoadNodeConfig_Url + "获取节点配置失败,服务端返回信息:" + JsonConvert.SerializeObject(r));
}
GlobalNodeConfig.NodeInfo = r.Data.Node;
GlobalNodeConfig.Alarm = r.Data.AlarmPerson.ToString();
if (GlobalNodeConfig.NodeID <= 0)
{
GlobalNodeConfig.NodeID = r.Data.Node.id;
}
//初始化配置信息
OnInit("**请求节点配置信息完成,请求结果:" + JsonConvert.SerializeObject(r) + "**");
//初始化命令池
OnInit("**开启初始化节点命令池**");
ICommandPoolBuilder builder = new CommandPoolBuilder();
builder.OnInitEvent += builder_OnInitEvent;
builder.BuildCommandPool();
OnInit("**初始化节点命令池完成:本地节点命令池数量:" + CommandPoolManager.CreateInstance().GetList().Count + "**");
OnInit("**开始初始化监控线程**");
//初始化监控信息
GlobalNodeConfig.Monitors.Add(new NodeHeartBeatMonitor()); //心跳
GlobalNodeConfig.Monitors.Add(new TaskPerformanceMonitor()); //任务性能监控
GlobalNodeConfig.Monitors.Add(new NodePerformanceMonitor()); //节点性能监控
GlobalNodeConfig.Monitors.Add(new NodeTaskSchedulingMonitor()); //节点调度中的任务监控
GlobalNodeConfig.Monitors.Add(new NodeListenComandQueueMonitor()); //节点监听命令队列监控
GlobalNodeConfig.Monitors.Add(new TimingGcCollectMonitor()); //开启定时收集GC
OnInit("**监控线程已开启**");
OnInit("**开启循环监听命令队列线程**");
IOHelper.CreateDirectory(AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\" + GlobalNodeConfig.TaskSharedDllsDir + @"\");
CommandQueueScanManger.StartScanCommandQueueAsync();//循环监听命令队列线程
OnInit("**循环监听命令队列线程已开启**");
//刷新节点运行状态
var r2 = NodeProxy.PostToServer <EmptyResponse, UpdateNodeStatusRequest>(ProxyUrl.UpdateNodeStatus_Url, new UpdateNodeStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Node, NodeStatus = Model.enums.NodeStatus.Running
});
if (r2.Status != ResponesStatus.Success)
{
string msg = "更新节点运行状态失败,请求地址:" + ProxyUrl.UpdateNodeStatus_Url + ",服务器返回参数:" + JsonConvert.SerializeObject(r2);
OnInit(msg);
AlarmHelper.AlarmAsync(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, "更新节点(" + GlobalNodeConfig.NodeID.ToString() + ")的运行状态失败", msg + ",节点启动日志:" + strLog.ToString());
}
else
{
OnInit("更新节点运行状态成功");
}
OnInit("节点启动成功");
}
catch (Exception ex)
{
string exmsg = "节点启动异常:" + JsonConvert.SerializeObject(ex);
OnInit(exmsg);
AlarmHelper.AlarmAsync(GlobalNodeConfig.NodeInfo.isenablealarm, (AlarmType)GlobalNodeConfig.NodeInfo.alarmtype, GlobalNodeConfig.Alarm, "节点(" + GlobalNodeConfig.NodeID.ToString() + ")启动异常,请注意查看", exmsg + ",节点启动日志:" + strLog.ToString());
}
finally
{
OnInit("----------------------" + DateTime.Now + ":初始化节点结束-----------------------------------------");
LogProxy.AddNodeLog(strLog.ToString(), LogType.NodeInitLog);
//log.Info(strLog.ToString());
// EventLogHelper.Info(strLog.ToString());
strLog.Clear();
}
}
public virtual void StartScanCommandQueueAsync()
{
try
{
if (!isHaveStartThread)
{
task = Task.Factory.StartNew(() => {
while (true)
{
try
{
onScanMsg("----------------------------------" + DateTime.Now + ":准备接受命令并运行消息循环开始...-----------------------------------");
if (!importCts.Token.IsCancellationRequested)
{
System.Threading.Thread.Sleep(1000);
try
{
StartScanCommandQueue();
}
catch (Exception ex)
{
onScanMsg("扫描命令队列器发生不可恢复严重错误", ex);
}
System.Threading.Thread.Sleep(3000);
}
else
//当取消线程时，停止扫描
{
onScanMsg("收到扫描停止命令,扫描线程已终止");
break;
}
}
catch (Exception ex)
{
onScanMsg("扫描命令异常，异常信息:" + JsonConvert.SerializeObject(ex));
}
finally
{
onScanMsg("----------------------------------" + DateTime.Now + ":消息循环结束...-----------------------------------");
Console.WriteLine(strLog.ToString());
LogProxy.AddNodeLog(strLog.ToString(), LogType.RefreshCommandQueueLog);//上报扫描命令队列日志
strLog.Clear();
}
}
}, importCts.Token);
isHaveStartThread = true;
}
var r = NodeProxy.PostToServer <EmptyResponse, UpdateNodeRefreshCommandQueueStatusRequest>(ProxyUrl.UpdateNodeRefreshCmdQueueStatus_Url, new UpdateNodeRefreshCommandQueueStatusRequest()
{
NodeId = GlobalNodeConfig.NodeID, Source = Source.Web, RefreshStatus = RefreshCommandQueueStatus.Refreshing
});
if (r.Status != ResponesStatus.Success)
{
onScanMsg("更新节点刷新命令队列状态(刷新中)失败,服务器返回:" + JsonConvert.SerializeObject(r));
}
}
catch (Exception ex)
{
isHaveStartThread = false;
onScanMsg("开启线程刷新命令队列失败,异常信息:" + JsonConvert.SerializeObject(ex));
}
//return isHaveStartThread;
}
public static RunTaskResult TryRunTask(this AbstractTask task, string nextRunTime, NodeTaskRunTimeInfo taskruntimeinfo)
{
RunTaskResult result = new RunTaskResult()
{
RunStatus = (int)RunStatus.Failed
};
string logId = "";
long times = 0;
Model.enums.ExecuteStatus executestatus = Model.enums.ExecuteStatus.ExecuteSucess;
try
{
task.ShowProcessIngLog("----------------------" + DateTime.Now + ":开始执行任务-----------------------------------------");
DateTime startTime = DateTime.Now;
//开始执行任务，上报开始执行日志，并更新任务版本状态为执行中
#region 开始执行任务，上报开始执行日志，并更新任务版本状态为执行中
AddTaskExecuteLogRequest req = new AddTaskExecuteLogRequest()
{
NodeId = GlobalNodeConfig.NodeID,
RunStatus = Model.enums.ExecuteStatus.Executing,
Source = Model.Source.Node,
StartTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
TaskId = taskruntimeinfo.TaskModel.id,
TaskParams = taskruntimeinfo.TaskVersionModel.taskparams,
TaskVersionId = taskruntimeinfo.TaskVersionModel.id,
NextRunTime = nextRunTime
};
var r2 = NodeProxy.PostToServer <AddTaskExecuteLogResponse, AddTaskExecuteLogRequest>(ProxyUrl.AddTaskVersionExecuteLog_Url, req);
if (r2.Status != ResponesStatus.Success)
{
task.ShowProcessIngLog("上报任务(taskid=" + task.TaskDetail.id + "taskversionid=" + task.TaskVersionDetail.id + ")的执行日志失败,请求地址:" + ProxyUrl.AddTaskVersionExecuteLog_Url + ",请求参数:" + JsonConvert.SerializeObject(req) + ",服务器返回参数:" + JsonConvert.SerializeObject(r2));
}
logId = r2.Data.LogId;
#endregion
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
result = task.RunTask();
}
catch (Exception ex)
{
result = new RunTaskResult()
{
RunStatus = (int)RunStatus.Exception, Message = ex.Message, Ex = ex
};
task.ShowProcessIngLog("执行任务异常,异常信息:" + JsonConvert.SerializeObject(ex));
}
sw.Stop();
TimeSpan ts = sw.Elapsed;
times = sw.ElapsedMilliseconds / 1000;//秒
executestatus = result.RunStatus == (int)RunStatus.Normal? Model.enums.ExecuteStatus.ExecuteSucess:(result.RunStatus == (int)RunStatus.Failed?ExecuteStatus.ExecuteFailed:ExecuteStatus.ExecuteException);
}
catch (Exception exp)
{
executestatus = Model.enums.ExecuteStatus.ExecuteException;
task.ShowProcessIngLog("执行任务异常,异常信息:" + JsonConvert.SerializeObject(exp));
}
finally
{
#region 执行任务完毕，上报开始执行日志，并更新任务版本状态为执行中
task.ShowProcessIngLog("上报任务状态:" + executestatus);
task.ShowProcessIngLog("----------------------" + DateTime.Now + ":执行任务完成-----------------------------------------");
DateTime endTime = DateTime.Now;
//上报任务执行日志和执行结果，并更新最后一次任务状态
UpdateTaskExecuteLogRequest req2 = new UpdateTaskExecuteLogRequest()
{
NodeId = GlobalNodeConfig.NodeID,
RunStatus = executestatus,
Source = Model.Source.Node,
EndTime = endTime.ToString("yyyy-MM-dd HH:mm:ss"),
TaskId = taskruntimeinfo.TaskModel.id,
TaskResult = result,
LogId = string.IsNullOrEmpty(logId)?0: int.Parse(logId),
TotalRunTime = times.ToString(),
TaskVersionId = taskruntimeinfo.TaskVersionModel.id,
LogMsg = task.GetLog(),
};
if (!string.IsNullOrEmpty(logId))
{
var r3 = NodeProxy.PostToServer <EmptyResponse, UpdateTaskExecuteLogRequest>(ProxyUrl.UpdateTaskVersionExecuteLog_Url, req2);
if (r3.Status != ResponesStatus.Success)
{
task.ShowProcessIngLog("上报任务(taskid=" + taskruntimeinfo.TaskModel.id + "taskversionid=" + taskruntimeinfo.TaskVersionModel.id + ")的执行日志失败,请求地址:" + ProxyUrl.AddTaskVersionExecuteLog_Url + ",请求参数:" + JsonConvert.SerializeObject(req2) + ",服务器返回参数:" + JsonConvert.SerializeObject(r3));
}
}
log.Info(task.GetLog().ToString());
Alaram(req2, taskruntimeinfo, task);
task.ClearLog();
#endregion
}
return(result);
}