private IEnumerable <IBackgroundProcess> GetRequiredProcesses()
{
var processes = new List <IBackgroundProcess>();
var filterProvider = _options.FilterProvider ?? JobFilterProviders.Providers;
var factory = new BackgroundJobFactory(filterProvider);
var performer = new BackgroundJobPerformer(filterProvider, _options.Activator ?? JobActivator.Current);
var 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);
}
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);
}
private IEnumerable <IBackgroundProcessDispatcherBuilder> GetRequiredProcesses()
{
var processes = new List <IBackgroundProcessDispatcherBuilder>();
var timeZoneResolver = _options.TimeZoneResolver ?? new DefaultTimeZoneResolver();
var filterProvider = _options.FilterProvider ?? JobFilterProviders.Providers;
var activator = _options.Activator ?? JobActivator.Current;
var factory = new BackgroundJobFactory(filterProvider);
var performer = new BackgroundJobPerformer(filterProvider, activator, _options.TaskScheduler);
var stateChanger = new BackgroundJobStateChanger(filterProvider);
var gate = new Gate(1, _options.WorkerCount);
processes.Add(new GateTuner(gate, _options.Queues, TimeSpan.FromSeconds(5)).UseBackgroundPool(1));
processes.Add(new GateWorker(gate, 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 (BackgroundJobServer server, IRecurringJobManager recurringJobManager, IBackgroundJobClient backgroundJobClient) StartHangfireServer(BackgroundJobServerOptions options, string connectionString)
{
JobStorage storage;
if (string.IsNullOrWhiteSpace(connectionString))
{
storage = new MemoryStorage();
}
else if (ConnectionStringHelper.IsSQLite(connectionString))
{
storage = new SQLiteStorage(connectionString);
}
else
{
storage = new SqlServerStorage(connectionString);
}
var filterProvider = JobFilterProviders.Providers;
var activator = JobActivator.Current;
var backgroundJobFactory = new BackgroundJobFactory(filterProvider);
var performer = new BackgroundJobPerformer(filterProvider, activator);
var backgroundJobStateChanger = new BackgroundJobStateChanger(filterProvider);
IEnumerable <IBackgroundProcess> additionalProcesses = null;
var server = new BackgroundJobServer(options, storage, additionalProcesses,
options.FilterProvider ?? filterProvider,
options.Activator ?? activator,
backgroundJobFactory,
performer,
backgroundJobStateChanger);
var recurringJobManager = new RecurringJobManager(storage, backgroundJobFactory);
var backgroundJobClient = new BackgroundJobClient(storage, backgroundJobFactory, backgroundJobStateChanger);
return(server, recurringJobManager, backgroundJobClient);
}
SetupHangfire(
Action <ContainerBuilder> configureContainer = null,
Action <Mock <Crawler>, Mock <IGrainFactory> > configureCrawlerMock = null,
Action <Mock <ICrawlerStrategy> > configureStrategyMock = null)
{
var jobStorage = new MemoryStorage(
new MemoryStorageOptions
{
FetchNextJobTimeout = TimeSpan.FromMilliseconds(200)
});
var containerBuilder = new ContainerBuilder();
var stateChanger = new BackgroundJobStateChanger(JobFilterProviders.Providers);
var jobFactory = new BackgroundJobFactory(JobFilterProviders.Providers);
var jobClient = new BackgroundJobClient(
jobStorage,
jobFactory,
stateChanger);
var strategy = new Mock <ICrawlerStrategy>();
if (configureStrategyMock != null)
{
configureStrategyMock(strategy);
}
else
{
strategy.Setup(s => s.ProcessRequestAsync(
It.IsAny <CrawlRequestBase>(),
It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
}
var strategyFactory = new Mock <ICrawlerStrategyFactory>();
strategyFactory.Setup(f => f.Create(
It.IsAny <CrawlRequestBase>()))
.Returns(() => strategy.Object);
var grainFactoryMock = new Mock <IGrainFactory>();
grainFactoryMock.Setup(gf => gf.GetGrain <IProcessCrawlRequests>(
It.IsAny <string>(),
It.IsAny <string>()))
.Returns <string, string>((grainId, _) => createCrawler(grainId));
Crawler createCrawler(string id)
{
var logger = Mock.Of <ILogger <Crawler> >();
var crawlerMock = new Mock <Crawler>(
MockBehavior.Loose,
jobClient,
logger,
new Lazy <ICrawlerStrategyFactory>(strategyFactory.Object));
if (configureCrawlerMock != null)
{
configureCrawlerMock(crawlerMock, grainFactoryMock);
}
else
{
crawlerMock.Setup(c => c.PersistState(It.IsAny <CrawlStateSnapshot>()))
.Returns(Task.CompletedTask);
crawlerMock.Setup(c => c.GrainFactory)
.Returns(() => grainFactoryMock.Object);
crawlerMock.Setup(c => c.GrainFactory.GetGrain <IProcessCrawlRequests>(
It.IsAny <string>(),
It.IsAny <string>()))
.Returns <string, string>((grainId, _) => createCrawler(grainId));
crawlerMock.Setup(c => c.Process(It.IsAny <CrawlRequestBase>()))
.CallBase();
}
return(crawlerMock.Object);
}
if (configureContainer != null)
{
configureContainer(containerBuilder);
}
else
{
containerBuilder.RegisterType <CrawlJobPerformer>()
.InstancePerBackgroundJob();
containerBuilder.Register(ctx => grainFactoryMock.Object)
.As <IGrainFactory>();
}
var container = containerBuilder.Build();
var activator = new AutofacJobActivator(container);
var jobPerformer = new BackgroundJobPerformer(JobFilterProviders.Providers, activator);
Func <Job, CreateContext> createContext = (Job job) =>
new CreateContext(
jobStorage,
jobStorage.GetConnection(),
job,
new EnqueuedState());
Func <Job, BackgroundJob> createBackgroundJob = (Job job) =>
jobFactory.Create(createContext(job));
return(
() => new BackgroundJobServer(
new BackgroundJobServerOptions
{
Activator = activator,
WorkerCount = Environment.ProcessorCount
},
jobStorage,
Enumerable.Empty <IBackgroundProcess>(),
JobFilterProviders.Providers,
activator,
jobFactory,
jobPerformer,
stateChanger),
createCrawler,
grainFactoryMock.Object,
strategy,
jobClient,
jobFactory,
jobPerformer,
activator,
(Job job) => createBackgroundJob(job),
(Job job) => createContext(job),
(BackgroundJob job) =>
{
var token = new JobCancellationToken(false);
var result = jobPerformer.Perform(
new PerformContext(
jobStorage.GetConnection(),
job,
token));
return (result, token);
});
}
