/// <summary>
/// Uses websockets with service provider
/// </summary>
public static IHorseServer UseWebSockets(this IHorseServer server, IServiceProvider provider)
{
ModelWsConnectionHandler bus = (ModelWsConnectionHandler)provider.GetService(typeof(IWebSocketServerBus));
bus.ServiceProvider = provider;
return(server);
}
/// <summary>
/// Uses HMQ Protocol and accepts TCP connections.
/// </summary>
public static IHorseServer UseHmq(this IHorseServer server, IProtocolConnectionHandler <HorseServerSocket, HorseMessage> handler)
{
HorseMqProtocol protocol = new HorseMqProtocol(server, handler);
server.UseProtocol(protocol);
return(server);
}
/// <summary>
/// Creates new server-side websocket client
/// </summary>
public WsServerSocket(IHorseServer server, IConnectionInfo info)
: base(info)
{
Client = info.Client;
Server = server;
Info = info;
}
/// <summary>
/// Called when a new message received from the client
/// </summary>
public Task Received(IHorseServer server, IConnectionInfo info, HorseServerSocket client, HorseMessage message)
{
MqClient mc = (MqClient)client;
//if client sends anonymous messages and server needs message id, generate new
if (string.IsNullOrEmpty(message.MessageId))
{
//anonymous messages can't be responsed, do not wait response
if (message.WaitResponse)
{
message.WaitResponse = false;
}
//if server want to use message id anyway, generate new.
if (_server.Options.UseMessageId)
{
message.SetMessageId(_server.MessageIdGenerator.Create());
}
}
//if message does not have a source information, source will be set to sender's unique id
if (string.IsNullOrEmpty(message.Source))
{
message.SetSource(mc.UniqueId);
}
//if client sending messages like someone another, kick him
else if (message.Source != mc.UniqueId)
{
client.Disconnect();
return(Task.CompletedTask);
}
return(RouteToHandler(mc, message, false));
}
/// <summary>
/// Triggered when handshake is completed and the connection is ready to communicate
/// </summary>
public async Task Ready(IHorseServer server, WsServerSocket client)
{
if (_readyHandler != null)
{
await _readyHandler(client);
}
}
public async Task <WsServerSocket> Connected(IHorseServer server, IConnectionInfo connection, ConnectionData data)
{
WsServerSocket socket = new WsServerSocket(server, connection);
Interlocked.Increment(ref _online);
return(await Task.FromResult(socket));
}
/// <summary>
/// Uses HMQ Protocol and accepts TCP connections.
/// </summary>
public static IHorseServer UseHmq(this IHorseServer server, HorseMessageHandler action)
{
HorseMethodHandler handler = new HorseMethodHandler(action);
HorseMqProtocol protocol = new HorseMqProtocol(server, handler);
server.UseProtocol(protocol);
return(server);
}
/// <summary>
/// Uses HTTP Protocol and accepts HTTP connections with Horse MVC Architecture
/// </summary>
public static IHorseServer UseMvc(this IHorseServer server, HorseMvc mvc, HttpOptions options)
{
MvcConnectionHandler handler = new MvcConnectionHandler(mvc, mvc.AppBuilder);
HorseHttpProtocol protocol = new HorseHttpProtocol(server, handler, options);
server.UseProtocol(protocol);
return(server);
}
/// <summary>
/// Uses WebSocket Protocol and accepts HTTP connections which comes with "Upgrade: websocket" header data
/// </summary>
public static IHorseServer UseWebSockets(this IHorseServer server,
WebSocketReadyHandler readyAction,
WebSocketMessageRecievedHandler messageAction)
{
return(UseWebSockets(server,
new MethodWebSocketConnectionHandler(null, readyAction, messageAction),
HttpOptions.CreateDefault()));
}
/// <summary>
///
/// </summary>
public Task Disconnected(IHorseServer server, HorseServerSocket client)
{
MqClient node = (MqClient)client;
_server.Clients.Remove(node);
return(Task.CompletedTask);
}
/// <summary>
/// Uses HTTP Protocol and accepts HTTP connections
/// </summary>
public static IHorseServer UseHttp(this IHorseServer server, HttpRequestHandler action, string optionsFilename)
{
HttpMethodHandler handler = new HttpMethodHandler(action);
HorseHttpProtocol protocol = new HorseHttpProtocol(server, handler, HttpOptions.Load(optionsFilename));
server.UseProtocol(protocol);
return(server);
}
/// <summary>
/// Uses HTTP Protocol and accepts HTTP connections
/// </summary>
public static IHorseServer UseHttp(this IHorseServer server, HttpRequestHandler action, HttpOptions options)
{
HttpMethodHandler handler = new HttpMethodHandler(action);
HorseHttpProtocol protocol = new HorseHttpProtocol(server, handler, options);
server.UseProtocol(protocol);
return(server);
}
/// <summary>
/// Creates new Horse HTTP protocol handler
/// </summary>
public HorseHttpProtocol(IHorseServer server, IProtocolConnectionHandler <SocketBase, HttpMessage> handler, HttpOptions options)
{
Options = options;
_server = server;
_handler = handler;
PredefinedHeaders.SERVER_TIME_CRLF = Encoding.UTF8.GetBytes("Date: " + DateTime.UtcNow.ToString("R") + "\r\n");
_timeTimer = new Timer(s => PredefinedHeaders.SERVER_TIME_CRLF = Encoding.UTF8.GetBytes("Date: " + DateTime.UtcNow.ToString("R") + "\r\n"), "", 1000, 1000);
}
/// <summary>
/// Creates new HMQ Server-side socket client
/// </summary>
public HorseServerSocket(IHorseServer server, IConnectionInfo info, IUniqueIdGenerator generator, bool useUniqueMessageId = true)
: base(info)
{
Client = info.Client;
Server = server;
Info = info;
_uniqueIdGenerator = generator;
UseUniqueMessageId = useUniqueMessageId;
}
/// <summary>
/// Called when connected client is connected in HMQ protocol
/// </summary>
public async Task Disconnected(IHorseServer server, HorseServerSocket client)
{
MqClient mqClient = (MqClient)client;
await _server.RemoveClient(mqClient);
foreach (IClientHandler handler in _server.ClientHandlers)
{
await handler.Disconnected(_server, mqClient);
}
}
/// <summary>
/// Triggered when a websocket client is connected.
/// </summary>
public async Task <WsServerSocket> Connected(IHorseServer server, IConnectionInfo connection, ConnectionData data)
{
WsServerSocket socket = new WsServerSocket(server, connection);
if (_connectedHandler != null)
{
await _connectedHandler(socket, data);
}
return(socket);
}
/// <summary>
/// Triggered when a non-websocket request available.
/// </summary>
private async Task RequestAsync(IHorseServer server, HttpRequest request, HttpResponse response)
{
IServiceScope scope = Mvc.ServiceProvider.CreateScope();
try
{
if (App.Descriptors.Count > 0)
{
MiddlewareRunner runner = new MiddlewareRunner(scope);
await runner.RunSequence(App, request, response);
if (runner.LastResult != null)
{
WriteResponse(response, runner.LastResult);
return;
}
}
await RequestMvc(server, request, response, scope);
}
catch (Exception ex)
{
if (Mvc.IsDevelopment)
{
IErrorHandler handler = new DevelopmentErrorHandler();
IActionResult result = await handler.Error(request, ex);
WriteResponse(request.Response, result);
}
else if (Mvc.ErrorHandler != null)
{
IActionResult result = await Mvc.ErrorHandler.Error(request, ex);
WriteResponse(request.Response, result);
}
else
{
WriteResponse(request.Response, StatusCodeResult.InternalServerError());
}
if (request.Response.StreamSuppressed && request.Response.ResponseStream != null)
{
GC.ReRegisterForFinalize(request.Response.ResponseStream);
}
}
finally
{
scope.Dispose();
}
}
/// <summary>
///
/// </summary>
public Task Received(IHorseServer server, IConnectionInfo info, HorseServerSocket client, HorseMessage message)
{
MqClient mc = (MqClient)client;
if (message.Type == MessageType.Server)
{
if (message.ContentType == KnownContentTypes.DecisionOverNode)
{
DecisionOverNode(message);
return(Task.CompletedTask);
}
}
return(_connectionHandler.RouteToHandler(mc, message, true));
}
/// <summary>
///
/// </summary>
public async Task <HorseServerSocket> Connected(IHorseServer server, IConnectionInfo connection, ConnectionData data)
{
string clientId;
bool found = data.Properties.TryGetValue(HorseHeaders.CLIENT_ID, out clientId);
if (!found || string.IsNullOrEmpty(clientId))
{
clientId = _server.Server.ClientIdGenerator.Create();
}
//if another client with same unique id is online, do not accept new client
MqClient foundClient = _server.Clients.Find(x => x.UniqueId == clientId);
if (foundClient != null)
{
await connection.Socket.SendAsync(HmqWriter.Create(MessageBuilder.Busy()));
return(null);
}
//creates new node client object
MqClient client = new MqClient(_server.Server, connection);
client.Data = data;
client.UniqueId = clientId.Trim();
client.Token = data.Properties.GetStringValue(HorseHeaders.CLIENT_TOKEN);
client.Name = data.Properties.GetStringValue(HorseHeaders.CLIENT_NAME);
client.Type = data.Properties.GetStringValue(HorseHeaders.CLIENT_TYPE);
if (_server.Authenticator != null)
{
bool accepted = await _server.Authenticator.Authenticate(_server, client);
if (!accepted)
{
return(null);
}
}
client.RemoteHost = client.Info.Client.Client.RemoteEndPoint.ToString()?.Split(':')[0];
_server.Clients.Add(client);
await client.SendAsync(MessageBuilder.Accepted(client.UniqueId));
return(client);
}
/// <summary>
/// Uses WebSocket Protocol and accepts HTTP connections which comes with "Upgrade: websocket" header data
/// </summary>
public static IHorseServer UseWebSockets(this IHorseServer server,
IProtocolConnectionHandler <WsServerSocket, WebSocketMessage> handler,
HttpOptions options)
{
//we need http protocol is added
IHorseProtocol http = server.FindProtocol("http");
if (http == null)
{
HorseHttpProtocol httpProtocol = new HorseHttpProtocol(server, new WebSocketHttpHandler(), options);
server.UseProtocol(httpProtocol);
}
HorseWebSocketProtocol protocol = new HorseWebSocketProtocol(server, handler);
server.UseProtocol(protocol);
return(server);
}
/// <summary>
/// Uses websocket protocol
/// </summary>
public static IHorseServer AddWebSockets(this IHorseServer server, HttpOptions options, Action <WebSocketServerBuilder> cfg)
{
//we need http protocol is added
IHorseProtocol http = server.FindProtocol("http");
if (http == null)
{
HorseHttpProtocol httpProtocol = new HorseHttpProtocol(server, new WebSocketHttpHandler(), options);
server.UseProtocol(httpProtocol);
}
WebSocketServerBuilder builder = new WebSocketServerBuilder();
cfg(builder);
ModelWsConnectionHandler handler = builder.Build();
HorseWebSocketProtocol protocol = new HorseWebSocketProtocol(server, handler);
server.UseProtocol(protocol);
return(server);
}
public async Task Disconnected(IHorseServer server, WsServerSocket client)
{
Interlocked.Decrement(ref _online);
await Task.CompletedTask;
}
public async Task Received(IHorseServer server, IConnectionInfo info, WsServerSocket client, WebSocketMessage message)
{
Console.WriteLine(message);
await Task.CompletedTask;
}
public async Task Ready(IHorseServer server, WsServerSocket client)
{
await Task.CompletedTask;
}
/// <summary>
/// Creates new HMQ Server-side socket client
/// </summary>
public HorseServerSocket(IHorseServer server, IConnectionInfo info)
: this(server, info, new DefaultUniqueIdGenerator())
{
}
/// <summary>
/// Creates new HMQ Protocol handler
/// </summary>
public HorseMqProtocol(IHorseServer server, IProtocolConnectionHandler <HorseServerSocket, HorseMessage> handler)
{
_server = server;
_handler = handler;
}
/// <summary>
/// Triggered when a HMQ client is connected.
/// </summary>
public async Task Disconnected(IHorseServer server, HorseServerSocket client)
{
await Task.CompletedTask;
}
/// <summary>
/// Triggered when a HMQ message received from client
/// </summary>
public async Task Received(IHorseServer server, IConnectionInfo info, HorseServerSocket client, HorseMessage message)
{
await _action(client, message);
}
/// <summary>
/// Triggered when a HMQ client is connected.
/// </summary>
public async Task <HorseServerSocket> Connected(IHorseServer server, IConnectionInfo connection, ConnectionData data)
{
return(await Task.FromResult(new HorseServerSocket(server, connection, _uniqueIdGenerator)));
}
/// <summary>
/// Triggered when a client sends a message to the server
/// </summary>
public async Task Received(IHorseServer server, IConnectionInfo info, SocketBase client, HttpMessage message)
{
message.Response.StatusCode = HttpStatusCode.NotFound;
await Task.CompletedTask;
}
