- upgrade cherrypy to version 3.6.0

- dont't pass unicode hostname to cherrypy (see cherrypy-issue #1285,
https://bitbucket.org/cherrypy/cherrypy/issue/1285/n-must-be-a-native-str-got-unicode)

lib/cherrypy/process/plugins.py

@@ -7,7 +7,8 @@ import sys
 import time
 import threading
 
-from cherrypy._cpcompat import basestring, get_daemon, get_thread_ident, ntob, set
+from cherrypy._cpcompat import basestring, get_daemon, get_thread_ident
+from cherrypy._cpcompat import ntob, set, Timer, SetDaemonProperty
 
 # _module__file__base is used by Autoreload to make
 # absolute any filenames retrieved from sys.modules which are not
@@ -19,8 +20,8 @@ from cherrypy._cpcompat import basestring, get_daemon, get_thread_ident, ntob, s
 # changes the current directory by executing os.chdir(), then the next time
 # Autoreload runs, it will not be able to find any filenames which are
 # not absolute paths, because the current directory is not the same as when the
-# module was first imported.  Autoreload will then wrongly conclude the file has
-# "changed", and initiate the shutdown/re-exec sequence.
+# module was first imported.  Autoreload will then wrongly conclude the file
+# has "changed", and initiate the shutdown/re-exec sequence.
 # See ticket #917.
 # For this workaround to have a decent probability of success, this module
 # needs to be imported as early as possible, before the app has much chance
@@ -29,10 +30,12 @@ _module__file__base = os.getcwd()
 
 
 class SimplePlugin(object):
+
     """Plugin base class which auto-subscribes methods for known channels."""
 
     bus = None
-    """A :class:`Bus <cherrypy.process.wspbus.Bus>`, usually cherrypy.engine."""
+    """A :class:`Bus <cherrypy.process.wspbus.Bus>`, usually cherrypy.engine.
+    """
 
     def __init__(self, bus):
         self.bus = bus
@@ -54,8 +57,8 @@ class SimplePlugin(object):
                 self.bus.unsubscribe(channel, method)
 
 
-
 class SignalHandler(object):
+
     """Register bus channels (and listeners) for system signals.
 
     You can modify what signals your application listens for, and what it does
@@ -74,9 +77,9 @@ class SignalHandler(object):
     if the process is attached to a TTY. This is because Unix window
     managers tend to send SIGHUP to terminal windows when the user closes them.
 
-    Feel free to add signals which are not available on every platform. The
-    :class:`SignalHandler` will ignore errors raised from attempting to register
-    handlers for unknown signals.
+    Feel free to add signals which are not available on every platform.
+    The :class:`SignalHandler` will ignore errors raised from attempting
+    to register handlers for unknown signals.
     """
 
     handlers = {}
@@ -187,15 +190,17 @@ class SignalHandler(object):
 
 
 try:
-    import pwd, grp
+    import pwd
+    import grp
 except ImportError:
     pwd, grp = None, None
 
 
 class DropPrivileges(SimplePlugin):
+
     """Drop privileges. uid/gid arguments not available on Windows.
 
-    Special thanks to Gavin Baker: http://antonym.org/node/100.
+    Special thanks to `Gavin Baker <http://antonym.org/2005/12/dropping-privileges-in-python.html>`_ 
     """
 
     def __init__(self, bus, umask=None, uid=None, gid=None):
@@ -207,6 +212,7 @@ class DropPrivileges(SimplePlugin):
 
     def _get_uid(self):
         return self._uid
+
     def _set_uid(self, val):
         if val is not None:
             if pwd is None:
@@ -217,10 +223,11 @@ class DropPrivileges(SimplePlugin):
                 val = pwd.getpwnam(val)[2]
         self._uid = val
     uid = property(_get_uid, _set_uid,
-        doc="The uid under which to run. Availability: Unix.")
+                   doc="The uid under which to run. Availability: Unix.")
 
     def _get_gid(self):
         return self._gid
+
     def _set_gid(self, val):
         if val is not None:
             if grp is None:
