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 Worker(
[NotNull] IEnumerable<string> queues,
[NotNull] IBackgroundJobPerformer performer,
[NotNull] IBackgroundJobStateChanger stateChanger)
{
if (queues == null) throw new ArgumentNullException("queues");
if (performer == null) throw new ArgumentNullException("performer");
if (stateChanger == null) throw new ArgumentNullException("stateChanger");
_queues = queues.ToArray();
_performer = performer;
_stateChanger = stateChanger;
_workerId = Guid.NewGuid().ToString();
}
public ContinuationsSupportAttribute(
[NotNull] HashSet<string> knownFinalStates,
[NotNull] IBackgroundJobStateChanger stateChanger)
{
if (knownFinalStates == null) throw new ArgumentNullException("knownFinalStates");
if (stateChanger == null) throw new ArgumentNullException("stateChanger");
_knownFinalStates = knownFinalStates;
_stateChanger = stateChanger;
// Ensure this filter is the last filter in the chain to start
// continuations on the last candidate state only.
Order = 1000;
}
/// <summary>
/// Initializes a new instance of the <see cref="DelayedJobScheduler"/>
/// class with a specified polling interval and given state changer.
/// </summary>
/// <param name="pollingDelay">Delay between scheduler runs.</param>
/// <param name="stateChanger">State changer to use for background jobs.</param>
/// <param name="queues">The queues that the scheduler will create jobs for.</param>
/// <exception cref="ArgumentNullException"><paramref name="stateChanger"/> is null.</exception>
public DelayedJobScheduler(TimeSpan pollingDelay, [NotNull] IBackgroundJobStateChanger stateChanger, params string[] queues)
{
if (stateChanger == null)
{
throw new ArgumentNullException(nameof(stateChanger));
}
if (queues == null)
{
throw new ArgumentNullException(nameof(queues));
}
_stateChanger = stateChanger;
_queues = queues;
_pollingDelay = pollingDelay;
}
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);
}
public ContinuationsSupportAttribute(
[NotNull] HashSet <string> knownFinalStates,
[NotNull] IBackgroundJobStateChanger stateChanger)
{
if (knownFinalStates == null)
{
throw new ArgumentNullException(nameof(knownFinalStates));
}
if (stateChanger == null)
{
throw new ArgumentNullException(nameof(stateChanger));
}
_knownFinalStates = knownFinalStates;
_stateChanger = stateChanger;
// Ensure this filter is the last filter in the chain to start
// continuations on the last candidate state only.
Order = 1000;
}
public WorkerTask(string[] queues, IAsyncBackgroundJobPerformer performer, IBackgroundJobStateChanger stateChanger)
{
if (queues == null || queues.Length == 0)
{
throw new ArgumentNullException(nameof(queues));
}
if (performer == null)
{
throw new ArgumentNullException(nameof(performer));
}
if (stateChanger == null)
{
throw new ArgumentNullException(nameof(stateChanger));
}
_queues = queues;
_performer = performer;
_stateChanger = stateChanger;
_workerId = Guid.NewGuid().ToString();
}
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);
}
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;
}
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;
}
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 Worker(
[NotNull] IEnumerable <string> queues,
[NotNull] IBackgroundJobPerformer performer,
[NotNull] IBackgroundJobStateChanger stateChanger)
{
if (queues == null)
{
throw new ArgumentNullException(nameof(queues));
}
if (performer == null)
{
throw new ArgumentNullException(nameof(performer));
}
if (stateChanger == null)
{
throw new ArgumentNullException(nameof(stateChanger));
}
_queues = queues.ToArray();
_performer = performer;
_stateChanger = stateChanger;
_workerId = Guid.NewGuid().ToString();
}
public AtomRunningStateElectionFilter(IBackgroundJobStateChanger stateChanger)
{
_stateChanger = stateChanger ?? throw new ArgumentNullException(nameof(stateChanger));
Order = 900;
}
public SubAtomStateElectionFilter(HashSet <string> knownFinalStates, IBackgroundJobStateChanger stateChanger)
{
_knownFinalStates = knownFinalStates ?? throw new ArgumentNullException(nameof(knownFinalStates));
_stateChanger = stateChanger ?? throw new ArgumentNullException(nameof(stateChanger));
Order = 800;
}
/// <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;
}
/// <summary>
/// Initializes a new instance of the <see cref="DelayedJobScheduler"/>
/// class with a specified polling interval and given state changer.
/// </summary>
/// <param name="pollingDelay">Delay between scheduler runs.</param>
/// <param name="stateChanger">State changer to use for background jobs.</param>
/// <param name="schedulerEvent">Event to awake scheuler</param>
///
/// <exception cref="ArgumentNullException"><paramref name="stateChanger"/> is null.</exception>
public DelayedJobScheduler(TimeSpan pollingDelay, AutoResetEvent schedulerEvent, [NotNull] IBackgroundJobStateChanger stateChanger)
{
if (stateChanger == null)
{
throw new ArgumentNullException(nameof(stateChanger));
}
_stateChanger = stateChanger;
_pollingDelay = pollingDelay;
_schedulerEvent = schedulerEvent;
}
public ApplicationInsightsBackgroundJobStateChanger([NotNull] IBackgroundJobStateChanger inner)
{
_inner = inner ?? throw new ArgumentNullException(nameof(inner));
}
public CustomBackgroundJobStateChanger([NotNull] IBackgroundJobStateChanger inner)
{
_inner = inner ?? throw new ArgumentNullException(nameof(inner));
}
public ContinuationsSupportAttribute(
[NotNull] HashSet <string> knownFinalStates,
[NotNull] IBackgroundJobStateChanger stateChanger)
: this(false, knownFinalStates, stateChanger)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="DelayedJobScheduler"/>
/// class with a specified polling interval and given state changer.
/// </summary>
/// <param name="pollingDelay">Delay between scheduler runs.</param>
/// <param name="stateChanger">State changer to use for background jobs.</param>
///
/// <exception cref="ArgumentNullException"><paramref name="stateChanger"/> is null.</exception>
public DelayedJobScheduler(TimeSpan pollingDelay, [NotNull] IBackgroundJobStateChanger stateChanger)
{
if (stateChanger == null) throw new ArgumentNullException("stateChanger");
_stateChanger = stateChanger;
_pollingDelay = pollingDelay;
}
/// <summary>
/// Initializes a new instance of the <see cref="DelayedJobScheduler"/>
/// class with a specified polling interval and given state changer.
/// </summary>
/// <param name="pollingDelay">Delay between scheduler runs.</param>
/// <param name="stateChanger">State changer to use for background jobs.</param>
/// <exception cref="ArgumentNullException"><paramref name="stateChanger"/> is null.</exception>
public DelayedJobScheduler(TimeSpan pollingDelay, [NotNull] IBackgroundJobStateChanger stateChanger)
: this(pollingDelay, stateChanger, EnqueuedState.DefaultQueue)
{
}
