private void Io_OnClientMessage(MasterControlClient session, RouterMessage msg)
 {
     if (session.authenticated)
     {
         //Authenticated commands
         if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_CONFIG)
         {
             HandleRequestConfigCommand(session, msg);
         }
         else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_GETUSERCFG)
         {
             HandleGetUserConfigCmd(session, msg);
         }
         else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_INSTANCE_LOG)
         {
             HandleInstanceLogCommand(session, msg);
         }
         else
         {
             logger.Log("Io_OnClientMessage", $"Client {session.GetDebugName()} sent an unknown command.", DeltaLogLevel.Debug);
         }
     }
     else
     {
         //Unauthenticated commands
         if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_LOGIN)
         {
             HandleLoginCommand(session, msg);
         }
         else
         {
             logger.Log("Io_OnClientMessage", $"Client {session.GetDebugName()} sent unauthenticated command that was not LOGIN.", DeltaLogLevel.Debug);
         }
     }
 }
Exemplo n.º 2
0
 private void reipcHandler(RouterMessage obj)
 {
     lock (tslistlock)
     {
         tslist.Add(string.Format(" Task ID: {0} Progess: {1}", obj.TaskID, obj.Progress));
     }
 }
Exemplo n.º 3
0
        private void OnCmdRemoveInstance(RouterMessage msg)
        {
            //Decode arguments and create logger
            ManagerUpdateInstance args   = msg.DeserializeAs <ManagerUpdateInstance>();
            MasterCommandLogger   logger = new MasterCommandLogger(msg);

            //Find instance
            ManagerInstance instance = session.GetInstanceById(long.Parse(args.instance_id));

            if (instance == null)
            {
                logger.FinishFail("Could not find that instance on the server.");
                return;
            }

            //Run
            try
            {
                instance.DestoryInstance(session, logger);
            }
            catch (Exception ex)
            {
                logger.FinishFail($"Unexpected error: {ex.Message}{ex.StackTrace}");
            }
        }
Exemplo n.º 4
0
        public static void Run(
            [QueueTrigger("routermessage")] RouterMessage routerMessage,
            [Table("installation", "{InstallationId}", "{RepoName}")] Installation installation,
            [Table("installation")] ICollector <Installation> installations,
            [Queue("compressimagesmessage")] ICollector <CompressImagesMessage> compressImagesMessages,
            TraceWriter log)
        {
            if (installation == null)
            {
                installations.Add(new Installation(routerMessage.InstallationId, routerMessage.RepoName)
                {
                    AccessTokensUrl = routerMessage.AccessTokensUrl,
                    CloneUrl        = routerMessage.CloneUrl,
                    Owner           = routerMessage.Owner,
                });
            }

            /*
             *  TODO: add logic for routing
             *        https://github.com/dabutvin/ImgBot/issues/98
             */

            log.Info($"Routing {routerMessage.CloneUrl} to {nameof(compressImagesMessages)}.");

            compressImagesMessages.Add(new CompressImagesMessage
            {
                AccessTokensUrl = routerMessage.AccessTokensUrl,
                CloneUrl        = routerMessage.CloneUrl,
                InstallationId  = routerMessage.InstallationId,
                Owner           = routerMessage.Owner,
                RepoName        = routerMessage.RepoName,
            });
        }
Exemplo n.º 5
0
        private void OnCmdAssignSite(RouterMessage msg)
        {
            //Decode arguments and create logger
            ManagerAssignSite   args   = msg.DeserializeAs <ManagerAssignSite>();
            MasterCommandLogger logger = new MasterCommandLogger(msg);

            //Update if it was supposed to be null
            if (args.site_id == "")
            {
                args.site_id = null;
            }

            //Find instance
            ManagerInstance instance = session.GetInstanceById(long.Parse(args.instance_id));

            if (instance == null)
            {
                logger.FinishFail("Could not find that instance on the server.");
                return;
            }

            //Run
            try
            {
                //Update
                instance.site_id = args.site_id;
                session.Save();
                session.RefreshSites();
            }
            catch (Exception ex)
            {
                logger.FinishFail($"Unexpected error: {ex.Message}{ex.StackTrace}");
            }
        }
