public override void Execute()
{
var job = new JobFactory <int, DeformerFlattenFactory>
{
FactoryJob = new DeformerFlattenFactory
{
Envelope = Env,
Input = VertexIn,
Output = VertexOut
}
};
job.Run();
// var job = new JobParallelForFactory<int, DeformerFlattenFactory>
// {
// FactoryJob = new DeformerFlattenFactory
// {
// Envelope = Env,
// Input = VertexIn,
// Output = VertexOut
// }
// };
// var dpt = job.Schedule(VertexIn.Length, 64);
// dpt.Complete();
}
private async Task Clone()
{
var wrapper = new JobOptionsWrapper {
Options = jobOptions
};
var entity = new JobEntity
{
Owner = await GuestRepo.Get(uid),
CreationDate = DateTime.Now,
JobType = jobType,
JobOptions = JsonConvert.SerializeObject(wrapper, settings)
};
await JobRepo.Add(entity);
// Get the entity that was just added in order to get its ID
// entity = await JobRepo.GetAll().Include(j => j.Owner).OrderByDescending(e => e.Id).FirstAsync();
try
{
var job = JobFactory.FromOptions(entity.Id, entity.Owner == null ? 0 : entity.Owner.Id, jobOptions);
Manager.AddJob(job);
Nav.NavigateTo($"job/{job.Id}");
}
catch (Exception ex)
{
await js.AlertException(ex);
}
}
public Engine()
{
this.employees = new List <IEmployee>();
this.jobs = new Jobs();
this.employeeFactory = new EmployeeFactory();
this.jobFactory = new JobFactory();
}
public void Given_scheduler_with_daily_item()
{
var context = new TestSchedulerContext();
_scheduler = new Scheduler(context);
var runsoon = new TimeSpan(DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second);
var foo1 = JobFactory.Daily("Foo1", () => { Console.WriteLine("Foo1"); foo1_calls += 1; }, runsoon, description: "Description for Foo1");
var foo2 = JobFactory.Daily("Foo2", () => Console.WriteLine("Foo2"), runsoon);
_scheduler.Schedule(foo1);
_scheduler.Schedule(foo2);
_scheduler.Start();
Wait.Until(() => foo1_calls > 0, 30);
context.MoveToTommorrow();
Wait.Until(() => foo1_calls > 1, 30);
context.MoveForwardNDays(2);
Wait.Until(() => foo1_calls > 2, 50);
}
static void Main(string[] args)
{
var dt = new DataTable(); // fill data
var jobs = new List <Job>();
Parallel.ForEach(dt.AsEnumerable(), row => jobs.Add(JobFactory.GetJob(row)));
}
public void CanRunJobSuccess()
{
setupCalled = false;
runCalled = false;
tearDownCalled = false;
var mockJob = serviceProvider.GetRequiredService <MockTileGenerationJob>();
Assert.IsNotNull(mockJob);
mockJob.SetupInvoked += OnSetupInvoked;
mockJob.RunInvoked += OnRunInvoked;
mockJob.TearDownInvoked += OnTearDownInvoked;
var context = GetMockHangfireContext(typeof(VSSHangfireJobRunnerTests), TestContext.TestName, string.Empty);
var errorProvider = new Mock <IErrorCodesProvider>();
var configStore = new Mock <IConfigurationStore>();
var jobManager = new JobRegistrationManager(loggerFactory);
var jobFactory = new JobFactory(serviceProvider, jobManager);
var vssJobUid = Guid.NewGuid();
jobManager.RegisterJob(vssJobUid, typeof(MockTileGenerationJob));
var devOpsNotification = new Mock <IDevOpsNotification>();
var jobRunner = new JobRunner(loggerFactory, errorProvider.Object, configStore.Object, jobFactory, jobManager, serviceProvider);
var request = new JobRequest {
JobUid = vssJobUid, RunParameters = new DxfTileGenerationRequest()
};
var result = jobRunner.RunHangfireJob("testjob", request, false, null, context);
Assert.IsTrue(setupCalled);
Assert.IsTrue(runCalled);
Assert.IsTrue(tearDownCalled);
}
public void CreateFromJobDefinitions_ForSingleValidJobDefinitionAndNoSchedule_WillCreateCorrectly()
{
var jobDefinitions = new List <JobDefinition> {
GetJobDefinition("testJob", "SOD", "it does stuff")
};
var jobDetails = JobFactory.CreateFromJobDefinitions(jobDefinitions);
var jobA = jobDetails[0];
Assert.IsNotNull(jobA);
Assert.IsTrue(jobA.JobType == typeof(ConsoleJob));
Assert.AreEqual("SOD.testJob", jobA.Key.ToString());
Assert.AreEqual("it does stuff", jobA.Description);
Assert.IsTrue(jobA.Durable);
Assert.AreEqual("Hello", jobA.JobDataMap[Constants.FieldNames.ExecutableName]);
Assert.AreEqual("None", jobA.JobDataMap[Constants.FieldNames.Parameters]);
Assert.AreEqual(Path.Combine(SchedulerConfig.LogPath, "SOD-testJob.txt"), jobA.JobDataMap[Constants.FieldNames.OutputFile]);
Assert.AreEqual("SOD.a", jobA.JobDataMap[Constants.FieldNames.RunOnCompletionOf]);
Assert.AreEqual("SOD.b", jobA.JobDataMap[Constants.FieldNames.RunOnFailureOf]);
Assert.AreEqual("SOD.c", jobA.JobDataMap[Constants.FieldNames.RunOnSuccessOf]);
Assert.AreEqual(3, jobA.JobDataMap[Constants.FieldNames.MaxRetries]);
Assert.AreEqual(4, jobA.JobDataMap[Constants.FieldNames.WarnAfter]);
Assert.AreEqual(2, jobA.JobDataMap[Constants.FieldNames.TerminateAfter]);
Assert.AreEqual(string.Empty, jobA.JobDataMap[Constants.FieldNames.RunAt]);
Assert.AreEqual(string.Empty, jobA.JobDataMap[Constants.FieldNames.ExclusionCalendar]);
Assert.AreEqual(string.Empty, jobA.JobDataMap[Constants.FieldNames.RunCalendar]);
Assert.AreEqual(string.Empty, jobA.JobDataMap[Constants.FieldNames.RunDays]);
Assert.AreEqual(string.Empty, jobA.JobDataMap[Constants.FieldNames.Timezone]);
}
// Please set the following connection strings in app.config for this WebJob to run:
// AzureWebJobsDashboard and AzureWebJobsStorage
static void Main()
{
var host = JobFactory.CreateJob();
// The following code ensures that the WebJob will be running continuously
host.RunAndBlock();
}
protected async override void OnStart(string[] args)
{
try
{
//Configure Container
IContainer container = Helpers.IocConfig.ConfigureContainer();
//Configure LogProvider
//Quartz.Logging.LogProvider.SetCurrentLogProvider(new Logging.NLogProvider());
Quartz.Logging.LogProvider.SetCurrentLogProvider(new Logging.ConsoleLogProvider());
//StdSchedulerFactory factory = new StdSchedulerFactory();
ISchedulerFactory factory = container.Resolve <ISchedulerFactory>();
scheduler = await factory.GetScheduler();
//Start scheduler
await scheduler.Start();
//Get All Jobs
var lstJobs = JobFactory.GetAllJobs();
foreach (var jobItem in lstJobs)
{
//Define the job
IJobDetail job = JobBuilder.Create(jobItem.JobType)
.WithIdentity(jobItem.Name, "groupTools")
.Build();
//Trigger the job to run now, and then repeat by Interval
ITrigger trigger = null;
if (jobItem.Interval != 0)
{
trigger = TriggerBuilder.Create()
.WithIdentity("trigger" + jobItem.Number, "groupTools")
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(jobItem.Interval)
.RepeatForever())
.Build();
}
else
{
trigger = TriggerBuilder.Create()
.WithIdentity("trigger" + jobItem.Number, "groupTools")
.StartNow()
.WithSchedule(CronScheduleBuilder.DailyAtHourAndMinute(jobItem.DailyAtHour, jobItem.DailyAtMinute))
.Build();
}
//Tell quartz to schedule the job using our trigger
await scheduler.ScheduleJob(job, trigger);
}
}
catch (SchedulerException se)
{
Console.WriteLine(se);
}
Logger.Info("Service Started");
}
private void loadList()
{
try
{
dept = DepartmentFactory.DepartmentCreateList();
cmbDepartmentModify.DataSource = dept;
cmbDepartmentModify.DisplayMember = "DepartmentName";
cmbDepartmentModify.ValueMember = "DepartmentID";
job = JobFactory.JobsCreateList();
cmbJobAssignmentModify.DataSource = job;
cmbJobAssignmentModify.DisplayMember = "jobTitle";
cmbJobAssignmentModify.ValueMember = "jobId";
cmbEmpStatusModify.DataSource = Enum.GetValues(typeof(EmpStatus));
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex);
}
}
public override async Task Execute(DeploymentManifestSourceTrackingContext context)
{
var repository = context.DeploymentManifest.Repository;
_log.LogInformation("Checkout repository containing application declaration");
await _deploymentManifestRepositoryService.Checkout(repository, true);
_log.LogInformation("Starting sync-job for {Repository} in {Path}",
repository.Uri,
repository.GetCheckoutDirectory()
);
var job = JobFactory.BuildJobWithData <GitRepositorySyncJob, DeploymentManifestSourceTrackingContext>(
$"gitwatch-{context.ApplicationName}",
Constants.SchedulerGroup,
context
);
var trigger = TriggerBuilder.Create()
.WithIdentity($"gitwatch-trig-{context.ApplicationName}", Constants.SchedulerGroup)
.StartNow()
.WithSimpleSchedule(x => x
.WithIntervalInSeconds(10)
.RepeatForever()
)
.ForJob(job)
.Build();
await _scheduler.ScheduleJob(job, trigger);
}
public Executioner(JobFactory jobFactory,
EmployeeFactory employeeFactory, IWriter writer)
{
this.jobFactory = jobFactory;
this.employeeFactory = employeeFactory;
this.writer = writer;
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
StartupIoC.RegisterIoC(_locator);
// make sure we're able to do work
_worker = new WorkerRegistrationController(_locator).EnsureWorkerRegistration();
_jobRepository = _locator.Locate <IJobRepository>();
_presenter = new WorkloadPresenter(new WorkloadView());
var poller = new JobPoller(_presenter, _locator, _worker);
if (_worker.CurrentJob != Guid.Empty)
{
// start working on the job
_presenter.CurrentJob = JobFactory.CreateJob(_jobRepository.GetCurrentJob(_worker.Id), _worker, _locator);
}
poller.Start();
try
{
Application.Run((WorkloadView)_presenter.View);
}
finally
{
poller.Stop();
}
}
private void Run()
{
while (!_stop)
{
// Wait the specified interval before checking again...
if (_presenter.CurrentJob == null)
{
var desc = _jobRepository.GetNextJob(_worker.Id);
if (desc != null)
{
_worker.CurrentJob = desc.Id;
// TODO: change this so that it happens automatically when CurrentJob is set on the workerstate
_presenter.CurrentJob = JobFactory.CreateJob(desc, _worker, _serviceLocator);
}
}
Thread.Sleep(_interval);
}
try
{
_thread.Abort();
}
catch (ThreadAbortException tae)
{
}
finally
{
_thread = null;
}
}
public MainGameScreen(Renderer renderer, ContentManager contentManager, string mapPathToLoad)
: base(contentManager)
{
if (renderer == null)
{
throw new ArgumentNullException("renderer");
}
if (contentManager == null)
{
throw new ArgumentNullException("contentManager");
}
if (String.IsNullOrEmpty(mapPathToLoad))
{
throw new ArgumentNullException("mapPathToLoad");
}
simulationManager = new SimulationManager(DateTime.Now, contentManager.ThoughtPool);
jobFactory = new JobFactory(contentManager);
agentFactory = new AgentFactory(renderer, contentManager, jobFactory);
roomFactory = new RoomFactory(renderer, contentManager);
simulationManager.HadThought += HandleEmployeeHadThought;
simulationManager.EmployeeThirstSatisfied += HandleEmployeeThirstSatisfied;
simulationManager.EmployeeHungerSatisfied += HandleEmployeeHungerSatisfied;
this.mapPathToLoad = mapPathToLoad;
}
private async Task ConfigureScheduler()
{
var jobFactory = new JobFactory(ServiceProvider);
var schedulerFactory = new StdSchedulerFactory();
IScheduler scheduler = await schedulerFactory.GetScheduler();
scheduler.JobFactory = jobFactory; // Use our DI container to create the Job
await scheduler.Start();
IJobDetail job = JobBuilder.Create <AfterLunchJob>()
.WithIdentity(nameof(AfterLunchJob), "Lunch Bot")
.Build();
// Trigger the job every Friday sometime after Lunch ....say 3:00
var onFriday = DailyTimeIntervalScheduleBuilder.Create()
.OnDaysOfTheWeek(new DayOfWeek[] { DayOfWeek.Friday });
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity(nameof(onFriday), "Lunch Bot")
.WithSchedule(onFriday)
.Build();
// Tell quartz to schedule the job using our trigger
await scheduler.ScheduleJob(job, trigger);
}
/// <summary>
/// Create a workflow based on the job and settings objects provided. This will create an AutoSave workflow if the
/// job's printer has an AutoSave profile associated or the default profile uses AutoSave.
/// Otherwise, an interactive workflow will be created.
/// 基于提供的作业和设置对象创建工作流。如果作业的打印机关联了自动保存配置文件或默认配置文件使用自动保存，
/// 则此操作将创建自动保存工作流。否则，将创建交互式工作流。
/// </summary>
/// <param name="jobInfo">The jobinfo used for the decision</param>
/// <param name="settings">The settings used for the decision</param>
/// <returns>A ConversionWorkflow either for AutoSave or interactive use</returns>
public static ConversionWorkflow CreateWorkflow(IJobInfo jobInfo, clawPDFSettings settings)
{
Logger.Trace("Creating Workflow");
var preselectedProfile = PreselectedProfile(jobInfo, settings).Copy();
Logger.Debug("Profile: {0} (GUID {1})", preselectedProfile.Name, preselectedProfile.Guid);
var jobTranslations = new JobTranslations();
jobTranslations.EmailSignature = MailSignatureHelper.ComposeMailSignature();
var job = JobFactory.CreateJob(jobInfo, preselectedProfile, JobInfoQueue.Instance, jobTranslations);
job.AutoCleanUp = true;
if (preselectedProfile.AutoSave.Enabled)
{
Logger.Trace("Creating AutoSaveWorkflow");
return(new AutoSaveWorkflow(job, settings));
}
Logger.Trace("Creating InteractiveWorkflow");
return(new InteractiveWorkflow(job, settings));
}
/// <summary>
/// Register a job for a calendar event as specified by the <paramref name="predicate"/>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="predicate">Predicate filter calendar events.</param>
/// <param name="factory">Factory for creating job after a match has been found.</param>
/// <param name="job">Job method that will be ran when event starts.</param>
public Task RegisterEvent <T>(EventPredicate predicate, JobFactory factory, Job <T> job) where T : IJob
{
jobPredicates.Add(predicate);
jobFactories.Add(factory);
return(JobModule.RegisterJobAsync(job));
}
private void InitializeJobs()
{
_jobFactory = new JobFactory();
_jobConverter = new JobConverter(_jobFactory, _skillConverter, _toolConverter, _zoneConverter);
_jobs = new ConcurrentDictionary <int, IJob>();
_activitiesMap = new ConcurrentDictionary <int, IActivity>();
_scheduledJobs = new ConcurrentDictionary <Guid, IActivitySchedule>();
}
public void OneTimeSetup()
{
queue = client.GetQueueReference("producertest");
factory = new JobFactory();
factory.RegisterJobType(typeof(HelloWho));
factory.RegisterJobType(typeof(MockJob));
}
public void Setup()
{
factory = new JobFactory();
factory.RegisterJobType(typeof(HelloWho));
factory.RegisterJobType(typeof(MockJob));
factory.RegisterJobType(typeof(NoopJob));
}
public MainSimulator(List <IBot> bots, ISimulationRunner simulationRunner, JobFactory jobFactory)
{
Bots = bots;
SimulationRunner = simulationRunner;
_assignedBots = new List <Bot>();
JobFactory = jobFactory;
CreateBotCharacters(bots);
}
public void OneTimeSetup()
{
queue = client.GetQueueReference("producertest");
factory = new JobFactory();
factory.RegisterJobType(typeof(HelloWho));
factory.RegisterJobType(typeof(MockJob));
}
public void Given_work_item()
{
var definition = JobFactory.Interval("Foo1", () =>
{
return(Task.Factory.StartNew(() => Console.WriteLine("Foo1")));
}, TimeSpan.FromMinutes(10));
_item = new JobItem(new DefaultSchedulerContext(), definition, null);
}
private async Task Start(JobEntity jobView)
{
var jobRuntime = await JobFactory.CreateJobRuntime(_serviceRoute, jobView);
JobDataMap map = new JobDataMap
{
new KeyValuePair <string, object> ("JobRuntime", jobRuntime)
};
IJobDetail job = JobBuilder.Create().OfType(typeof(JobImplementation)).WithIdentity(jobView.Id).UsingJobData(map).Build();
_scheduler.ListenerManager.AddJobListener(new JobListener(jobView.Id, JobWasExecuteCallBack), KeyMatcher <JobKey> .KeyEquals(new JobKey(jobView.Id)));
if (!jobView.IsSimple)
{
if (!ValidExpression(jobView.CronExpression))
{
throw new Exception("cron表达式验证失败");
}
var trigger = new CronTriggerImpl
{
CronExpressionString = jobView.CronExpression,
Name = jobView.Name,
Key = new TriggerKey(jobView.Id),
Description = jobView.Remark
};
if (jobView.StartTime.HasValue)
{
trigger.StartTimeUtc = Utils.ConvertToDateTimeOffset(jobView.StartTime.Value);
}
if (jobView.EndTime.HasValue)
{
trigger.EndTimeUtc = Utils.ConvertToDateTimeOffset(jobView.EndTime.Value);
}
await _scheduler.ScheduleJob(job, trigger);
}
else
{
var triggerBuilder = TriggerBuilder.Create().WithIdentity(jobView.Id).WithSimpleSchedule(x => x.WithRepeatCount(jobView.RepeatCount).WithInterval(TimeSpan.FromSeconds(jobView.IntervalSeconds)));
if (jobView.StartTime.HasValue)
{
var start = Utils.ConvertToDateTimeOffset(jobView.StartTime.Value);
triggerBuilder = triggerBuilder.StartAt(start);
}
if (jobView.EndTime.HasValue)
{
var end = Utils.ConvertToDateTimeOffset(jobView.EndTime.Value);
triggerBuilder = triggerBuilder.EndAt(end);
}
var trigger = triggerBuilder.Build();
await _scheduler.ScheduleJob(job, trigger);
}
_logger.Info($"job [{jobView.Id}]{jobView.Name} start success");
}
public static JobItem Create(ISchedulerContext ctx)
{
var definition = JobFactory.Interval("Foo1", () =>
{
return(Task.Factory.StartNew(() => Console.WriteLine("Foo1")));
}, TimeSpan.FromMinutes(10), "Some");
return(new InlineScheduler.Advanced.JobItemFactory(ctx).Create(definition));
}
public static async void UseQuartz(this IApplicationBuilder app)
{
IScheduler scheduler = app.ApplicationServices.GetService <IScheduler>();
var jobFactory = new JobFactory(app.ApplicationServices);
scheduler.JobFactory = jobFactory;
await scheduler.Start();
}
public override void Execute(string[] commandParams, IRepository repository)
{
var jobName = commandParams[1];
var jobHours = int.Parse(commandParams[2]);
var employee = repository.GetEmployee(commandParams[3]);
var job = JobFactory.CreateJob(jobName, jobHours, employee);
repository.AddJob(jobName, job);
}
static void Main(string[] args)
{
IOffice office = new Office();
IEmployeeFactory employeeFactory = new EmployeeFactory();
IJobFactory jobFactory = new JobFactory();
IRunnable engine = new Engine(office, employeeFactory, jobFactory);
engine.Run();
}
/// <summary>
/// 初始化
/// 包括 定时器的初始化 作业的初始化 配置的初始化
/// </summary>
internal void Init()
{
#region 清空
if (mainTimer != null)
{
mainTimer.Stop();
mainTimer.Elapsed -= MainTimer_Elapsed;
mainTimer.Dispose();
mainTimer = null;
}
mainTimer = new Timer
{
Interval = 1000,
Enabled = false,
};
if (taskModelList != null)
{
foreach (BaseJob item in taskModelList)
{
item.Dispose();
}
}
if (taskCollection != null)
{
foreach (Task item in taskCollection)
{
item.Dispose();
}
}
#endregion
ReadConfig readConfig = new ReadConfig();
//判断是否有异常
if (readConfig.IsException)
{
return;
}
GlobalObject.RichTextLog.AppendTextByAsync("配置加载完成！", Color.Black);
BaseJob model = null;
//根据配置数量进行初始化作业
foreach (SourceConfig item in readConfig._SourceConfig)
{
foreach (TableConfig tableConfig in item.TableConfigList)
{
model = JobFactory.CreateJob(tableConfig);
model.InitTask();
taskModelList.Add(model);
}
}
GlobalObject.RichTextLog.AppendTextByAsync("任务初始化完成！", Color.Black);
mainTimer.Elapsed += MainTimer_Elapsed;
}
public void OneTimeSetup()
{
CloudQueueClient client = StorageAccount.Get().CreateCloudQueueClient();
queue = client.GetQueueReference("jobexecutioncontexttest");
queue.CreateIfNotExists();
factory = new JobFactory();
factory.RegisterJobType(typeof(HelloWho));
factory.RegisterJobType(typeof(MockJob));
}
public SolverDataManager(ProjectDataSet model, ConstraintSolverResult data)
{
_model = model;
_solverResult = data;
var jobFactory = new JobFactory();
var skillFactory = new SkillFactory();
var workerFactory = new WorkerFactory();
var toolFactory = new ToolFactory();
var zoneFactory = new ZoneFactory();
var shiftFactory = new ShiftFactory();
var shiftConverter = new ShiftConverter(shiftFactory);
var skillConverter = new SkillConverter(skillFactory);
var toolConverter = new ToolConverter(toolFactory, shiftConverter);
var zoneConverter = new ZoneConverter(zoneFactory);
var laborConverter = new LaborConverter(workerFactory, shiftConverter, skillConverter);
var jobConverter = new JobConverter(jobFactory, skillConverter, toolConverter, zoneConverter);
_shiftManager = new ShiftManager(shiftConverter, skillConverter, laborConverter, toolConverter);
_jobManager = new JobManager(jobConverter);
_zoneManager = new ZoneManager(zoneConverter);
}
private void InitializeJobs()
{
_jobFactory = new JobFactory();
_jobConverter = new JobConverter(_jobFactory, _skillConverter, _toolConverter, _zoneConverter);
_jobs = new ConcurrentDictionary<int, IJob>();
_activitiesMap = new ConcurrentDictionary<int, IActivity>();
_scheduledJobs = new ConcurrentDictionary<Guid, IActivitySchedule>();
}
/// <summary>
/// Call once during application start up.
/// </summary>
/// <returns>A list of executable jobs, or Null if no plug-ins were found.</returns>
public List<iJob> Initialize()
{
List<iJob> jobs = new List<iJob>();
foreach (iPluginFactory factory in _plugins)
{
try
{
string name = factory.GetType().Module.Assembly.GetName().Name.Replace(".plugin", "");
PluginSettings settings = _storage.Find(factory.getID());
JobFactory jobFactory = new JobFactory(name, settings);
factory.StartUp(settings);
factory.Create(jobFactory, settings);
jobs.AddRange(jobFactory.Jobs.Values);
}
catch (Exception e)
{
_logger.Exception(e);
factory.ShutDown();
}
}
return jobs;
}
public void OneTimeSetup()
{
CloudQueueClient client = CloudStorageAccount.DevelopmentStorageAccount.CreateCloudQueueClient();
queue = client.GetQueueReference("jobexecutioncontexttest");
queue.CreateIfNotExists();
factory = new JobFactory();
factory.RegisterJobType(typeof(HelloWho));
factory.RegisterJobType(typeof(MockJob));
}
public void OneTimeSetup()
{
factory = new JobFactory();
factory.RegisterJobType(typeof(HelloWho));
factory.RegisterJobType(typeof(MockJob));
}
