private static IUnityContainer ConfigureOperationsProcessing(this IUnityContainer container,
IEnvironmentSettings environmentSettings,
IConnectionStringSettings connectionStringSettings)
{
var kafkaSettingsFactory =
new KafkaSettingsFactory(new Dictionary <IMessageFlow, string>
{
[AliasForAmsFactsFlow.Instance] = connectionStringSettings.GetConnectionString(AmsConnectionStringIdentity.Instance)
},
environmentSettings);
return(container.RegisterInstance <IKafkaSettingsFactory>(kafkaSettingsFactory)
.RegisterType <KafkaMessageFlowInfoProvider>(new ContainerControlledLifetimeManager()));
}
private static IUnityContainer ConfigureOperationsProcessing(
this IUnityContainer container,
IConnectionStringSettings connectionStringSettings,
IEnvironmentSettings environmentSettings)
{
#if DEBUG
container.RegisterType <ITelemetryPublisher, DebugTelemetryPublisher>(Lifetime.Singleton);
#else
container.RegisterType <ITelemetryPublisher, CachingTelemetryPublisherDecorator <LogstashTelemetryPublisher> >(Lifetime.Singleton);
#endif
// primary
container.RegisterInstance(new EntityTypeMappingRegistryBuilder().Create <ErmSubDomain>(), Lifetime.Singleton)
.RegisterType <IOperationIdentityRegistry, EmptyOperationIdentityRegistry>(Lifetime.Singleton)
.RegisterTypeWithDependencies(typeof(ServiceBusMessageReceiverTelemetryDecorator), Lifetime.PerScope, null)
.RegisterOne2ManyTypesPerTypeUniqueness <IRuntimeTypeModelConfigurator, ProtoBufTypeModelForTrackedUseCaseConfigurator <ErmSubDomain> >(Lifetime.Singleton)
.RegisterTypeWithDependencies(typeof(BinaryEntireBrokeredMessage2TrackedUseCaseTransformer), Lifetime.Singleton, null)
.RegisterType <IXmlEventSerializer, XmlEventSerializer>();
// final
container.RegisterTypeWithDependencies(typeof(AggregatesFlowHandler), Lifetime.PerResolve, null);
container.RegisterType <IEventLoggingStrategyProvider, UnityEventLoggingStrategyProvider>()
.RegisterType <IEvent2BrokeredMessageConverter <IEvent>, Event2BrokeredMessageConverter>()
.RegisterType <IEventLogger, SequentialEventLogger>()
.RegisterType <IServiceBusMessageSender, BatchingServiceBusMessageSender>();
var kafkaSettingsFactory =
new KafkaSettingsFactory(new Dictionary <IMessageFlow, string>
{
[AmsFactsFlow.Instance] =
connectionStringSettings.GetConnectionString(AmsConnectionStringIdentity.Instance),
[RulesetFactsFlow.Instance] =
connectionStringSettings.GetConnectionString(RulesetConnectionStringIdentity.Instance)
},
environmentSettings
);
// kafka receiver
container
.RegisterType <BatchingKafkaReceiverTelemetryDecorator <AmsFactsFlowTelemetryPublisher> >(new InjectionConstructor(new ResolvedParameter <KafkaReceiver>(nameof(AmsFactsFlow)),
typeof(AmsFactsFlowTelemetryPublisher)))
.RegisterType <BatchingKafkaReceiverTelemetryDecorator <RulesetFactsFlowTelemetryPublisher> >(new InjectionConstructor(new ResolvedParameter <KafkaReceiver>(nameof(RulesetFactsFlow)),
typeof(RulesetFactsFlowTelemetryPublisher)))
.RegisterType <KafkaReceiver>(nameof(AmsFactsFlow), Lifetime.Singleton)
.RegisterType <KafkaReceiver>(nameof(RulesetFactsFlow), Lifetime.Singleton)
.RegisterType <IKafkaMessageFlowReceiverFactory, KafkaMessageFlowReceiverFactory>(Lifetime.Singleton)
.RegisterInstance <IKafkaSettingsFactory>(kafkaSettingsFactory)
.RegisterType <KafkaMessageFlowInfoProvider>(Lifetime.Singleton);
return(container.RegisterInstance <IParentContainerUsedRegistrationsContainer>(new ParentContainerUsedRegistrationsContainer(), Lifetime.Singleton)
.RegisterType(typeof(ServiceBusMessageFlowReceiver), Lifetime.Singleton)
.RegisterType <IServiceBusLockRenewer, NullServiceBusLockRenewer>(Lifetime.Singleton)
.RegisterType <IServiceBusSettingsFactory, ServiceBusSettingsFactory>(Lifetime.Singleton)
.RegisterType <IServiceBusMessageFlowReceiverFactory, ServiceBusMessageFlowReceiverFactory>(Lifetime.PerScope)
.RegisterType <IMessageProcessingStagesFactory, UnityMessageProcessingStagesFactory>(Lifetime.PerScope)
.RegisterType <IMessageFlowProcessorFactory, UnityMessageFlowProcessorFactory>(Lifetime.PerScope)
.RegisterType <IMessageReceiverFactory, UnityMessageReceiverFactory>(Lifetime.PerScope)
.RegisterOne2ManyTypesPerTypeUniqueness <IMessageFlowProcessorResolveStrategy, PrimaryProcessorResolveStrategy>(Lifetime.Singleton)
.RegisterOne2ManyTypesPerTypeUniqueness <IMessageFlowProcessorResolveStrategy, FinalProcessorResolveStrategy>(Lifetime.PerScope)
.RegisterOne2ManyTypesPerTypeUniqueness <IMessageFlowReceiverResolveStrategy, MessageFlowReceiverResolveStrategy>(Lifetime.PerScope)
.RegisterType <IMessageValidatorFactory, UnityMessageValidatorFactory>(Lifetime.PerScope)
.RegisterType <IMessageTransformerFactory, UnityMessageTransformerFactory>(Lifetime.PerScope)
.RegisterOne2ManyTypesPerTypeUniqueness <IMessageTransformerResolveStrategy, PrimaryMessageTransformerResolveStrategy>(Lifetime.PerScope)
.RegisterType <IMessageProcessingHandlerFactory, UnityMessageProcessingHandlerFactory>(Lifetime.PerScope)
.RegisterType <IMessageProcessingContextAccumulatorFactory, UnityMessageProcessingContextAccumulatorFactory>(Lifetime.PerScope)
.RegisterType <IMessageFlowProcessingObserver, NullMessageFlowProcessingObserver>(Lifetime.Singleton));
}
public static void Main(string[] args)
{
StateInitializationRoot.Instance.PerformTypesMassProcessing(Array.Empty <IMassProcessor>(), true, typeof(object));
var commands = new List <ICommand>();
if (args.Contains("-facts"))
{
commands.Add(BulkReplicationCommands.ErmToFacts);
// Надо подумать о лишней обёртке
commands.Add(new KafkaReplicationCommand(AmsFactsFlow.Instance, BulkReplicationCommands.AmsToFacts));
commands.Add(new KafkaReplicationCommand(RulesetFactsFlow.Instance, BulkReplicationCommands.RulesetsToFacts));
commands.Add(SchemaInitializationCommands.WebApp);
commands.Add(SchemaInitializationCommands.Facts);
}
if (args.Contains("-aggregates"))
{
commands.Add(BulkReplicationCommands.FactsToAggregates);
commands.Add(SchemaInitializationCommands.WebApp);
commands.Add(SchemaInitializationCommands.Aggregates);
}
if (args.Contains("-messages"))
{
commands.Add(BulkReplicationCommands.AggregatesToMessages);
commands.Add(SchemaInitializationCommands.WebApp);
commands.Add(SchemaInitializationCommands.Messages);
}
var connectionStrings = ConnectionStrings.For(ErmConnectionStringIdentity.Instance,
AmsConnectionStringIdentity.Instance,
FactsConnectionStringIdentity.Instance,
AggregatesConnectionStringIdentity.Instance,
MessagesConnectionStringIdentity.Instance,
RulesetConnectionStringIdentity.Instance);
var connectionStringSettings = new ConnectionStringSettingsAspect(connectionStrings);
var environmentSettings = new EnvironmentSettingsAspect();
var businessModelSettings = new BusinessModelSettingsAspect();
var tracer = CreateTracer(environmentSettings, businessModelSettings);
var kafkaSettingsFactory =
new KafkaSettingsFactory(new Dictionary <IMessageFlow, string>
{
[AmsFactsFlow.Instance] =
connectionStringSettings.GetConnectionString(AmsConnectionStringIdentity.Instance),
[RulesetFactsFlow.Instance] =
connectionStringSettings.GetConnectionString(RulesetConnectionStringIdentity.Instance)
},
environmentSettings,
Offset.Beginning);
var kafkaMessageFlowReceiverFactory = new KafkaMessageFlowReceiverFactory(new NullTracer(), kafkaSettingsFactory);
var dataObjectTypesProviderFactory = new DataObjectTypesProviderFactory();
var bulkReplicationActor = new BulkReplicationActor(dataObjectTypesProviderFactory, connectionStringSettings);
var kafkaReplicationActor = new KafkaReplicationActor(connectionStringSettings,
dataObjectTypesProviderFactory,
kafkaMessageFlowReceiverFactory,
new KafkaMessageFlowInfoProvider(kafkaSettingsFactory),
new IBulkCommandFactory <Message>[]
{
new AmsFactsBulkCommandFactory(),
new RulesetFactsBulkCommandFactory(businessModelSettings)
},
tracer);
var schemaInitializationActor = new SchemaInitializationActor(connectionStringSettings);
var sw = Stopwatch.StartNew();
schemaInitializationActor.ExecuteCommands(commands);
bulkReplicationActor.ExecuteCommands(commands.Where(x => x == BulkReplicationCommands.ErmToFacts).ToList());
kafkaReplicationActor.ExecuteCommands(commands);
bulkReplicationActor.ExecuteCommands(commands.Where(x => x != BulkReplicationCommands.ErmToFacts).ToList());
Console.WriteLine($"Total time: {sw.ElapsedMilliseconds}ms");
}
public static void Main(string[] args)
{
StateInitializationRoot.Instance.PerformTypesMassProcessing(Array.Empty <IMassProcessor>(), true,
typeof(object));
var commands = new List <ICommand>();
if (args.Any(x => x.Contains("-facts")))
{
commands.AddRange(BulkReplicationCommands.ErmToFacts
.Where(x => IsConfigured(x.SourceStorageDescriptor)));
commands.Add(new KafkaReplicationCommand(AmsFactsFlow.Instance, BulkReplicationCommands.AmsToFacts));
commands.Add(new KafkaReplicationCommand(RulesetFactsFlow.Instance, BulkReplicationCommands.RulesetsToFacts, 500));
// TODO: отдельный schema init для erm\ams\ruleset facts
commands.Add(SchemaInitializationCommands.Facts);
}
if (args.Contains("-aggregates"))
{
commands.Add(BulkReplicationCommands.FactsToAggregates);
commands.Add(SchemaInitializationCommands.Aggregates);
}
if (args.Contains("-messages"))
{
commands.AddRange(BulkReplicationCommands.ErmToMessages
.Where(x => IsConfigured(x.SourceStorageDescriptor)));
commands.Add(BulkReplicationCommands.AggregatesToMessages);
commands.Add(SchemaInitializationCommands.Messages);
}
var environmentSettings = new EnvironmentSettingsAspect();
var tracer = CreateTracer(environmentSettings);
var kafkaSettingsFactory = new KafkaSettingsFactory(new Dictionary <IMessageFlow, string>
{
{
AmsFactsFlow.Instance,
ConnectionStringSettings.GetConnectionString(AmsConnectionStringIdentity.Instance)
},
{
RulesetFactsFlow.Instance,
ConnectionStringSettings.GetConnectionString(RulesetConnectionStringIdentity.Instance)
}
},
environmentSettings);
var kafkaMessageFlowReceiverFactory =
new StateInitKafkaMessageFlowReceiverFactory(new NullTracer(), kafkaSettingsFactory);
var bulkReplicationActor = new BulkReplicationActor(ConnectionStringSettings);
var kafkaReplicationActor = new KafkaReplicationActor(ConnectionStringSettings,
kafkaMessageFlowReceiverFactory,
new KafkaMessageFlowInfoProvider(kafkaSettingsFactory),
new IBulkCommandFactory <ConsumeResult <Ignore, byte[]> >[]
{
new AmsFactsBulkCommandFactory(),
new RulesetFactsBulkCommandFactory()
},
tracer);
var schemaInitializationActor = new SchemaInitializationActor(ConnectionStringSettings);
var sw = Stopwatch.StartNew();
schemaInitializationActor.ExecuteCommands(commands);
bulkReplicationActor.ExecuteCommands(commands.Where(x => BulkReplicationCommands.ErmToFacts.Contains(x))
.ToList());
kafkaReplicationActor.ExecuteCommands(commands);
bulkReplicationActor.ExecuteCommands(commands.Where(x => !BulkReplicationCommands.ErmToFacts.Contains(x))
.ToList());
var webAppSchemaHelper = new WebAppSchemaInitializationHelper(ConnectionStringSettings);
if (args.Contains("-webapp"))
{
webAppSchemaHelper.CreateWebAppSchema(SchemaInitializationCommands.WebApp);
}
if (args.Contains("-webapp-drop"))
{
webAppSchemaHelper.DropWebAppSchema(SchemaInitializationCommands.WebApp);
}
Console.WriteLine($"Total time: {sw.ElapsedMilliseconds}ms");
}
