Spin up XMPP server for testservers of type sync.

net/tools/testserver/testserver.py

 #!/usr/bin/python2.4
 # Copyright (c) 2006-2010 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """This is a simple HTTP server used for testing Chrome.
 
 It supports several test URLs, as specified by the handlers in TestPageHandler.
 By default, it listens on an ephemeral port and sends the port number back to
 the originating process over a pipe. The originating process can specify an
 explicit port if necessary.
 It can use https if you specify the flag --https=CERT where CERT is the path
 to a pem file containing the certificate and private key that should be used.
 """
 
+import asyncore
 import base64
 import BaseHTTPServer
 import cgi
+import errno
 import optparse
 import os
 import re
-import shutil
+import select
 import SocketServer
+import socket
 import sys
 import struct
 import time
 import urlparse
 import warnings
 
 if sys.version_info < (2, 6):
   import simplejson as json
 else:
   import json
@@ skipping 17 matching lines @@
 
 SERVER_HTTP = 0
 SERVER_FTP = 1
 SERVER_SYNC = 2
 
 debug_output = sys.stderr
 def debug(str):
   debug_output.write(str + "\n")
   debug_output.flush()
 
+class Error(Exception):
+  """Error class for this module."""
+  pass
+
+class UnexpectedSocketType(Error):
+  """Raised when a value of a socket map is of unknown type."""
+  pass
+
 class StoppableHTTPServer(BaseHTTPServer.HTTPServer):
   """This is a specialization of of BaseHTTPServer to allow it
   to be exited cleanly (by setting its "stop" member to True)."""
 
   def serve_forever(self):
     self.stop = False
     self.nonce_time = None
     while not self.stop:
       self.handle_request()
     self.socket.close()
@@ skipping 42 matching lines @@
       return False
 
 
 class SyncHTTPServer(StoppableHTTPServer):
   """An HTTP server that handles sync commands."""
 
   def __init__(self, server_address, request_handler_class):
     # We import here to avoid pulling in chromiumsync's dependencies
     # unless strictly necessary.
     import chromiumsync
+    import xmppserver
+    StoppableHTTPServer.__init__(self, server_address, request_handler_class)
     self._sync_handler = chromiumsync.TestServer()
-    StoppableHTTPServer.__init__(self, server_address, request_handler_class)
+    self._socket_map = { self.fileno(): self }
+    self._xmpp_server = xmppserver.XmppServer(

[cbentzel, 2010/11/18 11:59:09]

Should xmpp_server be run a separate thread so you don't have to combine
asyncore's main looping mechanism with httpserver's? 

[akalin, 2010/11/18 23:32:58]

I think the complexity of this select loop (especially since I've cleaned it up
a bit more) is far less than the complexity of using threading in testserver.

+      self._socket_map, ('localhost', 0))
+    self.xmpp_port = self._xmpp_server.getsockname()[1]
 
   def HandleCommand(self, query, raw_request):
     return self._sync_handler.HandleCommand(query, raw_request)
 
+  def serve_forever(self):
+    """This is a merge of asyncore.loop() and SocketServer.serve_forever().
+    """
+
+    def HandleSocketServerRequestNoBlock(socket_server):
+      """Handles a single request for a SocketServer.BaseServer.
+
+      Copied from SocketServer._handle_request_noblock().
+      """
+      try:
+        request, client_address = socket_server.get_request()
+      except socket.error:
+        return
+      if socket_server.verify_request(request, client_address):
+        try:
+          socket_server.process_request(request, client_address)
+        except:
+          socket_server.handle_error(request, client_address)
+          socket_server.close_request(request)
+
+    def RunDispatcherHandler(dispatcher, handler):
+      """Handles a single event for an asyncore.dispatcher.
+
+      Adapted from asyncore.read() et al.
+      """
+      try:
+        handler(dispatcher)
+      except (asyncore.ExitNow, KeyboardInterrupt, SystemExit):
+        raise
+      except:
+        dispatcher.handle_error()
+
+    poll_interval = 0.5
+
+    while map:
+      r = []; w = []; e = []
+      for fd, obj in self._socket_map.items():
+        if isinstance(obj, SocketServer.BaseServer):
+          r.append(fd)
+        elif isinstance(obj, asyncore.dispatcher):
+          is_r = obj.readable()
+          is_w = obj.writable()
+          if is_r:
+            r.append(fd)
+          if is_w:
+            w.append(fd)
+          if is_r or is_w:
+            e.append(fd)
+        else:
+          raise UnexpectedSocketType()
+
+      if [] == r == w == e:
+        time.sleep(poll_interval)

[Paweł Hajdan Jr., 2010/11/18 11:58:45]

hmmm, why? Can we wait for an event that would make either of r, w, e non-empty?

[akalin, 2010/11/18 23:32:58]

Actually, this case should never happen.  Removed this check and rewrote loop to
make it more obvious that r is never empty.

+        continue
+
+      try:
+        r, w, e = select.select(r, w, e, poll_interval)
+      except select.error, err:
+        if err.args[0] != errno.EINTR:
+          raise
+        else:
+          continue
+
+      for fd in r:
+        obj = self._socket_map.get(fd)
+        if obj is None:
+          continue
+        if isinstance(obj, SocketServer.BaseServer):
+          HandleSocketServerRequestNoBlock(obj)
+        elif isinstance(obj, asyncore.dispatcher):
+          RunDispatcherHandler(obj, asyncore.dispatcher.handle_read_event)
+        else:
+          raise UnexpectedSocketType()
+
+      for fd in w:
+        obj = self._socket_map.get(fd)
+        if obj is None:
+          continue
+        if isinstance(obj, asyncore.dispatcher):
+          RunDispatcherHandler(obj, asyncore.dispatcher.handle_write_event)
+        else:
+          raise UnexpectedSocketType()
+
+      for fd in e:
+        obj = self._socket_map.get(fd)
+        if obj is None:
+          continue
+        if isinstance(obj, asyncore.dispatcher):
+          RunDispatcherHandler(obj, asyncore.dispatcher.handle_expt_event)
+        else:
+          raise UnexpectedSocketType()
+
 
 class BasePageHandler(BaseHTTPServer.BaseHTTPRequestHandler):
 
   def __init__(self, request, client_address, socket_server,
                connect_handlers, get_handlers, post_handlers, put_handlers):
     self._connect_handlers = connect_handlers
     self._get_handlers = get_handlers
     self._post_handlers = post_handlers
     self._put_handlers = put_handlers
     BaseHTTPServer.BaseHTTPRequestHandler.__init__(
@@ skipping 1103 matching lines @@
     self.__fd1.flush()
     self.__fd2.flush()
 
 def main(options, args):
   logfile = open('testserver.log', 'w')
   sys.stdout = FileMultiplexer(sys.stdout, logfile)
   sys.stderr = FileMultiplexer(sys.stderr, logfile)
 
   port = options.port
 
+  server_data = {}
+
   if options.server_type == SERVER_HTTP:
     if options.cert:
       # let's make sure the cert file exists.
       if not os.path.isfile(options.cert):
         print 'specified server cert file not found: ' + options.cert + \
               ' exiting...'
         return
       for ca_cert in options.ssl_client_ca:
         if not os.path.isfile(ca_cert):
           print 'specified trusted client CA file not found: ' + ca_cert + \
                 ' exiting...'
           return
       server = HTTPSServer(('127.0.0.1', port), TestPageHandler, options.cert,
                            options.ssl_client_auth, options.ssl_client_ca,
                            options.ssl_bulk_cipher)
       print 'HTTPS server started on port %d...' % server.server_port
     else:
       server = StoppableHTTPServer(('127.0.0.1', port), TestPageHandler)
       print 'HTTP server started on port %d...' % server.server_port
 
     server.data_dir = MakeDataDir()
     server.file_root_url = options.file_root_url
-    listen_port = server.server_port
+    server_data['port'] = server.server_port

[cbentzel, 2010/11/18 11:59:09]

Should this move to unique key per server type? 

[akalin, 2010/11/18 23:32:58]

Hmm I don't think so.  Then run_testserver would have to look up a
per-server-type key, which seems like needless complexity at this point.

     server._device_management_handler = None
   elif options.server_type == SERVER_SYNC:
     server = SyncHTTPServer(('127.0.0.1', port), SyncPageHandler)
     print 'Sync HTTP server started on port %d...' % server.server_port
-    listen_port = server.server_port
+    print 'Sync XMPP server started on port %d...' % server.xmpp_port
+    server_data['port'] = server.server_port
+    server_data['xmpp_port'] = server.xmpp_port
   # means FTP Server
   else:
     my_data_dir = MakeDataDir()
 
     # Instantiate a dummy authorizer for managing 'virtual' users
     authorizer = pyftpdlib.ftpserver.DummyAuthorizer()
 
     # Define a new user having full r/w permissions and a read-only
     # anonymous user
     authorizer.add_user('chrome', 'chrome', my_data_dir, perm='elradfmw')
 
     authorizer.add_anonymous(my_data_dir)
 
     # Instantiate FTP handler class
     ftp_handler = pyftpdlib.ftpserver.FTPHandler
     ftp_handler.authorizer = authorizer
 
     # Define a customized banner (string returned when client connects)
     ftp_handler.banner = ("pyftpdlib %s based ftpd ready." %
                           pyftpdlib.ftpserver.__ver__)
 
     # Instantiate FTP server class and listen to 127.0.0.1:port
     address = ('127.0.0.1', port)
     server = pyftpdlib.ftpserver.FTPServer(address, ftp_handler)
-    listen_port = server.socket.getsockname()[1]
-    print 'FTP server started on port %d...' % listen_port
+    server_data['port'] = server.socket.getsockname()[1]
+    print 'FTP server started on port %d...' % server_data['port']
 
   # Notify the parent that we've started. (BaseServer subclasses
   # bind their sockets on construction.)
   if options.startup_pipe is not None:
-    server_data = {
-      'port': listen_port
-    }
     server_data_json = json.dumps(server_data)
     print 'sending server_data: %s' % server_data_json
     server_data_len = len(server_data_json)
     if sys.platform == 'win32':
       fd = msvcrt.open_osfhandle(options.startup_pipe, 0)
     else:
       fd = options.startup_pipe
     startup_pipe = os.fdopen(fd, "w")
     # First write the data length as an unsigned 4-byte value.  This
     # is _not_ using network byte ordering since the other end of the
@@ skipping 44 matching lines @@
                            'option may appear multiple times, indicating '
                            'multiple algorithms should be enabled.');
   option_parser.add_option('', '--file-root-url', default='/files/',
                            help='Specify a root URL for files served.')
   option_parser.add_option('', '--startup-pipe', type='int',
                            dest='startup_pipe',
                            help='File handle of pipe to parent process')
   options, args = option_parser.parse_args()
 
   sys.exit(main(options, args))