====== Faire tourner le serveur sous Docker ======

<WRAP centeralign>
{{ :fr:docker-friends.jpg?direct&450 |}}
</WRAP>

====== 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

<WRAP prewrap 650px>
<code bash>
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
</code>
</WRAP>

3/ Démarrer l'image

<WRAP prewrap 650px>
<code bash>
docker run -it opennel/servercontainer_debian_stretch_x86_64 /opt/ext/servercontainer_launch_auto.sh --opennel-manager
</code>
</WRAP>
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:**
<WRAP centeralign>
{{ :fr:khanat-server-docker-terminal.png?direct&450 |}}
</WRAP>


**Web : Home page**
<WRAP centeralign>
{{ :fr:khanat-server-docker-web-1.png?direct&450 |}}
</WRAP>


**Web : OpenNel Manager**
<WRAP centeralign>
{{ :fr:khanat-server-docker-web-2.png?direct&450 |}}
</WRAP>


**Web : OpenNel Manager - player connected**
<WRAP centeralign>
{{ :fr:khanat-server-docker-web-3.png?direct&450 |}}
</WRAP>



4/ Se connecter sur le serveur

Récupérer l'adresse ip :

<WRAP prewrap 650px>
<code bash>
docker inspect --format="{{ .NetworkSettings.IPAddress }}" $(docker ps -qf 'status=running' -f 'ancestor=opennel/servercontainer_debian_stretch_x86_64')
</code>
</WRAP>

via ssh : 

<WRAP prewrap 650px>
<code bash>
ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no gameserver@$ipaddress
</code>
</WRAP>

via http :
http://ipaddress/

5/ Jouer

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

<WRAP prewrap 650px>
<code bash>
bash prepare_environment_container_64.sh
(cd Khanat_Linux64; ./khanat_client)
</code>
</WRAP>

====== 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 =====

<WRAP prewrap 650px>
<code bash>
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
</code>
</WRAP>

===== Lancer la compilation (x86_64) =====

<WRAP prewrap 650px>
<code bash>
khanat-server-docker/builder/debian/jessie/x86_64/build.sh -c -j 12 -a '-DWITH_SYMBOLS=ON'
</code>
</WRAP>

===== 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 ====
<WRAP prewrap 650px>
<code bash>
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
</code>
</WRAP>

==== Mise à jour du serveur & démarrage ====
<WRAP prewrap 650px>
<code bash>
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
</code>
</WRAP>

==== Se connecter sur votre serveur (via ssh) ====
Utile si l'on souhaite déboguer.

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

<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh --ssh
</code>
</WRAP>


===== 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

<WRAP prewrap 650px>
<file bash 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"
</file>
</WRAP>

<WRAP prewrap 650px>
<code bash>
./prepare_environment_container_64.sh
(cd Khanat_Linux64; ./khanat_client)
</code>
</WRAP>


====== 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.

<WRAP prewrap 650px>
<code bash>
khanat-server-docker/build_all.sh --clean --save-docker-images
</code>
</WRAP>

==== jessie - 32bit (i686) ====
=== compilation ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/builder/debian/jessie/i686/build.sh -c -j 12 -a '-DWITH_SSE2=OFF' -a '-DWITH_SYMBOLS=ON'  
</code>
</WRAP>
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 ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/i686/server-container.sh -r -b -k -w -c -n
</code>
</WRAP>

=== mise à jour du serveur ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/i686/server-container.sh -u -w -c -n
</code>
</WRAP>

=== démarrage du serveur ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/i686/server-container.sh -w -c
</code>
</WRAP>

==== jessie - 64bit (x86_64) ====
=== compilation ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/builder/debian/jessie/x86_64/build.sh -c -j 12 -a '-DWITH_SYMBOLS=ON'
</code>
</WRAP>


=== préparation du serveur ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -r -b -k -w -c -n
</code>
</WRAP>

=== mise à jour du serveur ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -u -w -c -n
</code>
</WRAP>

=== démarrage du serveur ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -w -c
</code>
</WRAP>


