public Task Execute(IJobExecutionContext context) { var jobData = QuartzScheduler.GetJobDataConfiguration <MunicipalityCodeJobDataConfiguration>(context.JobDetail); var serviceProvider = context.Scheduler.Context.Get(QuartzScheduler.SERVICE_PROVIDER) as IServiceProvider; ExecuteInternal(unitOfWork => { var content = Download(jobData.Url, GetKapaConfiguration(context)); // roughly 300k var downloadedMunicipalityCodes = Parse(content); var existingMunicipalityCodes = unitOfWork.CreateRepository <IMunicipalityRepository>() .All() .Include(a => a.MunicipalityNames).ThenInclude(b => b.Localization) .ToList(); // add new postal codes and update existing var vmToEntity = serviceProvider.GetRequiredService <ITranslationViewModel>(); vmToEntity.TranslateAll <VmJsonMunicipality, Municipality>(downloadedMunicipalityCodes, unitOfWork); // invalidate not exist postal codes var municipalityCodesToInvalidate = existingMunicipalityCodes.Where(em => !downloadedMunicipalityCodes.Select(a => a.MunicipalityCode).Contains(em.Code)).ToList(); municipalityCodesToInvalidate.ForEach(m => m.IsValid = false); unitOfWork.Save(SaveMode.AllowAnonymous, userName: context.JobDetail.Key.Name); }, context); return(Task.CompletedTask); }
/// <summary> /// Instantiates the scheduler. /// </summary> /// <param name="rsrcs">The resources.</param> /// <param name="qs">The scheduler.</param> /// <returns>Scheduler.</returns> protected override IScheduler Instantiate(QuartzSchedulerResources rsrcs, QuartzScheduler qs) { var scheduler = base.Instantiate(rsrcs, qs); scheduler.JobFactory = _jobFactory; return(scheduler); }
public async Task <JsonResult> GetJobHistory() { int count = 0; QuartzScheduler context = new QuartzScheduler(quartzJobStoreSettings.QuartzConnectionString); var dataTableData = new DataTableData <QRTZ_JOB_HISTORY>(); var gridData = context.QRTZ_JOB_HISTORY.ToList();//new List<QRTZ_JOB_HISTORY>(); PagingData pgData = new PagingData(Request.QueryString); Expression <Func <QRTZ_JOB_HISTORY, bool> > where = w => ( w.JOB_NAME.Contains(pgData.Search ?? "")); /* Expression<Func<Order, bool>> where = w => ( * w.OrderNumber != "");*/ dataTableData.draw = pgData.Draw; // count = gridData.Count; gridData = await GetList(gridData.Where(d => d.JOB_NAME != "").AsQueryable().OrderByDescending(d => d.STARTDATE).ThenBy(d => d.JOB_NAME), pgData, where); dataTableData.data = gridData; dataTableData.recordsFiltered = count; dataTableData.recordsTotal = count; dataTableData.success = true; return(Json(dataTableData, JsonRequestBehavior.AllowGet)); }
private void ScheduleExecuteActionJob(long entityId, AuditEntity auditEntity, AutomatedAction ac) { var scheduler = new QuartzScheduler( ConfigurationManager.AppSettings["QuartzServer"], Convert.ToInt32(ConfigurationManager.AppSettings["QuartzPort"]), ConfigurationManager.AppSettings["QuartzScheduler"]); IDictionary <string, object> map = new Dictionary <string, object>(); map.Add("EntityId", entityId.ToString()); map.Add("EntityType", auditEntity.EntityType.Name); map.Add("AutomatedActionId", ac.Id.ToString()); //get Type of Job Type type = Type.GetType("BaseEAM.Services.ExecuteActionJob, BaseEAM.Services"); if (ac.TriggerType == (int?)ActionTriggerType.Immediately) { scheduler.ScheduleOneTimeJob(type, map); } else if (ac.TriggerType == (int?)ActionTriggerType.TimeBased) { scheduler.ScheduleOneTimeJob(type, map, ac.HoursAfter); } }
public Task SaveHistory(IJobExecutionContext context, string Status) { return(Task.Run(() => { QuartzScheduler db = new QuartzScheduler(quartzJobStoreSettings.QuartzConnectionString); QRTZ_JOB_HISTORY history = new QRTZ_JOB_HISTORY(); history.JOB_GROUP = context.JobDetail.Key.Group; history.SCHED_NAME = context.Scheduler.SchedulerName; history.JOB_NAME = context.JobDetail.Key.Name; history.STATUSDETAIL = Status; history.RECORDDATE = DateTime.Now; history.STARTDATE = context.FireTimeUtc.ToLocalTime().DateTime; history.ENDDATE = history.STARTDATE + context.JobRunTime; history.ISEXCEPTION = (Status != "Successful"); history.TRIGGER_GROUP = context.Trigger.Key.Group; history.TRIGGER_NAME = context.Trigger.Key.Name; using (MemoryStream memoryStream = new MemoryStream()) { BinaryFormatter binaryFormatter = new BinaryFormatter(); binaryFormatter.Serialize(memoryStream, context.JobDetail.JobDataMap); history.JOB_DATA = memoryStream.ToArray(); } IQuartzServiceJob job = (IQuartzServiceJob)context.JobInstance; history.LOGFILE = job.GetLogFile(); db.QRTZ_JOB_HISTORY.InsertOnSubmit(history); db.SubmitChanges(); })); }
/// <summary> /// Initializes the job execution context with given scheduler and bundle. /// </summary> /// <param name="sched">The scheduler.</param> /// <param name="cancellationToken">The cancellation instruction.</param> public virtual async Task Initialize( QuartzScheduler sched, CancellationToken cancellationToken = default) { qs = sched; IJob job; IJobDetail jobDetail = firedTriggerBundle.JobDetail; try { job = sched.JobFactory.NewJob(firedTriggerBundle, scheduler); } catch (SchedulerException se) { await sched.NotifySchedulerListenersError($"An error occurred instantiating job to be executed. job= '{jobDetail.Key}'", se, cancellationToken).ConfigureAwait(false); throw; } catch (Exception e) { SchedulerException se = new SchedulerException($"Problem instantiating type '{jobDetail.JobType.FullName}: {e.Message}'", e); await sched.NotifySchedulerListenersError($"An error occurred instantiating job to be executed. job= '{jobDetail.Key}, message={e.Message}'", se, cancellationToken).ConfigureAwait(false); throw se; } jec = new JobExecutionContextImpl(scheduler, firedTriggerBundle, job); }
public SchedulerSignalerImpl(QuartzScheduler sched, QuartzSchedulerThread schedThread) { this.sched = sched; this.schedThread = schedThread; log.Info("Initialized Scheduler Signaller of type: " + GetType()); }
protected override IScheduler Instantiate(QuartzSchedulerResources rsrcs, QuartzScheduler qs) { var sch = base.Instantiate(rsrcs, qs); sch.JobFactory = _serviceProvider.GetService <IJobFactory>(); return(sch); }
/// <summary> /// Initializes the job execution context with given scheduler and bundle. /// </summary> /// <param name="sched">The scheduler.</param> /// <param name="firedBundle">The bundle offired triggers.</param> public virtual void Initialize(QuartzScheduler sched, TriggerFiredBundle firedBundle) { qs = sched; IJob job; JobDetail jobDetail = firedBundle.JobDetail; try { job = sched.JobFactory.NewJob(firedBundle); } catch (SchedulerException se) { sched.NotifySchedulerListenersError(string.Format(CultureInfo.InvariantCulture, "An error occured instantiating job to be executed. job= '{0}'", jobDetail.FullName), se); throw; } catch (Exception e) { SchedulerException se = new SchedulerException(string.Format(CultureInfo.InvariantCulture, "Problem instantiating type '{0}'", jobDetail.JobType.FullName), e); sched.NotifySchedulerListenersError(string.Format(CultureInfo.InvariantCulture, "An error occured instantiating job to be executed. job= '{0}'", jobDetail.FullName), se); throw se; } jec = new JobExecutionContext(scheduler, firedBundle, job); }
public JsonResult GetLogFiles() { QuartzScheduler context = new QuartzScheduler(quartzJobStoreSettings.QuartzConnectionString); var list = QuartzProgram <AdminController> .GetJobHistory().Select(s => s.LOGFILE).Distinct().ToArray(); return(Json(list, JsonRequestBehavior.AllowGet)); }
protected override IScheduler Instantiate(QuartzSchedulerResources rsrcs, QuartzScheduler qs) { SetFactory(qs); var res = new CustomScheduler(qs, _container); AddListeners(res); return(res); }
private static void AddNewTriggersToScheduler(IList newItems) { foreach (TriggerModel item in newItems) { var trigger = QuartzTrigger.CreateTriggerForExistedJob(item.DateStart, item.RepeatType, item.TriggerId.ToString()); QuartzScheduler.AttachTrigger(trigger); } }
private static void RemoveOldTriggersFromScheduler(IList oldItems) { foreach (TriggerModel item in oldItems) { var triggerKey = QuartzTrigger.GetTriggerKey(item.DateStart, item.RepeatType); QuartzScheduler.DetachTrigger(triggerKey); } }
public IActionResult ForceJob(JobTypeEnum?jobType) { if (jobType == null) { throw new Exception($"JobType '{ControllerContext.RouteData.Values[nameof(jobType)]}' is not defined."); } QuartzScheduler.ForceJobExecution(jobType.Value); return(Ok("Task started ...")); }
public IActionResult RestartJob(JobTypeEnum?jobType) { if (jobType == null) { throw new Exception($"JobType '{ControllerContext.RouteData.Values[nameof(jobType)]}' is not defined."); } QuartzScheduler.RestartJob(jobType.Value); return(Ok($"Task '{jobType}' has been restarted.")); }
public void CreateQuartzSchedulerDatabase(string ConnectionStr) { if (ConnectionStr == string.Empty) { ConnectionStr = "data source=localhost;initial catalog=Quartz;integrated security=True"; } QuartzScheduler context = new QuartzScheduler(ConnectionStr); context.CreateDatabase(); }
protected virtual void Dispose(bool disposing) { if (disposing) { if (sched != null) { sched.Dispose(); sched = null; } } }
public string HandleScheduler(string type) { string msg = ""; try { if (type == "Run") { if (sched != null) { if (!sched.IsShutdown) { sched.Clear(); } } QuartzScheduler.Run(); } if (type == "Pause") { if (sched != null) { if (!sched.IsShutdown) { sched.PauseAll(); } } } if (type == "Resume") { if (sched != null) { if (!sched.IsShutdown) { sched.ResumeAll(); } } } if (type == "Shutdown") { if (sched != null) { if (!sched.IsShutdown) { sched.Shutdown(false); } } } } catch (Exception ex) { msg = ex.Message; } return(msg); }
protected override async Task SchedulePostBootJobs() { if (!Configuration.LoadedConfiguration.FirstRunCompleted) { await QuartzScheduler.ScheduleJob <BcatFirstRunJob>("Normal"); } else if (Configuration.LoadedConfiguration.IsProduction) { await QuartzScheduler.ScheduleJob <BcatCheckerJob>("Normal", Configuration.LoadedConfiguration.JobSchedules["Bcat"]); } }
public async Task Shutdown(bool shouldRestart = true) { if (!shouldRestart && RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { // Write out the automatic restart disabling file File.WriteAllText(Program.LOCAL_AUTOMATIC_RESTART_DISABLE_FLAG, "no restart"); } await Context.Channel.SendMessageAsync("**[Admin]** OK, scheduling immediate shutdown"); await QuartzScheduler.ScheduleJob <ShutdownJob>("Immediate"); }
protected override IScheduler Instantiate(QuartzSchedulerResources rsrcs, QuartzScheduler scheduler) { try { scheduler.JobFactory = _unityJobFactory; return(base.Instantiate(rsrcs, scheduler)); } catch (Exception ex) { return(null); } }
private async Task Run(bool fastShutdown) { Console.WriteLine($"{(fastShutdown ? "Fast" : "Slow")} shutdown started"); if (!fastShutdown) { // Shutdown the Scheduler await QuartzScheduler.Dispose(); // Shutdown the DiscordBot await DiscordBot.Dispose(); } else { // Create a backup of the current config.json just in case File.Copy(Boot.LOCAL_CONFIGURATION, Boot.LOCAL_CONFIGURATION_AUTOMATIC_BACKUP, true); } // Shutdown Twitter TwitterManager.Dispose(); // Shutdown DigitalOcean DoApi.Dispose(); // Shutdown S3 S3Api.Dispose(); // Shutdown BCAT BcatApi.Dispose(); // Shutdown DAuth DAuthApi.Dispose(); // Shutdown the HandlerMapper HandlerMapper.Dispose(); // Shutdown the KeysetManager KeysetManager.Dispose(); // Shutdown anything app-specific ShutdownAppSpecificItems(); // Save the configuration Configuration.LoadedConfiguration.Write(); if (!fastShutdown) { // Wait a little while await Task.Delay(1000 *ShutdownWaitTime); } Console.WriteLine("Shutdown complete"); }
/// <summary> /// Construct a new <see cref="QuartzSchedulerThread" /> for the given /// <see cref="QuartzScheduler" /> as a non-daemon <see cref="Thread" /> /// with normal priority. /// </summary> internal QuartzSchedulerThread(QuartzScheduler qs, QuartzSchedulerResources qsRsrcs) { Log = LogProvider.GetLogger(GetType()); //ThreadGroup generatedAux = qs.SchedulerThreadGroup; this.qs = qs; this.qsRsrcs = qsRsrcs; // start the underlying thread, but put this object into the 'paused' // state // so processing doesn't start yet... paused = true; halted = false; }
public ScheduledJobController(QuartzScheduler quartzScheduler, ILocalizationService localizationService, IPermissionService permissionService, HttpContextBase httpContext, IWorkContext workContext, IDbContext dbContext) { this._quartzScheduler = quartzScheduler; this._localizationService = localizationService; this._permissionService = permissionService; this._httpContext = httpContext; this._workContext = workContext; this._dbContext = dbContext; }
/// <summary> /// Construct a new <see cref="QuartzSchedulerThread" /> for the given /// <see cref="QuartzScheduler" /> as a <see cref="Thread" /> with the given /// attributes. /// </summary> internal QuartzSchedulerThread(QuartzScheduler qs, QuartzSchedulerResources qsRsrcs, bool setDaemon, int threadPrio) : base(qsRsrcs.ThreadName) { //ThreadGroup generatedAux = qs.SchedulerThreadGroup; this.qs = qs; this.qsRsrcs = qsRsrcs; IsBackground = setDaemon; Priority = (ThreadPriority)threadPrio; // start the underlying thread, but put this object into the 'paused' // state // so processing doesn't start yet... paused = true; halted = false; }
private void RestartJob() { try { IScheduler sched = QuartzBase.GetRemoteScheduler(); if (!sched.IsShutdown) { sched.Clear(); } QuartzScheduler.Run(); } catch (Exception) { } }
private static IScheduler CreateScheduler(string customerCode) { var ramJobStore = new RAMJobStore(); var schedulerResources = new QuartzSchedulerResources { JobRunShellFactory = new StdJobRunShellFactory(), JobStore = ramJobStore, Name = $"TasksScheduler_{customerCode}" }; var threadPool = new DefaultThreadPool(); threadPool.Initialize(); schedulerResources.ThreadPool = threadPool; var quartzScheduler = new QuartzScheduler(schedulerResources, TimeSpan.Zero); ITypeLoadHelper loadHelper; try { loadHelper = ObjectUtils.InstantiateType <ITypeLoadHelper>(typeof(SimpleTypeLoadHelper)); } catch (Exception e) { throw new SchedulerConfigException("Unable to instantiate type load helper: {0}".FormatInvariant(e.Message), e); } loadHelper.Initialize(); ramJobStore.Initialize(loadHelper, quartzScheduler.SchedulerSignaler); var standartScheduler = new StdScheduler(quartzScheduler); schedulerResources.JobRunShellFactory.Initialize(standartScheduler); quartzScheduler.Initialize(); SchedulerRepository schedRep = SchedulerRepository.Instance; schedRep.Bind(standartScheduler); return(standartScheduler); }
protected override async Task SchedulePostBootJobs() { // Check if this is the production bot if (Configuration.LoadedConfiguration.IsProduction) { // Schedule regular BCAT checks await QuartzScheduler.ScheduleJob <BcatCheckerJob>("Regular", Configuration.LoadedConfiguration.JobSchedules["Bcat"]); await DiscordBot.LoggingChannel.SendMessageAsync($"**[BootHousekeepingJob]** Scheduling immediate BCAT check"); // Schedule a BCAT check now await QuartzScheduler.ScheduleJob <BcatCheckerJob>("Immediate"); } // Schedule the recurring housekeeping job await QuartzScheduler.ScheduleJob <SsbuBotRecurringHousekeepingJob>("Regular", Configuration.LoadedConfiguration.JobSchedules["Housekeeping"]); }
private void ShutdownFromInstantiateException(IThreadPool tp, QuartzScheduler qs, bool tpInited, bool qsInited) { try { if (qsInited) { qs.Shutdown(false); } else if (tpInited) { tp.Shutdown(false); } } catch (Exception e) { Log.Error("Got another exception while shutting down after instantiation exception", e); } }
public ImportProfileController(ILocalizationService localizationService, IRepository <ImportProfile> importProfileRepository, IImportProfileService importProfileService, QuartzScheduler quartzScheduler, IPermissionService permissionService, HttpContextBase httpContext, IWorkContext workContext, IDbContext dbContext) { this._localizationService = localizationService; this._quartzScheduler = quartzScheduler; this._importProfileRepository = importProfileRepository; this._importProfileService = importProfileService; this._permissionService = permissionService; this._httpContext = httpContext; this._workContext = workContext; this._dbContext = dbContext; }
/// <summary> /// Instantiates the scheduler. /// </summary> /// <param name="rsrcs">The resources.</param> /// <param name="qs">The scheduler.</param> /// <returns>Scheduler.</returns> protected override IScheduler Instantiate(QuartzSchedulerResources rsrcs, QuartzScheduler qs) { var scheduler = base.Instantiate(rsrcs, qs); scheduler.JobFactory = _jobFactory; return scheduler; }