run_isolated.py: install CIPD packages

client/tests/isolateserver_mock.py

 # Copyright 2014 The LUCI Authors. All rights reserved.
 # Use of this source code is governed under the Apache License, Version 2.0
 # that can be found in the LICENSE file.
 
-import BaseHTTPServer
 import base64
 import hashlib
 import json
 import logging
 import re
-import sys
-import threading
-import urllib2
-import urlparse
 import zlib
 
+import httpserver_mock
+
 ALGO = hashlib.sha1
 
 
 def hash_content(content):
   return ALGO(content).hexdigest()
 
 
 class FakeSigner(object):
 
   @classmethod
   def generate(cls, message, embedded):
     return '%s_<<<%s>>>' % (repr(message), json.dumps(embedded))
 
   @classmethod
   def validate(cls, ticket, message):
     a = re.match(r'^' + repr(message) + r'_<<<(.*)>>>$', ticket, re.DOTALL)
     if not a:
       raise ValueError('Message %s cannot validate ticket %s' % (
           repr(message), ticket))
     return json.loads(a.groups()[0])
 
 
-class MockHandler(BaseHTTPServer.BaseHTTPRequestHandler):
-  def _json(self, data):
-    """Sends a JSON response."""
-    self.send_response(200)
-    self.send_header('Content-type', 'application/json')
-    self.end_headers()
-    json.dump(data, self.wfile)
-
-  def _octet_stream(self, data):
-    """Sends a binary response."""
-    self.send_response(200)
-    self.send_header('Content-type', 'application/octet-stream')
-    self.end_headers()
-    self.wfile.write(data)
-
-  def _read_body(self):
-    """Reads the request body."""
-    return self.rfile.read(int(self.headers['Content-Length']))
-
-  def _drop_body(self):
-    """Reads the request body."""
-    size = int(self.headers['Content-Length'])
-    while size:
-      chunk = min(4096, size)
-      self.rfile.read(chunk)
-      size -= chunk
-
-  def log_message(self, fmt, *args):
-    logging.info(
-        '%s - - [%s] %s', self.address_string(), self.log_date_time_string(),
-        fmt % args)
-
-
-class IsolateServerHandler(MockHandler):
+class IsolateServerHandler(httpserver_mock.MockHandler):
   """An extremely minimal implementation of the isolate server API v1.0."""
 
   def _should_push_to_gs(self, isolated, size):
     max_memcache = 500 * 1024
     min_direct_gs = 501
     if isolated and size <= max_memcache:
       return False
     return size >= min_direct_gs
 
   def _generate_signed_url(self, digest, namespace='default'):
@@ skipping 92 matching lines @@
     else:
       body = self._read_body()
     if self.path.startswith('/FAKE_GCS/'):
       namespace, h = self.path[len('/FAKE_GCS/'):].split('/', 1)
       self.server.contents.setdefault(namespace, {})[h] = body
       self._octet_stream('')
     else:
       raise NotImplementedError(self.path)
 
 
-class MockServer(object):
-  _HANDLER_CLS = None
-
-  def __init__(self):
-    self._closed = False
-    self._server = BaseHTTPServer.HTTPServer(
-        ('127.0.0.1', 0), self._HANDLER_CLS)
-    self._server.url = self.url = 'http://localhost:%d' % (
-        self._server.server_port)
-    self._thread = threading.Thread(target=self._run, name='httpd')
-    self._thread.daemon = True
-    self._thread.start()
-    logging.info('%s', self.url)
-
-  def close(self):
-    self.close_start()
-    self.close_end()
-
-  def close_start(self):
-    assert not self._closed
-    self._closed = True
-    urllib2.urlopen(self.url + '/on/quit')
-
-  def close_end(self):
-    assert self._closed
-    self._thread.join()
-
-  def _run(self):
-    while not self._closed:
-      self._server.handle_request()
-
-
-class MockIsolateServer(MockServer):
+class MockIsolateServer(httpserver_mock.MockServer):
   _HANDLER_CLS = IsolateServerHandler
 
   def __init__(self):
     super(MockIsolateServer, self).__init__()
     self._server.contents = {}
     self._server.discard_content = False
 
   def discard_content(self):
     """Stops saving content in memory. Used to test large files."""
     self._server.discard_content = True
@@ skipping 10 matching lines @@
         zlib.compress(content))
     return h
 
   def add_content(self, namespace, content):
     assert not self._server.discard_content
     h = hash_content(content)
     logging.info('add_content(%s, %s)', namespace, h)
     self._server.contents.setdefault(namespace, {})[h] = base64.b64encode(
         content)
     return h