Seafile : installation sur CentOS

De wikiGite

Installation

Sur une CentOS < 7, Python 2.6 doit être installé. On l'installera par :

 yum install --enablerepo=epel python26

(voir Dépôts complémentaires pour le dépôt EPEL)

Installer les pré-requis :

yum install python-setuptools python-simplejson python-imaging MySQL-python httpd mod_ssl

ou, sur CentOS5 :

yum install --enablerepo=epel python26-distribute python26-setuptools python26-simplejson python26-imaging python26-mysqldb

Vérifier la dernière version sur https://bitbucket.org/haiwen/seafile/downloads

 cd install/
 wget https://bitbucket.org/haiwen/seafile/downloads/seafile-server_{version seafile}_x86-64.tar.gz # ou ....i386.tar.gz sur système 32 bits

Créer un répertoire seafile dans /home:

 cd /home
 mkdir seafile
 cd seafile
 tar -xvzf /root/install/seafile-server_{version seafile}_*.tar.gz

L'archive crée un sous-répertoire avec la version en cours. Lors d'une mise à jour, la précédente version ne sera donc pas écrasée.

Lancer l'installation (qui créera les bases de données) :

 cd seafile-server-{version seafile}
 ./setup-seafile-mysql.sh
* Nommer le server (nom affiché sur les clients, sans espaces)
* donner l'IP du serveur
* laisser le port ccnet, le chemin des données et les ports seafile par défaut
* donner un mail pour l'administrateur (mail existant si possible, qui servira à se connecter à l'interface) et un mot de passe
* Choisir "1" pour créer les bases
* donner les paramètres MySQL
* demander la création d'un utilisateur seafile
* laisser les noms de bases par défaut

On peut alors tester Seafile directement :

 ./seafile.sh start
 ./seahub.sh start

Et se connecter à l'interface par http://IP_DU_SERVEUR:8000

Configuration

Editer le fichier /home/seafile/conf/seafile.conf

[fileserver]
port = 8082

[database]
type = mysql
host = 127.0.0.1
port = 3306
user = seafile
password = PwdSeafile
db_name = seafile-db
connection_charset = utf8


Editer le fichier /home/seafile/conf/seahub_settings.py :

SECRET_KEY = "d56a6cbc-751c-dc66-9fdb-45f4492f5abda7d3"

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'seahub-db',
        'USER': 'seafile',
        'PASSWORD': 'PwdSeafile',
        'HOST': '127.0.0.1',
        'PORT': '3306',
        'OPTIONS': {
            'init_command': 'SET default_storage_engine=INNODB',
        }
    }
}

FILE_SERVER_ROOT = 'https://seafile.domain.fr/seafhttp'

Attention au "default_storage_engine" (plutôt que "storage_engine") à partir de la version 5 de Seafile !

Lancement automatique

https://github.com/haiwen/seafile/wiki/Start-seafile-server-at-system-bootup

D'abord, arrêter Seafile ! Il a été lancé avec le compte root pour le test, on le relancera avec un compte spécifique.

 ./seafile.sh stop
 ./seahub.sh stop

Créer un utilisateur seafile, dont le homedir sera le répertoire seafile :

 adduser -c "Seafile user" -d /home/seafile seafile
 chown -R seafile:apache /home/seafile
 chmod 750 /home/seafile

Créer le fichier /etc/sysconfig/seafile :

# Utilisateur lançant seafile
user=seafile

# Répertoire d'installation
seafile_dir=/home/seafile
script_path=${seafile_dir}/seafile-server-latest
seafile_init_log=${seafile_dir}/logs/seafile.init.log
seahub_init_log=${seafile_dir}/logs/seahub.init.log

# Mettre la valeur sur true si on utilise fastcgi
fastcgi=true

# définir le port pour fastcgi, par défaut le port 8000.
fastcgi_port=8000

Systèmes sysvinit (CentOS < 7)

Créer un script d'init pour le serveur seafile /etc/init.d/seafile :

#!/bin/bash
#
# seafile

#
# chkconfig: - 68 32
# description: seafile

# Source function library.
. /etc/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

