Beispiel #1
0
        public async Task DeleteAllUnsedMapsFromAllServers()
        {
            var servers = await _sshServerSerivce.FindAll();

            foreach (var server in servers)
            {
                foreach (var signleServer in server.PavlovServers)
                {
                    try
                    {
                        RconStatic.DeleteUnusedMaps(signleServer,
                                                    (await _serverSelectedMapService.FindAllFrom(signleServer)).ToList());
                    }
                    catch (Exception e)
                    {
                        DataBaseLogger.LogToDatabaseAndResultPlusNotify(e.Message, LogEventLevel.Verbose, _notifyService);
                        // ingore for now
                    }
                }
            }
        }
        public virtual async Task <PavlovServer> ValidatePavlovServer(PavlovServer pavlovServer, bool root)
        {
            DataBaseLogger.LogToDatabaseAndResultPlusNotify("start validate", LogEventLevel.Verbose, _notifyService);
            var hasToStop = false;

            await IsValidOnly(pavlovServer);


            DataBaseLogger.LogToDatabaseAndResultPlusNotify("try to start service", LogEventLevel.Verbose,
                                                            _notifyService);
            //try if the service realy exist
            try
            {
                pavlovServer = await GetServerServiceState(pavlovServer);

                if (pavlovServer.ServerServiceState != ServerServiceState.active)
                {
                    DataBaseLogger.LogToDatabaseAndResultPlusNotify("has to start", LogEventLevel.Verbose,
                                                                    _notifyService);
                    hasToStop = true;
                    //the problem is here for the validating part if it has to start the service first it has problems
                    await RconStatic.SystemDStart(pavlovServer, this);

                    pavlovServer = await GetServerServiceState(pavlovServer);

                    DataBaseLogger.LogToDatabaseAndResultPlusNotify("state = " + pavlovServer.ServerServiceState,
                                                                    LogEventLevel.Verbose, _notifyService);
                }
            }
            catch (CommandException e)
            {
                throw new ValidateException(e.Message);
            }

            DataBaseLogger.LogToDatabaseAndResultPlusNotify("try to send serverinfo", LogEventLevel.Verbose,
                                                            _notifyService);
            //try to send Command ServerInfo
            try
            {
                await RconStatic.SendCommandSShTunnel(pavlovServer, "ServerInfo", _notifyService);
            }
            catch (CommandException e)
            {
                await HasToStop(pavlovServer, hasToStop, root);

                throw new ValidateException(e.Message);
            }

            //try if the user have rights to delete maps cache
            try
            {
                DataBaseLogger.LogToDatabaseAndResultPlusNotify("delete unused maps", LogEventLevel.Verbose,
                                                                _notifyService);
                RconStatic.DeleteUnusedMaps(pavlovServer,
                                            (await _serverSelectedMapService.FindAllFrom(pavlovServer)).ToList());
            }
            catch (CommandException e)
            {
                await HasToStop(pavlovServer, hasToStop, root);

                throw new ValidateException(e.Message);
            }

            if (!string.IsNullOrEmpty(pavlovServer.SshServer.ShackMapsPath))
            {
                try
                {
                    DataBaseLogger.LogToDatabaseAndResultPlusNotify("check if ShackMapsPath exist!", LogEventLevel.Verbose,
                                                                    _notifyService);
                    RconStatic.DoesPathExist(pavlovServer, pavlovServer.SshServer.ShackMapsPath, _notifyService);
                }
                catch (CommandException e)
                {
                    await HasToStop(pavlovServer, hasToStop, root);

                    throw new ValidateException("ShackMapsPath does not exist: " + pavlovServer.SshServer.ShackMapsPath + "additional info:" + e.Message);
                }
            }

            await HasToStop(pavlovServer, hasToStop, root);

            return(pavlovServer);
        }