===== 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
    - elle aura la taille de 25Go
    - on perd toutes les informations à chaque redémarrage (temps de démarrage 20min)
    - arborescence d'un vrai serveur khanat (du moins il se raproche de celui-ci)
  - Méthode SERVERCONTAINER : construction d'une image légère, 
    - elle aura une taille réduite (600 Mo)
    - on garde toutes les informations entre chaque démarrage
    - possibilité de faire des mise à jour de data/binaire (incrémente la partie patch)
    - démarrage réduit (après un premier démarrage réussi)
    - partage de données avec le serveur hôte
    - 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")
    - 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)
    - 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)
    - 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é :

<WRAP prewrap 650px>
<code bash>
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 ..
</code>
</WRAP>

===== 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 ====
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/builder/debian/jessie/x86_64/build.sh -c -r -j 4 -a '-DWITH_SYMBOLS=ON'
</code>
</WRAP>

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.
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/builder/debian/jessie/x86_64/build.sh -c -j 4 -a '-DWITH_SYMBOLS=ON'
</code>
</WRAP>

==== 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 ====
<WRAP prewrap 650px>
<code bash>
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
</code>
</WRAP>

===== 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 
    - création de la base de données 
    - configuration apache
    - création (ou mise à jour) des données du serveur khanat
    - 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.

<WRAP center round important 90%>
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
</WRAP>

<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w
</code>
</WRAP>
=== Forcer une nouvelle génération des fichiers compressés, puis reconstruire le serveur et le démarrer ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -t -q -z -k
</code>
</WRAP>

=== Forcer une nouvelle génération des données de khanat et démarrer le serveur ===
== Démarrage sous screen ==
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -k
</code>
</WRAP>

== Démarrage avec le log ==
Affiche le //log// dans le terminal
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -k --start-khanat-with-full-log
</code>
</WRAP>

== Démarrage avec le statut ==
Affiche le statut (au format Nagios ?)
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -k --start-khanat-with-watch-state
</code>
</WRAP>

=== Se connecter au serveur en ssh ===
Il est possible de se connecter sur un serveur en ssh.
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh --ssh
</code>
</WRAP>
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
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -c -w -n -s
</code>
</WRAP>


=== Aide ===
<WRAP prewrap 650px>
<code bash>
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
</code>
</WRAP>

==== 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.

<WRAP prewrap 650px>
<file bash 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"
</file>
</WRAP>

<WRAP prewrap 650px>
<code bash>
./prepare_environment_image.sh
(cd Khanat_Linux64; ./khanat_client)
</code>
</WRAP>

Utiliser le compte //tester// pour se connecter dans le jeux (voir [[fr:docker_server#se_connecter_sur_l_administration_khanat|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 :
<WRAP prewrap 650px>
<code bash>
docker ps -qf 'status=running' -f 'ancestor=serverimage_khanat_debian_jessie_x86_64'
</code>
</WRAP>

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

Méthode 1 : via le script ''server.sh''
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh -i
</code>
</WRAP>

Méthode 2 : via une interrogation directe de docker
<WRAP prewrap 650px>
<code bash>
docker inspect --format="{{ .NetworkSettings.IPAddress }}" [ID du container]
</code>
</WRAP>

== Se connecter en ssh ==
  * en passant par le script ''server.sh''
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-image.sh --ssh
</code>
</WRAP>

  * sans passer par le script ''server.sh''
<WRAP prewrap 650px>
<code bash>
ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no gameserver@[ip khanat server]
</code>
</WRAP>

== Se connecter sur phpMyAdmin ==

On utilise l’adresse :
<code>
http://[Adresse ip server khanat sous docker]/phpmyadmin
</code>

^compte^mot de passe^
|root|//aucun//|


== Se connecter sur l'administration khanat ==
On utilise l’adresse :
<code>
http://[Adresse ip server khanat sous docker]/ams/
</code>

^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 
    - création de la base de données
    - création ( ou mise à jour) des données du serveur khanat
    - 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.
<WRAP center round important 60%>
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
</WRAP>

<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w
</code>
</WRAP>
=== Forcer une nouvelle génération des données, puis reconstruire le serveur et le démarrer ===
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -r -c -w -b -k -g
</code>
</WRAP>

=== Forcer une nouvelle génération des données de khanat et démarrer le serveur ===
== Démarrage sous screen ==
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -r -c -w -g
</code>
</WRAP>

