Table des matières

Faire tourner le serveur sous Docker
Utiliser khanat-server-docker
Faire en local
But
Prerequis
Architecture/Etat
Concretement
Détail
Docker
TODO (reste à faire)
Lien

Faire tourner le serveur sous Docker

Utiliser khanat-server-docker

1/ télécharger l'image : khanat-*-*-server-debian-stretch.zip voir : https://git.khaganat.net/khaganat/mmorpg_khanat/khanat-server-docker/pipelines

2/ ajouter l'image dans docker

unzip khanat-647e9a2-567-server-debian-stretch.zip
 
# si extension .tar.gz
zcat khanat-debian-server.tar.gz | docker import - opennel/servercontainer_debian_stretch_x86_64
 
## si extension .tar.bz2
# bunzip2 khanat-debian-server.tar.bz2
# cat khanat-debian-server.tar | docker import - opennel/servercontainer_debian_stretch_x86_64

3/ Démarrer l'image

docker run -it opennel/servercontainer_debian_stretch_x86_64 /opt/ext/servercontainer_launch_auto.sh --opennel-manager

Garder le terminal ouvert pour que le serveur soit actif. Il est possible d'envoyer les commandes depuis ce terminal. Un “exit” suffira pour arrêter le serveur.

Console:

Web : Home page

Web : OpenNel Manager

Web : OpenNel Manager - player connected

4/ Se connecter sur le serveur

Récupérer l'adresse ip :

docker inspect --format="{{ .NetworkSettings.IPAddress }}" $(docker ps -qf 'status=running' -f 'ancestor=opennel/servercontainer_debian_stretch_x86_64')

via ssh :

ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no gameserver@$ipaddress

via http : http://ipaddress/

5/ Jouer

Télécharger le script prepare_environment_container_64.sh http://ipaddress/prepare_environment_container_64.sh

bash prepare_environment_container_64.sh
(cd Khanat_Linux64; ./khanat_client)

Faire en local

Compilation et démarrage sous docker

But

L'objectif de compiler et démarrer un serveur sous docker et de permettre à tous de tester rapidement une fonctionnalité.

Prerequis

