IConsumerScopeContext <TConsumer, T> IConsumerScopeProvider.GetScope <TConsumer, T>(ConsumeContext <T> context) { if (context.TryGetPayload <ILifetimeScope>(out var existingLifetimeScope)) { ConsumerConsumeContext <TConsumer, T> consumerContext = existingLifetimeScope.GetConsumer <TConsumer, T>(context); return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext)); } var parentLifetimeScope = _scopeProvider.GetLifetimeScope(context); var lifetimeScope = parentLifetimeScope.BeginLifetimeScope(_name, builder => { builder.ConfigureScope(context); _configureScope?.Invoke(builder, context); }); try { ConsumerConsumeContext <TConsumer, T> consumerContext = lifetimeScope.GetConsumerScope <TConsumer, T>(); return(new CreatedConsumerScopeContext <ILifetimeScope, TConsumer, T>(lifetimeScope, consumerContext)); } catch { lifetimeScope.Dispose(); throw; } }
public IConsumerScopeContext <TConsumer, T> GetScope <TConsumer, T>(ConsumeContext <T> context) where TConsumer : class where T : class { if (context.TryGetPayload <IServiceScope>(out var payload)) { TConsumer service = payload.ServiceProvider.GetService <TConsumer>(); if ((object)service == null) { throw new ConsumerException(string.Format("Unable to resolve consumer type '{0}'.", (object)TypeMetadataCache <TConsumer> .ShortName)); } return((IConsumerScopeContext <TConsumer, T>) new ExistingConsumerScopeContext <TConsumer, T>(context.PushConsumer <TConsumer, T>(service))); } IServiceScope scope = SillycoreApp.Instance.ServiceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope(); try { TConsumer service = scope.ServiceProvider.GetService <TConsumer>(); if ((object)service == null) { throw new ConsumerException(string.Format("Unable to resolve consumer type '{0}'.", (object)TypeMetadataCache <TConsumer> .ShortName)); } ConsumerConsumeContext <TConsumer, T> context1 = context.PushConsumerScope <TConsumer, T, IServiceScope>(service, scope); return((IConsumerScopeContext <TConsumer, T>) new CreatedConsumerScopeContext <IServiceScope, TConsumer, T>(scope, context1)); } catch { scope.Dispose(); throw; } }
public Task Send(ConsumeContext <TMessage> context) { ConsumerConsumeContext <TConsumer, TMessage> consumerContext = context as ConsumerConsumeContext <TConsumer, TMessage> ?? new ConsumerConsumeContextProxy <TConsumer, TMessage>(context, _context.Consumer); return(_output.Send(consumerContext)); }
public async Task Send(ConsumerConsumeContext <MyConsumer> context, IPipe <ConsumerConsumeContext <MyConsumer> > next) { First.TrySetResult(true); await next.Send(context); Second.TrySetResult(true); }
public async void ServiceLifetime() { var services = new ServiceCollection(); services.AddTransient <IConsumerFactory <TestConsumer>, ResolvingConsumerFactory <TestConsumer> >(); services.AddTransient <TestConsumer>(); var outerProvider = services.BuildServiceProvider(); using ((IDisposable)outerProvider) using (var outerScope = outerProvider.CreateScope()) { var provider = outerScope.ServiceProvider; var factory = provider.GetRequiredService <IConsumerFactory <TestConsumer> >(); IServiceScope tempServiceScope = null; var mockContext = new Mock <ConsumeContext <string> >(MockBehavior.Strict); mockContext .Setup(_ => _.TryGetPayload(out tempServiceScope)) .Returns(() => false); ConsumerConsumeContext <TestConsumer, string> context = null; var mockNext = new Mock <IPipe <ConsumerConsumeContext <TestConsumer, string> > >(MockBehavior.Strict); mockNext .Setup(_ => _.Send(It.IsAny <ConsumerConsumeContext <TestConsumer, string> >())) .Returns((ConsumerConsumeContext <TestConsumer, string> argContext) => { context = argContext; return(Task.FromResult(0)); }); Assert.Equal(0, TestConsumer.Instances.Count); Assert.Equal(0, TestConsumer.Providers.Count); await factory.Send(mockContext.Object, mockNext.Object); Assert.Equal(1, TestConsumer.Instances.Count); Assert.Equal(1, TestConsumer.Providers.Count); Assert.True(TestConsumer.Instances[0].IsDisposed); var hasPayload = context.TryGetPayload(out tempServiceScope); Assert.True(hasPayload); Assert.Same(tempServiceScope.ServiceProvider, TestConsumer.Providers[0]); var consumer = provider.GetRequiredService <TestConsumer>(); Assert.NotNull(consumer); Assert.Equal(2, TestConsumer.Instances.Count); Assert.Equal(2, TestConsumer.Providers.Count); Assert.Same(provider, TestConsumer.Providers[1]); Assert.False(TestConsumer.Instances[1].IsDisposed); } Assert.True(TestConsumer.Instances[1].IsDisposed); }
async Task SendInScope <TMessage>(ConsumeContext <TMessage> context, IPipe <ConsumerConsumeContext <TConsumer, TMessage> > next) where TMessage : class { var scope = _registry.GetLifetimeScope(context); using (var consumerScope = scope.BeginLifetimeScope(_name, builder => builder.ConfigureScope(context))) { ConsumerConsumeContext <TConsumer, TMessage> consumerContext = consumerScope.GetConsumerScope <TConsumer, TMessage>(context); await next.Send(consumerContext).ConfigureAwait(false); } }
public Task Send(ConsumeContext <TMessage> context) { if (ReferenceEquals(context, _context)) { return(_output.Send(_context)); } ConsumerConsumeContext <TConsumer, TMessage> consumerContext = context as ConsumerConsumeContext <TConsumer, TMessage> ?? new ConsumerConsumeContextProxy <TConsumer, TMessage>(context, _context.Consumer); return(_output.Send(consumerContext)); }
public Task Send <TMessage>(ConsumeContext <TMessage> context, IPipe <ConsumerConsumeContext <TConsumer, TMessage> > next) where TMessage : class { if (context.TryGetPayload <ILifetimeScope>(out var existingScope)) { ConsumerConsumeContext <TConsumer, TMessage> consumerContext = existingScope.GetConsumer <TConsumer, TMessage>(context); return(next.Send(consumerContext)); } return(SendInScope(context, next)); }
Task IFilter <ConsumerConsumeContext <TConsumer, TJob> > .Send(ConsumerConsumeContext <TConsumer, TJob> context, IPipe <ConsumerConsumeContext <TConsumer, TJob> > next) { if (context.Consumer is IJobConsumer <TJob> messageConsumer) { return(RunJob(context, messageConsumer)); } var message = $"Consumer type {TypeMetadataCache<TConsumer>.ShortName} is not a consumer of job type {TypeMetadataCache<TJob>.ShortName}"; throw new ConsumerMessageException(message); }
public async Task Send(ConsumerConsumeContext <TConsumer> context, IPipe <ConsumerConsumeContext <TConsumer> > next) { Console.WriteLine("@@@@ Consume with Consumer : MessageId={0}, Consumer={1}", context.MessageId, context.Consumer); // Payload 에는 IServiceProvider 도 있다. var serviceProvider = context.GetPayload <IServiceProvider>(); var logger = serviceProvider.GetService(typeof(ILogger <ConsoleConsumeWithConsumerFilter <TConsumer> >)) as ILogger; logger.LogInformation("Logger를 MS DI 프레임웍에서 제공받아 사용중입니다. "); await next.Send(context); // NOTE! 반드시 next.Send() 를 호출해야 함. !!! }
Task IFilter <ConsumerConsumeContext <TConsumer, TMessage> > .Send(ConsumerConsumeContext <TConsumer, TMessage> context, IPipe <ConsumerConsumeContext <TConsumer, TMessage> > next) { if (context.Consumer is IConsumer <TMessage> messageConsumer) { return(messageConsumer.Consume(context)); } var message = $"Consumer type {TypeMetadataCache<TConsumer>.ShortName} is not a consumer of message type {TypeMetadataCache<TMessage>.ShortName}"; throw new ConsumerMessageException(message); }
public async Task Send(ConsumerConsumeContext <TConsumer, TMessage> context) { try { await _next.Send(context); _received.Add(context); } catch (Exception ex) { _received.Add(context, ex); } }
public Task Send(ConsumerConsumeContext <TConsumer, TMessage> context, IPipe <ConsumerConsumeContext <TConsumer, TMessage> > next) { if (context.TryGetPayload(out TScope _)) { _taskCompletionSource.TrySetResult(context); } else { _taskCompletionSource.TrySetException(new PayloadException("Service Provider not found")); } return(next.Send(context)); }
public async Task Send(ConsumerConsumeContext <TConsumer> context, IPipe <ConsumerConsumeContext <TConsumer> > next) { var messageType = context.GetType().GetClosingArgument(typeof(ConsumeContext <>)); int?length = null; BatchCompletionMode?mode = null; if (InterfaceExtensions.ClosesType(messageType, typeof(Batch <>))) { var consumeContextType = typeof(ConsumeContext <>).MakeGenericType(messageType); var message = consumeContextType.GetProperty("Message") !.GetValue(context); length = (int)messageType.GetProperty(nameof(Batch <object> .Length)) !.GetValue(message) !; mode = (BatchCompletionMode)messageType.GetProperty(nameof(Batch <object> .Mode)) !.GetValue(message) !; } var serviceProvider = context.GetPayload <IServiceProvider>(); var logger = serviceProvider.GetRequiredService <ILogger <LoggingFilter2 <TConsumer> > >(); using (logger.BeginScope(new Dictionary <string, object> { { "messageId", context.MessageId } })) { if (length == null) { logger.LogInformation("┌── {0}", TypeCache <TConsumer> .ShortName); } else { logger.LogInformation("╔══ {0} - {1} - {2} messages", TypeCache <TConsumer> .ShortName, mode, length); } var sw = Stopwatch.StartNew(); try { await next.Send(context); } finally { if (length == null) { logger.LogInformation("└── {0} [{1} ms]", TypeCache <TConsumer> .ShortName, sw.ElapsedMilliseconds); } else { logger.LogInformation("╚══ {0} [{1} ms]", TypeCache <TConsumer> .ShortName, sw.ElapsedMilliseconds); } } } }
public async Task Send(ConsumerConsumeContext <TConsumer> context, IPipe <ConsumerConsumeContext <TConsumer> > next) { var serviceProvider = context.GetPayload <IServiceProvider>(); var dataContext = serviceProvider.GetRequiredService <DataContext>(); var integrationMessagePublisher = serviceProvider.GetRequiredService <IIntegrationMessagePublisher>(); IDbContextTransaction dbContextTransaction = await dataContext.Database.BeginTransactionAsync(IsolationLevel.ReadCommitted); await next.Send(context); await dbContextTransaction.CommitAsync(); await integrationMessagePublisher.Publish(); }
public Task Send(ConsumerConsumeContext <TConsumer> context) { if (context is ConsumerConsumeContext <TConsumer, TMessage> consumerContext) { return(_output.Send(consumerContext)); } if (context.TryGetMessage(out ConsumeContext <TMessage> messageContext)) { return(_output.Send(new ConsumerConsumeContextProxy <TConsumer, TMessage>(messageContext, context.Consumer))); } throw new ArgumentException($"THe message could not be retrieved: {TypeMetadataCache<TMessage>.ShortName}", nameof(context)); }
public async Task Should_include_container_scope() { await InputQueueSendEndpoint.Send(new EasyMessage { CorrelationId = NewId.NextGuid() }); ConsumerConsumeContext <EasyConsumer> consumerContext = await _consumerCompletion.Task; var scope = consumerContext.GetPayload <TScope>(); ConsumerConsumeContext <EasyConsumer, EasyMessage> consumerMessageContext = await _consumerMessageCompletion.Task; Assert.AreEqual(scope, consumerMessageContext.GetPayload <TScope>()); ConsumeContext <EasyMessage> messageContext = await MessageCompletion.Task; Assert.AreEqual(scope, messageContext.GetPayload <TScope>()); }
async Task IConsumerFactory <TConsumer> .Send <T>(ConsumeContext <T> context, IPipe <ConsumerConsumeContext <TConsumer, T> > next) { using (var nestedContainer = _container.GetNestedContainer()) { var consumer = nestedContainer.GetInstance <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerConsumeContext = context.PushConsumerScope(consumer, nestedContainer); await next.Send(consumerConsumeContext).ConfigureAwait(false); } }
public async Task Send(ConsumerConsumeContext <T> context, IPipe <ConsumerConsumeContext <T> > next) { var unitOfWork = context.GetOrAddPayload <IUnitOfWork>(() => new UnitOfWork()); try { await next.Send(context).ConfigureAwait(false); unitOfWork.Commit(); } catch { unitOfWork.Abandon(); throw; } }
public async Task Send <TMessage>(ConsumeContext <TMessage> context, IPipe <ConsumerConsumeContext <TConsumer, TMessage> > next) where TMessage : class { using (var innerScope = _scope.BeginLifetimeScope(_name, x => ConfigureScope(x, context))) { var consumer = innerScope.Resolve <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, TMessage> consumerConsumeContext = context.PushConsumerScope(consumer, innerScope); await next.Send(consumerConsumeContext).ConfigureAwait(false); } }
public async Task Send <T>(ConsumeContext <T> context, IPipe <ConsumerConsumeContext <TConsumer, T> > next) where T : class { using (var childContainer = _container.CreateChildContainer()) { var consumer = childContainer.Resolve <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerConsumeContext = context.PushConsumerScope(consumer, childContainer); await next.Send(consumerConsumeContext).ConfigureAwait(false); } }
IConsumerScopeContext <TConsumer, T> IConsumerScopeProvider.GetScope <TConsumer, T>(ConsumeContext <T> context) { if (context.TryGetPayload <IServiceScope>(out var existingServiceScope)) { existingServiceScope.UpdateScope(context); var consumer = existingServiceScope.ServiceProvider.GetService <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerContext = context.PushConsumer(consumer); return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext)); } if (!context.TryGetPayload(out IServiceProvider serviceProvider)) { serviceProvider = _serviceProvider; } var serviceScope = serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope(); try { serviceScope.UpdateScope(context); var consumer = serviceScope.ServiceProvider.GetService <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerContext = context.PushConsumerScope(consumer, serviceScope); consumerContext.UpdatePayload(serviceScope); return(new CreatedConsumerScopeContext <IServiceScope, TConsumer, T>(serviceScope, consumerContext)); } catch { serviceScope.Dispose(); throw; } }
Task IFilter <ConsumerConsumeContext <TConsumer, TMessage> > .Send(ConsumerConsumeContext <TConsumer, TMessage> context, IPipe <ConsumerConsumeContext <TConsumer, TMessage> > next) { var messageConsumer = context.Consumer as IMessageConsumer <TMessage>; if (messageConsumer == null) { string message = $"Consumer type {TypeMetadataCache<TConsumer>.ShortName} is not a consumer of message type {TypeMetadataCache<TMessage>.ShortName}"; throw new ConsumerMessageException(message); } messageConsumer.Consume(context.Message); return(TaskUtil.Completed); }
public IConsumerScopeContext <TConsumer, T> GetScope <TConsumer, T>(ConsumeContext <T> context) where TConsumer : class where T : class { if (context.TryGetPayload <IKernel>(out var kernel)) { kernel.UpdateScope(context); var consumer = kernel.Resolve <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerContext = context.PushConsumer(consumer); return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext, ReleaseComponent)); } var scope = _kernel.CreateNewOrUseExistingMessageScope(context); try { var consumer = _kernel.Resolve <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerContext = context.PushConsumerScope(consumer, _kernel); foreach (Action <ConsumeContext> scopeAction in _scopeActions) { scopeAction(consumerContext); } return(new CreatedConsumerScopeContext <IDisposable, TConsumer, T>(scope, consumerContext, ReleaseComponent)); } catch { scope?.Dispose(); throw; } }
public IConsumerScopeContext <TConsumer, T> GetScope <TConsumer, T>(ConsumeContext <T> context) where TConsumer : class where T : class { if (context.TryGetPayload <Scope>(out var existingScope)) { existingScope.UpdateScope(context); var consumer = existingScope.Container.GetInstance <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerContext = context.PushConsumer(consumer); return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext)); } var scope = AsyncScopedLifestyle.BeginScope(_container); try { scope.UpdateScope(context); var consumer = scope.Container.GetInstance <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerContext = context.PushConsumerScope(consumer, scope, scope.Container); return(new CreatedConsumerScopeContext <Scope, TConsumer, T>(scope, consumerContext)); } catch { scope.Dispose(); throw; } }
public async Task Send(ConsumerConsumeContext <TConsumer, TMessage> context, IPipe <ConsumerConsumeContext <TConsumer, TMessage> > next) { Console.WriteLine("@@@@ Consume with Consumer of Typed Message : MessageId={0}, Consumer={1}, Message={2}", context.MessageId, context.Consumer, // Masstransit의 Reflection Utilityt 함수.. !!!!! TypeMetadataCache <TMessage> .ShortName //context.Message ); var serviceProvider = context.GetPayload <IServiceProvider>(); var validator = serviceProvider.GetService <IMessageValidator <TMessage> >(); if (validator != null) { await validator.Validate(context); } await next.Send(context); // NOTE! 반드시 next.Send() 를 호출해야 함. !!! }
public async Task Send(ConsumerConsumeContext <TConsumer, TMessage> context, IPipe <ConsumerConsumeContext <TConsumer, TMessage> > next) { if (!context.RequestId.HasValue) { throw new RequestException("RequestId is required"); } var clientId = context.Headers.Get(MessageHeaders.ClientId, default(Guid?)); if (!clientId.HasValue) { throw new RequestException($"ClientId not specified (requestId: {context.RequestId})"); } var acceptedContext = await _endpoint.Accept(clientId.Value, context.RequestId.Value).ConfigureAwait(false); context.AddOrUpdatePayload(() => acceptedContext, existing => acceptedContext); await next.Send(context).ConfigureAwait(false); }
public async Task Send(ConsumerConsumeContext <TConsumer> context, IPipe <ConsumerConsumeContext <TConsumer> > next) { try { var serviceScope = context.GetPayload <IServiceScope>(); var publisher = serviceScope.ServiceProvider.GetRequiredService <IEventPublisher>() as MassTransitEventPublisher; if (publisher != null) { publisher.SetContext(context); } await next.Send(context).ConfigureAwait(false); } catch (Exception) { throw; } }
public async Task Send(ConsumerConsumeContext <TConsumer> context, IPipe <ConsumerConsumeContext <TConsumer> > next) { try { var serviceScope = context.GetPayload <IServiceScope>(); var scoped = serviceScope.ServiceProvider.GetRequiredService <ScopedObject>(); if (scoped != null) { scoped.SetContext(context); } await next.Send(context).ConfigureAwait(false); } catch (Exception) { throw; } }
public IConsumerScopeContext <TConsumer, T> GetScope <TConsumer, T>(ConsumeContext <T> context) where TConsumer : class where T : class { if (context.TryGetPayload <IContainer>(out var existingContainer)) { existingContainer.Inject(context); var consumer = existingContainer.GetInstance <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerContext = context.PushConsumer(consumer); return(new ExistingConsumerScopeContext <TConsumer, T>(consumerContext)); } var nestedContainer = _container?.CreateNestedContainer(context) ?? _context?.CreateNestedContainer(context); try { var consumer = nestedContainer.GetInstance <TConsumer>(); if (consumer == null) { throw new ConsumerException($"Unable to resolve consumer type '{TypeMetadataCache<TConsumer>.ShortName}'."); } ConsumerConsumeContext <TConsumer, T> consumerContext = context.PushConsumerScope(consumer, nestedContainer); consumerContext.UpdatePayload(nestedContainer); return(new CreatedConsumerScopeContext <IContainer, TConsumer, T>(nestedContainer, consumerContext)); } catch { nestedContainer.Dispose(); throw; } }