static void Main(string[] args)
{
XmlConfigurator.Configure();
try
{
ThreadPool.SetMinThreads(32, 1024);
var statePersister = new StatePersister();
AuthController authController = new AuthController(StatePersister.LoadUsers(), statePersister);
ElectroController electroController = new ElectroController(StatePersister.LoadElections(), StatePersister.LoadKeys(), authController, statePersister);
var staticHandler = new StaticHandler(GetPrefix(null), Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "web"));
staticHandler.Start();
var registerHandler = new RegisterHandler(authController, GetPrefix("register"));
registerHandler.Start();
var loginHandler = new LoginHandler(authController, GetPrefix("login"));
loginHandler.Start();
var logoutHandler = new LogoutHandler(authController, GetPrefix("logout"));
logoutHandler.Start();
var startElectionHandler = new StartElectionHandler(electroController, authController, GetPrefix("startElection"));
startElectionHandler.Start();
var listElectionsHandler = new ListElectionsHandler(electroController, authController, GetPrefix("listElections"));
listElectionsHandler.Start();
var findElectionHandler = new FindElectionHandler(electroController, authController, GetPrefix("findElection"));
findElectionHandler.Start();
var nominateHandler = new NominateHandler(electroController, authController, GetPrefix("nominate"));
nominateHandler.Start();
var voteHandler = new VoteHandler(electroController, authController, GetPrefix("vote"));
voteHandler.Start();
while (true)
{
Thread.Sleep(electionsSnapshotTimeoutMs);
try
{
log.Info("Saving elections snapshot");
StatePersister.SaveAllElections(electroController.DumpElections().Reverse());
log.Info("Elections snapshot saved");
}
catch (Exception e)
{
log.Error("Failed to save elections snapshot. Sleeping and retrying", e);
}
}
}
catch (Exception e)
{
log.Fatal(e);
}
}
protected override void SetUp()
{
_activationCtx = new TActivationContext();
DisposableHandler.Reset();
SomeHandler.Reset();
StaticHandler.Reset();
}
protected override void SetUp()
{
_factory = new TFactory();
DisposableHandler.Reset();
SomeHandler.Reset();
StaticHandler.Reset();
}
private static void Main()
{
AppDomain.CurrentDomain.UnhandledException += (sender, args) => Console.Error.WriteLine(args.ExceptionObject);
ThreadPool.SetMinThreads(HttpServerSettings.Concurrency, HttpServerSettings.Concurrency);
ThreadPool.SetMaxThreads(HttpServerSettings.Concurrency, HttpServerSettings.Concurrency);
var cancellation = new CancellationTokenSource();
var token = cancellation.Token;
var wsServer = new WsServer <User>(9999, ws => Users.Find(ws.HttpRequest.Cookies?.GetAuth()));
var authHandler = new AuthHandler(login => Task.Run(() => wsServer.BroadcastAsync(user => AuthHandler.FormatUserMessage(user, login), token), token));
var foodHandler = new FoodHandler((login, food) => Task.Run(() => wsServer.BroadcastAsync(user => FoodHandler.FormatUserMessage(user, login, food), token), token));
var staticHandler = new StaticHandler("static", ctx =>
{
var url = ctx.Request.Url;
if (url.HostNameType != UriHostNameType.Dns && url.HostNameType != UriHostNameType.IPv4 && url.HostNameType == UriHostNameType.IPv6)
{
throw new HttpException(400, "Invalid host");
}
ctx.Response.Headers["X-Frame-Options"] = "deny";
ctx.Response.Headers["X-XSS-Protection"] = "1; mode=block";
ctx.Response.Headers["Content-Security-Policy"] = $"default-src 'none'; script-src 'self'; style-src 'self'; img-src 'self'; font-src 'self'; connect-src 'self' ws://{url.Host}:9999;";
ctx.SetCsrfTokenCookie();
});
var httpServer = new HttpServer(8888)
.AddHandler("POST", "/signin", authHandler.SignInAsync)
.AddHandler("POST", "/signup", authHandler.SignUpAsync)
.AddHandler("POST", "/put", foodHandler.PutAsync)
.AddHandler("GET", "/get", foodHandler.GetAsync)
.AddHandler("GET", "/", staticHandler.GetAsync);
Console.CancelKeyPress += (sender, args) =>
{
Console.Error.WriteLine("Stopping...");
args.Cancel = true;
cancellation.Cancel();
};
Task.WaitAll(wsServer.AcceptLoopAsync(token), httpServer.AcceptLoopAsync(token));
}
public void Received(Packet p, int packetId)
{
try
{
if (p is PingPacket)
{
lightClient.startPingStopwatch();
lightClient.sendObject(new PongPacket(), false);
}
else if (p is PingReceive)
{
lightClient.endPingStopwatch();
lightClient.LoggerInstance.Debug("Ping: {0}", lightClient.getPingTime().Milliseconds + "ms");
}
else if (p is IllegalConnectionPacket)
{
lightClient.LoggerInstance.Info(((IllegalConnectionPacket)p).message);
lightClient.disconnect(ServerDisconnectEvent.DisconnectStatus.CONNECTION_LOST);
}
else if (p is InitialHandshakePacket)
{
// Handles object encryption key sharing
var packet = (InitialHandshakePacket)p;
var versionData = packet.getVersionData();
var versionRange = StaticHandler.getVersionRangeStatus(versionData);
if (versionRange == StaticHandler.VersionRange.MATCH_REQUIREMENTS)
{
lightClient.LoggerInstance.Info("Version range requirements match Server version.");
}
else
{
// Current version is smaller than the server's required minimum
if (versionRange == StaticHandler.VersionRange.WE_ARE_LOWER)
{
lightClient.LoggerInstance
.Info(
"The client version ({0}) does not meet server's minimum version ({1}) requirements. Expect incompatibility issues",
StaticHandler.VERSION_DATA.Version.ToString(), versionData.MinVersion.ToString());
}
// Current version is larger than server's minimum version
if (versionRange == StaticHandler.VersionRange.WE_ARE_HIGHER)
{
lightClient.LoggerInstance
.Info(
"The server version ({0}) does not meet client's minimum version ({1}) requirements. Expect incompatibility issues",
versionData.Version.ToString(), StaticHandler.VERSION_DATA.MinVersion.ToString());
}
}
var secretKey = EncryptionUtil.generateAESProvider();
// TODO: Remove this debug
string debug = "Using key " + string.Join(",", secretKey.Key) + " base64:" + Convert.ToBase64String(secretKey.Key);
StaticHandler.Core.Logger.Debug(debug);
lightClient.setSecretKey(secretKey);
var responsePacket = new KeyResponsePacket(secretKey, packet.getPublicKey());
lightClient.sendObject(responsePacket, false);
lightClient.callEvent(new ServerConnectHandshakeEvent(lightClient.Channel));
}
else if (p is RequestConnectInfoPacket)
{
var connectedPacket = lightClient.buildConnectedPacket();
lightClient.sendObject(connectedPacket).ConfigureAwait(false);
StaticHandler.Core.Logger.Info("Sent the connection Packet for request");
}
else if (p is SelfMessagePacket)
{
switch (((SelfMessagePacket)p).type)
{
case SelfMessagePacket.MessageType.TIMED_OUT_REGISTRATION:
lightClient.LoggerInstance.Info("Timed out on registering.");
lightClient.disconnect(ServerDisconnectEvent.DisconnectStatus.TIMEOUT);
break;
case SelfMessagePacket.MessageType.REGISTER_PACKET:
lightClient.registered = true;
lightClient.LoggerInstance.Info("Successfully connected to server");
lightClient.callEvent(new ServerConnectFinishEvent(lightClient.Channel));
break;
case SelfMessagePacket.MessageType.LOST_SERVER_CONNECTION:
lightClient.LoggerInstance.Info("Lost connection to server! Must have shutdown!");
lightClient.disconnect(ServerDisconnectEvent.DisconnectStatus.CONNECTION_LOST);
break;
}
}
foreach (var iPacketHandler in lightClient.getPacketHandlers())
{
Task.Run(() =>
{
try
{
iPacketHandler.handlePacket(p, packetId);
}
catch (Exception e)
{
throw ExceptionUtil.throwParsePacketException(e, p);
}
});
}
}
catch (ParsePacketException ignored)
{
throw;
}
catch (Exception e)
{
throw ExceptionUtil.throwParsePacketException(e, p);
}
}
