peerflix-server
Sommaire :
0. Pré-requis
1. Installation de Peerflix-server
2. Configuration de peerflix-server
3. Installation en tant que service
4. Création du vhost Nginx
5. Goodies
Salut !

Peerflix-server permet de télécharger des torrent et de les regarder en streaming avant même que leur téléchargement ne soit achevé. Il s'agit en fait d'une GUI pour torrent-stream, puissant client torrent en nodejs.

On va donc l'installer, le paramétrer en tant que daemon et créer un vhost Nginx afin d'avoir une URL propre.

0. Pré-requis :
Etre root
Avoir un serveur nginx fonctionnel
Avoir installé node-js : 
apt-get install nodejs
1. Installation de peerflix-server

L'installation est simplissime :
npm install -g peerflix-server
Une fois que c'est fait, 
peerflix-server
Le serveur se lance, pour l'instant pas en tant que daemon. On vérifie qu'il soit bien en écoute sur le port 9000 : 
netstat -lptn |grep node
NOTE : Attention car c'est le port par défaut de php-fpm si vous ne l'utilisez par sur un socket unix. Cette option n'étant pas paramétrable pour peerflix-server, dans notre cas il faudra modifier la config de php-fpm si il y a conflit.
On vérifie sur http://adresse_ip:9000 qu'on a bien l'interface. Puis Ctrl-C pour terminer la tâche.

2. Configuration

Pour la configuration on crée le fichier suivant : 
nano /root/.config/peerflix-server/config.json
Voici les options configurables :
{
    connections: 100,     // Nombre maximum de peers auquel se connecter
    uploads: 10,          // Nombre de slots d'envoi.
    tmp: '/tmp',          //Dossier de stockage temporaire. Les fichiers .torrents y seront placés sous ./torrent-stream.
    path: '/tmp/my-files', // Endroit ou sauvegarder les médias téléchargés.
    verify: true,         // Vérifier les données précédemment téléchargées, au démarrage du serveur. (true par défaut)
                          
    dht: true,            // Utiliser ou non les DHT. true par défaut, conseillé pour meilleure efficacité du streaming.
                          
    tracker: true,        // Utiliser ou non le tracker qui figure dans letorrent ajouté
                           // Defaults to true
    trackers: [
        'udp://tracker.openbittorrent.com:80',
        'udp://tracker.ccc.de:80'
    ],
                          // Possibilité d'utiliser des trackers personnalisés.
                          // Vide par défaut.
}
3. Installation en tant que service

Pour pouvoir utiliser peerflix-server en tant que démon on installe forever :
npm install -g forever
Une fois que c'est fait, la commande pour démarrer notre démon :
forever start /usr/bin/peerflix-server
Pour l'arrêter : 
forever stop /urs/bin/peerflix-server
On va créer un script init.d histoire de simplifier tout ça et d'avoir un log dans /var/log :
cd /etc/init.d
touch peerflix-server
chmod +x peerflix-server
nano peerflix-server
Et on colle :
#!/bin/bash
### BEGIN INIT INFO
# Provides:          /usr/bin/peerflix-server
# Required-Start:    $remote_fs $syslog
# Required-Stop:     $remote_fs $syslog
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: forever running /usr/bin/peerflix-server
# Description:       /usr/bin/peerflix-server
### END INIT INFO
#
# initd a node app
# Based on a script posted by https://gist.github.com/jinze at https://gist.github.com/3748766
#

# Source function library.
. /lib/lsb/init-functions

sourceDir="/usr/bin" ## Editez cette ligne pour indiquer le chemin de vos applications nodejs (typiquement /usr/bin ou /usr/local/bin/)
pidFile="/var/run/peerflix-server.pid"
logFile="/var/log/peerflix-server.log"
command="$sourceDir/node"
nodeApp="$sourceDir/peerflix-server"
foreverApp="$sourceDir/forever"
export NODE_PATH=$NODE_PATH:/usr/lib/node_modules

start() {
        echo "Starting $nodeApp"

        # Notice that we change the PATH because on reboot
   # the PATH does not include the path to node.
   # Launching forever with a full path
   # does not work unless we set the PATH.
   PATH=/usr/bin:$PATH
        export NODE_ENV=production

   $foreverApp start --pidFile $pidFile -l $logFile -a -v -d  -c $command $nodeApp
   RETVAL=$?
}

restart() {
        echo -n "Restarting $nodeApp"
        $foreverApp restart $nodeApp
        RETVAL=$?
}

stop() {
        echo -n "Shutting down $nodeApp"
   $foreverApp stop $nodeApp
   RETVAL=$?
}

