public MTProtoClientConnection(
[NotNull] IClientTransportConfig clientTransportConfig,
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec)
{
Argument.IsNotNull(() => clientTransportConfig);
Argument.IsNotNull(() => clientTransportFactory);
Argument.IsNotNull(() => tlRig);
Argument.IsNotNull(() => messageIdGenerator);
Argument.IsNotNull(() => messageCodec);
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
DefaultRpcTimeout = Defaults.RpcTimeout;
DefaultConnectTimeout = Defaults.ConnectTimeout;
_methods = new MTProtoAsyncMethods(this);
InitResponseDispatcher(_responseDispatcher);
// Init transport.
_clientTransport = clientTransportFactory.CreateTransport(clientTransportConfig);
// Connector in/out.
_clientTransport.ObserveOn(DefaultScheduler.Instance).Do(bytes => LogMessageInOut(bytes, "IN")).Subscribe(ProcessIncomingMessageBytes);
}
public TcpMessageSender(ClientConfig clientConfig, IMessageStatistics statistics)
{
_mClientConfig = clientConfig;
_mStatistics = statistics;
_mActive = true;
_mQueue = new ConcurrentQueue <IMessageTree>();
_mCodec = new PlainTextMessageCodec();
}
public TcpMessageSender(ClientConfig clientConfig, IMessageStatistics statistics)
{
_mClientConfig = clientConfig;
_mStatistics = statistics;
_mActive = true;
_mQueue = new List<IMessageTree>(100000);
_mCodec = new PlainTextMessageCodec();
}
public TcpMessageSender(ClientConfig clientConfig, IMessageStatistics statistics)
{
_clientConfig = clientConfig;
_statistics = statistics;
_connPool = new ConcurrentDictionary <Server, TcpClient>();
_queue = new ConcurrentQueue <IMessageTree>();
_codec = new PlainTextMessageCodec();
_maxQueueSize = clientConfig.Domain.MaxQueueSize;
}
/// <summary>
/// Initializes a new instance of the <see cref="BasicMessageChannel{T}"/> class.
/// </summary>
public BasicMessageChannel(string name, IMessageCodec <T> codec, IBinaryMessenger messenger)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("name cannot be null or empty");
}
_name = name;
_codec = codec ?? throw new ArgumentNullException(nameof(codec));
_messenger = messenger ?? throw new ArgumentNullException(nameof(messenger));
}
public TcpMessageSender(AbstractClientConfig clientConfig, IMessageStatistics statistics, MessageIdFactory messageIdFactory)
{
_mClientConfig = clientConfig;
_mStatistics = statistics;
_mActive = true;
_mQueue = new BlockingThreadSafeQueue<IMessageTree>();
_mAtomicTrees = new BlockingThreadSafeQueue<IMessageTree>(MAX_ATOMIC_MESSAGES);
_mCodec = new PlainTextMessageCodec();
_messageIdFactory = messageIdFactory;
}
public TcpMessageSender(ClientConfig clientConfig, IMessageStatistics statistics)
{
_clientConfig = clientConfig;
_statistics = statistics;
_connPool = new ConcurrentDictionary<Server, TcpClient>();
_queue = new ConcurrentQueue<IMessageTree>();
_atomicTress = new ConcurrentQueue<IMessageTree>();
_codec = new PlainTextMessageCodec();
_maxQueueSize = clientConfig.Domain.MaxQueueSize;
}
public TcpMessageSender(AbstractClientConfig clientConfig, IMessageStatistics statistics, MessageIdFactory messageIdFactory)
{
_mClientConfig = clientConfig;
_mStatistics = statistics;
_mActive = true;
_mQueue = new BlockingThreadSafeQueue <IMessageTree>();
_mAtomicTrees = new BlockingThreadSafeQueue <IMessageTree>(MAX_ATOMIC_MESSAGES);
_mCodec = new PlainTextMessageCodec();
_messageIdFactory = messageIdFactory;
}
public MessageHandler(IServiceProvider serviceProvider,
ILoggerFactory loggerFactory,
IMessageCenter messageCenter,
IMessageCodec codec)
{
this.messageCenter = messageCenter;
this.serviceProvider = serviceProvider;
this.logger = loggerFactory.CreateLogger("Network");
this.codec = codec;
}
public MTProtoClientConnection(
[NotNull] IClientTransportConfig clientTransportConfig,
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec)
{
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
DefaultRpcTimeout = Defaults.RpcTimeout;
DefaultConnectTimeout = Defaults.ConnectTimeout;
_methods = new MTProtoAsyncMethods(this);
_updatesHandler = new UpdatesHandler(_tlRig);
InitResponseDispatcher(_responseDispatcher);
// Init transport.
_clientTransport = clientTransportFactory.CreateTransport(clientTransportConfig);
// Connector in/out.
_clientTransport.ObserveOn(DefaultScheduler.Instance).Do(bytes => LogMessageInOut(bytes, "IN")).Subscribe(ProcessIncomingMessageBytes);
_clientTransport.RegisterOnDisconnectInternally(() =>
{
Console.WriteLine("Client has been closed internally.");
if (_onClosedInternally != null)
{
_onClosedInternally(this, null);
}
if (_state == MTProtoConnectionState.Disconnected)
{
return;
}
_state = MTProtoConnectionState.Disconnected;
if (_connectionCts != null)
{
_connectionCts.Cancel();
_connectionCts.Dispose();
_connectionCts = null;
}
});
}
public DefaultConnectionSessionInfo(long sessionID,
ILogger logger,
IMessageCodec codec,
SendingThreads sendingThreads)
{
this.sessionID = sessionID;
this.logger = logger;
this.codec = codec;
this.sendingThreads = sendingThreads;
this.inboundMessageQueue = new ConcurrentQueue <OutboundMessage>();
this.ActiveTime = Platform.GetMilliSeconds();
}
public WebSocketMiddleware(IMessageListener listener, IHostApplicationLifetime hostLifetime,
IMessageCodec messageCodec, ILoggerFactory loggerFactory, ServiceAddress address)
{
_listener = listener;
_messageCodec = messageCodec;
_loggerFactory = loggerFactory;
_address = address;
_logger = loggerFactory.CreateLogger <WebSocketMiddleware>();
if (_appShutdownHandler.Token.Equals(CancellationToken.None))
{
_appShutdownHandler = hostLifetime.ApplicationStopping.Register(ApplicationShutdownHandler);
}
SocketLoopTokenSource = new CancellationTokenSource();
}
public async Task Listen(int port, IMessageHandlerFactory factory, IMessageCodec codec)
{
var connectionListener = this.ServiceProvider.GetRequiredService <IConnectionListener>();
var messageCenter = this.ServiceProvider.GetRequiredService <IMessageCenter>();
var clientFactory = this.ServiceProvider.GetRequiredService <IClientConnectionFactory>();
var clientConnectionPool = this.serviceProvider.GetRequiredService <ClientConnectionPool>();
factory.Codec = codec;
clientFactory.Init();
connectionListener.Init();
await connectionListener.BindAsync(port, factory).ConfigureAwait(false);
clientConnectionPool.MessageHandlerFactory = factory;
}
public MessageBus(string listenAddress, string publishAddress, IMessageCodec messageCodec)
{
_listenAddress = listenAddress;
_publishAddress = publishAddress;
_messageCodec = messageCodec;
_messages = new Subject <object>();
_context = new Context(1);
_outgoing = _context.Socket(SocketType.PUB);
_outgoing.Connect(_publishAddress);
_incoming = _context.Socket(SocketType.SUB);
_incoming.Bind(_listenAddress);
_incoming.Subscribe(string.Empty, messageCodec.Encoding);
}
public MTProtoClientBuilder(
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec,
[NotNull] IHashServices hashServices,
[NotNull] IEncryptionServices encryptionServices,
[NotNull] INonceGenerator nonceGenerator,
[NotNull] IKeyChain keyChain)
{
_clientTransportFactory = clientTransportFactory;
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
_nonceGenerator = nonceGenerator;
_keyChain = keyChain;
}
public MTProtoClientBuilder(
[NotNull] IClientTransportFactory clientTransportFactory,
[NotNull] TLRig tlRig,
[NotNull] IMessageIdGenerator messageIdGenerator,
[NotNull] IMessageCodec messageCodec,
[NotNull] IHashServices hashServices,
[NotNull] IEncryptionServices encryptionServices,
[NotNull] INonceGenerator nonceGenerator,
[NotNull] IKeyChain keyChain)
{
_clientTransportFactory = clientTransportFactory;
_tlRig = tlRig;
_messageIdGenerator = messageIdGenerator;
_messageCodec = messageCodec;
_hashServices = hashServices;
_encryptionServices = encryptionServices;
_nonceGenerator = nonceGenerator;
_keyChain = keyChain;
}
public async Task ListenWebSocket(int port, string websocketPath, IMessageHandlerFactory factory, IMessageCodec codec)
{
var connectionListener = this.ServiceProvider.GetRequiredService <IConnectionListener>();
var messageCenter = this.ServiceProvider.GetRequiredService <IMessageCenter>();
var clientFactory = this.ServiceProvider.GetRequiredService <IClientConnectionFactory>();
factory.Codec = codec;
clientFactory.Init();
connectionListener.Init();
await connectionListener.BindWebSocketAsync(port, websocketPath, factory).ConfigureAwait(false);
}
/// <summary> RabbitMQ事件总线 </summary>
/// <param name="connection"></param>
/// <param name="subsManager"></param>
/// <param name="messageCodec"></param>
public EventBusRabbitMq(IRabbitMqConnection connection, ISubscribeManager subsManager, IMessageCodec messageCodec)
: base(subsManager, messageCodec, connection?.Name)
{
_connection =
connection ?? throw new ArgumentNullException(nameof(connection));
_brokerName = connection.Broker;
_logger = CurrentIocManager.CreateLogger <EventBusRabbitMq>();
SubscriptionManager.OnEventRemoved += SubsManager_OnEventRemoved;
}
/// <summary> 使用RabbitMQ事件总线 </summary>
/// <param name="services"></param>
/// <param name="configName"></param>
/// <param name="messageCodec"></param>
/// <returns></returns>
public static IServiceCollection AddRabbitMqEventBus(this IServiceCollection services, string configName = null, IMessageCodec messageCodec = null)
{
if (messageCodec != null)
{
services.TryAddSingleton(messageCodec);
}
else
{
services.TryAddSingleton <IMessageSerializer, JsonMessageSerializer>();
services.TryAddSingleton <IMessageCodec, JsonCodec>();
}
services.AddSingleton <IEventBus>(provider =>
{
var manager = provider.GetService <ISubscribeManager>();
var codec = provider.GetService <IMessageCodec>();
var connection = new DefaultRabbitMqConnection(configName);
return(new EventBusRabbitMq(connection, manager, codec));
});
return(services);
}
public HttpMicroListener(IMessageCodec messageCodec, IMicroEntryFactory entryFactory, ILoggerFactory loggerFactory)
{
_messageCodec = messageCodec;
_entryFactory = entryFactory;
_logger = loggerFactory.CreateLogger <HttpMicroListener>();
}
public DotNettyMicroListener(ILoggerFactory loggerFactory, IMessageCodec messageCodec)
{
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger <DotNettyMicroListener>();
_messageCodec = messageCodec;
}
/// <summary>
/// Initializes a new instance of the <see cref="BasicMessageChannel{T}"/> class.
/// </summary>
public BasicMessageChannel(string name, IMessageCodec <T> codec)
: this(name, codec, DefaultBinaryMessenger.Instance)
{
}
public UdpMicroListener(ILoggerFactory loggerFactory, IMessageCodec messageCodec)
{
_loggerFactory = loggerFactory;
_messageCodec = messageCodec;
_logger = loggerFactory.CreateLogger <UdpMicroListener>();
}
protected AbstractEventBus(ISubscribeManager manager, IMessageCodec messageCodec, string name = null)
{
SubscriptionManager = manager ?? new DefaultSubscribeManager();
Codec = messageCodec;
Name = name;
}
