public AeTitleJobProcessor(
ClaraApplicationEntity configuration,
IInstanceStoredNotificationService instanceStoredNotificationService,
ILoggerFactory loggerFactory,
IJobs jobsApi,
IJobStore jobStore,
IInstanceCleanupQueue cleanupQueue,
IDicomToolkit dicomToolkit,
CancellationToken cancellationToken) : base(instanceStoredNotificationService, loggerFactory, jobsApi, jobStore, cleanupQueue, cancellationToken)
{
if (loggerFactory is null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_dicomToolkit = dicomToolkit ?? throw new ArgumentNullException(nameof(dicomToolkit));
_instances = new Dictionary <string, InstanceCollection>();
_pipelines = new Dictionary <string, string>();
_logger = loggerFactory.CreateLogger <AeTitleJobProcessor>();
_timer = new System.Timers.Timer(1000);
_timer.AutoReset = false;
_timer.Elapsed += OnTimedEvent;
_timer.Enabled = true;
_jobs = new BlockingCollection <InstanceCollection>();
InitializeSettings();
_jobProcessingTask = ProcessJobs();
}
public JobSpeechEN(IJobStore _store)
{
this.StoreJob = _store;
this.queue = new QueueThreadSafe <string>();
this.storeUrl = new DictionaryThreadSafe <string, string>();
this.storePath = new DictionaryThreadSafe <string, string>();
}
public ExaminationController(ExaminationPlanManager examManager, CandidateManager candidateManager, IRecruitmentPlanStore recruitmentPlanStore, IJobStore jobStore)
{
this.examManager = examManager;
this.candidateManager = candidateManager;
this.recruitmentPlanStore = recruitmentPlanStore;
this.jobStore = jobStore;
}
public JobLink(IJobStore _store)
{
this.StoreJob = _store;
list = new ListThreadSafe <oLink>();
msg = new QueueThreadSafe <Message>();
urlData = new DictionaryThreadSafe <string, string>();
}
public override void SetUp()
{
base.SetUp();
mockJobStore = Mocks.CreateMock<IJobStore>();
mockJobRunner = Mocks.CreateMock<IJobRunner>();
mockLogger = Mocks.CreateMock<ILogger>();
mockTrigger = Mocks.PartialMock<Trigger>();
scheduler = new DefaultScheduler(mockJobStore, mockJobRunner);
dummyJobData = new JobData();
dummyJobSpec = new JobSpec("foo", "bar", "key", mockTrigger);
dummyJobDetails = new JobDetails(dummyJobSpec, DateTime.UtcNow);
isWoken = false;
// Ensure the scheduler is initialized.
mockJobStore.RegisterScheduler(scheduler.Guid, scheduler.Name);
Mocks.Replay(mockJobStore);
scheduler.Initialize();
Mocks.Verify(mockJobStore);
Mocks.BackToRecord(mockJobStore);
mockJobStore.UnregisterScheduler(scheduler.Guid);
// Create a separate uninitialized scheduler for certain tests.
uninitializedScheduler = new DefaultScheduler(mockJobStore, mockJobRunner);
}
public RecruitmentController(RecruitmentPlanManager recruitmentPlanManager, ApplicationFormManager enrollmentManager, ApplicationUserManager userManager, IJobStore jobStore)
{
this.recruitmentManager = recruitmentPlanManager;
this.applicationFormManager = enrollmentManager;
this.targetUserManager = userManager;
this.jobStore = jobStore;
}
private static TimeSpan ComputeDelayForRepeatedErrors(IJobStore jobStore, int acquiresFailed)
{
var delay = TimeSpan.FromMilliseconds(100);
try
{
// TODO v4, use interface
if (jobStore is JobStoreSupport jobStoreSupport)
{
delay = jobStoreSupport.GetAcquireRetryDelay(acquiresFailed);
}
else if (jobStore is RAMJobStore ramJobStore)
{
delay = ramJobStore.GetAcquireRetryDelay(acquiresFailed);
}
}
catch
{
// we're trying to be useful in case of error states, not cause
// additional errors..
}
// sanity check per getAcquireRetryDelay specification
if (delay < minDelay)
{
delay = minDelay;
}
if (delay > maxDelay)
{
delay = maxDelay;
}
return(delay);
}
public JobDispatcher(IJobStore jobStore)
{
if (jobStore == null)
throw new ArgumentNullException(nameof(jobStore));
this.jobStore = jobStore;
this.webClient = new HttpWebClient();
}
public QuartzNetHostedService(QuartzNetConfig config, IScheduler scheduler, IJobStore jobStore, ISchedulerManager schedulerManager)
{
_config = config;
_scheduler = scheduler;
_jobStore = jobStore;
_schedulerManager = schedulerManager;
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it for remote access.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="schedulerPluginMap"></param>
/// <param name="idleWaitTime">The idle wait time. You can specify TimeSpan.Zero for
/// the default value, which is currently 30000 ms.</param>
public virtual void CreateScheduler(string schedulerName, string schedulerInstanceId, IThreadPool threadPool,
IJobStore jobStore, IDictionary <string, ISchedulerPlugin> schedulerPluginMap, TimeSpan idleWaitTime)
{
CreateScheduler(
schedulerName, schedulerInstanceId, threadPool, DefaultThreadExecutor,
jobStore, schedulerPluginMap, idleWaitTime);
}
public SchedulerManager(QuartzNetConfig config, IScheduler scheduler, IJobStore jobStore, IServiceRoute serviceRoute)
{
_config = config;
_scheduler = scheduler;
_jobStore = jobStore;
_serviceRoute = serviceRoute;
}
public override void SetUp()
{
base.SetUp();
mockJobStore = Mocks.CreateMock <IJobStore>();
mockJobRunner = Mocks.CreateMock <IJobRunner>();
mockLogger = Mocks.CreateMock <ILogger>();
mockTrigger = Mocks.PartialMock <Trigger>();
scheduler = new DefaultScheduler(mockJobStore, mockJobRunner);
dummyJobData = new JobData();
dummyJobSpec = new JobSpec("foo", "bar", "key", mockTrigger);
dummyJobDetails = new JobDetails(dummyJobSpec, DateTime.UtcNow);
isWoken = false;
// Ensure the scheduler is initialized.
mockJobStore.RegisterScheduler(scheduler.Guid, scheduler.Name);
Mocks.Replay(mockJobStore);
scheduler.Initialize();
Mocks.Verify(mockJobStore);
Mocks.BackToRecord(mockJobStore);
mockJobStore.UnregisterScheduler(scheduler.Guid);
// Create a separate uninitialized scheduler for certain tests.
uninitializedScheduler = new DefaultScheduler(mockJobStore, mockJobRunner);
}
public SignalRProgressLog(JobInfo jobInfo, IJobStore jobRepository, HubConnection hubConnection)
{
_jobInfo = jobInfo;
_jobRepository = jobRepository;
_hubConnection = hubConnection;
_log = Log.ForContext("JobId", jobInfo.JobId);
_fullLog = new StringBuilder();
}
public static IJob Create(this IJobStore jobStore, string url, DateTime scheduledOn, string method = null)
{
if (jobStore == null)
{
throw new ArgumentNullException(nameof(jobStore));
}
return(jobStore.Queue(new JobDetails(url, scheduledOn, method)));
}
private void Initialize(IJobStore jobStore, ISettingsProvider settingsProvider, ILoggingProvider loggingProvider)
{
this.jobStore = jobStore;
this.logger = loggingProvider;
this.settings = settingsProvider;
this.jobStore.JobActionRequired += new EventHandler <JobActionRequiredEventArgs>(jobStore_JobActionRequired);
this.jobStore.JobDeleted += new EventHandler <JobActionRequiredEventArgs>(jobStore_JobDeleted);
}
public JobController(ILogger <JobController> logger, IJobStore jobStore, ISchedulerRemoting schedulerRemoting, ILoadBalancerFactory loadBalancerFactory)
{
_logger = logger;
_jobStore = jobStore;
_schedulerRemoting = schedulerRemoting;
_loadBalancerFactory = loadBalancerFactory;
}
public JobDispatcher(IJobStore jobStore)
{
if (jobStore == null)
{
throw new ArgumentNullException(nameof(jobStore));
}
this.jobStore = jobStore;
this.webClient = new HttpWebClient();
}
public JobProgressUpdaterFactory(
IJobStore jobStore,
ILoggerFactory loggerFactory)
{
EnsureArg.IsNotNull(jobStore, nameof(jobStore));
_jobStore = jobStore;
_loggerFactory = loggerFactory;
}
public DefaultClusterStateMonitor(
ISchedulerMetadataStore <TSchedulerKey> schedulerMetadataStore,
IJobStore <TJobKey, TSchedulerKey> jobStore,
ILogger <DefaultClusterStateMonitor <TSchedulerKey, TJobKey> > logger)
{
this.schedulerMetadataStore = schedulerMetadataStore;
this.jobStore = jobStore;
this.logger = logger;
}
public DefaultJobProcessor(
ISingleJobProcessor <TSchedulerKey, TJobKey> singleJobProcessor,
IJobStore <TJobKey, TSchedulerKey> jobStore,
ILogger <DefaultJobProcessor <TSchedulerKey, TJobKey> > logger)
{
this.singleJobProcessor = singleJobProcessor;
this.jobStore = jobStore;
this.logger = logger;
}
protected void SetUp()
{
fJobStore = new RAMJobStore();
fSignaler = new SampleSignaler();
fJobStore.Initialize(null, fSignaler);
fJobDetail = new JobDetail("job1", "jobGroup1", typeof(NoOpJob));
fJobDetail.Durable = true;
fJobStore.StoreJob(null, fJobDetail, false);
}
public void SetUp()
{
fJobStore = new RAMJobStore();
fSignaler = new SampleSignaler();
fJobStore.Initialize(null, fSignaler);
fJobDetail = new JobDetailImpl("job1", "jobGroup1", typeof (NoOpJob));
fJobDetail.Durable = true;
fJobStore.StoreJob(fJobDetail, false);
}
public DataController(IUserStore userStore,
IJobStore jobStore,
IImportFormParser parser,
IImportService importService)
{
_userStore = userStore;
_jobStore = jobStore;
_parser = parser;
_importService = importService;
}
public fChromium(IJobStore store) : base(store)
{
this.Text = "English";
this.OnReceiveMessage += f_event_OnReceiveMessage;
this.Shown += f_form_Shown;
this.FormClosing += f_form_Closing;
f_brow_Init();
f_tab_Init();
}
public MockJobProcessor(
ClaraApplicationEntity configuration,
IInstanceStoredNotificationService instanceStoredNotificationService,
ILoggerFactory loggerFactory,
IJobs jobsApi,
IJobStore jobStore,
IInstanceCleanupQueue cleanupQueue,
CancellationToken cancellationToken) : base(instanceStoredNotificationService, loggerFactory, jobsApi, jobStore, cleanupQueue, cancellationToken)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
}
public DefaultSingleJobProcessor(
IJobStore <TJobKey, TSchedulerKey> jobStore,
ISyncHelper syncHelper,
IJobFactory jobFactory,
ILogger <DefaultSingleJobProcessor <TSchedulerKey, TJobKey> > logger)
{
this.jobStore = jobStore;
this.syncHelper = syncHelper;
this.jobFactory = jobFactory;
this.logger = logger;
}
public void SetUp()
{
fJobStore = new RAMJobStore();
fSignaler = new SampleSignaler();
fJobStore.Initialize(null, fSignaler);
fJobStore.SchedulerStarted();
fJobDetail = new JobDetailImpl("job1", "jobGroup1", typeof(NoOpJob));
fJobDetail.Durable = true;
fJobStore.StoreJob(fJobDetail, false);
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it for remote access.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="schedulerPluginMap"></param>
/// <param name="idleWaitTime">The idle wait time. You can specify TimeSpan.Zero for
/// the default value, which is currently 30000 ms.</param>
/// <param name="maxBatchSize">The maximum batch size of triggers, when acquiring them</param>
/// <param name="batchTimeWindow">The time window for which it is allowed to "pre-acquire" triggers to fire</param>
public virtual void CreateScheduler(
string schedulerName,
string schedulerInstanceId,
IThreadPool threadPool,
IJobStore jobStore,
IDictionary <string, ISchedulerPlugin> schedulerPluginMap,
TimeSpan idleWaitTime,
int maxBatchSize,
TimeSpan batchTimeWindow)
{
CreateScheduler(schedulerName, schedulerInstanceId, threadPool, jobStore, schedulerPluginMap, idleWaitTime, maxBatchSize, batchTimeWindow, null);
}
private void InitJobStore()
{
fJobStore = new RavenJobStore();
fJobStore.ClearAllSchedulingData();
fSignaler = new SampleSignaler();
fJobStore.Initialize(null, fSignaler);
fJobStore.SchedulerStarted();
fJobDetail = new JobDetailImpl("job1", "jobGroup1", typeof(NoOpJob));
fJobDetail.Durable = true;
fJobStore.StoreJob(fJobDetail, true);
}
public AccountController(IUserStore userStore,
IOwnerSettingsStore ownerSettingsStore,
IRepoSettingsStore repoSettingsStore,
IDatasetStore datasetStore,
IJobStore jobStore,
ISchemaStore schemaStore)
{
_userStore = userStore;
_ownerSettingsStore = ownerSettingsStore;
_repoSettingsStore = repoSettingsStore;
_datasetStore = datasetStore;
_jobStore = jobStore;
_schemaStore = schemaStore;
}
public static void Initialize(TestContext context)
{
originalHeartbeat = BlueCollarSection.Current.Heartbeat;
originalRetryTimeout = BlueCollarSection.Current.RetryTimeout;
BlueCollarSection.Current.Heartbeat = Heartbeat;
BlueCollarSection.Current.RetryTimeout = RetryTimeout;
jobStore = JobStore.Create();
jobStore.DeleteAllJobs();
jobRunner = new JobRunner(jobStore, Guid.NewGuid().ToString() + ".bin", false, Heartbeat, MaximumConcurrency, RetryTimeout, true, new JobScheduleElement[0]);
jobRunner.Error += new EventHandler<JobErrorEventArgs>(JobRunnerError);
jobRunner.Start();
}
public JobSubmissionService(
IInstanceCleanupQueue cleanupQueue,
ILogger <JobSubmissionService> logger,
IJobs jobsApi,
IPayloads payloadsApi,
IJobStore jobStore,
IFileSystem fileSystem)
{
_cleanupQueue = cleanupQueue ?? throw new ArgumentNullException(nameof(cleanupQueue));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_jobsApi = jobsApi ?? throw new ArgumentNullException(nameof(jobsApi));
_payloadsApi = payloadsApi ?? throw new ArgumentNullException(nameof(payloadsApi));
_jobStore = jobStore ?? throw new ArgumentNullException(nameof(jobStore));
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
}
public DataRetrievalService(
IDicomWebClientFactory dicomWebClientFactory,
ILogger <DataRetrievalService> logger,
IInferenceRequestStore inferenceRequestStore,
IFileSystem fileSystem,
IDicomToolkit dicomToolkit,
IJobStore jobStore)
{
_dicomWebClientFactory = dicomWebClientFactory ?? throw new ArgumentNullException(nameof(dicomWebClientFactory));
_inferenceRequestStore = inferenceRequestStore ?? throw new ArgumentNullException(nameof(inferenceRequestStore));
_fileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
_dicomToolkit = dicomToolkit ?? throw new ArgumentNullException(nameof(dicomToolkit));
_jobStore = jobStore ?? throw new ArgumentNullException(nameof(jobStore));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public JobProgressUpdater(
IJobStore jobStore,
Job job,
ILogger <JobProgressUpdater> logger)
{
_jobStore = EnsureArg.IsNotNull(jobStore, nameof(jobStore));
_job = EnsureArg.IsNotNull(job, nameof(job));
_logger = EnsureArg.IsNotNull(logger, nameof(logger));
var channelOptions = new UnboundedChannelOptions
{
SingleReader = true,
SingleWriter = false,
};
_progressChannel = Channel.CreateUnbounded <TaskContext>(channelOptions);
}
/// <summary>
/// Creates a scheduler with a default name.
/// </summary>
/// <param name="jobStore">The job store</param>
/// <param name="jobRunner">The job runner</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="jobStore"/> or
/// <paramref name="jobRunner"/> is null</exception>
public DefaultScheduler(IJobStore jobStore, IJobRunner jobRunner)
{
if (jobStore == null)
throw new ArgumentNullException("jobStore");
if (jobRunner == null)
throw new ArgumentNullException("jobRunner");
this.jobStore = jobStore;
this.jobRunner = jobRunner;
logger = NullLogger.Instance;
errorRecoveryDelayInSeconds = DefaultErrorRecoveryDelayInSeconds;
guid = Guid.NewGuid();
name = GetDefaultName();
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it for remote access.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="schedulerPluginMap"></param>
/// <param name="idleWaitTime">The idle wait time. You can specify TimeSpan.Zero for
/// the default value, which is currently 30000 ms.</param>
/// <param name="maxBatchSize">The maximum batch size of triggers, when acquiring them</param>
/// <param name="batchTimeWindow">The time window for which it is allowed to "pre-acquire" triggers to fire</param>
public virtual void CreateScheduler(
string schedulerName,
string schedulerInstanceId,
IThreadPool threadPool,
IJobStore jobStore,
IDictionary<string, ISchedulerPlugin> schedulerPluginMap,
TimeSpan idleWaitTime,
int maxBatchSize,
TimeSpan batchTimeWindow)
{
CreateScheduler(schedulerName, schedulerInstanceId, threadPool, jobStore, schedulerPluginMap, idleWaitTime, maxBatchSize, batchTimeWindow, null);
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it for remote access.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="threadExecutor">Thread executor.</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="schedulerPluginMap"></param>
/// <param name="idleWaitTime">The idle wait time. You can specify TimeSpan.Zero for
/// the default value, which is currently 30000 ms.</param>
/// <param name="dbFailureRetryInterval">The db failure retry interval.</param>
/// <param name="maxBatchSize">The maximum batch size of triggers, when acquiring them</param>
/// <param name="batchTimeWindow">The time window for which it is allowed to "pre-acquire" triggers to fire</param>
public virtual void CreateScheduler(string schedulerName, string schedulerInstanceId, IThreadPool threadPool, IThreadExecutor threadExecutor,
IJobStore jobStore, IDictionary<string, ISchedulerPlugin> schedulerPluginMap, TimeSpan idleWaitTime,
TimeSpan dbFailureRetryInterval, int maxBatchSize, TimeSpan batchTimeWindow)
{
// Currently only one run-shell factory is available...
IJobRunShellFactory jrsf = new StdJobRunShellFactory();
// Fire everything u
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
threadPool.Initialize();
QuartzSchedulerResources qrs = new QuartzSchedulerResources();
qrs.Name = schedulerName;
qrs.InstanceId = schedulerInstanceId;
SchedulerDetailsSetter.SetDetails(threadPool, schedulerName, schedulerInstanceId);
qrs.JobRunShellFactory = jrsf;
qrs.ThreadPool = threadPool;
qrs.ThreadExecutor= threadExecutor;
qrs.JobStore = jobStore;
qrs.MaxBatchSize = maxBatchSize;
qrs.BatchTimeWindow = batchTimeWindow;
// add plugins
if (schedulerPluginMap != null)
{
foreach (ISchedulerPlugin plugin in schedulerPluginMap.Values)
{
qrs.AddSchedulerPlugin(plugin);
}
}
QuartzScheduler qs = new QuartzScheduler(qrs, idleWaitTime, dbFailureRetryInterval);
ITypeLoadHelper cch = new SimpleTypeLoadHelper();
cch.Initialize();
SchedulerDetailsSetter.SetDetails(jobStore, schedulerName, schedulerInstanceId);
jobStore.Initialize(cch, qs.SchedulerSignaler);
IScheduler scheduler = new StdScheduler(qs);
jrsf.Initialize(scheduler);
qs.Initialize();
// Initialize plugins now that we have a Scheduler instance.
if (schedulerPluginMap != null)
{
foreach (var pluginEntry in schedulerPluginMap)
{
pluginEntry.Value.Initialize(pluginEntry.Key, scheduler);
}
}
Log.Info(string.Format(CultureInfo.InvariantCulture, "Quartz scheduler '{0}", scheduler.SchedulerName));
Log.Info(string.Format(CultureInfo.InvariantCulture, "Quartz scheduler version: {0}", qs.Version));
SchedulerRepository schedRep = SchedulerRepository.Instance;
qs.AddNoGCObject(schedRep); // prevents the repository from being
// garbage collected
schedRep.Bind(scheduler);
initialized = true;
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it for remote access.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="threadExecutor">Thread executor.</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="schedulerPluginMap"></param>
/// <param name="idleWaitTime">The idle wait time. You can specify TimeSpan.Zero for
/// the default value, which is currently 30000 ms.</param>
/// <param name="dbFailureRetryInterval">The db failure retry interval.</param>
public virtual void CreateScheduler(string schedulerName, string schedulerInstanceId, IThreadPool threadPool, IThreadExecutor threadExecutor,
IJobStore jobStore, IDictionary<string, ISchedulerPlugin> schedulerPluginMap, TimeSpan idleWaitTime,
TimeSpan dbFailureRetryInterval)
{
CreateScheduler(schedulerName, schedulerInstanceId, threadPool, threadExecutor, jobStore, schedulerPluginMap, idleWaitTime, dbFailureRetryInterval, DefaultBatchMaxSize, DefaultBatchTimeWindow);
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it for remote access.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="idleWaitTime">The idle wait time. You can specify "-1" for
/// the default value, which is currently 30000 ms.</param>
/// <param name="dbFailureRetryInterval">The db failure retry interval.</param>
public virtual void CreateScheduler(string schedulerName, string schedulerInstanceId, IThreadPool threadPool,
IJobStore jobStore, TimeSpan idleWaitTime,
TimeSpan dbFailureRetryInterval)
{
CreateScheduler(schedulerName, schedulerInstanceId, threadPool, jobStore, null, idleWaitTime, dbFailureRetryInterval);
}
/// <summary>
/// Same as DirectSchedulerFactory#createScheduler(ThreadPool threadPool, JobStore jobStore),
/// with the addition of specifying the scheduler name and instance ID. This
/// scheduler can only be retrieved via DirectSchedulerFactory#getScheduler(String)
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="jobStore">The type of job store</param>
public virtual void CreateScheduler(string schedulerName, string schedulerInstanceId, IThreadPool threadPool,
IJobStore jobStore)
{
CreateScheduler(schedulerName, schedulerInstanceId, threadPool, jobStore, TimeSpan.Zero, TimeSpan.Zero);
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store. This
/// scheduler can be retrieved via DirectSchedulerFactory#GetScheduler()
/// </summary>
/// <param name="threadPool">
/// The thread pool for executing jobs
/// </param>
/// <param name="jobStore">
/// The type of job store
/// </param>
/// <throws> SchedulerException </throws>
/// <summary> if initialization failed
/// </summary>
public virtual void CreateScheduler(IThreadPool threadPool, IJobStore jobStore)
{
CreateScheduler(DefaultSchedulerName, DefaultInstanceId, threadPool, jobStore);
initialized = true;
}
/// <summary>
/// Enqueues the job for execution using the given <see cref="IJobStore"/>.
/// </summary>
/// <param name="store">The job store to use when queueing the job.</param>
/// <returns>The job record that was persisted.</returns>
public virtual JobRecord Enqueue(IJobStore store)
{
if (store == null)
{
throw new ArgumentNullException("store", "store cannot be null.");
}
JobRecord record = this.CreateRecord();
store.SaveJob(record);
return record;
}
/// <summary>
/// Initializes a new instance of the JobRunner class.
/// </summary>
/// <param name="store">The <see cref="IJobStore"/> to use when accessing job data.</param>
public JobRunner(IJobStore store)
: this(store, BlueCollarSection.Current.PersistencePathResolved)
{
}
/// <summary>
/// Initializes a new instance of the JobStoreTestBase class.
/// </summary>
/// <param name="store">The store to use for the tests.</param>
protected JobStoreTestBase(IJobStore store)
{
this.Store = store;
}
/// <summary>
/// Initializes a new instance of the JobRunner class.
/// </summary>
/// <param name="store">The <see cref="IJobStore"/> to use when accessing job data.</param>
/// <param name="runningJobsPersistencePath">The path to use when saving running jobs state to disk.</param>
public JobRunner(IJobStore store, string runningJobsPersistencePath)
: this(store, runningJobsPersistencePath, BlueCollarSection.Current.Store.DeleteRecordsOnSuccess, BlueCollarSection.Current.Heartbeat, BlueCollarSection.Current.MaximumConcurrency, BlueCollarSection.Current.RetryTimeout, BlueCollarSection.Current.Enabled)
{
}
/// <summary>
/// Initializes a new instance of the JobRunner class.
/// </summary>
/// <param name="store">The <see cref="IJobStore"/> to use when accessing job data.</param>
/// <param name="runningJobsPersistencePath">The path to use when saving running jobs state to disk.</param>
/// <param name="deleteRecordsOnSuccess">A value indicating whether to delete records after successful job runs.</param>
/// <param name="heartbeat">The heartbeat, in milliseconds, to poll for jobs with.</param>
/// <param name="maximumConcurrency">The maximum number of simultaneous jobs to run.</param>
/// <param name="retryTimeout">The timeout, in milliseconds, to use for failed job retries.</param>
/// <param name="enabled">A value indicating whether dequeueing new jobs is enabled.</param>
public JobRunner(IJobStore store, string runningJobsPersistencePath, bool deleteRecordsOnSuccess, int heartbeat, int maximumConcurrency, int retryTimeout, bool enabled)
: this(store, runningJobsPersistencePath, deleteRecordsOnSuccess, heartbeat, maximumConcurrency, retryTimeout, enabled, BlueCollarSection.Current.Schedules)
{
}
/// <summary>
/// Initializes a new instance of the JobRunner class.
/// </summary>
/// <param name="store">The <see cref="IJobStore"/> to use when accessing job data.</param>
/// <param name="runningJobsPersistencePath">The path to use when saving running jobs state to disk.</param>
/// <param name="deleteRecordsOnSuccess">A value indicating whether to delete records after successful job runs.</param>
/// <param name="heartbeat">The heartbeat, in milliseconds, to poll for jobs with.</param>
/// <param name="maximumConcurrency">The maximum number of simultaneous jobs to run.</param>
/// <param name="retryTimeout">The timeout, in milliseconds, to use for failed job retries.</param>
/// <param name="enabled">A value indicating whether dequeueing new jobs is enabled.</param>
/// <param name="schedules">The collection of scheduled jobs to run.</param>
public JobRunner(IJobStore store, string runningJobsPersistencePath, bool deleteRecordsOnSuccess, int heartbeat, int maximumConcurrency, int retryTimeout, bool enabled, IEnumerable<JobScheduleElement> schedules)
{
this.store = store ?? JobStore.Current;
this.runs = new RunningJobs(runningJobsPersistencePath);
this.deleteRecordsOnSuccess = deleteRecordsOnSuccess;
this.heartbeat = heartbeat < 1 ? 10000 : heartbeat;
this.maximumConcurrency = maximumConcurrency < 1 ? 25 : maximumConcurrency;
this.retryTimeout = retryTimeout < 1 ? 60000 : retryTimeout;
this.isEnabled = enabled;
this.SetSchedules(schedules);
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it for remote access.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="schedulerPluginMap"></param>
/// <param name="idleWaitTime">The idle wait time. You can specify TimeSpan.Zero for
/// the default value, which is currently 30000 ms.</param>
public virtual void CreateScheduler(string schedulerName, string schedulerInstanceId, IThreadPool threadPool,
IJobStore jobStore, IDictionary<string, ISchedulerPlugin> schedulerPluginMap, TimeSpan idleWaitTime)
{
CreateScheduler(
schedulerName, schedulerInstanceId, threadPool, jobStore, schedulerPluginMap, idleWaitTime, DefaultBatchMaxSize, DefaultBatchTimeWindow);
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it for remote access.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="idleWaitTime">The idle wait time. You can specify "-1" for
/// the default value, which is currently 30000 ms.</param>
public virtual void CreateScheduler(string schedulerName, string schedulerInstanceId, IThreadPool threadPool,
IJobStore jobStore, TimeSpan idleWaitTime)
{
CreateScheduler(schedulerName, schedulerInstanceId, threadPool, jobStore, null, idleWaitTime);
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it to RMI.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="schedulerPluginMap"></param>
/// <param name="idleWaitTime">The idle wait time. You can specify TimeSpan.Zero for
/// the default value, which is currently 30000 ms.</param>
/// <param name="dbFailureRetryInterval">The db failure retry interval.</param>
public virtual void CreateScheduler(string schedulerName, string schedulerInstanceId, IThreadPool threadPool,
IJobStore jobStore, IDictionary schedulerPluginMap, TimeSpan idleWaitTime,
TimeSpan dbFailureRetryInterval)
{
// Currently only one run-shell factory is available...
IJobRunShellFactory jrsf = new StdJobRunShellFactory();
// Fire everything up
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SchedulingContext schedCtxt = new SchedulingContext();
schedCtxt.InstanceId = schedulerInstanceId;
SchedulerSchedulerResources qrs = new SchedulerSchedulerResources();
qrs.Name = schedulerName;
qrs.InstanceId = schedulerInstanceId;
qrs.JobRunShellFactory = jrsf;
qrs.ThreadPool = threadPool;
qrs.JobStore = jobStore;
// add plugins
if (schedulerPluginMap != null)
{
foreach (ISchedulerPlugin plugin in schedulerPluginMap.Values)
{
qrs.AddSchedulerPlugin(plugin);
}
}
SchedulerScheduler qs = new SchedulerScheduler(qrs, schedCtxt, idleWaitTime, dbFailureRetryInterval);
ITypeLoadHelper cch = new CascadingClassLoadHelper();
cch.Initialize();
jobStore.Initialize(cch, qs.SchedulerSignaler);
IScheduler scheduler = new StdScheduler(qs, schedCtxt);
// Initialize plugins now that we have a Scheduler instance.
if (schedulerPluginMap != null)
{
foreach (DictionaryEntry pluginEntry in schedulerPluginMap)
{
((ISchedulerPlugin)pluginEntry.Value).Initialize(
(string) pluginEntry.Key, scheduler);
}
}
jrsf.Initialize(scheduler, schedCtxt);
Log.Info(string.Format(CultureInfo.InvariantCulture, "Scheduler scheduler '{0}", scheduler.SchedulerName));
Log.Info(string.Format(CultureInfo.InvariantCulture, "Scheduler scheduler version: {0}", qs.Version));
SchedulerRepository schedRep = SchedulerRepository.Instance;
qs.AddNoGCObject(schedRep); // prevents the repository from being
// garbage collected
schedRep.Bind(scheduler);
}