Exemplo n.º 6
0
        private void OnCmdRebootInstance(RouterMessage msg)
        {
            //Decode arguments and create logger
            ManagerRebootInstance args   = msg.DeserializeAs <ManagerRebootInstance>();
            MasterCommandLogger   logger = new MasterCommandLogger(msg);

            //Find instance
            ManagerInstance instance = session.GetInstanceById(long.Parse(args.instance_id));

            if (instance == null)
            {
                logger.FinishFail("Could not find that instance on the server.");
                return;
            }

            //Run
            try
            {
                //Shut down instance
                logger.Log("REBOOT", "Shutting down instance...");
                bool graceful = instance.StopInstance();
                if (!graceful)
                {
                    logger.Log("REBOOT", "Instance was shut down forcefully!");
                }

                //Start
                instance.StartInstance(session);
            }
            catch (Exception ex)
            {
                logger.FinishFail($"Unexpected error: {ex.Message}{ex.StackTrace}");
            }
        }
Exemplo n.º 7
0
        public static void Run(
            [QueueTrigger("routermessage")] RouterMessage routerMessage,
            [Table("installation", "{InstallationId}", "{RepoName}")] Installation installation,
            [Table("installation")] ICollector <Installation> installations,
            [Queue("compressimagesmessage")] ICollector <CompressImagesMessage> compressImagesMessages,
            ILogger logger)
        {
            if (installation == null)
            {
                installations.Add(new Installation(routerMessage.InstallationId, routerMessage.RepoName)
                {
                    CloneUrl = routerMessage.CloneUrl,
                    Owner    = routerMessage.Owner,
                });
            }

            /*
             *  TODO: add logic for routing
             *        https://github.com/dabutvin/ImgBot/issues/98
             */

            compressImagesMessages.Add(new CompressImagesMessage
            {
                CloneUrl       = routerMessage.CloneUrl,
                InstallationId = routerMessage.InstallationId,
                Owner          = routerMessage.Owner,
                RepoName       = routerMessage.RepoName,
            });

            logger.LogInformation("RouterFunction: Added CompressImagesMessage for {Owner}/{RepoName}", routerMessage.Owner, routerMessage.RepoName);
        }
Exemplo n.º 8
0
        internal static async void SendIPCUpdate(RouterMessage ipc)
        {
            if (connection.State == HubConnectionState.Disconnected)
            {
                return;
            }

            await connection.SendAsync("SendRouterEngineStatusToClients", UrlStrings.ReIPCGroupName, ipc, source.Token);
        }
Exemplo n.º 9
0
        private void HandleRequestLogCommand(RouterSession session, RouterMessage msg)
        {
            //Add the instance ID to the beginning of the payload, then send to the master
            byte[] data = new byte[msg.payload.Length + 8];

            //Set instance ID and copy
            BitConverter.GetBytes(session.linkedInstance.id).CopyTo(data, 0);
            msg.payload.CopyTo(data, 8);

            //Send to master
            this.session.masterConnection.SendMessage(MasterConnectionOpcodes.OPCODE_MASTER_INSTANCE_LOG, data);
        }
Exemplo n.º 10
0
        private void HandleRequestConfigCommand(RouterSession session, RouterMessage msg)
        {
            //Create LoginServerInfo to return
            LoginServerInfo response = new LoginServerInfo
            {
                success     = true,
                instance_id = session.linkedInstance.id.ToString(),
                user_ports  = session.linkedInstance.ports,
                config      = this.session.remoteConfig
            };

            //Respond
            msg.RespondJson(response, true);
        }
 private void HandleRequestConfigCommand(MasterControlClient session, RouterMessage msg)
 {
     msg.RespondJson(new LoginServerConfig
     {
         enviornment                = Program.cfg.general.enviornment,
         mongodb_connection         = Program.cfg.general.mongodb_connection,
         steam_api_key              = Program.cfg.general.steam_api_token,
         steam_cache_expire_minutes = Program.cfg.general.steam_cache_expire_minutes,
         firebase_uc_bucket         = Program.cfg.general.firebase_uc_bucket,
         log             = Program.cfg.general.log,
         steam_token_key = Program.cfg.secrets.steam_token_key,
         hosts           = Program.cfg.hosts
     }, true);
 }
