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);
}
public SqlServerMessageSender(IConnectionStringProvider connectionStringProvider, PipelineExecutor pipelineExecutor)
{
this.connectionStringProvider = connectionStringProvider;
this.pipelineExecutor = pipelineExecutor;
}
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;
}
internal SqlServerStorageContext(PipelineExecutor pipelineExecutor, LocalConnectionParams localConnectionParams)
{
this.pipelineExecutor = pipelineExecutor;
this.localConnectionParams = localConnectionParams;
}
/// <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 });
}
