public FetchFuelInstHhCur(ITaskHelper taskHelper, IElexonDownloader downloader, IDirectory dir, ITime time)
{
_taskHelper = taskHelper;
_scheduler = new Scheduler(time, taskHelper);
_fuelInstHhCur = new FuelInstHhCur(taskHelper, downloader);
_datastoreWriter = new FuelInstHhCur.Writer(taskHelper, dir);
}
public PostBag(ITaskHelper th, ITime time, CmdLineOptions options)
{
_th = th;
_time = time;
_initTcs = new TaskCompletionSource <int>();
th.Run(() => InitAsync(new SystemDirectory(th, options.BlogRootDirectory)));
}
public static IHelperTask GetCleanTask(
this ITaskHelper helper,
string cleanCategory = "",
string targetName = "All",
bool isTarget = true)
{
if (helper == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(targetName))
{
targetName = "All";
}
if (string.IsNullOrWhiteSpace(cleanCategory))
{
cleanCategory = "Generic";
}
cleanCategory = $"Clean-{cleanCategory}";
var taskName = $"{cleanCategory}-{targetName}";
var task = helper.GetTask(taskName, isTarget, "Clean", cleanCategory);
if (targetName == "All")
{
var defaultTask = helper.GetDefaultCleanTask();
helper.AddTaskDependency(defaultTask, task);
}
return(task);
}
// TODO: Make this roll
// Filename format: "{baseName}.0x{sequence ID}.log"
public RollingFileAppender(IDirectory dir, string baseName, ITaskHelper taskHelper)
{
_dir = dir;
_baseName = baseName;
_taskHelper = taskHelper;
_findFileTask = taskHelper.Run(() => FindFileAsync(CancellationToken.None));
}
public static IHelperTask AddToTestTask(
this ITaskHelper helper,
string targetName,
string testCategory,
bool isTarget = true,
string parentTaskName = "")
{
if (string.IsNullOrWhiteSpace(targetName))
{
throw new ArgumentNullException(nameof(targetName));
}
if (string.IsNullOrWhiteSpace(testCategory))
{
throw new ArgumentNullException(nameof(testCategory));
}
if (!isTarget && string.IsNullOrWhiteSpace(parentTaskName))
{
throw new ArgumentNullException(nameof(parentTaskName));
}
var newTaskName = isTarget ? targetName : $"{parentTaskName}-{targetName}";
var parentTask = isTarget
? helper.GetTestTask(testCategory)
: helper.AddToTestTask(parentTaskName, testCategory);
var newTask = helper.GetTestTask(testCategory, newTaskName, isTarget);
helper.AddTaskDependency(parentTask, newTask);
return(newTask);
}
public DataController(
ITaskHelper taskHelper,
Db <FuelInstHhCur.Data> fuelInstHhCur)
{
_taskHelper = taskHelper;
_fuelInstHhCur = fuelInstHhCur;
}
public FetchPhyBmData(ITaskHelper taskHelper, IElexonDownloader downloader, IDirectory dir, ITime time)
{
_taskHelper = taskHelper;
_time = time;
_scheduler = new Scheduler(time, taskHelper);
_phyBmData = new PhyBmData(taskHelper, downloader);
_writer = new PhyBmData.FpnWriter(taskHelper, dir);
}
internal static IHelperTask AddToDocCleanTask(
this ITaskHelper helper,
string targetName,
bool isTarget = true,
string parentTaskName = "")
{
return(helper.AddToCleanTask(targetName, TargetCategory, isTarget, parentTaskName));
}
protected AbstractExample(Settings settings, ITaskHelper taskHelper, ILogger logger)
{
Logger = logger;
TaskHelper = taskHelper;
AwaitableTaskName = $"{GetType().Name}.{settings.AwaitableTaskName}";
AwaitableTaskDurationInSeconds = settings.AwaitableTaskDurationInSeconds;
FireAndForgetTaskName = $"{GetType().Name}.{settings.FireAndForgetTaskName}";
FireAndForgetTaskDurationInSeconds = settings.FireAndForgetTaskDurationInSeconds;
}
public FetchFreq(ITaskHelper taskHelper, IElexonDownloader downloader, IDirectory dir, ITime time)
{
_taskHelper = taskHelper;
_time = time;
_scheduler = new Scheduler(time, taskHelper);
_freq = new Freq(taskHelper, downloader);
_reader = new Freq.Reader(taskHelper, dir);
_writer = new Freq.Writer(taskHelper, dir);
}
public TaskController(ITaskHelper taskHelper)
{
if (taskHelper == null)
{
throw new ArgumentNullException();
}
_taskHelper = taskHelper;
}
public DataStoreWriter(ITaskHelper taskHelper, IDirectory dir, string prefix)
{
_taskHelper = taskHelper;
_dir = dir;
_prefix = prefix;
_factory = Singletons <TFactory> .Instance;
// Find last file, and check to see if it's version-compatible
_appendFileNameTask = _taskHelper.Run(() => AppendFileName(CancellationToken.None));
}
public FetchGasFlow(ITaskHelper taskHelper, ISoapDownloader downloader, IDirectory dir, ITime time)
{
_taskHelper = taskHelper;
_time = time;
_scheduler = new Scheduler(time, taskHelper);
_flow = new InstantaneousFlow(taskHelper, downloader);
_reader = new InstantaneousFlow.Reader(taskHelper, dir);
_writer = new InstantaneousFlow.Writer(taskHelper, dir);
_strings = new Strings(taskHelper, dir);
}
public async Task <T> WriteStringsAsync(ITaskHelper taskHelper, Strings strings)
{
var indexes = new List <long>();
foreach (var s in Strings)
{
indexes.Add(await strings.AddOrGetIndexAsync(s).ConfigureAwait(taskHelper));
}
return(Data.CloneWithStrings(indexes));
}
public SystemDirectory(ITaskHelper taskHelper, string path)
{
TaskHelper = taskHelper;
_path = Path.GetFullPath(path);
if (!Directory.Exists(_path))
{
throw new ArgumentException($"Directory: '{_path}' does not exist, or is not a directory.");
}
_fileProvider = new PhysicalFileProvider(_path);
}
public FetchB1610(ITaskHelper taskHelper, IElexonDownloader downloader, IDirectory dir, ITime time,
string errorLogFilename)
{
_taskHelper = taskHelper;
_time = time;
_scheduler = new Scheduler(time, taskHelper);
_b1610 = new B1610(taskHelper, downloader);
_reader = new B1610.Reader(taskHelper, dir);
_writer = new B1610.Writer(taskHelper, dir);
_errorLogFilename = errorLogFilename;
}
public static async Task <IEnumerable <TResult> > SelectAsync <T, TResult>(
this IEnumerable <T> en, ITaskHelper taskHelper, Func <T, Task <TResult> > fn)
{
List <TResult> result = new List <TResult>();
foreach (var item in en)
{
result.Add(await fn(item).ConfigureAwait(taskHelper));
}
return(result);
}
public DailyTaskWrapper(TaskInfo info, TaskDetail detail, ITaskHelper helper)
{
this.info = info;
this.detail = detail;
this.helper = helper;
var times = detail.Quality - detail.DoneNum;
Debug.Assert(times > 0);
Difficulty = helper.PredictDifficulty(times);
}
internal CommandHelper(
ITaskHelper taskHelper)
{
if (taskHelper == null)
{
throw new ArgumentNullException(nameof(taskHelper));
}
this.TaskHelper = taskHelper;
this.AddDefaultArguments();
}
public LegacyAppApiController(ITaskHelper taskHelper,
Db <FuelInstHhCur.Data> fuelInstDb,
Db <Freq.Data> freqDb,
InstantaneousFlow.Reader gasFlowReader,
Db <InstantaneousFlow.Data> gasFlowDb)
{
_taskHelper = taskHelper;
_fuelInstDb = fuelInstDb;
_freqDb = freqDb;
_gasFlowReader = gasFlowReader;
_gasFlowDb = gasFlowDb;
}
public ServiceController(
IFileHelper fileHelper,
ITaskHelper taskHelper,
IFileValidationService fileValidationService,
IStorageController storageController,
IReportingController reportingController)
{
_fileHelper = fileHelper;
_taskHelper = taskHelper;
_fileValidationService = fileValidationService;
_reportingController = reportingController;
_storageController = storageController;
}
internal static IHelperTask GetDefaultCleanTask(
this ITaskHelper helper)
{
if (helper == null)
{
return(null);
}
var targetName = "All";
var taskName = $"Clean-{targetName}";
return(helper.GetTask(taskName, true, "Clean"));
}
public ApplicationService(
IAppRegistryDataService appRegistryDataService,
IContentRetriever contentRetriever,
IContentProcessorService contentProcessorService,
ITaskHelper taskHelper,
MarkupMessages markupMessages)
{
this.appRegistryDataService = appRegistryDataService;
this.contentRetriever = contentRetriever;
this.contentProcessorService = contentProcessorService;
this.taskHelper = taskHelper;
this.markupMessages = markupMessages;
}
public ApplicationService(
IPathDataService pathDataService,
IRegionService regionService,
IContentRetriever contentRetriever,
IContentProcessorService contentProcessorService,
ITaskHelper taskHelper)
{
this.pathDataService = pathDataService;
this.regionService = regionService;
this.contentRetriever = contentRetriever;
this.contentProcessorService = contentProcessorService;
this.taskHelper = taskHelper;
}
internal static IHelperTask GetDefaultTestTask(
this ITaskHelper helper)
{
if (helper == null)
{
return(null);
}
var targetName = "All";
var taskName = $"{TargetCategory}-{targetName}";
return(helper.GetTask(taskName, true, TargetCategory));
}
public Db(ITaskHelper taskHelper, IReader <T> reader, int requestedBlockSize = 0, Duration?pollInterval = null, Duration?maxJitter = null, bool disableWatch = false)
: base(requestedBlockSize)
{
_taskHelper = taskHelper;
_reader = reader;
_pollInterval = pollInterval ?? Duration.FromMinutes(15);
_maxJitter = maxJitter ?? (_pollInterval / 4);
_enableWatch = !disableWatch;
_cts = new CancellationTokenSource();
_tcs = new TaskCompletionSource <int>();
_rnd = new Random();
// Start load of initial data
taskHelper.Run(ReadAsync);
}
public static TaskAwaitable <T> ConfigureAwaitHideErrors <T>(this ITaskHelper taskHelper, Task <T> task, T resultOnError)
{
async Task <T> Inner()
{
try
{
return(await taskHelper.ConfigureAwait(task));
}
catch
{
return(resultOnError);
}
}
return(taskHelper.ConfigureAwait(Inner()));
}
internal static IHelperTask GetDocCleanTask(
this ITaskHelper helper,
string targetName = "All",
bool isTarget = true)
{
if (helper == null)
{
return(null);
}
if (string.IsNullOrWhiteSpace(targetName))
{
targetName = "All";
}
return(helper.GetCleanTask(TargetCategory, targetName, isTarget));
}
public static TaskAwaitable <Exception> ConfigureAwaitHideErrors(this ITaskHelper taskHelper, Func <Task> task)
{
async Task <Exception> Inner()
{
try
{
await taskHelper.ConfigureAwait(task());
return(null);
}
catch (Exception e)
{
return(e);
}
}
return(taskHelper.ConfigureAwait(Inner()));
}
public static TaskAwaitable <bool> ConfigureAwaitHideCancel(this Task task, ITaskHelper taskHelper)
{
async Task <bool> Inner()
{
try
{
await task.ConfigureAwait(taskHelper);
return(false);
}
catch (OperationCanceledException)
{
return(true);
}
}
return(Inner().ConfigureAwait(taskHelper));
}
