Forcibly uses a non-standard port for local svn and git servers.

tests/fake_repos.py

 #!/usr/bin/python
 # Copyright (c) 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.
 
 """Generate fake repositories for testing."""
 
 import atexit
 import datetime
 import errno
@@ skipping 134 matching lines @@
 def commit_git(repo):
   """Commits the changes and returns the new hash."""
   check_call(['git', 'add', '-A', '-f'], cwd=repo)
   check_call(['git', 'commit', '-q', '--message', 'foo'], cwd=repo)
   rev = Popen(['git', 'show-ref', '--head', 'HEAD'],
               cwd=repo).communicate()[0].split(' ', 1)[0]
   logging.debug('At revision %s' % rev)
   return rev
 
 
+def test_port(host, port):
+  s = socket.socket()
+  try:
+    return s.connect_ex((host, port)) == 0
+  finally:
+    s.close()
+
+
+def find_free_port(host, base_port):
+  """Finds a listening port free to listen to."""
+  while base_port < (2<<16):
+    if not test_port(host, base_port):
+      return base_port
+    base_port += 1
+  assert False, 'Having issues finding an available port'
+
+
+def wait_for_port_to_bind(host, port, process):
+  sock = socket.socket()
+
+  if sys.platform == 'darwin':
+    # On Mac SnowLeopard, if we attempt to connect to the socket
+    # immediately, it fails with EINVAL and never gets a chance to
+    # connect (putting us into a hard spin and then failing).
+    # Linux doesn't need this.
+    time.sleep(0.1)
+
+  try:
+    start = datetime.datetime.utcnow()
+    maxdelay = datetime.timedelta(seconds=30)
+    while (datetime.datetime.utcnow() - start) < maxdelay:
+      try:
+        sock.connect((host, port))
+        logging.debug('%d is now bound' % port)
+        return
+      except EnvironmentError:
+        pass
+      logging.debug('%d is still not bound' % port)
+  finally:
+    sock.close()
+  # The process failed to bind. Kill it and dump its ouput.
+  process.kill()
+  logging.error('%s' % process.communicate()[0])
+  assert False, '%d is still not bound' % port
+
+
+def wait_for_port_to_free(host, port):
+  start = datetime.datetime.utcnow()
+  maxdelay = datetime.timedelta(seconds=30)
+  while (datetime.datetime.utcnow() - start) < maxdelay:
+    try:
+      sock = socket.socket()
+      sock.connect((host, port))
+      logging.debug('%d was bound, waiting to free' % port)
+    except EnvironmentError:
+      logging.debug('%d now free' % port)
+      return
+    finally:
+      sock.close()
+  assert False, '%d is still bound' % port
+
+
 _FAKE_LOADED = False
 
 class FakeReposBase(object):
   """Generate both svn and git repositories to test gclient functionality.
 
   Many DEPS functionalities need to be tested: Var, File, From, deps_os, hooks,
   use_relative_paths.
 
   And types of dependencies: Relative urls, Full urls, both svn and git.
 
@@ skipping 23 matching lines @@
     # For consistency with self.svn_revs, it is 1-based too.
     self.git_hashes = {}
     self.svnserve = None
     self.gitdaemon = None
     self.git_pid_file = None
     self.git_root = None
     self.svn_checkout = None
     self.svn_repo = None
     self.git_dirty = False
     self.svn_dirty = False
-    self.svn_base = 'svn://%s/svn/' % self.host
-    self.git_base = 'git://%s/git/' % self.host
-    self.svn_port = 3690
-    self.git_port = 9418
+    self.svn_port = None
+    self.git_port = None
+    self.svn_base = None
+    self.git_base = None
 
   @property
   def root_dir(self):
     return self.trial.root_dir
 
   def set_up(self):
     """All late initialization comes here."""
     self.cleanup_dirt()
     if not self.root_dir:
       try:
@@ skipping 25 matching lines @@
     self.trial = None
 
   def tear_down_svn(self):
     if self.svnserve:
       logging.debug('Killing svnserve pid %s' % self.svnserve.pid)
       try:
         self.svnserve.kill()
       except OSError, e:
         if e.errno != errno.ESRCH:   # no such process
           raise
-      self.wait_for_port_to_free(self.svn_port)
+      wait_for_port_to_free(self.host, self.svn_port)
       self.svnserve = None
+      self.svn_port = None
+      self.svn_base = None
       if not self.trial.SHOULD_LEAK:
         logging.debug('Removing %s' % self.svn_repo)
         gclient_utils.rmtree(self.svn_repo)
         logging.debug('Removing %s' % self.svn_checkout)
         gclient_utils.rmtree(self.svn_checkout)
       else:
         return False
     return True
 
   def tear_down_git(self):
     if self.gitdaemon:
       logging.debug('Killing git-daemon pid %s' % self.gitdaemon.pid)
       self.gitdaemon.kill()
       self.gitdaemon = None
       if self.git_pid_file:
         pid = int(self.git_pid_file.read())
         self.git_pid_file.close()
         logging.debug('Killing git daemon pid %s' % pid)
         kill_pid(pid)
         self.git_pid_file = None
-      self.wait_for_port_to_free(self.git_port)
+      wait_for_port_to_free(self.host, self.git_port)
+      self.git_port = None
+      self.git_base = None
       if not self.trial.SHOULD_LEAK:
         logging.debug('Removing %s' % self.git_root)
         gclient_utils.rmtree(self.git_root)
       else:
         return False
     return True
 
   @staticmethod
   def _genTree(root, tree_dict):
     """For a dictionary of file contents, generate a filesystem."""
@@ skipping 29 matching lines @@
     text += ''.join('%s = %s\n' % (usr, pwd) for usr, pwd in self.USERS)
     write(join(self.svn_repo, 'conf', 'passwd'), text)
 
     # Mac 10.6 ships with a buggy subversion build and we need this line
     # to work around the bug.
     write(join(self.svn_repo, 'db', 'fsfs.conf'),
         '[rep-sharing]\n'
         'enable-rep-sharing = false\n')
 
     # Start the daemon.
-    cmd = ['svnserve', '-d', '--foreground', '-r', self.root_dir]
+    self.svn_port = find_free_port(self.host, 10000)
+    cmd = ['svnserve', '-d', '--foreground', '-r', self.root_dir,
+        '--listen-port=%d' % self.svn_port]
     if self.host == '127.0.0.1':
       cmd.append('--listen-host=' + self.host)
     self.check_port_is_free(self.svn_port)
     self.svnserve = Popen(cmd, cwd=self.svn_repo)
-    self.wait_for_port_to_bind(self.svn_port, self.svnserve)
+    wait_for_port_to_bind(self.host, self.svn_port, self.svnserve)
+    self.svn_base = 'svn://%s:%d/svn/' % (self.host, self.svn_port)
     self.populateSvn()
     self.svn_dirty = False
     return True
 
   def set_up_git(self):
     """Creates git repositories and start the servers."""
     self.set_up()
     if self.gitdaemon:
       return True
     if sys.platform == 'win32':
       return False
     assert self.git_pid_file == None
     for repo in ['repo_%d' % r for r in range(1, self.NB_GIT_REPOS + 1)]:
       check_call(['git', 'init', '-q', join(self.git_root, repo)])
       self.git_hashes[repo] = [None]
-    # Unlike svn, populate git before starting the server.
-    self.populateGit()
+    self.git_port = find_free_port(self.host, 20000)
+    self.git_base = 'git://%s:%d/git/' % (self.host, self.git_port)
     # Start the daemon.
     self.git_pid_file = tempfile.NamedTemporaryFile()
     cmd = ['git', 'daemon',
         '--export-all',
         '--reuseaddr',
         '--base-path=' + self.root_dir,
-        '--pid-file=' + self.git_pid_file.name]
+        '--pid-file=' + self.git_pid_file.name,
+        '--port=%d' % self.git_port]
     if self.host == '127.0.0.1':
       cmd.append('--listen=' + self.host)
     self.check_port_is_free(self.git_port)
     self.gitdaemon = Popen(cmd, cwd=self.root_dir)
-    self.wait_for_port_to_bind(self.git_port, self.gitdaemon)
+    wait_for_port_to_bind(self.host, self.git_port, self.gitdaemon)
+    self.populateGit()
     self.git_dirty = False
     return True
 
   def _commit_svn(self, tree):
     self._genTree(self.svn_checkout, tree)
     commit_svn(self.svn_checkout, self.USERS[0][0], self.USERS[0][1])
     if self.svn_revs and self.svn_revs[-1]:
       new_tree = self.svn_revs[-1].copy()
       new_tree.update(tree)
     else:
@@ skipping 15 matching lines @@
     sock = socket.socket()
     try:
       sock.connect((self.host, port))
       # It worked, throw.
       assert False, '%d shouldn\'t be bound' % port
     except EnvironmentError:
       pass
     finally:
       sock.close()
 
-  def wait_for_port_to_bind(self, port, process):
-    sock = socket.socket()
-
-    if sys.platform == 'darwin':
-      # On Mac SnowLeopard, if we attempt to connect to the socket
-      # immediately, it fails with EINVAL and never gets a chance to
-      # connect (putting us into a hard spin and then failing).
-      # Linux doesn't need this.
-      time.sleep(0.1)
-
-    try:
-      start = datetime.datetime.utcnow()
-      maxdelay = datetime.timedelta(seconds=30)
-      while (datetime.datetime.utcnow() - start) < maxdelay:
-        try:
-          sock.connect((self.host, port))
-          logging.debug('%d is now bound' % port)
-          return
-        except EnvironmentError:
-          pass
-        logging.debug('%d is still not bound' % port)
-    finally:
-      sock.close()
-    # The process failed to bind. Kill it and dump its ouput.
-    process.kill()
-    logging.error('%s' % process.communicate()[0])
-    assert False, '%d is still not bound' % port
-
-  def wait_for_port_to_free(self, port):
-    start = datetime.datetime.utcnow()
-    maxdelay = datetime.timedelta(seconds=30)
-    while (datetime.datetime.utcnow() - start) < maxdelay:
-      try:
-        sock = socket.socket()
-        sock.connect((self.host, port))
-        logging.debug('%d was bound, waiting to free' % port)
-      except EnvironmentError:
-        logging.debug('%d now free' % port)
-        return
-      finally:
-        sock.close()
-    assert False, '%d is still bound' % port
-
   def populateSvn(self):
     raise NotImplementedError()
 
   def populateGit(self):
     raise NotImplementedError()
 
 
 class FakeRepos(FakeReposBase):
   """Implements populateSvn() and populateGit()."""
   NB_GIT_REPOS = 4
@@ skipping 305 matching lines @@
     fake.set_up_git()
     print('Fake setup, press enter to quit or Ctrl-C to keep the checkouts.')
     sys.stdin.readline()
   except KeyboardInterrupt:
     trial_dir.TrialDir.SHOULD_LEAK.leak = True
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv))