Obtenir un script shell à exécuter en tant que démon sur CentOS?

EDIT: Pour une raison quelconque, la moitié de mon message a été tronquée, je ne sais pas ce qui s'est passé. Je mettrai à jour bientôt et posterai qu'il est mis à jour ici en haut.

EDIT: J'ai à nouveau mis à jour le message, désolé pour la question incomplète.

EDIT (8:55 PM EST 10/10/2011): J'ai mis à jour /srv/rhodecode/start.sh comme Steven l'a suggéré, toujours pas de joie. Il continue de pendre comme ça:

[lpeabody@vcs rhodecode]$ sudo /etc/init.d/rhodecode-server start
Starting rhodecode-server:

J'ai mis à jour les scripts ci-dessous pour montrer les changements.

Je n'ai jamais écrit de shell ou de script bash de ma vie. J'essaie d'installer RhodeCode sur CentOS, et il y a des scripts d'initialisation pour Debian et Gentoo, mais pas pour RedHat / CentOS qui est fou pour moi. J'ai donc besoin d'en écrire un car notre environnement de serveur est limité à l'exécution de CentOS 5. La source du projet se trouve ici sur Bitbucket .

L'idée est d'exécuter RhodeCode avec Celery et RabbitMQ. Tout est écrit en Python et j'ai l'environnement dans son propre conteneur virtuel séparé en utilisant virtualenv. J'ai eu l'idée du script shell ici .

J'ai créé un utilisateur système nommé rhodecode et créé le répertoire / var / run / rhodecode et il appartient à rhodecode. J'ai également créé / var / www / rhodecode où réside production.ini, ainsi que /srv/rhodecode/start.sh, qui appartiennent tous à rhodecode.

Autorisations:

[lpeabody@vcs run]$ ll -a /var/run/rhodecode
total 12
drwxr-xr-x  2 rhodecode rhodecode 4096 Oct 10 15:57 .
drwxr-xr-x 21 root      root      4096 Oct 10 16:07 ..

[lpeabody@vcs run]$ ll -a /var/www/rhodecode
total 76
drwxr-xr-x  4 rhodecode rhodecode  4096 Oct 10 16:47 .
drwxr-xr-x 11 root      root       4096 Oct  5 14:54 ..
drwxrwxr-x  3 rhodecode rhodecode  4096 Oct  5 19:40 data
-rw-r--r--  1 rhodecode rhodecode     0 Oct 10 16:41 debug.log
-rw-r--r--  1 rhodecode rhodecode  1466 Oct 10 16:41 error.log
-rw-rw-r--  1 rhodecode rhodecode  6000 Oct  6 15:27 production.ini
drwxrwxr-x  2 rhodecode rhodecode  4096 Oct  5 18:37 repos
-rw-r--r--  1 rhodecode rhodecode 44032 Oct  5 19:16 rhodecode.db

[lpeabody@vcs run]$ ll -a /srv/rhodecode/
total 16
drwxr-xr-x 2 rhodecode rhodecode 4096 Oct 10 16:40 .
drwxr-xr-x 4 root      root      4096 Oct  7 14:40 ..
-rwxr-xr-x 1 rhodecode rhodecode  277 Oct 10 16:40 start.sh

J'ai les scripts bash et shell suivants.

/srv/rhodecode/start.sh

#!/bin/bash                                                                                               
# run this as the rhodecode user!                                                                         

WDIR=/var/www/rhodecode                                                                                   
VIRTUALENV_DIR=/opt/python_virtualenvironments/rhodecode-venv                                             
export PYTHON_EGG_CACHE=/tmp/.python-eggs                                                                 

source $VIRTUALENV_DIR/bin/activate                                                                       

cd $WDIR                                                                                                  
exec paster serve production.ini 1> debug.log 2> error.log

/etc/init.d/rhodecode-server

#!/bin/sh                                                                                                                                                                                                                                    
#                                                                                                                                                                                                                                            
# rhodecode-server RhodeCode server instance                                                                                                                                                                                                 
#                                                                                                                                                                                                                                            
#                                                                                                                                                                                                                                            

# PATH=/sbin:/usr/sbin:/bin:/usr/bin                                                                                                                                                                                                         
NAME=rhodecode-server                                                                                                                                                                                                                        
DESC=rhodecode-server                                                                                                                                                                                                                        
USER=rhodecode                                                                                                                                                                                                                               
PID_FILE=/var/run/rhodecode/pid                                                                                                                                                                                                              
CMD=/srv/rhodecode/start.sh                                                                                                                                                                                                                  

LOCK_FILE=/var/lock/subsys/$NAME                                                                                                                                                                                                             

. /etc/init.d/functions                                                                                                                                                                                                                      