status() {
   echo -n "Status $nodeApp"
   $foreverApp list
   RETVAL=$?
}

case "$1" in
   start)
        start
        ;;
    stop)
        stop
        ;;
   status)
        status
       ;;
   restart)
        restart
        ;;
        *)
       echo "Usage:  {start|stop|status|restart}"
       exit 1
        ;;
esac
exit $RETVAL
Note : modifiez le chemin vers les binaires si toutefois sur votre installation il n'était pas sous /usr/bin. Pour le trouver facilement : cd / && find -name peerflix-server
On ajoute le script au démarrage automatique :
update-rc.d peerflix-server defaults
Avant de pouvoir lancer le serveur on va devoir modifier un fichier car il y a un bug, lorsque forever lance peerflix-server depuis un script init.d.
nano /usr/lib/node_modules/peerflix-server/server/store.js
trouver : 
homePath = process.env[(process.platform === 'win32') ? 'USERPROFILE' : 'HOME'],
et remplacer par : 
homePath = '/root',
On peut lancer peerflix server :
service peerflix-server start
On vérifie les logs : 
tail -f /var/log/peerflix-server.log
[h]
4. Vhost pour nginx[/h]

On va maintenant créer un vhost pour nginx histoire d'avoir une adresse de connexion du style https://stream.domaine.tld :
nano /etc/nginx/sites-available/stream.conf
et on colle :
server {
        listen 80;
        server_name stream.domain.tld;
        return 301 https://stream.domain.tld$request_uri;
}

server {
        listen 443 ssl;
        server_name stream.domain.tld;
        add_header Strict-Transport-Security max-age=2592000;
        server_tokens off;

        ssl on;
        ssl_certificate /chemin/vers/le/certificat.crt;
        ssl_certificate_key /chemin/vers/la/clé.key;
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
        ssl_prefer_server_ciphers on;
        ssl_session_timeout 5m;
        ssl_session_cache builtin:1000 shared:SSL:10m;
        ssl_ciphers "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE ECDSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES128-SHA256:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA384:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES128-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA256:DHE-DSS-AES256-SHA:DHE-RSA-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:!aNULL:!eNULL:!LOW:!3DES:!MD5:!EXP:!PSK:!SRP:!DSS:!RC4";
        ssl_dhparam /chemin/vers/dhparam.key;
        ssl_ecdh_curve secp521r1; # NIST P-521





        location / {
                proxy_pass http://localhost:9000;
                proxy_http_version 1.1;
                # Pour protéger la page et la réserver aux utilisateurs des seedbox :
                auth_basic "streaming";
                auth_basic_user_file "/etc/nginx/passwd/rutorrent_passwd";
        }

        location /socket.io/ {
                proxy_pass http://localhost:9000/socket.io/;
                proxy_http_version 1.1;
                proxy_set_header Upgrade $http_upgrade;
                proxy_set_header Connection "upgrade";
        }
}
NOTE : On a mis une authentification basée sur les utilisateurs des seedbox du système.
On active notre vhost et on redémarre :
ln -s /etc/nginx/sites-available/stream.conf /etc/nginx/sites-enabled/stream.conf
service nginx restart
5. Goodies : Partager les torrents téléchargés avec peerflix-server dans le home des utilisateurs de seedbox

On va créer un dossier partagé par tous les utilisateurs de nos seedbox. Ainsi quand un média sera téléchargé grace à peerflix-server il sera disponible pour nos utilisateurs s'ils veulent le récupérer par ftp ou le regarder dans leur cakebox par exemple.
mkdir /home/shared
chmod 775 /home/shared
On modifie la configuration de peerflix-server : 
nano /root/.config/peerflix-server/config.json
# Chercher :
path: '/tmp/my-files',
# Remplacer par :
path: '/home/shared',
Puis on crée un lien symbolique vers les dossiers utilisateurs :
ln -s /home/shared /home/user1/torrents
ln -s /home/shared /home/user2/torrents
# etc...

On redémarre peerflix-server :
service peerflix-server restart
Il ne reste plus qu'à vous connecter sur votre site à l'adresse http://stream.domain.tld
NOTE :
- Les torrents ou magnets que vous ajoutez vont commencer à être téléchargés soit quand vous commencez le streaming, ou alors soit quand vous cochez la case de sélection.
- Les torrents restent en seed tant qu'ils ne sont pas effacés de l'interface de peerflix-server.
- Plus il y aura de seeders, plus le streaming sera efficace.
Enfin, pour les discussions et commentaires, ça se passe ici : [Discussion]Peerflix-Server : installation, configuration, vhost nginx
Répondre…