if [ -f /etc/sysconfig/seafile ];then
        . /etc/sysconfig/seafile
        else
            echo "Config file /etc/sysconfig/seafile not found! Bye."
            exit 200
        fi

RETVAL=0

start() {
        # Start daemons.
        echo -n $"Starting seafile: "
        ulimit -n 30000
        su - ${user} -c"${script_path}/seafile.sh start >> ${seafile_init_log} 2>&1"
        RETVAL=$?
        echo
        [ $RETVAL -eq 0 ] && touch /var/lock/subsys/seafile
        return $RETVAL
}

stop() {
        echo -n $"Shutting down seafile: "
        su - ${user} -c"${script_path}/seafile.sh stop >> ${seafile_init_log} 2>&1"
        RETVAL=$?
        echo
        [ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/seafile
        return $RETVAL
}

# See how we were called.
case "$1" in
  start)
        start
        ;;
  stop)
        stop
        ;;
  restart|reload)
        stop
        start
        RETVAL=$?
        ;;
  *)
        echo $"Usage: $0 {start|stop|restart}"
        RETVAL=3
esac

Créer un script d'init pour l'interface web seahub /etc/init.d/seahub :

#!/bin/bash
#
# seahub

#
# chkconfig: - 69 31
# description: seahub

# Source function library.
. /etc/init.d/functions

# Source networking configuration.
. /etc/sysconfig/network

if [ -f /etc/sysconfig/seafile ];then
        . /etc/sysconfig/seafile
        else
            echo "Config file /etc/sysconfig/seafile not found! Bye."
            exit 200
        fi

RETVAL=0

start() {
        # Start daemons.
        echo -n $"Starting seahub: "
        ulimit -n 30000
        if [  $fastcgi = true ];
                then
                su - ${user} -c"${script_path}/seahub.sh start-fastcgi ${fastcgi_port} >> ${seahub_init_log} 2>&1"
                else
                su - ${user} -c"${script_path}/seahub.sh start >> ${seahub_init_log} 2>&1"
                fi
        RETVAL=$?
        echo
        [ $RETVAL -eq 0 ] && touch /var/lock/subsys/seahub
        return $RETVAL
}

stop() {
        echo -n $"Shutting down seafile: "
        su - ${user} -c"${script_path}/seahub.sh stop >> ${seahub_init_log} 2>&1"
        RETVAL=$?
        echo
        [ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/seahub
        return $RETVAL
}

# See how we were called.
case "$1" in
  start)
        start
        ;;
  stop)
        stop
        ;;
  restart|reload)
        stop
        start
        RETVAL=$?
        ;;
  *)
        echo $"Usage: $0 {start|stop|restart}"
        RETVAL=3
esac

exit $RETVAL

Activer les serveurs :

 chmod 550 /etc/init.d/seafile
 chmod 550 /etc/init.d/seahub
 chkconfig --add seafile
 chkconfig --add seahub
 chkconfig seahub on
 chkconfig seafile on

On peut les lancer :

 service seafile start
 service seahub start

Systèmes systemd (CentOS >= 7)

Créer /etc/systemd/system/seafile.service

[Unit]
Description=Seafile
# add mysql.service or postgresql.service depending on your database to the line below
After=network.target
 
[Service]
Type=oneshot
ExecStart=/home/seafile/seafile-server-latest/seafile.sh start
ExecStop=/home/seafile/seafile-server-latest/seafile.sh stop
RemainAfterExit=yes
User=seafile
Group=seafile
 
[Install]
WantedBy=multi-user.target

et /etc/systemd/system/seahub.service

[Unit]
Description=Seafile hub
After=network.target seafile.service
 
[Service]
# change start to start-fastcgi if you want to run fastcgi
ExecStart=/home/seafile//seafile-server-latest/seahub.sh start-fastcgi
ExecStop=/home/seafile/seafile-server-latest/seahub.sh stop
User=seafile
Group=seafile
Type=oneshot
RemainAfterExit=yes
 
[Install]
WantedBy=multi-user.target

Activer et lancer les 2 services

systemctl enable seafile
systemctl enable seahub
systemctl start seafile
systemctl start seahub

Plusieurs versions de Python

