Exemplo n.º 1
0
        public IMessageScopeContext <T> GetScope <T>(ConsumeContext <T> context)
            where T : class
        {
            if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
            {
                existingServiceScope.SetCurrentConsumeContext(context);

                return(new ExistingMessageScopeContext <T>(context));
            }

            if (!context.TryGetPayload(out IServiceProvider serviceProvider))
            {
                serviceProvider = _serviceProvider;
            }

            var serviceScope = serviceProvider.CreateScope();

            try
            {
                var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider);

                var scopeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider);

                serviceScope.SetCurrentConsumeContext(scopeContext);

                return(new CreatedMessageScopeContext <IServiceScope, T>(serviceScope, scopeContext));
            }
            catch
            {
                serviceScope.Dispose();

                throw;
            }
        }
Exemplo n.º 2
0
        IConsumerScopeContext IConsumerScopeProvider.GetScope(ConsumeContext context)
        {
            if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
            {
                existingServiceScope.SetCurrentConsumeContext(context);

                return(new ExistingConsumerScopeContext(context));
            }

            if (!context.TryGetPayload(out IServiceProvider serviceProvider))
            {
                serviceProvider = _serviceProvider;
            }

            var serviceScope = serviceProvider.CreateScope();

            try
            {
                var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider);

                var scopeContext = new ConsumeContextScope(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider);

                serviceScope.SetCurrentConsumeContext(scopeContext);

                return(new CreatedConsumerScopeContext <IServiceScope>(serviceScope, scopeContext));
            }
            catch
            {
                serviceScope.Dispose();

                throw;
            }
        }
Exemplo n.º 3
0
        async ValueTask <IConsumerScopeContext <TConsumer, T> > IConsumerScopeProvider.GetScope <TConsumer, T>(ConsumeContext <T> context)
        {
            if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
            {
                existingServiceScope.SetCurrentConsumeContext(context);

                var consumer = existingServiceScope.ServiceProvider.GetService <TConsumer>();
                if (consumer == null)
                {
                    throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
                }

                var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(context, consumer);

                return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext));
            }

            if (!context.TryGetPayload(out IServiceProvider serviceProvider))
            {
                serviceProvider = _serviceProvider;
            }

            var serviceScope = serviceProvider.CreateScope();

            try
            {
                var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider);

                var scopeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider);

                serviceScope.SetCurrentConsumeContext(scopeContext);

                var consumer = scopeServiceProvider.GetService <TConsumer>();
                if (consumer == null)
                {
                    throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'.");
                }

                var consumerContext = new ConsumerConsumeContextScope <TConsumer, T>(scopeContext, consumer);

                return(new CreatedConsumerScopeContext <IServiceScope, TConsumer, T>(serviceScope, consumerContext));
            }
            catch
            {
                if (serviceScope is IAsyncDisposable asyncDisposable)
                {
                    await asyncDisposable.DisposeAsync().ConfigureAwait(false);
                }
                else
                {
                    serviceScope.Dispose();
                }

                throw;
            }
        }
Exemplo n.º 4
0
        Task Send <T>(ConsumeContext <T> context, Func <ConsumeContext <T>, ISagaRepositoryContextFactory <TSaga>, Task> send)
            where T : class
        {
            if (!context.TryGetPayload(out IServiceProvider serviceProvider))
            {
                serviceProvider = _serviceProvider;
            }

            if (context.TryGetPayload <IServiceScope>(out var existingScope))
            {
                existingScope.SetCurrentConsumeContext(context);

                context.GetOrAddPayload(() => existingScope.ServiceProvider.GetService <IStateMachineActivityFactory>()
                                        ?? DependencyInjectionStateMachineActivityFactory.Instance);

                var factory = existingScope.ServiceProvider.GetRequiredService <ISagaRepositoryContextFactory <TSaga> >();

                return(send(context, factory));
            }

            async Task CreateScope()
            {
                var serviceScope = serviceProvider.CreateScope();

                try
                {
                    var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider);

                    var scopeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider);

                    serviceScope.SetCurrentConsumeContext(scopeContext);

                    var activityFactory = serviceScope.ServiceProvider.GetService <IStateMachineActivityFactory>()
                                          ?? DependencyInjectionStateMachineActivityFactory.Instance;

                    var consumeContextScope = new ConsumeContextScope <T>(scopeContext, activityFactory);

                    var factory = serviceScope.ServiceProvider.GetRequiredService <ISagaRepositoryContextFactory <TSaga> >();

                    await send(consumeContextScope, factory).ConfigureAwait(false);
                }
                finally
                {
                    if (serviceScope is IAsyncDisposable asyncDisposable)
                    {
                        await asyncDisposable.DisposeAsync().ConfigureAwait(false);
                    }
                    else
                    {
                        serviceScope.Dispose();
                    }
                }
            }

            return(CreateScope());
        }
Exemplo n.º 5
0
        public async ValueTask <IMessageScopeContext <T> > GetScope <T>(ConsumeContext <T> context)
            where T : class
        {
            if (context.TryGetPayload <IServiceScope>(out var existingServiceScope))
            {
                existingServiceScope.SetCurrentConsumeContext(context);

                return(new ExistingMessageScopeContext <T>(context));
            }

            if (!context.TryGetPayload(out IServiceProvider serviceProvider))
            {
                serviceProvider = _serviceProvider;
            }

            var serviceScope = serviceProvider.CreateScope();

            try
            {
                var scopeServiceProvider = new DependencyInjectionScopeServiceProvider(serviceScope.ServiceProvider);

                var scopeContext = new ConsumeContextScope <T>(context, serviceScope, serviceScope.ServiceProvider, scopeServiceProvider);

                serviceScope.SetCurrentConsumeContext(scopeContext);

                return(new CreatedMessageScopeContext <IServiceScope, T>(serviceScope, scopeContext));
            }
            catch
            {
                if (serviceScope is IAsyncDisposable asyncDisposable)
                {
                    await asyncDisposable.DisposeAsync().ConfigureAwait(false);
                }
                else
                {
                    serviceScope.Dispose();
                }

                throw;
            }
        }