private void CheckHandlers(IJobProvider provider, IList <IJob> jobs, IList <Handler> handlers)
{
foreach (var job in jobs)
{
var handler = handlers.FirstOrDefault(e => e.Name == job.Name);
if (handler == null && job.Enable && !job.ClassName.IsNullOrEmpty())
{
XTrace.WriteLine("发现未知作业[{0}]@[{1}]", job.Name, job.ClassName);
try
{
// 实例化一个处理器
var type = Type.GetType(job.ClassName);
if (type != null)
{
handler = type.CreateInstance() as Handler;
if (handler != null)
{
XTrace.WriteLine("添加新作业[{0}]@[{1}]", job.Name, job.ClassName);
handler.Name = job.Name;
handler.Schedule = this;
handler.Provider = provider;
handler.Log = XTrace.Log;
handler.Start();
handlers.Add(handler);
}
}
}
catch { }
}
}
}
public WeekPlanService(
IJobProvider jobProvider,
IMemberService memberService,
IGroupService groupService,
IDayAssignService dayAssignService,
IJobStatusLogService jobStatusLogService,
IPathHelper pathHelper,
IManagementDepartmentService managementDepartmentService,
IJobService jobService,
IAppSettingHelper appSettingHelper,
IJobStatusService jobStatusService)
{
this.jobProvider = jobProvider;
this.memberService = memberService;
this.groupService = groupService;
this.dayAssignService = dayAssignService;
this.jobStatusLogService = jobStatusLogService;
this.pathHelper = pathHelper;
this.managementDepartmentService = managementDepartmentService;
this.jobService = jobService;
this.appSettingHelper = appSettingHelper;
this.jobStatusService = jobStatusService;
logger = LogManager.GetLogger("MoveExpiriedJobsLog");
}
public StreamHub(IJobProvider jobProvider,
IJobProcessor jobProcessor,
IJobBufferHandler buffer)
{
this.jobProvider = jobProvider;
this.jobProcessor = jobProcessor;
this.buffer = buffer;
}
public bool TryRegisterJobProvider(IJobProvider <TDef> jobProvider)
{
if (_registeredJobProviders.ContainsKey(jobProvider.InstanceId))
{
return(false);
}
_registeredJobProviders.Add(jobProvider.InstanceId, jobProvider);
return(true);
}
/// <summary>构造函数</summary>
public JobService()
{
this.configuration = MembershipConfigurationView.Instance.Configuration;
// 创建对象构建器(Spring.NET)
string springObjectFile = this.configuration.Keys["SpringObjectFile"].Value;
SpringObjectBuilder objectBuilder = SpringObjectBuilder.Create(MembershipConfiguration.ApplicationName, springObjectFile);
// ���������ṩ��
this.provider = objectBuilder.GetObject <IJobProvider>(typeof(IJobProvider));
}
public YearlyPlanService(
IJobProvider jobProvider,
ICategoryService categoryService,
IDayAssignProvider dayAssignProvider,
IMemberService memberService,
IJobAssignProvider jobAssignProvider)
{
this.jobProvider = jobProvider;
this.categoryService = categoryService;
this.dayAssignProvider = dayAssignProvider;
this.memberService = memberService;
this.jobAssignProvider = jobAssignProvider;
}
public IEnumerable <IJobWorker <TDef> > GetWorker(IJobProvider <TDef> jobProvider)
{
var jobIds = new List <string>();
foreach (var jobid in jobIds)
{
if (!_jobs.ContainsKey(jobid))
{
throw new Exception("Worker found with JobInstanceId: " + jobid + " But no job matches id");
}
else
{
foreach (var worker in _jobs[jobid].Workers)
{
yield return(worker);
}
}
}
}
public JobEngine(JobSetting setting, IMcJobExcute <T> worker, IJobProvider provider = null, ILog log = null)
{
lock (GetType())
{
if (!_isInitlize)
{
provider = provider ?? new JobProvider();
_lockFactory = provider.GetLockFactory(setting.ZkConnectionString, setting.SystemId);
_log = log;
_queue = provider.GetQueue <T>(setting.QueueConnectionString, setting.QueueName);
_worker = worker;
_cacheClient = provider.GetCacheClient(setting.RedisConnection, setting.RedisDb);
Task.Factory.StartNew(() =>
{
_queue.OnReceive(ExcuteTask);
}, TaskCreationOptions.LongRunning).ConfigureAwait(false);
_isInitlize = true;
}
}
}
public OperationalTaskService(
IMessageBus messageBus,
ITaskIdGenerator taskIdGenerator,
IJobAssignProvider jobAssignProvider,
IDayAssignService dayAssignService,
IJobProvider jobProvider,
ICategoryService categoryService,
IPathHelper pathHelper,
IMemberService memberService,
IJobStatusService jobStatusService,
IJobService jobService)
{
this.messageBus = messageBus;
this.taskIdGenerator = taskIdGenerator;
this.jobAssignProvider = jobAssignProvider;
this.dayAssignService = dayAssignService;
this.jobProvider = jobProvider;
this.categoryService = categoryService;
this.pathHelper = pathHelper;
this.memberService = memberService;
this.jobStatusService = jobStatusService;
this.jobService = jobService;
}
/// <summary>开始</summary>
public void Start()
{
// 如果没有指定工作者，则全局扫描
var bs = Jobs.ToList();
if (bs.Count == 0)
{
XTrace.WriteLine("没有可用工作者");
return;
}
// 启动作业提供者，获取所有作业
var prv = Provider;
if (prv == null)
{
prv = Provider = new JobFileProvider();
}
if (prv.Schedule == null)
{
prv.Schedule = this;
}
prv.Start();
var jobs = prv.GetJobs(bs.Select(e => e.Name).ToArray());
if (jobs == null || jobs.Length == 0)
{
XTrace.WriteLine("没有可用作业");
return;
}
// 输出日志
var mode = $"定时{Period}秒";
var msg = $"启动任务调度引擎[{prv}]，作业[{bs.Count}]项，模式：{mode}";
XTrace.WriteLine(msg);
// 设置日志
foreach (var wrk in bs)
{
wrk.Schedule = this;
wrk.Provider = prv;
var job = wrk.Model = jobs.FirstOrDefault(e => e.Name == wrk.Name);
if (job != null && job.Mode == 0)
{
job.Mode = wrk.Mode;
}
wrk.Log = XTrace.Log;
wrk.Start();
}
// 全部启动后再加入集合
Jobs.Clear();
Jobs.AddRange(bs);
// 定时执行
if (Period > 0)
{
_timer = new TimerX(Loop, null, 100, Period * 1000, "Job")
{
Async = true
}
}
;
}
/// <summary>开始</summary>
public void Start()
{
// 如果没有指定处理器，则全局扫描
var bs = Jobs.ToList();
if (bs.Count == 0)
{
XTrace.WriteLine("没有可用处理器");
return;
}
// 启动作业提供者，获取所有作业
var prv = Provider;
if (prv == null)
{
prv = Provider = new FileJobProvider();
}
if (prv.Schedule == null)
{
prv.Schedule = this;
}
prv.Start();
var jobs = prv.GetJobs();
if (jobs == null || jobs.Length == 0)
{
XTrace.WriteLine("没有可用作业");
return;
}
// 输出日志
var mode = $"定时{Period}秒";
var msg = $"启动任务调度引擎[{prv}]，作业[{bs.Count}]项，模式：{mode}";
XTrace.WriteLine(msg);
// 设置日志
foreach (var handler in bs)
{
handler.Schedule = this;
handler.Provider = prv;
var job = handler.Job = jobs.FirstOrDefault(e => e.Name == handler.Name);
if (job != null && job.Mode == 0)
{
job.Mode = handler.Mode;
}
handler.Log = XTrace.Log;
handler.Start();
}
//// 全部启动后再加入集合
//Jobs.Clear();
//Jobs.AddRange(bs);
// 定时执行
if (Period > 0)
{
_timer = new TimerX(Loop, null, 100, Period * 1000, "Job")
{
Async = true
}
}
;
}
/// <summary>开始</summary>
public void Start()
{
// 检查本地添加的处理器
var hs = Handlers;
if (hs.Count == 0)
{
throw new ArgumentNullException(nameof(Handlers), "没有可用处理器");
}
// 启动作业提供者
var prv = Provider;
if (prv == null)
{
prv = Provider = new FileJobProvider();
}
if (prv.Schedule == null)
{
prv.Schedule = this;
}
prv.Start();
// 获取本应用在调度中心管理的所有作业
var jobs = prv.GetJobs();
if (jobs == null || jobs.Length == 0)
{
throw new Exception("调度中心没有可用作业");
}
// 输出日志
var msg = $"启动任务调度引擎[{prv}]，作业[{hs.Count}]项，定时{Period}秒";
XTrace.WriteLine(msg);
// 设置日志
foreach (var handler in hs)
{
handler.Schedule = this;
handler.Provider = prv;
// 查找作业参数，分配给处理器
var job = jobs.FirstOrDefault(e => e.Name == handler.Name);
if (job != null && job.Mode == 0)
{
job.Mode = handler.Mode;
}
handler.Job = job;
handler.Log = XTrace.Log;
handler.Start();
}
// 定时执行
if (Period > 0)
{
_timer = new TimerX(Loop, null, 100, Period * 1000, "Job")
{
Async = true
}
}
;
}
