[Zodb-checkins] CVS: ZODB3/zdaemon - zdctl.py:1.2

Guido van Rossum guido@python.org
Mon, 25 Nov 2002 14:58:33 -0500


Update of /cvs-repository/ZODB3/zdaemon
In directory cvs.zope.org:/tmp/cvs-serv8289

Modified Files:
	zdctl.py 
Log Message:
Make it a lot more real.  There's help, a config file, more actions,
etc.

Still needed: more actions (e.g. "debug", "logtail"); kill the daemon
manager more often (?); abbreviated commands; config params to pass
more options to zdaemon; user testing.


=== ZODB3/zdaemon/zdctl.py 1.1 => 1.2 ===
--- ZODB3/zdaemon/zdctl.py:1.1	Mon Nov 25 08:18:22 2002
+++ ZODB3/zdaemon/zdctl.py	Mon Nov 25 14:58:33 2002
@@ -1,9 +1,29 @@
 #! /usr/bin/env python
+##############################################################################
+#
+# Copyright (c) 2001, 2002 Zope Corporation and Contributors.
+# All Rights Reserved.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""zdctl -- control an application run by zdaemon.
+
+Usage: python zdctl.py -C config-file [action [arguments]]
+
+Options:
+-C/--configuration URL -- configuration file or URL
+action [arguments] -- see below
 
-"""
-zdctl -- control an application run by zdaemon.
+If no action is specified on the command line, a "shell" interpreting
+actions typed interactively is started.
 
-Usage: python zdctl.py config-file [command [arguments]]
+Use the action "help" to find out about available actions.
 """
 
 import os
@@ -11,26 +31,81 @@
 import cmd
 import sys
 import time
+import signal
 import socket
 
+if __name__ == "__main__":
+    # Add the parent of the script directory to the module search path
+    from os.path import dirname, abspath, normpath
+    sys.path.append(dirname(dirname(normpath(abspath(sys.argv[0])))))
+
+from ZEO.runsvr import Options
+
+
+class ZDOptions(Options):
+
+    # Where's python?
+    python = sys.executable
+
+    # Where's zdaemon?
+    if __name__ == "__main__":
+        _file = __file__
+    else:
+        _file = sys.argv[0]
+    _file = os.path.normpath(os.path.abspath(_file))
+    _dir = os.path.dirname(_file)
+    zdaemon = os.path.join(_dir, "zdaemon.py")
+
+    # Options for zdaemon
+    backofflimit = 10                   # -b SECONDS
+    forever = 0                         # -f
+    sockname = os.path.abspath("zdsock") # -s SOCKET
+    exitcodes = [0, 2]                  # -x LIST
+    user = None                         # -u USER
+    zdirectory = "/"                    # -z DIRECTORY
+
+    # Program (and arguments) for zdaemon
+    program = None
+
+    def load_configuration(self):
+        Options.load_configuration(self) # Sets self.rootconf
+        if not self.rootconf:
+            self.usage("a configuration file is required; use -C")
+        # XXX Should allow overriding more zdaemon options here
+        if self.program is None:
+            self.program = self.rootconf.getlist("program")
+        if self.program is None:
+            self.usage("no program specified in configuration")
+
+
 class ZDCmd(cmd.Cmd):
 
     prompt = "(zdctl) "
 
     def __init__(self, options):
+        print "program:", " ".join(options.program)
         self.options = options
         cmd.Cmd.__init__(self)
-        self.zdstatus()
+        self.do_status()
+        if self.zd_status:
+            m = re.search("(?m)^args=(.*)$", self.zd_status)
+            if m:
+                s = m.group(1)
+                args = eval(s, {"__builtins__": {}})
+                if args != self.options.program:
+                    print "WARNING! zdaemon is managing a different program!"
+                    print "our program   =", self.options.program
+                    print "daemon's args =", args
 
