public async Task <Boolean> DeleteModelAsync(string modelCode)
{
return(await Task.Run <Boolean>(() => {
var db = Repository.GetDbContext();
return db.Ado.UseTran <Boolean>(() =>
{
DmeModel model = db.Queryable <DmeModel>().Single(m => m.SysCode == modelCode);
if (null == model)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"模型[{modelCode}]不存在");
}
model.Status = 0;
db.Updateable <DmeModel>(model).UpdateColumns(m => m.Status).ExecuteCommand();
// 级联逻辑删除版本
var updateCount = db.Updateable <DmeModelVersion>()
.UpdateColumns(it => new DmeModelVersion()
{
Status = 0
})
.Where(it => it.ModelId == model.Id).ExecuteCommand();
LOG.Info($"共更新[{updateCount}]条版本记录");
// 暂停模型相关的任务
List <DmeTask> tasks = db.Queryable <DmeTask>().Where(t => t.ModelId == model.Id).ToList();
if (tasks?.Count > 0)
{
foreach (var subTask in tasks)
{
DmeQuartzScheduler <TaskRunnerJob> .PauseJob(subTask.SysCode, model.ModelTypeCode);
}
}
return true;
}).Data;
}));
}
public object OperateTask(string taskCode, int operation)
{
var db = Repository.GetDbContext();
DmeTask task = db.Queryable <DmeTask>().Single(t => t.SysCode == taskCode);
if (null == task)
{
throw new BusinessException((int)EnumSystemStatusCode.DME_FAIL, $"任务[{taskCode}]不存在");
}
DmeModel model = db.Queryable <DmeModel>().InSingle(task.ModelId);
switch (operation)
{
case 0:
LOG.Info($"停止任务[{taskCode}]");
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_STOP);
task.LastTime = DateUtil.CurrentTimeMillis;
db.Updateable <DmeTask>(task).UpdateColumns(t => new { task.Status, task.LastTime }).ExecuteCommand();
DmeQuartzScheduler <TaskRunnerJob> .PauseJob(task.SysCode, model.ModelTypeCode);
break;
case 1:
// @TODO 有待完成
LOG.Info($"重启任务[{taskCode}]");
task.Status = EnumUtil.GetEnumDisplayName(EnumSystemStatusCode.DME_RUNNING);
task.LastTime = DateUtil.CurrentTimeMillis;
db.Updateable <DmeTask>(task).UpdateColumns(t => new { task.Status, task.LastTime }).ExecuteCommand();
DmeQuartzScheduler <TaskRunnerJob> .ResumeJob(task.SysCode, model.ModelTypeCode);
break;
case -1:
LOG.Info($"删除任务[{taskCode}]");
// 删除与任务相关的步骤记录和结果记录
int count = db.Deleteable <DmeTaskRuleStep>(trs => trs.TaskId == task.Id).ExecuteCommand();
LOG.Info($"删除任务[{taskCode}]关联的[{count}]个步骤记录");
count = db.Deleteable <DmeTaskResult>(tr => tr.TaskId == task.Id).ExecuteCommand();
LOG.Info($"删除任务[{taskCode}]关联的[{count}]个结果记录");
// 从mongo中获取
var filter = Builders <TaskResultColl> .Filter.And(
Builders <TaskResultColl> .Filter.Eq("TaskId", task.Id));
MongodbHelper <TaskResultColl> .DeleteMany(ServiceFactory.MongoDatabase, filter);
db.Deleteable <DmeTask>(task).ExecuteCommand();
DmeQuartzScheduler <TaskRunnerJob> .DeleteJob(task.SysCode, model.ModelTypeCode);
break;
default:
break;
}
return(true);
}
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);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
// 设置数据源，读取appsettings.json配置文件
GlobalSystemConfig.DBConnectionString = this.Configuration.GetConnectionString("DataSource");
// 注册缓存对象
services.AddMemoryCache();
IConfigurationSection connectionStringsSection = this.Configuration.GetSection("ConnectionStrings");
IConfigurationSection cacheProviderSection = connectionStringsSection.GetSection("CacheProvider");
if (cacheProviderSection != null)
{
try
{
string type = cacheProviderSection.GetValue <string>("type");
if ("redis".Equals(type, StringComparison.OrdinalIgnoreCase))
{
// redis 分布式缓存
RedisCacheProvider provider = cacheProviderSection.GetSection("provider").Get <RedisCacheProvider>();
services.AddSingleton(typeof(ICacheService), new RedisCacheService(new RedisCacheOptions
{
Configuration = provider.HostName + ":" + provider.Port,
InstanceName = provider.InstanceName
}, provider.DataBase));
}
else if ("redis.r.w".Equals(type, StringComparison.OrdinalIgnoreCase))
{
// redis读写分离
RedisRWConfigInfo provider = cacheProviderSection.GetSection("provider").Get <RedisRWConfigInfo>();
RedisManager redisManager = new RedisManager(provider);
services.AddSingleton(typeof(ICacheService), new RedisRWCacheService(redisManager.GetClient()));
}
}
catch (Exception ex)
{
LOG.Error(ex, "redis连接失败，准备启用MemoryCache服务");
SetCacheService(services);
}
}
else
{
SetCacheService(services);
}
// mongo
IConfigurationSection mongoSection = this.Configuration.GetSection("ConnectionStrings").GetSection("Mongo");
if (mongoSection != null)
{
try
{
// 注册mongo连接信息
MongodbHost mongohost = mongoSection.Get <MongodbHost>();
services.AddSingleton(typeof(MongodbHost), mongohost);
// IMongoClient mongoClient = new MongoClient(mongohost.Connection);
IMongoClient mongoClient = MongodbManager <object> .GetMongodbClient(mongohost.ConnectionString);
services.AddSingleton(typeof(IMongoClient), mongoClient);
IMongoDatabase mongoDatabase = mongoClient.GetDatabase(mongohost.DataBase);
services.AddSingleton(typeof(IMongoDatabase), mongoDatabase);
}
catch (Exception ex)
{
LOG.Error(ex, "mongo连接失败");
}
}
// 注册知识库
services.AddSingleton <IRepository, Repository>();
// 注册版本服务
services.AddSingleton <IVersionService, VersionService>();
// 注册用户服务
services.AddSingleton <IUserService, UserService>();
// 注册模型服务
services.AddSingleton <IModelService, ModelService> ();
// 注册数据源服务
services.AddSingleton <IDataSourceService, DataSourceService>();
// 注册算法服务
services.AddSingleton <IAlgorithmService, AlgorithmService>();
// 注册业务日志服务
services.AddSingleton <ILogService, LogService>();
// 注册任务服务
services.AddSingleton <ITaskService, TaskService>();
// 设置全局
IServiceProvider serviceProvider = services.BuildServiceProvider();
ServiceFactory.CacheService = serviceProvider.GetService <ICacheService>();
ServiceFactory.MongoHost = serviceProvider.GetService <MongodbHost>();
ServiceFactory.MongoClient = serviceProvider.GetService <IMongoClient>();
ServiceFactory.MongoDatabase = serviceProvider.GetService <IMongoDatabase>();
// 消息相关
IConfigurationSection messageSection = connectionStringsSection.GetSection("Message");
if (messageSection != null)
{
// 消息
IConfigurationSection mqSection = messageSection.GetSection("MQ");
if (mqSection != null)
{
KafkaSetting kafkaSetting = mqSection.Get <KafkaSetting>();
if (kafkaSetting.Switch)
{
KafkaConsumer.CreateConsumer(kafkaSetting.Opinion.GroupId, kafkaSetting.Opinion.Servers, kafkaSetting.Opinion.Topics);
KafkaConsumer.Start();
KafkaProducer.CreateProducer(kafkaSetting.Opinion.Servers);
}
}
// websocket
IConfigurationSection websocketSection = messageSection.GetSection("Websocket");
if (websocketSection != null)
{
WebsocketSetting websocketSetting = websocketSection.Get <WebsocketSetting>();
WebsocketFleckServer.CreateWebsocketServer(websocketSetting.NodeId, websocketSetting.Port, websocketSetting.Host);
}
}
// scheduler，注入参数设置
IConfigurationSection schedulerSection = this.Configuration.GetSection("Scheduler");
if (schedulerSection != null)
{
if (schedulerSection.GetValue <Boolean>("switch"))
{
IConfigurationSection propertiesSection = schedulerSection.GetSection("properties");
var values = propertiesSection.GetChildren()
.Select(item => new KeyValuePair <string, string>(item.Key,
item.Value.Contains("$") ? Configuration.GetValue <string>(item.Value.Replace("${", "").Replace("}", "")) : item.Value))
.ToDictionary(x => x.Key, x => x.Value);
DmeQuartzScheduler <TaskRunnerJob> .SetSchedulerProperties(DataUtil.ToNameValueCollection(values));
// 调取开启。如果不开启，则不会执行。
DmeQuartzScheduler <TaskRunnerJob> .Start().GetAwaiter();
}
}
// DemoScheduler.RunProOracle().Wait();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info
{
Version = "v1",
Title = "Dist Model Engine接口文档",
Description = "RESTful API for DME",
TermsOfService = "None",
Contact = new Contact {
Name = "weifj", Email = "*****@*****.**", Url = "https://github.com/leoterry-ulrica/dme"
}
});
//Set the comments path for the swagger json and ui.
var basePath = PlatformServices.Default.Application.ApplicationBasePath;
var xmlPath = Path.Combine(basePath, "Dist.Dme.WebApi.xml");
c.IncludeXmlComments(xmlPath);
// c.OperationFilter<HttpHeaderOperation>(); // 添加httpHeader参数
});
// 配置日志服务
services.AddLogging();
}
