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 we use simplejson always, we get some warnings when we run under
 # 2.6.
 if sys.version_info < (2, 6):
   import simplejson as json
@@ skipping 81 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._xmpp_socket_map = {}
+    self._xmpp_server = xmppserver.XmppServer(
+      self._xmpp_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 HandleRequestNoBlock(self):
+    """Handles a single request.
+
+    Copied from SocketServer._handle_request_noblock().
+    """
+    try:
+      request, client_address = self.get_request()
+    except socket.error:
+      return
+    if self.verify_request(request, client_address):
+      try:
+        self.process_request(request, client_address)
+      except:
+        self.handle_error(request, client_address)
+        self.close_request(request)
+
+  def serve_forever(self):
+    """This is a merge of asyncore.loop() and SocketServer.serve_forever().
+    """
+
+    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()
+
+    while True:
+      r = [ self.fileno() ]

[cbentzel, 2010/11/19 15:39:29]

Nit: are r,w,e too short? [maybe at least r,w,x since python's documentation for
select has arguments as rlist, wlist, xlist, although that may lead people to
believe this is read/write/execute]

I'd prefer read_fds, write_fds, exceptional_fds, but I understand it may make
the call to select.select expand to more than one line.

[akalin, 2010/11/19 18:06:17]

Done.

+      w = []
+      e = []
+
+      for fd, obj in self._xmpp_socket_map.items():

[cbentzel, 2010/11/19 15:39:29]

xmpp_connection instead of obj? 

[akalin, 2010/11/19 18:06:17]

Done.

+        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)
+
+      select_timeout = 0.5
+      try:
+        r, w, e = select.select(r, w, e, select_timeout)

[cbentzel, 2010/11/19 15:39:29]

Why do you need a timeout here? The tests that spawn testserver will likely have
timeouts for the test-on-the-whole. 

[akalin, 2010/11/19 18:06:17]

Done.

+      except select.error, err:
+        if err.args[0] != errno.EINTR:
+          raise
+        else:
+          continue
+
+      for fd in r:
+        if fd == self.fileno():
+          self.HandleRequestNoBlock()
+          continue
+        obj = self._xmpp_socket_map.get(fd)
+        RunDispatcherHandler(obj, asyncore.dispatcher.handle_read_event)
+
+      for fd in w:
+        obj = self._xmpp_socket_map.get(fd)
+        RunDispatcherHandler(obj, asyncore.dispatcher.handle_write_event)
+
+      for fd in e:
+        obj = self._xmpp_socket_map.get(fd)
+        RunDispatcherHandler(obj, asyncore.dispatcher.handle_expt_event)
+
 
 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 1122 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 = {}

[cbentzel, 2010/11/19 15:39:29]

Maybe server_ports instead of server_data? 

[akalin, 2010/11/19 18:06:17]

Hmm, it's a JSON grab-bag, so I think we shouldn't limit it to ports.  May want
to transmit other info later.

+
   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
     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)
     debug('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))