/// <summary>
/// 执行节点实例代码内容
/// </summary>
/// <param name="cr"></param>
/// <param name="nodeCase"></param>
/// <param name="err"></param>
public static bool ExcuteScriptCaseCode(CompilerResults cr, BLL.EM_SCRIPT_NODE_CASE.Entity nodeCase, ref ErrorInfo err)
{
// 通过反射,调用函数
Assembly objAssembly = cr.CompiledAssembly;
object objScripRunner = objAssembly.CreateInstance("Easyman.ScriptService.Script.ScripRunner");
if (objScripRunner == null)
{
err.IsError = true;
err.Message = "不能创建脚本的运行实例。";
return(false);
}
//初始化节点实例相关数据Initialize()
var initialize = objScripRunner.GetType().GetMethod("SetScriptNodeCaseID").Invoke(objScripRunner, new object[] { nodeCase.ID });
//设置启动数据库编号
var setnowdb = objScripRunner.GetType().GetMethod("setnowdbid").Invoke(objScripRunner, new object[] { nodeCase.DB_SERVER_ID });
//运行脚本
var run = objScripRunner.GetType().GetMethod("Run").Invoke(objScripRunner, null);
#region 获取错误信息GetErr()
//外部job需要接收内部错误信息
//用于判断重试次数、用于是否再执行
var errorMsg = objScripRunner.GetType().GetMethod("GetErrorMessage").Invoke(objScripRunner, null);
if (string.IsNullOrEmpty(errorMsg.ToString()) == false)
{
err.IsError = true;
err.Message = errorMsg.ToString();
return(false);
}
else
{
var warnMsg = objScripRunner.GetType().GetMethod("GetWarnMessage").Invoke(objScripRunner, null);
if (string.IsNullOrEmpty(warnMsg.ToString()) == false)
{
err.IsError = false;
err.Message = warnMsg.ToString();
err.IsWarn = true;
}
return(true);
}
#endregion
}
/// <summary>
/// 运行脚本
/// </summary>
/// <param name="code">脚本代码</param>
/// <param name="nodeCase">节点实例</param>
/// <param name="err">错误信息</param>
/// <returns></returns>
public static bool Run(string code, BLL.EM_SCRIPT_NODE_CASE.Entity nodeCase, ref ErrorInfo err)
{
//动态编译
CompilerResults cr = CompilerClass(code, ref err);
if (cr == null)
{
BLL.EM_SCRIPT_NODE_CASE_LOG.Instance.Add(nodeCase.ID, 3, "节点脚本编译失败：\r\n" + err.Message, code);
return(false);
}
BLL.EM_SCRIPT_NODE_CASE_LOG.Instance.Add(nodeCase.ID, 4, "节点脚本编译成功", "");
//调用必备函数+执行实例代码
return(ExcuteScriptCaseCode(cr, nodeCase, ref err));
}
public static bool NewRun(string code, BLL.EM_SCRIPT_NODE_CASE.Entity nodeCase, List <KV> monitList, ref ErrorInfo err)
{
//动态编译
string dllName = NewCompilerClass(code, nodeCase.SCRIPT_NODE_ID.ToString(), ref err);
if (string.IsNullOrEmpty(dllName))
{
BLL.EM_SCRIPT_NODE_CASE_LOG.Instance.Add(nodeCase.ID, 3, "节点脚本编译失败：\r\n" + err.Message, code);
return(false);
}
BLL.EM_SCRIPT_NODE_CASE_LOG.Instance.Add(nodeCase.ID, 4, "节点脚本编译成功:" + dllName, "");
//调用必备函数+执行实例代码
return(NewExcuteScriptCaseCode(dllName, nodeCase, monitList, ref err));
}
/// <summary>
/// 运行节点实例（不支持单独新建节点实例，只支持对失败节点实例再启动）
/// </summary>
/// <param name="scriptNodeID">节点ID</param>
/// <param name="err">错误信息</param>
private static bool RunNodeJob(long id, long scriptNodeID, ref ErrorInfo err, long?nodeCaseId = null)
{
int i = 0;
try
{
BLL.EM_SCRIPT_NODE_CASE.Entity nodeCaseEntity = null;
if (nodeCaseId == null)
{
nodeCaseEntity = BLL.EM_SCRIPT_NODE_CASE.Instance.GetFailCase(scriptNodeID);
}
else
{
nodeCaseEntity = BLL.EM_SCRIPT_NODE_CASE.Instance.GetNodeCase(nodeCaseId.Value);
}
//BLL.EM_SCRIPT_NODE_CASE.Entity nodeCaseEntity = BLL.EM_SCRIPT_NODE_CASE.Instance.GetNodeCase(scriptNodeID);
if (nodeCaseEntity == null)
{
err.IsError = true;
err.Message = string.Format("执行节点【{0}】的手动任务，当前没有该节点的失败节点(或未查找到实例对象)可以执行，因此本次任务已经取消。", scriptNodeID);
//设置为“取消执行”状态，无具体实例对应
i = BLL.EM_HAND_RECORD.Instance.SetCancel(id, 0, err.Message);
return(false);
}
//记录执行的任务ID(将处理后的手工改为已处理状态)
i = BLL.EM_HAND_RECORD.Instance.SetCaseID(id, nodeCaseEntity.ID);
Node node = new Node(nodeCaseEntity.ID, 1);
node.Start();
BLog.Write(BLog.LogLevel.INFO, string.Format("节点【{0}】的手动任务的实例【{1}】已经被执行。", scriptNodeID, nodeCaseEntity.ID));
}
catch (Exception ex)
{
err.IsError = true;
err.Message = string.Format("执行节点【{0}】的手动任务【{1}】失败。{2}", scriptNodeID, id, ex.ToString());
return(false);
}
return(true);
}
/// <summary>
/// 转换脚本
/// </summary>
/// <param name="nodeCaseEntity">节点实例</param>
/// <param name="err">错误信息</param>
/// <returns>转换后的脚本</returns>
public static string Trans(BLL.EM_SCRIPT_NODE_CASE.Entity nodeCaseEntity, ref ErrorInfo err)
{
if (nodeCaseEntity == null)
{
return(string.Empty);
}
string code = nodeCaseEntity.CONTENT;
string functions = string.Empty;
try
{
//若为创建表，替换表名
if (nodeCaseEntity.SCRIPT_MODEL == (short)Enums.ScriptModel.CreateTb)
{
code = TransCreateTable(code, nodeCaseEntity.E_TABLE_NAME, nodeCaseEntity.TABLE_SUFFIX, nodeCaseEntity.TABLE_TYPE);
}
//替换当前脚本流实例涉及的节点~表(公、私)
code = ReplaceTableNames(nodeCaseEntity.SCRIPT_CASE_ID, code);
//替换自定义函数
code = ReplaceFunctions('@', code);
//拼凑自定义函数字符串(代码暂未实现)
functions = BLL.EM_SCRIPT_FUNCTION.Instance.GetAllFunctionsToString();
//拼凑节点执行代码块
return(GenerateCode(code, functions));
}
catch (Exception ex)
{
err.IsError = true;
err.Message = string.Format("脚本流【{0}】的实例【{1}】中的节点【{2}】的实例【{3}】转换脚本，错误信息为：\r\n{3}\r\n原始脚本代码为：\r\n{4}", nodeCaseEntity.SCRIPT_ID, nodeCaseEntity.SCRIPT_CASE_ID, nodeCaseEntity.SCRIPT_NODE_ID, nodeCaseEntity.ID, ex.ToString(), code);
return(string.Empty);
}
}
public static bool NewExcuteScriptCaseCode(string dllName, BLL.EM_SCRIPT_NODE_CASE.Entity nodeCase, List <KV> monitList, ref ErrorInfo err)
{
bool resBool = true;
// string dllPath = dllName;
// AppDomain ad = AppDomain.CurrentDomain;
// ProxyObject obj = (ProxyObject)ad.CreateInstanceFromAndUnwrap(System.AppDomain.CurrentDomain.BaseDirectory + "Easyman.ScriptService.exe", "Easyman.ScriptService.Script.ProxyObject");
// obj.LoadAssembly(dllPath);
// resBool=obj.Invoke("Easyman.ScriptService.Script.ScripRunner", nodeCase.ID, nodeCase.DB_SERVER_ID);
//// AppDomain.Unload(ad);
//DoAbsoluteDeleteFile(dllName, ref err);
#region 原模式
AppDomain objAppDomain = null;
IRemoteInterface objRemote = null;
try
{
// 0. Create an addtional AppDomain
//AppDomainSetup objSetup = new AppDomainSetup();
//objSetup.ApplicationBase = AppDomain.CurrentDomain.BaseDirectory;
//objAppDomain = AppDomain.CreateDomain("MyAppDomain", null, objSetup);
objAppDomain = AppDomain.CreateDomain("Domain_" + DateTime.Now.Ticks.ToString());//.CurrentDomain;
// 4. Invoke the method by using Reflection
RemoteLoaderFactory factory = (RemoteLoaderFactory)objAppDomain.CreateInstance("Easyman.ScriptService", "RemoteAccess.RemoteLoaderFactory").Unwrap();
// with help of factory, create a real 'LiveClass' instance
object objObject = factory.Create(dllName, "Easyman.ScriptService.Script.ScripRunner", null);
if (objObject == null)
{
resBool = false;
err.IsError = true;
err.Message = "创建实例【Easyman.ScriptService.Script.ScripRunner】失败";
}
// *** Cast object to remote interface, avoid loading type info
objRemote = (IRemoteInterface)objObject;
//初始化节点实例相关数据Initialize()
objRemote.Invoke("SetScriptNodeCaseID", new object[] { nodeCase.ID });
//设置启动数据库编号
//objRemote.Invoke("setnowdbid", new object[] { nodeCase.DB_SERVER_ID });
//设置待拷贝文件编号
if (monitList != null && monitList.Count() > 0)
{
objRemote.Invoke("SetMonitFileList", new object[] { monitList.Select(p => p.K).ToList() });
}
//运行脚本
objRemote.Invoke("Run", null);
#region 获取错误信息GetErr()
//外部job需要接收内部错误信息
//用于判断重试次数、用于是否再执行
var errorMsg = (string)objRemote.Invoke("GetErrorMessage", null);
if (!string.IsNullOrEmpty(errorMsg.ToString()))
{
err.IsError = true;
err.Message = errorMsg.ToString();
resBool = false;
}
else
{
var warnMsg = (string)objRemote.Invoke("GetWarnMessage", null);
if (!string.IsNullOrEmpty(warnMsg.ToString()))
{
err.IsError = false;
err.Message = warnMsg.ToString();
err.IsWarn = true;
}
}
////Dispose the objects and unload the generated DLLs.
//objRemote = null;
//AppDomain.Unload(objAppDomain);
//System.IO.File.Delete(dllName);
#endregion
}
catch (Exception ex)
{
resBool = false;
err.IsError = true;
err.Message = ex.Message;
}
finally
{
//Dispose the objects and unload the generated DLLs.
//objRemote = null;
AppDomain.Unload(objAppDomain);
// System.IO.File.Delete(dllName);
DoAbsoluteDeleteFile(dllName, ref err);
}
// BLL.EM_SCRIPT_NODE_CASE_LOG.Instance.Add(nodeCase.ID, 3, "执行错误：\r\n" + err.Message,"");
#endregion
return(resBool);
}
/// <summary>
/// 开始执行任务
/// </summary>
/// <param name="isLastNodeCase">是否为程序上次运行添加的节点实例，这种节点可能正处于运行中程序被停止了</param>
/// <returns></returns>
public bool Start(bool isLastNodeCase = false)
{
try
{
//验证运行节点实例数量
if (Main.RunningNodeCount >= Main.MaxExecuteNodeCount)
{
WriteLog(_scriptNodeCaseID, BLog.LogLevel.WARN, string.Format("当前已经有【{0}】个节点实例运行，超过系统设定的最大数【{1}】，本节点实例将暂时不被执行。", Main.RunningNodeCount, Main.MaxExecuteNodeCount));
return(false);
}
//读取当前节点
_nodeCaseEntity = BLL.EM_SCRIPT_NODE_CASE.Instance.GetEntityByKey <BLL.EM_SCRIPT_NODE_CASE.Entity>(_scriptNodeCaseID);
if (_nodeCaseEntity == null)
{
WriteLog(_scriptNodeCaseID, BLog.LogLevel.WARN, string.Format("没有获取脚本流节点实例ID【{0}】的实体对象，将不被执行。", _scriptNodeCaseID));
return(false);
}
//已经停止的节点，不再执行
if (_nodeCaseEntity.RUN_STATUS == (short)Enums.RunStatus.Stop)
{
WriteLog(_scriptNodeCaseID, BLog.LogLevel.WARN, string.Format("脚本流【{0}】的实例【{1}】中的节点【{2}】的实例【{3}】的运行状态为【停止】，本节点将不被执行。", _nodeCaseEntity.SCRIPT_ID, _nodeCaseEntity.SCRIPT_CASE_ID, _nodeCaseEntity.SCRIPT_NODE_ID, _nodeCaseEntity.ID));
return(false);
}
//当前状态不等于等待执行
if (_nodeCaseEntity.RUN_STATUS != (short)Enums.RunStatus.Wait)
{
//上次未完成的节点实例，可以继续执行
if (isLastNodeCase == false)
{
WriteLog(_scriptNodeCaseID, BLog.LogLevel.WARN, string.Format("脚本流【{0}】的实例【{1}】中的节点【{2}】的实例【{3}】的运行状态不为【等待执行】，本节点将不被执行。", _nodeCaseEntity.SCRIPT_ID, _nodeCaseEntity.SCRIPT_CASE_ID, _nodeCaseEntity.SCRIPT_NODE_ID, _nodeCaseEntity.ID));
return(false);
}
}
//添加到内存
if (Main.AddNodeTask(_scriptNodeCaseID) == false)
{
//WriteLog(_scriptNodeCaseID, BLog.LogLevel.WARN, string.Format("脚本流【{0}】的实例【{1}】中的节点【{2}】的实例【{3}】已经于【{4}】开始运行，本次将不被执行。", _nodeCaseEntity.SCRIPT_ID, _nodeCaseEntity.SCRIPT_CASE_ID, _nodeCaseEntity.SCRIPT_NODE_ID, _nodeCaseEntity.ID, Main.GetNodeTaskStartTime(_scriptNodeCaseID).ToString("yyyy-MM-dd HH:mm:ss.fff")));
return(false);
}
//更新当前节点状态
int i = BLL.EM_SCRIPT_NODE_CASE.Instance.UpdateRunStatus(_scriptNodeCaseID, Enums.RunStatus.Excute);
if (i < 0)
{
WriteLog(_scriptNodeCaseID, BLog.LogLevel.WARN, string.Format("更新脚本流【{0}】的实例【{1}】中的节点【{2}】的实例【{3}】的运行状态为【执行中】失败，本节点将不被执行。", _nodeCaseEntity.SCRIPT_ID, _nodeCaseEntity.SCRIPT_CASE_ID, _nodeCaseEntity.SCRIPT_NODE_ID, _nodeCaseEntity.ID));
return(false);
}
WriteLog(_scriptNodeCaseID, BLog.LogLevel.INFO, string.Format("脚本流【{0}】的实例【{1}】中的节点【{2}】的实例【{3}】的运行状态已经更新为【执行中】，下面将执行节点脚本内容。", _nodeCaseEntity.SCRIPT_ID, _nodeCaseEntity.SCRIPT_CASE_ID, _nodeCaseEntity.SCRIPT_NODE_ID, _nodeCaseEntity.ID));
_bw = new BackgroundWorker();
_bw.WorkerSupportsCancellation = true;
_bw.DoWork += DoWork;
_bw.RunWorkerAsync();
}
catch (Exception ex)
{
WriteLog(_scriptNodeCaseID, BLog.LogLevel.WARN, string.Format("执行节点实例【{0}】出现了未知异常，1错误信息为：\r\n{1}", _scriptNodeCaseID, ex.ToString()));
return(false);
}
return(true);
}
