public override ServerName Execute([NotNull] object jobContext,
[NotNull] JobCancellationManager jobCancellationManager)
{
if (jobContext == null)
{
throw new ArgumentNullException(nameof(jobContext));
}
if (jobCancellationManager == null)
{
throw new ArgumentNullException(nameof(jobCancellationManager));
}
var getServerAtDateJob = jobContext as GetServerAtDateJob;
if (getServerAtDateJob != null)
{
return(TryGetServer(getServerAtDateJob.CharacterName, getServerAtDateJob.DateTime, jobCancellationManager));
}
var getCurrentServerJob = jobContext as GetCurrentServerJob;
if (getCurrentServerJob != null)
{
return(TryGetCurrentServer(getCurrentServerJob.CharacterName, jobCancellationManager));
}
ParsePendingEvents();
persistentLibrary.SaveChanged();
throw new InvalidOperationException("No handler specified for job type: " + jobContext.GetType());
}
/// <summary>
/// True if any data found
/// </summary>
private bool SearchLogsBackwards(DateTime datetimeTo, JobCancellationManager jobCancellationManager)
{
var dateFrom = datetimeTo - TimeSpan.FromDays(30);
if (datetimeTo < wurmCharacterLogFiles.OldestLogFileDate)
{
return(false);
}
var results = logsSearcher.Scan(
new LogSearchParameters()
{
CharacterName = characterName.Normalized,
MinDate = dateFrom,
MaxDate = datetimeTo,
LogType = LogType.Event
}, jobCancellationManager.GetLinkedToken());
UpdateEntity(dateFrom, datetimeTo);
var found = ParseForServerInfo(results);
if (found)
{
return(true);
}
return(SearchLogsBackwards(dateFrom, jobCancellationManager));
}
public QueuedJobsSyncRunner([NotNull] JobExecutor <TJobContext, TResult> jobExecutor, IWurmApiLogger logger)
{
if (jobExecutor == null)
{
throw new ArgumentNullException(nameof(jobExecutor));
}
this.jobExecutor = jobExecutor;
searchJobTask = new Task((token) =>
{
var internalCancellationToken = cancellationTokenSource.Token;
while (true)
{
var signalled = jobSignaller.WaitOne(jobExecutor.IdleJobTreshhold);
if (internalCancellationToken.IsCancellationRequested)
{
CancelAllRemainingJobs();
return;
}
if (!signalled)
{
try
{
jobExecutor.IdleJob(internalCancellationToken);
}
catch (Exception exception)
{
logger.Log(LogLevel.Error, "Regular job has thrown unhandled exception.", this,
exception);
}
}
ScanJob job;
while (jobQueue.TryDequeue(out job))
{
if (internalCancellationToken.IsCancellationRequested)
{
CancelAllRemainingJobs();
return;
}
try
{
var cancellationManager = new JobCancellationManager(internalCancellationToken,
job.ExternalCancellationToken);
var result = this.jobExecutor.Execute(job.JobContext, cancellationManager);
job.SetResult(result);
}
catch (Exception exception)
{
job.SetException(exception);
}
}
if (internalCancellationToken.IsCancellationRequested)
{
CancelAllRemainingJobs();
return;
}
}
}, TaskCreationOptions.LongRunning);
searchJobTask.Start();
}
public ServerName TryGetAtTimestamp(DateTime timestamp, JobCancellationManager jobCancellationManager)
{
ParsePendingLiveLogEvents();
var timeNow = Time.Get.LocalNow;
var time12MonthsAgo = timeNow.AddMonths(-12);
// a cheap hack to reset history if its very outdated
if (persistentData.Entity.SearchedFrom < time12MonthsAgo &&
persistentData.Entity.SearchedTo < time12MonthsAgo)
{
persistentData.Entity.Reset();
}
if (persistentData.Entity.AnySearchCompleted &&
timestamp >= persistentData.Entity.SearchedFrom &&
timestamp <= persistentData.Entity.SearchedTo)
{
// within already scanned period
ServerName serverName = sortedServerHistory.TryGetServerAtStamp(timestamp);
if (serverName != null)
{
// we have data, return
return(serverName);
}
// no data, we should continue
}
jobCancellationManager.ThrowIfCancelled();
bool found = false;
if (persistentData.Entity.AnySearchCompleted)
{
if (timestamp > persistentData.Entity.SearchedTo)
{
found = SearchLogsForwards(persistentData.Entity.SearchedTo, jobCancellationManager);
}
if (!found || timestamp < persistentData.Entity.SearchedFrom)
{
SearchLogsBackwards(persistentData.Entity.SearchedFrom, jobCancellationManager);
}
}
else
{
found = SearchLogsForwards(timestamp, jobCancellationManager);
if (!found)
{
SearchLogsBackwards(timestamp, jobCancellationManager);
}
persistentData.Entity.AnySearchCompleted = true;
}
persistentData.FlagAsChanged();
return(sortedServerHistory.TryGetServerAtStamp(timestamp));
}
public ServerName TryGetCurrentServer(JobCancellationManager jobCancellationManager)
{
ParsePendingLiveLogEvents();
if (currentLiveLogsServer != null)
{
return(currentLiveLogsServer);
}
return(TryGetAtTimestamp(Time.Get.LocalNow, jobCancellationManager));
}
public override JobResult Execute(Job jobContext, JobCancellationManager jobCancellationManager)
{
var dateTimeJob = jobContext as CurrentWurmDateTimeJob;
if (dateTimeJob != null)
{
var dateTime = TryGetCurrentTime(jobContext.ServerName);
return(new JobResult(dateTime, null));
}
var uptimeJob = jobContext as CurrentUptimeJob;
if (uptimeJob != null)
{
var uptime = TryGetCurrentUptime(jobContext.ServerName);
return(new JobResult(null, uptime));
}
persistentCollectionsLibrary.SaveChanged();
throw new InvalidOperationException("Unknown type of job: " + jobContext.GetType());
}
/// <summary>
/// True if any data found
/// </summary>
private bool SearchLogsForwards(DateTime datetimeFrom, JobCancellationManager jobCancellationManager)
{
var dateFrom = datetimeFrom;
var dateTo = datetimeFrom + TimeSpan.FromDays(30);
var timeNow = Time.Get.LocalNow;
bool end = false;
if (dateTo > timeNow)
{
dateTo = timeNow;
end = true;
}
var results = logsSearcher.Scan(
new LogSearchParameters()
{
CharacterName = characterName.Normalized,
MinDate = dateFrom,
MaxDate = dateTo,
LogType = LogType.Event
}, jobCancellationManager.GetLinkedToken());
UpdateEntity(dateFrom, dateTo);
var found = ParseForServerInfo(results);
if (found)
{
return(true);
}
if (end)
{
return(false);
}
return(SearchLogsForwards(dateTo, jobCancellationManager));
}
ServerName TryGetCurrentServer(CharacterName character, JobCancellationManager jobCancellationManager)
{
ServerHistoryProvider provider = GetServerHistoryProvider(character);
return(provider.TryGetCurrentServer(jobCancellationManager));
}
ServerName TryGetServer(CharacterName character, DateTime exactDate, JobCancellationManager jobCancellationManager)
{
ServerHistoryProvider provider = GetServerHistoryProvider(character);
return(provider.TryGetAtTimestamp(exactDate, jobCancellationManager));
}
/// <summary> /// Executes single job synchronously with other jobs and returns it's result. /// </summary> /// <param name="jobContext">Argument passed to job instance</param> /// <param name="jobCancellationManager">Manager for cancellation requests</param> /// <returns></returns> public abstract TResult Execute(TJobContext jobContext, JobCancellationManager jobCancellationManager);