Shell-Skript als Daemon unter CentOS ausführen lassen?

EDIT: Aus irgendeinem Grund wurde die Hälfte meines Beitrags abgeschnitten, nicht sicher, was passiert ist. Ich werde bald aktualisieren und veröffentlichen, dass es hier oben aktualisiert wird.

EDIT: Ich habe den Beitrag erneut aktualisiert, entschuldige die unvollständige Frage.

BEARBEITEN (20:55 EST 10.10.2011): Ich habe /srv/rhodecode/start.sh aktualisiert, wie Steven vorgeschlagen hat, immer noch keine Freude. Es hängt weiter so:

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

Ich habe die folgenden Skripte aktualisiert, um die Änderungen anzuzeigen.

Ich habe noch nie in meinem Leben eine Shell oder ein Bash-Skript geschrieben. Ich versuche, RhodeCode unter CentOS zu installieren, und es gibt Init-Skripte für Debian und Gentoo, aber nicht für RedHat / CentOS, was für mich verrückt ist. Also habe ich ein , weil unsere Server - Umgebung bei Bitbucket gefunden werden kann CentOS 5. Die Quelle für das Projekt läuft schreiben müssen , beschränkt sich hier .

Die Idee ist, RhodeCode mit Sellerie und RabbitMQ auszuführen. Es ist alles in Python geschrieben und ich habe die Umgebung in einem eigenen virtuellen Container mit virtualenv. Ich habe die Idee für den Shell - Skript hier .

Ich habe einen Systembenutzer namens rhodecode erstellt und das Verzeichnis / var / run / rhodecode erstellt, das Rhodecode gehört. Ich habe auch / var / www / rhodecode erstellt, in dem sich product.ini befindet, sowie /srv/rhodecode/start.sh, die alle im Besitz von rhodecode sind.

Berechtigungen:

[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

Ich habe die folgenden Bash- und Shell-Skripte.

/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

Wenn ich starte sudo /etc/init.d/rhodecode-server startund dann starte ps -aux | grep paster, kann ich sehen, dass der paster serve production.iniBefehl aus /srv/rhodecode/start.sh durchlaufen wurde und mit der Benutzer-ID von rhodecode (102) ausgeführt wird.

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

Es wird jedoch keine PID-Datei erstellt, sodass ich den Server nicht über mein Init-Skript stoppen kann. Ich bin nicht sicher, warum der Daemon die PID-Datei nicht erstellt. Der Pfad zur PID-Datei ist gültig und die Berechtigungen sind korrekt. Gedanken?

Ich denke dein Problem ist in /srv/rhodecode/start.sh. Es wird derzeit pasterals separater Hintergrundprozess gestartet und sofort beendet. Dies stellt ein Problem für Ihr Init-Skript dar, das davon ausgeht, dass start.shes sich um den lang laufenden Daemon-Prozess handelt, der verwaltet werden muss.

Versuchen Sie daher, die letzte Zeile /srv/rhodecode/start.shwie folgt zu ändern :

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

Die Verwendung von execmake start.sh wird paster , die dann durch den daemonBefehl im Init-Skript dämonisiert wird.

Müssen Sie den Ort angeben? Könnten Sie die Option --name verwenden, um ihm einen Namen zu geben? Dadurch wird die PID für Sie erstellt und bereinigt, wenn Sie fertig sind. So würde es aussehen:

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

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