Exemplo n.º 12
0
        private void OnCmdAddPackage(RouterMessage msg)
        {
            //Decode arguments and create logger
            ManagerAddPackage   args   = msg.DeserializeAs <ManagerAddPackage>();
            MasterCommandLogger logger = new MasterCommandLogger(msg);

            //Run
            try
            {
                session.AddPackage(args, logger);
            } catch (Exception ex)
            {
                logger.FinishFail($"Unexpected error: {ex.Message}{ex.StackTrace}");
            }
        }
Exemplo n.º 13
0
        private void HandleRequestRPCCommand(RouterSession session, RouterMessage msg)
        {
            //We're going to attempt to dispatch this to all connected RPC servers locally.
            //In the future, we'll likely send this to the master and let it dispatch it to all machines and regions, but not yet
            //This will make only RPC sessions connected to this machine work, even if they're in a different process

            //Find all connected RPC clients
            var clients = this.session.GetConnectedInstancesByType(DeltaCoreNetServerType.API_RPC);

            //Dispatch
            foreach (var c in clients)
            {
                c.linkedSession.SendMessage(RouterConnection.OPCODE_SYS_RPC, msg.payload);
            }
        }
Exemplo n.º 14
0
 private void OnCmdGetStatus(RouterMessage msg)
 {
     //Produce and respond with thatus
     msg.RespondJson(new ManagerStatusMessage
     {
         host_name         = System.Environment.MachineName,
         host_os           = System.Environment.OSVersion.Platform.ToString().ToUpper(),
         current_time      = DateTime.UtcNow,
         start_time        = Program.startTime,
         version_app_major = Program.APP_VERSION_MAJOR,
         version_app_minor = Program.APP_VERSION_MINOR,
         version_lib_major = DeltaConnection.LIB_VERSION_MAJOR,
         version_lib_minor = DeltaConnection.LIB_VERSION_MINOR
     }, true);
 }
Exemplo n.º 15
0
        public static void Run(
            [QueueTrigger("routermessage")] RouterMessage routerMessage,
            [Table("installation", "{InstallationId}", "{RepoName}")] Installation installation,
            [Table("installation")] ICollector <Installation> installations,
            [Queue("compressimagesmessage")] ICollector <CompressImagesMessage> compressImagesMessages,
            ILogger logger)
        {
            var compress = routerMessage.GetType().GetProperty("Compress") == null || routerMessage.Compress == true;

            if (installation == null)
            {
                installations.Add(new Installation(routerMessage.InstallationId, routerMessage.RepoName)
                {
                    CloneUrl    = routerMessage.CloneUrl,
                    Owner       = routerMessage.Owner,
                    LastChecked = DateTime.UtcNow,
                    IsOptimized = compress,
                    IsPrivate   = routerMessage.IsPrivate,
                });
            }
            else
            {
                installation.LastChecked = DateTime.UtcNow;
            }

            if (routerMessage.GetType().GetProperty("Update") != null && routerMessage.Update == true)
            {
                installation.IsOptimized = compress;
            }

            /*
             *  TODO: add logic for routing
             *        https://github.com/dabutvin/ImgBot/issues/98
             */
            if (compress)
            {
                compressImagesMessages.Add(new CompressImagesMessage
                {
                    CloneUrl       = routerMessage.CloneUrl,
                    InstallationId = routerMessage.InstallationId,
                    Owner          = routerMessage.Owner,
                    RepoName       = routerMessage.RepoName,
                });

                logger.LogInformation("RouterFunction: Added CompressImagesMessage for {Owner}/{RepoName}", routerMessage.Owner, routerMessage.RepoName);
            }
        }
