public PoolService(IScopeFactory scopeFactory, int capacity, string?name) : base
(
capacity,
//
// Ez itt trukkos mert:
// 1) "injector" by design nem szalbiztos viszont ez a metodus lehet hivva paralell
// 2) Minden egyes legyartott elemnek sajat scope kell (az egyes elemek kulon szalakban lehetnek hasznalva)
// 3) Letrehozaskor a mar meglevo grafot boviteni kell
//
() => scopeFactory
//
// A letrehozott injector elettartamat PoolService deklaralo kontenere kezeli
//
.CreateScope(new Dictionary <string, object> { [PooledLifetime.POOL_SCOPE] = true })
//
// A referenciat magat adjuk vissza, hogy azt fuggosegkent menteni lehessen a
// hivo scope-jaban.
//
.GetReference(typeof(TInterface), name),
suppressItemDispose: true
)
{
}
internal MemcachedBucket(string name, ClusterContext context, IScopeFactory scopeFactory, IRetryOrchestrator retryOrchestrator, ILogger <MemcachedBucket> logger,
HttpClusterMapBase httpClusterMap)
: base(name, context, scopeFactory, retryOrchestrator, logger)
{
Name = name;
_httpClusterMap = httpClusterMap;
}
/// <summary>
/// Use RabbitMQ as Pub/Sub system.
/// </summary>
/// <param name="bootstrapper">Bootstrapper instance to configure</param>
/// <returns>Configured bootstrapper instance</returns>
public static Bootstrapper UseRabbitMQ(
this Bootstrapper bootstrapper,
RabbitConnectionInfos connectionInfos,
RabbitNetworkInfos networkInfos,
Action <RabbitSubscriberConfiguration> subscriberConfiguration = null,
Action <RabbitPublisherConfiguration> publisherConfiguration = null)
{
var service = RabbitMQBootstrappService.Instance;
var subscriberConf = new RabbitSubscriberConfiguration
{
ConnectionInfos = connectionInfos,
NetworkInfos = networkInfos
};
subscriberConfiguration?.Invoke(subscriberConf);
service.BootstrappAction += (ctx) =>
{
var publisherConf = new RabbitPublisherConfiguration()
{
ConnectionInfos = connectionInfos,
NetworkInfos = networkInfos
};
publisherConfiguration?.Invoke(publisherConf);
bootstrapper.AddIoCRegistration(new InstanceTypeRegistration(subscriberConf, typeof(RabbitSubscriberConfiguration)));
bootstrapper.AddIoCRegistration(new InstanceTypeRegistration(publisherConf, typeof(RabbitPublisherConfiguration)));
bootstrapper.AddIoCRegistration(new TypeRegistration(typeof(RabbitPublisher), true));
bootstrapper.AddIoCRegistration(new TypeRegistration(typeof(RabbitSubscriber), true));
if (publisherConf.RoutingKeyFactory != null)
{
bootstrapper.AddIoCRegistration(new InstanceTypeRegistration(publisherConf.RoutingKeyFactory, typeof(IRoutingKeyFactory)));
}
};
bootstrapper.AddService(service);
bootstrapper.OnPostBootstrapping += (c) =>
{
ILoggerFactory loggerFactory = null;
IScopeFactory scopeFactory = null;
if (c.Scope != null)
{
loggerFactory = c.Scope.Resolve <ILoggerFactory>();
scopeFactory = c.Scope.Resolve <IScopeFactory>();
}
if (loggerFactory == null)
{
loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new DebugLoggerProvider());
}
RabbitMQBootstrappService.RabbitSubscriber =
new RabbitSubscriber(
loggerFactory,
subscriberConf,
scopeFactory);
RabbitMQBootstrappService.RabbitSubscriber.Start();
};
return(bootstrapper);
}
public AccountController(IScopeFactory scopeFactory,
IAccountService accountService,
Authenticator authenticator)
: base(scopeFactory) {
_accountService = accountService;
_authenticator = authenticator;
}
internal CouchbaseBucket(string name, ClusterContext context, IScopeFactory scopeFactory, IRetryOrchestrator retryOrchestrator,
IVBucketKeyMapperFactory vBucketKeyMapperFactory, ILogger <CouchbaseBucket> logger, TypedRedactor redactor, IBootstrapperFactory bootstrapperFactory,
IRequestTracer tracer, IOperationConfigurator operationConfigurator, IRetryStrategy retryStrategy, BucketConfig config)
: base(name, context, scopeFactory, retryOrchestrator, logger, redactor, bootstrapperFactory, tracer, operationConfigurator, retryStrategy, config)
{
_vBucketKeyMapperFactory = vBucketKeyMapperFactory ?? throw new ArgumentNullException(nameof(vBucketKeyMapperFactory));
_viewClientLazy = new Lazy <IViewClient>(() =>
context.ServiceProvider.GetRequiredService <IViewClient>()
);
_viewManagerLazy = new Lazy <IViewIndexManager>(() =>
new ViewIndexManager(name,
context.ServiceProvider.GetRequiredService <IServiceUriProvider>(),
context.ServiceProvider.GetRequiredService <ICouchbaseHttpClientFactory>(),
context.ServiceProvider.GetRequiredService <ILogger <ViewIndexManager> >(),
context.ServiceProvider.GetRequiredService <IRedactor>()));
_collectionManagerLazy = new Lazy <ICouchbaseCollectionManager>(() =>
new CollectionManager(name,
context.ServiceProvider.GetRequiredService <IServiceUriProvider>(),
context.ServiceProvider.GetRequiredService <ICouchbaseHttpClientFactory>(),
context.ServiceProvider.GetRequiredService <ILogger <CollectionManager> >(),
context.ServiceProvider.GetRequiredService <IRedactor>())
);
}
public BucketFactory(
ClusterContext clusterContext,
IScopeFactory scopeFactory,
IRetryOrchestrator retryOrchestrator,
IVBucketKeyMapperFactory vBucketKeyMapperFactory,
IKetamaKeyMapperFactory ketamaKeyMapperFactory,
ILogger <CouchbaseBucket> couchbaseLogger,
ILogger <MemcachedBucket> memcachedLogger,
IRedactor redactor,
IBootstrapperFactory bootstrapperFactory,
IRequestTracer tracer,
IOperationConfigurator operationConfigurator,
IRetryStrategy retryStrategy
)
{
_clusterContext = clusterContext ?? throw new ArgumentNullException(nameof(clusterContext));
_scopeFactory = scopeFactory ?? throw new ArgumentNullException(nameof(scopeFactory));
_retryOrchestrator = retryOrchestrator ?? throw new ArgumentNullException(nameof(retryOrchestrator));
_vBucketKeyMapperFactory = vBucketKeyMapperFactory ?? throw new ArgumentNullException(nameof(vBucketKeyMapperFactory));
_ketamaKeyMapperFactory = ketamaKeyMapperFactory ?? throw new ArgumentNullException(nameof(ketamaKeyMapperFactory));
_couchbaseLogger = couchbaseLogger ?? throw new ArgumentNullException(nameof(couchbaseLogger));
_memcachedLogger = memcachedLogger ?? throw new ArgumentNullException(nameof(memcachedLogger));
_redactor = redactor ?? throw new ArgumentNullException(nameof(IRedactor));
_bootstrapperFactory = bootstrapperFactory ?? throw new ArgumentNullException(nameof(bootstrapperFactory));
_tracer = tracer ?? throw new ArgumentNullException(nameof(tracer));
_operationConfigurator = operationConfigurator ?? throw new ArgumentNullException(nameof(operationConfigurator));
_retryStrategy = retryStrategy ?? throw new ArgumentNullException(nameof(retryStrategy));
}
internal MemcachedBucket(string name, ClusterContext context, IScopeFactory scopeFactory, IRetryOrchestrator retryOrchestrator, IKetamaKeyMapperFactory ketamaKeyMapperFactory,
ILogger <MemcachedBucket> logger, HttpClusterMapBase httpClusterMap, IRedactor redactor, IBootstrapperFactory bootstrapperFactory)
: base(name, context, scopeFactory, retryOrchestrator, logger, redactor, bootstrapperFactory)
{
Name = name;
_ketamaKeyMapperFactory = ketamaKeyMapperFactory ?? throw new ArgumentNullException(nameof(ketamaKeyMapperFactory));
_httpClusterMap = httpClusterMap;
}
protected BucketBase(string name, ClusterContext context, IScopeFactory scopeFactory, IRetryOrchestrator retryOrchestrator, ILogger logger)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
Context = context ?? throw new ArgumentNullException(nameof(context));
_scopeFactory = scopeFactory ?? throw new ArgumentNullException(nameof(scopeFactory));
RetryOrchestrator = retryOrchestrator ?? throw new ArgumentNullException(nameof(retryOrchestrator));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public AccountController(IScopeFactory scopeFactory,
IAccountService accountService,
Authenticator authenticator)
: base(scopeFactory)
{
_accountService = accountService;
_authenticator = authenticator;
}
internal MemcachedBucket(string name, ClusterContext context, IScopeFactory scopeFactory, IRetryOrchestrator retryOrchestrator, IKetamaKeyMapperFactory ketamaKeyMapperFactory,
ILogger <MemcachedBucket> logger, IHttpClusterMapFactory httpClusterMapFactory, TypedRedactor redactor, IBootstrapperFactory bootstrapperFactory, IRequestTracer tracer, IOperationConfigurator operationConfigurator, IRetryStrategy retryStrategy, BucketConfig config)
: base(name, context, scopeFactory, retryOrchestrator, logger, redactor, bootstrapperFactory, tracer, operationConfigurator, retryStrategy, config)
{
BucketType = BucketType.Memcached;
Name = name;
_ketamaKeyMapperFactory = ketamaKeyMapperFactory ?? throw new ArgumentNullException(nameof(ketamaKeyMapperFactory));
_httpClusterMapFactory = httpClusterMapFactory ?? throw new ArgumentNullException(nameof(httpClusterMapFactory));
_httpClusterMap = _httpClusterMapFactory.Create(Context);
}
internal CQELightToolbox(IScopeFactory scopeFactory,
IDispatcher?dispatcher = null,
IEventStore?eventStore = null,
IAggregateEventStore?aggregateEventStore = null)
{
ScopeFactory = scopeFactory;
Dispatcher = dispatcher;
EventStore = eventStore;
AggregateEventStore = aggregateEventStore;
}
/// <summary>
/// Constructor without using the default factory
/// </summary>
/// <param name="factory">Factory to build the default scope</param>
public Engine(IScopeFactory factory)
{
if (factory == null)
{
factory = new ScopeFactory();
}
ReaderFactory = new SourceReaderFactory();
ScriptFactory = new DefaultLanguageScriptFactory();
DefaultScope = factory.MakeScope();
}
private static BucketBase CreateBucketMock(IScopeFactory factory)
{
var mock = new Mock <BucketBase>(
"default",
new ClusterContext(),
factory,
new Mock <IRetryOrchestrator>().Object,
new Mock <ILogger>().Object);
return(mock.Object);
}
protected BucketBase(string name, ClusterContext context, IScopeFactory scopeFactory, IRetryOrchestrator retryOrchestrator, ILogger logger, IRedactor redactor, IBootstrapperFactory bootstrapperFactory)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
Context = context ?? throw new ArgumentNullException(nameof(context));
_scopeFactory = scopeFactory ?? throw new ArgumentNullException(nameof(scopeFactory));
RetryOrchestrator = retryOrchestrator ?? throw new ArgumentNullException(nameof(retryOrchestrator));
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
Redactor = redactor ?? throw new ArgumentNullException(nameof(redactor));
BootstrapperFactory = bootstrapperFactory ?? throw new ArgumentNullException(nameof(bootstrapperFactory));
Bootstrapper = bootstrapperFactory.Create(Context.ClusterOptions.BootstrapPollInterval);
}
protected BaseViewModel(IScopeFactory scopeFactory = null)
{
if (scopeFactory != null)
{
_scope = scopeFactory.CreateScope();
}
_logger =
_scope?.Resolve <ILoggerFactory>()?.CreateLogger(GetType().Name)
??
new LoggerFactory().CreateLogger(GetType().Name);
CoreDispatcher.AddHandlerToDispatcher(this);
}
/// <summary>
/// Create a new builder for building configuration.
/// </summary>
public DispatcherConfigurationBuilder(IScopeFactory scopeFactory = null)
{
_singleEventConfigs = new List <SingleEventTypeConfiguration>();
_multipleEventConfigs = new List <MultipleEventTypeConfiguration>();
_singleCommandConfigs = new List <SingleCommandTypeConfiguration>();
_multipleCommandConfigs = new List <MultipleCommandTypeConfiguration>();
if (scopeFactory != null)
{
_scope = scopeFactory.CreateScope();
}
}
public FluentLangCompiler(
ILogger <FluentLangCompiler> logger,
SolutionFactory solutionFactory,
IScopeFactory <SolutionInfo, IProjectLoader> projectLoader,
IFileSystem fileSystem,
IDiagnosticFormatter diagnosticFormatter)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_solutionFactory = solutionFactory ?? throw new ArgumentNullException(nameof(solutionFactory));
_projectLoader = projectLoader ?? throw new ArgumentNullException(nameof(projectLoader));
_fileSystem = fileSystem;
_diagnosticFormatter = diagnosticFormatter;
}
public BucketFactory(
ClusterContext clusterContext,
IScopeFactory scopeFactory,
IRetryOrchestrator retryOrchestrator,
ILogger <CouchbaseBucket> couchbaseLogger,
ILogger <MemcachedBucket> memcachedLogger)
{
_clusterContext = clusterContext ?? throw new ArgumentNullException(nameof(clusterContext));
_scopeFactory = scopeFactory ?? throw new ArgumentNullException(nameof(scopeFactory));
_retryOrchestrator = retryOrchestrator ?? throw new ArgumentNullException(nameof(retryOrchestrator));
_couchbaseLogger = couchbaseLogger ?? throw new ArgumentNullException(nameof(couchbaseLogger));
_memcachedLogger = memcachedLogger ?? throw new ArgumentNullException(nameof(memcachedLogger));
}
/// <summary>
/// Create a new dispatcher instance.
/// </summary>
/// <param name="configuration">Dispatcher configuration.</param>
/// <param name="scopeFactory">Factory of DI scope.</param>
public BaseDispatcher(DispatcherConfiguration configuration, IScopeFactory scopeFactory = null)
{
s_Config = configuration ?? DispatcherConfiguration.Current;
if (scopeFactory != null)
{
s_PrivateScope = scopeFactory.CreateScope();
}
s_Logger =
s_Scope?.Resolve <ILoggerFactory>()?.CreateLogger <BaseDispatcher>()
??
new LoggerFactory().CreateLogger <BaseDispatcher>();
}
private static BucketBase CreateBucketMock(IScopeFactory factory)
{
var mock = new Mock <BucketBase>(
"default",
new ClusterContext(),
factory,
new Mock <IRetryOrchestrator>().Object,
new Mock <ILogger>().Object,
new Mock <IRedactor>().Object,
new Mock <IBootstrapperFactory>().Object,
NullRequestTracer.Instance);
return(mock.Object);
}
internal InMemoryCommandBus(InMemoryCommandBusConfiguration configuration = null,
IScopeFactory scopeFactory = null)
{
if (scopeFactory != null)
{
_scope = scopeFactory.CreateScope();
}
_logger =
_scope?.Resolve <ILoggerFactory>()?.CreateLogger <InMemoryCommandBus>()
??
new LoggerFactory().CreateLogger <InMemoryCommandBus>();
_config = configuration ?? InMemoryCommandBusConfiguration.Default;
}
internal CouchbaseBucket(string name, ClusterContext context, IScopeFactory scopeFactory, IRetryOrchestrator retryOrchestrator, ILogger <CouchbaseBucket> logger)
: base(name, context, scopeFactory, retryOrchestrator, logger)
{
var httpClient = context.ServiceProvider.GetRequiredService <CouchbaseHttpClient>();
_viewClientLazy = new Lazy <IViewClient>(() =>
new ViewClient(context)
);
_viewManagerLazy = new Lazy <IViewIndexManager>(() =>
new ViewIndexManager(name, httpClient, context));
_collectionManagerLazy = new Lazy <ICollectionManager>(() =>
new CollectionManager(name, context, httpClient)
);
}
public RabbitSubscriber(
ILoggerFactory loggerFactory,
RabbitSubscriberConfiguration config,
IScopeFactory scopeFactory = null)
{
if (loggerFactory == null)
{
loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new DebugLoggerProvider());
}
_logger = loggerFactory.CreateLogger <RabbitSubscriber>();
_config = config;
this.scopeFactory = scopeFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="Scoped{T}"/>.
/// </summary>
/// <param name="scopeFactory"> A factory for creating scopes. </param>
public Scoped(IScopeFactory scopeFactory)
{
if (scopeFactory == null)
{
throw new ArgumentNullException(nameof(scopeFactory));
}
if (GenericScope <T> .CurrentScope != null)
{
throw new InvalidOperationException($"The current scope of GenericScope<{typeof(T).Name}> is not null when trying to initialize it.");
}
Scope = scopeFactory.CreateScope();
GenericScope <T> .CurrentScope = Scope;
}
private static BucketBase CreateBucketMock(IScopeFactory factory)
{
var mock = new Mock <BucketBase>(
"default",
new ClusterContext(),
factory,
new Mock <IRetryOrchestrator>().Object,
new Mock <ILogger>().Object,
new Mock <IRedactor>().Object,
new Mock <IBootstrapperFactory>().Object,
NoopRequestTracer.Instance,
new Mock <IOperationConfigurator>().Object,
new BestEffortRetryStrategy());
return(mock.Object);
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultRequestWorker" /> class.
/// </summary>
/// <param name="timerFactory">Factory to create timers with.</param>
/// <param name="transactionFactory">Factory to create transactions with.</param>
/// <param name="relay">Relay service to send/receive messages through the queue.</param>
/// <param name="options">Options to use for handling requests.</param>
/// <param name="scopeFactory">Service to create scopes with.</param>
/// <param name="tracing">Service for managing app traces.</param>
/// <param name="logger">Logger used to log info to some destination(s).</param>
public DefaultRequestWorker(
ITimerFactory timerFactory,
ITransactionFactory transactionFactory,
IRequestMessageRelay relay,
IOptions <RequestOptions> options,
IScopeFactory scopeFactory,
ITracingService tracing,
ILogger <DefaultRequestWorker> logger
)
{
this.timerFactory = timerFactory;
this.transactionFactory = transactionFactory;
this.relay = relay;
this.options = options.Value;
this.scopeFactory = scopeFactory;
this.tracing = tracing;
this.logger = logger;
}
private static BucketBase CreateBucketMock(IScopeFactory factory)
{
var mock = new Mock <BucketBase>(
"default",
new ClusterContext(),
factory,
new Mock <IRetryOrchestrator>().Object,
new Mock <ILogger>().Object,
new TypedRedactor(RedactionLevel.None),
new Mock <IBootstrapperFactory>().Object,
NoopRequestTracer.Instance,
new Mock <IOperationConfigurator>().Object,
new BestEffortRetryStrategy(),
new BucketConfig());
mock.SetupGet(it => it.Name).Returns("default");
return(mock.Object);
}
static void Main(string[] args)
{
IScopeFactory scopeFactory = InfraConfig.Initialize();
using (IAppLayer app = scopeFactory.CreateAppLayer())
{
IPaymentService payment = app.GetService <IPaymentService>();
IOrderPlacementService orderPlacement = app.GetService <IOrderPlacementService>();
Console.WriteLine("\n#### IPaymentService.PayOrder ####\n");
payment.PayOrder(orderId: 1, amount: 30);
app.UnitOfWork.Save();
Console.WriteLine("\n#### IOrderPlacementService.ShipOrder ####\n");
orderPlacement.ShipOrder(orderId: 1, address: "G1Q1Q9");
app.UnitOfWork.Save();
}
Console.ReadKey();
}
internal CouchbaseBucket(string name, ClusterContext context, IScopeFactory scopeFactory, IRetryOrchestrator retryOrchestrator,
IVBucketKeyMapperFactory vBucketKeyMapperFactory, ILogger <CouchbaseBucket> logger)
: base(name, context, scopeFactory, retryOrchestrator, logger)
{
_vBucketKeyMapperFactory = vBucketKeyMapperFactory ?? throw new ArgumentNullException(nameof(vBucketKeyMapperFactory));
_viewClientLazy = new Lazy <IViewClient>(() =>
context.ServiceProvider.GetRequiredService <IViewClient>()
);
_viewManagerLazy = new Lazy <IViewIndexManager>(() =>
new ViewIndexManager(name,
context.ServiceProvider.GetRequiredService <IServiceUriProvider>(),
context.ServiceProvider.GetRequiredService <CouchbaseHttpClient>(),
context.ServiceProvider.GetRequiredService <ILogger <ViewIndexManager> >()));
_collectionManagerLazy = new Lazy <ICollectionManager>(() =>
new CollectionManager(name,
context.ServiceProvider.GetRequiredService <IServiceUriProvider>(),
context.ServiceProvider.GetRequiredService <CouchbaseHttpClient>(),
context.ServiceProvider.GetRequiredService <ILogger <CollectionManager> >())
);
}
public Controller(
IScopeFactory scopeFactory,
IMegaFactory factory,
IGenericFactory <IBuilder, INotifier> generic,
Func <ScopedService> scopedFunc,
Func <TransientService> transientFunc,
Defer <ScopedService> scopedDefer,
Defer <TransientService> transientDefer)
{
Factory = factory;
Generic = generic;
ScopedFunc = scopedFunc;
ScopedDefer = scopedDefer;
TransientFunc = transientFunc;
TransientDefer = transientDefer;
Console.WriteLine("Controller created");
using (new Scoped <Controller>(scopeFactory))
{
}
}
public async Task ShouldInvokeAllReceivedMessagesThenCompleteTransactions(
RequestMessage message1,
RequestMessage message2,
IScope scope1,
IScope scope2,
IRequestInvoker invoker1,
IRequestInvoker invoker2,
ITransaction transaction1,
ITransaction transaction2,
[Frozen] ITransactionFactory transactionFactory,
[Frozen] IRequestMessageRelay relay,
[Frozen] IScopeFactory scopeFactory,
[Target] DefaultRequestWorker worker,
CancellationToken cancellationToken
)
{
transactionFactory.CreateTransaction().Returns(transaction1, transaction2);
scope1.GetService <IRequestInvoker>().Returns(invoker1);
scope2.GetService <IRequestInvoker>().Returns(invoker2);
scopeFactory.CreateScope().Returns(scope1, scope2);
relay.Receive(Any <CancellationToken>()).Returns(new[] { message1, message2 });
await worker.Run(cancellationToken);
Received.InOrder(async() =>
{
transactionFactory.Received().CreateTransaction();
scopeFactory.Received().CreateScope();
scope1.Received().GetService <IRequestInvoker>();
await invoker1.Received().Invoke(Is(message1), Is(cancellationToken));
transaction1.Received().Complete();
transactionFactory.Received().CreateTransaction();
scopeFactory.Received().CreateScope();
scope2.Received().GetService <IRequestInvoker>();
await invoker2.Received().Invoke(Is(message2), Is(cancellationToken));
transaction2.Received().Complete();
});
}
public TutorialController(IScopeFactory scopeFactory, ITutorialService tutorialService) : base(scopeFactory)
{
_tutorialService = tutorialService;
}
public GroupController(IScopeFactory scopeFactory, IGroupService groupService)
: base(scopeFactory) {
_groupService = groupService;
}
public ExerciceController(IScopeFactory scopeFactory, IExerciceService exerciceService) : base(scopeFactory)
{
_exerciceService = exerciceService;
}
public UserExperienceController(IScopeFactory scopeFactory, IUserExperienceService userExperience) : base(scopeFactory)
{
_userExperience = userExperience;
}
protected ApiController(IScopeFactory scopeFactory) {
_scopeFactory = scopeFactory;
}