Si, après l'installation de Seafile avec Python 2.6, une version 2.7 est installée sur le serveur, par défaut c'est cette dernière qui sera utilisée (les scripts de lancement de Seafile et Seahub recherchent les binaires Python et s'arrêtent sur la 2.7).

Mais les modules nécessaires à Seafile ont été installés sur la version 2.6, la 2.7 ne les voit pas, Seafile ne démarre pas (dans les logs, erreurs du type : "ImportError: No module named simplejson" ou ImportError: No module named MySQL-python").

Si (comme c'est le cas sur CentOS6 où la version 2.7 n'est pas dans les dépôts, et doit être installée manuellement) les modules nécessaires ne sont pas facilement installables sur la 2.7, il faut forcer la 2.6.

Pour ça, on initialise la variable PYTHON qui, si elle n'est pas vide, empêche les scripts Seafile de chercher plus loin.

Créer /home/seafile/.bash_profile avec :

PYTHON=/usr/bin/python2.6 # le chemin de l'exécutable qu'on souhaite
export PYTHON
 chown seafile.seafile /home/seafile/.bash_profile

Les scripts ne devraient plus chercher Python et démarrer sans problème.

Connexion seahub par Apache

Pour la liaison entre Apache et Seafile, on utilisera Fastcgi. Sur CentOS, à installer des dépôts RPMForge (voir Dépôts complémentaires) :

  yum install --enablerepo=rpmforge mod_fastcgi

Editer /etc/httpd/conf.d/fastcgi.conf, modifier :

 FastCgiWrapper Off

et ajouter à la fin :

 <IfModule mod_fastcgi.c>
     FastCGIExternalServer /var/www/seahub.fcgi -host 127.0.0.1:8000 
 </IfModule>

NOTE : le fichier /var/www/seahub.fcgi n'a pas besoin d'exister, ce n'est qu'un "wrapper" (voir ci-dessous)

Créer un fichier /etc/httpd/conf.d/seafile.conf :

<VirtualHost *:443>
    ServerName seafile.domain.fr
    DocumentRoot /var/www
    Alias /media /home/seafile/seafile-server-latest/seahub/media/           
    RewriteEngine On
    
    # seafile httpserver
    #
    ProxyPass /seafhttp http://127.0.0.1:8082
    ProxyPassReverse /seafhttp http://127.0.0.1:8082
    RewriteRule ^/seafhttp - [QSA,L]
  
    #
    # seahub
    #
    RewriteRule ^/(media.*)$ /$1 [QSA,L,PT]
    RewriteCond %{REQUEST_FILENAME} !-f
    RewriteRule ^(.*)$ /seahub.fcgi$1 [QSA,L,E=HTTP_AUTHORIZATION:%{HTTP:Authorization}]
    
    # add ssl protocol
    SSLEngine On
    SSLOptions +FakeBasicAuth +ExportCertData +StrictRequire
    SSLCertificateFile    /etc/ssl/seafile.crt
    SSLCertificateKeyFile /etc/ssl/seafile.key
</virtualhost>

NOTE : le DocumentRoot doit correspondre au chemin du "wrapper" seahub.fcgi paramétré plus haut !

Dans /home/seafile, éditer ccnet/ccnet.conf, modifier :

 SERVICE_URL = https://seafile.domain.fr

Editer seahub_settings.py, ajouter :

 HTTP_SERVER_ROOT = 'https://seafile.domain.fr/seafhttp'

"HTTP_SERVER_ROOT" peut être aussi "FILE_SERVER_ROOT", indifféremment.

Et pour le service mail (exemple avec serveur mail local) :

EMAIL_USE_TLS = False
EMAIL_HOST = 'localhost'        # smpt server
EMAIL_HOST_USER =     # username and domain
EMAIL_HOST_PASSWORD =     # password
EMAIL_PORT = '25'
DEFAULT_FROM_EMAIL = EMAIL_HOST_USER
SERVER_EMAIL = EMAIL_HOST_USER


Générer des certificats :

  openssl genrsa -out privkey.pem 2048
  openssl req -new -x509 -key privkey.pem -out cacert.pem -days 1095

Copier et renommer les fichiers générés :

  mv cacert.pem /etc/ssl/seafile.crt
  mv privkey.pem /etc/ssl/seafile.key

Si nécessaire, faire une redirection du site HTTP vers HTTPS. A la racine du site HTTP (port 80, qui doit être différente de la racine du site HTTPS), créer un fichier .htaccess :

RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule ^(.*)$ https://seafile.domain.fr/$1 [L,R=301]

Dans /etc/htpd/conf/httpd.conf : s'assurer que la directive "AllowOverride" du site par défaut (sous <Directory /var/www/html>) est à "All".

Supprimer /etc/httpd/conf.d/welcome.conf pour ne pas tomber sur la page de test en cas d'erreur.

Reste à relancer apache

  service httpd restart

NOTE : Vérifier qu'Apache écoute sur le port 443 ! Décommenter "Listen 443" dans /etc/httpd/conf.d/ssl.conf.

Connexion seahub par NGINX

La configuration nginx (https via fastcgi) est enregistrée dans un fichier, chargé ensuite en "include" dans la configuration de nginx :

server {
    listen 192.168.0.50:443;
    ssl on;
    ssl_certificate      /home/seafile/conf/ssl.seafile.domain.fr.pem;
    ssl_certificate_key  /home/seafile/conf/ssl.seafile.domain.fr.key;
    server_name  seafile.domain.fr;
    proxy_set_header X-Forwarded-For $remote_addr;

    add_header Strict-Transport-Security "max-age=31536000; includeSubdomains";
    server_tokens off;

    location / {
        fastcgi_pass    127.0.0.1:8000;
        fastcgi_param   SCRIPT_FILENAME     $document_root$fastcgi_script_name;
        fastcgi_param   PATH_INFO           $fastcgi_script_name;

        fastcgi_param   SERVER_PROTOCOL        $server_protocol;
        fastcgi_param   QUERY_STRING        $query_string;
        fastcgi_param   REQUEST_METHOD      $request_method;
        fastcgi_param   CONTENT_TYPE        $content_type;
        fastcgi_param   CONTENT_LENGTH      $content_length;
        fastcgi_param   SERVER_ADDR         $server_addr;
        fastcgi_param   SERVER_PORT         $server_port;
        fastcgi_param   SERVER_NAME         $server_name;
        fastcgi_param   HTTPS               on;
        fastcgi_param   HTTP_SCHEME         https;

        access_log      /var/log/nginx/seahub.access.log;
        error_log       /var/log/nginx/seahub.error.log;
        fastcgi_read_timeout 36000;
    }
    location /seafhttp {
        rewrite ^/seafhttp(.*)$ $1 break;
        proxy_pass http://127.0.0.1:8082;
        client_max_body_size 0;
        proxy_connect_timeout  36000s;
        proxy_read_timeout  36000s;
        proxy_send_timeout  36000s;
        send_timeout  36000s;
    }
    location /media {
        root /home/seafile/seafile-server-latest/seahub;
    }
}

WebDAV

Pour activer WebDAV (gestion des fichiers via le web) sur Seafile :

  • Editer seafile/conf/seafdav.conf
 [WEBDAV]
 enabled = true
 port = 8080
 fastcgi = true
 share_name = /seafdav
  • Ajouter dans /etc/httpd/conf.d/seafile.conf les lignes suivantes :
 #
 # seafile webdav
 #
 RewriteCond %{HTTP:Authorization} (.+)
 RewriteRule ^(/seafdav.*)$ /seafdav.fcgi$1 [QSA,L,e=HTTP_AUTHORIZATION:%1]
 RewriteRule ^(/seafdav.*)$ /seafdav.fcgi$1 [QSA,L]
  • Ajouter dans /etc/httpd/conf.d/fastcgi.conf la ligne :
 FastCGIExternalServer /var/www/seafdav.fcgi -host 127.0.0.1:8080

Reste à relancer apache et Seafile

  service httpd restart
  service seafile-server restart

La connexion du client DAV se fera sur le dossier "/seafdav".

Memcached

On peut utiliser seafile avec memcached pour accélérer la navigation :

Installation sur centos 6:

  yum install memcached python-memcached

Installation sur centos 5 ; ajouter epel puis :

  yum install --enablerepo=epel memcached
  easy_install-2.6 python-memcached

Ajouter dans seafile/conf/seahub_setting.py :

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
	'LOCATION': '127.0.0.1:11211',
    }
}

