public virtual string GetAssemblyVersion()
{
string version = string.Empty;
if (System.IO.File.Exists(StartupParam.FileName))
{
try
{
byte[] buffer = System.IO.File.ReadAllBytes(StartupParam.FileName);//?????LoadFile????????????????????????????????????????????
var assembly = Assembly.Load(buffer);
Regex reg = new Regex("Version=([^,]+)");
var m = reg.Match(assembly.FullName);
if (m.Success && m.Groups.Count > 1)
{
version = m.Groups[1].Value;
}
assembly = null;
}
catch (Exception ex)
{
LogHelper.AddNodeError("»ñÈ¡°æ±¾ºÅʧ°Ü", ex);
}
}
return(version);
}
public void Execute(JobExecutionContext context)
{
try
{
int taskid = Convert.ToInt32(context.JobDetail.Name);
var taskruntimeinfo = TaskPoolManager.CreateInstance().Get(taskid.ToString());
if (taskruntimeinfo == null || taskruntimeinfo.DllTask == null)
{
LogHelper.AddTaskError("当前任务信息为空引用", taskid, new Exception());
return;
}
taskruntimeinfo.TaskLock.Invoke(() => {
try
{
taskruntimeinfo.DllTask.TryRun();
}
catch (Exception exp)
{
LogHelper.AddTaskError("任务" + taskid + "TaskJob回调时执行失败", taskid, exp);
}
});
}
catch (Exception exp)
{
LogHelper.AddNodeError("任务回调时严重系统级错误", exp);
}
}
/// <summary>
/// 获取程序集版本
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
private string GetAssemblyVersion(string fileName)
{
string version = string.Empty;
if (System.IO.File.Exists(fileName))
{
try
{
byte[] buffer = System.IO.File.ReadAllBytes(fileName);//不要用LoadFile去加载，那样会锁住文件，在下次启动时对文件覆盖就被占用
var assembly = Assembly.Load(buffer);
Regex reg = new Regex("Version=([^,]+)");
var m = reg.Match(assembly.FullName);
if (m.Success && m.Groups.Count > 1)
{
version = m.Groups[1].Value;
}
assembly = null;
}
catch (Exception ex)
{
LogHelper.AddNodeError("获取程序集版本异常", ex);
}
}
return(version);
}
public static void ServiceRunning()
{
RedisHelper.RedisListner((channel, msg) =>
{
try
{
//msg = "{'CommondType':2,'nodeid':1}";
RedisCommondInfo redisCommondInfo = null;
redisCommondInfo = new BSF.Serialization.JsonProvider().Deserialize <RedisCommondInfo>(msg);
if (redisCommondInfo != null)
{
if (redisCommondInfo.CommondType == EnumCommondType.TaskCommand && redisCommondInfo.NodeId == GlobalConfig.NodeID)
{
RunCommond();
}
else if (redisCommondInfo.CommondType == EnumCommondType.ConfigUpdate)
{
RedisHelper.RefreashRedisServerIP();
}
}
}
catch (Exception ex)
{
LogHelper.AddNodeError($"Redis获取订阅消息出错,{ex.Message}", ex);
}
}, (info) =>
{
if (info != null)
{
LogHelper.AddNodeError("Redis订阅出错," + info.Message.NullToEmpty(), info.Exception);
}
});
}
static void RunCommond()
{
lock (_lockRunLoop)
{
try
{
List <tb_command_model> commands = new List <tb_command_model>();
try
{
SqlHelper.ExcuteSql(GlobalConfig.TaskDataBaseConnectString, (c) =>
{
tb_command_dal commanddal = new tb_command_dal();
if (lastMaxID < 0)
{
lastMaxID = commanddal.GetMaxCommandID(c);
}
commands = commanddal.GetNodeCommands(c, GlobalConfig.NodeID, lastMaxID);
});
}
catch (Exception exp2)
{
LogHelper.AddNodeError("获取当前节点命令集错误", exp2);
}
if (commands.Count > 0)
{
LogHelper.AddNodeLog("当前节点扫描到" + commands.Count + "条命令,并执行中....");
}
foreach (var c in commands)
{
try
{
CommandFactory.Execute(c);
SqlHelper.ExcuteSql(GlobalConfig.TaskDataBaseConnectString, (conn) =>
{
new tb_command_dal().UpdateCommandState(conn, c.id, (int)EnumTaskCommandState.Success);
});
LogHelper.AddNodeLog(string.Format("当前节点执行命令成功! id:{0},命令名:{1},命令内容:{2}", c.id, c.commandname, c.command));
}
catch (Exception exp1)
{
try
{
SqlHelper.ExcuteSql(GlobalConfig.TaskDataBaseConnectString, (conn) =>
{
new tb_command_dal().UpdateCommandState(conn, c.id, (int)EnumTaskCommandState.Error);
});
}
catch { }
LogHelper.AddTaskError("执行节点命令失败", c.taskid, exp1);
}
lastMaxID = Math.Max(lastMaxID, c.id);
}
}
catch (Exception exp)
{
LogHelper.AddNodeError("系统级不可恢复严重错误", exp);
}
}
}
protected override void Run()
{
foreach (var taskruntimeinfo in TaskManager.Node.SystemRuntime.TaskPoolManager.CreateInstance().GetList())
{
try
{
if (taskruntimeinfo == null)
{
continue;
}
string fileinstallpath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\" + GlobalConfig.TaskDllDir + @"\" + taskruntimeinfo.TaskModel.id;
double dirsizeM = -1;
if (System.IO.Directory.Exists(fileinstallpath))
{
long dirsize = TaskManager.Core.IOHelper.DirSize(new DirectoryInfo(fileinstallpath));
dirsizeM = (double)dirsize / 1024 / 1024;
}
try
{
if (taskruntimeinfo.Domain != null)
{
try
{
double cpu = taskruntimeinfo.Domain.MonitoringTotalProcessorTime.TotalSeconds;
var memory = taskruntimeinfo.Domain.MonitoringSurvivedMemorySize;
SqlHelper.ExcuteSql(GlobalConfig.TaskDataBaseConnectString, (c) =>
{
tb_performance_dal nodedal = new tb_performance_dal();
nodedal.AddOrUpdate(c, new Domain.Model.tb_performance_model()
{
cpu = cpu,
memory = (double)memory / 1024 / 1024,
installdirsize = dirsizeM,
taskid = taskruntimeinfo.TaskModel.id,
lastupdatetime = DateTime.Now,
nodeid = GlobalConfig.NodeID
});
});
}
catch (AppDomainUnloadedException)
{ }
}
}
catch (Exception ex)
{
LogHelper.AddTaskError("任务性能监控时出错", taskruntimeinfo.TaskModel.id, ex);
}
}
catch (Exception exp)
{
LogHelper.AddNodeError("任务性能监控者出错", exp);
}
}
}
/// <summary>
/// 任务的资源释放
/// </summary>
/// <param name="taskid"></param>
/// <param name="taskruntimeinfo"></param>
/// <returns></returns>
private bool DisposeTask(int taskid, NodeTaskRuntimeInfo taskruntimeinfo, bool isforceDispose)
{
if (taskruntimeinfo != null && taskruntimeinfo.DllTask != null)
{
try { taskruntimeinfo.DllTask.Dispose(); taskruntimeinfo.DllTask = null; }
catch (TaskSafeDisposeTimeOutException ex)
{
LogHelper.AddNodeError("强制资源释放之任务资源释放", ex);
if (isforceDispose == false)
{
throw ex;
}
}
}
private void TryRun()
{
while (true)
{
try
{
Run();
System.Threading.Thread.Sleep(Interval);
}
catch (Exception exp)
{
LogHelper.AddNodeError(this.GetType().Name + "监控严重错误", exp);
}
}
}
protected override void Run()
{
try
{
string url = GlobalConfig.TaskManagerWebUrl.TrimEnd('/') + "/OpenApi/" + "Ping/";
ClientResult r = ApiHelper.Get(url, new
{
});
if (r.success == false)
{
LogHelper.AddNodeError("检测到任务平台站点异常", new Exception("节点任务平台Web保持心跳连接时出错"));
}
}
catch (Exception exp) {
LogHelper.AddNodeError("检测到任务平台站点异常", exp);
}
}
static void Running()
{
//lastMaxID = 0;//仅测试
RecoveryStartTasks();
RedisHelper.RedisListner((channel, msg) =>
{
try
{
RedisCommondInfo redisCommondInfo = null;
try { redisCommondInfo = new BSF.Serialization.JsonProvider().Deserialize <RedisCommondInfo>(msg); } catch { }
if (redisCommondInfo != null)
{
if (redisCommondInfo.CommondType == EnumCommondType.TaskCommand && redisCommondInfo.NodeId == GlobalConfig.NodeID)
{
RunCommond();
}
if (redisCommondInfo.CommondType == EnumCommondType.ConfigUpdate)
{
RedisHelper.RefreashRedisServerIP();
}
}
else
{
throw new Exception("redis命令无法识别");
}
}
catch (Exception exp)
{
LogHelper.AddNodeError("Redis命令处理出错,msg:" + msg.NullToEmpty(), exp);
}
}, (info) =>
{
if (info != null)
{
LogHelper.AddNodeError("Redis订阅出错," + info.Message.NullToEmpty(), info.Exception);
}
});
RuningCommandLoop();
}
protected override void Run()
{
List <int> taskids = new List <int>();
SqlHelper.ExcuteSql(GlobalConfig.TaskDataBaseConnectString, (c) =>
{
tb_task_dal taskdal = new tb_task_dal();
taskids = taskdal.GetTaskIDsByState(c, (int)EnumTaskState.Running, GlobalConfig.NodeID);
});
List <int> currentscantaskids = new List <int>();
foreach (var taskid in taskids)
{
try
{
var taskruntimeinfo = TaskPoolManager.CreateInstance().Get(taskid.ToString());
if (taskruntimeinfo == null)
{
currentscantaskids.Add(taskid);
}
var recovertaskids = (from o in lastscantaskids
from c in currentscantaskids
where o == c
select o).ToList();
if (recovertaskids != null && recovertaskids.Count > 0)
{
recovertaskids.ForEach((c) =>
{
LogHelper.AddTaskError("任务资源运行可能异常停止了", taskid, new Exception("任务处于运行状态，但是相应集群节点中，未发现任务在运行"));
});
}
lastscantaskids = currentscantaskids;
}
catch (Exception exp)
{
LogHelper.AddNodeError("任务" + taskid + "检测是否异常终止出错", exp);
}
}
}
/// <summary>
/// 恢复已开启的任务
/// </summary>
static void RecoveryStartTasks()
{
try
{
LogHelper.AddNodeLog("当前节点启动成功,准备恢复已经开启的任务...");
List <int> taskids = new List <int>();
SqlHelper.ExcuteSql(GlobalConfig.TaskDataBaseConnectString, (c) =>
{
tb_task_dal taskdal = new tb_task_dal();
taskids = taskdal.GetTaskIDsByState(c, (int)EnumTaskState.Running, GlobalConfig.NodeID);
});
foreach (var taskid in taskids)
{
try
{
CommandFactory.Execute(new tb_command_model()
{
command = "",
commandcreatetime = DateTime.Now,
commandname = Core.EnumTaskCommandName.StartTask.ToString(),
commandstate = (int)Core.EnumTaskCommandState.None,
nodeid = GlobalConfig.NodeID,
taskid = taskid,
id = -1
});
}
catch (Exception exp)
{
LogHelper.AddTaskError(string.Format("恢复已经开启的任务{0}失败", taskid), taskid, exp);
}
}
LogHelper.AddNodeLog(string.Format("恢复已经开启的任务完毕，共{0}条任务重启", taskids.Count));
}
catch (Exception exp)
{
LogHelper.AddNodeError("恢复已经开启的任务失败", exp);
}
}
private static void KillProcess(string taskId, NodeTaskRuntimeInfo taskruntimeinfo)
{
if (taskruntimeinfo.Process != null)
{
try
{
taskruntimeinfo.Process.Kill();
taskruntimeinfo.Process.WaitForExit();
}
catch (Exception ex)
{
LogHelper.AddNodeError($"kill process{ex.Message}", ex);
}
}
try
{
TaskPoolManager.CreateInstance().Remove(taskId);
}
catch (Exception e)
{
LogHelper.AddNodeError("强制资源释放之任务池释放", e);
}
}
static void RunCommond()
{
lock (_lockRunLoop)
{
try
{
List <tb_command_model> commands = new List <tb_command_model>();
try
{
SqlHelper.ExcuteSql(GlobalConfig.ConnectionString, (conn) =>
{
tb_command_dal commanddal = new tb_command_dal();
if (lastMaxID < 0)
{
lastMaxID = commanddal.GetMaxCommandID(conn);
}
commands = commanddal.GetNodeCommands(conn, GlobalConfig.NodeID, lastMaxID);
});
}
catch (Exception ex)
{
LogHelper.AddNodeError("获取当前节点命令集错误", ex);
}
if (commands.Count > 0)
{
LogHelper.AddNodeLog("当前节点扫描到" + commands.Count + "条命令,并执行中....");
}
foreach (var c in commands)
{
EnumTaskCommandState enumTaskCommandState = EnumTaskCommandState.Error;
EnumTaskState enumTaskState = EnumTaskState.UnInstall;
try
{
SqlHelper.ExcuteSql(GlobalConfig.ConnectionString, (conn) =>
{
tb_task_dal taskDAL = new tb_task_dal();
var task = taskDAL.GetOneTask(conn, c.taskid);
tb_version_dal versionDAL = new tb_version_dal();
var version = versionDAL.GetVersionByTaskID(conn, c.taskid);
string path = $"{AppDomain.CurrentDomain.BaseDirectory}{task.taskname}";
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
if (version != null)
{
string zipFilePath = $"{path}\\{version.zipfilename}";
///数据库二进制转压缩文件
CompressHelper.ConvertToFile(version.zipfile, zipFilePath);
CompressHelper.UnCompress(zipFilePath, path);
///删除压缩文件
File.Delete(zipFilePath);
///初始化shell脚本
InitScript.InstallScript(task.taskname, task.taskmainclassdllfilename);
InitScript.UninstallScript(task.taskname);
InitScript.StartScript(task.taskname);
InitScript.StopScript(task.taskname);
}
else
{
throw new Exception($"在tb_version表中未查到taskid:{c.taskid}数据");
}
}
if (c.commandname == EnumTaskCommandName.StartTask.Tostring())
{
if (ServiceHelper.ServiceState(task.taskname) == EnumTaskState.UnInstall)
{
CommandFactory.Execute(path + "\\install.bat");
}
///线程睡眠5s，等待服务安装完成
Thread.Sleep(5000);
CommandFactory.Execute(path + "\\start.bat");
///线程睡眠2s，等到脚本执行完成
Thread.Sleep(2000);
if (ServiceHelper.ServiceState(task.taskname) == EnumTaskState.Running)
{
enumTaskCommandState = EnumTaskCommandState.Success;
enumTaskState = EnumTaskState.Running;
}
}
else if (c.commandname == EnumTaskCommandName.ReStartTask.Tostring())
{
CommandFactory.Execute(path + "\\start.bat");
///线程睡眠2s，等到脚本执行完成
Thread.Sleep(2000);
if (ServiceHelper.ServiceState(task.taskname) == EnumTaskState.Running)
{
enumTaskCommandState = EnumTaskCommandState.Success;
enumTaskState = EnumTaskState.Running;
}
}
else if (c.commandname == EnumTaskCommandName.StopTask.Tostring())
{
CommandFactory.Execute(path + "\\stop.bat");
///线程睡眠2s，等到脚本执行完成
Thread.Sleep(2000);
if (ServiceHelper.ServiceState(task.taskname) == EnumTaskState.Stop)
{
enumTaskCommandState = EnumTaskCommandState.Success;
enumTaskState = EnumTaskState.Stop;
}
}
else if (c.commandname == EnumTaskCommandName.UninstallTask.Tostring())
{
if (ServiceHelper.ServiceState(task.taskname) == EnumTaskState.Running)
{
CommandFactory.Execute(path + "\\stop.bat");
Thread.Sleep(2000);
}
CommandFactory.Execute(path + "\\uninstall.bat");
///线程睡眠2s，等到脚本执行完成
Thread.Sleep(2000);
if (ServiceHelper.ServiceState(task.taskname) == EnumTaskState.UnInstall)
{
enumTaskCommandState = EnumTaskCommandState.Success;
}
}
///更新命令状态
new tb_command_dal().UpdateCommandState(conn, c.id, (int)enumTaskCommandState);
///更新服务状态
new tb_task_dal().UpdateTaskState(conn, c.taskid, (int)enumTaskState);
if (enumTaskCommandState == EnumTaskCommandState.Success)
{
LogHelper.AddNodeLog($"节点:{c.nodeid}成功执行任务:{c.taskid}……");
}
});
}
catch (Exception ex)
{
LogHelper.AddTaskError("任务执行错误", c.taskid, ex);
}
}
}
catch (Exception ex)
{
LogHelper.AddNodeLog($"节点执行错误，错误原因:{ex.Message}");
}
}
}
