public static (BackgroundJobServer server, IRecurringJobManager recurringJobManager, IBackgroundJobClient backgroundJobClient) StartHangfireServer(
string tenantId,
string serverName,
string connectionString,
IApplicationLifetime applicationLifetime,
IJobFilterProvider jobFilters,
MultitenantContainer mtc,
IBackgroundJobFactory backgroundJobFactory,
IBackgroundJobPerformer backgroundJobPerformer,
IBackgroundJobStateChanger backgroundJobStateChanger,
IBackgroundProcess[] additionalProcesses
)
{
var tenantJobActivator = new AspNetCoreMultiTenantJobActivator(mtc, tenantId);
return(HangfireHelper.StartHangfireServer(
serverName,
connectionString,
applicationLifetime,
jobFilters,
tenantJobActivator,
backgroundJobFactory,
backgroundJobPerformer,
backgroundJobStateChanger,
additionalProcesses));
}
/// <summary>
/// Initializes a new instance of the <see cref="RecurringJobScheduler"/> class
/// with custom background job factory, state machine and clocks.
/// </summary>
/// <param name="factory">Factory that will be used to create background jobs.</param>
/// <param name="pollingDelay">Delay before another polling attempt, when no jobs scheduled yet.</param>
/// <param name="timeZoneResolver">Function that returns a time zone object by its identifier.</param>
/// <exception cref="ArgumentNullException"><paramref name="factory"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="timeZoneResolver"/> is null.</exception>
public RecurringJobScheduler(
[NotNull] IBackgroundJobFactory factory,
TimeSpan pollingDelay,
[NotNull] ITimeZoneResolver timeZoneResolver)
: this(factory, pollingDelay, timeZoneResolver, () => DateTime.UtcNow)
{
}
public AppTenantsInitializer(
AppTenantsContext context,
IConfiguration configuration,
IHostingEnvironment environment,
IApplicationLifetime applicationLifetime,
IJobFilterProvider jobFilters,
MultitenantContainer multiTenantContainer,
IBackgroundJobFactory backgroundJobFactory,
IBackgroundJobPerformer backgroundJobPerformer,
IBackgroundJobStateChanger backgroundJobStateChanger,
IBackgroundProcess[] additionalProcesses,
ITenantConfiguration[] tenantConfigurations)
{
_context = context;
_configuration = configuration;
_environment = environment;
_applicationLifetime = applicationLifetime;
_jobFilters = jobFilters;
_multiTenantContainer = multiTenantContainer;
_backgroundJobFactory = backgroundJobFactory;
_backgroundJobPerformer = backgroundJobPerformer;
_backgroundJobStateChanger = backgroundJobStateChanger;
_additionalProcesses = additionalProcesses;
_tenantConfigurations = tenantConfigurations;
}
public static (BackgroundJobServer server, IRecurringJobManager recurringJobManager, IBackgroundJobClient backgroundJobClient) StartHangfireServer(
string serverName,
string connectionString,
IApplicationLifetime applicationLifetime,
IJobFilterProvider jobFilters,
JobActivator jobActivator,
IBackgroundJobFactory backgroundJobFactory,
IBackgroundJobPerformer backgroundJobPerformer,
IBackgroundJobStateChanger backgroundJobStateChanger,
IBackgroundProcess[] additionalProcesses
)
{
var options = new BackgroundJobServerOptions
{
ServerName = serverName,
Queues = new string[] { serverName, "default" }
};
return(StartHangfireServer(
options,
connectionString,
applicationLifetime,
jobFilters,
jobActivator,
backgroundJobFactory,
backgroundJobPerformer,
backgroundJobStateChanger,
additionalProcesses
));
}
public RecurringJobScheduler(
[NotNull] IBackgroundJobFactory factory,
TimeSpan pollingDelay,
[NotNull] ITimeZoneResolver timeZoneResolver,
[NotNull] Func <DateTime> nowFactory)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (nowFactory == null)
{
throw new ArgumentNullException(nameof(nowFactory));
}
if (timeZoneResolver == null)
{
throw new ArgumentNullException(nameof(timeZoneResolver));
}
_factory = factory;
_nowFactory = nowFactory;
_timeZoneResolver = timeZoneResolver;
_pollingDelay = pollingDelay;
_profiler = new SlowLogProfiler(_logger);
}
public RecurringJobManager([NotNull] JobStorage storage, [NotNull] IBackgroundJobFactory factory)
{
if (storage == null) throw new ArgumentNullException("storage");
if (factory == null) throw new ArgumentNullException("factory");
_storage = storage;
_factory = factory;
}
public BackgroundJobClientWithContext(
[NotNull] JobStorage storage,
[NotNull] IBackgroundJobFactory factory,
[NotNull] IBackgroundJobStateChanger stateChanger)
{
_storage = storage ?? throw new ArgumentNullException(nameof(storage));
_stateChanger = stateChanger ?? throw new ArgumentNullException(nameof(stateChanger));
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
}
internal BackgroundJobFactory(
[NotNull] IJobFilterProvider filterProvider,
[NotNull] IBackgroundJobFactory innerFactory)
{
if (filterProvider == null) throw new ArgumentNullException(nameof(filterProvider));
if (innerFactory == null) throw new ArgumentNullException(nameof(innerFactory));
_filterProvider = filterProvider;
_innerFactory = innerFactory;
}
internal RecurringDateRangeJobScheduler(
[NotNull] IBackgroundJobFactory factory,
[NotNull] Func <CrontabSchedule, TimeZoneInfo, IScheduleInstant> instantFactory,
[NotNull] IThrottler throttler,
bool ignoreTimeComponentInStartEndDates = false)
{
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
_instantFactory = instantFactory ?? throw new ArgumentNullException(nameof(instantFactory));
_throttler = throttler ?? throw new ArgumentNullException(nameof(throttler));
_ignoreTimeComponentInStartEndDates = ignoreTimeComponentInStartEndDates;
}
internal RecurringJobManager(
[NotNull] JobStorage storage,
[NotNull] IBackgroundJobFactory factory,
[NotNull] ITimeZoneResolver timeZoneResolver,
[NotNull] Func <DateTime> nowFactory)
{
_storage = storage ?? throw new ArgumentNullException(nameof(storage));
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
_timeZoneResolver = timeZoneResolver ?? throw new ArgumentNullException(nameof(timeZoneResolver));
_nowFactory = nowFactory ?? throw new ArgumentNullException(nameof(nowFactory));
}
public BackgroundJobManager(IBackgroundJobFactory jobFactory)
{
this._jobFactory = jobFactory;
this._jobStore = new ConcurrentDictionary <string, JobInfo>();
this._tokenSource = new CancellationTokenSource();
this._token = this._tokenSource.Token;
ThreadPool.QueueUserWorkItem(JobStoreCleanup, this, false);
}
public BackgroundJobServer(
[NotNull] BackgroundJobServerOptions options,
[NotNull] JobStorage storage,
[NotNull] IEnumerable <IBackgroundProcess> additionalProcesses,
[CanBeNull] IJobFilterProvider filterProvider,
[CanBeNull] JobActivator activator,
[CanBeNull] IBackgroundJobFactory factory,
[CanBeNull] IBackgroundJobPerformer performer,
[CanBeNull] IBackgroundJobStateChanger stateChanger)
{
if (storage == null)
{
throw new ArgumentNullException(nameof(storage));
}
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (additionalProcesses == null)
{
throw new ArgumentNullException(nameof(additionalProcesses));
}
_options = options;
var processes = new List <IBackgroundProcessDispatcherBuilder>();
processes.AddRange(GetRequiredProcesses(filterProvider, activator, factory, performer, stateChanger));
processes.AddRange(additionalProcesses.Select(x => x.UseBackgroundPool(1)));
var properties = new Dictionary <string, object>
{
{ "Queues", options.Queues },
{ "WorkerCount", options.WorkerCount }
};
_logger.Info($"Starting Hangfire Server using job storage: '{storage}'");
storage.WriteOptionsToLog(_logger);
_logger.Info("Using the following options for Hangfire Server:\r\n" +
$" Worker count: {options.WorkerCount}\r\n" +
$" Listening queues: {String.Join(", ", options.Queues.Select(x => "'" + x + "'"))}\r\n" +
$" Shutdown timeout: {options.ShutdownTimeout}\r\n" +
$" Schedule polling interval: {options.SchedulePollingInterval}");
_processingServer = new BackgroundProcessingServer(
storage,
processes,
properties,
GetProcessingServerOptions());
}
public RecurringJobManager([NotNull] JobStorage storage, [NotNull] IBackgroundJobFactory factory)
{
if (storage == null)
{
throw new ArgumentNullException("storage");
}
if (factory == null)
{
throw new ArgumentNullException("factory");
}
_storage = storage;
_factory = factory;
}
internal BackgroundJobFactory(
[NotNull] IJobFilterProvider filterProvider,
[NotNull] IBackgroundJobFactory innerFactory)
{
if (filterProvider == null)
{
throw new ArgumentNullException(nameof(filterProvider));
}
if (innerFactory == null)
{
throw new ArgumentNullException(nameof(innerFactory));
}
_filterProvider = filterProvider;
_innerFactory = innerFactory;
}
public BackgroundJobServerHostedService(
[NotNull] JobStorage storage,
[NotNull] BackgroundJobServerOptions options,
[NotNull] IEnumerable <IBackgroundProcess> additionalProcesses,
[CanBeNull] IBackgroundJobFactory factory,
[CanBeNull] IBackgroundJobPerformer performer,
[CanBeNull] IBackgroundJobStateChanger stateChanger)
{
_options = options ?? throw new ArgumentNullException(nameof(options));
_storage = storage ?? throw new ArgumentNullException(nameof(storage));
_additionalProcesses = additionalProcesses;
_factory = factory;
_performer = performer;
_stateChanger = stateChanger;
}
public static (BackgroundJobServer server, IRecurringJobManager recurringJobManager, IBackgroundJobClient backgroundJobClient) StartHangfireServer(
BackgroundJobServerOptions options,
string connectionString,
IApplicationLifetime applicationLifetime,
IJobFilterProvider jobFilters,
JobActivator jobActivator,
IBackgroundJobFactory backgroundJobFactory,
IBackgroundJobPerformer backgroundJobPerformer,
IBackgroundJobStateChanger backgroundJobStateChanger,
IBackgroundProcess[] additionalProcesses
)
{
JobStorage storage;
if (string.IsNullOrWhiteSpace(connectionString))
{
storage = new MemoryStorage();
}
else if (ConnectionStringHelper.IsSQLite(connectionString))
{
storage = new SQLiteStorage(connectionString);
}
else
{
storage = new SqlServerStorage(connectionString);
}
var server = new BackgroundJobServer(options, storage, additionalProcesses,
options.FilterProvider ?? jobFilters,
options.Activator ?? jobActivator,
backgroundJobFactory,
backgroundJobPerformer,
backgroundJobStateChanger);
applicationLifetime.ApplicationStopping.Register(() => server.SendStop());
applicationLifetime.ApplicationStopped.Register(() => server.Dispose());
var recurringJobManager = new RecurringJobManager(storage, backgroundJobFactory);
var backgroundJobClient = new BackgroundJobClient(storage, backgroundJobFactory, backgroundJobStateChanger);
return(server, recurringJobManager, backgroundJobClient);
}
private IEnumerable <IBackgroundProcessDispatcherBuilder> GetRequiredProcesses(
[CanBeNull] IJobFilterProvider filterProvider,
[CanBeNull] JobActivator activator,
[CanBeNull] IBackgroundJobFactory factory,
[CanBeNull] IBackgroundJobPerformer performer,
[CanBeNull] IBackgroundJobStateChanger stateChanger)
{
var processes = new List <IBackgroundProcessDispatcherBuilder>();
var timeZoneResolver = _options.TimeZoneResolver ?? new DefaultTimeZoneResolver();
if (factory == null && performer == null && stateChanger == null)
{
filterProvider = filterProvider ?? _options.FilterProvider ?? JobFilterProviders.Providers;
activator = activator ?? _options.Activator ?? JobActivator.Current;
factory = new BackgroundJobFactory(filterProvider);
performer = new BackgroundJobPerformer(filterProvider, activator, _options.TaskScheduler);
stateChanger = new BackgroundJobStateChanger(filterProvider);
}
else
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (performer == null)
{
throw new ArgumentNullException(nameof(performer));
}
if (stateChanger == null)
{
throw new ArgumentNullException(nameof(stateChanger));
}
}
processes.Add(new Worker(_options.Queues, performer, stateChanger).UseBackgroundPool(_options.WorkerCount));
processes.Add(new DelayedJobScheduler(_options.SchedulePollingInterval, stateChanger).UseBackgroundPool(1));
processes.Add(new RecurringJobScheduler(factory, _options.SchedulePollingInterval, timeZoneResolver).UseBackgroundPool(1));
return(processes);
}
public static BackgroundJob TriggerRecurringJob(
[NotNull] this IBackgroundJobFactory factory,
[NotNull] JobStorage storage,
[NotNull] IStorageConnection connection,
[NotNull] IProfiler profiler,
[NotNull] RecurringJobEntity recurringJob,
DateTime now)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (storage == null)
{
throw new ArgumentNullException(nameof(storage));
}
if (connection == null)
{
throw new ArgumentNullException(nameof(connection));
}
if (profiler == null)
{
throw new ArgumentNullException(nameof(profiler));
}
if (recurringJob == null)
{
throw new ArgumentNullException(nameof(recurringJob));
}
var context = new CreateContext(storage, connection, recurringJob.Job, null, profiler);
context.Parameters["RecurringJobId"] = recurringJob.RecurringJobId;
context.Parameters["Time"] = JobHelper.ToTimestamp(now);
var backgroundJob = factory.Create(context);
recurringJob.LastExecution = now;
recurringJob.LastJobId = backgroundJob?.Id;
return(backgroundJob);
}
internal static bool GetInternalServices(
IServiceProvider provider,
out IBackgroundJobFactory factory,
out IBackgroundJobStateChanger stateChanger,
out IBackgroundJobPerformer performer)
{
factory = provider.GetService <IBackgroundJobFactory>();
performer = provider.GetService <IBackgroundJobPerformer>();
stateChanger = provider.GetService <IBackgroundJobStateChanger>();
if (factory != null && performer != null && stateChanger != null)
{
return(true);
}
factory = null;
performer = null;
stateChanger = null;
return(false);
}
public SpecifyQueueBackgroundJobClient(
[NotNull] JobStorage storage,
[NotNull] IBackgroundJobFactory factory,
[NotNull] IBackgroundJobStateChanger stateChanger)
{
if (storage == null)
{
throw new ArgumentNullException(nameof(storage));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (stateChanger == null)
{
throw new ArgumentNullException(nameof(stateChanger));
}
_storage = storage;
_stateChanger = stateChanger;
_factory = factory;
}
/// <summary>
/// Initializes a new instance of the <see cref="BackgroundJobClient"/> class
/// with the specified storage, background job factory and state changer.
/// </summary>
///
/// <param name="storage">Job storage to use for background jobs.</param>
/// <param name="factory">Factory to create background jobs.</param>
/// <param name="stateChanger">State changer to change states of background jobs.</param>
///
/// <exception cref="ArgumentNullException"><paramref name="storage"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="factory"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="stateChanger"/> is null.</exception>
public BackgroundJobClient(
[NotNull] JobStorage storage,
[NotNull] IBackgroundJobFactory factory,
[NotNull] IBackgroundJobStateChanger stateChanger)
{
if (storage == null)
{
throw new ArgumentNullException("storage");
}
if (factory == null)
{
throw new ArgumentNullException("factory");
}
if (stateChanger == null)
{
throw new ArgumentNullException("stateChanger");
}
_storage = storage;
_stateChanger = stateChanger;
_factory = factory;
}
internal RecurringJobScheduler(
[NotNull] IBackgroundJobFactory factory,
[NotNull] Func <CrontabSchedule, TimeZoneInfo, IScheduleInstant> instantFactory,
[NotNull] IThrottler throttler)
{
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (instantFactory == null)
{
throw new ArgumentNullException(nameof(instantFactory));
}
if (throttler == null)
{
throw new ArgumentNullException(nameof(throttler));
}
_factory = factory;
_instantFactory = instantFactory;
_throttler = throttler;
}
private IEnumerable <IBackgroundProcess> GetRequiredProcesses(
[NotNull] IJobFilterProvider filterProvider,
[NotNull] JobActivator activator,
[CanBeNull] IBackgroundJobFactory factory,
[CanBeNull] IBackgroundJobPerformer performer,
[CanBeNull] IBackgroundJobStateChanger stateChanger)
{
var processes = new List <IBackgroundProcess>();
factory = factory ?? new BackgroundJobFactory(filterProvider);
performer = performer ?? new BackgroundJobPerformer(filterProvider, activator);
stateChanger = stateChanger ?? new BackgroundJobStateChanger(filterProvider);
for (var i = 0; i < _options.WorkerCount; i++)
{
processes.Add(new Worker(_options.Queues, performer, stateChanger));
}
processes.Add(new DelayedJobScheduler(_options.SchedulePollingInterval, stateChanger));
processes.Add(new RecurringJobScheduler(factory));
return(processes);
}
public HangfireServer(
BackgroundJobServerOptions options,
JobStorage jobStorage,
IEnumerable <IBackgroundProcess> backgroundProcesses,
IBackgroundJobFactory jobFactory,
IBackgroundJobPerformer jobPerformer,
IBackgroundJobStateChanger jobStateChanger,
ILogger <HangfireServer> logger,
IJobFilterProvider jobFilterProvider = default,
JobActivator activator = default
)
{
_options = options;
_jobStorage = jobStorage;
_backgroundProcesses = backgroundProcesses;
_jobFactory = jobFactory;
_jobPerformer = jobPerformer;
_jobStateChanger = jobStateChanger;
_jobFilterProvider = options.FilterProvider ?? jobFilterProvider;
_activator = options.Activator ?? activator;
_logger = logger;
}
/// <summary>
/// Initializes a new instance of the <see cref="RecurringJobScheduler"/>
/// class with custom background job factory and a state machine.
/// </summary>
/// <param name="factory">Factory that will be used to create background jobs.</param>
///
/// <exception cref="ArgumentNullException"><paramref name="factory"/> is null.</exception>
public RecurringJobScheduler(
[NotNull] IBackgroundJobFactory factory)
: this(factory, TimeSpan.Zero)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RecurringJobScheduler"/>
/// class with custom background job factory.
/// </summary>
/// <param name="factory">Factory that will be used to create background jobs.</param>
///
/// <exception cref="ArgumentNullException"><paramref name="factory"/> is null.</exception>
public RecurringJobScheduler([NotNull] IBackgroundJobFactory factory)
: this(factory, new string[] { EnqueuedState.DefaultQueue })
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RecurringJobScheduler"/> class
/// with custom background job factory, state machine and clocks.
/// </summary>
/// <param name="factory">Factory that will be used to create background jobs.</param>
/// <param name="pollingDelay">Delay before another polling attempt, when no jobs scheduled yet.</param>
/// <exception cref="ArgumentNullException"><paramref name="factory"/> is null.</exception>
public RecurringJobScheduler(
[NotNull] IBackgroundJobFactory factory,
TimeSpan pollingDelay)
: this(factory, pollingDelay, new DefaultTimeZoneResolver())
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BackgroundJobClient"/> class
/// with the specified storage, background job factory and state changer.
/// </summary>
///
/// <param name="storage">Job storage to use for background jobs.</param>
/// <param name="factory">Factory to create background jobs.</param>
/// <param name="stateChanger">State changer to change states of background jobs.</param>
///
/// <exception cref="ArgumentNullException"><paramref name="storage"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="factory"/> is null.</exception>
/// <exception cref="ArgumentNullException"><paramref name="stateChanger"/> is null.</exception>
public BackgroundJobClient(
[NotNull] JobStorage storage,
[NotNull] IBackgroundJobFactory factory,
[NotNull] IBackgroundJobStateChanger stateChanger)
{
if (storage == null) throw new ArgumentNullException("storage");
if (factory == null) throw new ArgumentNullException("factory");
if (stateChanger == null) throw new ArgumentNullException("stateChanger");
_storage = storage;
_stateChanger = stateChanger;
_factory = factory;
}
internal RecurringJobScheduler(
[NotNull] IBackgroundJobFactory factory,
[NotNull] Func<CrontabSchedule, TimeZoneInfo, IScheduleInstant> instantFactory,
[NotNull] IThrottler throttler)
{
if (factory == null) throw new ArgumentNullException("factory");
if (instantFactory == null) throw new ArgumentNullException("instantFactory");
if (throttler == null) throw new ArgumentNullException("throttler");
_factory = factory;
_instantFactory = instantFactory;
_throttler = throttler;
}
public RecurringJobManager([NotNull] JobStorage storage, [NotNull] IBackgroundJobFactory factory)
: this(storage, factory, new DefaultTimeZoneResolver())
{
}
public CustomBackgroundJobFactory([NotNull] IBackgroundJobFactory inner)
{
_inner = inner ?? throw new ArgumentNullException(nameof(inner));
}
public RecurringJobManager([NotNull] JobStorage storage, [NotNull] IBackgroundJobFactory factory, [NotNull] ITimeZoneResolver timeZoneResolver)
: this(storage, factory, timeZoneResolver, () => DateTime.UtcNow)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RecurringDateRangeJobScheduler"/>
/// class with custom background job factory.
/// </summary>
/// <param name="factory">Factory that will be used to create background jobs.</param>
///
/// <exception cref="ArgumentNullException"><paramref name="factory"/> is null.</exception>
public RecurringDateRangeJobScheduler([NotNull] IBackgroundJobFactory factory, bool ignoreTimeComponentInStartEndDates = false)
: this(factory, ScheduleInstant.Factory, new EveryMinuteThrottler(), ignoreTimeComponentInStartEndDates)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="RecurringJobScheduler"/>
/// class with custom background job factory.
/// </summary>
/// <param name="factory">Factory that will be used to create background jobs.</param>
///
/// <exception cref="ArgumentNullException"><paramref name="factory"/> is null.</exception>
public RecurringJobScheduler([NotNull] IBackgroundJobFactory factory)
: this(factory, ScheduleInstant.Factory, new EveryMinuteThrottler())
{
}