Docker
Accès internet (utile pour l'étape 1 de chacune des phases)
[Optionnel] 7Zip (utile pour décompresser le client khanat)
tar (pour décompresser le client généré par votre build)

Architecture/Etat

Debian
- jessie (8)
  - 64bit (x86_64) : tout fonctionne
  - 32bit (i686) : tout fonctionne
- stretch (9)
  - 64bit (x86_64) : non réalisé
  - 32bit (i686) : non réalisé

Concretement

Pour ceux qui souhaite rapidement compiler et démarrer le serveur (en local) et le client. Voici les commandes afin d'avoir un système fonctionnel. (attention la phase de compilation peut etre longue [cela dépend de votre machine])

Cloner les repo

git clone https://git.khaganat.net/khaganat/mmorpg_khanat/khanat-server-docker.git
git clone https://git.khaganat.net/khaganat/mmorpg_khanat/khanat-opennel-code.git
git clone https://git.khaganat.net/khaganat/mmorpg_khanat/khanat-client-data.git
git clone https://git.khaganat.net/khaganat/mmorpg_khanat/khanat-ressources.git
git clone https://git.khaganat.net/khaganat/mmorpg_khanat/opennel-pymanager.git

Lancer la compilation (x86_64)

khanat-server-docker/builder/debian/jessie/x86_64/build.sh -c -j 12 -a '-DWITH_SYMBOLS=ON'

Démarrer le serveur (en mode container)

Ce mode est plus fléxible, quand on recompile partiellement, ou que l'on modifie des donnée du jeux, la mise à jour est plus rapide.

Premier génération du serveur & démarrage

khanat-server-docker/server/debian/jessie/i686/server-container.sh -r -b -k -w -c -n
khanat-server-docker/server/debian/jessie/i686/server-container.sh -w -c

Mise à jour du serveur & démarrage

khanat-server-docker/server/debian/jessie/i686/server-container.sh -u -w -c -n
khanat-server-docker/server/debian/jessie/i686/server-container.sh -w -c

Se connecter sur votre serveur (via ssh)

Utile si l'on souhaite déboguer.

(il faut s'assurer que le serveur est bien actif)

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh --ssh

Démarrer le client du jeux (x86_64)

Télécharger les binaires du jeux (présent sur le serveur démarrer)
Modifier les paramètres pour ce connecter sur votre serveur
Démarrage du client

prepare_environment_container_64.sh

#!/bin/bash
 
declare IMAGEKHANATSERVER="opennel/servercontainer_debian_jessie_x86_64"
 
mkdir -p $HOME/Public
 
echo "$(date "+%Y/%m/%d %H:%M:%S") Get ip address server khanat"
listcontainer="$(docker ps -qf 'status=running' -f 'ancestor='"${IMAGEKHANATSERVER}"'')"
if [[ ${#listcontainer[@]} -eq 1 ]]
then
  ipaddress=$(docker inspect --format="{{ .NetworkSettings.IPAddress }}" ${listcontainer[@]})
fi
 
echo "$(date "+%Y/%m/%d %H:%M:%S") get client package"
wget http://$ipaddress/client/smokey_linux64.tar.gz -O smokey_linux64.tar.gz
 
echo "$(date "+%Y/%m/%d %H:%M:%S") clean old client"
if [[ -d Khanat_Linux64 ]]
then
	rm -rf Khanat_Linux64 || exit 2
fi
 
echo "$(date "+%Y/%m/%d %H:%M:%S") install new client"
#7z x -y $SRCKHANATCLIENT || exit 2
#7z x -y -oKhanat_Linux64 $SRCKHANATCLIENTDEBUG || exit 2
tar xvzf smokey_linux64.tar.gz || exit 2
 
echo "$(date "+%Y/%m/%d %H:%M:%S") configure client"
sed -i 's/lirria.khaganat.net/'$ipaddress'/g' Khanat_Linux64/client_default.cfg
echo -en "Client khanat installed & configured\nGo to Khanat_Linux64 directory and launch client\n"
echo -en "(cd Khanat_Linux64;./khanat_client)\n"

./prepare_environment_container_64.sh
(cd Khanat_Linux64; ./khanat_client)

Détail

Commande

tout compiler

Vous avez la possibilité de compiler toutes les versions et créer les serveurs types de serveur. et sauvegarder les images réalisé sur le serveur host.

khanat-server-docker/build_all.sh --clean --save-docker-images

jessie - 32bit (i686)

compilation

khanat-server-docker/builder/debian/jessie/i686/build.sh -c -j 12 -a '-DWITH_SSE2=OFF' -a '-DWITH_SYMBOLS=ON'

Actuellement, nous avons besoin d'ajouter l'option '-DWITH_SSE2=OFF' dans la compilation pour corriger (temporaire) un problème pendant la phase de “build”.

préparation du serveur

khanat-server-docker/server/debian/jessie/i686/server-container.sh -r -b -k -w -c -n

mise à jour du serveur

khanat-server-docker/server/debian/jessie/i686/server-container.sh -u -w -c -n

démarrage du serveur

khanat-server-docker/server/debian/jessie/i686/server-container.sh -w -c

jessie - 64bit (x86_64)

compilation

khanat-server-docker/builder/debian/jessie/x86_64/build.sh -c -j 12 -a '-DWITH_SYMBOLS=ON'

préparation du serveur

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -r -b -k -w -c -n

mise à jour du serveur

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -u -w -c -n

démarrage du serveur

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -w -c

Fonctionnement

Nous avons séparé en deux parties(chacune divisée en plusieurs étapes):

BUILD : construction des binaires (entre 1h & +8h)
SERVER : Construction & démarrage du serveur khanat

Pour l'étape SERVER nous avons deux méthodes possible :

Méthode SERVERIMAGE : construction d'une image complète
1. elle aura la taille de 25Go
2. on perd toutes les informations à chaque redémarrage (temps de démarrage 20min)
3. arborescence d'un vrai serveur khanat (du moins il se raproche de celui-ci)
Méthode SERVERCONTAINER : construction d'une image légère,
1. elle aura une taille réduite (600 Mo)
2. on garde toutes les informations entre chaque démarrage
3. possibilité de faire des mise à jour de data/binaire (incrémente la partie patch)
4. démarrage réduit (après un premier démarrage réussi)
5. partage de données avec le serveur hôte
6. utilisation de référence (link) pour pointer sur les fichiers sources (confusion quand on regarde le résultat sur l'hôte)

BUILD :

construction d'une image générique (contenant tout le nécessaire pour le “build”)
1. on a besoin d'un accès Internet
génération des binaires

SERVERIMAGE :

récupération des données (binaire, data khanat, …)
construction d'une image générique (contenant tout le nécessaire pour le serveur)
1. on a besoin d'un accès Internet
construction d'une image complète
démarrage du serveur khanat

SERVERCONTAINER :

construction d'une image générique (contenant tout le nécessaire pour le serveur)
1. on a besoin d'un accès Internet
configuration du serveur (écrit les données sur l'hôte)
mise à jour des données (optionnel)
démarrage du serveur

Préparation de l'environnement

On doit récupérer tous les dépôts utilisés pour le serveur et les données. Pour cela, on crée un répertoire dédié :

mkdir -p khanat
cd khanat
git clone https://git.khaganat.net/khaganat/mmorpg_khanat/khanat-server-docker.git
git clone https://git.khaganat.net/khaganat/mmorpg_khanat/khanat-opennel-code.git
git clone https://git.khaganat.net/khaganat/mmorpg_khanat/khanat-client-data.git
git clone https://git.khaganat.net/khaganat/mmorpg_khanat/khanat-ressources.git
git clone https://git.khaganat.net/khaganat/mmorpg_khanat/opennel-pymanager.git
cd ..

Compilation

Première phase, la compilation des binaires du serveur :

Génération d'une image docker avec tous les outils de compilation (accès Internet requis pour cette étape)
compilation des binaires

Image : builder_khanat_debian_jessie_x86_64
pendant la compilation, vous pouvez regarder les log
les binaires sont directement visible du serveur host (celui qui lance docker)

Création du serveur de compilation & compilation

khanat-server-docker/builder/debian/jessie/x86_64/build.sh -c -r -j 4 -a '-DWITH_SYMBOLS=ON'

Détail des options :

-c : efface les containers (docker) après leur utilisation
-r : supprime l'ancien répertoire de build
-a : ajoute les options de compilation (options pour la commande cmake)
-m : ajoute les options docker pour la phase de compilation (ici on limite la mémoire à 20Go)
-j : ajoute le nombre de thread pour la compilation (valeur = nb de CPU +1)
-d : affiche les messages de débogage.

Compilation seulement

Quand on a déjà l'image docker de compilation [builder_khanat_debian_jessie_x86_64], on peut lancer uniquement la phase de compilation.

khanat-server-docker/builder/debian/jessie/x86_64/build.sh -c -j 4 -a '-DWITH_SYMBOLS=ON'

Info

Log : khanat-code/code/build/builder_khanat_debian_jessie_x86_64/build.log

Donnée de compilation : khanat-code/code/build/builder_khanat_debian_jessie_x86_64

Aide

usage:khanat-server-docker/builder/debian/jessie/x86_64/build.sh [options]
  script to build under docker
 
  Step: 
   1) clean old build directory
   2) create image builder
   3) launch build under docker (launch script build-under-docker.sh)
   4) remove docker container with state exited
 
options:
  -h, --help       : Show this help
  -d, --debug      : Show debug message
  -r, --remove     : Remove old build repository
  -f, --force-create-image : force to create docker image (use to build khanat) - default autodetec.
  -j [N], --jobs[=N]          Allow N jobs at once; infinite jobs with no arg.
  -a OPTS, --add-opts-cmake=OPTS : Adding options on cmake command (before build)
  -c, --clean-container : remove all container in state Exited
  -w, --clean-images-none : Remove images docker (with name 'none')
  -m OPTS, --add-opts-docker=OPTS : Adding options on docker command (when build)
  --only-build-server : adding option to build only server
  -p, --package : generate package
  --code-source=[DIR] : localization source OpenNel code
 
 
Example :
  cd [root Khanat directory]
  ./build.sh -c -r -m '-m 20g'
  ./build.sh -c -r -j 4 -a '-DWITH_SYMBOLS=ON' -a '-DWITH_RYZOM_TOOLS=OFF' -a '-DWITH_NEL_TOOLS=OFF'  -m '-m 20g' -d

Démarrage du serveur

Vous avez deux possibilités pour démarrer le serveur :

Soit SERVERIMAGE, où tout est contenu dans une image docker (à savoir l’intégralité du filesystem d’un serveur de jeu) :
- Contient absolument tout le serveur, avec son arborescence, tous ses services et l’intégralité des données.

Soit SERVERCONTAINER, où toutes les données sont sur l'hôte :
- Plus rapide et facile à manipuler pour les mises à jour.

SERVERIMAGE

Génération des données pour le serveur et démarrage de celui-ci

Création du fichier compressé du repo khanat-ressources [TAR.GZ]
Création du fichier compressé du repo khanat-data-client [TAR.GZ]
Création du fichier compressé du repo ryzom-ressources (provient du khanat-code) [TAR.GZ]
Génération d'une image docker avec tous les outils pour le serveur (accès internet requis pour cette étape)
Génération d'une image serveur khanat
1. création de la base de données
2. configuration apache
3. création (ou mise à jour) des données du serveur khanat
4. création des données pour le serveur de patch (juste un serveur web qui fournit des fichiers)
Démarrage du serveur

Tout faire en automatique

Il détecte les étapes qu'il n'a pas faites et les exécute.

Attention, il ne vérifie pas s'il faut générer de nouveau les fichiers compressés contenant les ressources/binaires/données client

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w

Forcer une nouvelle génération des fichiers compressés, puis reconstruire le serveur et le démarrer

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -t -q -z -k

Forcer une nouvelle génération des données de khanat et démarrer le serveur

Démarrage sous screen

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -k

Démarrage avec le log

Affiche le log dans le terminal

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -k --start-khanat-with-full-log

Démarrage avec le statut

Affiche le statut (au format Nagios ?)

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -k --start-khanat-with-watch-state

Se connecter au serveur en ssh

Il est possible de se connecter sur un serveur en ssh.

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh --ssh

Attention, il faut avoir démarré le serveur avant d'exécuter cette commande.

Arrêter le serveur

Arrêter le serveur et effacer tous les containeurs

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -n -s

Aide

usage:dist/docker/server/debian/jessie/x86_64/server-image.sh [options]
  script to build under docker
 
  Step: 
   1) generate tar with khanat-ressources
   2) generate tar with ryzom-ressources
   3) create image basic server
   4) create image khanat server
   5) launch khanat server
 
