public Service1(ILogger <Service1> logger, IMessageHandlerService service)
{
_logger = logger;
_service = service;
InitializeComponent();
}
protected BaseEntityActor(ILog logger, IMessageHandlerService <EntityActorMessage, EntityActorMessageContext> messageHandlerService)
{
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
MessageHandlerService = messageHandlerService ?? throw new ArgumentNullException(nameof(messageHandlerService));
ReceiveAsync <EntityActorMessage>(OnReceiveMessageAsync);
//This allows us to handle dispose attachment messages.
Receive <AttachDisposableActorMessage>(message => AttachDisposable(message.Disposable));
}
// The socket is closed when this exceptions are thrown
private async Task HandleErrorExceptions(WebSocket socket, IMessageHandlerService handlerService, Exception exc)
{
if (exc is PlayerNotFoundException || exc is RoomNotFoundException)
{
Console.WriteLine($"{exc.GetType()}: {exc.Message}");
await handlerService.SendMessageAsync(socket, BuildResponse( exc.GetType().Name, exc.Message));
}
else
{
Console.WriteLine(exc);
}
}
protected override void OnStart(string[] args)
{
Trace.CorrelationManager.ActivityId = typeof(Program).GUID;
Trace.TraceInformation("Starting host context on Console Presentation System at {0}", DateTime.Now);
// Detect platform
if (System.Environment.OSVersion.Platform != PlatformID.Win32NT)
{
Trace.TraceWarning("Not running on WindowsNT, some features may not function correctly");
}
// Do this because loading stuff is tricky ;)
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(Program.CurrentDomain_AssemblyResolve);
try
{
// Initialize
HostContext context = new HostContext();
Trace.TraceInformation("Getting default message handler service.");
m_messageHandlerService = context.GetService(typeof(IMessageHandlerService)) as IMessageHandlerService;
if (m_messageHandlerService == null)
{
Trace.TraceError("PANIC! Can't find a default message handler service: {0}", "No IMessageHandlerService classes are registered with this host context");
}
else
{
Trace.TraceInformation("Starting message handler service {0}", m_messageHandlerService);
if (m_messageHandlerService.Start())
{
Trace.TraceInformation("Service Started Successfully");
ExitCode = 0;
}
else
{
Trace.TraceError("No message handler service started. Terminating program");
ExitCode = 1911;
Stop();
}
}
}
catch (Exception e)
{
Trace.TraceError("Fatal exception occurred: {0}", e.ToString());
ExitCode = 1064;
Stop();
}
finally
{
}
}
// The socket should keep running when this exceptions are thrown
private async Task HandleWarningExceptions(WebSocket socket, IMessageHandlerService handler, Exception exc)
{
if (exc is LobbyWarningException)
{
Console.WriteLine($"{exc.GetType()}: {exc.Message}");
await handler.SendMessageAsync(socket, BuildResponse( exc.GetType().Name, exc.Message));
}
else if (exc is Newtonsoft.Json.JsonReaderException ||
exc is Newtonsoft.Json.JsonSerializationException)
{
Console.WriteLine($"{exc.GetType()}: {exc.Message}");
await handler.SendMessageAsync(socket, BuildResponse( exc.GetType().Name,
"Event Message is not a valid JSON with the correct structure: " +
"{ eventType: 'event-type', data: 'event-data'"));
}
else
{
Console.WriteLine($"{exc.GetType()}: {exc.Message}");
}
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="configService"></param>
public WeixinController(IMessageHandlerService messageHandlerService)
{
_messageHandlerService = messageHandlerService;
}
public StockChannelHub(IMessageHandlerService messageHandlerService)
{
_messageHandlerService = messageHandlerService ?? throw new ArgumentNullException(nameof(messageHandlerService));
}
// # COMMUNICATION LOGIC for GAME CLIENT Socket Connections ...
public async Task Invoke(HttpContext context, IMessageHandlerService handlerService, IHttpClientFactory httpFactory)
{
if (!context.WebSockets.IsWebSocketRequest)
{
context.Response.StatusCode = StatusCodes.Status400BadRequest;
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(
BuildResponse("" + context.Response.StatusCode, "Not a WebSocket HTTP Request"));
return;
}
// The request must have an auth token and the player should be hosting or joining a room
var routeValues = context.GetRouteData().Values;
string auth_cookie = context.Request.Cookies["auth-token"];
if (!(routeValues["host_join"].Equals("host") || routeValues["host_join"].Equals("join") ||
routeValues["host_join"].Equals("findmatch")) || string.IsNullOrWhiteSpace(auth_cookie))
{
context.Response.StatusCode = StatusCodes.Status400BadRequest;
return;
}
WebSocket socket = null;
string conn_playerID = null, conn_roomID = null;
try // # HANDLE ERROR EXCEPTIONS, socket is closed
{
conn_playerID = await HandlePlayerAuthentication(httpFactory, auth_cookie);
if (string.IsNullOrWhiteSpace(conn_playerID))
{
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
return;
}
// Everything is set, accept the socket connection and execute de handshake
socket = await context.WebSockets.AcceptWebSocketAsync();
string check_ingame = handlerService.CheckIfPlayerInGame(conn_playerID);
if (check_ingame != null)
{
await handlerService.SendMessageAsync(socket, BuildResponse("PlayerInGame", check_ingame));
return; // socket is closed on the 'finally' block
}
if (context.Request.Path.ToString().Contains("host"))
{
conn_roomID = await handlerService.OnConnectedHostLobby(
new RoomPlayer(conn_playerID, socket), false);
}
else if (context.Request.Path.ToString().Contains("findmatch"))
{
conn_roomID = await handlerService.OnConnectedHostLobby(
new RoomPlayer(conn_playerID, socket), true);
}
else if (context.Request.Path.ToString().Contains("join"))
{
conn_roomID = context.Request.Query["room-id"].ToString();
await handlerService.OnConnectedJoinLobby(conn_roomID,
new RoomPlayer(conn_playerID, socket));
}
await HandleReceivedMessage(socket, async(result, data) => {
try // # HANDLE WARNING EXCEPTIONS, socket keeps running
{
switch (result.MessageType)
{
case WebSocketMessageType.Text:
await handlerService.HandleLobbyAsync(conn_roomID, conn_playerID, socket, data);
break;
default: // WebSocketMessageType.Close
await handlerService.CancelMatchmaking(conn_roomID);
await handlerService.OnPlayerLeft(conn_roomID, conn_playerID);
break;
}
}
catch (Exception exc)
{
await HandleWarningExceptions(socket, handlerService, exc);
}
});
}
catch (Exception exc) // catch socket and thread exceptions so the service doesn't break
{
await HandleErrorExceptions(socket, handlerService, exc);
}
finally // Make sure socket is closed when connection terminates
{
await CloseSocketConn(socket);
}
}
// # COMMUNICATION LOGIC for UNITY GAME Socket Connections ...
public async Task Invoke(HttpContext context, IMessageHandlerService handlerService, IHttpClientFactory httpFactory)
{
if (!context.WebSockets.IsWebSocketRequest)
{
context.Response.StatusCode = StatusCodes.Status400BadRequest;
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(
BuildResponse("" + context.Response.StatusCode, "Not a WebSocket HTTP Request"));
return;
}
string conn_playerID = null,
conn_roomID = context.Request.Query["room-id"].ToString(),
auth_token = context.Request.Query["player-auth"].ToString();
WebSocket socket = null;
try // # HANDLE ERROR EXCEPTIONS, socket is closed
{
conn_playerID = await GetPlayerInformation(httpFactory, auth_token);
if (string.IsNullOrWhiteSpace(conn_playerID))
{
context.Response.StatusCode = StatusCodes.Status401Unauthorized;
return;
}
// Everything is set, accept the socket connection and execute de handshake
socket = await context.WebSockets.AcceptWebSocketAsync();
if (handlerService.CheckIfPlayerInStartedGame(conn_roomID, conn_playerID))
{
await handlerService.SendMessageAsync(socket, BuildResponse("PlayerGameStarted",
"Game already started. Player should exit first before updating connection."));
return; // socket is closed on the 'finally' block
}
await handlerService.UpdateConnection(conn_roomID, conn_playerID, socket);
await HandleReceivedMessage(socket, async(result, data) => {
try // # HANDLE WARNING EXCEPTIONS, socket keeps running
{
switch (result.MessageType)
{
case WebSocketMessageType.Text:
// DO SOMETHING when received message is text
await handlerService.HandleGameAsync(conn_roomID, conn_playerID, socket, data);
break;
case WebSocketMessageType.Binary:
// DO SOMETHING when received message is binary
break;
default: // WebSocketMessageType.Close
// DO SOMETHING when connection closes
await handlerService.OnPlayerLeft(conn_roomID, conn_playerID);
break;
}
}
catch (Exception exc)
{
await HandleWarningExceptions(socket, handlerService, exc);
}
});
}
catch (Exception exc) // catch socket and thread exceptions so the service doesn't break
{
await HandleErrorExceptions(socket, handlerService, exc);
}
finally // Make sure socket is closed when connection terminates
{
await CloseSocketConn(socket);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IndexController"/> class.
/// </summary>
/// <param name="messageHandlerService"></param>
/// <param name="logger"></param>
public IndexController(IMessageHandlerService messageHandlerService, ILogger <IndexController> logger)
{
_messageHandlerService = messageHandlerService;
_logger = logger;
}
static void Console()
{
ShowCopyright();
Trace.CorrelationManager.ActivityId = typeof(Program).GUID;
Trace.TraceInformation("Starting host context on Console Presentation System at {0}", DateTime.Now);
// Detect platform
if (System.Environment.OSVersion.Platform != PlatformID.Win32NT)
{
Trace.TraceWarning("Not running on WindowsNT, some features may not function correctly");
}
// Do this because loading stuff is tricky ;)
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
console.Write("Starting MARC-HI Service Framework...");
// Start the message handler service
IMessageHandlerService messageHandlerService = null;
try
{
// Initialize
HostContext context = new HostContext();
Trace.TraceInformation("Getting default message handler service.");
messageHandlerService = context.GetService(typeof(IMessageHandlerService)) as IMessageHandlerService;
console.WriteLine("ok");
console.Write("Starting default MessageHandler...");
if (messageHandlerService == null)
{
Trace.TraceError("PANIC! Can't find a default message handler service: {0}", "No IMessageHandlerService classes are registered with this host context");
}
else
{
Trace.TraceInformation("Starting message handler service {0}", messageHandlerService);
if (messageHandlerService.Start())
{
console.WriteLine("ok\r\nService host console started succesfully, press any key to terminate...");
console.ReadKey();
}
else
{
console.WriteLine("fail");
Trace.TraceError("No message handler service started. Terminating program");
}
}
}
catch (Exception e)
{
Trace.TraceError("Fatal exception occurred: {0}", e.ToString());
}
finally
{
if (messageHandlerService != null)
{
console.Write("Stopping listeners...");
Trace.TraceInformation("Stopping message handler service {0}", messageHandlerService);
messageHandlerService.Stop();
console.WriteLine("ok");
}
}
console.WriteLine("Service Terminated, press any key to close...");
console.ReadKey();
}
public MessageReceiverService(ILogger <MessageReceiverService> logger, IMessageHandlerService service)
{
_logger = logger;
_service = service;
}
