public Result ListMongoCollection([FromQuery] string host, [FromQuery] int port, [FromQuery] string dataBase)
{
if (string.IsNullOrEmpty(host) || string.IsNullOrEmpty(dataBase))
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, "host或dataBase不能为空");
}
if (!NetAssist.IsIP(host))
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, "host不合法");
}
return(base.Success(base.dataSourceService.ListMongoCollection(host, port, dataBase)));
}
/// <summary>
/// 获取客户端ID
/// </summary>
/// <param name="socket"></param>
/// <returns></returns>
private static MessageAuthKey GetAppAuthKey(IWebSocketConnection socket)
{
MessageAuthKey messageAuthKey = null;
NameValueCollection queryParams = UriUtil.GetQueryString(socket.ConnectionInfo.Path);
string appKey = queryParams["appKey"];
string appId = queryParams["appId"];
// string authKeyStr =socket.ConnectionInfo.Path.Substring(socket.ConnectionInfo.Path.LastIndexOf("?") + 1);
string callbackMsg = "";
if (string.IsNullOrEmpty(appKey) || string.IsNullOrEmpty(appId))
{
callbackMsg = $"appKey或appId 信息不存在，连接被拒绝";
LOG.Error(callbackMsg);
socket.Send(callbackMsg);
socket.Close();
return(null);
}
try
{
// 获取agent类型，支持多端同时连接
EnumUserAgentType enumUserAgentType = NetAssist.GetUserAgentType(socket.ConnectionInfo.Headers["User-Agent"]);
string agentType = EnumUtil.GetEnumName <EnumUserAgentType>((int)enumUserAgentType);
if (appId_Agent_AuthKeyMap.ContainsKey(appId))
{
if (appId_Agent_AuthKeyMap[appId].ContainsKey(agentType))
{
return(appId_Agent_AuthKeyMap[appId][agentType]);
}
}
messageAuthKey = new MessageAuthKey
{
AppId = appId,
AppKey = appKey,
AgentType = agentType
};
// @TODO 验证appkey的有限性和appId是否唯一
return(messageAuthKey);
}
catch (Exception ex)
{
LOG.Error(ex, ex.Message);
callbackMsg = $"连接信息缺失，连接被拒绝。详情：{ex.Message}";
socket.Send(callbackMsg);
socket.Close();
return(null);
}
}
/// <summary>
/// 通过sde文件连接SDE
/// </summary>
/// <param name="sdeFile">sde的连接配置文件</param>
/// <param name="message"></param>
/// <returns></returns>
public static IWorkspace OpenSdeWorkspace(string sdeFile, out string sdeUser, out string message)
{
message = string.Empty;
sdeUser = string.Empty;
IWorkspace pWorkSpace = null;
IWorkspaceFactory pSdeFactory = null;
try
{
if (string.IsNullOrEmpty(sdeFile))
{
message = "获取连接文件出错";
return(null);
}
if (!File.Exists(sdeFile))
{
message = "获取连接文件出错";
return(null);
}
pSdeFactory = new SdeWorkspaceFactoryClass();
IPropertySet pPropertySet = pSdeFactory.ReadConnectionPropertiesFromFile(sdeFile);
if (pPropertySet == null)
{
message = "读取连接文件出错";
return(null);
}
string strServer = pPropertySet.GetProperty("SERVER").ToString();
string strPort = pPropertySet.GetProperty("INSTANCE").ToString();
sdeUser = pPropertySet.GetProperty("USER").ToString();
//if (NetAssist.CheckSDEConnecTion(strServer, Convert.ToInt32(strPort), out message) == false)
//{
// return null;
//}
if (NetAssist.PingIP(strServer) == false)
{
message = "无法连接服务器";
return(null);
}
if (strPort == "5151")
{
if (NetAssist.PingPort(strServer, Convert.ToInt32(strPort)) == false)
{
message = "无法连接服务器";
return(null);
}
}
pWorkSpace = pSdeFactory.OpenFromFile(sdeFile, 0);
}
catch (Exception ex)
{
LOG.Error("空间数据库打开错误，详情：" + ex.Message);
// Console.WriteLine("空间数据库打开错误");
message = ex.Message;
return(null);
}
return(pWorkSpace);
}
/// <summary>
/// 运行步骤节点
/// </summary>
/// <param name="db"></param>
/// <param name="task"></param>
/// <param name="node"></param>
private void RunRuleStepNode(SqlSugarClient db, DmeTask task, RuleStepLinkedListNode <DmeRuleStep> node)
{
// 先计算前置节点
if (node.Previous?.Count > 0)
{
foreach (var item in node.Previous)
{
RunRuleStepNode(db, task, item);
}
}
DmeTaskRuleStep dmeTaskRuleStep = null;
try
{
// 先判断任务的状态，是否被停止
DmeTask taskStatus = db.Queryable <DmeTask>().Single(t => t.SysCode == task.SysCode);
if (null == taskStatus || taskStatus.Status.Equals(EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_STOP)))
{
LOG.Info($"任务[{task.SysCode}]不存在或者已被停止");
return;
}
dmeTaskRuleStep = this.GetTaskRuleStep(db, task, node.Value, out string cacheKey);
if (dmeTaskRuleStep != null && EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_SUCCESS).Equals(dmeTaskRuleStep.Status))
{
// 释放
dmeTaskRuleStep = null;
LOG.Info($"任务[{task.SysCode}]下的步骤[{node.Value.SysCode}]已被计算过，并且状态为[success]");
return;
}
// 如果前置节点没有了，则计算当前节点内容
DmeRuleStepType ruleStepTypeTemp = db.Queryable <DmeRuleStepType>().Single(rst => rst.Id == node.Value.StepTypeId);
IRuleStepData ruleStepData = RuleStepFactory.GetRuleStepData(ruleStepTypeTemp.Code, this.Repository, task, node.Value);
if (null == ruleStepData)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"步骤工厂无法创建编码为[{ruleStepTypeTemp.Code}]的流程实例节点");
}
dmeTaskRuleStep = new DmeTaskRuleStep
{
SysCode = GuidUtil.NewGuid(),
TaskId = task.Id,
RuleStepId = node.Value.Id,
Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_RUNNING),
CreateTime = DateUtil.CurrentTimeMillis,
LastTime = DateUtil.CurrentTimeMillis
};
dmeTaskRuleStep = db.Insertable <DmeTaskRuleStep>(dmeTaskRuleStep).ExecuteReturnEntity();
// 任务步骤创建成功后，把相关信息记录在缓存中
ServiceFactory.CacheService.AddAsync(cacheKey, dmeTaskRuleStep, 60);
Result stepResult = ruleStepData.Run();
UpdateRuleStep(db, dmeTaskRuleStep, cacheKey, stepResult);
// 然后计算下一个步骤
if (node?.Next.Count > 0)
{
foreach (var item in node.Next)
{
RunRuleStepNode(db, task, item);
}
}
}
catch (Exception ex)
{
dmeTaskRuleStep.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_ERROR);
dmeTaskRuleStep.LastTime = DateUtil.CurrentTimeMillis;
// 只更新状态和最后时间
db.Updateable <DmeTaskRuleStep>(dmeTaskRuleStep).UpdateColumns(ts => new { ts.Status, ts.LastTime }).ExecuteCommand();
this.LogService.AddLogAsync(Base.Common.Log.EnumLogType.ENTITY, EnumLogLevel.ERROR, nameof(DmeTaskRuleStep), dmeTaskRuleStep.SysCode, "", ex, "", NetAssist.GetLocalHost());
}
}
private Task RunTaskAsyncEx(SqlSugarClient db, DmeModel model, DmeModelVersion modelVersion, DmeTask task, IList <DmeRuleStep> ruleSteps)
{
return(Task.Run(() =>
{
return db.Ado.UseTran <DmeTask>(() =>
{
try
{
// 查询步骤前后依赖关系
// 形成链表
IList <DmeRuleStepHop> hops = db.Queryable <DmeRuleStepHop>().Where(rsh => rsh.ModelId == model.Id && rsh.VersionId == modelVersion.Id).OrderBy("STEP_FROM_ID").ToList();
IList <RuleStepLinkedListNode <DmeRuleStep> > rulestepLinkedList = this.GetRuleStepNodeLinkedList(db, model, modelVersion, ruleSteps);
foreach (var item in rulestepLinkedList)
{
// 开始计算步骤
this.RunRuleStepNode(db, task, item);
}
// 完成模型计算
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_SUCCESS);
task.LastTime = DateUtil.CurrentTimeMillis;
db.Updateable <DmeTask>(task).ExecuteCommand();
// @TODO 发送模型计算成功的消息
KafkaProducer.Send(nameof(EnumMessageType.TASK), new MessageBody()
{
// 创建者一致
From = "123",
To = "123",
ChannelType = EnumChannelType.P2P,
MessageType = EnumMessageType.TASK,
Payload = $"模型[{task.SysCode}]计算完成，状态[{task.Status}]"
});
return task;
}
catch (Exception ex)
{
// 更改任务执行的状态
if (ex is BusinessException)
{
task.Status = EnumUtil.GetEnumDisplayName(EnumUtil.GetEnumObjByValue <EnumSystemStatusCode>(((BusinessException)ex).Code));
}
else
{
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_ERROR);
}
task.LastTime = DateUtil.CurrentTimeMillis;
db.Updateable <DmeTask>(task).ExecuteCommand();
// 添加日志
this.LogService.AddLogAsync(Base.Common.Log.EnumLogType.ENTITY, Base.Common.Log.EnumLogLevel.ERROR, nameof(DmeTask), task.SysCode, "", ex, "", NetAssist.GetLocalHost());
throw ex;
}
});
}));
}
public async Task <DmeTask> CreateTaskAsync(NewTaskReqDTO dto)
{
// 验证数据库是否存在指定模型版本信息
SqlSugarClient db = base.Repository.GetDbContext();
// 查询模型版本
DmeModelVersion modelVersion = db.Queryable <DmeModelVersion>().Single(mv => mv.SysCode == dto.ModelVersionCode);
if (null == modelVersion)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"模型的版本[{dto.ModelVersionCode}]不存在");
}
// Single方法，如果查询数据库多条数据，会抛出异常
DmeModel model = db.Queryable <DmeModel>().Single(m => m.Id == modelVersion.ModelId);
if (null == model)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_ERROR, $"模型[{modelVersion.ModelId}]不存在");
}
// 获取模型类型
DmeModelType modelType = db.Queryable <DmeModelType>().InSingle(model.ModelTypeId);
// 查找关联的算法信息
IList <DmeRuleStep> ruleSteps = db.Queryable <DmeRuleStep>().Where(rs => rs.ModelId == model.Id && rs.VersionId == modelVersion.Id).ToList();
if (0 == ruleSteps?.Count)
{
LOG.Warn($"模型[{model.SysCode}]的版本[{dto.ModelVersionCode}]下没有可执行步骤，停止运行");
return(null);
}
DmeTask newTask = db.Ado.UseTran <DmeTask>(() =>
{
// 每执行一次模型，生成一次任务
newTask = new DmeTask
{
SysCode = GuidUtil.NewGuid(),
CreateTime = DateUtil.CurrentTimeMillis,
Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_WAITTING),
ModelId = model.Id,
VersionId = modelVersion.Id,
Remark = dto.Remark,
NodeServer = NetAssist.GetLocalHost()
};
if (string.IsNullOrWhiteSpace(dto.Name))
{
newTask.Name = "task-" + newTask.CreateTime;
}
else
{
newTask.Name = dto.Name;
}
newTask.LastTime = newTask.CreateTime;
newTask = db.Insertable <DmeTask>(newTask).ExecuteReturnEntity();
return(newTask);
}).Data;
// 创建job
await DmeQuartzScheduler <TaskRunnerJob> .NewJob(
newTask.SysCode,
modelType.SysCode,
dto.CronExpression,
new Dictionary <string, object> {
{ TaskRunnerJob.TASK_CODE_KEY, newTask.SysCode }
},
1 == dto.StartNow,
DateTimeOffset.Now.AddSeconds(dto.InSeconds),
dto.Remark);
return(newTask);
}
