text: #!/usr/bin/python
  
  import re
  import sys
  import os
  import tempfile
  import urllib2
  import subprocess
  import tarfile
  import zipfile
  import shutil
  import errno
  # To ensure it exists on the system
  import gzip
  import argparse
  
  #
  # Useful script for installing multiple versions of MongoDB on a machine
  # Only really tested/works on Linux.
  #
  
  def version_tuple(version):
      """Returns a version tuple that can be used for numeric sorting
      of version strings such as '2.6.0-rc1' and '2.4.0'"""
  
      RC_OFFSET = -100
      version_parts = re.split(r'\.|-', version[0])
  
      if version_parts[-1].startswith("rc"):
          rc_part = version_parts.pop()
          rc_part = rc_part.split('rc')[1]
  
          # RC versions are weighted down to allow future RCs and general
          # releases to be sorted in ascending order (e.g., 2.6.0-rc1,
          # 2.6.0-rc2, 2.6.0).
          version_parts.append(int(rc_part) + RC_OFFSET)
      else:
          # Non-RC releases have an extra 0 appended so version tuples like
          # (2, 6, 0, -100) and (2, 6, 0, 0) sort in ascending order.
          version_parts.append(0)
  
      return tuple(map(int, version_parts))
  
  class MultiVersionDownloaderBase : 
  
      def download_version(self, version):
  
          try:
              os.makedirs(self.install_dir)
          except OSError as exc:
              if exc.errno == errno.EEXIST and os.path.isdir(self.install_dir):
                  pass
              else: raise
  
          url, full_version = self.gen_url(version)
  
          # this extracts the filename portion of the URL, without the extension.
          # for example: ttp://downloads.mongodb.org/osx/mongodb-osx-x86_64-2.4.12.tgz
          # extract_dir will become mongodb-osx-x86_64-2.4.12
          extract_dir = url.split("/")[-1][:-4]
  
          # only download if we don't already have the directory
          already_downloaded = os.path.isdir(os.path.join( self.install_dir, extract_dir))
          if already_downloaded:
              print "Skipping download for version %s (%s) since the dest already exists '%s'" \
                  % (version, full_version, extract_dir)
          else:
              temp_dir = tempfile.mkdtemp()
              temp_file = tempfile.mktemp(suffix=".tgz")
  
              print "Downloading data for version %s (%s) from %s..." % (version, full_version, url)
  
              data = urllib2.urlopen(url)
  
              with open(temp_file, 'wb') as f:
                  f.write(data.read())
                  print "Uncompressing data for version %s (%s)..." % (version, full_version)
  
              try:
                  tf = tarfile.open(temp_file, 'r:gz')
                  tf.extractall(path=temp_dir)
                  tf.close()
              except:
                  # support for windows
                  zfile = zipfile.ZipFile(temp_file)
                  try:
                      if not os.path.exists(temp_dir):
                          os.makedirs(temp_dir)
                      for name in zfile.namelist():
                          _, filename = os.path.split(name)
                          print "Decompressing " + filename + " on " + temp_dir
                          zfile.extract(name, temp_dir)
                  except:
                      zfile.close()
                      raise
                  zfile.close()
              temp_install_dir = os.path.join(temp_dir, extract_dir)
              try:
                  os.stat(temp_install_dir)
              except:
                  dir = os.listdir(temp_dir)
                  # TODO confirm that there is one and only one directory entry
                  os.rename(os.path.join(temp_dir,dir[0]),temp_install_dir)
              shutil.move(temp_install_dir, self.install_dir)
              shutil.rmtree(temp_dir)
              try:
                  os.remove(temp_file)
              except Exception as e:
                  print e
                  pass
          self.symlink_version(version, os.path.abspath(os.path.join(self.install_dir, extract_dir)))
  
      def symlink_version(self, version, installed_dir):
  
          try:
              os.makedirs(self.link_dir)
          except OSError as exc:
              if exc.errno == errno.EEXIST and os.path.isdir(self.link_dir):
                  pass
              else: raise
  
          for executable in os.listdir(os.path.join(installed_dir, "bin")):
              link_name = "%s-%s" % (executable, version)
              # support for windows
              if executable.endswith(".exe") or executable.endswith(".pdb"):
                  link_name = "%s-%s.%s" % (executable[:-4], version, executable[len(executable)-3:])
  
              try:
                  os.symlink(os.path.join(installed_dir, "bin", executable),\
                             os.path.join(self.link_dir, link_name))
              except Exception as exc:
                  try:
                      # support for windows
                      shutil.copy2(os.path.join(installed_dir, "bin", executable),\
                                 os.path.join(self.link_dir, link_name))
                  except:
                      if exc.errno == errno.EEXIST:
                          pass
                      else:
                          raise
  
  class MultiVersionDownloader(MultiVersionDownloaderBase) :
  
      def __init__(self, install_dir, link_dir, platform):
          self.install_dir = install_dir
          self.link_dir = link_dir
          match = re.compile("(.*)\/(.*)").match(platform)
          self.platform = match.group(1)
          self.arch = match.group(2)
          self._links = None
  
      @property
      def links(self):
          if self._links is None:
              self._links = self.download_links()
          return self._links
  
      def gen_url(self, version):
          urls = []
          for link_version, link_url in self.links.iteritems():
              if link_version.startswith(version):
                  # If we have a "-" in our version, exact match only
                  if version.find("-") >= 0:
                      if link_version != version: continue
                  elif link_version.find("-") >= 0:
                      continue
  
                  urls.append((link_version, link_url))
  
          if len(urls) == 0:
              raise Exception("Cannot find a link for version %s, versions %s found." \
                  % (version, self.links))
  
          urls.sort(key=version_tuple)
          full_version = urls[-1][0]
          url = urls[-1][1]
          return url, full_version
  
      def download_links(self):
          href = "http://dl.mongodb.org/dl/%s/%s" \
                 % (self.platform, self.arch)
  
          html = urllib2.urlopen(href).read()
          links = {}
          for line in html.split():
              match = None
              for ext in ["tgz", "zip"]:
                  match = re.compile("http:\/\/downloads\.mongodb\.org\/%s/mongodb-%s-%s-([^\"]*)\.%s" \
                      % (self.platform, self.platform, self.arch, ext)).search(line)
                  if match != None:
                      break
  
              if match == None:
                  continue
              link = match.group(0)
              version = match.group(1)
              links[version] = link
  
          return links
  
  
  class LatestMultiVersionDownloader(MultiVersionDownloaderBase) :
  
      def __init__(self, install_dir, link_dir, platform, use_ssl, os):
          self.install_dir = install_dir
          self.link_dir = link_dir
          match = re.compile("(.*)\/(.*)").match(platform)
          self.platform = match.group(1)
          self.arch = match.group(2)
          self._links = None
          self.use_ssl = use_ssl
          self.os = os
  
      def gen_url(self, version):
          ext = "tgz"
          if "win" in self.platform:
              ext = "zip"
          if self.use_ssl:
              if version == "2.4":
                  enterprise_string = "subscription"
              else:
                  enterprise_string = "enterprise"
              full_version = self.os + "-v" + version + "-latest"
              url = "http://downloads.10gen.com/%s/mongodb-%s-%s-%s-%s.%s" % ( self.platform, self.platform, self.arch, enterprise_string, full_version, ext )
          else:
              full_version = "v" + version + "-latest"
              url = "http://downloads.mongodb.org/%s/mongodb-%s-%s-%s.%s" % ( self.platform, self.platform, self.arch, full_version, ext )
          return url, full_version
  
  CL_HELP_MESSAGE = \
  """
  Downloads and installs particular mongodb versions (each binary is renamed to include its version) 
  into an install directory and symlinks the binaries with versions to another directory.
  
  Usage: setup_multiversion_mongodb.py INSTALL_DIR LINK_DIR PLATFORM_AND_ARCH VERSION1 [VERSION2 VERSION3 ...]
  
  Ex: setup_multiversion_mongodb.py ./install ./link "Linux/x86_64" "2.0.6" "2.0.3-rc0" "2.0" "2.2" "2.3"
  Ex: setup_multiversion_mongodb.py ./install ./link "OSX/x86_64" "2.4" "2.2"
  
  After running the script you will have a directory structure like this:
  ./install/[mongodb-osx-x86_64-2.4.9, mongodb-osx-x86_64-2.2.7]
  ./link/[mongod-2.4.9, mongod-2.2.7, mongo-2.4.9...]
  
  You should then add ./link/ to your path so multi-version tests will work.
  
  Note: If "rc" is included in the version name, we'll use the exact rc, otherwise we'll pull the highest non-rc
  version compatible with the version specified.
  """
  
  def parse_cl_args(args):
  
      parser = argparse.ArgumentParser(description=CL_HELP_MESSAGE)
  
      def raise_exception(msg):
          print CL_HELP_MESSAGE
          raise Exception(msg)
  
      parser.add_argument('install_dir', action="store" )
      parser.add_argument('link_dir', action="store" )
      parser.add_argument('platform_and_arch', action="store" )
      parser.add_argument('--latest', action="store_true" )
      parser.add_argument('--use-ssl', action="store_true" )
      parser.add_argument('--os', action="store" )
      parser.add_argument('version', action="store", nargs="+" )
  
      args = parser.parse_args()
  
      if re.compile(".*\/.*").match(args.platform_and_arch) == None:
          raise_exception("PLATFORM_AND_ARCH isn't of the correct format")
  
      if args.latest:
          if not args.os:
              raise_exception("using --use-ssl requires an --os parameter")
          return (LatestMultiVersionDownloader(args.install_dir, args.link_dir, args.platform_and_arch, args.use_ssl, args.os), args.version)
      else:
          if args.use_ssl:
              raise_exception("you can only use --use-ssl when using --latest")
          return (MultiVersionDownloader(args.install_dir, args.link_dir, args.platform_and_arch), args.version)
  
  def main():
  
      downloader, versions = parse_cl_args(sys.argv[1:])
  
      for version in versions:
          downloader.download_version(version)
  
  
  
  if __name__ == '__main__':
    main()
  
  