private Uri BuildTaskCallbackUri(ConfiguredTask taskConfig, long occurrence)
{
if (!taskConfig.Url.IsAbsoluteUri && _context != null && _context.Request != null)
{
string callbackUrlLeftPart = $"{_context.Request.Scheme}{UriKeys.SchemeDelimiter}{_context.Request.Host.ToUriComponent()}";
return(new Uri(string.Concat(
callbackUrlLeftPart,
_recurringTaskHandlerAbsolutePath,
taskConfig.Identifier,
"/",
occurrence.ToString(CultureInfo.InvariantCulture)
), UriKind.Absolute));
}
return(new Uri(string.Concat(
taskConfig.Url.Scheme,
UriKeys.SchemeDelimiter,
taskConfig.Url.Authority,
_recurringTaskHandlerAbsolutePath,
taskConfig.Identifier,
"/",
occurrence.ToString(CultureInfo.InvariantCulture)
)));
}
private CallbackRequest PrepareNextCallback(ConfiguredTask taskConfig)
{
long occurrence = taskConfig.GetNextOccurrence();
Uri callbackUri = BuildTaskCallbackUri(taskConfig, occurrence);
DateTimeOffset callbackTime = new DateTimeOffset(occurrence, TimeSpan.Zero);
return(new CallbackRequest(callbackTime, callbackUri));
}
internal bool TryGetTask(string identifier, out ConfiguredTask taskConfig)
{
if (string.IsNullOrEmpty(identifier))
{
taskConfig = null;
return(false);
}
return(_taskCollection.TryGetTask(identifier, out taskConfig));
}
async Task AddTaskAsync(IClockSource clockSource, PeriodicityType periodicity, int day, int hour, int minute, Uri url)
{
using (var taskBuilder = new TaskBuilder(CallbackBaseUri))
{
ConfiguredTask taskConfig = taskBuilder.Create(clockSource, periodicity, day, hour, minute, url);
if (await _taskCollection.AddAsync(taskConfig))
{
if (CallbackBaseUri == null)
{
ScavengeForCallbackBaseUri(taskConfig.Url);
}
await Schedule(PrepareNextCallback(taskConfig));
if (!_currentState.IsActive)
{
await Start();
}
}
}
}
public async Task <bool> AddAsync(ConfiguredTask taskConfig)
{
// A proper immutable dictionary class would simplify this routine
RandomWaitScheduler retryScheduler = null;
do
{
Dictionary <string, ConfiguredTask> original = _Tasks;
if (!original.ContainsKey(taskConfig.Identifier))
{
var clone = new Dictionary <string, ConfiguredTask>(original);
if (!clone.ContainsKey(taskConfig.Identifier))
{
clone.Add(taskConfig.Identifier, taskConfig);
if (!object.ReferenceEquals(Interlocked.CompareExchange(ref _Tasks, clone, original), original))
{
if (retryScheduler == null)
{
retryScheduler = new RandomWaitScheduler();
}
await retryScheduler.Wait();
continue;
}
return(true);
}
}
return(false);
} while (true);
}
public bool TryGetTask(string identifier, out ConfiguredTask taskConfig) => _Tasks.TryGetValue(identifier, out taskConfig);
public async Task <bool> RemoveAsync(ConfiguredTask taskConfig) => await RemoveAsync(taskConfig.Identifier);
internal async Task Reschedule(ConfiguredTask taskConfig)
{
await Schedule(PrepareNextCallback(taskConfig));
}
