public async Task HandleSumThree()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 0, new object[] {
new IntArgument()
{
Left = 2, Right = 3
},
new IntArgument()
{
Left = 4, Right = 5
},
new ByteArgument {
Left = 6, Right = 7
}
});
Assert.IsNotNull(result);
Assert.IsTrue(result is int);
Assert.IsTrue((int)result == (2 + 3 + 4 + 5 + 6 + 7));
}
public async Task HandleManySum()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
resolver.Register(new CalculatorParameter()
{
First = 10
});
var watch = Stopwatch.StartNew();
for (int i = 0; i < 100000; i++)
{
//var result = await handler.HandleAsync(0, new IntArgument() { Left = 2, Right = 3 });
//var result = await handler.HandleAsync(0, new IntArgument() { Left = 2, Right = 3 });
var value = await handler.HandleAsync <CalculatorResult>(resolver.CreateSession(), 1, new object[] {
new CalculatorArgument()
{
Left = 2, Right = 3
},
});
}
watch.Stop();
// s: 100k 0.59s
}
public IResolverSession GetProtocolResolver(IPacketStream packetStream, CancellationToken cancellationToken)
{
var resolver = new Resolver();
resolver.LoadFromReference <ProtocolTests>();
var session = resolver.CreateSession();
var handler = new HandlerProvider(session.Resolve <IMethodContextInfoProvider>());
handler.LoadFromReference <ProtocolTests>();
var converter = new Serializer();
converter.LoadFromReference <ProtocolTests>();
var protocol = new SocketProtocolHandler(session, packetStream, converter, handler);
session.Resolver.Register(protocol);
session.Resolver.Register(handler);
session.Resolver.Register(converter);
var listenTask = protocol.ListenAsync(cancellationToken);
return(session);
}
public async Task CalculatorAddDuoTest()
{
var handlerProvider = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handlerProvider.LoadFromReference <HandlingTests>();
resolver.Register(new CalculatorParameter()
{
First = 10
});
//var sum = InterfaceHandling.CreateHandler<ICalculator, InterfaceHandlerTest<ICalculator>>(new HandlerArgument() { Arg = "5" });
var value = await handlerProvider.HandleAsync <CalculatorResult>(resolver.CreateSession(), "", 1,
new CalculatorArgument()
{
Left = 2, Right = 3
},
new CalculatorArgument()
{
Left = 4, Right = 5
});
var result = (CalculatorResult)value;
Assert.AreEqual(24, result.Result);
}
private void Initialize()
{
HandlerProvider = new HandlerProvider();
Serializer = new Serializer();
Resolver.Register(HandlerProvider);
Resolver.Register(Serializer);
}
protected override void ConsumeMessage(IMessageContext messageContext)
{
var eventContext = messageContext as MessageContext;
var message = eventContext.Message;
var messageHandlerTypes = HandlerProvider.GetHandlerTypes(message.GetType());
if (messageHandlerTypes.Count == 0)
{
return;
}
messageHandlerTypes.ForEach(messageHandlerType =>
{
PerMessageContextLifetimeManager.CurrentMessageContext = eventContext;
eventContext.ToBeSentMessageContexts.Clear();
var messageStore = IoCFactory.Resolve <IMessageStore>();
var subscriptionName = string.Format("{0}.{1}", SubscriptionName, messageHandlerType.FullName);
if (!messageStore.HasEventHandled(eventContext.MessageID, subscriptionName))
{
try
{
var messageHandler = IoCFactory.Resolve(messageHandlerType);
((dynamic)messageHandler).Handle((dynamic)message);
var commandContexts = eventContext.ToBeSentMessageContexts;
var eventBus = IoCFactory.Resolve <IEventBus>();
var messageContexts = new List <MessageContext>();
eventBus.GetMessages().ForEach(msg => messageContexts.Add(new MessageContext(msg)));
messageStore.SaveEvent(eventContext, subscriptionName, commandContexts, messageContexts);
if (commandContexts.Count > 0)
{
((CommandBus)IoCFactory.Resolve <ICommandBus>()).SendCommands(commandContexts.AsEnumerable());
}
if (messageContexts.Count > 0)
{
IoCFactory.Resolve <IEventPublisher>().Publish(messageContexts.ToArray());
}
}
catch (Exception e)
{
if (e is DomainException)
{
_Logger.Warn(message.ToJson(), e);
}
else
{
//IO error or sytem Crash
_Logger.Error(message.ToJson(), e);
}
messageStore.SaveFailHandledEvent(eventContext, subscriptionName, e);
}
finally
{
PerMessageContextLifetimeManager.CurrentMessageContext = null;
}
}
});
}
public bool RegisterHandler(Type type, bool isSingletone)
{
if (HandlerProvider.RegisterHandler(type))
{
Resolver.Register(type, true, isSingletone);
return(true);
}
return(false);
}
public bool RegisterHandler(object instance, bool includeBase)
{
if (HandlerProvider.RegisterHandler(instance.GetType()))
{
Resolver.Register(instance, includeBase);
return(true);
}
return(false);
}
public RouteContext GetContext(RouteId id, HttpContext ctx)
{
var spec = Specs[id];
var options = RouteOptionsBuilder.Build(id, Config);
var callCtx = RequestContextBuilder.Build(ctx);
var handler = HandlerProvider.GetHandler(options.Handler, options.Config, responseContext: null);
return(new RouteContext(options, spec, callCtx, handler, Logger));
}
public async Task HandleSumString()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var result = await handler.HandleAsync <string>(resolver.CreateSession(), 0, "s");
Assert.IsNotNull(result);
Assert.IsTrue(result is string);
Assert.IsTrue((string)result == "sums");
}
public async Task HandleSumZero()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 0, new object[] { });
Assert.IsNotNull(result);
Assert.IsTrue(result is int);
Assert.IsTrue((int)result == 1);
}
public async Task HandleMinusAsyncWithRole()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 2, new IntArgument()
{
Left = 2, Right = 3
});
Assert.IsNotNull(result);
Assert.IsTrue(result is int);
Assert.IsTrue((int)result == -1);
}
static async Task Main(string[] args)
{
var provider = new HandlerProvider();
var pipeline = new PipeLineBuilder(provider);
pipeline.UseHandler <MessageHandler>();
pipeline.UseHandler <EmailHandler>();
var del = pipeline.Build();
await del(new HandlerContext()
{
Topic = "Email"
});
Console.Read();
}
public async Task CalculatorAddStringTest()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
resolver.Register(new CalculatorParameter()
{
First = 10
});
//var sum = InterfaceHandling.CreateHandler<ICalculator, InterfaceHandlerTest<ICalculator>>(new HandlerArgument() { Arg = "5" });
var result = await handler.HandleAsync <CalculatorResult>(resolver.CreateSession(), "IAddString", 1, "6");
Assert.AreEqual(7, result.Result);
}
public void LoadFromReference <T>()
{
if (loaded)
{
throw new Exception($"Already initialized");
}
Resolver.LoadFromReference <T>();
if (Resolver.TryResolveSingletone <IMethodContextInfoProvider>(out var contextProvider))
{
HandlerProvider = new HandlerProvider(contextProvider);
Resolver.Register(HandlerProvider);
}
HandlerProvider.LoadFromReference <T>();
Serializer.LoadFromReference <T>();
loaded = true;
}
public async Task HandleManyMultiplyAsync()
{
var handler = new HandlerProvider();
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
handler.LoadFromReference <HandlingTests>();
var watch = Stopwatch.StartNew();
for (int i = 0; i < 100000; i++)
{
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 1, new IntArgument()
{
Left = 2, Right = 3
});
}
watch.Stop();
// 0.48s (0.8) 100k
}
public async Task HandlerByteMinusAsyncWithAdminMinusRoles()
{
var resolver = new Resolver();
resolver.LoadFromReference <HandlingTests>();
var handler = new HandlerProvider();
handler.LoadFromReference <HandlingTests>();
resolver.Register(new Roles("Minus", "Admin"));
var result = await handler.HandleAsync <int>(resolver.CreateSession(), 2, new ByteArgument()
{
Left = 6, Right = 2
});
Assert.IsNotNull(result);
Assert.IsTrue(result is int);
Assert.IsTrue((int)result == 3);
}
Task SendInProc(IMessageContext commandContext, CancellationToken cancellationToken)
{
Task task = null;
var command = commandContext.Message as ICommand;
if (command is ILinearCommand)
{
task = SendAsync(commandContext, cancellationToken);
}
else //if not a linear command, we run synchronously.
{
task = new Task(() =>
{
var commandHandler = HandlerProvider.GetHandler(command.GetType());
if (commandHandler == null)
{
throw new NoCommandHandlerExists();
}
MessageState messageState = BuildMessageState(commandContext.MessageID, command, cancellationToken);
PerMessageContextLifetimeManager.CurrentMessageContext = commandContext;
try
{
var unitOfWork = IoCFactory.Resolve <IUnitOfWork>();
commandHandler.Handle(command);
unitOfWork.Commit();
}
finally
{
commandContext.ClearItems();
}
});
task.RunSynchronously();
if (task.Exception != null)
{
throw task.Exception.GetBaseException();
}
}
return(task);
}
public async Task InterfaceToMethodProtocolHandlerTest()
{
var resolver = new Resolver();
resolver.LoadFromReference <ProtocolTests>();
resolver.Register(new CalculatorParameter()
{
First = 10
});
var session = resolver.CreateSession();
//resolver.Register(session);
var handler = new HandlerProvider(session.Resolve <IMethodContextInfoProvider>());
handler.LoadFromReference <ProtocolTests>();
var methodHandler = new MethodProtocolHandler(handler, session);
resolver.Register(methodHandler, true);
var calculator = InterfaceHandling.CreateHandler <ICalculator, ProtocolInterfaceHandler <ICalculator> >(session);
List <Task> tasks = new List <Task>();
var watch = Stopwatch.StartNew();
for (int i = 0; i < 10000; i++)
{
var task = calculator.AddAsync("20");
tasks.Add(task);
}
await Task.WhenAll(tasks);
watch.Stop();
// a: 10k 0.2-0.3s
//Assert.AreEqual(30, task.Result);
}
public SyncSession(SyncServer server, HandlerProvider provider, ILogger <SyncSession> logger) : base(server, provider, logger)
{
}
protected override void ConsumeMessage(IFramework.MessageQueue.EQueue.MessageFormat.MessageContext messageContext, EQueueProtocols.QueueMessage queueMessage)
{
if (messageContext == null || messageContext.Message == null)
{
return;
}
var message = messageContext.Message as ICommand;
if (message == null)
{
return;
}
MessageReply messageReply = null;
var needRetry = message.NeedRetry;
bool commandHasHandled = false;
IMessageStore messageStore = null;
try
{
PerMessageContextLifetimeManager.CurrentMessageContext = messageContext;
messageStore = IoCFactory.Resolve <IMessageStore>();
commandHasHandled = messageStore.HasCommandHandled(messageContext.MessageID);
if (!commandHasHandled)
{
var messageHandler = HandlerProvider.GetHandler(message.GetType());
_Logger.InfoFormat("Handle command, commandID:{0}", messageContext.MessageID);
if (messageHandler == null)
{
messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, new NoHandlerExists());
}
else
{
do
{
try
{
((dynamic)messageHandler).Handle((dynamic)message);
messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, messageContext.Reply);
needRetry = false;
}
catch (Exception ex)
{
if (!(ex is OptimisticConcurrencyException) || !needRetry)
{
throw;
}
}
} while (needRetry);
}
}
else
{
messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, new MessageDuplicatelyHandled());
}
}
catch (Exception e)
{
messageReply = new MessageReply(messageContext.ReplyToEndPoint, messageContext.MessageID, e.GetBaseException());
if (e is DomainException)
{
_Logger.Warn(message.ToJson(), e);
}
else
{
_Logger.Error(message.ToJson(), e);
}
if (messageStore != null)
{
messageStore.SaveFailedCommand(messageContext);
}
}
finally
{
PerMessageContextLifetimeManager.CurrentMessageContext = null;
}
if (!commandHasHandled)
{
OnMessageHandled(messageContext, messageReply);
HandledMessageCount++;
}
}
private static Type GetHandler <TAction>(TAction action)
where TAction : IAction
{
return(HandlerProvider.GetHandler <IActionHandler <TAction> >());
}
protected virtual Task SendInProc(IMessageContext commandContext, CancellationToken cancellationToken)
{
Task task = null;
var command = commandContext.Message as ICommand;
if (command is ILinearCommand)
{
task = SendAsync(commandContext, cancellationToken);
}
else if (command != null) //if not a linear command, we run synchronously.
{
task = Task.Factory.StartNew(() =>
{
IMessageStore messageStore = null;
try
{
var needRetry = command.NeedRetry;
object result = null;
PerMessageContextLifetimeManager.CurrentMessageContext = commandContext;
messageStore = IoCFactory.Resolve <IMessageStore>();
if (!messageStore.HasCommandHandled(commandContext.MessageID))
{
var commandHandler = HandlerProvider.GetHandler(command.GetType());
if (commandHandler == null)
{
PerMessageContextLifetimeManager.CurrentMessageContext = null;
throw new NoHandlerExists();
}
do
{
try
{
((dynamic)commandHandler).Handle((dynamic)command);
result = commandContext.Reply;
needRetry = false;
}
catch (Exception ex)
{
if (!(ex is OptimisticConcurrencyException) || !needRetry)
{
throw;
}
}
} while (needRetry);
return(result);
}
else
{
throw new MessageDuplicatelyHandled();
}
}
catch (Exception e)
{
if (e is DomainException)
{
_Logger.Warn(command.ToJson(), e);
}
else
{
_Logger.Error(command.ToJson(), e);
}
if (messageStore != null)
{
messageStore.SaveFailedCommand(commandContext);
}
throw;
}
finally
{
PerMessageContextLifetimeManager.CurrentMessageContext = null;
}
}, cancellationToken);
}
return(task);
}
private IPersonIdentifierDisplayHandler GetDisplayHandler(IdentifierDefinition identifierType) => HandlerProvider.GetDisplayHandler(identifierType);
