/// <summary>
/// Initializes a new instance of the <see cref="WebSocketDataHandler" /> class.
/// </summary>
/// <param name="dependencyUtility">The dependency utility.</param>
protected WebSocketDataHandler(IDependencyUtility dependencyUtility)
{
_dependencyUtility = dependencyUtility ?? throw new ArgumentNullException(nameof(dependencyUtility));
Logger = _dependencyUtility.Resolve <ILogger>();
ConnectionManager = _dependencyUtility.Resolve <IWebSocketConnectionManager>();
}
/// <summary>
/// Initializes a new instance of the <see cref="DirectMessagingExtension"/> class.
/// </summary>
/// <param name="extensionName">Name of the extension.</param>
/// <param name="dependencyUtility">The dependency utility.</param>
public DirectMessagingExtension(string extensionName, IDependencyUtility dependencyUtility) : base(extensionName, dependencyUtility)
{
this.RegisterAction("SendMessage", SendMessage);
_connections = dependencyUtility.Resolve <IWebSocketConnectionManager>();
_queueHandler = dependencyUtility.Resolve <IEventedQueueHandler <ISignal> >();
}
public BroadcastService(
ILogger <BroadcastService> logger,
IWebSocketConnectionManager connectionManager)
{
this.logger = logger;
this.connectionManager = connectionManager;
}
/// <summary>
/// Initializes this instance.
/// </summary>
public void Initialize()
{
if (_extensionLoader == null)
{
_extensionLoader = _dependencyUtility.Resolve <IExtensionLoader>();
}
if (_logger == null)
{
_logger = _dependencyUtility.Resolve <ILogger>();
}
if (_config == null)
{
_config = _dependencyUtility.Resolve <IConfigurationHandler>();
}
if (_connectionManager == null)
{
_connectionManager = _dependencyUtility.Resolve <IWebSocketConnectionManager>();
}
CreateConnectionResources();
CreateRequestResources();
CreateResponseResources();
_isInitialized = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="WebSocketServer"/> class.
/// </summary>
/// <param name="id">The identifier.</param>
/// <param name="host">The host.</param>
/// <param name="port">The port.</param>
/// <param name="dependencyUtility">The dependency utility.</param>
/// <param name="listenerThreads">The listener threads.</param>
/// <param name="clientThreadMultiplier">The client thread multiplier.</param>
public WebSocketServer(string id, string host, int port, IDependencyUtility dependencyUtility = null, int listenerThreads = 1, int clientThreadMultiplier = 3)
{
Id = id;
Host = host;
Port = port;
_listenerThreads = listenerThreads;
_clientThreadMultiplier = clientThreadMultiplier;
_dependencyUtility = dependencyUtility ?? new DependencyUtility();
_logger = _dependencyUtility.Resolve <ILogger>() ??
_dependencyUtility.Register <ILogger>(new Logger());
_securityContainer = _dependencyUtility.Resolve <ISecurityContainer>() ??
_dependencyUtility.Register <ISecurityContainer>(new SecurityContainer(null, SslProtocols.None, false, false, false));
_clientHandler = _dependencyUtility.Resolve <ITcpHandler>() ??
_dependencyUtility.Register <ITcpHandler>(new TcpHandler(IPAddress.Parse(Host), Port));
_connectionManager = _dependencyUtility.Resolve <IWebSocketConnectionManager>() ??
_dependencyUtility.Register <IWebSocketConnectionManager>(new WebSocketConnectionManager(_dependencyUtility));
_threadHelper = _dependencyUtility.Resolve <IThreadHelper>() ??
_dependencyUtility.Register <IThreadHelper>(new ThreadHelper());
_routeTable = _dependencyUtility.Resolve <IRouteTable>() ??
_dependencyUtility.Register <IRouteTable>(BuildRouteTable());
}
public ClientsDispatcher(IWebSocketConnectionManager manager, IBackplane backplane, ILogger <ClientsDispatcher> logger)
{
Manager = manager;
Backplane = backplane;
_logger = logger;
All = new ClientInvoker(
async(methodName, args) =>
{
var message = new Message()
{
MessageType = MessageType.ClientMethodInvocation,
Data = MessageSerializer.SerializeObject(new InvocationDescriptor()
{
MethodName = methodName,
Arguments = args
})
};
await Backplane.SendMessageAllAsync(message).ConfigureAwait(false);
},
async msg =>
{
await Backplane.SendMessageAllAsync(msg).ConfigureAwait(false);
},
async group => {
await Backplane.SubscribeAll(group).ConfigureAwait(false);
},
async group => {
await Backplane.UnsubscribeAll(group).ConfigureAwait(false);
});
}
/// <summary>
/// Registers the connection.
/// </summary>
/// <param name="connection">The connection.</param>
public override void RegisterConnection(IWebSocketConnection connection)
{
if (_connections == null)
{
_connections = DependencyUtility.Resolve <IWebSocketConnectionManager>();
}
_queueHandler.CreateQueue(QUEUE_EXCHANGE_ID, connection.ClientIdentifier);
_queueHandler.AddEvent(QUEUE_EXCHANGE_ID, connection.ClientIdentifier, OnDequeue);
}
public WebSocketManager(
ILogger <WebSocketManager> logger,
IOptions <ApplicationSettings> appSettings,
IWebSocketConnectionManager connectionManager,
IMessageHandler messageHandler,
IBroadcastService broadcastService,
ITransactionPoolManager transactionPoolManager)
{
this.logger = logger;
this.appSettings = appSettings;
this.connectionManager = connectionManager;
this.messageHandler = messageHandler;
this.broadcastService = broadcastService;
this.transactionPoolManager = transactionPoolManager;
}
public ChatHandler(IWebSocketConnectionManager manager) : base(manager)
{
}
protected WebSocketHandler(IServiceProvider serviceProvider)
{
_connectionManager = serviceProvider.GetService <IWebSocketConnectionManager>();
_sender = serviceProvider.GetService <IWebSocketSender>();
}
public WebSocketMiddleware(RequestDelegate next, IServiceProvider serviceProvider)
{
_next = next;
_webSocketHandler = serviceProvider.GetService <T>();
_connectionManager = serviceProvider.GetService <IWebSocketConnectionManager>();
}
public WebSocketHandler(IWebSocketConnectionManager webSocketConnectionManager)
{
_webSocketConnectionManager = webSocketConnectionManager;
}
public OldSearchHandler(IWebSocketConnectionManager socketManager,
IConfiguration configuration) : base(socketManager)
{
_configuration = configuration;
}
public WebSocketChatManager(IWebSocketConnectionManager manager, IServiceProvider serviceProvider) : base(manager)
{
_chatService = serviceProvider.GetRequiredService <IChatService>();
}
protected WebSocketHandler(IServiceProvider services, ILoggerFactory loggerFactory)
{
_services = services;
webSocketManager = services.GetRequiredService <IWebSocketConnectionManager>();
_logger = loggerFactory.CreateLogger <WebSocketHandler>();
}
public WebSocketMiddleware(RequestDelegate next, ILogger <WebSocketMiddleware> logger, IWebSocketConnectionManager webSocketConnectionManager)
{
_next = next;
_logger = logger;
_webSocketConnectionManager = webSocketConnectionManager;
}
public WebSocketSender(IWebSocketConnectionManager connectionManager)
{
_connectionManager = connectionManager;
}
protected WebSocketChatManagerBase(IWebSocketConnectionManager manager)
{
_socketManagerUsers = manager;
}
