Import recent rootwrap features in local rootwrap

Import features developed in oslo-rootwrap during the Grizzly cycle (and
recently in havana) into quantum-rootwrap. This is the first step toward
using the common oslo-rootwrap into Quantum: the goal being to make both
implementations converge, we should avoid making local changes (and push
any required change into oslo-rootwrap instead from now on).

New features include:
- Optional logging (use_syslog)
- Searching for executables in a specified binary path (exec_dirs)
- New path-based PathFilter

Those features required a refactoring in the way executables are matched
and in configuration loading.

Implements bp quantum-rootwrap-new-features

Change-Id: Ia6a2e91c297ade471448dae0964adfd001a46086

1 files changed, 67 insertions, 28 deletions

diff --git a/bin/quantum-rootwrap b/bin/quantum-rootwrap
index 0e3383fe9e..8f0158c71a 100755
--- a/bin/quantum-rootwrap
+++ b/bin/quantum-rootwrap
@@ -36,40 +36,45 @@
    node.
 """
 
+from __future__ import print_function
+
 import ConfigParser
+import logging
 import os
+import pwd
 import signal
+import subprocess
 import sys
 
-from quantum.common import utils
-
 
 RC_UNAUTHORIZED = 99
 RC_NOCOMMAND = 98
 RC_BADCONFIG = 97
+RC_NOEXECFOUND = 96
+
+
+def _subprocess_setup():
+    # Python installs a SIGPIPE handler by default. This is usually not what
+    # non-Python subprocesses expect.
+    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
+
+
+def _exit_error(execname, message, errorcode, log=True):
+    print("%s: %s" % (execname, message))
+    if log:
+        logging.error(message)
+    sys.exit(errorcode)
 
 
 if __name__ == '__main__':
     # Split arguments, require at least a command
     execname = sys.argv.pop(0)
-    # argv[0] required; path to conf file
     if len(sys.argv) < 2:
-        print "%s: %s" % (execname, "No command specified")
-        sys.exit(RC_NOCOMMAND)
+        _exit_error(execname, "No command specified", RC_NOCOMMAND, log=False)
 
     configfile = sys.argv.pop(0)
     userargs = sys.argv[:]
 
-    # Load configuration
-    config = ConfigParser.RawConfigParser()
-    config.read(configfile)
-    try:
-        filters_path = config.get("DEFAULT", "filters_path").split(",")
-        filters = None
-    except ConfigParser.Error:
-        print "%s: Incorrect configuration file: %s" % (execname, configfile)
-        sys.exit(RC_BADCONFIG)
-
     # Add ../ to sys.path to allow running from branch
     possible_topdir = os.path.normpath(os.path.join(os.path.abspath(execname),
                                                     os.pardir, os.pardir))
@@ -78,17 +83,51 @@ if __name__ == '__main__':
 
     from quantum.rootwrap import wrapper
 
+    # Load configuration
+    try:
+        rawconfig = ConfigParser.RawConfigParser()
+        rawconfig.read(configfile)
+        config = wrapper.RootwrapConfig(rawconfig)
+    except ValueError as exc:
+        msg = "Incorrect value in %s: %s" % (configfile, exc.message)
+        _exit_error(execname, msg, RC_BADCONFIG, log=False)
+    except ConfigParser.Error:
+        _exit_error(execname, "Incorrect configuration file: %s" % configfile,
+                    RC_BADCONFIG, log=False)
+
+    if config.use_syslog:
+        wrapper.setup_syslog(execname,
+                             config.syslog_log_facility,
+                             config.syslog_log_level)
+
     # Execute command if it matches any of the loaded filters
-    filters = wrapper.load_filters(filters_path)
-    filtermatch = wrapper.match_filter(filters, userargs)
-    if filtermatch:
-        obj = utils.subprocess_popen(filtermatch.get_command(userargs),
-                                     stdin=sys.stdin,
-                                     stdout=sys.stdout,
-                                     stderr=sys.stderr,
-                                     env=filtermatch.get_environment(userargs))
-        obj.wait()
-        sys.exit(obj.returncode)
-
-    print "Unauthorized command: %s" % ' '.join(userargs)
-    sys.exit(RC_UNAUTHORIZED)
+    filters = wrapper.load_filters(config.filters_path)
+    try:
+        filtermatch = wrapper.match_filter(filters, userargs,
+                                           exec_dirs=config.exec_dirs)
+        if filtermatch:
+            command = filtermatch.get_command(userargs,
+                                              exec_dirs=config.exec_dirs)
+            if config.use_syslog:
+                logging.info("(%s > %s) Executing %s (filter match = %s)" % (
+                    os.getlogin(), pwd.getpwuid(os.getuid())[0],
+                    command, filtermatch.name))
+
+            obj = subprocess.Popen(command,
+                                   stdin=sys.stdin,
+                                   stdout=sys.stdout,
+                                   stderr=sys.stderr,
+                                   preexec_fn=_subprocess_setup,
+                                   env=filtermatch.get_environment(userargs))
+            obj.wait()
+            sys.exit(obj.returncode)
+
+    except wrapper.FilterMatchNotExecutable as exc:
+        msg = ("Executable not found: %s (filter match = %s)"
+               % (exc.match.exec_path, exc.match.name))
+        _exit_error(execname, msg, RC_NOEXECFOUND, log=config.use_syslog)
+
+    except wrapper.NoFilterMatched:
+        msg = ("Unauthorized command: %s (no filter matched)"
+               % ' '.join(userargs))
+        _exit_error(execname, msg, RC_UNAUTHORIZED, log=config.use_syslog)