public static IBusSubscriber SubscribeCommand <T>(this IBusSubscriber busSubscriber) where T : class, ICommand
{
return(busSubscriber.Subscribe <T>((sp, command, ctx) =>
{
var commandHandler = sp.GetRequiredService <ICommandHandler <T> >();
return commandHandler.HandleAsync(command);
}));
}
public static IBusSubscriber SubscribeEvent <T>(this IBusSubscriber busSubscriber) where T : class, IEvent
{
return(busSubscriber.Subscribe <T>((sp, @event, ctx) =>
{
var commandHandler = sp.GetRequiredService <IEventHandler <T> >();
return commandHandler.HandleAsync(@event);
}));
}
public CreateAirplaneHandlerTests()
{
_airplanesRepository = Substitute.For <IAirplanesRepository>();
_busPublisher = Substitute.For <IBusPublisher>();
_busSubscriber = Substitute.For <IBusSubscriber>();
_correlationContext = Substitute.For <ICorrelationContext>();
_commandHandler = new CreateAirplaneHandler(_airplanesRepository, _busPublisher);
}
protected override void SubscribeEventAndMessageBus(IBusSubscriber bus)
{
// base.SubscribeEventAndMessageBus(bus);
if (DomainType != null)
{
bus.SubscribeAllCommands(true, DomainType.Assembly);
//bus.SubscribeOnRejected(DomainType.Assembly);
}
//bus.SubscribeCommand<CreateProduct>(onError: (c, e) => new CreateProductRejected(c.Id, e.Message, e.Code));
}
private static IBusSubscriber SubscribeAllMessages <TMessage>
(this IBusSubscriber subscriber, string subscribeMethod, bool excludeOperationsMessages = false, params Assembly[] assemblies)
{
var ass = new List <Assembly>(assemblies);
//ass.Insert(0, MessagesAssembly);
ass.ForEach(assembly =>
{
var messageTypes = assembly
.GetTypes()
.Where(t => t.IsClass && !(t.IsAbstract) && typeof(TMessage).IsAssignableFrom(t))
.Where(t => excludeOperationsMessages && !ExcludedMessages.Contains(t))
.ToList();
var m0 = subscriber.GetType().GetMethod(subscribeMethod);
var m1 = typeof(Extensions).GetMethod("CreateOnRejected", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy);
foreach (var mt in messageTypes)
{
// if (mt.Name == "CreateTypeDePropriete")
// Debugger.Break();
try
{
var keyType = mt.GetProperty("Id").GetGetMethod().ReturnType;
var m2 = m0.MakeGenericMethod(mt);
var p0 = mt.GetCustomAttribute <MessageNamespaceAttribute>()?.Namespace;
var m3 = m1.MakeGenericMethod(keyType);
var p1 = m3.Invoke(null, new object[] { mt });
var p = new object[] { p0, null, p1 };
m2.Invoke(subscriber, p);
}catch (Exception e)
{
Logger.LogError(e.Message);
#if DEBUG
Debugger.Break();
#endif
}
}
/*messageTypes.ForEach(mt =>
* subscriber.GetType()
* .GetMethod(subscribeMethod)
* .MakeGenericMethod(mt)
* .Invoke(subscriber,
* new object[] {
* mt.GetCustomAttribute<MessageNamespaceAttribute>()?.Namespace,
* null,
* CreateOnRejected(mt) }));*/
});
return(subscriber);
}
private static IBusSubscriber SubscribeAllMessages <TMessage>(this IBusSubscriber subscriber, string subscriberMethod)
{
var messageTypes = MessageAssembly
.GetTypes()
.Where(t => t.IsClass && typeof(TMessage).IsAssignableFrom(t))
.Where(t => !ExcludeMessages.Contains(t))
.ToList();
messageTypes.ForEach(mt => subscriber.GetType()
.GetMethod(subscriberMethod)
.MakeGenericMethod(mt)
.Invoke(subscriber,
new object[] { mt.GetCustomAttribute <MessageNamespaceAttribute>()?.Namespace, null, null }));
return(subscriber);
}
protected virtual void SubscribeEventAndMessageBus(IBusSubscriber bus)
{
if (UseSignalR)
{
bus.SubscribeEvent <OperationPending>(@namespace: "operations")
.SubscribeEvent <OperationCompleted>(@namespace: "operations")
.SubscribeEvent <OperationRejected>(@namespace: "operations");
}
if (DomainType != null)
{
bus.SubscribeAllMessages(true, DomainType.Assembly);
// bus.SubscribeOnRejected(DomainType.Assembly);
}
}
private static void SubscribeCommands(IBusSubscriber subscriber, IEnumerable <ICommand> messages)
{
const string methodName = nameof(IBusSubscriber.Subscribe);
foreach (var message in messages)
{
var subscribeMethod = subscriber.GetType().GetMethod(methodName);
Task Handle(IServiceProvider sp, ICommand command, ICorrelationContext ctx) =>
sp.GetService <ICommandHandler <ICommand> >().HandleAsync(command);
subscribeMethod.MakeGenericMethod(message.GetType()).Invoke(subscriber,
new object[] { (Func <IServiceProvider, ICommand, ICorrelationContext, Task>)Handle });
}
}
public static IBusSubscriber SubscribeMessages(this IBusSubscriber subscriber)
{
const string path = "messages.json";
if (!File.Exists(path))
{
return(subscriber);
}
var messages = File.ReadAllText(path);
if (string.IsNullOrWhiteSpace(messages))
{
return(subscriber);
}
var servicesMessages = JsonConvert.DeserializeObject <IDictionary <string, ServiceMessages> >(messages);
if (!servicesMessages.Any())
{
return(subscriber);
}
var commands = new List <Command>();
var events = new List <TestEvent>();
var rejectedEvents = new List <Application.Types.RejectedEvent>();
var assemblyName = new AssemblyName("Sprirebyte.Services.Operations.Api.Messages");
var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
var moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name);
foreach (var(_, serviceMessages) in servicesMessages)
{
var exchange = serviceMessages.Exchange;
commands.AddRange(BindMessages <Command>(moduleBuilder, exchange, serviceMessages.Commands));
events.AddRange(BindMessages <TestEvent>(moduleBuilder, exchange, serviceMessages.Events));
rejectedEvents.AddRange(BindMessages <Application.Types.RejectedEvent>(moduleBuilder, exchange,
serviceMessages.RejectedEvents));
}
SubscribeCommands(subscriber, commands);
SubscribeEvents(subscriber, events);
SubscribeRejectedEvents(subscriber, rejectedEvents);
return(subscriber);
}
private static void SubscribeCommands(IBusSubscriber subscriber, IEnumerable <ICommand> messages)
{
if (messages is null)
{
return;
}
var subscribeMethod = subscriber.GetType().GetMethod(nameof(IBusSubscriber.Subscribe));
if (subscribeMethod is null)
{
return;
}
foreach (var message in messages)
{
subscribeMethod.MakeGenericMethod(message.GetType()).Invoke(subscriber,
new object[] { (Func <IServiceProvider, ICommand, object, Task>)Handle });
}
public TopicSubscriberSelfDestroyingTopicWrapper(BusManager busManager,
SubscriberSettings <TMessage> subscriberSettings,
ITopicNameGetter topicNameGetter,
IMessageSerializer <TMessage> messageSerializer,
ILogger logger,
TrackingModule trackingModule)
{
_topicName = topicNameGetter.Get <TMessage>(subscriberSettings);
_busSubscriber = new TopicSubscriberV2 <TMessage>(
busManager,
subscriberSettings,
topicNameGetter,
messageSerializer,
logger,
trackingModule);
UsedTopics.Add(_topicName);
}
public static IBusSubscriber SubscribeOnRejected(this IBusSubscriber bus, params Assembly[] assemblies)
{
var typesWithMyAttribute =
from a in assemblies
from t in a.GetTypes()
let attributes = t.GetCustomAttributes(typeof(OnRejectedAttribute), true)
where attributes != null && attributes.Length > 0
select new { Type = t, Attributes = attributes.Cast <OnRejectedAttribute>() };
foreach (var item in typesWithMyAttribute)
{
var type = item.Attributes.First().Type;
bus.SubscribeCommandByType(item.Type, onError: (c, e) =>
{
var o = (BaseRejectedEvent)c;
return((IRejectedEvent)Activator.CreateInstance(type, o.Id, o.Reason, o.Code));
});
}
return(bus);
}
public BusHostedService(IBusSubscriber busSubscriber) => _busSubscriber = busSubscriber;
public BaseHostedService(IBusSubscriber busSubscriber,
IDispatcher dispatcher)
{
_busSubscriber = busSubscriber;
_dispatcher = dispatcher;
}
private static IBusSubscriber SubscribeAllEvents(this IBusSubscriber subscriber) => subscriber.SubscribeAllMessages <IEvent>(nameof(IBusSubscriber.SubscribeEvent));
private static IBusSubscriber SubscribeAllCommands(this IBusSubscriber subscriber) => subscriber.SubscribeAllMessages <ICommand>(nameof(IBusSubscriber.SubscribeCommand));
public static IBusSubscriber SubscribeAllMessages(this IBusSubscriber subscriber) => subscriber.SubscribeAllCommands().SubscribeAllEvents();
public static IBusSubscriber SubscribeAllMessages(this IBusSubscriber subscriber, bool excludeOperationsMessages = false, params Assembly[] assemblies) => subscriber .SubscribeAllCommands(excludeOperationsMessages, assemblies) .SubscribeAllEvents(excludeOperationsMessages, assemblies);
public HandleMessage(IBusSubscriber subscriber)
{
_log.Debug("ctor -=========================================");
_subscriber = subscriber;
}
public static IBusSubscriber SubscribeAllCommands(this IBusSubscriber subscriber, bool excludeOperationsMessages = false, params Assembly[] assemblies) => subscriber.SubscribeAllMessages <ICommand>(nameof(IBusSubscriber.SubscribeCommand), excludeOperationsMessages, assemblies);
public static IBusSubscriber SubscribeAllEvents(this IBusSubscriber subscriber, bool excludeOperationsMessages = false, params Assembly[] assemblies) => subscriber.SubscribeAllMessages <IEvent>(nameof(IBusSubscriber.SubscribeEvent), excludeOperationsMessages, assemblies);
public static IBusSubscriber SubscribeCommand <T>(this IBusSubscriber busSubscriber) where T : class, ICommand => busSubscriber.Subscribe <T>(async(serviceProvider, command, _) =>
public static IBusSubscriber SubscribeCommand <T>(this IBusSubscriber busSubscriber) where T : class, ICommand => busSubscriber.Subscribe <T>((sp, command, ctx) => sp.GetService <ICommandHandler <T> >().HandleAsync(command));
public static IBusSubscriber SubscribeEvent <T>(this IBusSubscriber busSubscriber) where T : class, IIntegrationEvent => busSubscriber.Subscribe <T>(async(serviceProvider, @event, _) =>
public ValuesController(IBusPublisher publisher, IBusSubscriber subscriber)
{
_publisher = publisher;
_subscriber = subscriber;
}
public static IBusSubscriber SubscribeEvent <T>(this IBusSubscriber busSubscriber) where T : class, IEvent => busSubscriber.Subscribe <T>((sp, @event, ctx) => sp.GetService <IEventHandler <T> >().HandleAsync(@event));
public StubbedBusPublisher(IBusSubscriber subscriber)
{
_busSubscriber = subscriber;
}
protected override void SubscribeEventAndMessageBus(IBusSubscriber bus)
{
base.SubscribeEventAndMessageBus(bus);
bus.SubscribeAllMessages(true, Assembly.GetEntryAssembly(), Assembly.GetExecutingAssembly());
}
public StubbedControllerBusPublisher(IBusSubscriber busSubscriber)
{
_busSubscriber = busSubscriber;
}