=== Mettre à jour les données de khanat et démarrer le serveur ===
== Démarrage sous screen ==
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w -u
</code>
</WRAP>

== Démarrage avec le log ==
Affiche la log dans le terminal
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w -k --start-khanat-with-full-log
</code>
</WRAP>

== Demarrage avec le status ==
Affiche la status (format Nagios ?)
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w -k --start-khanat-with-watch-state
</code>
</WRAP>

=== Se connecter au serveur en ssh ===
Il est possible de se connecter sur un serveur en ssh.
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh --ssh
</code>
</WRAP>
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
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -c -w -n -s
</code>
</WRAP>


=== Aide ===
<WRAP prewrap 650px>
<code bash>
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
</code>
</WRAP>


=== 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.

<WRAP prewrap 650px>
<file bash 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"
</file>
</WRAP>

<WRAP prewrap 650px>
<code bash>
./prepare_environment_container.sh
(cd Khanat_Linux64; ./khanat_client)
</code>
</WRAP>

Utiliser le compte //tester// pour se connecter dans le jeux (voir [[fr:docker_server#se_connecter_sur_l_administration_khanat|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

<WRAP prewrap 650px>
<code bash>
docker ps -qf 'status=running' -f 'ancestor=servercontainer_khanat_debian_jessie_x86_64'
</code>
</WRAP>

== Récuperer l'IP en fonction de l'ID du containeur ==
Méthode 1 : via le script server.sh
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh -i
</code>
</WRAP>

Méthode 2 : via une interrogation de docker
<WRAP prewrap 650px>
<code bash>
docker inspect --format="{{ .NetworkSettings.IPAddress }}" [ID du container]
</code>
</WRAP>

== Se connecter en ssh ==
  * en passant par le script //server.sh//
<WRAP prewrap 650px>
<code bash>
khanat-server-docker/server/debian/jessie/x86_64/server-container.sh --ssh
</code>
</WRAP>

  * sans passer par le script //server.sh//
<WRAP prewrap 650px>
<code bash>
  ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no gameserver@[ip khanat server]
</code>
</WRAP>

== Se connecter sur phpMyAdmin ==
<code>
http://[Adresse IP server khanat sous docker]/phpmyadmin
</code>

^compte^mot de passe^
|root|  //aucun//  |


== Se connecter sur l'administration khanat ==
<code>
http://[Adresse IP server khanat sous docker]/ams/
</code>

^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 ===
<WRAP prewrap 650px>
<code bash>
df -h
</code>
</WRAP>
Il doit rester de l'espace disque (pas de 100% utilisé)

=== Nettoyer les containers docker non utilisée ===
<WRAP prewrap 650px>
<code bash>
docker ps -a
docker rm 0d80f8c01701
</code>
</WRAP>

=== Nettoyer les images docker  non utilisées ===
<WRAP prewrap 650px>
<code bash>
docker images
docker rmi e0b14f49be1f
</code>
</WRAP>

=== Nettoyer les données de test ===
<WRAP prewrap 650px>
<code bash>
ls khanat-code/output/khanat_debian_jessie_x86_64/
rm -rf khanat-code/output/khanat_debian_jessie_x86_64
</code>
</WRAP>

=== Relancer le démarrage du serveur à froid ===

=== Contrôler docker ===
<WRAP prewrap 650px>
<code bash>
docker version
docker info
docker search debian
</code>
</WRAP>


====== Docker ======
Quelques commandes :

=== Lister les images ===
<code bash>
docker images
</code>
=== Lister les containers ===
<code bash>
  docker ps -a
</code>
=== Récupérer les info d'un container ===
<code bash>
  docker inspect [id container]
</code>
=== Arrêter un container ===
<code bash>
  docker stop [id container]
</code>
=== Supprimer un container ===
<code bash>
  docker rm [id container]
</code>
=== Supprimer une image ===
<code bash>
  docker rmi [id image]
</code>
  
====== 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
    - supprimer les copies de donnée inutile
    - 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 ======

[[fr:installation_d_un_serveur_de_patchs]] \\
[[fr:mises_a_jour_des_donnees_de_jeu]] \\
[[fr:shard]] \\
[[fr:tag:informatique:ryzom_core:start]]


{{tag>informatique}}