@@ -231,10 +238,11 @@ class DropPrivileges(SimplePlugin):
                 val = grp.getgrnam(val)[2]
         self._gid = val
     gid = property(_get_gid, _set_gid,
-        doc="The gid under which to run. Availability: Unix.")
+                   doc="The gid under which to run. Availability: Unix.")
 
     def _get_umask(self):
         return self._umask
+
     def _set_umask(self, val):
         if val is not None:
             try:
@@ -244,8 +252,11 @@ class DropPrivileges(SimplePlugin):
                              level=30)
                 val = None
         self._umask = val
-    umask = property(_get_umask, _set_umask,
-        doc="""The default permission mode for newly created files and directories.
+    umask = property(
+        _get_umask,
+        _set_umask,
+        doc="""The default permission mode for newly created files and
+        directories.
 
         Usually expressed in octal format, for example, ``0644``.
         Availability: Unix, Windows.
@@ -299,6 +310,7 @@ class DropPrivileges(SimplePlugin):
 
 
 class Daemonizer(SimplePlugin):
+
     """Daemonize the running script.
 
     Use this with a Web Site Process Bus via::
@@ -368,7 +380,7 @@ class Daemonizer(SimplePlugin):
             pid = os.fork()
             if pid > 0:
                 self.bus.log('Forking twice.')
-                os._exit(0) # Exit second parent
+                os._exit(0)  # Exit second parent
         except OSError:
             exc = sys.exc_info()[1]
             sys.exit("%s: fork #2 failed: (%d) %s\n"
@@ -394,6 +406,7 @@ class Daemonizer(SimplePlugin):
 
 
 class PIDFile(SimplePlugin):
+
     """Maintain a PID file via a WSPBus."""
 
     def __init__(self, bus, pidfile):
@@ -406,7 +419,7 @@ class PIDFile(SimplePlugin):
         if self.finalized:
             self.bus.log('PID %r already written to %r.' % (pid, self.pidfile))
         else:
-            open(self.pidfile, "wb").write(ntob("%s" % pid, 'utf8'))
+            open(self.pidfile, "wb").write(ntob("%s\n" % pid, 'utf8'))
             self.bus.log('PID %r written to %r.' % (pid, self.pidfile))
             self.finalized = True
     start.priority = 70
@@ -421,14 +434,20 @@ class PIDFile(SimplePlugin):
             pass
 
 
-class PerpetualTimer(threading._Timer):
-    """A responsive subclass of threading._Timer whose run() method repeats.
+class PerpetualTimer(Timer):
+
+    """A responsive subclass of threading.Timer whose run() method repeats.
 
     Use this timer only when you really need a very interruptible timer;
     this checks its 'finished' condition up to 20 times a second, which can
     results in pretty high CPU usage
     """
 
+    def __init__(self, *args, **kwargs):
+        "Override parent constructor to allow 'bus' to be provided."
+        self.bus = kwargs.pop('bus', None)
+        super(PerpetualTimer, self).__init__(*args, **kwargs)
+
     def run(self):
         while True:
             self.finished.wait(self.interval)
@@ -437,13 +456,16 @@ class PerpetualTimer(threading._Timer):
             try:
                 self.function(*self.args, **self.kwargs)
             except Exception:
-                self.bus.log("Error in perpetual timer thread function %r." %
-                             self.function, level=40, traceback=True)
+                if self.bus:
+                    self.bus.log(
+                        "Error in perpetual timer thread function %r." %
+                        self.function, level=40, traceback=True)
                 # Quit on first error to avoid massive logs.
                 raise
 
 
-class BackgroundTask(threading.Thread):
+class BackgroundTask(SetDaemonProperty, threading.Thread):
+
     """A subclass of threading.Thread whose run() method repeats.
 
     Use this class for most repeating tasks. It uses time.sleep() to wait
@@ -462,6 +484,9 @@ class BackgroundTask(threading.Thread):
         self.running = False
         self.bus = bus
 
+        # default to daemonic
+        self.daemon = True
+
     def cancel(self):
         self.running = False
 
@@ -480,11 +505,9 @@ class BackgroundTask(threading.Thread):
                 # Quit on first error to avoid massive logs.
                 raise
 
-    def _set_daemon(self):
-        return True
-
 
 class Monitor(SimplePlugin):
+
     """WSPBus listener to periodically run a callback in its own thread."""
 
     callback = None
@@ -494,7 +517,9 @@ class Monitor(SimplePlugin):
     """The time in seconds between callback runs."""
 
     thread = None
-    """A :class:`BackgroundTask<cherrypy.process.plugins.BackgroundTask>` thread."""
+    """A :class:`BackgroundTask<cherrypy.process.plugins.BackgroundTask>`
+    thread.
+    """
 
     def __init__(self, bus, callback, frequency=60, name=None):
         SimplePlugin.__init__(self, bus)
@@ -509,7 +534,7 @@ class Monitor(SimplePlugin):
             threadname = self.name or self.__class__.__name__
             if self.thread is None:
                 self.thread = BackgroundTask(self.frequency, self.callback,
-                                             bus = self.bus)
+                                             bus=self.bus)
                 self.thread.setName(threadname)
                 self.thread.start()
                 self.bus.log("Started monitor thread %r." % threadname)
@@ -520,7 +545,8 @@ class Monitor(SimplePlugin):
     def stop(self):
         """Stop our callback's background task thread."""
         if self.thread is None:
-            self.bus.log("No thread running for %s." % self.name or self.__class__.__name__)
+            self.bus.log("No thread running for %s." %
+                         self.name or self.__class__.__name__)
         else:
             if self.thread is not threading.currentThread():
                 name = self.thread.getName()
@@ -538,6 +564,7 @@ class Monitor(SimplePlugin):
 
 
 class Autoreloader(Monitor):
+
     """Monitor which re-executes the process when files change.
 
     This :ref:`plugin<plugins>` restarts the process (via :func:`os.execv`)
@@ -547,9 +574,9 @@ class Autoreloader(Monitor):
 
         cherrypy.engine.autoreload.files.add(myFile)
 
-    If there are imported files you do *not* wish to monitor, you can adjust the
-    ``match`` attribute, a regular expression. For example, to stop monitoring
-    cherrypy itself::
+    If there are imported files you do *not* wish to monitor, you can
+    adjust the ``match`` attribute, a regular expression. For example,
+    to stop monitoring cherrypy itself::
 
         cherrypy.engine.autoreload.match = r'^(?!cherrypy).+'
 
@@ -583,15 +610,20 @@ class Autoreloader(Monitor):
     def sysfiles(self):
         """Return a Set of sys.modules filenames to monitor."""
         files = set()
-        for k, m in sys.modules.items():
+        for k, m in list(sys.modules.items()):
             if re.match(self.match, k):
-                if hasattr(m, '__loader__') and hasattr(m.__loader__, 'archive'):
+                if (
+                    hasattr(m, '__loader__') and
+                    hasattr(m.__loader__, 'archive')
+                ):
                     f = m.__loader__.archive
                 else:
                     f = getattr(m, '__file__', None)
                     if f is not None and not os.path.isabs(f):
-                        # ensure absolute paths so a os.chdir() in the app doesn't break me
-                        f = os.path.normpath(os.path.join(_module__file__base, f))
+                        # ensure absolute paths so a os.chdir() in the app
+                        # doesn't break me
+                        f = os.path.normpath(
+                            os.path.join(_module__file__base, f))
                 files.add(f)
         return files
 
@@ -619,14 +651,17 @@ class Autoreloader(Monitor):
                 else:
                     if mtime is None or mtime > oldtime:
                         # The file has been deleted or modified.
-                        self.bus.log("Restarting because %s changed." % filename)
+                        self.bus.log("Restarting because %s changed." %
+                                     filename)
                         self.thread.cancel()
-                        self.bus.log("Stopped thread %r." % self.thread.getName())
+                        self.bus.log("Stopped thread %r." %
+                                     self.thread.getName())
                         self.bus.restart()
                         return
 
 
 class ThreadManager(SimplePlugin):
+
     """Manager for HTTP request threads.
 
     If you have control over thread creation and destruction, publish to
@@ -680,4 +715,3 @@ class ThreadManager(SimplePlugin):
             self.bus.publish('stop_thread', i)
         self.threads.clear()
     graceful = stop
-

lib/cherrypy/process/servers.py

@@ -13,7 +13,9 @@ protocols, etc.), you can manually register each one and then start them all
 with engine.start::
 
     s1 = ServerAdapter(cherrypy.engine, MyWSGIServer(host='0.0.0.0', port=80))
