public static TOutput RunCheckpoint <TConvention, TInput, TOutput>(this ICheckpointRunner runner,
IMoveableResultCheckpoint <TConvention, TInput, TOutput> wrapper,
TInput input,
TConvention convention)
{
return(runner.RunCheckpoint(wrapper, input, wrapper.GetNamingConvention(convention)));
}
public IParsingResult <IModeLauncher> Parse(
MainParser main, ILogger logger, ISettings settings, ICheckpointRunner checkpointRunner,
IWorkDoer workDoer, string[] args, TextWriter standardWriter, TextWriter errorWriter)
{
var results = main.GetParseResults(args);
var parsingResult = checkpointRunner.RunCheckpoint("Validate input", () =>
{
if (!results.Validate(out IParsingResult <IModeLauncher> failedResult))
{
return(ParsingResult <T> .FailedResult(failedResult.ErrorMessage));
}
var successfulResults = new SuccessfulResultCollection(results);
var commonOptions = successfulResults.Get(MainParser.CommonOptionsParser);
return(GetSerializedResult(successfulResults, commonOptions));
});
if (!parsingResult.Success)
{
ShowError(main, logger.Error, parsingResult.ErrorMessage);
return(ParsingResult <IModeLauncher> .FailedResult(parsingResult));
}
var runner = GetRunner(parsingResult.Result);
return(ParsingResult <IModeLauncher> .SuccessfulResult(new ModeLauncher(logger, settings, checkpointRunner, workDoer, runner, args, main.GetVersion(), Name)));
}
public static Task <TOutput> RunCheckpointAsync <TInput, TOutput>(this ICheckpointRunner runner,
IAbstractCheckpoint <TInput, TOutput> wrapper,
TInput input,
INamingConvention <TOutput> namingConvention)
{
return(runner.RunCheckpointAsync(wrapper.GetStepName(), wrapper, input, namingConvention));
}
public static TOutput RunCheckpoint <TInput, TOutput>(this ICheckpointRunner runner,
IAbstractCheckpoint <TInput, TOutput> wrapper,
TInput input,
ILoadingConvention <TInput, TOutput> loadingConvention)
{
return(runner.RunCheckpoint(wrapper.GetStepName(), wrapper.Run, input, loadingConvention));
}
public static TOutput RunCheckpoint <TInput, TOutput>(this ICheckpointRunner runner,
IAbstractCheckpoint <TInput, TOutput> wrapper,
TInput input,
INamingConvention <TOutput> namingConvention)
{
return(runner.RunCheckpoint(wrapper.GetStepName(), dir => wrapper.Run(input, dir), namingConvention));
}
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager)
{
CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, false, CanvasCoverageMode.TruncatedDynamicRange, 100, CommonOptions.CustomParams);
var callset = GetCallset();
logger.Info($"Normal Vcf path: {callset.NormalVcfPath}");
runner.CallSample(callset);
}
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager, IFileLocation runtimeExecutable)
{
CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, runtimeExecutable, true, CanvasCoverageMode.GCContentWeighted, 100, CommonOptions.CustomParams);
var callset = GetCallset();
runner.CallSample(callset);
}
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager, IFileLocation runtimeExecutable)
{
CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, runtimeExecutable, false, CanvasCoverageMode.TruncatedDynamicRange, 100, CommonOptions.CustomParams);
var callset = GetCallset();
var spwWorkflow = new SmallPedigreeWorkflow(runner);
spwWorkflow.CallPedigree(callset);
}
public static TResult RunCheckpoint <TResult>(this ICheckpointRunner runner, string name, Func <IDirectoryLocation, TResult> run, INamingConvention <TResult> namingConvention)
{
return(runner.RunCheckpoint(name, (dir, mover) =>
{
var result = run(dir);
return namingConvention.Move(result, mover.Move);
}));
}
private IParsingResult <IModeLauncher> Parse(
ILogger logger, ISettings settings, ICheckpointRunner checkpointRunner,
IWorkDoer workDoer, string[] args, TextWriter standardWriter, TextWriter errorWriter)
{
var mode = _modeParsers[args[0]];
return(mode.Parse(this, logger, settings, checkpointRunner, workDoer, args, standardWriter, errorWriter));
}
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager, IFileLocation runtimeExecutable)
{
CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, runtimeExecutable, false, CanvasCoverageMode.TruncatedDynamicRange, 100, CommonOptions.CustomParams);
var callset = GetCallset();
logger.Info($"Normal Vcf path: {callset.SingleSampleCallset.NormalVcfPath}");
runner.CallSample(callset);
}
public static TResult RunCheckpoint <TInput, TResult>(this ICheckpointRunner runner, string name, Func <TInput, IDirectoryLocation, TResult> run, TInput input, ILoadingConvention <TInput, TResult> loadingConvention)
{
return(runner.RunCheckpoint(name, (dir, mover) =>
{
var result = run(input, dir);
loadingConvention.Move(result, mover.Move);
return loadingConvention.Load(input);
}, () => loadingConvention.Load(input)));
}
public CanvasRunnerFactory(ILogger logger, ICheckpointRunner checkpointRunner,
IWorkDoer workDoer, IFileLocation runtimeExecutable, Func <string, ICommandFactory> runtimeCommandPrefix)
{
_logger = logger;
_checkpointRunner = checkpointRunner;
_workDoer = workDoer;
_runtimeExecutable = runtimeExecutable;
_runtimeCommandPrefix = runtimeCommandPrefix;
}
public static Task <TOutput> RunCheckpointAsync <TOutput>(this ICheckpointRunner runner,
string key,
Func <IDirectoryLocation, TOutput> run,
INamingConvention <TOutput> namingConvention)
{
var asyncNamingConvention = new NamingConventionAsync <TOutput>(namingConvention);
return(runner.RunCheckpoint(key, dir => Task.Run(() => run(dir)), asyncNamingConvention));
}
public CanvasRunner(ILogger logger, IWorkManager workManager, ICheckpointRunner checkpointRunner, bool isSomatic, CanvasCoverageMode coverageMode,
int countsPerBin, Dictionary<string, string> customParameters = null)
{
_logger = logger;
_workManager = workManager;
_checkpointRunner = checkpointRunner;
_isSomatic = isSomatic;
_canvasFolder = Path.Combine(Utilities.GetAssemblyFolder(typeof(CanvasRunner)));
_coverageMode = coverageMode;
_countsPerBin = countsPerBin;
if (customParameters != null) { _customParameters = customParameters; }
}
public ModeLauncher(
ILogger logger, ISettings settings, ICheckpointRunner checkpointRunner,
IWorkDoer workDoer, IModeRunner modeRunner, IEnumerable <string> args, string version, string mode)
{
_logger = logger;
_settings = settings;
_checkpointRunner = checkpointRunner;
_workDoer = workDoer;
_modeRunner = modeRunner;
_args = args;
_version = version;
_mode = mode;
}
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager)
{
CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, true, CanvasCoverageMode.TruncatedDynamicRange, 300, CommonOptions.CustomParams);
var callset = GetCallset(logger);
runner.CallSample(callset);
}
public Task <SampleSet <TCanvasOutput> > RunAsync(SampleSet <TCanvasInput> inputs, SampleStubNamingConvention sampleStubNamingConvention, ICheckpointRunner checkpointRunner)
{
return(Task.FromResult(inputs.SelectData(input => default(TCanvasOutput))));
}
public Task <SampleSet <TCanvasOutput> > RunAsync(SampleSet <TCanvasInput> inputs, SampleStubNamingConvention sampleStubNamingConvention, ICheckpointRunner checkpointRunner)
{
return(checkpointRunner.RunCheckpointAsync(_canvasCheckpoint, inputs, sampleStubNamingConvention));
}
public static Task <TOutput> RunCheckpointAsync <TInput, TOutput>(this ICheckpointRunner runner, string key, ISandboxedCheckpoint <TInput, TOutput> wrapper, TInput input,
INamingConvention <TOutput> namingConvention)
{
return(runner.RunCheckpointAsync(key, dir => wrapper.Run(input, dir), namingConvention));
}
public static Task <TResult> RunCheckpointAsync <TResult>(this ICheckpointRunner checkpointRunner, string checkpointName, Func <TResult> function)
{
return(checkpointRunner.RunCheckpoint(checkpointName, () => Task.Run(function)));
}
public void Run(ILogger logger, ICheckpointRunner checkpointRunner, IWorkManager workManager)
{
CanvasRunner runner = new CanvasRunner(logger, workManager, checkpointRunner, true, CanvasCoverageMode.GCContentWeighted, 100, CommonOptions.CustomParams);
var callset = GetCallset();
runner.CallSample(callset);
}
public static Task <TResult> RunCheckpointAsync <TResult>(this ICheckpointRunner checkpointRunner, string key, Func <TResult> run, Func <TResult> load)
{
return(checkpointRunner.RunCheckpoint(key, () => Task.Run(run), () => Task.Run(load)));
}
public static TResult RunCheckpoint <TResult>(this ICheckpointRunner checkpointRunner, string checkpointName, Func <ICheckpointRunner, IDirectoryLocation, IFileMover, TResult> run)
{
return(checkpointRunner.RunCheckpoint(checkpointName, (tempDir, fileMover) => run(checkpointRunner, tempDir, fileMover)));
}
public static Task <TOutput> RunCheckpointAsync <TConvention, TInput, TOutput>(this ICheckpointRunner runner,
ILoadableResultCheckpoint <TConvention, TInput, TOutput> wrapper,
TInput input,
TConvention convention)
{
return(runner.RunCheckpointAsync(wrapper, input, wrapper.GetLoadingConvention(convention)));
}
public SampleSet <TCanvasOutput> Run(SampleSet <TCanvasInput> inputs, SampleStubNamingConvention sampleStubNamingConvention, ICheckpointRunner checkpointRunner)
{
return(inputs.SelectData(input => default(TCanvasOutput)));
}
/// <summary>
///
/// </summary>
/// <param name="runner"></param>
/// <param name="key"></param>
/// <param name="wrapper"></param>
/// <param name="input"></param>
/// <param name="loadingConvention"></param>
/// <typeparam name="TInput"></typeparam>
/// <typeparam name="TOutput"></typeparam>
/// <returns></returns>
/// <exception cref="NotImplementedException"></exception>
public static Task <TOutput> RunCheckpointAsync <TInput, TOutput>(this ICheckpointRunner runner, string key, ISandboxedCheckpoint <TInput, TOutput> wrapper, TInput input, ILoadingConvention <TInput, TOutput> loadingConvention)
{
var asyncLoadingConvention = new LoadingConventionAsync <TInput, TOutput>(loadingConvention);
return(runner.RunCheckpoint(key, (tempInput, dir) => Task.Run(() => wrapper.Run(tempInput, dir)), input, asyncLoadingConvention));
}
public static Task <TResult> RunCheckpointAsync <TResult>(this ICheckpointRunner checkpointRunner, string checkpointName, Func <IDirectoryLocation, IFileMover, TResult> function, Func <TResult> load)
{
return(checkpointRunner.RunCheckpoint(checkpointName, (tempDir, fileMover) => Task.Run(() => function(tempDir, fileMover)), () => Task.Run(load)));
}
