Successo con start-stop-daemon e mono-service2?

Question

Qualcuno ha avuto successo usando start-stop-daemon e mono-service2 insieme? L'ho combattuto per alcuni giorni e ho ottenuto vari bit per funzionare, ma non ho avuto successo nell'ottenere uno script init completamente funzionale per un servizio mono.

Ecco quello che ho imparato fino ad oggi:

1. Il mono o mono-servizio exe deve essere chiamato come il demone variabili (non è possibile elencare il vostro exe come il demone)

2. È necessario utilizzare il flag --background ... altrimenti quando questo script viene eseguito da un programma di installazione del pacchetto (deb nel mio caso). Il servizio termina quando termina il programma di installazione (ha a che fare con il modo in cui i fork dei programmi di installazione vengono elaborati ... Non ho indagato più di tanto).

3. Ho avuto successo elencando il file pid con il flag mono-service in altri script e usandolo per fermare il daemon, ma per qualche motivo non funziona qui. Di conseguenza, lo script qui sotto non interrompe il servizio, non so perché. Inizia funziona bene.

E qui è il mio script di init parzialmente funzionanti:

#! /bin/sh 
### BEGIN INIT INFO 
# Provides:   ServiceName 
# Required-Start: $remote_fs $syslog 
# Required-Stop:  $remote_fs $syslog 
# Default-Start:  2 3 4 5 
# Default-Stop:  0 1 6 
# Short-Description: Starts and Stops Service 
# Description:  Service start|stop|restart 
### END INIT INFO 

# Author: Author 
# 

# Do NOT "set -e" 

# PATH should only include /usr/* if it runs after the mountnfs.sh script 
PATH=/sbin:/usr/sbin:/bin:/usr/bin 
DESC="Description of the service" 
NAME=Service.exe 
DAEMONNAME=ServiceDaemon.sh 
INSTALLDIR=/usr/sbin/ 
DAEMON=/usr/bin/mono-service2 
EXENAME=Service.exe 
PIDFILE=/var/run/$DAEMONNAME.pid 
DAEMON_ARGS=" -l:$PIDFILE $INSTALLDIR/$EXENAME" 
#DAEMON_ARGS=" $INSTALLDIR/$EXENAME" 
SCRIPTNAME=/etc/init.d/$DAEMONNAME 

# Exit if the package is not installed 
[ -x "$DAEMON" ] || exit 0 

# Read configuration variable file if it is present 
[ -r /etc/default/$NAME ] && . /etc/default/$NAME 

# Load the VERBOSE setting and other rcS variables 
. /lib/init/vars.sh 

# Define LSB log_* functions. 
# Depend on lsb-base (>= 3.0-6) to ensure that this file is present. 
. /lib/lsb/init-functions 

# 
# Function that starts the daemon/service 
# 
do_start() 
{ 
# Return 
# 0 if daemon has been started 
# 1 if daemon was already running 
# 2 if daemon could not be started 
start-stop-daemon --start --quiet --background --exec $DAEMON --test > /dev/null \ 
    || return 1 
start-stop-daemon --start --quiet --background --exec $DAEMON -- \ 
    $DAEMON_ARGS \ 
    || return 2 
# Add code here, if necessary, that waits for the process to be ready 
# to handle requests from services started subsequently which depend 
# on this one. As a last resort, sleep for some time. 
} 

# 
# Function that stops the daemon/service 
# 
do_stop() 
{ 
# Return 
# 0 if daemon has been stopped 
# 1 if daemon was already stopped 
# 2 if daemon could not be stopped 
# other if a failure occurred 
start-stop-daemon --stop --quiet --retry=TERM/30/KILL/5 --name $NAME 
RETVAL="$?" 
[ "$RETVAL" = 2 ] && return 2 
# Wait for children to finish too if this is a daemon that forks 
# and if the daemon is only ever run from this initscript. 
# If the above conditions are not satisfied then add some other code 
# that waits for the process to drop all resources that could be 
# needed by services started subsequently. A last resort is to 
# sleep for some time. 
start-stop-daemon --stop --quiet --oknodo --retry=0/30/KILL/5 --exec $DAEMON 
[ "$?" = 2 ] && return 2 
# Many daemons don't delete their pidfiles when they exit. 
rm -f $PIDFILE 
return "$RETVAL" 
} 

# 
# Function that sends a SIGHUP to the daemon/service 
# 
do_reload() { 
# 
# If the daemon can reload its configuration without 
# restarting (for example, when it is sent a SIGHUP), 
# then implement that here. 
# 
start-stop-daemon --stop --signal 1 --quiet --pidfile $PIDFILE --name $NAME 
return 0 
} 