Exemplo n.º 16
0
        private static void OnIncomingRPCCommand(RouterMessage msg)
        {
            //Decode header
            byte cmdOpcode = msg.payload[0];
            byte cmdFlags  = msg.payload[1];

            //Switch on message opcode
            switch (cmdOpcode)
            {
            case RPCMessageTool.TYPECODE_MESSAGE: OnIncomingRPCCommand_RPCMessage(msg.payload); break;

            case RPCMessageTool.TYPECODE_GROUP_RESET: OnIncomingRPCCommand_RefreshGroups(msg.payload); break;

            case RPCMessageTool.TYPECODE_PRIVILEGED_MESSAGE_SERVER: OnIncomingRPCCommand_PrivledgedMessage(msg.payload); break;

            default: throw new Exception("Unknwon command opcode " + cmdOpcode + "!");
            }
        }
        private void HandleLoginCommand(MasterControlClient session, RouterMessage msg)
        {
            //Get details
            int loginId = BitConverter.ToInt16(msg.payload, 0);

            byte[] loginKey = new byte[16];
            Array.Copy(msg.payload, 2, loginKey, 0, 16);

            //Search for a server
            DeltaManagerServer server = null;

            lock (Program.servers)
            {
                foreach (var s in Program.servers)
                {
                    if (s.id == loginId)
                    {
                        //Authenticate key
                        if (BinaryTool.CompareBytes(s.key, loginKey))
                        {
                            server = s;
                        }
                    }
                }
            }

            //Check if it was successful
            if (server != null)
            {
                //Set
                server.SetTransport(session);
                session.authenticated = true;

                //Log
                logger.Log("HandleLoginCommand", $"Client {session.GetDebugName()} successfully logged in as server ID {server.id}.", DeltaLogLevel.Low);
            }
            else
            {
                //Failed
                logger.Log("HandleLoginCommand", $"Client {session.GetDebugName()} attempted login, but failed.", DeltaLogLevel.Low);
            }
        }
Exemplo n.º 18
0
        private async Task OnCmdGetInstanceStatus(RouterMessage msg)
        {
            //Create buffer for output. It consists of this format, each a byte unless otherwise stated: [status, reserved, appVersionMajor, appVersionMinor, libVersionMajor, libVersionMinor, (ushort)time]
            byte[] buffer = new byte[8];
            buffer[0] = (byte)InstanceStatusResult.NOT_CONNECTED;

            //Find instance
            ManagerInstance instance = session.GetInstanceById(BitConverter.ToInt64(msg.payload, 0));

            if (instance != null && instance.linkedSession != null)
            {
                try
                {
                    //Send ping
                    DateTime start      = DateTime.UtcNow;
                    var      pingResult = await instance.linkedSession.SendPing(4000);

                    if (pingResult != null)
                    {
                        //Success
                        buffer[0] = (byte)InstanceStatusResult.ONLINE;
                        buffer[2] = pingResult.Value.lib_version_major;
                        buffer[3] = pingResult.Value.lib_version_minor;
                        buffer[4] = pingResult.Value.app_version_major;
                        buffer[5] = pingResult.Value.app_version_minor;
                        BitConverter.GetBytes((ushort)Math.Min(ushort.MaxValue, (DateTime.UtcNow - start).TotalMilliseconds)).CopyTo(buffer, 6);
                    }
                    else
                    {
                        //Timed out
                        buffer[0] = (byte)InstanceStatusResult.PING_TIMED_OUT;
                    }
                } catch
                {
                    buffer[0] = (byte)InstanceStatusResult.PING_FAILED;
                }
            }

            //Send
            msg.Respond(buffer, true);
        }
