/// <summary>
/// Creates a job runner with the specified job factory
/// </summary>
/// <param name="jobFactory">The job factory</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="jobFactory"/> is null</exception>
public DefaultJobRunner(IJobFactory jobFactory)
{
if (jobFactory == null)
throw new ArgumentNullException("jobFactory");
this.jobFactory = jobFactory;
}
public JobViewModel(IJobFactory jobFactory)
{
this.job = jobFactory.CreateJob();
this.ChooseOutputFolderCommand = new RelayCommand(this.ChooseOutputFolder);
this.SelectedJobItems = new ObservableCollection<IJobItem>();
}
public Service(Logger logger, ISchedulerFactory schedulerFactory, IJobFactory jobFactory, IJobActivator jobActivator, IEnumerable<IJobConfiguration> jobsConfig, WcfServiceHostFactory serviceHostFactory)
{
_logger = logger;
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
_jobActivator = jobActivator;
_jobsConfig = jobsConfig;
_serviceHostFactory = serviceHostFactory;
ServiceName = Program.ServiceName;
}
public QuartzNetScheduler(IDictionary<string, string> props, IJobFactory jobFactory)
{
foreach (var prop in props.Keys) {
properties[prop] = props[prop];
}
var sf = new StdSchedulerFactory(properties);
scheduler = sf.GetScheduler();
scheduler.JobFactory = jobFactory;
WaitForJobsToCompleteAtShutdown = true; // default
}
/// <summary>
/// Registers a job at runtime.
/// </summary>
/// <param name="jobFactory">the job to be registered</param>
/// <exception cref="DuplicateJobException">if a factory with the same job name has already been registered</exception>
public void Register(IJobFactory jobFactory)
{
Assert.NotNull(jobFactory);
string name = jobFactory.JobName;
Assert.NotNull(name, "Job configuration must have a name.");
IJobFactory value = _map.GetOrAdd(name, jobFactory);
if (value != jobFactory)
{
throw new DuplicateJobException("A job configuration with this name [" + name + "] was already registered");
}
}
public QuartzClockService(
ISchedulerFactory schedulerFactory,
IJobFactory jobFactory,
TimeTaskTriggerFactory taskTriggerFactory,
ILogger <QuartzClockService> logger)
{
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
_taskTriggerFactory = taskTriggerFactory;
_logger = logger;
LogProvider.SetCurrentLogProvider(new QuartzLogger(logger));
}
public SchedulerManager(ISchedulerFactory factory, IJobFactory jobFactory, ISettingsHelper settingsHelper, ICheckRepository checks,
ILogger <SchedulerManager> logger, ILoggerFactory loggerFactory, IJobHelper jobHelper)
{
_scheduler = factory.GetScheduler().Result;
_scheduler.JobFactory = jobFactory;
_scheduler.ListenerManager.AddJobListener(new GlobalJobListener(loggerFactory.CreateLogger <GlobalJobListener>()), GroupMatcher <JobKey> .AnyGroup());
_scheduler.ListenerManager.AddSchedulerListener(new GlobalSchedulerListener(loggerFactory.CreateLogger <GlobalSchedulerListener>(), this));
_settingsHelper = settingsHelper;
_checks = checks;
_logger = logger;
_jobHelper = jobHelper;
}
/// <summary>
/// 构造注入
/// </summary>
/// <param name="schedulerFactory"></param>
/// <param name="jobFactory"></param>
/// <param name="jobSchedules"></param>
/// <param name="logger"></param>
public QuartzHostedService(
ISchedulerFactory schedulerFactory,
IJobFactory jobFactory,
IEnumerable <JobSchedule> jobSchedules,
ILogger <QuartzHostedService> logger
)
{
_schedulerFactory = schedulerFactory;
_jobSchedules = jobSchedules;
_jobFactory = jobFactory;
_logger = logger;
}
/// <summary>
/// Constructs a Scheduler that uses Castle Windsor
/// </summary>
/// <param name="props">Properties</param>
/// <param name="jobFactory">JobFactory</param>
/// <param name="kernel">Castle MicroKernel</param>
public QuartzNetScheduler(IDictionary<string, string> props, IJobFactory jobFactory, IKernel kernel)
{
foreach (var prop in props.Keys)
{
_properties[prop] = props[prop];
}
var sf = new StdSchedulerFactory(_properties);
_scheduler = sf.GetScheduler();
_scheduler.JobFactory = jobFactory;
_scheduler.ListenerManager.AddJobListener(new ReleasingJobListener(kernel));
WaitForJobsToCompleteAtShutdown = true; // default
}
public TaskScheduleManager(IJobFactory jobFactory)
{
var props = new NameValueCollection
{
{ "quartz.serializer.type", "binary" }
};
var factory = new StdSchedulerFactory(props);
_scheduler = factory.GetScheduler().GetAwaiter().GetResult();
_scheduler.JobFactory = jobFactory;
_scheduler.ListenerManager.AddJobListener(new DefaultJobListener());
}
public ExecutorJob(IJobFactory jobFactory,
IHorariumLogger horariumLogger,
IJobRepository jobRepository,
IAdderJobs adderJobs,
JsonSerializerSettings jsonSerializerSettings)
{
_jobFactory = jobFactory;
_horariumLogger = horariumLogger;
_jobRepository = jobRepository;
_adderJobs = adderJobs;
_jsonSerializerSettings = jsonSerializerSettings;
}
/// <summary>
/// Registers a job at runtime.
/// </summary>
/// <param name="jobFactory">the job to be registered</param>
/// <exception cref="DuplicateJobException"> if a factory with the same job name has already been registered</exception>
public void Register(IJobFactory jobFactory)
{
Assert.NotNull(jobFactory);
string name = jobFactory.JobName;
Assert.NotNull(name, "Job configuration must have a name.");
IJobFactory value = _map.GetOrAdd(name, jobFactory);
if (value != jobFactory)
{
throw new DuplicateJobException("A job configuration with this name [" + name + "] was already registered");
}
}
public JobWorker(
ISchedulerFactory schedulerFactory,
IJobFactory jobFactory,
IFFmpegInitializer fFmpegInitializer,
IEnumerable <JobScheduleOptions> scheduleOptions,
IEnumerable <IJob> jobs)
{
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
_fFmpegInitializer = fFmpegInitializer;
_scheduleOptions = scheduleOptions;
_jobs = jobs;
}
public void InitiateScheduler(ILogger logger, IJobFactory jobFactory, CancellationToken ct)
{
try
{
// Once the scheduler is running, all actions will be initiated from the functions that listen to the service bus
logger.LogInformation("Started scheduler");
schedulingActions.StartScheduler(jobFactory, ct);
}
catch (Exception e)
{
logger.LogError(e, "Unable to start scheduler");
}
}
public CommandParser(
ISubject subject,
IEmployeeRepository employeeRepository,
IEmployeeFactory employeeFactory,
IJobFactory jobFactory,
IOutputWriter writer)
{
this.subject = subject;
this.employeeRepository = employeeRepository;
this.employeeFactory = employeeFactory;
this.jobFactory = jobFactory;
this.writer = writer;
}
public JobHandler(
ILogger logger,
IJobDequeuer jobDequeuer,
IJobRepository jobRepository,
IJobFactory jobFactory,
IJobUpdater jobUpdater)
{
_logger = logger.ForContext <JobHandler>();
_jobDequeuer = jobDequeuer;
_jobRepository = jobRepository;
_jobFactory = jobFactory;
_jobUpdater = jobUpdater;
}
public QuartzService(ISchedulerFactory schedulerFactory, ITaskRepository task, IJobFactory jobFactory,
ITaskLogRepository taskLogService, ILogRepository log, IJobManager jobManager, ITriggerManager triggerManager,
ILogger <QuartzService> logger)
{
_logger = logger;
_triggerManager = triggerManager;
_jobManager = jobManager;
_log = log;
_taskLog = taskLogService;
_jobFactory = jobFactory;
_task = task;
_schedulerFactory = schedulerFactory;
}
/// <summary>
/// Constructs a Scheduler that uses Castle Windsor
/// </summary>
/// <param name="props">Properties</param>
/// <param name="jobFactory">JobFactory</param>
/// <param name="kernel">Castle MicroKernel</param>
public QuartzNetScheduler(IDictionary <string, string> props, IJobFactory jobFactory, IKernel kernel)
{
foreach (var prop in props.Keys)
{
_properties[prop] = props[prop];
}
var sf = new StdSchedulerFactory(_properties);
_scheduler = sf.GetScheduler();
_scheduler.JobFactory = jobFactory;
_scheduler.ListenerManager.AddJobListener(new ReleasingJobListener(kernel));
WaitForJobsToCompleteAtShutdown = true; // default
}
/// <summary>
/// ctor
/// </summary>
/// <param name="schedulerFactory"></param>
/// <param name="jobFactory"></param>
/// <param name="repository"></param>
/// <param name="typeFinder"></param>
/// <param name="configuration"></param>
public NGPJobHostedService(
ISchedulerFactory schedulerFactory,
IJobFactory jobFactory,
IUnitRepository repository,
ITypeFinder typeFinder,
IConfiguration configuration)
{
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
_repository = repository;
_typeFinder = typeFinder;
_configuration = configuration;
}
/// <summary>Initializes a new instance of the <see cref="QuartzJobService"/> class.</summary>
/// <param name="schedulerFactory">The scheduler factory.</param>
/// <param name="jobFactory">The job factory.</param>
/// <param name="jobDetails">The job details.</param>
/// <exception cref="ArgumentNullException"><paramref name="schedulerFactory"/> is <see langword="null"/>
/// or
/// <paramref name="jobFactory"/> is <see langword="null"/>
/// or
/// <paramref name="jobDetails"/> is <see langword="null"/>.</exception>
public QuartzJobService(
ISchedulerFactory schedulerFactory,
IJobFactory jobFactory,
IEnumerable <IJob> jobDetails)
{
_schedulerFactory = schedulerFactory ?? throw new ArgumentNullException(nameof(schedulerFactory));
_jobFactory = jobFactory ?? throw new ArgumentNullException(nameof(jobFactory));
if (jobDetails == null)
{
throw new ArgumentNullException(nameof(jobDetails));
}
_triggersAndJobs = GetTriggersAndJobs(jobDetails);
}
public JobScheduler(
IScheduler scheduler,
IJobFactory jobFactory,
IDocumentSession session,
IEnumerable<IJobListener> jobListeners)
: this(scheduler, jobFactory, session)
{
if (jobListeners == null)
{
throw new ArgumentNullException("jobListeners");
}
this.jobListeners = jobListeners;
}
public SchedulerFactory(
IQuartzConfig config,
ILoggingSchedulerListener loggingSchedulerListener,
ILoggingJobListener loggingJobListener,
IJobFactory jobFactory,
IRetrySettings retrySettings
)
{
_retrySettings = retrySettings;
_config = config;
_loggingSchedulerListener = loggingSchedulerListener;
_loggingJobListener = loggingJobListener;
_jobFactory = jobFactory;
}
public PackageManagerProxy(IPackageManagerProvider packageManagerProvider,
IPackageManagerSettings packageManagerSettings,
IClientMessenger clientMessenger,
IJobQueue jobQueue,
IJobFactory jobFactory,
IPackageList packageList)
{
_packageManagerProvider = packageManagerProvider;
_packageManagerSettings = packageManagerSettings;
_clientMessenger = clientMessenger;
_jobQueue = jobQueue;
_jobFactory = jobFactory;
_packageList = packageList;
}
/// <summary>
/// Quartz.Net启动后注册job和trigger
/// </summary>
/// <param name="serviceProvider"></param>
/// <param name="loggerFactory"></param>
public QuartzService(IServiceProvider serviceProvider, ILoggerFactory loggerFactory)
{
this.CacheContainer = new ConcurrentDictionary <string, Func <Task> >();
_logger = loggerFactory.CreateLogger <QuartzService>();
jobfactory = new QuartzJobFactory(serviceProvider);
var schedulerFactory = new StdSchedulerFactory();
_scheduler = schedulerFactory.GetScheduler().Result;
_scheduler.JobFactory = jobfactory;
}
public PackageManagerProxy(IPackageManagerProvider packageManagerProvider,
IPackageManagerSettings packageManagerSettings,
IClientMessenger clientMessenger,
IJobQueue jobQueue,
IJobFactory jobFactory,
IPackageList packageList)
{
_packageManagerProvider = packageManagerProvider;
_packageManagerSettings = packageManagerSettings;
_clientMessenger = clientMessenger;
_jobQueue = jobQueue;
_jobFactory = jobFactory;
_packageList = packageList;
}
public QuartzHostedService(ISchedulerFactory schedulerFactory,
IJobFactory jobFactory,
IQuartzTriggerFactory quartzTriggerFactory,
Func <IBookService> bookService,
Func <IPickOfTheDayService> pickOfTheDayService,
Func <IPickOfTheWeekService> pickOfTheWeekService)
{
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
_triggerFactory = quartzTriggerFactory;
_bookService = bookService;
_pickOfTheDayService = pickOfTheDayService;
_pickOfTheWeekService = pickOfTheWeekService;
}
public MyService(IJobFactory jobFactory)
{
_jobFactory = jobFactory;
var props = new NameValueCollection
{
{ "quartz.serializer.type", "binary" },
{ "quartz.scheduler.instanceName", "MyScheduler" },
{ "quartz.jobStore.type", "Quartz.Simpl.RAMJobStore, Quartz" },
{ "quartz.threadPool.threadCount", "3" }
};
_factory = new StdSchedulerFactory(props);
}
public JobHandle(IJob job, IJobFactory factory)
{
this.Factory = factory;
this.Job = job;
this.State = JOB_HANDLE.RUN;
this.HandleJob = ThreadPool.RegisterWaitForSingleObject(
new AutoResetEvent(false),
new WaitOrTimerCallback((state, timeOut) => { this.Job.f_runLoop(this); }),
this,
JOB_CONST.JOB_TIMEOUT_RUN,
true); /* true: run once; false: repeate */
}
public CustomeSchedule(
ISchedulerFactory schedulerFactory,
IJobFactory jobFactory,
JobScheduleDTO jobScheduleDTO,
ILogger <CustomeSchedule> logger,
IServiceProvider provider
)
{
this.schedulerFactory = schedulerFactory;
this.jobFactory = jobFactory;
this.jobScheduleDTO = jobScheduleDTO;
this.logger = logger;
this._provider = provider;
}
public QuartzSchedulerJobService(
ILogService logService,
ISettingsService settingsService,
ISchedulerFactory schedulerFactory,
IJobFactory jobFactory,
IEnumerable <ISchedulerJobDefinition> jobDefinitions,
IJobEntitiesRepository jobEntitiesRepository)
: base(logService, settingsService)
{
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
_jobEntitiesRepository = jobEntitiesRepository;
_jobIndex = jobDefinitions.ToDictionary(definition => definition.Id);
}
/// <summary>
/// 构造函数
/// </summary>
public ExamJobService(
ISchedulerFactory schedulerFactory,
IJobFactory jobFactory,
IRepository <TbExamjobs> repository
)
{
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
_repository = repository;
if (App.ServiceProvider.GetService(typeof(IExamService)) is IExamService examService)
{
_examService = examService;
}
}
public void WrapsJobFactoryException()
{
JobExecutionContext context = new JobExecutionContext(
Mocks.CreateMock <IScheduler>(), Mocks.CreateMock <ILogger>(),
new JobSpec("job", "description", "key", Mocks.CreateMock <Trigger>()), null);
IJobFactory jobFactory = Mocks.CreateMock <IJobFactory>();
Expect.Call(jobFactory.GetJob("key")).Throw(new Exception("Ack!"));
Mocks.ReplayAll();
DefaultJobRunner jobRunner = new DefaultJobRunner(jobFactory);
jobRunner.BeginExecute(context, null, null);
}
public JobScheduler(
[NotNull] ILog log,
[NotNull] ITriggerBuilder triggerBuilder,
[NotNull] ISchedulerJobTypesLoader schedulerJobTypesLoader,
[NotNull] IJobFactory jobFactory,
[NotNull] IJobNameBuilder jobNameBuilder,
[NotNull] IUnityContainer unityContainer)
{
_schedulerJobTypesLoader = schedulerJobTypesLoader;
_jobFactory = jobFactory;
_jobNameBuilder = jobNameBuilder;
_unityContainer = unityContainer;
_triggerBuilder = triggerBuilder;
_log = log;
}
public ScheduleService(ILogger <ScheduleService> logger, IJobFactory jobFactory)
{
_logger = logger;
NameValueCollection props = new NameValueCollection
{
{ "quartz.serializer.type", "binary" },
{ "quartz.scheduler.instanceName", "MyScheduler" },
{ "quartz.jobStore.type", "Quartz.Simpl.RAMJobStore, Quartz" },
{ "quartz.threadPool.threadCount", "3" }
};
StdSchedulerFactory factory = new StdSchedulerFactory(props);
_scheduler = factory.GetScheduler().ConfigureAwait(false).GetAwaiter().GetResult();
_scheduler.JobFactory = jobFactory;
}
public FestiTimerContext(
DbContextOptions options,
IEmployerFactory employerFactory,
IPersonFactory personFactory,
IContractFactory contractFactory,
IWorkscheduleFactory workscheduleFactory,
IJobFactory jobFactory,
IWorkshiftFactory workshiftFactory) : base(options)
{
EmployerFactory = employerFactory;
PersonFactory = personFactory;
ContractFactory = contractFactory;
WorkscheduleFactory = workscheduleFactory;
JobFactory = jobFactory;
WorkshiftFactory = workshiftFactory;
Database.EnsureCreated();
}
public QuartzStartup(IServiceProvider IocContainer, ILoggerFactory loggerFactory, IConfiguration Configuration)
{
_logger = loggerFactory.CreateLogger <QuartzStartup>();
iocJobfactory = new NFineJobFactory(IocContainer);
#region 设置scheduler创建参数 /
var nameValueCollection = new NameValueCollection();
foreach (var config in Configuration.GetSection("QuartzNet").GetChildren())
{
nameValueCollection.Add(config.Key, config.Value);
}
#endregion
var schedulerFactory = new StdSchedulerFactory(nameValueCollection);
_scheduler = schedulerFactory.GetScheduler().GetAwaiter().GetResult();
_scheduler.JobFactory = iocJobfactory;
}
public SchedulingActions(ILogger <SchedulingActions> logger, IConfiguration configuration, IScheduledJobBuilder scheduledJobBuilder, IJobFactory jobFactory)
{
this.logger = logger;
this.scheduledJobBuilder = scheduledJobBuilder;
this.jobFactory = jobFactory;
var quartzSettingsDict = configuration.GetSection("Quartz")
.GetChildren()
.ToDictionary(x => x.Key, x => x.Value);
var quartzSettings = new NameValueCollection();
foreach (var key in quartzSettingsDict.Keys)
{
quartzSettings.Add(key, quartzSettingsDict[key]);
}
standardFactory = new StdSchedulerFactory(quartzSettings);
}
public Scheduler(
IJobFactory jobFactory,
ISchedulerFactory schedulerFactory,
ILogger <Scheduler> logger,
IExecutionHistoryManager historyManager,
ICubesEnvironment cubesEnvironment)
{
_schedulerFactory = schedulerFactory;
_jobFactory = jobFactory;
_logger = logger;
_historyManager = historyManager;
var configurationPath = cubesEnvironment
.GetFileOnPath(CubesFolderKind.Config, CubesConstants.Files_Scheduling);
_schedulerConfiguration = new ConfigurationBuilder()
.AddYamlFile(configurationPath, optional: true, reloadOnChange: true)
.Build();
}
public ServiceRunner(
IAdapterConfiguration adapterConfig,
IQueueConsumer<ValidateBatchCodelineRequest> validateCodelineRequestQueue,
IExchangePublisher<ValidateBatchCodelineResponse> validateCodelineExchange,
IQueueConsumer<CorrectBatchCodelineRequest> correctCodelineRequestQueue,
IExchangePublisher<CorrectBatchCodelineResponse> correctCodelineExchange,
IQueueConsumer<ValidateBatchTransactionRequest> validateTransactionRequestQueue,
IExchangePublisher<ValidateBatchTransactionResponse> validateTransactionExchange,
IQueueConsumer<CorrectBatchTransactionRequest> correctTransactionRequestQueue,
IExchangePublisher<CorrectBatchTransactionResponse> correctTransactionExchange,
IQueueConsumer<CheckThirdPartyBatchRequest> checkThirdPartyRequestQueue,
IExchangePublisher<CheckThirdPartyBatchResponse> checkThirdPartyExchange,
IQueueConsumer<GenerateCorrespondingVoucherRequest> generateCorrespondingVoucherRequestQueue,
IExchangePublisher<GenerateCorrespondingVoucherResponse> generateCorrespondingVoucherExchange,
IExchangePublisher<GetVouchersInformationRequest> getVoucherInformationRequestExchange,
IQueueConsumer<GetVouchersInformationResponse> getVoucherInformationResponseQueue,
IQueueConsumer<GenerateBatchBulkCreditRequest> generateBulkCreditRequestQueue,
IExchangePublisher<GenerateBatchBulkCreditResponse> generateBulkCreditResponseExchange,
IJobFactory jobFactory,
IScheduler scheduler,
IQuartzConfiguration quartzConfiguration)
{
this.adapterConfig = adapterConfig;
this.validateCodelineRequestQueue = validateCodelineRequestQueue;
this.validateCodelineExchange = validateCodelineExchange;
this.correctCodelineRequestQueue = correctCodelineRequestQueue;
this.correctCodelineExchange = correctCodelineExchange;
this.validateTransactionRequestQueue = validateTransactionRequestQueue;
this.validateTransactionExchange = validateTransactionExchange;
this.correctTransactionRequestQueue = correctTransactionRequestQueue;
this.correctTransactionExchange = correctTransactionExchange;
this.checkThirdPartyRequestQueue = checkThirdPartyRequestQueue;
this.checkThirdPartyExchange = checkThirdPartyExchange;
this.generateCorrespondingVoucherRequestQueue = generateCorrespondingVoucherRequestQueue;
this.generateCorrespondingVoucherExchange = generateCorrespondingVoucherExchange;
this.getVoucherInformationRequestExchange = getVoucherInformationRequestExchange;
this.getVoucherInformationResponseQueue = getVoucherInformationResponseQueue;
this.generateBulkCreditRequestQueue = generateBulkCreditRequestQueue;
this.generateBulkCreditResponseExchange = generateBulkCreditResponseExchange;
this.jobFactory = jobFactory;
this.scheduler = scheduler;
this.quartzConfiguration = quartzConfiguration;
}
public JobScheduler(IScheduler scheduler, IJobFactory jobFactory, IDocumentSession session)
{
if (scheduler == null)
{
throw new ArgumentNullException("scheduler");
}
if (jobFactory == null)
{
throw new ArgumentNullException("jobFactory");
}
if (session == null)
{
throw new ArgumentNullException("session");
}
this.scheduler = scheduler;
this.session = session;
this.scheduler.JobFactory = jobFactory;
}
public CronService(IJobFactory jobFactory, IScheduledScriptRepository scheduledScriptRepository)
{
_jobFactory = jobFactory;
_scheduledScriptRepository = scheduledScriptRepository;
}
public IocJobFactory(IServiceLocator serviceLocator, IJobFactory bottomFactory)
{
_serviceLocator = serviceLocator;
_bottomJobFactory = bottomFactory;
}
/// <summary>
/// Invoked by an <see cref="Spring.Objects.Factory.IObjectFactory"/>
/// after it has injected all of an object's dependencies.
/// </summary>
/// <remarks>
/// <p>
/// This method allows the object instance to perform the kind of
/// initialization only possible when all of it's dependencies have
/// been injected (set), and to throw an appropriate exception in the
/// event of misconfiguration.
/// </p>
/// <p>
/// Please do consult the class level documentation for the
/// <see cref="Spring.Objects.Factory.IObjectFactory"/> interface for a
/// description of exactly <i>when</i> this method is invoked. In
/// particular, it is worth noting that the
/// <see cref="Spring.Objects.Factory.IObjectFactoryAware"/>
/// and <see cref="Spring.Context.IApplicationContextAware"/>
/// callbacks will have been invoked <i>prior</i> to this method being
/// called.
/// </p>
/// </remarks>
/// <exception cref="System.Exception">
/// In the event of misconfiguration (such as the failure to set a
/// required property) or if initialization fails.
/// </exception>
public virtual void AfterPropertiesSet()
{
// Create SchedulerFactory instance.
#if QUARTZ_2_0
ISchedulerFactory schedulerFactory = ObjectUtils.InstantiateType<ISchedulerFactory>(schedulerFactoryType);
#else
ISchedulerFactory schedulerFactory = (ISchedulerFactory) ObjectUtils.InstantiateType(schedulerFactoryType);
#endif
InitSchedulerFactory(schedulerFactory);
if (taskExecutor != null)
{
// Make given TaskExecutor available for SchedulerFactory configuration.
configTimeTaskExecutor = taskExecutor;
}
if (dbProvider != null)
{
// Make given db provider available for SchedulerFactory configuration.
configTimeDbProvider = dbProvider;
}
try
{
// Get Scheduler instance from SchedulerFactory.
scheduler = CreateScheduler(schedulerFactory, schedulerName);
PopulateSchedulerContext();
if (!jobFactorySet && !(scheduler is RemoteScheduler))
{
// Use AdaptableJobFactory as default for a local Scheduler, unless when
// explicitly given a null value through the "jobFactory" object property.
jobFactory = new AdaptableJobFactory();
}
if (jobFactory != null)
{
if (jobFactory is ISchedulerContextAware)
{
((ISchedulerContextAware) jobFactory).SchedulerContext = scheduler.Context;
}
scheduler.JobFactory = jobFactory;
}
}
finally
{
if (taskExecutor != null)
{
configTimeTaskExecutor = null;
}
if (dbProvider != null)
{
configTimeDbProvider = null;
}
}
RegisterListeners();
RegisterJobsAndTriggers();
}
/// <summary>
/// Take the IJobFactory provided and unregister it with the IJobRegistry.
/// </summary>
/// <param name="jobFactory">an IJobFactory</param>
/// <param name="parms">not needed by this listener</param>
/// <exception cref="Exception"> if there is a problem</exception>
public void Unbind(IJobFactory jobFactory, IDictionary<string, object> parms)
{
_logger.Info("Unbinding JobFactory: {0}", jobFactory.JobName);
JobRegistry.Unregister(jobFactory.JobName);
}
public StructureMapSchedulerFactory(IJobFactory jobFactory) {
_jobFactory = jobFactory;
}
public QuartzInitializer(IJobFactory jobFactory)
{
_jobFactory = jobFactory;
}
