Updated regression script.

Author: glynos

libs/network/tools/regression.py

@@ -4,7 +4,13 @@
 #          http://www.boost.org/LICENSE_1_0.txt)
 #
 # This script downloads either a tarball or zipfile of the latest version of the
-# main repo.
+# main repo, unpacks it, runs bjam (including all unit tests) and creates a file
+# that contains all the information needed to evaluate any regression failures.
+#
+# 1. Create a directory where you want to run the test
+# 2. Download this script
+# 3. Run this script: python regression.py [options]
+# 4. E-mail the `cpp_netlib_regression.txt` file to the developers
 #
 
 
@@ -17,150 +23,202 @@
 import subprocess
 
 
-#
-# Some constants
-#
-repo_root = "http://github.com/mikhailberis/cpp-netlib/"
-branch = "0.6-devel"
-boost_minimum_version = "1_40"
 
+class RegressionTester:
+    """  """
+
+    def __init__(self):
+        """  """
 
-def check_boost_installation():
-    """ Gets information about the user's boost environment. """
+        self._repo_root = "http://github.com/mikhailberis/cpp-netlib/"
+        self._boost_minimum_version = "1_40"
 
-    env = os.getenv("BOOST_ROOT")
-    assert(env is not None)
+    def check_boost_installation(self):
+        """ Gets information about the user's boost environment. """
 
-    # get boost version from version.hpp
-    version = None
-    version_hpp = os.path.join(env, "boost", "version.hpp")
-    f = open(version_hpp, "r")
-    for line in f:
-        if line.startswith("#define BOOST_LIB_VERSION"):
-            begin = string.find(line, '"')
-            end = string.rfind(line, '"')
-            version = line[begin + 1:end]
-            break
+        env = os.getenv("BOOST_ROOT")
+        assert(env is not None)
 
-    class Params: pass
-    params = Params()
-    params.root = env
-    params.version = version
-    return params
+        # get boost version from version.hpp
+        version = None
+        version_hpp = os.path.join(env, "boost", "version.hpp")
+        f = open(version_hpp, "r")
+        for line in f:
+            if line.startswith("#define BOOST_LIB_VERSION"):
+                begin = string.find(line, '"')
+                end = string.rfind(line, '"')
+                version = line[begin + 1:end]
+                break
 
+        class Params: pass
+        params = Params()
+        params.root = env
+        params.version = version
+        return params
 
-def build(bjam, user_config=None):
-    """  """
+    def download(self, branch):
+        """  """
 
-    if bjam is None:
-        bjam = "bjam"
+        raise NotImplementedError
 
-    results = open("results.txt", "w+")
-    rc = subprocess.call(bjam, stdout=results, stderr=results)
+    def get_commit(self, filename):
+        """  """
+
+        (root, ext) = os.path.splitext(filename)
+        (root, ext) = os.path.splitext(root)
+        return root.split("-")[-1]
 
+    def unpack(self, filename):
+        """  """
+
+        raise NotImplementedError
 
-def download_tarball(stage):
-    """ Downloads the latest tarball from the mikhailberis fork. """
+    def build(self, results, bjam):
+        """  """
+
+        rc = subprocess.call(bjam, stdout=results, stderr=results)
+
+    def run(self, runner, branch, bjam=None, user_config=None):
+        """  """
+        
+        boost_params = self.check_boost_installation()
+        assert(boost_params.version is not None)
+        assert(boost_params.version > self._boost_minimum_version)
+
+        results = "cpp_netlib_regression.txt"
+        results_file = open(results, "w+")
+        
+        filename = self.download(branch)
+        commit = self.get_commit(filename)
+        
+        self.unpack(filename)
+
+        if bjam is None:
+            bjam = "bjam"
 
-    r = urllib2.urlopen(repo_root + "tarball/" + branch)
-    filename = urlparse.urlparse(r.geturl()).path.split("/")[-1]
-    path = os.path.join(stage, filename)
-    f = open(path, "w+")
-    f.write(r.read())
-    return filename
-
-def unpack_tarball(stage, filename):
-    """ Unpacks the tarball into a stage directory. """
-
-    import tarfile
-    import shutil
-
-    (root, ext) = os.path.splitext(filename)
-    (root, ext) = os.path.splitext(root)
-    if os.path.exists(os.path.join(stage, root)):
-        shutil.rmtree(os.path.join(stage, root))
-
-    os.chdir(stage)
-    f = tarfile.open(os.path.join(stage, filename))
-    f.extractall()
-    os.chdir(root)
+        if user_config is not None:
+            bjam = "%s --user-config=%s" % (bjam,u ser_config)
+        
+        self.build(results_file, bjam)
+
+        results_file.write("\n\n")
+        results_file.write("runner: %s\n" % runner)
+        results_file.write("git_branch: %s\n" % branch)
+        results_file.write("boost_root: %s\n" % boost_params.root)
+        results_file.write("boost_version: %s\n" % boost_params.version)
+        results_file.write("commit: %s\n" % commit)
+
+        return results
+
+
+class RegressionTesterWithTar(RegressionTester):
+    """  """
+
+    def __init__(self):
+        RegressionTester.__init__(self)
+
+    def download(self, branch):
+        """ Downloads the latest tarball from the mikhailberis fork. """
 
