// This method will kill the current recurring job if it exists
// and return normally so no retry is attempted.
protected void ClearAndExit(int projectId)
{
var jobToken = GetHangfireToken(projectId);
RecurringJobManager.RemoveIfExists(jobToken);
return;
}
protected void ClearRecurringJob(Guid productId)
{
var jobToken = GetHangfireToken(productId);
RecurringJobManager.RemoveIfExists(jobToken);
return;
}
protected async Task CreateBuildEngineBuildAsync(Product product)
{
await ResetPreviousBuildAsync(product);
BuildResponse buildResponse = null;
if (SetBuildEngineEndpoint(product.Project.Organization))
{
buildResponse = BuildEngineApi.CreateBuild(product.WorkflowJobId);
}
if ((buildResponse != null) && (buildResponse.Id != 0))
{
product.WorkflowBuildId = buildResponse.Id;
var productBuild = new ProductBuild
{
ProductId = product.Id,
BuildId = product.WorkflowBuildId
};
await ProductBuildRepository.CreateAsync(productBuild);
await ProductRepository.UpdateAsync(product);
var monitorJob = Job.FromExpression <BuildEngineBuildService>(service => service.CheckBuild(product.Id));
RecurringJobManager.AddOrUpdate(GetHangfireToken(product.Id), monitorJob, "* * * * *");
}
else
{
// TODO: Send Notification
// Throw Exception to force retry
throw new Exception("Create build failed");
}
}
protected async Task CreateBuildEngineProjectAsync(Project project)
{
var buildEngineProject = new BuildEngineProject
{
UserId = project.Owner.Email,
GroupId = project.Group.Abbreviation,
AppId = project.Type.Name,
LanguageCode = project.Language,
PublishingKey = project.Owner.PublishingKey,
ProjectName = project.Name
};
ProjectResponse projectResponse = null;
if (SetBuildEngineEndpoint(project.Organization))
{
projectResponse = BuildEngineApi.CreateProject(buildEngineProject);
}
if ((projectResponse != null) && (projectResponse.Id != 0))
{
// Set state to active?
project.WorkflowProjectId = projectResponse.Id;
await ProjectRepository.UpdateAsync(project);
var monitorJob = Job.FromExpression <BuildEngineProjectService>(service => service.ManageProject(project.Id));
RecurringJobManager.AddOrUpdate(GetHangfireToken(project.Id), monitorJob, "* * * * *");
}
else
{
// TODO: Send Notification
// Throw Exception to force retry
throw new Exception("Create project failed");
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHangfireDashboard();
var manager = new RecurringJobManager();
manager.AddOrUpdate("ReadTransactionJob", Job.FromExpression(() => Console.WriteLine("")), "*/5 * * * *");
manager.AddOrUpdate("ReadTransactionJob2", Job.FromExpression(() => Console.WriteLine("")), "*/8 * * * *");
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseMvc();
}
private void ServiceThreadFunc()
{
var uri = ConfigurationManager.AppSettings["HangfireUri"];
var pluginPath = ConfigurationManager.AppSettings["PluginDirectory"];
AppDomain.CurrentDomain.AssemblyResolve += (sender, args) => {
var asmName = new AssemblyName(args.Name);
var plugin = Path.Combine(pluginPath, asmName.Name + ".dll");
if (File.Exists(plugin))
{
return(Assembly.LoadFrom(plugin));
}
return(null);
};
using (var webApp = WebApp.Start <OwinStartup>(uri))
{
var manager = new RecurringJobManager();
InitializeCatalog(pluginPath);
LoadPlugins(manager);
logger.Info("Web Application listening.");
_shutdownEvent.WaitOne();
}
}
public static void InitializeTenants(this IApplicationBuilder app, ITenantService tenantService)
{
//var teervice = app.ApplicationServices.GetRequiredService <ITenantService>();
var tenants = tenantService.GetTenants().Result;
foreach (var tenant in tenants)
{
GlobalConfiguration.Configuration.UseSqlServerStorage(tenant.ConnectionString);
var sqlStorage = new SqlServerStorage(tenant.ConnectionString);
//var myapp = app.New();
app.UseHangfireDashboard($"/dashboard/{tenant.Name}", new DashboardOptions
{
Authorization = new[] { new HangfireAuthFilter() }
}, sqlStorage);
var options = new BackgroundJobServerOptions
{
ServerName = string.Format("{0}.{1}", tenant.Name, Guid.NewGuid().ToString()),
};
var jobStorage = JobStorage.Current;
app.UseHangfireServer(options, null, jobStorage);
//RecurringJob.AddOrUpdate<IHangfireRecurringJobService>(j => j.CheckForAbandonedCart(), Cron.Minutely);
var recurringJobManager = new RecurringJobManager();
recurringJobManager.RemoveIfExists(tenant.Id.ToString());
recurringJobManager.AddOrUpdate <IHangfireRecurringJobService>(tenant.Id.ToString(), j => j.CheckForAbandonedCart(tenant.ConnectionString), Cron.Minutely);
recurringJobManager.Trigger(tenant.Id.ToString());
}
}
public async Task Dispatch([NotNull] DashboardContext context)
{
var response = new Response()
{
Status = true
};
var job = new PeriodicJob();
job.Id = context.Request.GetQuery("Id");
job.Cron = context.Request.GetQuery("Cron");
job.Class = context.Request.GetQuery("Class");
job.Method = context.Request.GetQuery("Method");
job.Queue = context.Request.GetQuery("Queue");
if (!Utility.IsValidSchedule(job.Cron))
{
response.Status = false;
response.Message = "Invalid CRON";
await context.Response.WriteAsync(JsonConvert.SerializeObject(response));
return;
}
var manager = new RecurringJobManager(context.Storage);
var updatedJob = new Job(Type.GetType(job.Class).GetMethod(job.Method));
manager.AddOrUpdate(job.Id, updatedJob, job.Cron, TimeZoneInfo.Utc, job.Queue);
context.Response.StatusCode = (int)HttpStatusCode.OK;
await context.Response.WriteAsync(JsonConvert.SerializeObject(response));
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
System.Web.Http.GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
HangfireAspNet.Use(GetHangfireServers);
//BackgroundJob.Enqueue(() => CrawlerJobs.RemoveAll());
//BackgroundJob.Enqueue(() => CrawlerJobs.GetDiscounts());
//using (var connection = JobStorage.Current.GetConnection())
//{
// foreach (var recurringJob in StorageConnectionExtensions.GetRecurringJobs(connection))
// {
// RecurringJob.RemoveIfExists(recurringJob.Id);
// }
//}
// BackgroundJob.Enqueue(() => CrawlerJobs.AddGame());
//RecurringJob.AddOrUpdate(() => CrawlerJobs.RemoveAll(), Cron.Daily);
var manager = new RecurringJobManager();
manager.RemoveIfExists("500");
manager.AddOrUpdate("500", () => CrawlerJobs.GetDiscounts(), Cron.Daily);
manager.Trigger("500");
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseHangfireServer();
app.UseHangfireDashboard();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
var recurringJobs = new RecurringJobManager();
RecurringJob.AddOrUpdate <Tasks>(x => x.SuccessTask(null, null), Cron.Minutely);
// RecurringJob.AddOrUpdate<Tasks>(x => x.FailedTask(null, null), "*/2 * * * *");
recurringJobs.AddOrUpdate("Failed Task", Job.FromExpression <Tasks>(x => x.FailedTask(null)), "*/2 * * * *", TimeZoneInfo.Local);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseHangfireServer();
app.UseHangfireDashboard();
app.UseStaticFiles();
app.UseCookiePolicy();
app.UseRouting();
app.UseEndpoints(routes => routes.MapDefaultControllerRoute());
var recurringJobs = new RecurringJobManager();
RecurringJob.AddOrUpdate <Tasks>(x => x.SuccessTask(null, null), Cron.Minutely);
// RecurringJob.AddOrUpdate<Tasks>(x => x.FailedTask(null, null), "*/2 * * * *");
recurringJobs.AddOrUpdate("Failed Task", Job.FromExpression <Tasks>(x => x.FailedTask(null)), "*/2 * * * *", TimeZoneInfo.Local);
BackgroundJob.Enqueue <BaseJob>(x => x.Run());
BackgroundJob.Enqueue <DerivedJob>(x => x.Run());
}
protected async Task CreateBuildEngineReleaseAsync(Product product, string channel)
{
var release = new Release
{
Channel = channel
};
ClearRecurringJob(product.Id);
ReleaseResponse releaseResponse = null;
if (SetBuildEngineEndpoint(product.Project.Organization))
{
releaseResponse = BuildEngineApi.CreateRelease(product.WorkflowJobId,
product.WorkflowBuildId,
release);
}
if ((releaseResponse != null) && (releaseResponse.Id != 0))
{
product.WorkflowPublishId = releaseResponse.Id;
await ProductRepository.UpdateAsync(product);
var monitorJob = Job.FromExpression <BuildEngineReleaseService>(service => service.CheckRelease(product.Id));
RecurringJobManager.AddOrUpdate(GetHangfireToken(product.Id), monitorJob, "* * * * *");
}
else
{
// TODO: Send Notification
// Throw Exception to force retry
throw new Exception("Create release failed");
}
}
protected async Task CreateBuildEngineReleaseAsync(Product product, Dictionary <string, object> paramsDictionary, PerformContext context)
{
var channel = GetChannel(paramsDictionary);
var targets = GetTargets(paramsDictionary, "google-play");
var environment = GetEnvironment(paramsDictionary);
environment["PRODUCT_ID"] = product.Id.ToString();
environment["PROJECT_ID"] = product.ProjectId.ToString();
var release = new Release
{
Channel = channel,
Targets = targets,
Environment = environment
};
ClearRecurringJob(product.Id);
ReleaseResponse releaseResponse = null;
if (SetBuildEngineEndpoint(product.Project.Organization))
{
releaseResponse = BuildEngineApi.CreateRelease(product.WorkflowJobId,
product.WorkflowBuildId,
release);
}
if ((releaseResponse != null) && (releaseResponse.Id != 0))
{
product.WorkflowPublishId = releaseResponse.Id;
await ProductRepository.UpdateAsync(product);
var build = await BuildRepository.Get().Where(b => b.BuildId == product.WorkflowBuildId).FirstOrDefaultAsync();
if (build == null)
{
throw new Exception($"Failed to find ProductBuild: {product.WorkflowBuildId}");
}
var publish = new ProductPublication
{
ProductId = product.Id,
ProductBuildId = build.Id,
ReleaseId = releaseResponse.Id,
Channel = channel
};
await PublicationRepository.CreateAsync(publish);
var monitorJob = Job.FromExpression <BuildEngineReleaseService>(service => service.CheckRelease(product.Id));
RecurringJobManager.AddOrUpdate(GetHangfireToken(product.Id), monitorJob, "* * * * *");
}
else
{
var messageParms = new Dictionary <string, object>()
{
{ "projectName", product.Project.Name },
{ "productName", product.ProductDefinition.Name }
};
await SendNotificationOnFinalRetryAsync(context, product.Project.Organization, product.Project.Owner, "releaseFailedUnableToCreate", messageParms);
// Throw Exception to force retry
throw new Exception("Create release failed");
}
}
public ActionResult Index(SettingsModel model)
{
// Event
SysEvent ev = new SysEvent();
ev.Action = Action.Settings;
ev.Description = "Updated system settings";
if (ModelState.IsValid)
{
// Check for changed settings we need to reflect here and now.
SettingsModel settings = db.Settings.Single(x => x.Id == 1);
if (settings.PingInterval != model.PingInterval)
{
// Reset Hangfires recurring ping job.
var manager = new RecurringJobManager();
manager.AddOrUpdate("Enqueue", Job.FromExpression(() => Core.Jobs.Enqueue()), Cron.MinuteInterval(model.PingInterval));
}
// Save to database
db.Settings.AddOrUpdate(model);
db.SaveChanges();
ev.ActionStatus = ActionStatus.OK;
LogsController.AddEvent(ev, User.Identity.GetUserId());
return(RedirectToAction("Index", "Home"));
}
ev.ActionStatus = ActionStatus.Error;
LogsController.AddEvent(ev, User.Identity.GetUserId());
return(View(model));
}
private void ScheduleJob(JobConfigDetails job)
{
//LogManager.Log($"Starting job: {job.Id}");
if (string.IsNullOrEmpty(job.Cron) || string.IsNullOrEmpty(job.TypeName))
{
return;
}
try
{
var jobManager = new RecurringJobManager();
jobManager.RemoveIfExists(job.Id);
var type = Type.GetType(job.TypeName);
if (type != null && job.Enabled)
{
var jobSchedule = new Job(type, type.GetMethod("Start"));
jobManager.AddOrUpdate(job.Id, jobSchedule, job.Cron, TimeZoneInfo.Local);
//LogManager.Log($"Job {job.Id} has started");
}
else
{
//LogManager.Log($"Job {job.Id} of type {type} is not found or job is disabled");
}
}
catch (Exception ex)
{
//LogManager.Log($"Exception has been thrown when starting the job {ex.Message}", LogLevel.Critical);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IBackgroundJobClient backgroundJobs, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
/* app.ApplicationServices.UseSmartSqlSync();
* app.ApplicationServices.UseSmartSqlSubscriber((syncRequest) =>
* {
* Console.Error.WriteLine(syncRequest.Scope);
* });*/
app.UseMvc();
app.UseHangfireDashboard();
backgroundJobs.Enqueue(() => Console.WriteLine("Hello world from Hangfire!"));
var manager = new RecurringJobManager();
manager.AddOrUpdate("hello-world-id", () => Console.WriteLine("Hello World!"), Cron.Minutely());
app.UseHealthChecks("/healthz", new HealthCheckOptions
{
Predicate = _ => true,
ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
})
.UseHealthChecksUI();
app.UseSwagger(c => { });
app.UseSwaggerUI(c => { c.SwaggerEndpoint("/swagger/v1/swagger.json", "Zema.Sample.AspNetCore"); });
}
// Method creating the time-bound scheduler jobs
public static void SendEmailDaily()
{
GlobalConfiguration.Configuration
.SetDataCompatibilityLevel(CompatibilityLevel.Version_170)
.UseColouredConsoleLogProvider()
.UseSimpleAssemblyNameTypeSerializer()
.UseRecommendedSerializerSettings()
.UseSqlServerStorage("Server=(localdb)\\MSSQLLocalDB;Database=DBEmailScheduler;Trusted_Connection=True;", new SqlServerStorageOptions
{
CommandBatchMaxTimeout = TimeSpan.FromMinutes(5),
SlidingInvisibilityTimeout = TimeSpan.FromMinutes(5),
QueuePollInterval = TimeSpan.Zero,
UseRecommendedIsolationLevel = true,
UsePageLocksOnDequeue = true,
DisableGlobalLocks = true
});
int hourDiff = DateTimeOffset.Now.Offset.Hours;
int minDiff = DateTimeOffset.Now.Offset.Minutes;
var manager = new RecurringJobManager();
manager.AddOrUpdate("EmailSchedulerDaily", Job.FromExpression(() => EmailSchedulerDailyJob()), Cron.Daily(hourDiff, minDiff));
using (var server = new BackgroundJobServer())
{
Console.ReadLine();
}
}
public async Task <string> Start()
{
var contailers = await _container.GetContainerListAsync(Client);
var ids = contailers.Select(x => x.ID).ToArray();
lock ("1")
{
foreach (var id in ids)
{
// if (!StaticValue.SENTRY_THREAD.ContainsKey((SentryEnum.Log, id)))
// StaticValue.SENTRY_THREAD.TryAdd(
// (SentryEnum.Log, id),
// _sentry.StartLogs(Client, id, (_, __, ___) =>
// {
// })
// );
var job = Hangfire.Common.Job.FromExpression <ISentry>(x => x.StartStats(id));
var manager = new RecurringJobManager(JobStorage.Current);
manager.AddOrUpdate($"stats_{id}", job, Cron.Minutely(), TimeZoneInfo.Local);
}
_log.LogWarning("Sentry started");
return("Done");
}
}
public void MultipleServerRunsRecurrentJobs()
{
// ARRANGE
const int serverCount = 20;
const int workerCount = 20;
var options = new BackgroundJobServerOptions[serverCount];
var storage = ConnectionUtils.CreateStorage(new MongoStorageOptions());
var servers = new BackgroundJobServer[serverCount];
var jobManagers = new RecurringJobManager[serverCount];
for (int i = 0; i < serverCount; i++)
{
options[i] = new BackgroundJobServerOptions {
Queues = new[] { $"queue_options_{i}" }, WorkerCount = workerCount
};
servers[i] = new BackgroundJobServer(options[i], storage);
jobManagers[i] = new RecurringJobManager(storage);
}
try
{
// ACT
for (int i = 0; i < serverCount; i++)
{
var i1 = i;
var jobManager = jobManagers[i1];
for (int j = 0; j < workerCount; j++)
{
var j1 = j;
var queueIndex = j1 % options[i1].Queues.Length;
var queueName = options[i1].Queues[queueIndex];
var job = Job.FromExpression(() => Console.WriteLine("Setting signal for queue {0}",
queueName));
var jobId = $"job:[{i},{j}]";
jobManager.AddOrUpdate(jobId, job, Cron.Minutely(), new RecurringJobOptions
{
QueueName = queueName
});
jobManager.Trigger(jobId);
}
}
// let hangfire run for 1 sec
Task.Delay(1000).Wait();
}
finally
{
for (int i = 0; i < serverCount; i++)
{
servers[i].SendStop();
servers[i].Dispose();
}
}
}
public JsonResult AddJob1([FromServices] RecurringJobManager jobManager)
{
string id = Guid.NewGuid().ToString("N");
jobManager.AddOrUpdate(id, () => MyJob.即時任務(null), Cron.Minutely);
return(Json(new { success = true, id }));
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
var manager = new RecurringJobManager();
manager.AddOrUpdate("CheckProductsObsolete", Job.FromExpression(() => CheckProductsObsolete()), Cron.Daily());
}
public void JobUpdate(string recurringJobId, Hangfire.Common.Job job, string interval)
{
var manager = new RecurringJobManager();
//manager.RemoveIfExists("my-job-id");
manager.AddOrUpdate(recurringJobId, job, interval);
manager.Trigger(recurringJobId);
}
private static void CreateRecurringJobs(JobBuilderOptions builderOptions)
{
var jobManager = new RecurringJobManager(JobStorage.Current);
builderOptions.JsonFileLocations.Select(GetFileContents)
.SelectMany(JsonConvert.DeserializeObject <List <RecurringJobInfo> >)
.ToList()
.ForEach(x => AddOrUpdateRecurringJob(x, jobManager));
}
public static void SetupJobs()
{
var manager = new RecurringJobManager();
//manager.AddOrUpdate ("email_send", Job.FromExpression (() => EmailSend ()), Cron.Minutely ());
manager.AddOrUpdate("tabels_create", Job.FromExpression(() => TabelsCreate()), Cron.Daily(0, 5));
manager.AddOrUpdate("alert_users", Job.FromExpression(() => AlertUsers()), Cron.Monthly(20, 9));
manager.AddOrUpdate("alert_managers", Job.FromExpression(() => AlertManagers()), Cron.Monthly(25, 9));
}
private void OnStopped()
{
var manager = new RecurringJobManager(JobStorage.Current);
foreach (var item in StaticValue.CONTAINERS)
{
manager.RemoveIfExists($"stats_{item.ID}");
}
_logger.LogInformation("Sentry stoped");
}
public static void ConfigureBackgroundJobs(ISettingManager settingManager)
{
var recurringJobManager = new RecurringJobManager();
recurringJobManager.RemoveIfExists(BackgroundJobNames.Users);
recurringJobManager.RemoveIfExists(BackgroundJobNames.Veeam);
ConfigureUsers(recurringJobManager, settingManager);
ConfigureVeeam(recurringJobManager, settingManager);
}
public TenantedBackgroundJobClient(TraffkGlobalDbContext gdb, ITraffkTenantFinder finder, IJobInfoFinder jobInfoFinder = null, ICurrentUser currentUser = null)
{
Inner = new BackgroundJobClient();
GDB = gdb;
Finder = finder;
CurrentUser = currentUser;
RecurringJobManager = new RecurringJobManager();
TenantId = Finder.GetTenantIdAsync().ExecuteSynchronously();
JobInfoFinder = jobInfoFinder;
}
public void Attach(Container container)
{
GlobalConfiguration.Configuration.UseActivator(new Activator(container));
var jobManager = new RecurringJobManager();
jobManager.AddOrUpdate(
NotifyParserJob.JobId,
Job.FromExpression((NotifyParserJob job) => job.Execute()), Cron.Daily(20));
}
public void StopJobs()
{
using (var conn = JobStorage.Current.GetConnection())
{
var manager = new RecurringJobManager();
foreach (var job in conn.GetRecurringJobs())
{
manager.RemoveIfExists(job.Id);
//LogManager.Log($"Job has been stopped: {job.Id}", LogLevel.Information);
}
}
}
private static void AddRecurringJobs()
{
//LogProvider.SetCurrentLogProvider(new ColouredConsoleLogProvider());
//RecurringJob.AddOrUpdate("ev-min-recur", () => Console.WriteLine("Recurring Background Methods"), Cron.Minutely);
var jobManager = new RecurringJobManager(new SqlServerStorage("HangfireConnection"));
Action <HttpContext> expression = PerformJob;
var job = new Job(expression.Method, HttpContext.Current);
jobManager.AddOrUpdate("recurring-job-minute",
job,
Cron.Minutely());
jobManager.Trigger("recurring-job-minute");
}
public static void AddRecurringBatchCommand(
this RouteCollection routes,
string pathTemplate,
[NotNull] Action<RecurringJobManager, string> command)
{
if (command == null) throw new ArgumentNullException("command");
routes.AddBatchCommand(pathTemplate, (context, jobId) =>
{
var manager = new RecurringJobManager(context.JobStorage);
command(manager, jobId);
});
}