Mise à jour

Arrêter seafile et seahub :

  service seafile stop
  service seahub stop

On donne tout de suite les droits à l'utilisateur seafile (important ! si on fait ensuite la mise à jour en tant qu'utilisateur "seafile") :

  chown -R seafile:apache /home/seafile

Passer sous l'utilisateur seafile (préférable, pour éviter les problèmes de version de Python, voir

  su - seafile

Télécharger et installer la mise à jour :

  cd /home/seafile/installed
  wget https://bitbucket.org/haiwen/seafile/downloads/seafile-server_2.1.5_x86-64.tar.gz
  wget https://bitbucket.org/haiwen/seafile/downloads/seafile-server_2.1.5_i386.tar.gz
  tar xvzf  seafile-server_2.1.5_i386.tar.gz
  mv seafile-server-2.1.5 ..

Deux scripts sont disponible en fonction du type de mise à jour :

  • Pour une mise à jour de version principale (1.8 => 2.0 ou 2.0 => 2.1) :
 cd ../seafile-server-2.1.5/upgrade
 ./upgrade_1.8_2.0.sh
  • Pour une simple mise a jour de sous-version (2.1.4 => 2.1.5) :
 cd ../seafile-server-2.1.5/upgrade
 /minor-upgrade.sh

Redevenir "root" et lancer les services seafile et seahub

  service seafile start
  service seahub start

