private static void RunPeoplePipeline() { var peoplePipelineFactory = new PeoplePipelineFactory(new Pipelines.PeopleStream.BlockFactories.ReadingBlockFactory(new FileLinesCounter(), new DataReader(new DataParser()), new StreamLinesReader(), new DataParser()), new PersonValidator(), new PersonFieldsComputer(), new Pipelines.PeopleStream.BlockFactories.WritingBlockFactory(new DataWriter()), new ThrowingBlockFactory(), new EmptyBlockFactory(), new ProgressReportingBlockFactory(), new RailroadPipelineFactory()); var pipelineExecutor = new PipelineExecutor(); using (var cancellationSource = new CancellationTokenSource()) { var progress = new Progress <PipelineProgress>(x => Console.WriteLine($"{x.Percentage}% processed.")); var pipeline = peoplePipelineFactory.Create(Settings.PeopleJsonFilePath, Settings.PeopleTargetFilePath, Settings.ErrorsFilePath, progress, cancellationSource); Task.Run(() => WaitForCancellation(cancellationSource)); var executionResult = pipelineExecutor.Execute(pipeline).Result; HandleExecutionResult(executionResult); } }
private void pipelineExecutor_OnDataReady(PipelineExecutor sender, ICollection <PSObject> data) { foreach (PSObject obj in data) { var line = obj.ToString(); if (_internalResponseHandling) { _internalData = line; if (_sendResponse) { OnRequestComplete(_internalData); } _internalResponseHandling = false; _sendResponse = true; } else { if (line.Contains(@" warning ")) { _display.AppendWarning(line); } else { _display.AppendLine(line); } _display.AppendLine(""); } } }
public void OverrideOutput() { List <GraphNode> nodes = new List <GraphNode>(); nodes.Add(TestHelpers.BuildGraphNode(0, "input")); nodes.Add(TestHelpers.BuildGraphNode(1, "process")); nodes.Add(TestHelpers.BuildGraphNode(2, "output", output.TypeName, "Override")); List <NodeLinkInfo> links = new List <NodeLinkInfo>(); links.Add(TestHelpers.MatchSlots(nodes[0], nodes[1], 0, 0)); links.Add(TestHelpers.MatchSlots(nodes[1], nodes[2], 0, 0)); DataStore staticStore = new DataStore(true), standardData = new DataStore(0, ""); List <DependentNode> dependents = TestHelpers.ConvertToDependentNodes(nodes); Dictionary <int, DependentNode> dependentNodes = TestHelpers.ConvertToDictionary(dependents); SpecialNodeData special = SpecialNodeSearch.CheckForSpecialNodes(dependentNodes, staticStore); PipelineExecutor pipeline = new PipelineExecutor(dependentNodes, staticStore, 0, special); TaskRunner runner = new TaskRunner(output, dependents[2], standardData, staticStore, pipeline, 0); Task task = runner.getTask(); task.Start(); task.Wait(); Assert.AreEqual("Override", output.OutputDir); }
private static void RunSingleProcessingBlockPipeline() { Console.WriteLine(); Console.WriteLine("SingleProcessingBlockPipeline"); var singleProcessingBlockPipelineFactory = new SingleProcessingBlockPipelineFactory(new Pipelines.PeopleBatchesStream.BlockFactories.ReadingBlockFactory(new FileLinesCounter(), new DataReader(new DataParser()), new StreamLinesReader(), new DataParser()), new PersonValidator(), new PersonFieldsComputer(), new Pipelines.PeopleBatchesStream.BlockFactories.WritingBlockFactory(new DataWriter()), new ProgressReportingBlockFactory(), new StraightPipelineFactory()); var pipelineExecutor = new PipelineExecutor(); using (var cancellationSource = new CancellationTokenSource()) { var progress = new Progress <PipelineProgress>(x => Console.WriteLine($"{x.Percentage}% processed.")); var pipeline = singleProcessingBlockPipelineFactory.Create(Settings.PeopleJsonFilePath, Settings.PeopleTargetFilePath, progress, cancellationSource); Task.Run(() => WaitForCancellation(cancellationSource)); var executionResult = pipelineExecutor.Execute(pipeline).Result; HandleExecutionResult(executionResult); } PrintDataPoolSize(); }
public void X() { var fileReaderConfig = new SinglefileLoaderStepConfig { FileName = "TestCsv.csv" }; var csvConfig = new FlatFileReaderConfiguration { }; var etlPipelineConfiguration = new List <ConfiguredEtlStep> { new ConfiguredEtlStep { StepType = typeof(SingleFileLoaderStep), Config = fileReaderConfig }, new ConfiguredEtlStep { StepType = typeof(CsvReaderEtlStep), Config = csvConfig } }; var container = new Container(); container.Register <CsvReaderEtlStep>(); container.Register <SingleFileLoaderStep>(); container.Register <ICsvRecordSelector, SingleRecordCsvRecordReaderSelector>(); var pipeline = EtlProcessFactory.CreateEtlPipeline(container, etlPipelineConfiguration); PipelineExecutor.RunPipeline(pipeline, x => { }, x => { }); }
public static IDisposable SetConnection(this PipelineExecutor pipelineExecutor, string connectionString, SqlConnection connection) { var key = MakeConnectionKey(connectionString); pipelineExecutor.CurrentContext.Set(key, connection); return(new ContextItemRemovalDisposable(key, pipelineExecutor)); }
public NativeTransactionReceiveStrategy(string connectionString, TableBasedQueue errorQueue, Func<TransportMessage, bool> tryProcessMessageCallback, PipelineExecutor pipelineExecutor, TransactionSettings transactionSettings) { this.pipelineExecutor = pipelineExecutor; this.tryProcessMessageCallback = tryProcessMessageCallback; this.errorQueue = errorQueue; this.connectionString = connectionString; isolationLevel = GetSqlIsolationLevel(transactionSettings.IsolationLevel); }
public NativeTransactionReceiveStrategy(string connectionString, TableBasedQueue errorQueue, Func <TransportMessage, bool> tryProcessMessageCallback, PipelineExecutor pipelineExecutor, TransactionSettings transactionSettings) { this.pipelineExecutor = pipelineExecutor; this.tryProcessMessageCallback = tryProcessMessageCallback; this.errorQueue = errorQueue; this.connectionString = connectionString; isolationLevel = GetSqlIsolationLevel(transactionSettings.IsolationLevel); }
/// <summary> /// Get the vhd path for a given named vm /// </summary> /// <param name="vmName">Name of the VM</param> /// <returns></returns> public string GetVHDPath(string vmName) { PipelineExecutor pexec = new PipelineExecutor(); Dictionary <string, object> getVHDPathParameters = new Dictionary <string, object>(); getVHDPathParameters.Add("VMName", vmName); ICollection <PSObject> results = pexec.RunScript(".\\PsScripts\\GetVHDPath.ps1", getVHDPathParameters, this._iss); if (null != results && null != results.ElementAt(2)) { return(results.ElementAt(2).ToString()); } return(String.Empty); }
private void StopScript() { if (_pipelineExecutor != null) { _pipelineExecutor.OnDataReady -= new PipelineExecutor.DataReadyDelegate(pipelineExecutor_OnDataReady); _pipelineExecutor.OnDataEnd -= new PipelineExecutor.DataEndDelegate(pipelineExecutor_OnDataEnd); _pipelineExecutor.Stop(); _pipelineExecutor = null; } }
public AmbientTransactionReceiveStrategy(string connectionString, TableBasedQueue errorQueue, Func <TransportMessage, bool> tryProcessMessageCallback, PipelineExecutor pipelineExecutor, TransactionSettings transactionSettings) { this.pipelineExecutor = pipelineExecutor; this.tryProcessMessageCallback = tryProcessMessageCallback; this.errorQueue = errorQueue; this.connectionString = connectionString; transactionOptions = new TransactionOptions { IsolationLevel = transactionSettings.IsolationLevel, Timeout = transactionSettings.TransactionTimeout }; }
public BehaviorChain(IEnumerable <Type> behaviorList, T context, PipelineExecutor pipelineExecutor, BusNotifications notifications) { context.SetChain(this); this.context = context; this.notifications = notifications; foreach (var behaviorType in behaviorList) { itemDescriptors.Enqueue(behaviorType); } lookupSteps = pipelineExecutor.Incoming.Concat(pipelineExecutor.Outgoing).ToDictionary(rs => rs.BehaviorType); }
public AmbientTransactionReceiveStrategy(string connectionString, TableBasedQueue errorQueue, Func<TransportMessage, bool> tryProcessMessageCallback, PipelineExecutor pipelineExecutor, TransactionSettings transactionSettings) { this.pipelineExecutor = pipelineExecutor; this.tryProcessMessageCallback = tryProcessMessageCallback; this.errorQueue = errorQueue; this.connectionString = connectionString; transactionOptions = new TransactionOptions { IsolationLevel = transactionSettings.IsolationLevel, Timeout = transactionSettings.TransactionTimeout }; }
public void Preview() { RunEtlStepResults.Clear(); var types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(x => x.GetTypes()).EtlSteps().ToList(); var container = new SimpleInjector.Container(); types.ForEach(x => container.Register(x)); var pipeline = EtlProcessFactory.CreateEtlPipeline(container, this.EtlSteps.ToList()); PipelineExecutor.RunPipeline(pipeline, context => { }, context => { RunEtlStepResults.Add(context); }); }
private void pipelineExecutor_OnDataEnd(PipelineExecutor sender) { if (sender.Pipeline.PipelineStateInfo.State == PipelineState.Failed) { _display.AppendError(string.Format("Error in script: {0}", sender.Pipeline.PipelineStateInfo.Reason)); OnScriptComplete(false); } else { OnScriptComplete(true); } _display.AppendLine("Ready"); }
public async void PipelineExecutor_Returns_Exact_Value_When_Query_Is_Executed() { var propertyValue = nameof(PipelineExecutor_Passes_Exact_Parameters_When_Executed); var processor = Processor.From(ctx => ctx.InfoResult(propertyValue, "Result is set.")); var pipeline = Pipeline.From(processor); var pipelineExecutor = new PipelineExecutor(pipeline); var args = new Bag(); (await pipelineExecutor.Run <string>(args)) .Should() .Be(propertyValue); }
public async void PipelineExecutor_Passes_Exact_Parameters_When_Executed() { var property = nameof(PipelineExecutor_Passes_Exact_Parameters_When_Executed); var processor = Processor.From(ctx => ctx.Set(property, true)); var pipeline = Pipeline.From(processor); var pipelineExecutor = new PipelineExecutor(pipeline); var args = new Bag(); await pipelineExecutor.Run(args).ConfigureAwait(false); args.Get(property, false) .Should() .BeTrue("context should have set up a property in passed context"); }
public async void PipelineExecutor_Uses_Exact_PipelineRunner_When_Being_Executed() { var pipelineRunner = new Mock <Runner>(null, null, null, null); var pipeline = new Mock <IPipeline>(); var pipelineExecutor = new PipelineExecutor(pipeline.Object, pipelineRunner.Object); pipeline.Setup(x => x.GetProcessors()).Returns(Enumerable.Empty <IProcessor>()); await pipelineExecutor.Run(null).ConfigureAwait(false); pipelineRunner.Verify( runner => runner.Run( It.IsAny <IPipeline>(), It.IsAny <Bag>() ), Times.AtLeastOnce); }
public async void PipelineExecutor_Uses_Exact_PipelineRunner_When_Being_Executed() { var pipelineRunner = new Mock <PipelineRunner>(); var pipeline = new Mock <IPipeline>(); var pipelineExecutor = new PipelineExecutor(pipeline.Object, pipelineRunner.Object); pipeline.Setup(x => x.GetProcessors()).Returns(Enumerable.Empty <IProcessor>()); await pipelineExecutor.Execute(string.Empty); pipelineRunner.Verify( runner => runner.RunPipeline( It.IsAny <IPipeline>(), It.IsAny <object>() ), Times.AtLeastOnce); }
public void Test() { var fileReaderConfig = new SinglefileLoaderStepConfig { FileName = "TestCsv.csv" }; var csvConfig = new CsvReaderConfiguration { SkipHeader = true, CsvRecords = { new CsvRecord { Name = "Test", TableName = "Data", Fields = { new CsvField { Name = "Field1", Position = 1, DefaultValue = "", Type = typeof(string) }, new CsvField { Name = "Field2", Position = 2, DefaultValue = null, Type = typeof(DateTime) }, new CsvField { Name = "Field3", Position = 3, DefaultValue = 1, Type = typeof(int) }, } } } }; var etlPipelineConfiguration = new List <ConfiguredEtlStep> { new ConfiguredEtlStep { StepType = typeof(SingleFileLoaderStep), Config = fileReaderConfig }, new ConfiguredEtlStep { StepType = typeof(CsvReaderEtlStep), Config = csvConfig } }; var container = new Container(); container.Register <CsvReaderEtlStep>(); container.Register <SingleFileLoaderStep>(); container.Register <ICsvRecordSelector, SingleRecordCsvRecordReaderSelector>(); var pipeline = EtlProcessFactory.CreateEtlPipeline(container, etlPipelineConfiguration); PipelineExecutor.RunPipeline(pipeline, context => { }, context => { }); }
void pipelineExecutor_OnErrorReady(PipelineExecutor sender, ICollection <object> data) { foreach (object e in data) { var message = e.ToString(); if (message.ToUpper().Contains("ERROR")) { _display.AppendError(message); } else { _display.AppendInfo(message); } } _display.AppendLine(""); }
void InnerHandle(TransportMessage message) { var errorMessageReceived = new ImportFailedMessage(message); var logicalMessage = LogicalMessageFactory.Create(typeof(ImportFailedMessage), errorMessageReceived); using (var childBuilder = Builder.CreateChildBuilder()) { PipelineExecutor.CurrentContext.Set(childBuilder); foreach (var enricher in childBuilder.BuildAll <IEnrichImportedMessages>()) { enricher.Enrich(errorMessageReceived); } PipelineExecutor.InvokeLogicalMessagePipeline(logicalMessage); } Forwarder.Send(message, Settings.ErrorLogQueue); }
private void ProcessMessagesFromBridge() { using (SqlConnection conn = new SqlConnection(Context.BridgeConnectionString.Invoke())) { conn.Open(); string sql = "SELECT MessageId, Source, Destination, Intent, Processed, Headers, Body FROM [dbo].[Bridge] WHERE Processed = 0 AND (Destination = @Destination OR Destination IS NULL)"; SqlCommand cmd = new SqlCommand(sql, conn); cmd.Parameters.AddWithValue("@Destination", Settings.EndpointName()); var reader = cmd.ExecuteReader(); while (reader.Read()) { string id = reader.GetString(reader.GetOrdinal("MessageId")); string source = reader.GetString(reader.GetOrdinal("Source")); string dest = reader.IsDBNull(reader.GetOrdinal("Destination")) ? null : reader.GetString(reader.GetOrdinal("Destination")); string intent = reader.GetString(reader.GetOrdinal("Intent")); var msgIntent = (MessageIntentEnum)Enum.Parse(typeof(MessageIntentEnum), intent); Dictionary <string, string> headers = JsonConvert.DeserializeObject <Dictionary <string, string> >(reader.GetString(reader.GetOrdinal("Headers"))); var messageTypes = headers[Headers.EnclosedMessageTypes].Split(';').Select(i => Type.GetType(i)).ToList(); if (ShouldHandleMessage(dest, messageTypes)) { var bodyStream = reader.GetStream(reader.GetOrdinal("Body")); byte[] body = new byte[bodyStream.Length]; body = GetByteArray(bodyStream); //Let's treat this message as a normal incoming message. var transportMessage = new TransportMessage(id, headers); transportMessage.Body = body; transportMessage.MessageIntent = msgIntent; var incomingContext = new IncomingContext(null, transportMessage); incomingContext.Set <IBuilder>(Builder); PipelineExecutor.InvokePipeline(PipelineExecutor.Incoming.Select(i => i.BehaviorType), incomingContext); var cmd2 = new SqlCommand("UPDATE [dbo].[Bridge] SET Processed = 1 WHERE MessageId = @MessageId", conn); cmd2.Parameters.AddWithValue("@MessageId", id); cmd2.ExecuteNonQuery(); } } } }
public override IDbConnection GetConnection() { string defaultConnectionString = ConfigurationManager.ConnectionStrings["NServiceBus/Persistence"] .ConnectionString; #region GetConnectionFromContext Lazy <IDbConnection> lazy; PipelineExecutor pipelineExecutor = Program.PipelineExecutor; string key = $"LazySqlConnection-{defaultConnectionString}"; if (pipelineExecutor != null && pipelineExecutor.CurrentContext.TryGet(key, out lazy)) { IDbConnection connection = Driver.CreateConnection(); connection.ConnectionString = lazy.Value.ConnectionString; connection.Open(); return(connection); } return(base.GetConnection()); #endregion }
protected IBuilder Activate(BusConfiguration busConfiguration, ConfigBase featureConfig, string connectionString = "") { var builder = new TestBuilder(); busConfiguration.UseContainer(builder); var configure = (Configure)typeof(BusConfiguration).GetMethod("BuildConfiguration", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(busConfiguration, new object[0]); var featureContext = (FeatureConfigurationContext)typeof(FeatureConfigurationContext).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, new[] { typeof(Configure) }, new ParameterModifier[0]).Invoke(new object[] { configure }); var settings = busConfiguration.GetSettings(); featureConfig.SetUpDefaults(settings); featureConfig.Configure(featureContext, connectionString); builder.CallAllFactories(); Builder = configure.Builder; PipelineExecutor = new PipelineExecutor(settings, configure.Builder); return(configure.Builder); }
void InnerHandle(TransportMessage message) { var receivedMessage = new ImportSuccessfullyProcessedMessage(message); using (var childBuilder = Builder.CreateChildBuilder()) { PipelineExecutor.CurrentContext.Set(childBuilder); foreach (var enricher in childBuilder.BuildAll <IEnrichImportedMessages>()) { enricher.Enrich(receivedMessage); } var logicalMessage = LogicalMessageFactory.Create(typeof(ImportSuccessfullyProcessedMessage), receivedMessage); PipelineExecutor.InvokeLogicalMessagePipeline(logicalMessage); } if (Settings.ForwardAuditMessages == true) { Forwarder.Send(message, Settings.AuditLogQueue); } }
public void StartScript(string command) { StopScript(); VerifyDirectory(); string fullPathCommand; if (command.StartsWith(@".\")) { fullPathCommand = command.Replace(@".\", _workingDirectory + "\\"); } else { fullPathCommand = command; } _pipelineExecutor = new PipelineExecutor(_runSpace, _display, fullPathCommand); _pipelineExecutor.OnDataReady += new PipelineExecutor.DataReadyDelegate(pipelineExecutor_OnDataReady); _pipelineExecutor.OnDataEnd += new PipelineExecutor.DataEndDelegate(pipelineExecutor_OnDataEnd); _pipelineExecutor.OnErrorReady += new PipelineExecutor.ErrorReadyDelegate(pipelineExecutor_OnErrorReady); _pipelineExecutor.Start(); if (!_internalResponseHandling) { _display.AppendCommand(command); } }
public void SetUp() { LicenseManager.InitializeLicense(); transportDefinition = new MsmqTransport(); settings = new SettingsHolder(); settings.SetDefault("EndpointName", "TestEndpoint"); settings.SetDefault("Endpoint.SendOnly", false); settings.SetDefault("MasterNode.Address", MasterNodeAddress); pipelineModifications = new PipelineModifications(); settings.Set <PipelineModifications>(pipelineModifications); ApplyPipelineModifications(); Transport = new FakeTransport(); FuncBuilder = new FuncBuilder(); FuncBuilder.Register <ReadOnlySettings>(() => settings); router = new StaticMessageRouter(KnownMessageTypes()); var conventions = new Conventions(); handlerRegistry = new MessageHandlerRegistry(conventions); MessageMetadataRegistry = new MessageMetadataRegistry(false, conventions); MessageSerializer = new XmlMessageSerializer(MessageMapper, conventions); messageSender = MockRepository.GenerateStub <ISendMessages>(); subscriptionStorage = new FakeSubscriptionStorage(); configure = new Configure(settings, FuncBuilder, new List <Action <IConfigureComponents> >(), new PipelineSettings(null)) { localAddress = Address.Parse("TestEndpoint") }; subscriptionManager = new SubscriptionManager { MessageSender = messageSender, SubscriptionStorage = subscriptionStorage, Configure = configure }; pipelineFactory = new PipelineExecutor(settings, FuncBuilder); FuncBuilder.Register <IMessageSerializer>(() => MessageSerializer); FuncBuilder.Register <ISendMessages>(() => messageSender); FuncBuilder.Register <LogicalMessageFactory>(() => new LogicalMessageFactory(MessageMetadataRegistry, MessageMapper, pipelineFactory)); FuncBuilder.Register <IManageSubscriptions>(() => subscriptionManager); FuncBuilder.Register <EstimatedTimeToSLABreachCalculator>(() => SLABreachCalculator); FuncBuilder.Register <MessageMetadataRegistry>(() => MessageMetadataRegistry); FuncBuilder.Register <IMessageHandlerRegistry>(() => handlerRegistry); FuncBuilder.Register <IMessageMapper>(() => MessageMapper); FuncBuilder.Register <DeserializeLogicalMessagesBehavior>(() => new DeserializeLogicalMessagesBehavior { MessageSerializer = MessageSerializer, MessageMetadataRegistry = MessageMetadataRegistry, }); FuncBuilder.Register <CreatePhysicalMessageBehavior>(() => new CreatePhysicalMessageBehavior()); FuncBuilder.Register <PipelineExecutor>(() => pipelineFactory); FuncBuilder.Register <TransportDefinition>(() => transportDefinition); var messagePublisher = new StorageDrivenPublisher { MessageSender = messageSender, SubscriptionStorage = subscriptionStorage }; var deferrer = new TimeoutManagerDeferrer { MessageSender = messageSender, TimeoutManagerAddress = MasterNodeAddress.SubScope("Timeouts"), Configure = configure, }; FuncBuilder.Register <IDeferMessages>(() => deferrer); FuncBuilder.Register <IPublishMessages>(() => messagePublisher); bus = new UnicastBus { Builder = FuncBuilder, MessageSender = messageSender, Transport = Transport, MessageMapper = MessageMapper, SubscriptionManager = subscriptionManager, MessageRouter = router, Settings = settings, Configure = configure, HostInformation = new HostInformation(Guid.NewGuid(), "HelloWorld") }; FuncBuilder.Register <IMutateOutgoingTransportMessages>(() => new CausationMutator { Bus = bus }); FuncBuilder.Register <IBus>(() => bus); FuncBuilder.Register <UnicastBus>(() => bus); FuncBuilder.Register <Conventions>(() => conventions); FuncBuilder.Register <Configure>(() => configure); }
public SqlServerMessageSender(IConnectionStringProvider connectionStringProvider, PipelineExecutor pipelineExecutor) { this.connectionStringProvider = connectionStringProvider; this.pipelineExecutor = pipelineExecutor; }
public void Setup() { this.pipelineFactory = Substitute.For <IPipelineFactory>(); this.pipelineExecutor = new PipelineExecutor(this.pipelineFactory); }
internal SqlServerStorageContext(PipelineExecutor pipelineExecutor, LocalConnectionParams localConnectionParams) { this.pipelineExecutor = pipelineExecutor; this.localConnectionParams = localConnectionParams; }
static void Main() { Console.Title = "Samples.MultiTenant.Receiver"; var hibernateConfig = CreateBasicNHibernateConfig(); var mapper = new ModelMapper(); mapper.AddMapping<OrderMap>(); hibernateConfig.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities()); var busConfiguration = new BusConfiguration(); busConfiguration.UseSerialization<JsonSerializer>(); busConfiguration.EndpointName("Samples.MultiTenant.Receiver"); #region ReceiverConfiguration var persistence = busConfiguration.UsePersistence<NHibernatePersistence>(); persistence.RegisterManagedSessionInTheContainer(); persistence.UseConfiguration(hibernateConfig); persistence.UseSubscriptionStorageConfiguration(CreateBasicNHibernateConfig()); persistence.UseTimeoutStorageConfiguration(CreateBasicNHibernateConfig()); persistence.DisableSchemaUpdate(); busConfiguration.EnableOutbox(); var settingsHolder = busConfiguration.GetSettings(); settingsHolder.Set("NHibernate.Timeouts.AutoUpdateSchema", true); settingsHolder.Set("NHibernate.Subscriptions.AutoUpdateSchema", true); #endregion #region ReplaceOpenSqlConnection busConfiguration.Pipeline.Replace("OpenSqlConnection", typeof(MultiTenantOpenSqlConnectionBehavior)); #endregion #region RegisterPropagateTenantIdBehavior busConfiguration.Pipeline.Register<PropagateTenantIdBehavior.Registration>(); #endregion busConfiguration.DisableFeature<SecondLevelRetries>(); #region CreateSchema var startableBus = Bus.Create(busConfiguration); CreateSchema(hibernateConfig, "A"); CreateSchema(hibernateConfig, "B"); #endregion #region CapturePipelineExecutor PipelineExecutor = ((UnicastBus) startableBus).Builder.Build<PipelineExecutor>(); #endregion using (startableBus.Start()) { Console.WriteLine("Press any key to exit"); Console.ReadKey(); } }
public ContextItemRemovalDisposable(string contextKey, PipelineExecutor pipelineExecutor) { this.contextKey = contextKey; this.pipelineExecutor = pipelineExecutor; }
public ContextualConnectionStore(PipelineExecutor pipelineExecutor) { this.pipelineExecutor = pipelineExecutor; }
/// <summary> /// Ctor /// </summary> /// <param name="messageMetadataRegistry"></param> /// <param name="messageMapper"></param> /// <param name="pipelineExecutor"></param> public LogicalMessageFactory(MessageMetadataRegistry messageMetadataRegistry, IMessageMapper messageMapper, PipelineExecutor pipelineExecutor) { this.messageMetadataRegistry = messageMetadataRegistry; this.messageMapper = messageMapper; this.pipelineExecutor = pipelineExecutor; }
internal ServiceFabricStorageContext(PipelineExecutor pipelineExecutor, IReliableStateManager stateManager) { this.pipelineExecutor = pipelineExecutor; StateManager = stateManager; }
public ReceiveStrategyFactory(PipelineExecutor pipelineExecutor, LocalConnectionParams localConnectionParams, Address errorQueueAddress) { this.pipelineExecutor = pipelineExecutor; this.errorQueueAddress = errorQueueAddress; this.localConnectionParams = localConnectionParams; }
internal NHibernateStorageContext(PipelineExecutor pipelineExecutor, string connectionString) { this.pipelineExecutor = pipelineExecutor; this.connectionString = connectionString; }
static void Main() { Console.Title = "Samples.MultiTenant.Receiver"; var hibernateConfig = CreateBasicNHibernateConfig(); var mapper = new ModelMapper(); mapper.AddMapping <OrderMap>(); hibernateConfig.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities()); var busConfiguration = new BusConfiguration(); busConfiguration.EndpointName("Samples.MultiTenant.Receiver"); #region ReceiverConfiguration var persistence = busConfiguration.UsePersistence <NHibernatePersistence>(); persistence.RegisterManagedSessionInTheContainer(); persistence.UseConfiguration(hibernateConfig); persistence.UseSubscriptionStorageConfiguration(CreateBasicNHibernateConfig()); persistence.UseTimeoutStorageConfiguration(CreateBasicNHibernateConfig()); persistence.DisableSchemaUpdate(); busConfiguration.EnableOutbox(); var settingsHolder = busConfiguration.GetSettings(); settingsHolder.Set("NHibernate.Timeouts.AutoUpdateSchema", true); settingsHolder.Set("NHibernate.Subscriptions.AutoUpdateSchema", true); #endregion #region ReplaceOpenSqlConnection busConfiguration.Pipeline.Replace("OpenSqlConnection", typeof(MultiTenantOpenSqlConnectionBehavior)); #endregion #region RegisterPropagateTenantIdBehavior busConfiguration.Pipeline.Register <PropagateTenantIdBehavior.Registration>(); #endregion var startableBus = Bus.Create(busConfiguration); #region CreateSchema CreateSchema(hibernateConfig, Connections.TenantA); CreateSchema(hibernateConfig, Connections.TenantB); #endregion #region CapturePipelineExecutor PipelineExecutor = ((UnicastBus)startableBus).Builder.Build <PipelineExecutor>(); #endregion using (startableBus.Start()) { Console.WriteLine("Press any key to exit"); Console.ReadKey(); } }
public Root(PipelineExecutor pipelineExecutor) { Get["/"] = _ => View["index.html"]; Get["/api"] = _ => Response.AsJson(new { incoming = pipelineExecutor.Incoming, outgoing = pipelineExecutor.Outgoing }); }