====== Serveur Bazaar avec authentification SSH ======

Cette page décrit les étapes à suivre pour mettre en place un serveur Bazaar avec une authentification via SSH afin de gérer un ou plusieurs dépôts de code.

Note : Toutes les commandes qui suivent sont à effectuer en **root**.

===== Configuration du serveur SSH =====

Lorsque l'on utilise une distribution pour un serveur, on a l'habitude d'installer un serveur SSH (si cela n'est pas fait durant l'installation).
<code bash>aptitude install openssh-server</code>
Par défaut, ce serveur va écouter sur le port 22. Il est conseillé de garder cette configuration pour coupler SSH à Bazaar. La configuration du serveur ne sera pas abordée dans cette page (car on sait tous faire ça ;-)).

===== Configuration de Bazaar =====

==== Installation ====

L'installation de Bazaar se résume à l'installation d'un seul et unique paquet.
<code bash>aptitude install bzr</code>
La commande **bzr** fait appel à un programme relativement simple. Toutes les fonctionnalités sont en fait implantées par des plugins que le programme principal va utiliser. Une complétion automatique est disponible pour compléter automatiquement les arguments à passer à **bzr**. Il est de plus possible de rajouter des plugins personnels en les mettant dans le répertoire ///home/<utilisateur>/.bazaar/plugins//.

==== Bazaar smart server ====

Tout comme [[http://subversion.tigris.org/|Subversion]], par exemple, Bazaar possède un serveur qui lui est propre. C'est ce "serveur intelligent" qui permet d'utiliser le gestionnaire de versions en mode //bzr+ssh//. Lancer un serveur Bazaar est plutôt simple. Une seule ligne de commande suffit.
<code>bzr serve --directory=/chemin/vers/la/racine/des/projets/</code>
Mais une utilisation à la ligne de commande peut s'avérer assez ennuyeuse. On va donc par la suite se simplifier la vie. Avant tout, il faut préparer le terrain pour que tout soit prêt dès le lancement du smart server. Comme on peut le voir dans la commande ci-dessus, il faut créer une racine qui va contenir par la suite tous les projets/ Ainsi, ces derniers seront tous accessibles via Bazaar. Ici, la racine sera ///var/bzr//.
<code bash>mkdir /var/bzr</code>
Ensuite, on pourra lancer le serveur. Cependant, il faut être certain qu'il soit accessible via l'extérieur. La configuration du [[gnu_linux_server:network_configuration:firewall|firewall]] est donc une étape qui (je l'espère) est indispensable. Il faut donc ouvrir le port **4155** en entrée et sortie seulement en **TCP**.
Il est extrêmement intéressant pour des questions d'administration de pouvoir lancer, arrêter, redémarrer le serveur Bazaar comme les autres serveurs ([[gnu_linux_server:webserver_apache_2:main|Apache]] par exemple). C'est-à-dire via une commande du genre :
<code bash>/etc/init.d/service start|stop|restart</code>
Parce que le serveur n'est en fait qu'un plugin rattaché à Bazaar et qu'il n'est pas installé comme un serveur classique, il faut créer un script //bazaar_server// dans le répertoire ///etc/init.d//. Ce script nous permettra alors de gérer le serveur facilement.
<code bash>### BEGIN INIT INFO
# Provides:          bazaar_server
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Start daemon at boot time
# Description:       Enable service provided by daemon.
### END INIT INFO

#!/bin/sh

# Path to root of repo tree
BZRROOT=/var/bzr/

# Listening port (default = 4155)
PORT=4155

# Logs file
LOG_FOLDER=/var/log/bzr
LOG_FILE=$LOG_FOLDER/smart_server.log

# Arguments to start the server
ARGS="serve --port=$PORT --directory=$BZRROOT"

bzr_smart_server_process() {
    pgrep -fl "bzr $ARGS"
}

bzr_smart_server_status() {
    process=`bzr_smart_server_process`
    listening=`netstat -nl | grep -e ":$PORT "`

    if [ -z "$process" ]; then
        echo "Bazaar smart server is *not* running."
    else
        echo "Bazaar smart server is running."

        if [ -z "$listening" ]; then
            echo "The server is *not* listening on port $PORT."
        else
            echo "The server is listening on port $PORT."
        fi
    fi
}

bzr_smart_server_start() {
    echo "Starting Bazaar smart server."

    # Make sure the log folder is created
    if [ ! -d $LOG_FOLDER ]; then
        mkdir -p $LOG_FOLDER
    fi
    echo "" > $LOG_FILE

    bzr $ARGS > $LOG_FILE 2>&1 &

    bzr_smart_server_status
}

bzr_smart_server_stop() {
    echo "Stopping Bazaar smart server."

    pkill -f "bzr $ARGS"

    bzr_smart_server_status
}

case "$1" in
    start)
        bzr_smart_server_start
    ;;
    stop)
    	bzr_smart_server_stop
    ;;
    status)
    	bzr_smart_server_status
    ;;
    restart)
    	bzr_smart_server_stop
    	bzr_smart_server_start
    ;;
    *)
        echo "Usage: $0 { start | stop | status | restart }"
        exit 1
    ;;
