overhauled logging

geocamPycroraptor2/bin/pyraptord.py

@@ -6,88 +6,30 @@
 # __END_LICENSE__
 
 import os
-import logging
-import errno
-import signal
-import time
 
 import zerorpc
 
 from geocamPycroraptor2.manager import Manager
-from geocamPycroraptor2.util import getPid, waitUntilDead
+from geocamPycroraptor2.daemonize import Daemon
 
 
-def getPidForManager(m):
-    return getPid(os.path.join(m._logDir, m._pidFile))
-
-
-def start(m):
-    pid = getPidForManager(m)
-    if pid is None:
-        startInternal(m)
-    else:
-        print 'pyraptord is already running, pid %s' % pid
-
-
-def startInternal(m):
-    print 'starting pyraptord...'
-    m._start()
-    s = zerorpc.Server(m)
-    s.bind(m._port)
-    logging.info('pyraptord: listening on %s', m._port)
-    print 'started'
-    s.run()
-
-
-def stop(m):
-    pid = getPidForManager(m)
-    if pid:
-        print 'stopping pyraptord (first attempt, SIGTERM), pid %s...' % pid
-        os.kill(pid, signal.SIGTERM)
-        isDead = waitUntilDead(pid, timeout=5)
-        if isDead:
-            print 'stopped'
-            return True
-        print 'stopping pyraptord (second attempt, SIGKILL), pid %s...' % pid
-        os.kill(pid, signal.SIGKILL)
-        isDead = waitUntilDead(pid, timeout=5)
-        if isDead:
-            logging.info('stopped')
-            return True
-        print "can't kill running pyraptord, pid %s", pid
-        return False
-    else:
-        print 'pyraptord does not appear to be running'
-        return True
-
-
-def restart(m):
-    print 'restarting pyraptord'
-    isStopped = stop(m)
-    if isStopped:
-        startInternal(m)
-
-
-def status(m):
-    pid = getPidForManager(m)
-    if pid is None:
-        print 'pyraptord is stopped'
-    else:
-        print 'pyraptord is running, pid %s' % pid
-
-
-COMMAND_REGISTRY = {
-    'start': start,
-    'stop': stop,
-    'restart': restart,
-    'status': status
-}
-
-
-def pyraptord(handler, opts):
+def pyraptord(cmd, opts):
     m = Manager(opts)
-    logging.basicConfig(level=logging.DEBUG)
-    handler(m)
+    d = Daemon(opts.name,
+               os.path.join(m._logDir, m._pidFile))
+
+    if cmd in ('start', 'restart'):
+        doStart = d.execute(cmd)
+        if doStart:
+            m._start()
+            s = zerorpc.Server(m)
+            s.bind(m._port)
+            m._logger.info('pyraptord: listening on %s', m._port)
+            m._logger.info('started')
+            d.writePid()
+            s.run()
+    else:
+        d.execute(cmd)
 
 
 def main():
@@ -103,15 +45,17 @@ def main():
                       help='Name of pyraptord zerorpc service [%default]',
                       default='pyraptord')
     opts, args = parser.parse_args()
-    if len(args) != 1:
-        parser.error('expected exactly 1 arg')
+    if len(args) == 0:
+        cmd = 'start'
+    elif len(args) == 1:
+        cmd = args[0]
+    else:
+        parser.error('expected at most 1 command')
 
-    cmd = args[0]
-    handler = COMMAND_REGISTRY.get(cmd)
-    if handler is None:
+    if cmd not in Daemon.COMMANDS:
         parser.error('unknown command "%s"' % cmd)
 
-    pyraptord(handler, opts)
+    pyraptord(cmd, opts)
 
 
 if __name__ == '__main__':

geocamPycroraptor2/daemonize.py

@@ -6,31 +6,35 @@
 
 import os
 import sys
+import signal
 
 from geocamPycroraptor2 import log
+from geocamPycroraptor2.util import getPid, waitUntilDead
 
 
-def daemonize(logPathTemplate, logPathContext, pidPath):
+def cleanIfExists(path):
+    if os.path.exists(path):
+        try:
+            os.unlink(path)
+        except OSError:
+            print 'could not delete file %s', path
+
+
+def daemonize(name, logFile):
     os.chdir('/')
     os.umask(0)
 
     # close stdin
     devNull = file('/dev/null', 'rw')
     os.dup2(devNull.fileno(), 0)
 
-    # redirect stdout and stderr to log file
-    if logPathTemplate == None:
+    print 'log at %s' % logFile.name
+    if logFile is None:
         logFile = devNull
-    else:
-        logName, logFile = (log.openLogFromTemplate
-                            ('pyraptord',
-                             logPathTemplate,
-                             logPathContext))
-    print 'daemonizing  -- log file %s' % logName
     os.dup2(logFile.fileno(), 1)
     os.dup2(logFile.fileno(), 2)
-    sys.stdout = log.StreamLogger('out', sys.stdout)
-    sys.stderr = log.StreamLogger('err', sys.stderr)
+    sys.stdout = log.TimestampingStream('%s.out' % name, sys.stdout)
+    sys.stderr = log.TimestampingStream('%s.err' % name, sys.stderr)
 
     # detach from tty
     pid = os.fork()
@@ -41,11 +45,64 @@ def daemonize(logPathTemplate, logPathContext, pidPath):
     if pid:
         os._exit(0)
 
-    # write pid file
-    if pidPath != None:
-        pidDir = os.path.dirname(pidPath)
-        if not os.path.isdir(pidDir):
-            os.makedirs(pidDir)
-        pidFile = file(pidPath, 'w')
-        pidFile.write('%d\n' % os.getpid())
-        pidFile.close()
+
+class Daemon(object):
+    COMMANDS = ('start', 'stop', 'restart', 'status')
+
+    def __init__(self, name, pidPath):
+        self._name = name
+        self._pidPath = pidPath
+
+    def execute(self, cmd):
+        if cmd in self.COMMANDS:
+            return getattr(self, cmd)()
+
+    def start(self):
+        pid = getPid(self._pidPath)
+        if pid is None:
+            print 'starting %s' % self._name
+            return True
+        else:
+            print '%s is already running, pid %s' % (self._name, pid)
+            return False
+
+    def writePid(self):
+        f = open(self._pidPath, 'w')
+        f.write('%d\n' % os.getpid())
+        f.close()
+
+    def stop(self):
+        pid = getPid(self._pidPath)
+        if pid:
+            print ('stopping %s (first attempt, SIGTERM), pid %s...'
+                   % (self._name, pid))
+            os.kill(pid, signal.SIGTERM)
+            isDead = waitUntilDead(pid, timeout=5)
+            if isDead:
+                print 'stopped'
+                cleanIfExists(self._pidPath)
+                return
+            print ('stopping %s (second attempt, SIGKILL), pid %s...'
+                   % (self._name, pid))
+            os.kill(pid, signal.SIGKILL)
+            isDead = waitUntilDead(pid, timeout=5)
+            if isDead:
+                print 'stopped'
+                cleanIfExists(self._pidPath)
+                return
+            print ("can't kill running %s, pid %s"
+                   % (self._name, pid))
+        else:
+            print '%s does not appear to be running' % self._name
+
+    def restart(self):
+        print 'restarting %s' % self._name
+        self.stop()
+        return self.start()
+
+    def status(self):
+        pid = getPid(self._pidPath)
+        if pid is None:
+            print '%s is stopped' % self._name
+        else:
+            print '%s is running, pid %s' % (self._name, pid)