/// <summary> /// Creates a new job resolved from the IoC container. /// </summary> /// <param name="bundle">Trigger fired bundle instance.</param> /// <param name="scheduler">Scheduler instance.</param> /// <returns>Returns a new job resolved from the IoC container.</returns> public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { if (bundle == null) throw new ArgumentNullException("bundle"); return (IJob)this._container.Resolve(bundle.JobDetail.JobType); }
/// <summary> /// Called by the scheduler at the time of the trigger firing, in order to /// produce a <see cref="T:Quartz.IJob"/> instance on which to call Execute. /// /// </summary> /// /// <remarks> /// It should be extremely rare for this method to throw an exception - /// basically only the the case where there is no way at all to instantiate /// and prepare the Job for execution. When the exception is thrown, the /// Scheduler will move all triggers associated with the Job into the /// <see cref="F:Quartz.TriggerState.Error"/> state, which will require human /// intervention (e.g. an application restart after fixing whatever /// configuration problem led to the issue wih instantiating the Job. /// /// </remarks> /// <param name="bundle">The TriggerFiredBundle from which the <see cref="T:Quartz.IJobDetail"/> /// and other info relating to the trigger firing can be obtained. /// </param><param name="scheduler">a handle to the scheduler that is about to execute the job</param><throws>SchedulerException if there is a problem instantiating the Job. </throws> /// <returns> /// the newly instantiated Job /// /// </returns> public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { var jobType = bundle.JobDetail.JobType.FullName; TenantId tenantId = null; if (bundle.JobDetail.JobDataMap.ContainsKey(JobKeys.TenantId)) { tenantId = new TenantId( bundle.JobDetail.JobDataMap.GetString(JobKeys.TenantId) ); Logger.DebugFormat("new job {0} on tenant {1}", jobType, tenantId ); } else { if (typeof (ITenantJob).IsAssignableFrom(bundle.JobDetail.JobType)) { string message = String.Format("Job {0}: missing tenantId", jobType); Logger.Error(message); throw new Exception(message); } Logger.DebugFormat("new job {0} without tenant", jobType); } var kernel = SelectKernel(tenantId); var job = this.ResolveByJobName ? (IJob)kernel.Resolve(bundle.JobDetail.Key.ToString(), typeof(IJob)) : (IJob)kernel.Resolve(bundle.JobDetail.JobType); if (job is ITenantJob) { (job as ITenantJob).TenantId = new TenantId(tenantId); } return job; }
/// <summary> /// Create the job instance, populating it with property values taken /// from the scheduler context, job data map and trigger data map. /// </summary> protected override object CreateJobInstance(TriggerFiredBundle bundle) { ObjectWrapper ow = new ObjectWrapper(bundle.JobDetail.JobType); if (IsEligibleForPropertyPopulation(ow.WrappedInstance)) { MutablePropertyValues pvs = new MutablePropertyValues(); if (schedulerContext != null) { pvs.AddAll(schedulerContext); } pvs.AddAll(bundle.JobDetail.JobDataMap); pvs.AddAll(bundle.Trigger.JobDataMap); if (ignoredUnknownProperties != null) { for (int i = 0; i < ignoredUnknownProperties.Length; i++) { string propName = ignoredUnknownProperties[i]; if (pvs.Contains(propName)) { pvs.Remove(propName); } } ow.SetPropertyValues(pvs); } else { ow.SetPropertyValues(pvs, true); } } return ow.WrappedInstance; }
public IJob NewJob(TriggerFiredBundle bundle) { Type jobType = bundle.JobDetail.JobType; var job = ObjectFactory.GetInstance(jobType) as IJob; ObjectFactory.BuildUp(job); return job; }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { var jobDetail = bundle.JobDetail; var jobType = jobDetail.JobType; try { if (Log.IsDebugEnabled) { Log.Debug(string.Format("Producing instance of Job '{0}', class={1}", new object[] { jobDetail.Key, jobType.FullName })); } var disallowConcurent = jobType.GetCustomAttributes(typeof(DisallowConcurrentExecutionAttribute), true).Length == 1; return typeof(IInterruptableJob).IsAssignableFrom(jobType) ? disallowConcurent ? new InterruptableDisallowConcurrentExecutionJobWrapper(bundle, _container) : new InterruptableJobWrapper(bundle, _container) : disallowConcurent ? new DisallowConcurrentExecutionJobWrapper(bundle, _container) : new JobWrapper(bundle, _container); } catch (Exception ex) { throw new SchedulerException( string.Format("Problem instantiating class '{0}'", new object[] { jobDetail.JobType.FullName }), ex); } }
/// <summary> /// Called by the scheduler at the time of the trigger firing, in order to produce /// a Quartz.IJob instance on which to call Execute /// </summary> /// <param name="bundle">The TriggerFiredBundle from which the Quartz.IJobDetail and other info relating to the trigger firing can be obtained.</param> /// <param name="scheduler">A handle to the scheduler that is about to execute the job</param> /// <returns>The new intance of IJob</returns> public IJob NewJob( TriggerFiredBundle bundle, IScheduler scheduler) { return (IJob)_container .GetInstance(bundle.JobDetail.JobType); }
/// <summary> /// Initializes the job execution context with given scheduler and bundle. /// </summary> /// <param name="sched">The scheduler.</param> /// <param name="firedBundle">The bundle offired triggers.</param> public virtual void Initialize(QuartzScheduler sched, TriggerFiredBundle firedBundle) { qs = sched; IJob job; JobDetail jobDetail = firedBundle.JobDetail; try { job = sched.JobFactory.NewJob(firedBundle); } catch (SchedulerException se) { sched.NotifySchedulerListenersError(string.Format(CultureInfo.InvariantCulture, "An error occured instantiating job to be executed. job= '{0}'", jobDetail.FullName), se); throw; } catch (Exception e) { SchedulerException se = new SchedulerException(string.Format(CultureInfo.InvariantCulture, "Problem instantiating type '{0}'", jobDetail.JobType.FullName), e); sched.NotifySchedulerListenersError(string.Format(CultureInfo.InvariantCulture, "An error occured instantiating job to be executed. job= '{0}'", jobDetail.FullName), se); throw se; } jec = new JobExecutionContext(scheduler, firedBundle, job); }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { var jobDetail = bundle.JobDetail; var jobType = jobDetail.JobType; try { if (Log.IsDebugEnabled) { Log.Debug(string.Format( CultureInfo.InvariantCulture, "Producing instance of Job '{0}', class={1}", new object[] { jobDetail.Key, jobType.FullName })); } return typeof(IInterruptableJob).IsAssignableFrom(jobType) ? new InterruptableJobWrapper(bundle, container) : new JobWrapper(bundle, container); } catch (Exception ex) { throw new SchedulerException(string.Format( CultureInfo.InvariantCulture, "Problem instantiating class '{0}'", new object[] { jobDetail.JobType.FullName }), ex); } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { if (bundle == null) throw new ArgumentNullException("bundle"); if (scheduler == null) throw new ArgumentNullException("scheduler"); var job = (IJob)IocManager.Instance.Resolve(bundle.JobDetail.JobType); return job; }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { var jobType = typeof(AutofacOwnedJob<>).MakeGenericType(new[] { bundle.JobDetail.JobType }); var job = this.container.Resolve(jobType); return (IJob)job; }
//----------------------------------------------------------------------------------------------------------------------------------------------------- public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { var jobAdapter = (IJob)_components.Resolve( bundle.JobDetail.JobType, new TypedParameter(typeof(IJobDetail), bundle.JobDetail)); return jobAdapter; }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { var type = bundle.JobDetail.JobType; _logger.Info("Job {0} was created", type.FullName); return _kernel.Get(type) as IJob; }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { IJobDetail jobDetail = bundle.JobDetail; if (jobDetail == null) throw new SchedulerException("JobDetail was null"); Type type = jobDetail.JobType; return _typeFactories[type].NewJob(bundle, scheduler); }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { var jobDetail = bundle.JobDetail; if (jobDetail == null) throw new SchedulerException("JobDetail was null"); var type = jobDetail.JobType; return _typeFactories.GetOrAdd(type, CreateJobFactory) .NewJob(bundle, scheduler); }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { return (IJob)_lifetimeScope.Resolve(bundle.JobDetail.JobType); } catch (Exception e) { throw new SchedulerException("Problem instantiating class: " + e.Message, e); } }
public override IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { return (IJob) this._kernel.Get(bundle.JobDetail.JobType); // will inject dependencies that the job requires } catch (Exception e) { throw new SchedulerException(string.Format("Problem while instantiating job '{0}' from the NinjectJobFactory.", bundle.JobDetail.Key), e); } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { // Configure your IoC container to return a job instance based on jobType var jobDetail = bundle.JobDetail; Type jobType = jobDetail.JobType; Log.TraceFormat("Getting instance of job type {0}", jobType); throw new NotImplementedException(); }
public Quartz.IJob NewJob(TriggerFiredBundle bundle, Quartz.IScheduler scheduler) { try { return (IJob)this.Container.Resolve(bundle.JobDetail.JobType); } catch (Exception ex) { throw; } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { var job = Container.Resolve(bundle.JobDetail.JobType) as IJob; return job; } catch (Exception exception) { throw new SchedulerException("Error on creation of new job", exception); } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { return (IJob)InversionControl.Current.Resolve(bundle.JobDetail.JobType); } catch (Exception e) { var se = new SchedulerException("falha ao agendar", e); throw; } }
/// <summary> /// Called by the scheduler at the time of the trigger firing, in order to /// produce a <see cref="IJob"/> instance on which to call Execute. /// </summary> /// <remarks> /// It should be extremely rare for this method to throw an exception - /// basically only the the case where there is no way at all to instantiate /// and prepare the Job for execution. When the exception is thrown, the /// Scheduler will move all triggers associated with the Job into the /// <see cref="TriggerState.Error"/> state, which will require human /// intervention (e.g. an application restart after fixing whatever /// configuration problem led to the issue wih instantiating the Job. /// </remarks> /// <param name="bundle">The TriggerFiredBundle from which the <see cref="IJobDetail"/> /// and other info relating to the trigger firing can be obtained.</param> /// <param name="scheduler">The scheduler instance.</param> /// <returns>the newly instantiated Job</returns> /// <throws>SchedulerException if there is a problem instantiating the Job.</throws> public virtual IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { object jobObject = CreateJobInstance(bundle); return AdaptJob(jobObject); } catch (Exception ex) { throw new SchedulerException("Job instantiation failed", ex); } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { return (IJob) Activator.CreateInstance(bundle.JobDetail.JobType); } catch { } throw new InvalidOperationException("Cannot construct job of type " + bundle.JobDetail.GetType().FullName); }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { var job = this.serviceLocator.GetInstance(bundle.JobDetail.JobType) as IJob; Contract.Assert(job != null); return job; } catch (Exception exception) { throw new SchedulerException("Error on creation of new job", exception); } }
/// <summary> /// News the job. /// </summary> /// <param name="bundle">The bundle.</param> /// <param name="scheduler">The scheduler.</param> /// <returns>IJob object.</returns> public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { var jobDetail = bundle.JobDetail; var jobType = jobDetail.JobType; try { return (IJob)this.container.GetInstance(bundle.JobDetail.JobType); } catch (Exception ex) { throw; } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { IJobDetail jobDetail = bundle.JobDetail; Type jobType = jobDetail.JobType; return (IJob)_locator.Resolve(jobType); } catch (Exception e) { var se = new SchedulerException("Problem instantiating class of type", e); throw se; } }
public IJob NewJob(TriggerFiredBundle bundle) { JobDetail jobDetail = bundle.JobDetail; try { return (IJob)NServiceBus.Configure.Instance.Builder.Build(jobDetail.JobType); } catch (Exception ex) { logger.Error(ex.Message, ex); throw; } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { IJobDetail jobDetail = bundle.JobDetail; Type jobType = jobDetail.JobType; return (IJob)locator.GetInstance(jobType); } catch (Exception e) { throw new SchedulerException("Problem instantiating class", e); } }
public IJob NewJob(TriggerFiredBundle bundle, Quartz.IScheduler scheduler) { try { var x = this.Kernel.Get(bundle.JobDetail.JobType); return (IJob)x; } catch(Exception err) { this.EventReporter.ExceptionForObject(err, bundle.JobDetail); throw; } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { try { var jobDetail = bundle.JobDetail; var jobType = jobDetail.JobType; return (IJob) TinyIoCContainer.Current.Resolve(jobType); } catch (Exception ex) { throw new SchedulerException("Problem Instantiating job class", ex); } }
public IJob NewJob(TriggerFiredBundle bundle, IScheduler scheduler) { IJob newJob; try { newJob = (IJob)container.Resolve(bundle.JobDetail.JobType); } catch (Exception ex) { Console.WriteLine(ex.Message); throw; } return newJob; }
///<summary> /// Constructor. ///</summary> ///<param name="triggerFiredBundle"></param> public TriggerFiredResult(TriggerFiredBundle triggerFiredBundle) { this.triggerFiredBundle = triggerFiredBundle; }