Exemplo n.º 19
0
 private void Io_OnClientMessage(RouterSession session, RouterMessage msg)
 {
     if (session.authenticated)
     {
         //Authenticated commands
         if (msg.opcode == RouterConnection.OPCODE_SYS_GETCFG)
         {
             HandleRequestConfigCommand(session, msg);
         }
         else if (msg.opcode == RouterConnection.OPCODE_SYS_USERCFG)
         {
             HandleRequestUserConfigCommand(session, msg);
         }
         else if (msg.opcode == RouterConnection.OPCODE_SYS_RPC)
         {
             HandleRequestRPCCommand(session, msg);
         }
         else if (msg.opcode == RouterConnection.OPCODE_SYS_LOG)
         {
             HandleRequestLogCommand(session, msg);
         }
         else
         {
             logger.Log("Io_OnClientMessage", $"Client {session.GetDebugName()} sent an unknown command ({msg.opcode}).", DeltaLogLevel.Debug);
         }
     }
     else
     {
         //Unauthenticated commands
         if (msg.opcode == RouterConnection.OPCODE_SYS_LOGIN)
         {
             HandleLoginCommand(session, msg);
         }
         else
         {
             logger.Log("Io_OnClientMessage", $"Client {session.GetDebugName()} sent unauthenticated command that was not LOGIN ({msg.opcode}).", DeltaLogLevel.Debug);
         }
     }
 }
        private void HandleGetUserConfigCmd(MasterControlClient session, RouterMessage msg)
        {
            //Read strings
            int    nameLen      = BitConverter.ToInt32(msg.payload, 0);
            string name         = Encoding.UTF8.GetString(msg.payload, 4, nameLen);
            int    defaultLen   = BitConverter.ToInt32(msg.payload, nameLen + 4);
            string defaultValue = Encoding.UTF8.GetString(msg.payload, 4 + nameLen + 4, defaultLen);

            //Get file path
            string path = Program.cfg.general.sub_configs_directory + name;

            //Create default if needed
            if (!File.Exists(path))
            {
                File.WriteAllText(path, defaultValue);
            }

            //Load and return
            string content = File.ReadAllText(path);

            msg.Respond(Encoding.UTF8.GetBytes(content), true);
        }
Exemplo n.º 21
0
        private void HandleLoginCommand(RouterSession session, RouterMessage msg)
        {
            //Get details
            DeltaCoreNetServerType type = (DeltaCoreNetServerType)BitConverter.ToInt32(msg.payload, 0);
            long loginKey = BitConverter.ToInt64(msg.payload, 4);

            //Find the linked instance
            ManagerInstance instance = null;

            lock (this.session.instances)
            {
                foreach (var s in this.session.instances)
                {
                    if (loginKey == s.id)
                    {
                        instance = s;
                    }
                }
            }

            //If this failed, abort
            if (instance == null)
            {
                logger.Log("HandleLoginCommand", $"Logging in client {session.GetDebugName()} with key {loginKey} FAILED. Dropping client...", DeltaLogLevel.Medium);
                io.DropClient(session);
                return;
            }

            //Set properties on session
            session.authenticatedType = type;
            instance.linkedSession    = session;
            session.linkedInstance    = instance;
            session.authenticated     = true;

            //Log
            logger.Log("HandleLoginCommand", $"Logged in client {session.GetDebugName()} as {type.ToString().ToUpper()} as {instance.id} (v {instance.version_id}).", DeltaLogLevel.Low);
        }
Exemplo n.º 22
0
        private void Io_OnRouterReceiveMessage(RouterMessage msg)
        {
            //Dispatch
            bool handled = false;

            if (boundReceiveEvents.ContainsKey(msg.opcode))
            {
                for (int i = 0; i < boundReceiveEvents[msg.opcode].Count; i++)
                {
                    try
                    {
                        boundReceiveEvents[msg.opcode][i](msg);
                    } catch (Exception ex)
                    {
                        conn.Log("Io_OnRouterReceiveMessage", $"Error handling incoming message from bound event: {ex.Message}{ex.StackTrace}", DeltaLogLevel.High);
                    }
                }
                handled = boundReceiveEvents[msg.opcode].Count > 0;
            }
            if (!handled)
            {
                conn.Log("Io_OnRouterReceiveMessage", $"Got unknown opcode {msg.opcode}, and nothing was able to handle it!", DeltaLogLevel.Low);
            }
        }
