/// <summary>
/// Resync the schedules for the global tenant.
/// </summary>
/// <param name="solutionAliases"></param>
/// <param name="scheduler"></param>
private void ResyncSchedulesForGlobalTenant(ISet <string> solutionAliases, Quartz.IScheduler scheduler)
{
if (solutionAliases.Count == 0)
{
return;
}
using (new GlobalAdministratorContext())
{
foreach (var schedItem in Entity.GetInstancesOfType <ScheduledItem>(true, "inSolution.{isOfType.id, alias}, isOfType.{systemTenantOnly}"))
{
var itemSolutions = new List <string>();
if (schedItem.InSolution != null)
{
itemSolutions.Add(schedItem.InSolution.Alias);
}
if (solutionAliases.Overlaps(itemSolutions) &&
schedItem.IsOfType.Any(t => t.SystemTenantOnly ?? false))
{
EventLog.Application.WriteTrace(string.Format("Post install updating updating ScheduledItems '{0}' in Global Tenant.", schedItem.Name));
SchedulingSyncHelper.UpdateScheduledJob(schedItem, scheduler);
}
}
}
}
public static ConfigProvider GetInstance(Quartz.IScheduler scheduler)
{
lock (padlock)
{
return(instance ?? (instance = new ConfigProvider(scheduler)));
}
}
public ScheduleBuilder()
{
var ssf = new StdSchedulerFactory();
Scheduler = ssf.GetScheduler();
Scheduler.Start();
}
public Scheduler(IUnityContainer container)
{
this.container = container;
ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
quartzScheduler = schedulerFactory.GetScheduler();
quartzScheduler.Start();
}
public async Task Start()
{
Container = new UnityContainer();
Systems = _actorSystemFactory.Invoke();
System = Systems.First();
System.InitDomainEventsSerialization(EventsAdaptersCatalog);
_transportMode = Systems.Length > 1 ? TransportMode.Cluster : TransportMode.Standalone;
System.RegisterOnTermination(OnSystemTermination);
System.AddDependencyResolver(new UnityDependencyResolver(Container, System));
ConfigureContainer(Container, _quartzConfig, System);
Transport = Container.Resolve <IActorTransport>();
_quartzScheduler = Container.Resolve <Quartz.IScheduler>();
_commandExecutor = Container.Resolve <ICommandExecutor>();
_waiterFactory = Container.Resolve <IMessageWaiterFactory>();
_commandWaiterFactory = Container.Resolve <ICommandWaiterFactory>();
EventBusForwarder = System.ActorOf(Props.Create(() => new EventBusForwarder(Transport)), nameof(EventBusForwarder));
var appInsightsConfig = Container.Resolve <IAppInsightsConfiguration>();
var perfCountersConfig = Container.Resolve <IPerformanceCountersConfiguration>();
var factories = Container.ResolveAll(typeof(IConstructAggregates))
.Select(o => new { Type = o.GetType(), Obj = (IConstructAggregates)o })
.Where(o => o.Type.IsGenericType && o.Type.GetGenericTypeDefinition() == typeof(AggregateSnapshottingFactory <>))
.Select(o => new { AggregateType = o.Type.GetGenericArguments().First(), Constructor = o.Obj })
.ToArray();
foreach (var factory in factories)
{
AggregateFromSnapshotsFactory.Register(factory.AggregateType, m => factory.Constructor.Build(factory.GetType(), Guid.Empty, m));
}
if (appInsightsConfig.IsEnabled)
{
var monitor = new ActorAppInsightsMonitor(appInsightsConfig.Key);
ActorMonitoringExtension.RegisterMonitor(System, monitor);
}
if (perfCountersConfig.IsEnabled)
{
ActorMonitoringExtension.RegisterMonitor(System, new ActorPerformanceCountersMonitor());
}
_stopping = false;
_log.Debug("Launching GridDomain node {Id}", Id);
var props = System.DI().Props <GridNodeController>();
var nodeController = System.ActorOf(props, nameof(GridNodeController));
await nodeController.Ask <GridNodeController.Started>(new GridNodeController.Start
{
RoutingActorType = RoutingActorType[_transportMode]
});
_log.Debug("GridDomain node {Id} started at home {Home}", Id, System.Settings.Home);
}
ConfigProvider(Quartz.IScheduler scheduler)
{
provider = IDPJobManagerConfiguration.Config.Provider;
schedulerProvider = new StdSchedulerProvider(scheduler)
{
Uri = provider.Uri
};
}
public SpiderContainerController(PortalDbContext dbContext,
PortalOptions options,
Quartz.IScheduler sched,
ILogger <SpiderController> logger)
{
_logger = logger;
_dbContext = dbContext;
_sched = sched;
_options = options;
}
void Application_Start(object sender, EventArgs e)
{
//---------------------------初始化quartz---------------------------
Quartz.ISchedulerFactory sf = new Quartz.Impl.StdSchedulerFactory();
sched = sf.GetScheduler();
sched.Start();
//------------------------------------------------------------------
Logger.Info("web启动成功");
}
public AddressAssociateService()
{
//Thread.Sleep(1000 * 5);
InitializeComponent();
if (scheduler == null)
{
var schedulerFactory = new StdSchedulerFactory();
scheduler = schedulerFactory.GetScheduler();
}
}
ConfigProvider(Quartz.IScheduler scheduler)
{
var baseUri = new Uri(AppDomain.CurrentDomain.BaseDirectory);
provider = IDPJobManagerConfiguration.Config.Provider;
schedulerProvider = new StdSchedulerProvider(scheduler)
{
Uri = provider.Uri
};
}
public TaskHandler()
{
_Logger = Common.Logging.LogManager.GetLogger(GetType());
//依据配置文件获取需要调度任务
var fact = new Quartz.Impl.StdSchedulerFactory();
_Scheduler = fact.GetScheduler();
//在此注册任务处理模块时间处理
JobBaseHandler.OnExecute += JobBaseHandler_OnExecute;
}
protected override void OnSchedulerCreated(IScheduler scheduler)
{
if (!scheduler.Context.ContainsKey(QuartzPersistentJob.SysKey))
{
scheduler.Context.Add(QuartzPersistentJob.SysKey, Context.System);
}
else
{
scheduler.Context.Remove(QuartzPersistentJob.SysKey);
scheduler.Context.Add(QuartzPersistentJob.SysKey, Context.System);
}
}
public QuartzPersistentActor()
{
_scheduler = new StdSchedulerFactory().GetScheduler();
if (!_scheduler.Context.ContainsKey(QuartzPersistentJob.SysKey))
{
_scheduler.Context.Add(QuartzPersistentJob.SysKey, Context.System);
}
else
{
_scheduler.Context.Remove(QuartzPersistentJob.SysKey);
_scheduler.Context.Add(QuartzPersistentJob.SysKey, Context.System);
}
}
public void DoesInstanceConnect()
{
QuartzAdmin.web.Models.InstanceRepository instanceRepo = new QuartzAdmin.web.Models.InstanceRepository();
QuartzAdmin.web.Models.InstanceModel instance = instanceRepo.GetInstance("Instance1");
try
{
Quartz.IScheduler sched = instance.GetQuartzScheduler();
Assert.IsNotNull(sched);
}
catch (Exception ex)
{
Assert.Fail("Error connecting", ex);
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
factory = new Quartz.Impl.StdSchedulerFactory();
scheduler = factory.GetScheduler();
scheduler.Start();
}
catch (Exception ex)
{
String s = ex.Message;
}
}
protected override void OnStart(string[] args)
{
try
{
factory = new Quartz.Impl.StdSchedulerFactory();
scheduler = factory.GetScheduler();
scheduler.Start();
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
}
public void DoesInstanceConnect2()
{
Story instanceConnectStory = new Story("Connect to instance");
QuartzAdmin.web.Models.InstanceRepository instanceRepo = new QuartzAdmin.web.Models.InstanceRepository();
QuartzAdmin.web.Models.InstanceModel instance = null;
Quartz.IScheduler sched = null;
instanceConnectStory
.AsA("System Admin")
.IWant("to connect to a running quartz instance")
.SoThat("I can perform admin functions");
instanceConnectStory
.WithScenario("Perform connection to instance")
.Given("the instance name is", "Instance1", delegate(string instanceName) { instance = instanceRepo.GetInstance(instanceName); })
.When("the connection is attempted", delegate() { sched = instance.GetQuartzScheduler(); })
.Then("the connection is not null", delegate() { Assert.IsNotNull(sched); });
}
/// <summary>
/// Creates and runs the service host for the easynetq handler.
/// </summary>
/// <param name="serviceName">The name of the handler service.</param>
/// <param name="container">The injection container used.</param>
/// <param name="scheduler">The scheduler instance used.</param>
private static void CreateAndRunServiceHost(string serviceName, IKernel container, Quartz.IScheduler scheduler)
{
HostFactory.Run(hostConfigurator =>
{
hostConfigurator.Service <IBusServiceHost>(s =>
{
s.ConstructUsing(name => container.Get <IBusServiceHost>());
s.WhenStarted(tc => tc.Start());
s.WhenStopped(tc =>
{
try
{
// Release and Dispose ninject
container.Release(tc);
container.Dispose();
}
catch (Exception ex)
{
_logger.Error("Error: {0}", ex.Message);
}
finally
{
// Shutdown the scheduler
scheduler.Shutdown();
}
});
});
// These are default settings, refere to:
// http://topshelf.readthedocs.org/en/latest/overview/commandline.html
// for hpow to specify service options
hostConfigurator.SetDisplayName(serviceName);
hostConfigurator.SetDescription($"Handles messages defined for {serviceName} in RabbitMQ.");
hostConfigurator.SetServiceName(serviceName.Replace(" ", ""));
// The above options are overridden like:
// EasyNetQ.GenericHost.exe install -servicename:myservice -description:"My Service description" -displayname:"MY Display Name"
// The service runs as local system, you might want to modify that after the service is installed or
// install with the --interactive option (make a .cdm file :-))
});
}
public Quartz.IJob NewJob(TriggerFiredBundle bundle, Quartz.IScheduler scheduler)
{
return(EventPublisherJobFactory.Instance);
}
public QuartzPersistentActor(IScheduler scheduler)
: base(scheduler)
{
AddSystemToScheduler();
}
public QuartzPersistentActor()
{
_scheduler = new StdSchedulerFactory().GetScheduler();
this.AddSystemToScheduler();
}
public CrossShopStatisticLogService()
{
InitializeComponent();
Quartz.ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
scheduler = schedulerFactory.GetScheduler();
}
public WithdrawService()
{
InitializeComponent();
Quartz.ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
scheduler = schedulerFactory.GetScheduler();
}
public QuartzPersistentActor(IScheduler scheduler)
: base(scheduler)
{
}
public void StartScheduler()
{
Quartz.Impl.StdSchedulerFactory factory = new Quartz.Impl.StdSchedulerFactory();
Quartz.IScheduler scheduler = factory.GetScheduler();
string myJobName = "MyFirstJob";
string myGroupName = "MyGroup";
string[] jobNames = scheduler.GetJobNames(myGroupName);
if (!jobNames.Contains(myJobName))
{
Quartz.JobDetail job = new Quartz.JobDetail(myJobName, myGroupName, typeof(ConsoleJob1));
job.JobDataMap.Add("ExtraText", "Plinko");
Quartz.Trigger trigger = Quartz.TriggerUtils.MakeMinutelyTrigger(2);
trigger.Name = "myFirstTrigger";
trigger.Group = myGroupName;
scheduler.ScheduleJob(job, trigger);
}
if (!jobNames.Contains("HelloWorld1"))
{
Quartz.JobDetail job = new Quartz.JobDetail("HelloWorld1", myGroupName, typeof(Quartz.Job.NoOpJob));
Quartz.Trigger trigger = Quartz.TriggerUtils.MakeMinutelyTrigger(15);
trigger.Name = "HelloWorld1Trigger";
trigger.Group = myGroupName;
scheduler.ScheduleJob(job, trigger);
}
if (!jobNames.Contains("HelloWorld2"))
{
Quartz.Impl.Calendar.HolidayCalendar calendar = new Quartz.Impl.Calendar.HolidayCalendar();
calendar.AddExcludedDate(DateTime.Now.ToUniversalTime());
calendar.AddExcludedDate(DateTime.Now.AddDays(4).ToUniversalTime());
scheduler.AddCalendar("randomHolidays", calendar, true, true);
Quartz.JobDetail job = new Quartz.JobDetail("HelloWorld2", myGroupName, typeof(Quartz.Job.NoOpJob));
Quartz.Trigger trigger = Quartz.TriggerUtils.MakeDailyTrigger(15, 00);
trigger.Name = "HelloWorld2Trigger";
trigger.Group = myGroupName;
trigger.CalendarName = "randomHolidays";
scheduler.ScheduleJob(job, trigger);
}
if (!jobNames.Contains("TimeTrackerReminder"))
{
Quartz.JobDetail job = new Quartz.JobDetail("TimeTrackerReminder", myGroupName, typeof(Quartz.Job.NoOpJob));
Quartz.Trigger trigger = Quartz.TriggerUtils.MakeWeeklyTrigger(DayOfWeek.Monday, 8, 0);
trigger.Name = "EveryMondayAtEight";
trigger.Group = myGroupName;
scheduler.ScheduleJob(job, trigger);
}
if (!jobNames.Contains("UnscheduledJob"))
{
Quartz.JobDetail job = new Quartz.JobDetail("UnscheduledJob", myGroupName, typeof(Quartz.Job.NoOpJob));
scheduler.AddJob(job, true);
}
if (!jobNames.Contains("TwoAliens"))
{
Quartz.JobDetail job = new Quartz.JobDetail("TwoAliens", myGroupName, typeof(TwoAlienJob));
Quartz.Trigger trigger = Quartz.TriggerUtils.MakeMonthlyTrigger(28, 23, 59);
trigger.Name = "EveryFullMoon";
trigger.Group = myGroupName;
scheduler.ScheduleJob(job, trigger);
}
scheduler.Start();
}
public MService()
{
scheduler = StdSchedulerFactory.GetDefaultScheduler();
}
public SchedulerWrapper(Quartz.IScheduler quartzScheduler)
{
_quartzScheduler = quartzScheduler;
}
public Scheduler()
{
ISchedulerFactory schedulerFactory = new StdSchedulerFactory();
quartzScheduler = schedulerFactory.GetScheduler();
quartzScheduler.Start();
}
