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

8

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?

Lester Peabody
la source
@mailq J'ai mis à jour ma question. Pour une raison quelconque, la moitié du message a été tronquée ... La question est de savoir pourquoi le démon ne crée pas de fichier pid.
Lester Peabody
Les autorisations sont-elles /var/run/rhodecode/pidcorrectes pour l'utilisateur sous lequel il s'exécute? D'ailleurs, cette variable est-elle correcte ou devrait-elle l'être /var/run/rhodecode.pid?
John Gardeniers
@John J'ai ajouté une section d'autorisations à mon message pour répertorier les autorisations sur tous les répertoires et fichiers impliqués dans ce processus (à ma connaissance).
Lester Peabody,
Veuillez joindre vos informations de débogage sh -x /etc/init.d/rhodecode-server start?
quanta
daemon --pidfilespécifie uniquement l'emplacement du fichier pid. les fonctions dans CentOS ne semblent pas avoir l' --make-pidfileoption requise
KCD

Réponses:

1

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.

Steven Monday
la source
Dans mon esprit, je savais que c'était exactement le problème, je n'avais aucune idée de ce qu'il fallait rechercher. J'ai essayé le pasteur avec et sans le & et évidemment les deux fois je n'ai eu aucun résultat. Malheureusement, je viens de rentrer du bureau, je vais mettre en œuvre cette première chose demain matin.
Lester Peabody
En fait, je viens de SSHd et l'ai essayé et cela n'a pas fonctionné non plus .. il continue de se bloquer, je mettrai à jour mon message.
Lester Peabody
0

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                                                                                                                                                                                                                           
}     
Jeffery Smith
la source
Il n'y a pas d'option comme '--stop' ou --name dans Centos 6.5
MariuszS
Il n'y en a pas --nameou --stopdans Centos 5 non plus.
Jim Mitchener