+        r = urllib2.urlopen(self._repo_root + "tarball/" + branch)
+        filename = urlparse.urlparse(r.geturl()).path.split("/")[-1]
+        f = open(filename, "w+")
+        f.write(r.read())
+        return filename
+
+    def unpack(self, filename):
+        """ Unpacks the tarball into a stage directory. """
+
+        import tarfile
+        import shutil
+
+        (root, ext) = os.path.splitext(filename)
+        (root, ext) = os.path.splitext(root)
+        if os.path.exists(root):
+            shutil.rmtree(root)
+
+        f = tarfile.open(filename)
+        f.extractall()
+        os.chdir(root)
+
 
-def download_zipball(stage):
-    """ Downloads the latest zipfile from the mikhailberis fork. """
+class RegressionTesterWithZip(RegressionTester):
+    """  """
+
+    def __init__(self):
+        RegressionTester.__init__(self)
+        
+    def download(self, branch):
+        """ Downloads the latest zipfile from the mikhailberis fork. """
 
-    r = urllib2.urlopen(repo_root + "zipball/" + branch)
-    filename = urlparse.urlparse(r.geturl()).path.split("/")[-1]
-    path = os.path.join(stage, filename)
-    f = open(path, "w+")
-    f.write(r.read())
-    return filename
+        r = urllib2.urlopen(self._repo_root + "zipball/" + branch)
+        filename = urlparse.urlparse(r.geturl()).path.split("/")[-1]
+        f = open(filename, "w+")
+        f.write(r.read())
+        return filename
 
-def unpack_zipball(stage, filename):
-    """ Unpacks the zip file into a stage directory. """
+    def unpack(self, filename):
+        """ Unpacks the zip file into a stage directory. """
 
-    import zipfile
-    import shutil
+        import zipfile
+        import shutil
 
-    (root, ext) = os.path.splitext(filename)
-    (root, ext) = os.path.splitext(root)
-    if os.path.exists(os.path.join(stage, root)):
-        shutil.rmtree(os.path.join(stage, root))
+        (root, ext) = os.path.splitext(filename)
+        (root, ext) = os.path.splitext(root)
+        if os.path.exists(root):
+            shutil.rmtree(root)
 
-    os.chdir(stage)
-    f = zipfile.ZipFile(os.path.join(stage, filename))
-    f.extractall()
-    os.chdir(root)
+        f = zipfile.ZipFile(filename)
+        f.extractall()
+        os.chdir(root)
 
 
 if __name__ == "__main__":
 
     opt = optparse.OptionParser(
         usage="%prog [options]")
-    
-    opt.add_option("--zip",
-                   action="store_false",
-                   help="Downloads the zip file.")
-    opt.add_option("--tar",
-                   action="store_false",
-                   help="Downloads the tar.gz file.")
-    opt.add_option("--stage",
-                   metavar="DIR",
-                   help="the stage directory.")
+
+    opt.add_option("--runner",
+                   metavar="RUNNER",
+                   help="A real name to identify the test runner.")
+    opt.add_option("--package",
+                   metavar="ZIP/TAR",
+                   help="Specify 'zip' to download the zip file, or 'tar' to "
+                        "download the tarball.")
     opt.add_option("--branch",
                    help="the Git branch to check.")
     opt.add_option("--bjam",
-                   help="The path to the bjam binary if it's not in the system path.")
+                   help="The path to the bjam binary if it's not in the system "
+                        "path.")
     opt.add_option("--user-config",
                    metavar="FILE",
                    help="the user-config file to use.")
 
     (opts, args) = opt.parse_args()
 
-    if (opts.zip is None and opts.tar is None) or \
-            (opts.zip is not None and opts.tar is not None):
-        print("Please specify either zip or tar")
+    if opt.runner is None:
+        opt.print_help()
         sys.exit(-1)
 
-    if opts.stage is None:
-        opts.stage = "/tmp"
-    print("stage: %s" % opts.stage)
+    if opts.branch is None:
+        opt.print_help()
+        sys.exit(-1)
 
-    boost_params = check_boost_installation()
-    assert(boost_params.version is not None)
-    assert(boost_params.version > boost_minimum_version)
-    print("boost_root: %s" % boost_params.root)
-    print("boost_version: %s" % boost_params.version)
+    if opts.package not in ["zip", "tar"]:
+        opt.print_help()
+        sys.exit(-1)
+        
+    if opts.package == "zip":
+        tester = RegressionTesterWithZip()
+    elif opts.package == "tar":
+        tester = RegressionTesterWithTar()
 
     try:
-        if opts.zip is not None:
-            filename = download_zipball(opts.stage)
-            unpack_zipball(opts.stage, filename)
-        elif opts.tar is not None:
-            filename = download_tarball(opts.stage)
-            unpack_tarball(opts.stage, filename)
-
-        build(opts.bjam, opts.user_config)
-
+        results = tester.run(opts.runner,
+                             opts.branch,
+                             bjam=opts.bjam,
+                             user_config=opts.user_config)
+        print("The regression results are found in `%s`." % results)
+        print("Please e-mail this to the project administrators at `[email protected]`")
     except Exception, e:
         print(e)