-    def zdcommand(self, command):
-        """Send a command to the zdaemon server and return the response.
+    def send_action(self, action):
+        """Send an action to the zdaemon server and return the response.
 
         Return None if the server is not up or any other error happened.
         """
         sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
         try:
             sock.connect(self.options.sockname)
-            sock.send(command + "\n")
+            sock.send(action + "\n")
             sock.shutdown(1) # We're not writing any more
             response = ""
             while 1:
@@ -39,15 +114,16 @@
                     break
                 response += data
             sock.close()
+            print "response =", `response`
             return response
         except socket.error, msg:
             return None
 
-    def zdstatus(self):
+    def get_status(self):
         self.zd_up = 0
         self.zd_pid = 0
         self.zd_status = None
-        resp = self.zdcommand("status")
+        resp = self.send_action("status")
         if not resp:
             return
         m = re.search("(?m)^application=(\d+)$", resp)
@@ -57,110 +133,136 @@
         self.zd_pid = int(m.group(1))
         self.zd_status = resp
 
+    def awhile(self, cond, msg):
+        try:
+            self.get_status()
+            while not cond():
+                sys.stdout.write(". ")
+                sys.stdout.flush()
+                time.sleep(1)
+                self.get_status()
+        except KeyboardInterrupt:
+            print "^C"
+        else:
+            print msg % self.__dict__
+
+    def help_help(self):
+        print "help          -- Print a list of available actions."
+        print "help <action> -- Print help for <action>."
+
     def do_start(self, arg):
         if not self.zd_up:
-            command = [self.options.python,
-                       self.options.zdaemon,
-                       "-d",
-                       "-s", self.options.sockname,
-                       self.options.program] + self.options.program_arguments
-            print command
-            os.spawnvp(os.P_WAIT, command[0], command)
-        else:
-            self.zdcommand("start")
-        self.zdstatus()
-        while not self.zd_pid:
-            sys.stdout.write(". ")
-            sys.stdout.flush()
-            time.sleep(1)
-            self.zdstatus()
-        print "started, pid=%d" % self.zd_pid
+            args = [
+                self.options.python,
+                self.options.zdaemon,
+                "-b", str(self.options.backofflimit),
+                "-d",
+                "-s", self.options.sockname,
+                "-x", ",".join(map(str, self.options.exitcodes)),
+                "-z", self.options.zdirectory,
+                ]
+            if self.options.forever:
+                args.append("-f")
+            if self.options.user:
+                argss.extend(["-u", str(self.options.user)])
+            args.extend(self.options.program)
+            print args
+            os.spawnvp(os.P_WAIT, args[0], args)
+        else:
+            self.send_action("start")
+        self.awhile(lambda: self.zd_pid, "started, pid=%(zd_pid)d")
+
+    def help_start(self):
+        print "start -- Start the daemon process."
+        print "         If it is already running, do nothing."
 
     def do_stop(self, arg):
-        self.zdstatus()
+        self.get_status()
         if not self.zd_up:
             print "daemon manager not running"
         elif not self.zd_pid:
-            print "daemon not running"
+            print "program not running"
         else:
-            self.zdcommand("stop")
-            self.zdstatus()
-            while self.zd_pid:
-                sys.stdout.write(". ")
-                sys.stdout.flush()
-                time.sleep(1)
-                self.zdstatus()
-            print "daemon stopped"
+            self.send_action("stop")
+            self.awhile(lambda: not self.zd_pid, "program stopped")
+
+    def help_stop(self):
+        print "stop -- Stop the daemon process."
+        print "        If it is not running, do nothing."
 
     def do_restart(self, arg):
-        self.zdstatus()
+        self.get_status()
         pid = self.zd_pid
         if not pid:
             self.do_start(arg)
         else:
-            self.zdcommand("restart")
-            self.zdstatus()
-            while self.zd_pid in (0, pid):
-                sys.stdout.write(". ")
-                sys.stdout.flush()
-                time.sleep(1)
-                self.zdstatus()
-            print "daemon restarted, pid=%d" % self.zd_pid
+            self.send_action("restart")
+            self.awhile(lambda: self.zd_pid not in (0, pid),
+                        "program restarted, pid=%(zd_pid)d")
+
+    def help_restart(self):
+        print "restart -- Stop and then start the daemon process."
+
+    def do_kill(self, arg):
+        if not arg:
+            sig = signal.SIGTERM
+        else:
+            try:
+                sig = int(arg)
+            except: # int() can raise any number of exceptions
+                print "invalid signal number", `arg`
+                return
+        self.get_status()
+        if not self.zd_pid:
+            print "program not running"
+            return
+        print "kill(%d, %d)" % (self.zd_pid, sig)
+        try:
+            os.kill(self.zd_pid, sig)
+        except os.error, msg:
+            print "Error:", msg
+        else:
+            print "signal %d sent to process %d" % (sig, self.zd_pid)
+
+    def help_kill(self):
+        print "kill [sig] -- Send signal sig to the daemon process."
+        print "              The default signal is SIGTERM."
+
+    def do_wait(self, arg):
+        self.awhile(lambda: not self.zd_pid, "program stopped")
+        self.do_status()
+
+    def help_wait(self):
+        print "wait -- Wait for the daemon process to exit."
 
-    def do_status(self, arg):
-        self.zdstatus()
+    def do_status(self, arg=""):
+        self.get_status()
         if not self.zd_up:
             print "daemon manager not running"
         elif not self.zd_pid:
-            print "daemon not running"
+            print "daemon manager running; program not running"
         else:
-            print "daemon running: pid=%d" % self.zd_pid
+            print "program running; pid=%d" % self.zd_pid
+        if arg == "-l" and self.zd_status:
+            print self.zd_status
+
+    def help_status(self):
+        print "status [-l] -- Print status for the daemon process."
+        print "               With -l, show raw status output as well."
 
     def do_quit(self, arg):
-        self.zdstatus()
+        self.get_status()
         if not self.zd_pid:
-            self.zdcommand("exit")
-            self.zdstatus()
-            while self.zd_up:
-                sys.stdout.write(". ")
-                sys.stdout.flush()
-                time.sleep(1)
-                self.zdstatus()
-            print "daemon not running; daemon manager stopped"
+            print "program not running; stopping daemon manager"
+            self.send_action("exit")
+            self.awhile(lambda: not self.zd_up, "daemon manager stopped")
         else:
-            print "daemon and daemon manager still running"
+            print "program and daemon manager still running"
         return 1
 
-class ZDOptions:
-
-    python = sys.executable
-    if __name__ == "__main__":
-        _file = __file__
-    else:
-        _file = sys.argv[0]
-    _file = os.path.normpath(os.path.abspath(_file))
-    _dir = os.path.dirname(_file)
-    zdaemon = os.path.join(_dir, "zdaemon.py")
-
-    backofflimit = 10                   # -b SECONDS
-    isclient = 0                        # -c
-    daemon = 0                          # -d
-    forever = 0                         # -f
-    sockname = "zdsock"                 # -s SOCKET
-    exitcodes = [0, 2]                  # -x LIST
-    user = None                         # -u USER
-    zdirectory = "/"                    # -z DIRECTORY
-
-    program = "sleep"
-    program_arguments = ["100"]
-
-##    program = os.path.join(_dir, "tests/nokill.py")
-##    program_arguments = []
-
-    def __init__(self, args=None):
-        if args is None:
-            args = sys.argv[1:]
-        self.args = args
+    def help_quit(self):
+        print "quit -- Exit the zdctl shell."
+        print "        If the program is not running, stop the daemon manager."
 
 def main(args=None):
     options = ZDOptions(args)