RETVAL=0                                                                                                                                                                                                                                     

remove_pid () {                                                                                                                                                                                                                              
    rm -f ${PID_FILE}                                                                                                                                                                                                                        
}                                                                                                                                                                                                                                            

start_rhodecode () {                                                                                                                                                                                                                         
    daemon --user $USER --pidfile $PID_FILE $CMD                                                                                                                                                                                        
    RETVAL=$?                                                                                                                                                                                                                                
    [ $RETVAL -eq 0 ] && touch $LOCK_FILE                                                                                                                                                                                                    
    return $RETVAL                                                                                                                                                                                                                           
}                                                                                                                                                                                                                                            

stop_rhodecode () {                                                                                                                                                                                                                          
    killproc -p $PID_FILE                                                                                                                                                                                                                    
    RETVAL=&?                                                                                                                                                                                                                                
    rm -f $LOCK_FILE                                                                                                                                                                                                                         
    rm -f $PID_FILE                                                                                                                                                                                                                          
    return $RETVAL                                                                                                                                                                                                                           
}                                                                                                                                                                                                                                            

restart_rhodecode () {                                                                                                                                                                                                                       
    stop_rhodecode                                                                                                                                                                                                                           
    start_rhodecode                                                                                                                                                                                                                          
    RETVAL=$?                                                                                                                                                                                                                                
}                                                                                                                                                                                                                                            

case "$1" in                                                                                                                                                                                                                                 
  start)                                                                                                                                                                                                                                     
    echo -n $"Starting $DESC: "                                                                                                                                                                                                              
    start_rhodecode                                                                                                                                                                                                                          
    echo                                                                                                                                                                                                                                     
    ;;                                                                                                                                                                                                                                       
  stop)                                                                                                                                                                                                                                      
    echo -n $"Stopping $DESC: "                                                                                                                                                                                                              
    stop_rhodecode                                                                                                                                                                                                                           
    echo                                                                                                                                                                                                                                     
    ;;                                                                                                                                                                                                                                       
  restart)                                                                                                                                                                                                                                   
    echo -n $"Restarting $DESC: "                                                                                                                                                                                                            
    restart_rhodecode                                                                                                                                                                                                                        
    echo                                                                                                                                                                                                                                     
    ;;
  *)                                                                                                                                                                                                                                         
    echo $"Usage: $0 {start|stop|restart}"                                                                                                                                                                                                   
    RETVAL=1                                                                                                                                                                                                                                 
    ;;                                                                                                                                                                                                                                       
esac                                                                                                                                                                                                                                         

exit $RETVAL

Lorsque j'exécute sudo /etc/init.d/rhodecode-server startpuis exécute ps -aux | grep paster, je peux voir la paster serve production.inicommande de /srv/rhodecode/start.sh passée et s'exécutant avec l'ID utilisateur de rhodecode (102).

102       5222  0.7  7.8 144300 80988 ?        Sl   16:08   0:00 /opt/python_virtualenvironments/rhodecode-venv/bin/python /opt/python_virtualenvironments/rhodecode-venv/bin/paster serve production.ini

Cependant, aucun fichier pid n'est créé, donc je ne peux pas arrêter le serveur de mon script init. Je ne sais pas pourquoi le démon ne crée pas le fichier pid. Le chemin d'accès au fichier pid est valide et les autorisations sont correctes. Pensées?

Je pense que votre problème est là /srv/rhodecode/start.sh. Il démarre actuellement en pastertant que processus d'arrière-plan distinct, puis se termine immédiatement. Cela pose un problème pour votre script init, qui s'attend start.shà être lui-même le processus démon de longue durée à gérer.

Par conséquent, essayez de modifier la dernière ligne de /srv/rhodecode/start.shpour lire comme suit:

exec paster serve production.ini 1> debug.log 2> error.log

Utilisation de execmarques start.sh deviennent paster , qui est daemon puis par la daemoncommande dans le script d'initialisation.

Devez-vous spécifier l'emplacement? Pourriez-vous utiliser l'option --name pour lui donner un nom? Cela créera le PID pour vous et le nettoiera lorsque vous aurez terminé. Cela ressemblerait donc à:

$NAME="rhodecode"
start_rhodecode () {                                                                                                                                                                                                                         
    daemon --user $USER --name $NAME $CMD                                                                                                                                                                                        
    RETVAL=$?                                                                                                                                                                                                                                
    return $RETVAL                                                                                                                                                                                                                           
} 

stop_rhodecode () {                                                                                                                                                                                                                          
    daemon --name $NAME --stop                                                                                                                                                           
    RETVAL=&?                                                                                                                                                                                                                                                                                                         
    return $RETVAL                                                                                                                                                                                                                           
}