esac</code>
L'en-tête du script va permettre de contrôler son exécution au démarrage de la machine. En effet, on va également ajouter ce script aux //runlevels//, afin de ne pas être obligé de le lancer et l'arrêter manuellement à chaque redémarrage de la machine. Pour cela on utilise la commande ci-dessous.
<code bash>update-rc.d bazaar_server defaults</code>
Les quatre variables principales du script (celles dont les noms sont en majuscules) sont éventuellement à modifier. Elles concernent la racine des projets à utiliser, le port utilisé par le serveur et le fichier dans lequel seront enregistrés les logs. On rend enfin le script exécutable et il est alors possible de lancer, redémarrer, arrêter le serveur mais aussi d'en voir le statut.
<code bash>chmod +x /etc/init.d/bazaar_server
/etc/init.d/bazaar_server start
/etc/init.d/bazaar_server stop
/etc/init.d/bazaar_server restart
/etc/init.d/bazaar_server status</code>

==== Création d'un projet ====

Une fois le serveur prêt, il ne reste qu'à créer les projets. Pour gérer les droits d'accès, on va utiliser un groupe et les utilisateurs ayant accès à SSH. On crée donc un groupe pour le projet (surtout si plusieurs personnes vont travailler dessus).
<code bash>groupadd mon_projet</code>
On peut désormais ajouter à ce groupe les utilisateurs qui auront un accès en écriture aux branches. Si l'utilisateur n'existe pas encore on utilisera :
<code bash>adduser --ingroup mon_projet mon_utilisateur</code>
Sinon, on fera plutôt :
<code bash>adduser mon_utilisateur mon_projet</code>
Il faut bien faire attention à l'inversion du nom du groupe et de celui de l'utilisateur d'une commande à l'autre. On peut alors créer le répertoire dans lequel toutes les branches seront présentes pour ensuite modifier son propriétaire qui deviendra le groupe précédemment créé.
<code bash>mkdir /var/bzr/mon_projet
chown :mon_projet /var/bzr/mon_projet</code>
Toutes les branches appartiendront au même groupe et donc tous les membres du groupe devront avoir un accès en lecture et en écriture alors que les autres ne pourront que lire le contenu des branches sans pouvoir le modifier (plutôt classique dans le cas d'un projet open source). C'est dans ce but que l'on va préciser les permissions.
<code bash>chmod ug+rwx,g+s,o+rx,o-w /var/bzr/mon_projet</code>
Après avoir déposé la branche **mainline** qui est la branche principale du développement (l'équivalent de **trunk** avec SVN), tous les développeurs du projet pourront la modifier. Il peut être intéressant pour des raisons de contrôle strict du code validé de n'avoir qu'un seul //gatekeeper// et donc qu'une seule personne ayant accès en écriture à **mainline**. Pour cela, on peut simplement réajuster le propriétaire de cette branche (il est possible de le faire pour toutes les branches).
<code bash>chown mon_utilisateur:mon_utilisateur /var/bzr/mon_projet/mainline</code>
Arrivé ici, il doit être possible pour tout le monde de créer une branche locale ou simplement de télécharger le code avec les commandes suivantes.
<code bash>bzr branch bzr://domaine.tld/mon_projet/branche
bzr checkout bzr://domaine.tld/mon_projet/branche</code>
En revanche, seules les développeurs du projet devraient être capables d'envoyer leurs branches et également de //pusher// leurs modifications sur les différentes branches avec la commande ci-dessous.
<code bash>bzr push bzr+ssh://domaine.tld/var/bzr/mon_projet/branche</code>
**Attention !** Il est très important d'indiquer le chemin complet car c'est ainsi que SSH fonctionne (cela ne dépend pas de Bazaar).
Pour terminer sur la création du projet, il fa&ut savoir que Bazaar fonctionne avec et sans //working-tree//. Une branche qui ne possède pas de working-tree ne permet pas à l'utilisateur de voir concrètement les fichiers. C'est-à-dire que la branche ne contient que l'historique du dépôt. Il est toutefois possible de construire un working-tree dans une branche qui n'en a pas.
<code bash>cd /chemin/vers/branche
bzr chechout .</code>
La branche nommée **mainline** étant la branche mère de toutes les autres (soit par héritage, soit directement), il est impératif que celle-ci possède un working-tree. Cependant, un problème fait sont apparition. En effet, l'action de **push** ne met pas à jour le working-tree. On peut le faire à la main en se connectant via SSH sur la machine puis en exécutant la commande de mise à jour dans la branche.
<code bash>bzr update</code>
Ou alors, on peut utiliser, pour plus de simplicitén le plugin [[https://launchpad.net/bzr-push-and-update|push-and-update]]. En réalité, ce dernier ne fait qu'exécuter automatiquement les commande **push** et **update**.
<code bash>bzr push bzr+ssh://domaine.tld/var/bzr/mon_projet/branche
ssh domain.tld bzr update /var/bzr/mon_projet/branche</code>