/// <summary> /// Registers the formatter /// </summary> /// <param name="context">The processing context</param> public override void BeforeInvoke(ArgHook.HookContext context) { PipelineOutputFormatter.RegisterFormatter(targetType, Formatter, true); }
internal PipelineStage CreateNextStage(ArgHook.HookContext context, string[] commandLine, ICommandLineArgumentsDefinitionFactory factory) { PipelineStage next; CommandLineAction inProcAction; if (Stages.Count == 0) { next = new RootPipelineStage(commandLine); } else if (commandLine[0].StartsWith(ArgPipeline.PipelineStageActionIndicator) && ArgPipelineActionStage.TryCreateActionStage(commandLine, out next)) { // do nothing, next is populated } else if (TryParseStageAction(context.Definition, commandLine[0], out inProcAction)) { next = new InProcessPipelineStage(context.Definition, commandLine); } else if (ExternalPipelineProvider.TryLoadOutputStage(commandLine, out next) == false) { throw new UnexpectedArgException("The pipeline action '"+string.Join(" ", commandLine)+"' is not valid. If you want to support piping between processes, learn how to here (TODO URL)"); } next.CommandLineDefinitionFactory = factory; this.AddStage(next); return next; }
/// <summary> /// Unregisters the formatter /// </summary> /// <param name="context">The processing context</param> public override void AfterInvoke(ArgHook.HookContext context) { if(PipelineOutputFormatter.GetFormatter(targetType) == Formatter) { PipelineOutputFormatter.UnregisterFormatter(targetType); } }
private ArgPipelineManager GetPipelineManagerFromContext(ArgHook.HookContext context) { if (ContextHasPipelineManager(context) == false) { context.SetProperty("ArgPipelineManager", new ArgPipelineManager(Mode)); } return context.GetProperty<ArgPipelineManager>("ArgPipelineManager"); }
private static bool ContextHasPipelineManager(ArgHook.HookContext context) { return context.HasProperty("ArgPipelineManager"); }
/// <summary> /// This is the main hook point where the pipeline features get injected. This method is responsible for creating the pipeline if needed. It is also /// responsible for connecting to an external program if this program was launched by another program's pipeline manager. It is also responsible for /// supporting any pipeline stage actions (e.g. $filter) that are not supported if the [ArgPipeline] metadata is omitted from the root definition. /// </summary> /// <param name="context">The processing context</param> public override void BeforeParse(ArgHook.HookContext context) { ExternalPipelineInputStage externalStage; if(ExternalPipelineProvider.TryLoadInputStage(context.Definition, context.CmdLineArgs, out externalStage) && externalStage.IsProgramLaunchedByExternalPipeline) { externalStage.CommandLineDefinitionFactory = this.commandLineDeinitionFactory; while (externalStage.IsDrained == false) { Thread.Sleep(10); } PowerLogger.LogLine("Input stage drained"); context.CancelAllProcessing(); return; } else if(context.CmdLineArgs.Contains(PowerArgsPipeIndicator)) { ValidatePipeline(context); List<List<string>> stageCommandLines = new List<List<string>>(); stageCommandLines.Add(new List<string>()); for(int i = 0; i < context.CmdLineArgs.Length; i++) { var arg = context.CmdLineArgs[i]; if(arg == PowerArgsPipeIndicator) { stageCommandLines.Add(new List<string>()); } else { stageCommandLines.Last().Add(arg); } } context.CmdLineArgs = stageCommandLines.First().ToArray(); var manager = GetPipelineManagerFromContext(context); for (int i = 0; i < stageCommandLines.Count; i++) { var args = stageCommandLines[i]; if(args.Count == 0) { throw new ArgException("Missing action after pipeline indicator: "+PowerArgsPipeIndicator); } manager.CreateNextStage(context, args.ToArray(), this.commandLineDeinitionFactory); } context.CmdLineArgs = manager.Stages[0].CmdLineArgs.ToArray(); } else { // do nothing } }
/// <summary> /// If the given context contains the pipeline manager then this method will make sure the /// pipeline is drained before returning. /// </summary> /// <param name="context">The processing context</param> public override void AfterInvoke(ArgHook.HookContext context) { context.Definition.Clean(); if (ContextHasPipelineManager(context) == false) { return; } var manager = GetPipelineManagerFromContext(context); manager.Drain(); }