-    s2 = ServerAdapter(cherrypy.engine, another.HTTPServer(host='127.0.0.1', SSL=True))
+    s2 = ServerAdapter(cherrypy.engine,
+                       another.HTTPServer(host='127.0.0.1',
+                       SSL=True))
     s1.subscribe()
     s2.subscribe()
     cherrypy.engine.start()
@@ -63,7 +65,7 @@ hello.py::
 
     cherrypy.tree.mount(HelloWorld())
     # CherryPy autoreload must be disabled for the flup server to work
-    cherrypy.config.update({'engine.autoreload_on':False})
+    cherrypy.config.update({'engine.autoreload.on':False})
 
 Then run :doc:`/deployguide/cherryd` with the '-f' arg::
 
@@ -107,15 +109,17 @@ directive, configure your fastcgi script like the following::
     } # end of $HTTP["url"] =~ "^/"
 
 Please see `Lighttpd FastCGI Docs
-<http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModFastCGI>`_ for an explanation
-of the possible configuration options.
+<http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModFastCGI>`_ for
+an explanation of the possible configuration options.
 """
 
 import sys
 import time
+import warnings
 
 
 class ServerAdapter(object):
+
     """Adapter for an HTTP server.
 
     If you need to start more than one HTTP server (to serve on multiple
@@ -149,8 +153,7 @@ class ServerAdapter(object):
         if self.bind_addr is None:
             on_what = "unknown interface (dynamic?)"
         elif isinstance(self.bind_addr, tuple):
-            host, port = self.bind_addr
-            on_what = "%s:%s" % (host, port)
+            on_what = self._get_base()
         else:
             on_what = "socket file: %s" % self.bind_addr
 
@@ -176,6 +179,21 @@ class ServerAdapter(object):
         self.bus.log("Serving on %s" % on_what)
     start.priority = 75
 
+    def _get_base(self):
+        if not self.httpserver:
+            return ''
+        host, port = self.bind_addr
+        if getattr(self.httpserver, 'ssl_certificate', None):
+            scheme = "https"
+            if port != 443:
+                host += ":%s" % port
+        else:
+            scheme = "http"
+            if port != 80:
+                host += ":%s" % port
+
+        return "%s://%s" % (scheme, host)
+
     def _start_http_thread(self):
         """HTTP servers MUST be running in new threads, so that the
         main thread persists to receive KeyboardInterrupt's. If an
@@ -234,6 +252,7 @@ class ServerAdapter(object):
 
 
 class FlupCGIServer(object):
+
     """Adapter for a flup.server.cgi.WSGIServer."""
 
     def __init__(self, *args, **kwargs):
@@ -257,6 +276,7 @@ class FlupCGIServer(object):
 
 
 class FlupFCGIServer(object):
+
     """Adapter for a flup.server.fcgi.WSGIServer."""
 
     def __init__(self, *args, **kwargs):
@@ -296,11 +316,13 @@ class FlupFCGIServer(object):
         # Forcibly stop the fcgi server main event loop.
         self.fcgiserver._keepGoing = False
         # Force all worker threads to die off.
-        self.fcgiserver._threadPool.maxSpare = self.fcgiserver._threadPool._idleCount
+        self.fcgiserver._threadPool.maxSpare = (
+            self.fcgiserver._threadPool._idleCount)
         self.ready = False
 
 
 class FlupSCGIServer(object):
+
     """Adapter for a flup.server.scgi.WSGIServer."""
 
     def __init__(self, *args, **kwargs):
@@ -344,10 +366,12 @@ def client_host(server_host):
         return '127.0.0.1'
     if server_host in ('::', '::0', '::0.0.0.0'):
         # :: is IN6ADDR_ANY, which should answer on localhost.
-        # ::0 and ::0.0.0.0 are non-canonical but common ways to write IN6ADDR_ANY.
+        # ::0 and ::0.0.0.0 are non-canonical but common
+        # ways to write IN6ADDR_ANY.
         return '::1'
     return server_host
 
+
 def check_port(host, port, timeout=1.0):
     """Raise an error if the given port is not free on the given host."""
     if not host:
@@ -364,7 +388,9 @@ def check_port(host, port, timeout=1.0):
                                   socket.SOCK_STREAM)
     except socket.gaierror:
         if ':' in host:
-            info = [(socket.AF_INET6, socket.SOCK_STREAM, 0, "", (host, port, 0, 0))]
+            info = [(
+                socket.AF_INET6, socket.SOCK_STREAM, 0, "", (host, port, 0, 0)
+            )]
         else:
             info = [(socket.AF_INET, socket.SOCK_STREAM, 0, "", (host, port))]
 
@@ -378,18 +404,20 @@ def check_port(host, port, timeout=1.0):
             s.settimeout(timeout)
             s.connect((host, port))
             s.close()
-            raise IOError("Port %s is in use on %s; perhaps the previous "
-                          "httpserver did not shut down properly." %
-                          (repr(port), repr(host)))
         except socket.error:
             if s:
                 s.close()
+        else:
+            raise IOError("Port %s is in use on %s; perhaps the previous "
+                          "httpserver did not shut down properly." %
+                          (repr(port), repr(host)))
 
 
 # Feel free to increase these defaults on slow systems:
 free_port_timeout = 0.1
 occupied_port_timeout = 1.0
 
+
 def wait_for_free_port(host, port, timeout=None):
     """Wait for the specified port to become free (drop requests)."""
     if not host:
@@ -409,6 +437,7 @@ def wait_for_free_port(host, port, timeout=None):
 
     raise IOError("Port %r not free on %r" % (port, host))
 
+
 def wait_for_occupied_port(host, port, timeout=None):
     """Wait for the specified port to become active (receive requests)."""
     if not host:
@@ -420,8 +449,17 @@ def wait_for_occupied_port(host, port, timeout=None):
         try:
             check_port(host, port, timeout=timeout)
         except IOError:
+            # port is occupied
             return
         else:
             time.sleep(timeout)
 
-    raise IOError("Port %r not bound on %r" % (port, host))
+    if host == client_host(host):
+        raise IOError("Port %r not bound on %r" % (port, host))
+
+    # On systems where a loopback interface is not available and the
+    #  server is bound to all interfaces, it's difficult to determine
+    #  whether the server is in fact occupying the port. In this case,
+    # just issue a warning and move on. See issue #1100.
+    msg = "Unable to verify that the server is bound on %r" % port
+    warnings.warn(msg)

lib/cherrypy/process/win32.py

@@ -11,6 +11,7 @@ from cherrypy.process import wspbus, plugins
 
 
 class ConsoleCtrlHandler(plugins.SimplePlugin):
+
     """A WSPBus plugin for handling Win32 console events (like Ctrl-C)."""
 
     def __init__(self, bus):
@@ -68,6 +69,7 @@ class ConsoleCtrlHandler(plugins.SimplePlugin):
 
 
 class Win32Bus(wspbus.Bus):
+
     """A Web Site Process Bus implementation for Win32.
 
     Instead of time.sleep, this bus blocks using native win32event objects.
@@ -90,6 +92,7 @@ class Win32Bus(wspbus.Bus):
 
     def _get_state(self):
         return self._state
+
     def _set_state(self, value):
         self._state = value
         event = self._get_state_event(value)
@@ -106,7 +109,8 @@ class Win32Bus(wspbus.Bus):
             # Don't wait for an event that beat us to the punch ;)
             if self.state not in state:
                 events = tuple([self._get_state_event(s) for s in state])
-                win32event.WaitForMultipleObjects(events, 0, win32event.INFINITE)
+                win32event.WaitForMultipleObjects(
+                    events, 0, win32event.INFINITE)
         else:
             # Don't wait for an event that beat us to the punch ;)
             if self.state != state:
@@ -115,6 +119,7 @@ class Win32Bus(wspbus.Bus):
 
 
 class _ControlCodes(dict):
+
     """Control codes used to "signal" a service via ControlService.
 
     User-defined control codes are in the range 128-255. We generally use
@@ -145,6 +150,7 @@ def signal_child(service, command):
 
 
 class PyWebService(win32serviceutil.ServiceFramework):
+
     """Python Web Service."""
 
     _svc_name_ = "Python Web Service"

lib/cherrypy/process/wspbus.py

@@ -78,13 +78,16 @@ from cherrypy._cpcompat import set
 # sys.executable is a relative-path, and/or cause other problems).
 _startup_cwd = os.getcwd()
 
+
 class ChannelFailures(Exception):
-    """Exception raised when errors occur in a listener during Bus.publish()."""
+
+    """Exception raised when errors occur in a listener during Bus.publish().
+    """
     delimiter = '\n'
 
     def __init__(self, *args, **kwargs):
         # Don't use 'super' here; Exceptions are old-style in Py2.4
-        # See http://www.cherrypy.org/ticket/959
+        # See https://bitbucket.org/cherrypy/cherrypy/issue/959
         Exception.__init__(self, *args, **kwargs)
         self._exceptions = list()
 
@@ -107,9 +110,13 @@ class ChannelFailures(Exception):
     __nonzero__ = __bool__
 
 # Use a flag to indicate the state of the bus.
+
+
 class _StateEnum(object):
+
     class State(object):
         name = None
+
         def __repr__(self):
             return "states.%s" % self.name
 
@@ -137,6 +144,7 @@ else:
 
 
 class Bus(object):
+
     """Process state-machine and messenger for HTTP site deployment.
 
     All listeners for a given channel are guaranteed to be called even
@@ -266,14 +274,14 @@ class Bus(object):
             # signal handler, console handler, or atexit handler), so we
             # can't just let exceptions propagate out unhandled.
             # Assume it's been logged and just die.
-            os._exit(70) # EX_SOFTWARE
+            os._exit(70)  # EX_SOFTWARE
 
         if exitstate == states.STARTING:
             # exit() was called before start() finished, possibly due to
             # Ctrl-C because a start listener got stuck. In this case,
             # we could get stuck in a loop where Ctrl-C never exits the
             # process, so we just call os.exit here.
-            os._exit(70) # EX_SOFTWARE
+            os._exit(70)  # EX_SOFTWARE
 
     def restart(self):
         """Restart the process (may close connections).
@@ -311,13 +319,21 @@ class Bus(object):
             raise
 
         # Waiting for ALL child threads to finish is necessary on OS X.
-        # See http://www.cherrypy.org/ticket/581.
+        # See https://bitbucket.org/cherrypy/cherrypy/issue/581.
         # It's also good to let them all shut down before allowing
         # the main thread to call atexit handlers.
-        # See http://www.cherrypy.org/ticket/751.
+        # See https://bitbucket.org/cherrypy/cherrypy/issue/751.
         self.log("Waiting for child threads to terminate...")
         for t in threading.enumerate():
-            if t != threading.currentThread() and t.isAlive():
+            # Validate the we're not trying to join the MainThread
+            # that will cause a deadlock and the case exist when
+            # implemented as a windows service and in any other case
+            # that another thread executes cherrypy.engine.exit()
+            if (
+                    t != threading.currentThread() and
+                    t.isAlive() and
+                    not isinstance(t, threading._MainThread)
+            ):
                 # Note that any dummy (external) threads are always daemonic.
                 if hasattr(threading.Thread, "daemon"):
                     # Python 2.6+
@@ -389,7 +405,7 @@ class Bus(object):
 
         Set self.max_cloexec_files to 0 to disable this behavior.
         """
-        for fd in range(3, self.max_cloexec_files): # skip stdin/out/err
+        for fd in range(3, self.max_cloexec_files):  # skip stdin/out/err
             try:
                 flags = fcntl.fcntl(fd, fcntl.F_GETFD)
             except IOError: