public StartConsumers(IConsumerFactory consumerFactory, IHandlerInvoker invoker, IWorkerThreadsConfig config, ILogger <StartConsumers> logger)
{
this.consumerFactory = consumerFactory ?? throw new ArgumentNullException(nameof(consumerFactory));
this.invoker = invoker ?? throw new ArgumentNullException(nameof(invoker));
this.config = config ?? throw new ArgumentNullException(nameof(config));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
/// <summary>
/// Initialize the client and send welcome packet.
/// </summary>
public void Initialize(ILogger <WorldClient> logger, IHandlerInvoker handlerInvoker, IWorldServerPacketFactory worldServerPacketFactory)
{
_logger = logger;
_handlerInvoker = handlerInvoker;
worldServerPacketFactory.SendWelcome(this, SessionId);
}
/// <summary>
/// Initializes the <see cref="ClusterClient"/>.
/// </summary>
/// <param name="clusterServer">Parent cluster server.</param>
/// <param name="logger">Logger.</param>
/// <param name="handlerInvoker">Handler invoker.</param>
/// <param name="clusterPacketFactory">Cluster packet factory.</param>
public void Initialize(IClusterServer clusterServer, ILogger <ClusterClient> logger, IHandlerInvoker handlerInvoker, IClusterPacketFactory clusterPacketFactory)
{
_clusterServer = clusterServer;
_logger = logger;
_handlerInvoker = handlerInvoker;
clusterPacketFactory.SendWelcome(this);
}
/// <summary>
/// Creates a new <see cref="WorldCoreClient"/> instance.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="worldConfiguration">World server configuration.</param>
/// <param name="coreConfiguration">Core server configuration.</param>
/// <param name="handlerInvoker">Handler invoker.</param>
public WorldCoreClient(ILogger <WorldCoreClient> logger, IOptions <WorldConfiguration> worldConfiguration, IOptions <CoreConfiguration> coreConfiguration, IHandlerInvoker handlerInvoker)
{
_logger = logger;
WorldServerConfiguration = worldConfiguration.Value;
CoreClientConfiguration = coreConfiguration.Value;
_handlerInvoker = handlerInvoker;
ClientConfiguration = new NetClientConfiguration(CoreClientConfiguration.Host, CoreClientConfiguration.Port, BufferSize);
}
public DefaultEventDispatcher(IEventHandlerRegistry handlerRegistry, IHandlerInvoker handlerInvoker)
{
Check.Argument.IsNotNull(handlerRegistry, "handlerRegistry");
Check.Argument.IsNotNull(handlerInvoker, "handlerInvoker");
_handlerRegistry = handlerRegistry;
_handlerInvoker = handlerInvoker;
}
/// <summary>
/// Initializes the current <see cref="LoginClient"/> instance.
/// </summary>
/// <param name="loginServer">Parent login server.</param>
/// <param name="logger">Logger.</param>
/// <param name="handlerInvoker">Handler invoker.</param>
/// <param name="loginPacketFactory">Login packet factory.</param>
public void Initialize(ILoginServer loginServer, ILogger <LoginClient> logger, IHandlerInvoker handlerInvoker, ILoginPacketFactory loginPacketFactory)
{
_loginServer = loginServer;
_logger = logger;
_handlerInvoker = handlerInvoker;
loginPacketFactory.SendWelcome(this, SessionId);
}
public DefaultEventDispatcher(IHandlerRegistry handlerRegistry, IHandlerInvoker handlerInvoker)
{
Require.NotNull(handlerRegistry, "handlerRegistry");
Require.NotNull(handlerInvoker, "handlerInvoker");
_handlerRegistry = handlerRegistry;
_handlerInvoker = handlerInvoker;
}
/// <summary>
/// Creates a new <see cref="ClusterCoreClient"/> instance.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="handlerInvoker">Handler invoker.</param>
/// <param name="clusterConfiguration">Cluster server configuration.</param>
/// <param name="coreConfiguration">Core server configuration.</param>
public ClusterCoreClient(ILogger <ClusterCoreClient> logger, IHandlerInvoker handlerInvoker, IOptions <ClusterConfiguration> clusterConfiguration, IOptions <CoreConfiguration> coreConfiguration)
{
_logger = logger;
_handlerInvoker = handlerInvoker;
_coreConfiguration = coreConfiguration.Value;
ClusterConfiguration = clusterConfiguration.Value;
ClientConfiguration = new NetClientConfiguration(_coreConfiguration.Host, _coreConfiguration.Port, BufferSize);
WorldServers = new List <WorldServerInfo>();
}
/// <summary>
/// Creates a new <see cref="CoreServer"/> instance.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="configuration">Core server configuration.</param>
/// <param name="serviceProvider">Service provider.</param>
public CoreServer(ILogger <CoreServer> logger, IOptions <CoreConfiguration> configuration, IServiceProvider serviceProvider, IHandlerInvoker handlerInvoker)
{
_logger = logger;
_configuration = configuration.Value;
_serviceProvider = serviceProvider;
_handlerInvoker = handlerInvoker;
ServerConfiguration = new NetServerConfiguration(_configuration.Host,
_configuration.Port,
ClientBacklog,
ClientBufferSize);
}
public IncomingPipeline(
IMessageSource messageSource,
IEnumerable <IIncomingBehaviour> behaviours,
IServiceScopeFactory serviceScopeFactory,
IHandlerInvoker handlerInvoker,
ILogger <IncomingPipeline> logger,
RetryOptions retryOptions)
{
this.behaviours = behaviours.ToArray();
this.messageSource = messageSource;
this.serviceScopeFactory = serviceScopeFactory;
this.handlerInvoker = handlerInvoker;
this.logger = logger;
this.retryOptions = retryOptions;
}
public async Task Start <TTopology>(IConnection connection) where TTopology : ITopology
{
await Task.Run(() =>
{
m_channel = connection.CreateModel();
m_container = this.RegisterDependencies();
m_publisher = m_container.Resolve <IPublisher>();
m_consumer = m_container.Resolve <IConsumer <BasicDeliverEventArgs> >();
m_topology = this.InitializeTopology <TTopology>();
m_handlerInvoker = m_container.Resolve <IHandlerInvoker>();
this.RegisterHandlersInInvoker();
m_serializer = m_container.Resolve <IMessageSerializer>();
m_serializer.KnownAssemblies = this.ContractsAssemblies.ToList();
m_topology.Initialize()
.ListenForCommands(OnCommand)
.ListenForEvents(OnEvent);
});
}
public TypedInvoker1(TypedHandler1 <T> handler, IHandlerInvoker continueWith)
{
this.handler = handler;
continuation = continueWith;
}
/// <summary>
/// Creates a new <see cref="SnapshotHandler"/> instance.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="handlerInvoker">Handler invoker.</param>
public SnapshotHandler(ILogger <SnapshotHandler> logger, IHandlerInvoker handlerInvoker)
{
_logger = logger;
_handlerInvoker = handlerInvoker;
}
/// <summary>
/// Initialize the <see cref="CoreServerClient"/>.
/// </summary>
/// <param name="logger">Logger.</param>
/// <param name="handlerInvoker">Handler Invoker.</param>
public void Initialize(ILogger <CoreServerClient> logger, IHandlerInvoker handlerInvoker)
{
_logger = logger;
_handlerInvoker = handlerInvoker;
}
public HandlerBucket(EventHandler <TEventArgs> handler)
{
_invoker = GetHandlerInvoker(handler.GetMethodInfo());
_weaklyReferencedTarget = new WeakReference(handler.Target);
}
/// <summary>
/// Creates a new <see cref="LoginClient"/> instance.
/// </summary>
public LoginClient(ILogger <ImgeneusClient> logger, ICryptoManager cryptoManager, IServiceProvider serviceProvider, IHandlerInvoker handlerInvoker, ILoginPacketFactory loginPacketFactory) :
base(logger, cryptoManager, serviceProvider)
{
_handlerInvoker = handlerInvoker;
_loginPacketFactory = loginPacketFactory;
}
public static void SetHandlerInvoker(IHandlerInvoker handlerInvoker)
{
invoker = handlerInvoker;
}
public WorldClient(ILogger <ImgeneusClient> logger, ICryptoManager cryptoManager, IServiceProvider serviceProvider, IHandlerInvoker handlerInvoker) :
base(logger, cryptoManager, serviceProvider)
{
_handlerInvoker = handlerInvoker;
}
public void Setup()
{
defaultHandlerInvoker = new DefaultHandlerInvoker(new ArgumentBuilder());
requestContext = new RequestContext { RouteData = new RouteData() };
}
public void Setup()
{
defaultHandlerInvoker = new DefaultHandlerInvoker(new ArgumentBuilder());
requestContext = new RequestContext { HttpContext = MvcMockHelpers.FakeHttpContext() };
}
public DynamicInvoker(DynamicHandler handler, IHandlerInvoker continueWith)
{
this.handler = handler;
continuation = continueWith;
}
