public async Task EnsurePropertExecutionOrder_2() { List<string> target = new List<string>(); PipelineBuilder<ActionContextBase> builder = new PipelineBuilder<ActionContextBase>(); PipelineResult<ActionContextBase> pipeline = builder.Use( async (next, ctxt) => { await next(ctxt); target.Add("third"); }).Use(async (next, ctxt) => { target.Add("first"); await next(ctxt); target.Add("second"); }).Build(); await pipeline.Instance(new TestActionContext()); Assert.Equal(3, target.Count); Assert.Equal("first", target[0]); Assert.Equal("second", target[1]); Assert.Equal("third", target[2]); }
public void Handle(PipelineBuilder.Samples.Events.Contracts.IDocumentOpenedEventArgsContract args) { DocumentOpenedEventArgsContractToViewAddInAdapter adaptedArgs; adaptedArgs = new DocumentOpenedEventArgsContractToViewAddInAdapter(args); object[] argsArray = new object[1]; argsArray[0] = adaptedArgs; _event.Invoke(_view, argsArray); }
public virtual void DocumentOpenedRemove(PipelineBuilder.Samples.Events.Contracts.IDocumentOpenedHandlerContract handler) { System.EventHandler<PipelineBuilder.Samples.Events.DocumentOpenedEventArgs> adaptedHandler; if (DocumentOpened_handlers.TryGetValue(handler, out adaptedHandler)) { DocumentOpened_handlers.Remove(handler); _view.DocumentOpened -= adaptedHandler; } }
internal virtual void Fire_DocumentOpened(PipelineBuilder.Samples.Events.DocumentOpenedEventArgs args) { if ((_DocumentOpened == null)) { } else { _DocumentOpened.Invoke(this, args); } }
internal static PipelineBuilder.Samples.Events.Contracts.IAppObjectContract ViewToContractAdapter(PipelineBuilder.Samples.Events.IAppObject view) { if (view.GetType().Equals(typeof(IAppObjectContractToViewHostAdapter))) { return ((IAppObjectContractToViewHostAdapter)(view)).GetSourceContract(); } else { return new IAppObjectViewToContractHostAdapter(view); } }
internal static PipelineBuilder.Samples.Events.Contracts.ISampleAddInContract ViewToContractAdapter(PipelineBuilder.Samples.Events.ISampleAddIn view) { if (view.GetType().Equals(typeof(ISampleAddInContractToViewAddInAdapter))) { return ((ISampleAddInContractToViewAddInAdapter)(view)).GetSourceContract(); } else { return new ISampleAddInViewToContractAddInAdapter(view); } }
internal static PipelineBuilder.Samples.Events.Contracts.IDocumentOpenedEventArgsContract ViewToContractAdapter(PipelineBuilder.Samples.Events.DocumentOpenedEventArgs view) { if (view.GetType().Equals(typeof(DocumentOpenedEventArgsContractToViewHostAdapter))) { return ((DocumentOpenedEventArgsContractToViewHostAdapter)(view)).GetSourceContract(); } else { return new DocumentOpenedEventArgsViewToContractHostAdapter(view); } }
internal static PipelineBuilder.Samples.Events.ISampleAddIn ContractToViewAdapter(PipelineBuilder.Samples.Events.Contracts.ISampleAddInContract contract) { if (((System.Runtime.Remoting.RemotingServices.IsObjectOutOfAppDomain(contract) != true) && contract.GetType().Equals(typeof(ISampleAddInViewToContractAddInAdapter)))) { return ((ISampleAddInViewToContractAddInAdapter)(contract)).GetSourceView(); } else { return new ISampleAddInContractToViewAddInAdapter(contract); } }
internal static PipelineBuilder.Samples.Events.DocumentOpenedEventArgs ContractToViewAdapter(PipelineBuilder.Samples.Events.Contracts.IDocumentOpenedEventArgsContract contract) { if (((System.Runtime.Remoting.RemotingServices.IsObjectOutOfAppDomain(contract) != true) && contract.GetType().Equals(typeof(DocumentOpenedEventArgsViewToContractHostAdapter)))) { return ((DocumentOpenedEventArgsViewToContractHostAdapter)(contract)).GetSourceView(); } else { return new DocumentOpenedEventArgsContractToViewHostAdapter(contract); } }
public IPipeline<ClientActionContext> CreatePipeline(Func<ActionDelegate<ClientActionContext>, ClientActionContext, Task> next = null) { PipelineBuilder<ClientActionContext> builder = new PipelineBuilder<ClientActionContext>(); builder.Use(new SessionMiddleware(SessionHandler.Object, SessionErrorHandling.Object)); if (next != null) { builder.Use(next); } return builder.Build(); }
public IPipeline<ServerActionContext> Build() { PipelineBuilder<ServerActionContext> builder = new PipelineBuilder<ServerActionContext>(); builder.Use(new HandleErrorMiddleware()); builder.Use(new SerializationMiddleware()); builder.Use(new InstanceProviderMiddleware()); builder.Use(new ActionInvokerMiddleware()); return builder.Build(); }
public IPipeline<ServerActionContext> Build(IEnumerable<IMiddleware<ServerActionContext>> middlewares) { if (middlewares == null) throw new ArgumentNullException(nameof(middlewares)); PipelineBuilder<ServerActionContext> builder = new PipelineBuilder<ServerActionContext>(); foreach (var middleware in middlewares) { builder.Use(middleware); } return builder.Build(); }
public override void Build(IConfiguration configuration) { var channel = configuration.Attributes["channel"]; var uri = configuration.Attributes["uri"]; var concurrency = configuration.Attributes["concurrency"]; var frequency = configuration.Attributes["frequency"]; var scheduled = configuration.Attributes["scheduled"]; // build the pipeline for the receive port: var pipelineBuilder = new PipelineBuilder(this.Kernel, configuration); var pipeline = pipelineBuilder.BuildReceivePipeline(); Port = this.CreatePort(pipeline, channel, uri, concurrency, frequency, scheduled); }
public void Pipeline_ExecutionStatusNotification_Test() { //Arrange PipelineComponentResolver.Add(new FooComponent(), new BarExceptionComponent()); var receiver = Substitute.For <IPipelineComponentExecutionStatusReceiver>(); var sut = PipelineBuilder <TestPayload> .InitializePipeline(receiver) .WithComponent <FooComponent>() .WithComponent <BarExceptionComponent>() .WithComponentResolver(PipelineComponentResolver) .WithoutSettings() .Build(); //Act Action act = () => sut.Execute(new TestPayload()); //Assert act.Should() .ThrowExactly <PipelineExecutionException>() .WithInnerExceptionExactly <NotImplementedException>(); receiver.Received(2) .ReceiveExecutionStarting(Arg.Is <PipelineComponentExecutionStartingInfo>(info => info.PipelineComponentName == nameof(FooComponent) || info.PipelineComponentName == nameof(BarExceptionComponent))); receiver.Received() .ReceiveExecutionCompleted( Arg.Is <PipelineComponentExecutionCompletedInfo>(info => info.PipelineComponentName == nameof(FooComponent) && info.ExecutionTime != TimeSpan.Zero && info.Exception == null)); receiver.Received() .ReceiveExecutionCompleted( Arg.Is <PipelineComponentExecutionCompletedInfo>(info => info.PipelineComponentName == nameof(BarExceptionComponent) && info.ExecutionTime != TimeSpan.Zero && info.Exception is NotImplementedException)); }
public void PipelineBuilder_BuildFromConfiguration_ServiceCollection() { var element = new ElementOptions() { BuilderName = "MultiplyByElementBuilder" }; element.BuildParameters.Add("multiple", "3"); // Create the configuration object. PipelineOptions opts = new PipelineOptions(); opts.Elements = new List <ElementOptions> { element }; Mock <IServiceProvider> services = new Mock <IServiceProvider>(); services.Setup(s => s.GetService(typeof(MultiplyByElementBuilder))) .Returns(new MultiplyByElementBuilder()); // Pass the configuration to the builder to create the pipeline. var pipeline = new PipelineBuilder(_loggerFactory, services.Object) .BuildFromConfiguration(opts); // Get the element var multiplyByElement = pipeline.GetElement <MultiplyByElement>(); // Create, populate and process flow data. var flowData = pipeline.CreateFlowData(); flowData .AddEvidence(multiplyByElement.EvidenceKeys[0], 25) .Process(); // Get the results and verify them. var multiplyByData = flowData.GetFromElement(multiplyByElement); Assert.AreEqual(75, multiplyByData.Result); }
public void Pipeline_without_external_dependencies_runs_all_steps_till_completion() { UniqueStepId firstStepId = null; UniqueStepId secondStepId = null; var pipeline = new PipelineBuilder() .AddStage(StageTriggerMode.Automatic) .AddActivity() .AddStepWithoutDependencies(x => firstStepId = x) .AddStepWithoutDependencies(x => secondStepId = x) .Build(); var result = pipeline.Run(EventSink, null, DateTime.UtcNow); Assert.AreEqual(StageState.Finished, result); Expect(new StepExecutedEvent(firstStepId)) .ThenExpect(new StepExecutedEvent(secondStepId)) .ThenExpectAny <StageFinishedEvent>() .AndNothingElse(); }
public PipelineForeignAttributesTests() { var registry = new SubscriberRegistry(); registry.Register <MyCommand, MyObsoleteCommandHandler>(); var container = new ServiceCollection(); container.AddTransient <MyObsoleteCommandHandler>(); container.AddTransient <MyValidationHandler <MyCommand> >(); container.AddTransient <MyLoggingHandler <MyCommand> >(); container.AddSingleton <IBrighterOptions>(new BrighterOptions() { HandlerLifetime = ServiceLifetime.Transient }); var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider()); _pipelineBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactorySync)handlerFactory); PipelineBuilder <MyCommand> .ClearPipelineCache(); }
public PipelineGlobalInboxTests() { _inbox = new InMemoryInbox(); var registry = new SubscriberRegistry(); registry.Register <MyCommand, MyCommandHandler>(); var container = new TinyIoCContainer(); var handlerFactory = new TinyIocHandlerFactory(container); container.Register <IHandleRequests <MyCommand>, MyCommandHandler>(); container.Register <IAmAnInbox>(_inbox); _requestContext = new RequestContext(); _inboxConfiguration = new InboxConfiguration(); _chainBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory, _inboxConfiguration); PipelineBuilder <MyCommand> .ClearPipelineCache(); }
public void Initialise() { var loggerFactory = new TestLoggerFactory(); var builder = new PipelineBuilder(loggerFactory); var httpClient = new HttpClient(); var dataUpdateService = new DataUpdateService( loggerFactory.CreateLogger <DataUpdateService>(), httpClient); _engine = new EmptyEngineBuilder(loggerFactory) .Build(); var shareUsage = new ShareUsageBuilder(loggerFactory, httpClient) .Build(); _pipeline = builder .AddFlowElement(_engine) .AddFlowElement(shareUsage) .Build(); }
public PipelineGlobalInboxTestsAsync() { _inbox = new InMemoryInbox(); var handler = new MyCommandHandlerAsync(new Dictionary <string, Guid>()); var registry = new SubscriberRegistry(); registry.RegisterAsync <MyCommand, MyCommandHandlerAsync>(); var container = new TinyIoCContainer(); var handlerFactory = new TinyIocHandlerFactoryAsync(container); container.Register <MyCommandHandlerAsync>(handler); container.Register <IAmAnInboxAsync>(_inbox); _requestContext = new RequestContext(); _inboxConfiguration = new InboxConfiguration(); _chainBuilder = new PipelineBuilder <MyCommand>(registry, handlerFactory, _inboxConfiguration); }
public static IApplicationBuilder UseExtendMiddleware(this IApplicationBuilder builder) { //配置文件初始化 InitConfiguration(builder); //中间件初始化 var pipelineBuilder = new PipelineBuilder(builder.ApplicationServices); pipelineBuilder.InitPipeline(); var firstDelegate = pipelineBuilder.Build(); builder.Use(async(context, task) => { var downstreamContext = new DownstreamContext(context); await firstDelegate.Invoke(downstreamContext); }); return(builder); }
public void Pipeline_requests_retry_when_allowed() { UniqueStepId firstStepId = null; UniqueStepId failedStepId = null; var pipeline = new PipelineBuilder() .AddStage(StageTriggerMode.Automatic) .AddActivity() .AddStepWithoutDependencies(id => firstStepId = id) .AddStep <FailingStep>(id => failedStepId = id) .AddStepWithoutDependencies() .Build(new RetryOnceFailureHandlingStrategy()); var result = pipeline.Run(EventSink, null, DateTime.UtcNow); Assert.AreEqual(StageState.RequestsRetry, result); Expect(new StepExecutedEvent(firstStepId)) .ThenExpect(new StepAttemptFailedEvent(failedStepId)) .AndNothingElse(); }
public PublishingToMultipleSubscribersAsyncTests() { var registry = new SubscriberRegistry(); registry.RegisterAsync <MyEvent, MyEventHandlerAsync>(); registry.RegisterAsync <MyEvent, MyOtherEventHandlerAsync>(); registry.RegisterAsync <MyEvent, MyThrowingEventHandlerAsync>(); var container = new ServiceCollection(); container.AddTransient <MyEventHandlerAsync>(); container.AddTransient <MyOtherEventHandlerAsync>(); container.AddTransient <MyThrowingEventHandlerAsync>(); container.AddSingleton(_receivedMessages); var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider()); _commandProcessor = new CommandProcessor(registry, (IAmAHandlerFactoryAsync)handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry()); PipelineBuilder <MyEvent> .ClearPipelineCache(); }
public CommandProcessorPipelineStepsTests() { var registry = new SubscriberRegistry(); registry.Register <MyCommand, MyStepsPreAndPostDecoratedHandler>(); var container = new ServiceCollection(); container.AddTransient <MyStepsPreAndPostDecoratedHandler>(); container.AddTransient <MyStepsValidationHandler <MyCommand> >(); container.AddTransient <MyStepsLoggingHandler <MyCommand> >(); container.AddSingleton <IBrighterOptions>(new BrighterOptions() { HandlerLifetime = ServiceLifetime.Transient }); var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider()); _commandProcessor = new CommandProcessor(registry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry()); PipelineBuilder <MyCommand> .ClearPipelineCache(); }
public PipelinePreAndPostFiltersAsyncTests() { var registry = new SubscriberRegistry(); registry.RegisterAsync <MyCommand, MyPreAndPostDecoratedHandlerAsync>(); var container = new ServiceCollection(); container.AddTransient <MyPreAndPostDecoratedHandlerAsync>(); container.AddTransient <MyValidationHandlerAsync <MyCommand> >(); container.AddTransient <MyLoggingHandlerAsync <MyCommand> >(); container.AddSingleton <IBrighterOptions>(new BrighterOptions() { HandlerLifetime = ServiceLifetime.Transient }); var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider()); _pipelineBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactoryAsync)handlerFactory); PipelineBuilder <MyCommand> .ClearPipelineCache(); }
public PipelineGlobalInboxNoInboxAttributeTests() { _inbox = new InMemoryInbox(); var registry = new SubscriberRegistry(); registry.Register <MyCommand, MyNoInboxCommandHandler>(); var container = new ServiceCollection(); container.AddTransient <MyNoInboxCommandHandler>(); container.AddSingleton <IAmAnInbox>(_inbox); var handlerFactory = new ServiceProviderHandlerFactory(container.BuildServiceProvider()); _requestContext = new RequestContext(); _inboxConfiguration = new InboxConfiguration(); _chainBuilder = new PipelineBuilder <MyCommand>(registry, (IAmAHandlerFactory)handlerFactory, _inboxConfiguration); }
public void Run(string resourceKey, string cloudEndPoint = "") { Console.WriteLine("This example shows the details of devices " + "associated with a given 'Type Allocation Code' or 'TAC'."); Console.WriteLine("More background information on TACs can be " + "found through various online sources such as Wikipedia: " + "https://en.wikipedia.org/wiki/Type_Allocation_Code"); Console.WriteLine("----------------------------------------"); ILoggerFactory loggerFactory = new LoggerFactory(); HttpClient httpClient = new HttpClient(); // Create a cloud request engine builder var cloudRequestEngineBuilder = new CloudRequestEngineBuilder(loggerFactory, httpClient) .SetResourceKey(resourceKey); // If a cloud endpoint has been provided then set the // cloud pipeline endpoint. if (string.IsNullOrWhiteSpace(cloudEndPoint) == false) { cloudRequestEngineBuilder.SetEndPoint(cloudEndPoint); } // Create the cloud request engine using (var cloudEngine = cloudRequestEngineBuilder.Build()) // Create the property-keyed engine to process the // response from the request engine. using (var propertyKeyedEngine = new HardwareProfileCloudEngineBuilder(loggerFactory) .Build()) // Create the pipeline using the engines. using (var pipeline = new PipelineBuilder(loggerFactory) .AddFlowElement(cloudEngine) .AddFlowElement(propertyKeyedEngine) .Build()) { // Pass a TAC into the pipeline and list the matching devices. AnalyseTac(TAC, pipeline); AnalyseTac(TAC2, pipeline); } }
public CommandProcessorBuildDefaultInboxPublishTests() { var handler = new MyGlobalInboxEventHandler(new Dictionary <string, Guid>()); var subscriberRegistry = new SubscriberRegistry(); //This handler has no Inbox attribute subscriberRegistry.Add(typeof(MyEvent), typeof(MyGlobalInboxEventHandler)); var container = new TinyIoCContainer(); var handlerFactory = new TinyIocHandlerFactory(container); container.Register <MyGlobalInboxEventHandler>(handler); container.Register <IAmAnInbox>(_inbox); var retryPolicy = Policy .Handle <Exception>() .Retry(); var circuitBreakerPolicy = Policy .Handle <Exception>() .CircuitBreaker(1, TimeSpan.FromMilliseconds(1)); var inboxConfiguration = new InboxConfiguration( InboxScope.All, //grab all the events onceOnly: true, //only allow once actionOnExists: OnceOnlyAction.Throw //throw on duplicates (we should be the only entry after) ); _commandProcessor = new CommandProcessor( subscriberRegistry, handlerFactory, new InMemoryRequestContextFactory(), new PolicyRegistry { { CommandProcessor.RETRYPOLICY, retryPolicy }, { CommandProcessor.CIRCUITBREAKER, circuitBreakerPolicy } }, inboxConfiguration: inboxConfiguration ); PipelineBuilder <MyEvent> .ClearPipelineCache(); }
private static IServiceCollection AddAsyncPipelineInternal <TPayload>(this IServiceCollection services, Action <AsyncPipelineComponentConfiguration <TPayload> > configAction, IDictionary <string, IDictionary <string, string> > settings, string pipelineName, ServiceLifetime lifetime) { var config = new AsyncPipelineComponentConfiguration <TPayload>(); configAction(config); config.Validate(); services.AddComponentServices <IAsyncPipelineComponent <TPayload> >(config, lifetime); services.Add(new ServiceDescriptor( typeof(IAsyncPipeline <TPayload>), provider => BuildAsyncPipeline(provider, settings, pipelineName), lifetime)); return(services); IAsyncPipeline <TPayload> BuildAsyncPipeline( IServiceProvider provider, IDictionary <string, IDictionary <string, string> > pipelineSettings, string name) { var initialBuilder = (IAdditionalPipelineComponentHolder <IAsyncPipeline <TPayload>, IAsyncPipelineComponent <TPayload>, TPayload>) PipelineBuilder <TPayload> .InitializeAsyncPipeline( provider.GetService <IAsyncPipelineComponentExecutionStatusReceiver>()); initialBuilder = config.Components.Aggregate(initialBuilder, (current, component) => current.WithComponent(component)); var settingsHolder = initialBuilder.WithComponentResolver(provider.GetService <IPipelineComponentResolver>()); var builder = pipelineSettings != null ? settingsHolder.WithSettings(pipelineSettings) : settingsHolder.WithoutSettings(); return(builder.Build(name)); } }
public static void AddNamedEntity(List <Book> books) { var pipeline = PipelineBuilder.GetPipeLineWithNamedEntities(); int counter = 1; foreach (var book in books) { Dictionary <string, int> entities = new Dictionary <string, int>(); var annotation = new Annotation(book.Text); pipeline.annotate(annotation); var sentences = annotation.get(new CoreAnnotations.SentencesAnnotation().getClass()) as ArrayList; foreach (CoreMap sentence in sentences) { var tokens = sentence.get(new CoreAnnotations.TokensAnnotation().getClass()) as ArrayList; foreach (CoreLabel token in tokens) { var ner = token.get(new CoreAnnotations.NamedEntityTagAnnotation().getClass()) as string; if (entities.ContainsKey(ner)) { entities[ner]++; } else { entities.Add(ner, 1); } } } foreach (var entity in entities) { book.NamedEntities.Add(new NamedEntity() { NamedEntityID = counter, BookID = book.BookID, NamedEntity1 = entity.Key, NumberOfOccurences = entity.Value }); counter++; } } }
public void AspectEngineLazyLoad_Itegrated_AsDictionary() { // Arrange var processCostMs = _timeoutMS / 2; _engine.SetProcessCost(TimeSpan.TicksPerMillisecond * processCostMs); var pipeline = new PipelineBuilder(_loggerFactory) .AddFlowElement(_engine) .Build(); // Act var stopwatch = new Stopwatch(); var flowData = pipeline.CreateFlowData(); Trace.WriteLine("Process starting"); stopwatch.Start(); flowData.Process(); long processTimeMs = stopwatch.ElapsedMilliseconds; Trace.WriteLine($"Process complete in {processTimeMs} ms"); // Assert var data = flowData.Get <EmptyEngineData>(); Assert.IsNotNull(data); var dictionary = data.AsDictionary(); long dictTimeMs = stopwatch.ElapsedMilliseconds; Trace.WriteLine($"Dictionary retrieved after {dictTimeMs} ms"); Assert.AreEqual(1, dictionary[EmptyEngineData.VALUE_ONE_KEY]); Assert.AreEqual(2, dictionary[EmptyEngineData.VALUE_TWO_KEY]); // Note - this should really take at least 'processCostMs' // but the accuracy of the timer seems to cause issues // if we are being that exact. Assert.IsTrue(dictTimeMs > processCostMs / 2, $"Accessing the dictionary should have taken at least " + $"{processCostMs / 2} ms from the time the Process method" + $"was called but it only took {dictTimeMs} ms."); }
public void Will_send_data_through_ws_publisher_at_the_end_of_the_pipeline() { var sourceElement = new TxPoolPipelineSource <Transaction>(_txPool); var element = new TxPoolPipelineElement <Transaction, Transaction>(); var publisher = new WebSocketsPublisher <Transaction, Transaction>("testPublisher", Substitute.For <IJsonSerializer>()); var mockWebSocket = Substitute.For <WebSocket>(); mockWebSocket.State.Returns(WebSocketState.Open); publisher.CreateClient(mockWebSocket, "testClient"); Transaction transactionToEmit = new() { To = new Address("0x92A3c5e7Cee811C3402b933A6D43aAF2e56f2823") }; var builder = new PipelineBuilder <Transaction, Transaction>(sourceElement); builder.AddElement(element).AddElement(publisher); var pipeline = builder.Build(); _txPool.NewPending += Raise.EventWith(new object(), new TxEventArgs(transactionToEmit)); mockWebSocket.Received().SendAsync(Arg.Any <ArraySegment <byte> >(), WebSocketMessageType.Text, true, CancellationToken.None); }
public void Will_send_data_through_log_publisher_at_the_end_of_the_pipeline() { string filePath = "path"; Transaction transaction = new() { To = new Address("0x92A3c5e7Cee811C3402b933A6D43aAF2e56f2823") }; IFileSystem fileSystemSub = Substitute.For <IFileSystem>(); fileSystemSub.File.Exists(filePath).Returns(true); fileSystemSub.File.ReadLines(filePath).Returns(new[] { "0x92A3c5e7Cee811C3402b933A6D43aAF2e56f2823" }); var sourceElement = new TxPoolPipelineSource <Transaction>(_txPool); var element = new TxPoolPipelineElement <Transaction, Transaction>(); var publisher = new LogPublisher <Transaction, Transaction>(Substitute.For <IJsonSerializer>(), Substitute.For <ILogManager>(), fileSystemSub); var builder = new PipelineBuilder <Transaction, Transaction>(sourceElement); builder.AddElement(element).AddElement(publisher); var pipeline = builder.Build(); _txPool.NewPending += Raise.EventWith(new object(), new TxEventArgs(transaction)); fileSystemSub.Received().File.AppendAllText(filePath, "0x92A3c5e7Cee811C3402b933A6D43aAF2e56f2823"); }
public async Task HandlingCommandWithNoRegisteredHandlerShouldRunNoMatchingRegistrationHandler() { var busSettings = new BusSettings(); var updater = new OuterPipelineDetector(); var dependencyScope = new TestDependencyScope(); var handler = new TestEventHandler(); var handlerShim = new EventHandlerShim <NoMatchingRegistrationEvent, TestEventHandler>(handler); dependencyScope.AddObject(handlerShim); var busBuilder = new BusBuilder() .RegisterEventHandler <NoMatchingRegistrationEvent, TestEventHandler>(); var pipelineBuilder = new PipelineBuilder(busBuilder); var pipelineRunBuilder = new PipelineRunBuilder(busSettings, pipelineBuilder, updater, dependencyScope); var runner = pipelineRunBuilder.GetRunnerForPipeline(typeof(TestCommand), default(CancellationToken)); await runner.Handle(new TestCommand()); handler.CallsToHandle.Should().Be(1); }
public async Task Pipeline_Should_Preserve_OwnPipelineComponents_AfterBuild() { // arrange var sp = new ServiceCollection().BuildServiceProvider(); var pipelineBuilder = new PipelineBuilder <TestCtx>(); pipelineBuilder.Use <Middleware1>(); var firstPipeline = pipelineBuilder.Build(sp); pipelineBuilder.Use(async(ctx, next) => { ctx.Msg += "Before_LambdaMiddleware"; await next(); ctx.Msg += "After_LambdaMiddleware"; }); var secondPipeline = pipelineBuilder.Build(sp); var testContext = new TestCtx(); // act await firstPipeline.ExecuteAsync(testContext); // this pipeline has no lambda middleware in pipeline. Assert.AreEqual("Before_Middleware1After_Middleware1", testContext.Msg); testContext.Msg = null; // clear before second pipeline execution await secondPipeline.ExecuteAsync(testContext); // this has full pipeline. // assert Assert.AreEqual( "Before_Middleware1Before_LambdaMiddlewareAfter_LambdaMiddlewareAfter_Middleware1", testContext.Msg ); }
public async void Should_pass_execution_parameters_to_middleware() { //Arrange var mockedServiceProvider = Mock.Of <IServiceProvider>(); IData receivedData1 = null, receivedData2 = null; CancellationToken receivedCancellationToken1, receivedCancellationToken2; var pipeline = new PipelineBuilder <IData>(mockedServiceProvider) .Use(async(data, cancellationToken, next) => { receivedData1 = data; receivedCancellationToken1 = cancellationToken; await next(); }) .Use(async(data, cancellationToken, next) => { receivedData2 = data; receivedCancellationToken2 = cancellationToken; await Task.Yield(); }) .Pipeline; var sentData = Mock.Of <IData>(); using (var ts = new CancellationTokenSource()) { var sentCancellationToken = ts.Token; //Act await pipeline(sentData, sentCancellationToken); //Assert receivedCancellationToken1.Should().Be(sentCancellationToken); receivedCancellationToken2.Should().Be(sentCancellationToken); receivedData1.Should().Be(sentData); receivedData2.Should().Be(sentData); } }
private static async Task InvokePipelineAsync(IPipelineComponentResolver resolver, IDictionary <string, IDictionary <string, string> > settings) { Console.WriteLine("Executing pipeline asynchronously.\n"); var payload = new ExamplePipelinePayload(); using (var pipeline = PipelineBuilder <ExamplePipelinePayload> .InitializeAsyncPipeline() .WithComponent <FooComponent>() .WithComponent <DelayComponent>() .WithComponent <BarComponent>() .WithComponentResolver(resolver) .WithSettings(settings) .Build()) { payload = await pipeline.ExecuteAsync(payload); } payload.Messages.ForEach(Console.WriteLine); Console.WriteLine("\n"); }
public async void should_unsubscribe_wiretap_correctly() { var dummyPipeline = new PipelineBuilder() .StartFrom(x => Task.FromResult((object)"hello")) .ThenInvoke(x => Task.FromResult((object)"there")) .Build() .AsWireTappable(); var sub1 = dummyPipeline.StartWiretap(1, (x, y) => { Assert.True(false); }); var sub2 = dummyPipeline.StartWiretap(2, (x, y) => { Assert.True(false); }); sub1.Unsubscribe(); sub2.Unsubscribe(); dummyPipeline.Execute(); }
public async void should_correctly_fork_stream_for_object_with_builder() { var expectedString = "hello there some new pipeline"; var data = "hello"; var dummyPipeline = new PipelineBuilder() .StartFromInput() .ThenInvoke(x => Task.FromResult((object)(x + " there"))) .ThenInvoke(x => Task.FromResult((object)(x + " some"))) .ThenInvoke(x => Task.FromResult((object)(x + " old"))) .ThenInvoke(x => Task.FromResult((object)(x + " pipeline"))) .Build(); var forkedPipeline = new PipelineBuilder() .ForkObjectFrom(dummyPipeline, 2) .ThenInvoke(x => Task.FromResult((object)(x + " new"))) .ThenInvoke(x => Task.FromResult((object)(x + " pipeline"))) .Build(); var actualOutput = await forkedPipeline.Execute(data); Assert.Equal(expectedString, actualOutput); }
public async Task RunAsync() { try { _logger.LogInformation("Application started"); var context = new PipelineContext <TestResult>(new TestResult()); var pipeline = PipelineBuilder <TestResult> .Create <TestResult>() .Use(_testRuntimeLibraryHandler) .Use(_testDbHandler) .Use(_testWebApiHandler) .Build(); await pipeline.RunAsync(context); PrintInfo(context.Data); } catch (Exception ex) { _logger.LogError(ex, "Необработанная ошибка {0}", ex.Message); } }
public void InvokePipeline() { var testObject1 = new TestObject { Name = "TestObject1" }; var option = new PSRuleOption(); option.Rule.Include = new string[] { "FromFile1" }; var builder = PipelineBuilder.Invoke(GetSource(), option); var pipeline = builder.Build(); pipeline.Begin(); var actual = new List <InvokeResult>(); for (var i = 0; i < 100; i++) { pipeline.Process(PSObject.AsPSObject(testObject1)); } pipeline.End(); }
public void Step_should_timeout_after_500_seconds() { UniqueStepId firstRetryStepId = null; var pipeline = new PipelineBuilder() .AddStage(StageTriggerMode.Automatic) .AddActivity() .AddStep <WaitingForExternalDependencyStep>(id => firstRetryStepId = id) .Build(new NoRetryFailureHandlingStrategy()); var startTime = DateTime.UtcNow; var retryTime = startTime + TimeSpan.FromSeconds(501); pipeline.Run(EventSink, null, startTime); pipeline.Run(EventSink, null, retryTime); Expect((new StepWaitingForExternalDependencyEvent(firstRetryStepId, startTime))) .ThenExpect(new StepAttemptFailedEvent(firstRetryStepId)) .ThenExpect(new StepFailedEvent(firstRetryStepId)) .ThenExpectAny <StageFailedEvent>() .AndNothingElse(); }
public async Task Should_BeCorrect_PipelineExecutionOrder() { // arrange var pipelineBuilder = new PipelineBuilder <TestCtx>(); pipelineBuilder.Use <Middleware1>(); pipelineBuilder.Use <Middleware2>(); pipelineBuilder.Use(async(ctx, next) => { ctx.ExecutedMiddlewaresCount++; ctx.Msg += "Before_LambdaMiddleware"; await next(); ctx.Msg += "After_LambdaMiddleware"; }); var pipeline = pipelineBuilder.Build(new ServiceCollection().BuildServiceProvider()); var testContext = new TestCtx(); Assert.IsNull(testContext.Msg); Assert.Zero(testContext.ExecutedMiddlewaresCount); // act await pipeline.ExecuteAsync(testContext); // assert const string expectedMessage = "Before_" + nameof(Middleware1) + "Before_" + nameof(Middleware2) + "Before_LambdaMiddleware" + "After_LambdaMiddleware" + "After_" + nameof(Middleware2) + "After_" + nameof(Middleware1); Assert.AreEqual(expectedMessage, testContext.Msg, "Pipeline execution order is not match"); Assert.AreEqual(3, testContext.ExecutedMiddlewaresCount, "ExecutedMiddlewaresCount is not match"); }
public IAppObjectViewToContractHostAdapter(PipelineBuilder.Samples.Events.IAppObject view) { _view = view; DocumentOpened_handlers = new System.Collections.Generic.Dictionary<PipelineBuilder.Samples.Events.Contracts.IDocumentOpenedHandlerContract, System.EventHandler<PipelineBuilder.Samples.Events.DocumentOpenedEventArgs>>(); }
public ISampleAddInContractToViewAddInAdapter(PipelineBuilder.Samples.Events.Contracts.ISampleAddInContract contract) { _contract = contract; _handle = new System.AddIn.Pipeline.ContractHandle(contract); }
private Project CreateAddInProject(DTE2 dte, String destPath, PipelineBuilder.PipelineSegmentSource pipelineComponent) { destPath += "\\" + pipelineComponent.Name; String generatedDestPath = destPath + "\\Generated Files"; Project proj = null; foreach (Project p in ProjectHelpers.GetProjectsFromSolution(dte)) { if (p.Name.Trim().Equals((pipelineComponent.Name))) { proj = p; } } if (proj == null) { if (Directory.Exists(destPath)) { throw new InvalidOperationException("The directory for this project already exists but is not part of the current solution. Please either add it back to the current solution or delete it manually: " + destPath); } else { Directory.CreateDirectory(destPath); } dte.Solution.AddFromTemplate(ProjectHelpers.Pop(this.GetType().Assembly.Location) + "\\Template.csproj", destPath, pipelineComponent.Name + ".csproj", false); foreach (Project p in ProjectHelpers.GetProjectsFromSolution(dte)) { if (p.Name.Trim().Equals((pipelineComponent.Name))) { proj = p; } } proj.Properties.Item("AssemblyName").Value = pipelineComponent.Name; } if (Directory.Exists(generatedDestPath)) { CheckSumValidator.ValidateCheckSum(generatedDestPath); } if (proj != null) { try { proj.ProjectItems.Item("Generated Files").Delete(); } catch (ArgumentException) { //If there is no generated files project item then we should just ignore this step. } if (Directory.Exists(generatedDestPath)) { throw new InvalidOperationException("Generated Files directory exists but is not part of project. Please save required files and delete manually: " + generatedDestPath); } Directory.CreateDirectory(generatedDestPath); proj.ProjectItems.AddFolder("Generated Files", null); foreach (PipelineBuilder.SourceFile source in pipelineComponent.Files) { String path = generatedDestPath + "\\" + source.Name; StreamWriter sw = new StreamWriter(path); sw.WriteLine(source.Source); sw.Close(); } proj.ProjectItems.AddFromDirectory(generatedDestPath); CheckSumValidator.StoreCheckSum(generatedDestPath); } return proj; }
internal static void SetOutputPath(Project p, PipelineBuilder.SegmentType type, String root) { foreach (Configuration c in p.ConfigurationManager) { Property prop = c.Properties.Item("OutputPath"); prop.Value = root; switch (type) { case PipelineBuilder.SegmentType.AIB: prop.Value += "\\AddInViews"; break; case PipelineBuilder.SegmentType.ASA: prop.Value += "\\AddInSideAdapters"; break; case PipelineBuilder.SegmentType.HSA: prop.Value += "\\HostSideAdapters"; break; case PipelineBuilder.SegmentType.HAV: break; case PipelineBuilder.SegmentType.VIEW: prop.Value += "\\AddInViews"; break; default: throw new InvalidOperationException("Not a valid pipeline component: " + p.Name); } } }
public void Initialize(PipelineBuilder.Samples.Events.IAppObject appObject) { _contract.Initialize(PipelineBuilder.Samples.EventsAddInAdapters.IAppObjectAddInAdapter.ViewToContractAdapter(appObject)); }
public virtual void Initialize(PipelineBuilder.Samples.Events.Contracts.IAppObjectContract appObject) { _view.Initialize(PipelineBuilder.Samples.EventsAddInAdapters.IAppObjectAddInAdapter.ContractToViewAdapter(appObject)); }
public ISampleAddInViewToContractAddInAdapter(PipelineBuilder.Samples.Events.ISampleAddIn view) { _view = view; }
public virtual void DocumentOpenedAdd(PipelineBuilder.Samples.Events.Contracts.IDocumentOpenedHandlerContract handler) { System.EventHandler<PipelineBuilder.Samples.Events.DocumentOpenedEventArgs> adaptedHandler = new System.EventHandler<PipelineBuilder.Samples.Events.DocumentOpenedEventArgs>(new IDocumentOpenedHandlerContractToViewHostAdapter(handler).Handler); _view.DocumentOpened += adaptedHandler; DocumentOpened_handlers[handler] = adaptedHandler; }
public IPipeline<ClientActionContext> CreatePipeline(int retries) { PipelineBuilder<ClientActionContext> builder = new PipelineBuilder<ClientActionContext>(); builder.Use(new RetryRequestMiddleware(ErrorHandling.Object) {Retries = retries}); builder.Use( (next, ctxt) => { Callback.Object.Handle(ctxt); return next(ctxt); }); return builder.Build(); }
public IAppObjectContractToViewAddInAdapter(PipelineBuilder.Samples.Events.Contracts.IAppObjectContract contract) { _contract = contract; _handle = new System.AddIn.Pipeline.ContractHandle(contract); DocumentOpened_Handler = new IDocumentOpenedHandlerViewToContractAddInAdapter(this, s_DocumentOpenedAddFire); }
public DocumentOpenedEventArgsViewToContractHostAdapter(PipelineBuilder.Samples.Events.DocumentOpenedEventArgs view) { _view = view; }
public IDocumentOpenedHandlerContractToViewHostAdapter(PipelineBuilder.Samples.Events.Contracts.IDocumentOpenedHandlerContract contract) { _contract = contract; _handle = new System.AddIn.Pipeline.ContractHandle(contract); }
public void Initialize() { var builder = this.Builder; if (builder == null) { builder = new PipelineBuilder(); } this.requestPipeline = builder.Build(this.requestProcessors, GetRequestInArguments(), this.GetRequestOutArguments()); this.responsePipeline = builder.Build(this.responseProcessors, this.GetResponseInArguments(), Enumerable.Empty<ProcessorArgument>()); }
public void Handler(object sender, PipelineBuilder.Samples.Events.DocumentOpenedEventArgs args) { _contract.Handle(PipelineBuilder.Samples.EventsHostAdapers.DocumentOpenedEventArgsHostAdapter.ViewToContractAdapter(args)); }