Exemplo n.º 23
0
        private void OnCmdDeleteVersion(RouterMessage msg)
        {
            //Decode arguments and create logger
            ManagerDeleteVersion args   = msg.DeserializeAs <ManagerDeleteVersion>();
            MasterCommandLogger  logger = new MasterCommandLogger(msg);

            //Find package
            if (!session.versions.ContainsKey(args.version_id))
            {
                logger.FinishFail("Could not find that version on the server.");
                return;
            }
            ManagerVersion version = session.versions[args.version_id];

            //Run
            try
            {
                version.DeleteVersion(session, logger);
            }
            catch (Exception ex)
            {
                logger.FinishFail($"Unexpected error: {ex.Message}{ex.StackTrace}");
            }
        }
Exemplo n.º 24
0
        private void OnCmdAddInstance(RouterMessage msg)
        {
            //Decode arguments and create logger
            ManagerAddInstance  args   = msg.DeserializeAs <ManagerAddInstance>();
            MasterCommandLogger logger = new MasterCommandLogger(msg);

            //Find package
            if (!session.packages.ContainsKey(args.package_name))
            {
                logger.FinishFail("Could not find that package on the server.");
                return;
            }
            ManagerPackage package = session.packages[args.package_name];

            //Run
            try
            {
                session.CreateNewInstance(package, logger, args.count, true);
            }
            catch (Exception ex)
            {
                logger.FinishFail($"Unexpected error: {ex.Message}{ex.StackTrace}");
            }
        }
Exemplo n.º 25
0
 private void MasterConnection_OnRouterReceiveMessage(RouterMessage msg)
 {
     if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_STATUS)
     {
         OnCmdGetStatus(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_ADDPACKAGE)
     {
         OnCmdAddPackage(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_ADDVERSION)
     {
         OnCmdAddVersion(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_ADDINSTANCE)
     {
         OnCmdAddInstance(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_LISTPACKAGES)
     {
         msg.RespondJson(MiscTools.DictToList(session.packages), true);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_LISTVERSIONS)
     {
         msg.RespondJson(MiscTools.DictToList(session.versions), true);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_LISTINSTANCES)
     {
         msg.RespondJson(session.instances, true);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_UPDATEINSTANCE)
     {
         OnCmdUpdateInstance(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_DESTROYINSTANCE)
     {
         OnCmdRemoveInstance(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_DELETEVERSION)
     {
         OnCmdDeleteVersion(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_ADDSITE)
     {
         OnCmdAddSite(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_LISTSITES)
     {
         msg.RespondJson(MiscTools.DictToList(session.sites), true);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_M_ASSIGNSITE)
     {
         OnCmdAssignSite(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_REBOOT_INSTANCE)
     {
         OnCmdRebootInstance(msg);
     }
     else if (msg.opcode == MasterConnectionOpcodes.OPCODE_MASTER_PING_INSTANCE)
     {
         OnCmdGetInstanceStatus(msg).GetAwaiter().GetResult();
     }
     else
     {
         Log("MasterConnection_OnRouterReceiveMessage", $"Got message with unknown opcode {msg.opcode}.", DeltaLogLevel.Medium);
     }
 }
 public override void RouterReceiveMessage(RouterMessage msg)
 {
     server.OnIncomingClientMessage(this, msg);
 }
 public MasterCommandLogger(RouterMessage message)
 {
     this.message = message;
 }
Exemplo n.º 28
0
 public async Task SendRouterEngineStatusToClients(string grpname, RouterMessage msg)
 {
     await Clients.Group(grpname).SendRouterIPC(msg);
 }
Exemplo n.º 29
0
 public override void RouterReceiveMessage(RouterMessage msg)
 {
     handlingMessages.Enqueue(msg);
 }
 private void HandleInstanceLogCommand(MasterControlClient session, RouterMessage msg)
 {
     session.DispatchInstanceLogEvent(msg.payload);
 }