public static void RegisterCrons()
{
var cronJobs = CronJob.GetCronJobs();
LogManager.Write("Initializing Cron Registry", LogType.Console);
CronRegistry.NonReentrantAsDefault();
foreach (var cronJob in cronJobs)
{
try
{
CronRegistry.Schedule(cronJob.Create <TcAdminCronJob>()).ToRunNow().AndEvery(cronJob.ExecuteEverySeconds).Seconds();
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
JobManager.Initialize(CronRegistry);
foreach (var schedule in JobManager.AllSchedules)
{
LogManager.Write($"{schedule.Name} has been scheduled to run at {schedule.NextRun:F}",
LogType.Console);
}
}
protected override void OnStart(string[] args)
{
//Below code fires once a second
job = new CronJob();
timerDelegate = new TimerCallback(job.DoSomething);
stateTimer = new Timer(timerDelegate, null, 1000, 1000);
}
public async Task UpdateCronJobAsync()
{
// Arrange
var fixture = Create();
var cronJob = new CronJob
{
Cron = Cron.Daily(),
Name = "1",
TypeName = "foo",
LastRun = new DateTime(2000, 1, 1)
};
await fixture.StoreCronJobAsync(cronJob);
cronJob.LastRun = new DateTime(2001, 1, 1);
cronJob.Cron = Cron.Minutely();
// Act
await fixture.UpdateCronJobAsync(cronJob);
// Assert
var job = fixture.Context.CronJobs.First();
job.LastRun.Should().Be(cronJob.LastRun);
job.Cron.Should().Be(cronJob.Cron);
}
public void TestStripComments()
{
Assert.IsNull(CronJob.Parse(ConfigReader.DoParseJobLine(null)));
Assert.IsNull(CronJob.Parse(ConfigReader.DoParseJobLine("")));
Assert.IsNull(CronJob.Parse(ConfigReader.DoParseJobLine(" ")));
Assert.IsNull(CronJob.Parse(ConfigReader.DoParseJobLine(" # This is some whitespace")));
}
public async Task <CronJob> UpdateJobAsync(CronJob cronJob)
{
cronJob.Token = _token;
var result = await _api.UpdateJobAsync(cronJob);
return(result.GetResult());
}
/// <summary>
/// </summary>
/// <param name="app"></param>
public static void UserCmsInitializer(this IApplicationBuilder app)
{
app.UseCmsMiddleware(); // 添加cms拦截器
// app.UseCmsRoutes(); // 注册路由
//Cms.OnInit += CmsEventRegister.Init;
// 初始化资源
SiteResourceInit.Init();
Cms.ConfigCache(new MemoryCacheWrapper());
Cms.Init(BootFlag.Normal, null);
// 加载插件
//WebCtx.Current.Plugin.Connect();
//设置可写权限
Cms.Utility.SetDirCanWrite(CmsVariables.RESOURCE_PATH);
Cms.Utility.SetDirCanWrite("templates/");
Cms.Utility.SetDirCanWrite(CmsVariables.FRAMEWORK_PATH);
Cms.Utility.SetDirCanWrite(CmsVariables.PLUGIN_PATH);
Cms.Utility.SetDirCanWrite(CmsVariables.TEMP_PATH + "update");
Cms.Utility.SetDirHidden("config");
//注册定时任务
CronJob.Initialize();
}
public async Task ExecuteAsync()
{
LoadCronJobSubscribers();
foreach (var cronJobSubscriber in _cronJobSubscribers)
{
var now = DateTime.Now;
var lastCronJob = await _dbContext.CronJobs
.Where(cj => cj.Service == cronJobSubscriber.GetType().FullName)
.OrderByDescending(cj => cj.ExecutionTime).FirstOrDefaultAsync();
var lastExecutionTime = lastCronJob?.ExecutionTime ?? DateTime.MinValue;
var timeSinceLastExecution = now - lastExecutionTime;
if (timeSinceLastExecution < cronJobSubscriber.GetMinimumIntervalBetweenExecutions())
{
continue;
}
var executionContext = new CronJobExecutionContext(lastExecutionTime, timeSinceLastExecution);
var executionResult = new CronJob()
{
Service = cronJobSubscriber.GetType().FullName,
Success = true,
ExecutionTime = now
};
try {
await cronJobSubscriber.ExecuteAsync(executionContext);
} catch (Exception e) {
executionResult.Success = false;
executionResult.Output = e.Message;
}
_dbContext.Add(executionResult);
}
await _dbContext.SaveChangesAsync();
}
public Task StoreJobAsync(CronJob job)
{
if (job == null)
{
throw new ArgumentNullException(nameof(job));
}
var sql = $@"
INSERT INTO {_schema}.CronJobs
(Id, Name, TypeName, Cron, LastRun)
VALUES
(@id, @name, @typeName, @cron, @lastRun)" ;
return(_storage.UseConnectionAsync(connection =>
{
return connection.ExecuteAsync(sql, new
{
id = job.Id,
name = job.Name,
typeName = job.TypeName,
cron = job.Cron,
lastRun = NormalizeDateTime(job.LastRun)
});
}));
}
public static void RegisterJobs()
{
string cron = "0 */30 * ? * *";
//CronJob.AddOrUpdate(GenerateJobInfo(typeof(JsonTransformationJob), cron));
CronJob.AddOrUpdate(GenerateJobInfo(typeof(SqlTransformationJob), cron));
}
public async Task GetCronJobsAsync()
{
// Arrange
var fixture = Create();
var cronJob1 = new CronJob
{
Cron = Cron.Daily(),
Name = "1",
TypeName = "foo",
LastRun = new DateTime(2000, 1, 1)
};
var cronJob2 = new CronJob
{
Cron = Cron.Minutely(),
Name = "2",
TypeName = "bar",
LastRun = new DateTime(2000, 1, 2)
};
await fixture.StoreCronJobAsync(cronJob1);
await fixture.StoreCronJobAsync(cronJob2);
// Act
var result = await fixture.GetCronJobsAsync();
// Assert
result.Should().HaveCount(2);
}
public virtual async Task WorkOutCronJobsCore(IStorageConnection connection, CronJobRegistry.Entry[] entries, CronJob[] currentJobs)
{
if (entries.Length != 0)
{
// Add or update jobs
foreach (var entry in entries)
{
var cronJob = currentJobs.FirstOrDefault(j => j.Name == entry.Name);
var updating = cronJob != null;
if (!updating)
{
cronJob = new CronJob
{
Name = entry.Name,
TypeName = entry.JobType.AssemblyQualifiedName,
Cron = entry.Cron,
LastRun = DateTime.MinValue
};
await connection.StoreJobAsync(cronJob);
}
else
{
cronJob.TypeName = entry.JobType.AssemblyQualifiedName;
cronJob.Cron = entry.Cron;
await connection.UpdateCronJobAsync(cronJob);
}
}
}
// Delete old jobs
foreach (var oldJob in currentJobs.Where(j => !entries.Any(e => e.Name == j.Name)))
{
await connection.RemoveCronJobAsync(oldJob.Name);
}
}
public bool ResumeJob(CronJob jobInfo)
{
var jobKey = KeyManager.CreateJobKey(jobInfo.Name, jobInfo.GroupName);
Scheduler.ResumeJob(jobKey);
return(true);
}
/// <summary>
/// Constructor to initialize the properties
/// </summary>
/// <param name="config">The schedule configurations</param>
/// <param name="logger">The logger</param>
/// <param name="httpService">The http helper service</param>
/// <param name="jobs">The jobs configuration</param>
public EStartEmpExportJob(IScheduleConfig <EStartEmpExportJob> config, ILogger <EStartEmpExportJob> logger, IHttpService httpService, IOptions <Jobs> jobs)
: base(config.CronExpression, config.TimeZoneInfo)
{
_logger = logger;
_httpService = httpService;
_job = jobs.Value.Cron.First(x => x.Key.Equals("EStartEmpExport"));
}
public void ConfigureServices(IServiceCollection services)
{
var appConfiguration = Configuration.GetSection(AppConfiguration.Section).Get <AppConfiguration>();
var csvFileHandlerJobConfig = Configuration.GetSection(CsvFileHandlerJobConfig.Section).Get <CsvFileHandlerJobConfig>();
services.AddAppConfig(Configuration);
services.AddAppServices();
services.AddHangfire(x =>
{
x.SetDataCompatibilityLevel(CompatibilityLevel.Version_170)
.UseSimpleAssemblyNameTypeSerializer()
.UseRecommendedSerializerSettings()
.UseSQLiteStorage(appConfiguration.SQLiteDBConn)
.UseNLogLogProvider();
var csvFileJob = JobsHelper.GenerateJobInfo(
typeof(TestCsvFileHandlerJob),
csvFileHandlerJobConfig.JobCron,
appConfiguration.TimeZoneId
);
CronJob.AddOrUpdate(csvFileJob);
});
services.AddHangfireServer();
}
public GameUpdate CreateGameUpdate()
{
var config = new CronJob().FindByType(typeof(MinecraftVanillaUpdatesCron)).Configuration.Parse <VanillaSettings>();
var newId = Regex.Replace(this.Id, "[^0-9]", "");
int.TryParse(newId, out var parsedId);
var variables = new Dictionary <string, object>
{
{ "Update", this },
{ "Update.Version", this.Id }
};
var gameUpdate = new GameUpdate
{
Name = config.NameTemplate.ReplaceWithVariables(variables),
GroupName = config.Group,
WindowsFileName = $"{this.Downloads.Server.Url} {config.FileName.ReplaceWithVariables(variables)}",
LinuxFileName = $"{this.Downloads.Server.Url} {config.FileName.ReplaceWithVariables(variables)}",
ImageUrl = config.ImageUrl,
ExtractPath = config.ExtractPath,
Reinstallable = true,
DefaultInstall = false,
GameId = config.GameId,
Comments = config.Description.ReplaceWithVariables(variables),
UserAccess = true,
SubAdminAccess = true,
ResellerAccess = true,
ViewOrder = config.UseVersionAsViewOrder ? parsedId : 0
};
gameUpdate.GenerateKey();
return(gameUpdate);
}
/// <summary> Executes the schedule asynchronous operation. </summary>
/// <typeparam name="TJob"> Type of the job. </typeparam>
/// <typeparam name="TJobData"> Type of the job data. </typeparam>
/// <param name="args"> The arguments. </param>
/// <returns> An asynchronous result. </returns>
public Task ExecuteScheduleAsync <TJob, TJobData>(TJobData args)
where TJob : IBackgroundJob, new()
where TJobData : IJobData
{
CronJob.AddOrUpdate <TJob>(j => j.Execute(null), args);
return(Task.FromResult(0));
}
public void TestParseExpenseFile()
{
CronJob job = new CronJob();
var result = job.parseExpenseFile("c:\\temp\\SampleImportData.expense");
Assert.IsTrue(result.Count > 0);
Assert.IsTrue(result[0].WBS1 == "1998001.00");
}
public CronEventEntry(string Name, CronEventHandler handler, CronJob Cronjob, bool Unique, CronLimit limit)
{
// infer a name from the handler passed in (if one was not supplied)
m_Name = (Name != null) ? Name : (handler != null && handler.Method != null && handler.Method.Name != null) ? handler.Method.Name : "Unknown";
m_Unique = Unique;
m_Handler = handler;
m_Cronjob = Cronjob;
m_Limit = limit;
}
/// <summary>
/// Creates a new cron job based on a specified method
/// call and schedules it to be trigger based on the expression.
/// </summary>
/// <param name="expression">The CRON expression.</param>
/// <param name="method">Instance method will executed.</param>
/// <returns>
/// Returns a <see cref="CronJob" /> representing the CRON job.
/// </returns>
public static CronJob Schedule(string expression, Action method)
{
var job = new CronJob(expression, method);
var delay = job.GetDelay();
job.Schedule(delay);
return(job);
}
public ComputedCronJob(CronJob job)
{
Job = job;
Schedule = CrontabSchedule.Parse(job.Cron);
if (job.TypeName != null)
{
JobType = Type.GetType(job.TypeName);
}
}
public void TestPostExpense()
{
CronJob job = new CronJob();
var records = job.parseExpenseFile("c:\\temp\\SampleImportData.expense");
var result = job.postToVision(records);
Assert.IsNotNull(result);
Assert.IsTrue(result.Errors.Count == 0);
}
/// <summary>
/// Constructor to initialize the properties
/// </summary>
/// <param name="config"></param>
/// <param name="logger"></param>
/// <param name="httpService"></param>
/// <param name="timeService"></param>
/// <param name="eStartService"></param>
/// <param name="jobs"></param>
public EStartExportJob(IScheduleConfig <EStartExportJob> config, ILogger <EStartExportJob> logger, IHttpService httpService, ITimeService timeService, IEStartService eStartService, IOptions <Jobs> jobs)
: base(config.CronExpression, config.TimeZoneInfo)
{
_logger = logger;
_httpService = httpService;
_timeService = timeService;
_eStartService = eStartService;
_job = jobs.Value.Cron.First(x => x.Key.Equals("EStartExport"));
_filters = JsonConvert.DeserializeObject <List <SpanFilter> >(_job.Filters);
}
public bool DeleteJob(CronJob jobInfo)
{
var jobKey = KeyManager.CreateJobKey(jobInfo.Name, jobInfo.GroupName);
var triggerKey = KeyManager.CreateTriggerKey(jobInfo.TriggerName, jobInfo.TriggerGroupName);
Scheduler.PauseTrigger(triggerKey);
Scheduler.UnscheduleJob(triggerKey);
Scheduler.DeleteJob(jobKey);
return(true);
}
public Task UpdateCronJobAsync(CronJob job)
{
if (job == null)
{
throw new ArgumentNullException(nameof(job));
}
_context.Update(job);
return(_context.SaveChangesAsync());
}
public AlarmDetailPage(CronJob item)
{
InitializeComponent();
var deleteItem = new ToolbarItem()
{
Text = "Delete"
};
deleteItem.Clicked += Delete_Clicked;
ToolbarItems.Add(deleteItem);
BindingContext = viewModel = new EditAlarmViewModel(item);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddHangfire(r =>
{
r.UseSqlServerStorage(Configuration.GetConnectionString("DefaultConnection"));
r.UseConsole();
r.UseDefaultActivator();
CronJob.AddOrUpdate("Jobs/hangfireJobs.json");
});
}
public ActionResult ConfigureCron([DynamicTypeBaseBinder] CronJob cronJob)
{
TempData["repeatEvery"] = cronJob.ExecuteEverySeconds;
var configurationJObject = cronJob.Configuration.Parse <JObject>();
var o = configurationJObject.ToObject(cronJob.Configuration.Type);
ViewData.TemplateInfo = new TemplateInfo
{
HtmlFieldPrefix = cronJob.Configuration.Type.Name,
};
return(PartialView($"{cronJob.Configuration.View}", o));
}
public void UpdateNext_LastRun_BeforePrev_SchedulesNow()
{
// Arrange
var now = new DateTime(2000, 1, 1, 8, 0, 0);
var cronJob = new CronJob(Cron.Daily(), now.Subtract(TimeSpan.FromDays(2)));
var computed = new ComputedCronJob(cronJob);
// Act
computed.UpdateNext(now);
// Assert
Assert.Equal(computed.Next, now);
}
public void UpdateNext_LastRun_AfterPrev_SchedulesNormal()
{
// Arrange
var now = new DateTime(2000, 1, 1, 8, 0, 0);
var cronJob = new CronJob(Cron.Daily(), now.Subtract(TimeSpan.FromSeconds(5)));
var computed = new ComputedCronJob(cronJob);
// Act
computed.UpdateNext(now);
// Assert
Assert.True(computed.Next > now);
}
public ActionResult ConfigureCron([DynamicTypeBaseBinder] CronJob cronJob, FormCollection model)
{
cronJob.ExecuteEverySeconds = int.Parse(Request[$"{cronJob.Configuration.Type.Name}.repeatEvery"]);
cronJob.Save();
TempData["repeatEvery"] = cronJob.ExecuteEverySeconds;
var bindModel = model.Parse(ControllerContext, cronJob.Configuration.Type);
cronJob.Configuration.SetConfiguration(bindModel);
return(Json(new
{
Message = $"Successfully updated <strong>{cronJob.Type.Name}</strong>"
}));
}
public override bool ModifyCronExpress(CronJob jobInfo)
{
var scheduleBuilder = CronScheduleBuilder.CronSchedule(jobInfo.CronExpress);
var triggerKey = KeyManager.CreateTriggerKey(jobInfo.TriggerName, jobInfo.TriggerGroupName);
var trigger = TriggerBuilder.Create().StartAt(DateTimeOffset.Now.AddYears(-1)).WithIdentity(triggerKey).WithSchedule(scheduleBuilder.WithMisfireHandlingInstructionDoNothing()).Build();
//WithMisfireHandlingInstructionDoNothing 不奏效
//Remove (delete) the Quartz.ITrigger with the given key, and store the new given one
Scheduler.RescheduleJob(triggerKey, trigger);
return(true);
}
protected override void OnStart(string [] args)
{
job = new CronJob();
timerDelegate = new TimerCallback(job.checkConnection);
stateTimer = new Timer(timerDelegate, null, 15000, 15000);
}
public CronEventEntry(string Name, CronEventHandler handler, CronJob Cronjob, bool Unique, CronLimit limit)
{
// infer a name from the handler passed in (if one was not supplied)
m_Name = (Name != null) ? Name : (handler != null && handler.Method != null && handler.Method.Name != null) ? handler.Method.Name : "Unknown";
m_Unique = Unique;
m_Handler = handler;
m_Cronjob = Cronjob;
m_Limit = limit;
}