case "$1" in 
    start) 
[ "$VERBOSE" != no ] && log_daemon_msg "Starting $DESC" "$NAME" 
do_start 
case "$?" in 
    0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;; 
    2) [ "$VERBOSE" != no ] && log_end_msg 1 ;; 
esac 
;; 
    stop) 
[ "$VERBOSE" != no ] && log_daemon_msg "Stopping $DESC" "$NAME" 
do_stop 
case "$?" in 
    0|1) [ "$VERBOSE" != no ] && log_end_msg 0 ;; 
    2) [ "$VERBOSE" != no ] && log_end_msg 1 ;; 
esac 
;; 
    status) 
     status_of_proc "$DAEMON" "$NAME" && exit 0 || exit $? 
     ;; 
    #reload|force-reload) 
# 
# If do_reload() is not implemented then leave this commented out 
# and leave 'force-reload' as an alias for 'restart'. 
# 
#log_daemon_msg "Reloading $DESC" "$NAME" 
#do_reload 
#log_end_msg $? 
#;; 
    restart|force-reload) 
# 
# If the "reload" option is implemented then remove the 
# 'force-reload' alias 
# 
log_daemon_msg "Restarting $DESC" "$NAME" 
do_stop 
case "$?" in 
    0|1) 
    do_start 
    case "$?" in 
    0) log_end_msg 0 ;; 
    1) log_end_msg 1 ;; # Old process is still running 
    *) log_end_msg 1 ;; # Failed to start 
    esac 
    ;; 
    *) 
    # Failed to stop 
    log_end_msg 1 
    ;; 
esac 
;; 
    *) 
#echo "Usage: $SCRIPTNAME {start|stop|restart|reload|force-reload}" >&2 
echo "Usage: $SCRIPTNAME {start|stop|status|restart|force-reload}" >&2 
exit 3 
;; 
esac 

: 

Answer 1

Abbiamo avuto un sacco di problemi con il mono-service e ha finito per implementare il nostro codice "servizio" nella nostra applicazione. Niente di difficile, basta afferrare alcuni segnali:

UnixSignal intr = new UnixSignal (Signum.SIGINT); 
UnixSignal term = new UnixSignal (Signum.SIGTERM); 
UnixSignal hup = new UnixSignal (Signum.SIGHUP); 
UnixSignal usr2 = new UnixSignal (Signum.SIGUSR2); 

UnixSignal[] signals = new UnixSignal[] { intr, term, hup, usr2 }; 

for (bool running = true; running;) 
{ 
    int idx = UnixSignal.WaitAny(signals); 

    if (idx < 0 || idx >= signals.Length) continue; 

    log.Debug("daemon: received signal " + signals[idx].Signum.ToString()); 

    if ((intr.IsSet || term.IsSet)) 
    { 
     intr.Reset(); 
     term.Reset(); 

     log.Debug("daemon: stopping..."); 

     running = false; 
    } 
    else if (hup.IsSet) 
    { 
     // Ignore. Could be used to reload configuration. 
     hup.Reset(); 
    } 
    else if (usr2.IsSet) 
    { 
     usr2.Reset(); 
     // do something 
    } 
} 

Answer 2

ho ottenuto questo script di lavoro con un paio di piccole modifiche:

• A pidfile in/var/run funziona solo se si esegue come utente root - se si tenta di eseguire lo script senza sudo, il mono-servizio fallirà silenziosamente.

• Utilizzare --pidfile anziché --name per trovare il servizio da interrompere.

Answer 3

So che questa domanda è vecchia ma non ci sono risposte accettate. Ho continuato a lavorarci su per un po 'e ho trovato uno script daemon che ha funzionato come un incantesimo per me. Ho bloggato su di esso qui: http://www.geekytidbits.com/start-stop-daemon-with-mono-service2/

Answer 4

do_stop() 
{ 

test -f $PIDFILE && kill `cat $PIDFILE` && return 2 

start-stop-daemon --stop --quiet --verbose --oknodo --retry=0/30/KILL/5\ 

--exec mono-service2 

[ "$?" = 2 ] && return 2 

# Many daemons don't delete their pidfiles when they exit. 

rm -f $PIDFILE 

return "$RETVAL" 

} 

quindi funziona, penso che solo perché non si può fermare un processo mediante il comando "start-stop-daemon" Sto imparando a usare mono ora, il tuo invito mi aiuta molto. Grazie. il mio inglese è povero, perdona il mio inglese cotto a metà.