Obtendo o script de shell para executar como um daemon no CentOS?

8

EDIT: Por alguma razão, metade do meu post foi truncado, não sei o que aconteceu. Vou atualizar em breve e publicarei que é atualizado aqui no topo.

EDIT: Atualizei a postagem novamente. Desculpe pela pergunta incompleta.

EDIT (8:55 PM EST 10/10/2011): Atualizei o arquivo /srv/rhodecode/start.sh como Steven sugeriu, ainda sem alegria. Ele continua travando assim:

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

Atualizei os scripts abaixo para mostrar as alterações.


Eu nunca escrevi um shell ou um script bash na minha vida. Estou tentando instalar o RhodeCode no CentOS, e existem scripts de inicialização para o Debian e o Gentoo, mas não para o RedHat / CentOS, o que é insano para mim. Então, eu preciso escrever um, porque nosso ambiente de servidor está restrito à execução do CentOS 5. A fonte do projeto pode ser encontrada no Bitbucket aqui .

A idéia é executar o RhodeCode com aipo e RabbitMQ. Está tudo escrito em Python e eu tenho o ambiente em seu próprio contêiner virtual separado usando o virtualenv. Eu tive a ideia do script de shell aqui .

Eu criei um usuário do sistema chamado rhodecode e criei o diretório / var / run / rhodecode e ele pertence ao rhodecode. Também criei / var / www / rhodecode em que production.ini reside, bem como /srv/rhodecode/start.sh, que pertence ao rhodecode.

Permissões:

[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

Eu tenho os seguintes scripts bash e shell.

/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

Quando executo sudo /etc/init.d/rhodecode-server starte, em seguida ps -aux | grep paster, consigo ver o paster serve production.inicomando de /srv/rhodecode/start.sh que foi executado e está sendo executado com o ID do usuário do 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

No entanto, nenhum arquivo pid é criado, portanto, não consigo parar o servidor do meu script init. Não sei por que o daemon não está criando o pidfile. O caminho para o arquivo pid é válido e as permissões estão corretas. Pensamentos?

Lester Peabody
fonte
@mailq Atualizei minha pergunta. Por alguma razão, metade da postagem foi truncada ... A questão é por que o daemon não cria um arquivo pid.
Lester Peabody #
A permissão está /var/run/rhodecode/pidcorreta para o usuário com o qual está sendo executado? Nesse caso, a variável está correta ou deveria estar /var/run/rhodecode.pid?
John Gardeniers 10/10
@ John Adicionei uma seção de permissões à minha postagem para listar as permissões em todos os diretórios e arquivos envolvidos neste processo (que eu saiba).
Lester Peabody #
Coloque suas informações de depuração sh -x /etc/init.d/rhodecode-server start?
quanta
daemon --pidfileespecifica apenas onde está o arquivo pid. não funciona no CentOS não parecem ter o necessário --make-pidfileopção
KCD

Respostas:

1

Acho que está com o seu problema /srv/rhodecode/start.sh. No momento, ele está iniciando pastercomo um processo em segundo plano separado e saindo imediatamente. Isso representa um problema para o script init, que espera start.shser o processo daemon de longa execução a ser gerenciado.

Portanto, tente alterar a última linha de /srv/rhodecode/start.shpara ler da seguinte maneira:

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

O uso de execmakes- start.sh se paster , que é daemonizado pelo daemoncomando no script init.

Steven segunda-feira
fonte
Na minha cabeça, eu sabia que esse era exatamente o problema, mas não fazia ideia do que procurar. Tentei paster com e sem o & e obviamente ambas as vezes não obtive resultados. Infelizmente, acabei de chegar do escritório e implementarei essa primeira coisa amanhã de manhã.
Lester Peabody #
Na verdade, eu apenas SSHd e tentei e também não funcionou .. continua travando, vou atualizar minha postagem.
Lester Peabody #
0

Você precisa especificar o local? Você poderia usar a opção --name para dar um nome a ela? Isso criará o PID para você e o limpará quando terminar. Então seria assim:

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

stop_rhodecode () {                                                                                                                                                                                                                          
    daemon --name $NAME --stop                                                                                                                                                           
    RETVAL=&?                                                                                                                                                                                                                                                                                                         
    return $RETVAL                                                                                                                                                                                                                           
}     
Jeffery Smith
fonte
Não há opção como '--stop' ou --name no Centos 6.5
MariuszS 4/14
Também não existe --nameou --stopno Centos 5.
Jim Mitchener