A daemon process class in python

In everbright task schedule project, we need some daemon process to do certain work, here is a example of daemon class:

 #encoding=utf-8
 #!/usr/bin/env python

 import sys, os, time, atexit
 from signal import SIGTERM
 Basedir='/home/ronglian/project/taskschedule'
 class Daemon:
     """
     A generic daemon class.

     Usage: subclass the Daemon class and override the run() method
     """
     def __init__(self, pidfile, stderr=Basedir+'/logs/deamon_err.log', stdout=Basedir+'/logs/deamon_out.log', stdin='/dev/null'):
         self.stdin = stdin
         self.stdout = stdout
         self.stderr = stderr
         self.pidfile = pidfile

     def daemonize(self):
         """
         do the UNIX double-fork magic, see Stevens' "Advanced
         Programming in the UNIX Environment" for details (ISBN 0201563177)
         http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
         """
         try:
             pid = os.fork()
             if pid > 0:
                 # exit first parent
                 sys.exit(0)
         except OSError, e:
             sys.stderr.write("fork #1 failed: %d (%s)\n" % (e.errno, e.strerror))
             sys.exit(1)

         # decouple from parent environment
         os.chdir("/")
         os.setsid()
         os.umask(0) 

         # do second fork
         try:
             pid = os.fork()
             if pid > 0:
                 # exit from second parent
                 sys.exit(0)
         except OSError, e:
             sys.stderr.write("fork #2 failed: %d (%s)\n" % (e.errno, e.strerror))
             sys.exit(1) 

         # redirect standard file descriptors
         sys.stdout.flush()
         sys.stderr.flush()
         si = file(self.stdin, 'r')
         so = file(self.stdout, 'a+')
         se = file(self.stderr, 'a+', 0)
         os.dup2(si.fileno(), sys.stdin.fileno())
         os.dup2(so.fileno(), sys.stdout.fileno())
         os.dup2(se.fileno(), sys.stderr.fileno())

         # write pidfile
         atexit.register(self.delpid)
         pid = str(os.getpid())
         file(self.pidfile,'w+').write("%s\n" % pid)

     def delpid(self):
         os.remove(self.pidfile)

     def start(self):
         """
         Start the daemon
         """
         # Check for a pidfile to see if the daemon already runs
         try:
             pf = file(self.pidfile,'r')
             pid = int(pf.read().strip())
             pf.close()
         except IOError:
             pid = None

         if pid:
             message = "pidfile %s already exist. Daemon already running?\n"
             sys.stderr.write(message % self.pidfile)
             sys.exit(1)

         # Start the daemon
         self.daemonize()
         self.run()

     def stop(self):
         """
         Stop the daemon
         """
         # Get the pid from the pidfile
         try:
             pf = file(self.pidfile,'r')
             pid = int(pf.read().strip())
             pf.close()
         except IOError:
             pid = None

         if not pid:
             message = "pidfile %s does not exist. Daemon not running?\n"
             sys.stderr.write(message % self.pidfile)
             return # not an error in a restart

         # Try killing the daemon process
         try:
             while 1:
                 os.kill(pid, SIGTERM)
                 time.sleep(0.1)
         except OSError, err:
             err = str(err)
             if err.find("No such process") > 0:
                 if os.path.exists(self.pidfile):
                     os.remove(self.pidfile)
             else:
                 print str(err)
                 sys.exit(1)

     def restart(self):
         """
         Restart the daemon
         """
         self.stop()
         self.start()

     def run(self):
         """
         You should override this method when you subclass Daemon. It will be called after the process has been
         daemonized by start() or restart().
         """

Here is a example how to use the class, need to rewrite the run function in parent calss:

 #encoding=utf-8

 import sys, time
 from daemon import Daemon
 import dbaction
 import Task
 import getdependency
 from  tslogging import GlobalLogging as Logging

 class sys_sync_task_mgr(Daemon):
     def __init__(self,temppath,starttime,frequency):
         Daemon.__init__(self,temppath)
         self.starttime = starttime
         self.frequency = frequency

     def run(self):

         while True:
             tasknolist= self.get_task_list()

             if len(tasknolist['sys_task']) > 0:
                 if time.ctime()>self.starttime:
                     Logging.getLog().info('Available system task list:%s'%(str(tasknolist['sys_task'])))
                     try:
                         for taskno in tasknolist['sys_task']:
                             Logging.getLog().info('Start running system task:%s'%str(taskno))
                             task = Task.sys_sync_task(taskno)
                             task.task_run()
                     except Exception, ex:
                         print 'hello'
                         Logging.getLog().error( "Exception in class: 'sys_sync_task_mgr' function:'run' :"+str(ex))
                 else:
                     print 'hello'
                     Logging.getLog().warn('Time to run the tasks still not reach.')
             time.sleep(self.frequency)
     def get_task_list(self):
         tasklist = getdependency.task_dependency([],3,1).get_executable_task()
         return tasklist

 #main function
 if __name__ == "__main__":
     daemon = sys_sync_task_mgr('/tmp/daemon_sys_sync_task_mgr.pid',time.ctime(),20)
     if len(sys.argv) == 2:
         if 'start' == sys.argv[1]:
             daemon.start()
         elif 'stop' == sys.argv[1]:
             daemon.stop()
         elif 'restart' == sys.argv[1]:
             daemon.restart()
         else:
             print "Unknown command"
             sys.exit(2)
         sys.exit(0)
     else:
         print "usage: %s start|stop|restart" % sys.argv[0]
         sys.exit(2)