Personnalisation

Mettre l'image ici, avec ce nom exact (sauvegarder éventuellement le seafile_logo.png existant) :

/home/seafile/seafile-server-latest/seahub/media/img/seafile_logo.png

Redémarrer seahub

Traduction

cd /home/seafile/seafile-server-2.1.5/seahub/locale/fr/LC_MESSAGES

Suppression de l'ancienne traduction :

  rm django.po

Télécharger la traduction :

  • depuis le site officiel de traduction :

https://www.transifex.com/organization/haiwen/dashboard/seahub

  • ou depuis le depot git de seahub :

https://github.com/haiwen/seahub/tree/master/locale/fr/LC_MESSAGES

Compiler le fichier de traduction :

  msgfmt -o django.mo -v django.po

Redémarrer seahub

Sauvegarde / restauration

Sauvegarde

Il est préférable d'arrêter les service Seafile avant sauvegarde, afin que celle-ci soit cohérente.

  • Sauvegarder le dossier /home/seafile/ (dans son entier, c'est plus simple)
  • Sauvegarder les 3 bases de données (par mysqldump sous MySQL/MariaDB) : ccnet-db, seafile-db, seahub-db

Restauration

Réinstaller si nécessaire Seafile, puis supprimer (ou renommer en .bak) le dossier /home/seafile.

Après sauvegarde (ou dump) des 3 bases de données (au cas où), les supprimer, et les recréer vides.

Restaurer les 3 bases.

Restaurer le dossier /home/seafile.

Lancer les services Seafile, et faire un check du répertoire (voir ci-dessous)

Réparation

En cas de message d'erreur sur des bibilothèques ("endommagée"), lancer un check :

 cd /home/seafile/seafile-server-latest/
 ./seaf-fsck.sh

Si des bibliothèques apparaissent corrompues et si le script indique "Find available commit xxxxx (created at xxxx-xx-xx xx:xx:xx) for repo xxxxxxx.", copier l'identifiant du dépôt (indiqué sur la ligne "Running fsck for repo xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx") et lancer une réparation :

 cd /home/seafile/seafile-server-latest/
 ./seaf-fsck.sh --repair xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

TIPS

  • Les logs sont visibles dans <racine_du_virtualhost>/seafile/seafile-server-<version>/runtime/
  • changer le mail administrateur : <racine_du_virtualhost>/seafile/seafile-server-<version>/reset_admin.sh
  • administer seafile en ligne de commande : https://github.com/HenriWahl/seafadm
  • backup en utilisant l'api (fichier api.py intéressant) : https://github.com/oal/barch