options:
  -h, --help        : Show this help
  -d, --debug       : Show debug message
  -b, --force-basic : Force create/recreate image basic server
  -t, --force-tar-ressources : Generate TAR.GZ for khanat-ressources (look directory ../khanat-ressources)
  -q, --force-tar-client-data : Generate TAR.GZ for khanat-client-data (look directory ../khanat-client-data)
  -z, --force-tar-ryzom-ressources : Generate TAR.GZ in data khanat-code
  -k, --force-khanat : Force create/recreate image khanat server
  -n, --no-launch-khanat : Doesn't launch khanat server
  -s, --stop-server : Stop server khanat
  -c, --clean-container-khanat : Remove old server khanat (stopped)
  -w, --clean-images-none : Remove images docker (with name 'none')
  -i, --show-ip-khanat-server : show ip address for khanat server (launch under docker)
  --option-docker-build=[STRING] : you can add option in "docker build"
  --opennel-code-dir=[DIR]       : localization opennel-code
  --start-khanat-with-screen : [default] start khanat with screen
  --start-khanat-with-full-log : start server khanat and show full log
  --start-khanat-with-watch-state : start server khanat and show state (loop)
  --ssh : connect on khanat server (with ssh) [Exclusive action, can't execute other action]
  --client-version=[INTEGER] : version client khanat (we need to communicate with our server)
 
 
Example :
  cd [root Khanat directory]
  ./server.sh
  ./server.sh -k
  ./server.sh --ssh

Configuration & Démarrage du client

Pour utiliser le serveur, il faudra reconstruire le client (sans données externes), afin qu'il récupère le patch.

prepare_environment_image.sh

#!/bin/bash
 
declare IMAGEKHANATSERVER="opennel/serverimage_debian_jessie_x86_64"
 
mkdir -p $HOME/Public
 
echo "$(date "+%Y/%m/%d %H:%M:%S") Get ip address server khanat"
listcontainer="$(docker ps -qf 'status=running' -f 'ancestor='"${IMAGEKHANATSERVER}"'')"
if [[ ${#listcontainer[@]} -eq 1 ]]
then
  ipaddress=$(docker inspect --format="{{ .NetworkSettings.IPAddress }}" ${listcontainer[@]})
fi
 
echo "$(date "+%Y/%m/%d %H:%M:%S") get client package"
wget http://$ipaddress/client/smokey_linux64.tar.gz -O smokey_linux64.tar.gz
 
echo "$(date "+%Y/%m/%d %H:%M:%S") clean old client"
if [[ -d Khanat_Linux64 ]]
then
	rm -rf Khanat_Linux64 || exit 2
fi
 
echo "$(date "+%Y/%m/%d %H:%M:%S") install new client"
#7z x -y $SRCKHANATCLIENT || exit 2
#7z x -y -oKhanat_Linux64 $SRCKHANATCLIENTDEBUG || exit 2
tar xvzf smokey_linux64.tar.gz || exit 2
 
echo "$(date "+%Y/%m/%d %H:%M:%S") configure client"
sed -i 's/lirria.khaganat.net/'$ipaddress'/g' Khanat_Linux64/client_default.cfg
echo -en "Client khanat installed & configured\nGo to Khanat_Linux64 directory and launch client\n"
echo -en "(cd Khanat_Linux64;./khanat_client)\n"

./prepare_environment_image.sh
(cd Khanat_Linux64; ./khanat_client)

Utiliser le compte tester pour se connecter dans le jeux (voir Se connecter sur l'administration khanat pour le détail du compte)

Connection

Il faut dans un premier temps récuperer l'IP du serveur khanat sous docker

Récupérer l'ID du container

Va chercher l’ID du container actif :

docker ps -qf 'status=running' -f 'ancestor=serverimage_khanat_debian_jessie_x86_64'

Récuperer l'IP en fonction de l'ID du container

Méthode 1 : via le script server.sh

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -i

Méthode 2 : via une interrogation directe de docker

docker inspect --format="{{ .NetworkSettings.IPAddress }}" [ID du container]

Se connecter en ssh

en passant par le script server.sh

khanat-server-docker/server/debian/jessie/x86_64/server-image.sh --ssh

sans passer par le script server.sh

ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no gameserver@[ip khanat server]

Se connecter sur phpMyAdmin

On utilise l’adresse :

http://[Adresse ip server khanat sous docker]/phpmyadmin

compte	mot de passe
root	aucun

Se connecter sur l'administration khanat

On utilise l’adresse :

http://[Adresse ip server khanat sous docker]/ams/

compte	mot de passe	fonction
admin	admin	compte qui lance khanat serveur
tester	tester	user

Compte serveur khanat

compte	mot de passe	fonction	home
gameserver	khanat	compte qui gère tout (le serveur khanat & serveur patch)	/home/gameserver

Arborescence

répertoire	fonction
/home/gameserver	Répertoire par défaut de gameserver (HOME)
/home/gameserver/khanat	Répertoire de base du serveur khanat
/home/gameserver/khanat/khanatweb	Répertoire de base pour la partie web service (hors patch serveur & phpmyadmin)
/home/gameserver/patch_service	Répertoire de base pour le patch serveur

SERVERCONTAINER

Génération des données pour le serveur et démarrage de celui-ci

Contrôle de la présence des données
Génération d'une image docker avec tous les outils pour le serveur (accès Internet requis pour cette étape)
Construction de l'image contenant toutes les données statiques (configuration mysql, apache, …)
Génération des données de khanat
1. création de la base de données
2. création ( ou mise à jour) des données du serveur khanat
3. création des données pour le serveur de patch (juste un serveur web qui présente des fichiers)
Démarrage du serveur

Tout faire en automatique

Il détecte les étapes qu'il n'a pas faites et les exécute.

Attention, il ne vérifie pas s'il faut générer de nouveau les fichiers compressés contenant les ressources/binaire/donnée client

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w

Forcer une nouvelle génération des données, puis reconstruire le serveur et le démarrer

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -r -c -w -b -k -g

Forcer une nouvelle génération des données de khanat et démarrer le serveur

Démarrage sous screen

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -r -c -w -g

Mettre à jour les données de khanat et démarrer le serveur

Démarrage sous screen

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w -u

Démarrage avec le log

Affiche la log dans le terminal

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w -k --start-khanat-with-full-log

Demarrage avec le status

Affiche la status (format Nagios ?)

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w -k --start-khanat-with-watch-state

Se connecter au serveur en ssh

Il est possible de se connecter sur un serveur en ssh.

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh --ssh

Attention, il faut avoir démarré le serveur avant d'exécuter cette commande.

Arrêter le serveur

Arrêter le serveur et effacer tous les containers

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w -n -s

Aide

usage:dist/docker/server/debian/jessie/x86_64/server-container.sh [options]
  script to build under docker
 
  Step: 
   1) create image basic server
   2) create image khanat server
   3) configure khagant server
   4) launch khagant server
 
options:
  -h, --help         : Show this help
  -d, --debug        : Show debug message
  -r, --remove       : Remove directory data khanat
  -b, --force-basic  : Force create/recreate image basic server
  -k, --force-khanat : Force create/recreate image khanat server
  -u, --update-data  : generate a new patch (client & update server)
  -g, --configure-khanat : Force configure khanat server
  -n, --no-launch-khanat : Doesn't launch khanat server
  -s, --stop-server      : Stop server khanat
  -c, --clean-container-khanat   : Remove old server khanat (stopped)
  -w, --clean-images-none        : Remove images docker (with name 'none')
  -i, --show-ip-khanat-server    : show ip address for khanat server (launch under docker)
  --option-docker-build=[STRING] : you can add option in "docker build"
  --khanat-ressources-dir=[DIR]  : localization khanat-ressources
  --khanat-client-data-dir=[DIR] : localization khanat-client-data
  --opennel-code-dir=[DIR]       : localization opennel-code
  --start-khanat-with-screen     : start with screen
  --start-khanat-with-khanat-log         : start server khanat and show khanat log
  --start-khanat-with-full-log           : start server khanat and show full log
  --start-khanat-with-watch-state        : start server khanat and show state (loop)
  --start-khanat-with-watch-state-nagios : start server khanat and show state [nagios format] (loop)
  --start-khanat-with-bash-after         : start server khanat and launch bash
  --start-with-manager                   : start khanat with manager
  --ssh : connect on khanat server (with ssh) [Exclusive action, can't execute other action]
  --client-version=[INTEGER] : version client khanat (we need to communicate with our server)
 
Example :
  cd [root Khanat directory]
  ./server.sh
  ./server.sh -k
  ./server.sh --ssh

Configuration & Démarrage du client

Pour utiliser le serveur, il faudra reconstruire le client (sans données externes), afin qu'il récupère le patch.

prepare_environment_container.sh

#!/bin/bash
 
declare IMAGEKHANATSERVER="opennel/servercontainer_debian_jessie_x86_64"
 
mkdir -p $HOME/Public
 
echo "$(date "+%Y/%m/%d %H:%M:%S") Get ip address server khanat"
listcontainer="$(docker ps -qf 'status=running' -f 'ancestor='"${IMAGEKHANATSERVER}"'')"
if [[ ${#listcontainer[@]} -eq 1 ]]
then
  ipaddress=$(docker inspect --format="{{ .NetworkSettings.IPAddress }}" ${listcontainer[@]})
fi
 
echo "$(date "+%Y/%m/%d %H:%M:%S") get client package"
wget http://$ipaddress/client/smokey_linux64.tar.gz -O smokey_linux64.tar.gz
 
echo "$(date "+%Y/%m/%d %H:%M:%S") clean old client"
if [[ -d Khanat_Linux64 ]]
then
	rm -rf Khanat_Linux64 || exit 2
fi
 
echo "$(date "+%Y/%m/%d %H:%M:%S") install new client"
#7z x -y $SRCKHANATCLIENT || exit 2
#7z x -y -oKhanat_Linux64 $SRCKHANATCLIENTDEBUG || exit 2
tar xvzf smokey_linux64.tar.gz || exit 2
 
echo "$(date "+%Y/%m/%d %H:%M:%S") configure client"
sed -i 's/lirria.khaganat.net/'$ipaddress'/g' Khanat_Linux64/client_default.cfg
echo -en "Client khanat installed & configured\nGo to Khanat_Linux64 directory and launch client\n"
echo -en "(cd Khanat_Linux64;./khanat_client)\n"

./prepare_environment_container.sh
(cd Khanat_Linux64; ./khanat_client)

Utiliser le compte tester pour se connecter dans le jeux (voir Se connecter sur l'administration khanat pour le détail du compte).

Connection

En premier, il faut récupérer l'IP du serveur khanat sous docker.

récupérer l'ID du containeur

Récupère l'ID du containeur actif

docker ps -qf 'status=running' -f 'ancestor=servercontainer_khanat_debian_jessie_x86_64'

Récuperer l'IP en fonction de l'ID du containeur

Méthode 1 : via le script server.sh

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -i

Méthode 2 : via une interrogation de docker

docker inspect --format="{{ .NetworkSettings.IPAddress }}" [ID du container]

Se connecter en ssh

en passant par le script server.sh

khanat-server-docker/server/debian/jessie/x86_64/server-container.sh --ssh

sans passer par le script server.sh

  ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no gameserver@[ip khanat server]

Se connecter sur phpMyAdmin

http://[Adresse IP server khanat sous docker]/phpmyadmin

compte	mot de passe
root	aucun

Se connecter sur l'administration khanat

http://[Adresse IP server khanat sous docker]/ams/

compte	mot de passe	fonction
admin	admin	compte qui lance khanat serveur
tester	tester	user

Compte serveur khanat

compte	mot de passe	fonction	home
gameserver	khanat	compte qui gère tout (le serveur khanat & serveur patch)	/home/gameserver

Arborescence

1) Dans le containeur Docker :

répertoire	fonction
/home/gameserver	Répertoire par défaut de gameserver (HOME)
/home/gameserver/khanat	Répertoire de base du serveur khanat
/home/gameserver/khanat/khanatweb	Répertoire de base pour la partie web service (hors patch serveur & phpmyadmin)
/home/gameserver/khanat/patch_service	Répertoire de base pour le patch serveur
/home/gameserver/log	Répertoire de base pour les log
/home/gameserver/databse	Répertoire de base pour la base de donnée

2) Dans l'hôte

répertoire	fonction
build	Répertoire contenant tous les build
build/builder_khanat_debian_jessie_x86_64	Répertoire d'un build spécifique (à un OS, version)
output	Répertoire contenant toutes les données de l'hote
output/khanat_debian_jessie_x86_64	Répertoire contenant les données de l'hote pour un OS & version spécifique

Aide

Au secours

Contrôler l'espace disque

df -h

Il doit rester de l'espace disque (pas de 100% utilisé)

Nettoyer les containers docker non utilisée

docker ps -a
docker rm 0d80f8c01701

Nettoyer les images docker non utilisées

docker images
docker rmi e0b14f49be1f

Nettoyer les données de test

ls khanat-code/output/khanat_debian_jessie_x86_64/
rm -rf khanat-code/output/khanat_debian_jessie_x86_64

Relancer le démarrage du serveur à froid

Contrôler docker

docker version
docker info
docker search debian

Docker

Quelques commandes :

Lister les images

docker images

Lister les containers

  docker ps -a

Récupérer les info d'un container

  docker inspect [id container]

Arrêter un container

  docker stop [id container]

Supprimer un container

  docker rm [id container]

Supprimer une image

  docker rmi [id image]

TODO (reste à faire)

ameliorer la partie server afin de réduire la copie de donnée, et permettre d'utiliser des patch réduit en cas d'upate mineur
1. supprimer les copies de donnée inutile
2. controler que les données sont identique (ou équivalente) à un vrai serveur
sur la partie patch (remplacer ryzom.xml par khanat.xml → attention cela impact le khanat_client [pour l'instant il attend uniquement ryzom.xml])

Lien

Installation d'un serveur de patchs
Mises à jour des données de jeu pour le serveur Lirria
Installation du shard
OpenNeL /Ryzom Core

informatique