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;
}
}
