Unix守护程序服务错误（使用框架模板）。 启动但状态显示它不起作用

Question

在/usr/local/sleep/sleep.py中，我有

#! /usr/bin/env python

import time
time.sleep(10)

我试图用骨架模板启动它

   #! /bin/sh  -x
   ### BEGIN INIT INFO
   # Provides:          skeleton
   # Required-Start:    $remote_fs $syslog
   # Required-Stop:     $remote_fs $syslog
   # Default-Start:     2 3 4 5
   # Default-Stop:      0 1 6
   # Short-Description: Example initscript
   # Description:       This file should be used to construct scripts to be
   #                    placed in /etc/init.d.
   ### END INIT INFO


  # 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=sleep
  DAEMON=/usr/local/sleep/$NAME.py
  DAEMON_ARGS=""
  PIDFILE=/var/run/$NAME.pid
  SCRIPTNAME=/etc/init.d/$NAME

  echo $DAEMON
  echo $SCRIPTNAME
  echo $DAEMON_ARGS

  # 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.2-14) to ensure that this file is present
  # and status_of_proc is working.
  . /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 --pidfile $PIDFILE --exec $DAEMON& --test > /dev/null \
     start-stop-daemon --start --pidfile $PIDFILE --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 --pidfile $PIDFILE --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

: 

它看起来像runnibg sleep.py文件，但当我检查状态时，它没有任何运行。 如何使它正确运行？ 那这是什么

start-stop-daemon --start --quiet --pidfile $PIDFILE --exec $DAEMON& --test > /dev/null \

线是什么意思？ 谢谢

Answer 1

要成为守护程序，进程应具有一些先决条件 。

然后您可以像这里尝试upstart 。