internal ScheduledJob(JobScheduler scheduler,
string name,
IJobSchedule schedule,
IProducerMethodJobQueue queue,
Expression<Action<IReceivedMessage<MessageExpression>, IWorkerNotification>> actionToRun,
IGetTime time,
string route)
{
_scheduler = scheduler;
Name = name;
Schedule = schedule;
_queue = queue;
_actionToRun = actionToRun;
_getTime = time;
Route = route;
}
internal ScheduledJob(JobScheduler scheduler,
string name,
IJobSchedule schedule,
IProducerMethodJobQueue queue,
LinqExpressionToRun expressionToRun,
IGetTime time,
string route
)
{
_scheduler = scheduler;
Name = name;
Schedule = schedule;
_queue = queue;
_expressionToRun = expressionToRun;
_getTime = time;
Route = route;
}
public override void Run()
{
// This is a sample worker implementation. Replace with your logic.
Trace.WriteLine("SqlAzureBackup.Worker entry point called", "Information");
Trace.WriteLine("Setting up jobs", "Info");
var jobScheduler = new JobScheduler<SqlAzureBackupJobContext>(
blobNextExecutionTimeName: "sql-azure-backups/azure-backup-next-execution-time.txt",
jobContext: new SqlAzureBackupJobContext(),
frequency: new TimeSpan(AzureHelper.BackupFrequencyInHours, 0, 0));
jobScheduler.AddJob(new ResolveDatacenterJob());
jobScheduler.AddJob(new ExportBacpacJob());
jobScheduler.AddJob(new CheckBacpacStatusJob());
jobScheduler.AddJob(new SendFileViaFTP());
Trace.WriteLine("Starting the WorkerRole loop", "Info");
while (true)
{
jobScheduler.TryExecuteJobs();
Thread.Sleep(1000);
}
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
JobScheduler.Start();
}
public void StartSendPayDayStatusJob()
{
JobScheduler.IsPayDayStatusSent = true;
JobScheduler.StartSendPayDayStatusJob();
}
public void NotifyRenewSubscription()
{
JobScheduler.IsRenewSubscriptionNotification = true;
JobScheduler.StartSubscriptonRenwalNotificationJob();
}
private PageCache RulePageCache(Config dbConfig, FileSystemAbstraction fs, JobScheduler scheduler)
{
return(_rulePageCache = GetOrCreatePageCache(dbConfig, fs, scheduler));
}
public async void RunJobOnce()
{
var cts = new CancellationTokenSource();
var clock = new Clock(new DateTime(1970, 1, 1));
var delay = new Delay();
var scheduler = JobScheduler <string> .Start(cts.Token, clock.GetCurrentTime, delay.Start);
var jobStarted = WaitEventAsync <JobStartedEventArgs <string> >(h => scheduler.JobStarted += h, h => scheduler.JobStarted -= h);
var jobEnded = WaitEventAsync <JobEndedEventArgs <string> >(h => scheduler.JobEnded += h, h => scheduler.JobEnded -= h);
var jobRemoved = WaitEventAsync <JobRemovalEventArgs <string> >(h => scheduler.JobRemoved += h, h => scheduler.JobRemoved -= h);
const string id = "foo";
var ran = false;
var thisThread = Thread.CurrentThread;
Thread jobThread = null;
scheduler.AddJob(id, clock.Time.AddSeconds(1), _ =>
{
ran = true;
jobThread = Thread.CurrentThread;
return(Task.FromResult(0));
});
clock.Time += TimeSpan.FromSeconds(1);
delay.Done();
await await Task.WhenAny(jobStarted, scheduler.Task);
Assert.False(scheduler.Task.IsCompleted);
Assert.Equal(TimeSpan.FromSeconds(1), delay.Duration);
var jobStartedEventArgs = await jobStarted;
Assert.NotNull(jobStartedEventArgs);
Assert.Equal(id, jobStartedEventArgs.Job);
Assert.Equal(clock.Time, jobStartedEventArgs.StartTime);
await jobStartedEventArgs.Task;
Assert.True(ran);
Assert.NotEqual(thisThread, jobThread);
await await Task.WhenAny(jobEnded, scheduler.Task);
Assert.False(scheduler.Task.IsCompleted);
var jobEndedEventArgs = await jobEnded;
Assert.NotNull(jobEndedEventArgs);
Assert.Equal(jobStartedEventArgs.Job, jobEndedEventArgs.Job);
Assert.Equal(jobStartedEventArgs.Task, jobEndedEventArgs.Task);
Assert.Equal(clock.Time, jobEndedEventArgs.EndTime);
await await Task.WhenAny(jobRemoved, scheduler.Task);
Assert.False(scheduler.Task.IsCompleted);
var jobRemovedEventArgs = await jobRemoved;
Assert.NotNull(jobRemovedEventArgs);
Assert.Equal(jobStartedEventArgs.Job, jobRemovedEventArgs.Job);
Assert.Equal(JobRemovalReason.EndOfSchedule, jobRemovedEventArgs.Reason);
cts.Cancel();
await scheduler.Task;
}
protected override void OnStop()
{
EventLog.WriteEntry("CitySourcedScheduler", "Stopping CitySourced.Scheduler Service", EventLogEntryType.Information);
JobScheduler.Stop();
}
public static void StartScheduler(bool loadFromDatabase)
{
JobScheduler.Start(loadFromDatabase);
ConsoleLogger.Log(" scheduler -> loaded");
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void start() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void Start()
{
_jobScheduler = new ThreadPoolJobScheduler();
_stores = BatchingNeoStores.batchingNeoStores(_fileSystemRule.get(), _directory.absolutePath(), Format, _config, NullLogService.Instance, AdditionalInitialIds.EMPTY, Config.defaults(), _jobScheduler);
_stores.createNew();
}
public LockingExecutor(JobScheduler jobScheduler, Group group)
{
this._jobScheduler = jobScheduler;
this._group = group;
}
public TaskService(JobScheduler jobScheduler)
{
_jobScheduler = jobScheduler;
}
internal DynamicLoggingQueryExecutionMonitor(Config config, FileSystemAbstraction fileSystem, JobScheduler scheduler, Log debugLog)
{
this._config = config;
this._fileSystem = fileSystem;
this._scheduler = scheduler;
this._debugLog = debugLog;
}
public void Scheduler_GetData()
{
JobScheduler sch = new JobScheduler();
sch.GetData(sch.Context);
}
public RobustJobSchedulerWrapper(JobScheduler @delegate, Log log)
{
this.@delegate = @delegate;
this._log = log;
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
AutoMapperWebConfig.Configure();
JobScheduler.Start();
//ServicePointManager.ServerCertificateValidationCallback =
// new RemoteCertificateValidationCallback(delegate { return true; });
System.Net.ServicePointManager.ServerCertificateValidationCallback +=
delegate(object sender, System.Security.Cryptography.X509Certificates.X509Certificate certificate,
System.Security.Cryptography.X509Certificates.X509Chain chain,
System.Net.Security.SslPolicyErrors sslPolicyErrors)
{
return(true); // **** Always accept
};
string UploadResultPDF = Server.MapPath(string.Concat("~/PDF/", Constants.UploadResultPDF));
string UploadTestsPDF = Server.MapPath(string.Concat("~/PDF/", Constants.UploadTestsPDF));
string UploadTestsLogo = Server.MapPath(string.Concat("~/Images/", Constants.UploadTestsLogo));
//string UploadAssignmentsPDF = Server.MapPath(string.Concat("~/PDF/", Constants.UploadAssignmentsPDF));
//string UploadAssignmentsLogo = Server.MapPath(string.Concat("~/Images/", Constants.UploadAssignmentsLogo));
string UploadNewsPDF = Server.MapPath(string.Concat("~/PDF/", Constants.UploadNewsPDF));
string WriteBlogPDF = Server.MapPath(string.Concat("~/PDF/", Constants.WriteBlog));
string BlogImage = Server.MapPath(string.Concat("~/Images/", Constants.BlogImage));
string StudentImagePath = Server.MapPath(string.Concat("~/Images/", Constants.StudentImageFolder));
string StudentTimeTableFile = Server.MapPath(string.Concat("~/PDF/", Constants.StudentTimeTableFile));
string DailyPracticePaperFile = Server.MapPath(string.Concat("~/PDF/", Constants.DailyPracticePaperFile));
if (!Directory.Exists(UploadResultPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadResultPDF);
}
string UploadNotesPDF = Server.MapPath(string.Concat("~/StudentAppPDF/", Constants.UploadNotesPDF));
if (!Directory.Exists(UploadNotesPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadNotesPDF);
}
string UploadNotesLogo = Server.MapPath(string.Concat("~/Images/", Constants.UploadNotesLogo));
if (!Directory.Exists(UploadNotesLogo))
{
DirectoryInfo di = Directory.CreateDirectory(UploadNotesLogo);
}
string UploadAssignmentsPDF = Server.MapPath(string.Concat("~/StudentAppPDF/", Constants.UploadAssignmentsPDF));
if (!Directory.Exists(UploadAssignmentsPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadAssignmentsPDF);
}
string UploadAssignmentsLogo = Server.MapPath(string.Concat("~/Images/", Constants.UploadAssignmentsLogo));
if (!Directory.Exists(UploadAssignmentsLogo))
{
DirectoryInfo di = Directory.CreateDirectory(UploadAssignmentsLogo);
}
string UploadTextbooksPDF = Server.MapPath(string.Concat("~/StudentAppPDF/", Constants.UploadTextbooksPDF));
if (!Directory.Exists(UploadTextbooksPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadTextbooksPDF);
}
string UploadTextbooksLogo = Server.MapPath(string.Concat("~/Images/", Constants.UploadTextbooksLogo));
if (!Directory.Exists(UploadTextbooksLogo))
{
DirectoryInfo di = Directory.CreateDirectory(UploadTextbooksLogo);
}
string UploadInbuiltquestionbankPDF = Server.MapPath(string.Concat("~/StudentAppPDF/", Constants.UploadInbuiltquestionbankPDF));
if (!Directory.Exists(UploadInbuiltquestionbankPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadInbuiltquestionbankPDF);
}
string UploadInbuiltquestionbankLogo = Server.MapPath(string.Concat("~/Images/", Constants.UploadInbuiltquestionbankLogo));
if (!Directory.Exists(UploadInbuiltquestionbankLogo))
{
DirectoryInfo di = Directory.CreateDirectory(UploadInbuiltquestionbankLogo);
}
string UploadPracticepapersPDF = Server.MapPath(string.Concat("~/StudentAppPDF/", Constants.UploadPracticepapersPDF));
if (!Directory.Exists(UploadPracticepapersPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadPracticepapersPDF);
}
string UploadPracticepapersLogo = Server.MapPath(string.Concat("~/Images/", Constants.UploadPracticepapersLogo));
if (!Directory.Exists(UploadPracticepapersLogo))
{
DirectoryInfo di = Directory.CreateDirectory(UploadPracticepapersLogo);
}
string UploadQuestionpapersPDF = Server.MapPath(string.Concat("~/StudentAppPDF/", Constants.UploadQuestionpapersPDF));
if (!Directory.Exists(UploadQuestionpapersPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadQuestionpapersPDF);
}
string UploadQuestionpapersLogo = Server.MapPath(string.Concat("~/Images/", Constants.UploadQuestionpapersLogo));
if (!Directory.Exists(UploadQuestionpapersLogo))
{
DirectoryInfo di = Directory.CreateDirectory(UploadQuestionpapersLogo);
}
string UploadReferencebooksPDF = Server.MapPath(string.Concat("~/StudentAppPDF/", Constants.UploadReferencebooksPDF));
if (!Directory.Exists(UploadReferencebooksPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadReferencebooksPDF);
}
string UploadReferencebooksLogo = Server.MapPath(string.Concat("~/Images/", Constants.UploadReferencebooksLogo));
if (!Directory.Exists(UploadReferencebooksLogo))
{
DirectoryInfo di = Directory.CreateDirectory(UploadReferencebooksLogo);
}
if (!Directory.Exists(UploadTestsPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadTestsPDF);
}
if (!Directory.Exists(UploadTestsLogo))
{
DirectoryInfo di = Directory.CreateDirectory(UploadTestsLogo);
}
/*if (!Directory.Exists(UploadAssignmentsPDF))
* {
* DirectoryInfo di = Directory.CreateDirectory(UploadAssignmentsPDF);
* }
* if (!Directory.Exists(UploadAssignmentsLogo))
* {
* DirectoryInfo di = Directory.CreateDirectory(UploadAssignmentsLogo);
* }*/
if (!Directory.Exists(UploadNewsPDF))
{
DirectoryInfo di = Directory.CreateDirectory(UploadNewsPDF);
}
if (!Directory.Exists(WriteBlogPDF))
{
DirectoryInfo di = Directory.CreateDirectory(WriteBlogPDF);
}
string StudentImageFolder = Server.MapPath(string.Concat("~/Images/", Constants.StudentImageFolder));
if (!Directory.Exists(StudentImageFolder))
{
DirectoryInfo di = Directory.CreateDirectory(StudentImageFolder);
}
string UploadPhotos = Server.MapPath(string.Concat("~/Images/", Constants.UploadPhotos));
if (!Directory.Exists(UploadPhotos))
{
DirectoryInfo di = Directory.CreateDirectory(UploadPhotos);
}
if (!Directory.Exists(BlogImage))
{
DirectoryInfo di = Directory.CreateDirectory(BlogImage);
}
if (!Directory.Exists(StudentImagePath))
{
DirectoryInfo di = Directory.CreateDirectory(StudentImagePath);
}
string QuestionImagePath = Server.MapPath(string.Concat("~/Images/", Constants.QuestionImageFolder));
if (!Directory.Exists(QuestionImagePath))
{
DirectoryInfo di = Directory.CreateDirectory(QuestionImagePath);
}
string PdfFilePath = Server.MapPath(string.Concat("~/PDF/", Constants.PdfFileFolder));
if (!Directory.Exists(PdfFilePath))
{
DirectoryInfo di = Directory.CreateDirectory(PdfFilePath);
}
string BrochureFilePath = Server.MapPath(string.Concat("~/PDF/", Constants.BrochureFolder));
if (!Directory.Exists(BrochureFilePath))
{
DirectoryInfo di = Directory.CreateDirectory(BrochureFilePath);
}
string SMSFileFolder = Server.MapPath(string.Concat("~/Images/", Constants.SMSFileFolder));
if (!Directory.Exists(SMSFileFolder))
{
DirectoryInfo di = Directory.CreateDirectory(SMSFileFolder);
}
if (!Directory.Exists(StudentTimeTableFile))
{
DirectoryInfo di = Directory.CreateDirectory(StudentTimeTableFile);
}
if (!Directory.Exists(DailyPracticePaperFile))
{
DirectoryInfo di = Directory.CreateDirectory(DailyPracticePaperFile);
}
}
// callback 返回 true 表示停止重试或完成
public static void ReadRemoteFile(IList <string> urls, string filename, Func <string, bool> callback)
{
JobScheduler.DispatchCoroutine(_ReadRemoteFile(urls, filename, callback));
}
public TimerService(JobScheduler scheduler, LogProvider logProvider)
{
this.Scheduler = scheduler;
this._log = logProvider.getLog(this.GetType());
}
private void StartCheckSessionThread()
{
this.jobScheduler = new JobScheduler(TimeSpan.FromSeconds(2), new Action(async() => { await this.CheckSessionStatus(); }));
this.jobScheduler.Start();
}
public JobSchedulerDependcenyService()
{
jobScheduler = (JobScheduler)MainActivity.Instance.GetSystemService(Android.Content.Context.JobSchedulerService);
}
protected void Application_Start(object sender, EventArgs e)
{
JobScheduler.IniciaEnvioCorreos();
JobScheduler.IniciaVerificaCorreos();
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//var settingsConnectionString = Configuration["SettingsConnString"];
//var settingsContainer = Configuration["SettingsContainerName"];
//var settingsFileName = Configuration["SettingsFileName"];
var connectionStringLogs = Configuration["LogsConnString"];
var settingsUrl = Configuration["SettingsUrl"];
Log = new LogToTable(new AzureTableStorage <LogEntity>(connectionStringLogs, "LogCompPlatform", null));
try
{
//Settings = GeneralSettingsReader.ReadGeneralSettings<BaseSettings>(settingsConnectionString, settingsContainer, settingsFileName);
Settings = GeneralSettingsReader.ReadGeneralSettingsFromUrl <BaseSettings>(settingsUrl);
services.AddSingleton(Settings);
}
catch (Exception ex)
{
Log.WriteErrorAsync("Startup", "ReadSettingsFile", "Reading Settings File", ex).Wait();
}
var connectionString = Settings.LykkeStreams.Azure.StorageConnString;
CheckSettings(Settings, Log);
try
{
// Add framework services.
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddAuthentication(
options => { options.SignInScheme = CookieAuthenticationDefaults.AuthenticationScheme; });
//var notificationEmailsQueueConnString = "";
var notificationSlackQueueConnString = Settings.SlackNotifications.AzureQueue.ConnectionString;
services.AddApplicationInsightsTelemetry(Configuration);
var builder = services.AddMvc();
builder.AddMvcOptions(o => { o.Filters.Add(new GlobalExceptionFilter(Log, notificationSlackQueueConnString)); });
services.RegisterLyykeServices();
//if (HostingEnvironment.IsProduction() && !string.IsNullOrEmpty(notificationEmailsQueueConnString) &&
// !string.IsNullOrEmpty(notificationSlackQueueConnString))
//{
// services.RegisterEmailNotificationServices(notificationEmailsQueueConnString);
//}
//else
//{
services.RegisterInMemoryNotificationServices();
//}
services.Configure <ForwardedHeadersOptions>(options =>
{
options.ForwardedHeaders = ForwardedHeaders.XForwardedProto;
});
services.RegisterRepositories(connectionString, Log);
JobScheduler.Start(connectionString, Log);
}
catch (Exception ex)
{
Log.WriteErrorAsync("Startup", "RegisterServices", "Registering Repositories and services", ex).Wait();
}
}
private void ObjectSpace_Committed(object sender, EventArgs e)
{
JobScheduler?.ScheduleDataExtractCreationJob(ViewCurrentObject);
}
public IndexSamplingControllerFactory(IndexSamplingConfig config, IndexStoreView storeView, JobScheduler scheduler, TokenNameLookup tokenNameLookup, LogProvider logProvider)
{
this._config = config;
this._storeView = storeView;
this._scheduler = scheduler;
this._tokenNameLookup = tokenNameLookup;
this._logProvider = logProvider;
}
private static PageCache GetOrCreatePageCache(Config config, FileSystemAbstraction fs, JobScheduler jobScheduler)
{
Log log = NullLog.Instance;
ConfiguringPageCacheFactory pageCacheFactory = new ConfiguringPageCacheFactory(fs, config, NULL, Org.Neo4j.Io.pagecache.tracing.cursor.PageCursorTracerSupplier_Fields.Null, log, EmptyVersionContextSupplier.EMPTY, jobScheduler);
return(pageCacheFactory.OrCreatePageCache);
}
protected void Application_Start(object sender, EventArgs e)
{
JobScheduler.Start();
}
public void StartTestScheduler()
{
JobScheduler.IsStarted = true;
JobScheduler.Start();
}
public void TestFileWrong()
{
var actual = new JobScheduler().ScheduleWrong(GetTestFile());
}
public void RenewSubscription()
{
JobScheduler.IsRenewSubscription = true;
JobScheduler.StartRenewSubscriptonJob();
}
public static void StartTaskScheduler(Guid id)
{
if (scheduler != null)
{
scheduler.Stop();
scheduler = null;
}
scheduler = new JobScheduler();
scheduler.TimerInterval = 60000;//30 phút
string status = string.Empty;
JobItem task = new JobItem();
var service = new BaseService();
var lstObj = new List<object>();
List<Sys_AutoBackup> listAutoBackup = new List<Sys_AutoBackup>();
var lstAutoBackup = service.GetById<Sys_AutoBackup>(id, ref status);
listAutoBackup.Add(lstAutoBackup);
foreach (var autoBackup in listAutoBackup)
{
scheduler.TaskItems.Add(new JobItem
{
Interval = autoBackup.TimeWaiting == null ? 0 : autoBackup.TimeWaiting.Value,
DateExpired = autoBackup.DateExpired,
DateStart = autoBackup.DateStart.Value,
Description = autoBackup.Description,
IsActivate = autoBackup.IsActivate == null ? false : autoBackup.IsActivate.Value,
LastStart = autoBackup.LastStart,
JobArgs = autoBackup.AutoBackupName
+ "|" + autoBackup.ProcedureName
+ "|" + autoBackup.Email,
JobType = autoBackup.AutoBackupName,
JobItemType = typeof(Task_AutoBackup),
Type = (SchedulerType)Enum.Parse(typeof(SchedulerType), autoBackup.Type.ToString()),
});
}
scheduler.Start();
}
public void RemindChorePayment()
{
JobScheduler.IsRemindChorePayment = true;
JobScheduler.StartRemindChorePaymentJob();
}
public static void StartTaskSchedulerGlobal()
{
JobScheduler scheduler = new JobScheduler();
scheduler.TimerInterval = 60000;//30 phút
string status = string.Empty;
var service = new BaseService();
var lstObj = new List<object>();
lstObj.Add(null);
lstObj.Add(1);
lstObj.Add(int.MaxValue - 1);
var listAutoBackup = service.GetData<Sys_AutoBackupEntity>(lstObj, ConstantSql.hrm_sys_sp_get_AutoBackup,string.Empty, ref status).ToList();
//var listAutoBackup = new List<Sys_AutoBackupEntity>();
foreach (var autoBackup in listAutoBackup)
{
scheduler.TaskItems.Add(new JobItem
{
Interval = autoBackup.TimeWaiting == null ? 0 : autoBackup.TimeWaiting.Value,
DateExpired = autoBackup.DateExpired,
DateStart = autoBackup.DateStart.Value,
Description = autoBackup.Description,
IsActivate = autoBackup.IsActivate == null ? false : autoBackup.IsActivate.Value,
LastStart = autoBackup.LastStart,
JobArgs = autoBackup.AutoBackupName
+ "|" + autoBackup.ProcedureName
+ "|" + autoBackup.Email,
JobType = autoBackup.AutoBackupName,
JobItemType = typeof(Task_AutoBackup),
Type = (SchedulerType)Enum.Parse(typeof(SchedulerType), autoBackup.Type.ToString()),
});
}
scheduler.Start();
}
/// <summary>
/// Cancels currently running job
/// </summary>
private static void ProcessCancelCommand()
{
JobScheduler.CancelCurrentJob();
}
public void TestFileRight()
{
var actual = new JobScheduler().ScheduleRight(GetTestFile());
}
