Enable framework-specific install directories and environment

This commit is my proof-of concept, only the 'go' test works right now.
You can look at go/ to see the changes required on a per-framework
basis - essentially I've modified go/setup.py to move the declaration
of the environment into go/bash_profile.sh

Each framework now gets a personal <framework>/installs directory, and
can declare any needed environment variables in
<framework>/bash_profile.sh, such as modifications to the PATH.

The FwBm code now provides an FWROOT environment variable to
*all* shell scripts (instead of ~/Frameworks being assumed).
Also, an IROOT environment variable is provided to any framework-specific
files (e.g. install.sh and bash_profile.sh) for the location of the install directory
for that framework. See go/bash_profile.sh to see me using both IROOT and
FWROOT.

By using IROOT, the strategy for installation is still controlled by python code and
the frameworks just reference IROOT and FWROOT in their scripts. These
variables are a nice step towards solving #448

The new function replace_environ in setup_util.py goes a long way towards
addressing #899 - as you can see I've removed all the changes to the ~/.bash_profile
from prerequisites.sh (and this commit serves as proof that everything still works) and
most of the changes from config/benchmark_profile

go/bash_profile.sh

@@ -0,0 +1,6 @@
+# IROOT=${FWROOT}/go/installs
+
+export GOROOT=${IROOT}/go
+export PATH="$GOROOT/bin:$PATH"
+
+export GOPATH=${FWROOT}/go

go/setup.py

@@ -12,7 +12,7 @@ def start(args, logfile, errfile):
     subprocess.call("set GOPATH=C:\\FrameworkBenchmarks\\go&& go get ./...", shell=True, cwd="go", stderr=errfile, stdout=logfile)
     subprocess.Popen("setup.bat", shell=True, cwd="go", stderr=errfile, stdout=logfile) 
     return 0
-  os.environ["GOPATH"] = os.path.expanduser('~/FrameworkBenchmarks/go')
+  # os.environ["GOPATH"] = os.path.expanduser('~/FrameworkBenchmarks/go')
   subprocess.call("go get ./...", shell=True, cwd="go", stderr=errfile, stdout=logfile) 
   subprocess.Popen("go run src/hello/hello.go".rsplit(" "), cwd="go", stderr=errfile, stdout=logfile)
   return 0

toolset/benchmark/framework_test.py

@@ -1,4 +1,5 @@
 from benchmark.fortune_html_parser import FortuneHTMLParser
+from setup.linux import setup_util
 
 import importlib
 import os
@@ -285,6 +286,8 @@ class FrameworkTest:
   # Start the test using it's setup file
   ############################################################
   def start(self, out, err):
+    profile="%s/bash_profile.sh" % self.directory
+    setup_util.replace_environ(config=profile, command="IROOT=$FWROOT/go/installs")
     return self.setup_module.start(self.benchmarker, out, err)
   ############################################################
   # End start

toolset/run-tests.py

@@ -8,6 +8,7 @@ import subprocess
 from pprint import pprint 
 from benchmark.benchmarker import Benchmarker
 from setup.linux.unbuffered import Unbuffered
+from setup.linux import setup_util
 
 ###################################################################################################
 # Main
@@ -20,12 +21,15 @@ def main(argv=None):
     # Enable unbuffered output so messages will appear in the proper order with subprocess output.
     sys.stdout=Unbuffered(sys.stdout)
 
-    # Ensure the current directory (which should be the benchmark home directory) is in the path so that the tests can be imported.
+    # Update python environment
+    # 1) Ensure the current directory (which should be the benchmark home directory) is in the path so that the tests can be imported.
     sys.path.append('.')
-
-    # Ensure toolset/setup/linux is in the path so that the tests can "import setup_util".
+    # 2) Ensure toolset/setup/linux is in the path so that the tests can "import setup_util".
     sys.path.append('toolset/setup/linux')
 
+    # Update environment for shell scripts
+    setup_util.replace_environ(config='config/benchmark_profile', root=os.getcwd())
+
     conf_parser = argparse.ArgumentParser(
         description=__doc__,
         formatter_class=argparse.RawDescriptionHelpFormatter,
@@ -129,35 +133,8 @@ def main(argv=None):
     if args.verbose:
         print 'Configuration options: '
         pprint(args)
-    benchmarker = Benchmarker(vars(args))
 
-    # Ensure a consistent environment for any subprocesses run during
-    # the lifetime of this program
-    # Note: This will not work if your command starts with 'sudo', you
-    # will need sudo sh -c ". config/benchmark_profile && your_command"
-    setup_env = '. config/benchmark_profile && env'
-    mini_environ = os.environ.copy()
-    mini_environ.clear()
-    mini_environ['HOME']=os.environ['HOME']
-    mini_environ['PATH']=os.environ['PATH']
-    mini_environ['USER']=os.environ['USER']
-    fwroot=subprocess.check_output("pwd", shell=True)
-    mini_environ['FWROOT']=fwroot
-    os.environ.clear()
-    env = subprocess.check_output(setup_env, shell=True, env=mini_environ)
-    for line in env.split('\n'):
-        try:
-            split=line.index('=')
-            key=line[:split]
-            value=line[split+1:]
-            os.environ[key]=value
-        except:
-            print "WARN: Cannot parse %s from config/benchmark_profile" % line
-            continue
-
-    out = subprocess.check_output('env', shell=True)
-    print 'Checking environment'
-    print out
+    benchmarker = Benchmarker(vars(args))
 
     # Run the benchmarker in the specified mode
     if benchmarker.list_tests:

toolset/setup/linux/installer.py

@@ -6,6 +6,7 @@ import traceback
 import sys
 import glob
 import logging
+import setup_util
 
 class Installer:
 
@@ -32,8 +33,9 @@ class Installer:
   def __install_server_software(self):
     print("\nINSTALL: Installing server software\n")
     
-    bash_functions_path='../toolset/setup/linux/bash_functions.sh'
-    prereq_path='../toolset/setup/linux/prerequisites.sh'
+    # Install global prerequisites
+    bash_functions_path='$FWROOT/toolset/setup/linux/bash_functions.sh'
+    prereq_path='$FWROOT/toolset/setup/linux/prerequisites.sh'
     self.__run_command(". %s && . %s" % (bash_functions_path, prereq_path))
 
     # Pull in benchmarker include and exclude list
@@ -42,25 +44,47 @@ class Installer:
     if exclude == None:
         exclude = []
 
-    # Assume we are running from FrameworkBenchmarks
-    install_files = glob.glob('*/install.sh')
+    # Locate all known tests
+    install_files = glob.glob("%s/*/install.sh" % self.root)
 
-    for install_file in install_files:
-        test = os.path.dirname(install_file)
-        
-        if test in exclude:
-            logging.debug("%s has been excluded", test)
+    # Run install for selected tests
+    for test_install_file in install_files:
+        test_dir = os.path.dirname(test_install_file)
+        test_name = os.path.basename(test_dir)
+        test_rel_dir = self.__path_relative_to_root(test_dir)
+
+        if test_name in exclude:
+            logging.debug("%s has been excluded", test_name)
             continue
-        elif include is not None and test not in include:
-            logging.debug("%s not in include list", test)
+        elif include is not None and test_name not in include:
+            logging.debug("%s not in include list", test_name)
             continue
         else:
-            logging.debug("Running installer for %s", test)
-            bash_functions_path="../toolset/setup/linux/bash_functions.sh"
-            self.__run_command(". %s && . ../%s" % (bash_functions_path, install_file))
+            logging.info("Running installation for %s"%test_name)
 
-    self.__run_command("sudo apt-get -y autoremove");
-    
+            # Find installation directory e.g. FWROOT/go/installs
+            test_install_dir="%s/%s" % (test_dir, self.install_dir)
+            test_rel_install_dir=self.__path_relative_to_root(test_install_dir)
+            if not os.path.exists(test_install_dir):
+              os.makedirs(test_install_dir)
+
+            # Load profile for this installation
+            test_profile_file="%s/bash_profile.sh" % test_dir
+            if os.path.exists(test_profile_file):
+              setup_util.replace_environ(config=test_profile_file)
+            else:
+              logging.warning("Framework %s does not have a bash_profile"%test_name)
+
+            # Find relative installation file
+            test_rel_install_file = "$FWROOT%s"%self.__path_relative_to_root(test_install_file)
+
+            # Then run test installer file
+            # Give all installers FWROOT, IROOT, and bash_functions
+            self.__run_command("IROOT=$FWROOT%s . %s && . %s" % 
+              (test_rel_install_dir, bash_functions_path, test_rel_install_file),
+                cwd=test_install_dir)
+
+    self.__run_command("sudo apt-get -y autoremove");    
 
     print("\nINSTALL: Finished installing server software\n")
   ############################################################
@@ -247,10 +271,8 @@ EOF
   # __run_command
   ############################################################
   def __run_command(self, command, send_yes=False, cwd=None, retry=False):
-    try:
-      cwd = os.path.join(self.install_dir, cwd)
-    except AttributeError:
-      cwd = self.install_dir
+    if cwd is None: 
+        cwd = self.install_dir
 
     if retry:
       max_attempts = 5
@@ -261,12 +283,13 @@ EOF
     if send_yes:
       command = "yes yes | " + command
         
-
-    print("\nINSTALL: %s (cwd=%s)" % (command, cwd))
+    rel_cwd = self.__path_relative_to_root(cwd)
+    print("INSTALL: %s (cwd=%s)" % (command, rel_cwd))
 
     while attempt <= max_attempts:
       error_message = ""
       try:
+
         # Execute command.
         subprocess.check_call(command, shell=True, cwd=cwd, executable='/bin/bash')
         break  # Exit loop if successful.
@@ -303,6 +326,20 @@ EOF
   # End __bash_from_string
   ############################################################
 
+  ############################################################
+  # __path_relative_to_root
+  # Returns path minus the FWROOT prefix. Useful for clean 
+  # presentation of paths 
+  # e.g. /foo/bar/benchmarks/go/bash_profile.sh
+  # v.s. FWROOT/go/bash_profile.sh 
+  ############################################################
+  def __path_relative_to_root(self, path):
+    # Requires bash shell parameter expansion
+    return subprocess.check_output("D=%s && printf ${D#%s}"%(path, self.root), shell=True, executable='/bin/bash')
+  ############################################################
+  # End __path_relative_to_root
+  ############################################################
+
   ############################################################
   # __download
   # Downloads a file from a URI.
@@ -326,6 +363,7 @@ EOF
   def __init__(self, benchmarker):
     self.benchmarker = benchmarker
     self.install_dir = "installs"
+    self.root = subprocess.check_output('printf $FWROOT', shell=True)
     
     # setup logging
     logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)

toolset/setup/linux/prerequisites.sh

@@ -35,9 +35,6 @@ fw_exists ~/.bash_profile.bak
   mv ~/.bash_profile ~/.bash_profile.bak
 }
 
-cp ../config/benchmark_profile ~/.bash_profile
-cat ../config/benchmark_profile >> ~/.profile
-cat ../config/benchmark_profile >> ~/.bashrc
 sudo sh -c "echo '*               -    nofile          65535' >> /etc/security/limits.conf"
 
 touch fwbm_prereqs_installed

toolset/setup/linux/setup_util.py

@@ -1,4 +1,6 @@
 import re
+import os
+import subprocess
 
 # Replaces all text found using the regular expression to_replace with the supplied replacement.
 def replace_text(file, to_replace, replacement):
@@ -7,3 +9,53 @@ def replace_text(file, to_replace, replacement):
     replaced_text = re.sub(to_replace, replacement, contents)
     with open(file, "w") as f:
         f.write(replaced_text)
+
+# Replaces the current process environment with the one found in 
+# config file. Retains original HOME/PATH/USER by default (although)
+# this can be overwritten by config if desired
+#
+# Note: This will not work if the command you are running from python
+# starts with sudo (e.g. subprocess.check_call("sudo <command>")). 
+# If you must do this, consider sudo sh -c ". <config> && your_command"
+#
+# This will work if you run a command that internally calls sudo, 
+# as long as your /etc/sudoers correctly has the NOPASSWD option set
+def replace_environ(config=None, root=None, print_result=False, command='true'):
+    # Source file and print resulting environment
+    setup_env = "%s && . %s && env" % (command, config)
+    mini_environ = os.environ.copy()
+    mini_environ.clear()
+    if 'HOME' in os.environ.keys():
+        mini_environ['HOME']=os.environ['HOME']
+    if 'PATH' in os.environ.keys():
+        mini_environ['PATH']=os.environ['PATH']
+    if 'USER' in os.environ.keys():
+        mini_environ['USER']=os.environ['USER']
+    if 'LD_LIBRARY_PATH' in os.environ.keys():
+        mini_environ['LD_LIBRARY_PATH'] = os.environ['LD_LIBRARY_PATH']
+    if 'PYTHONPATH' in os.environ.keys():
+        mini_environ['PYTHONPATH'] = os.environ['PYTHONPATH']
+
+    if root is not None: 
+      mini_environ['FWROOT']=root
+    elif 'FWROOT' in os.environ.keys():
+        mini_environ['FWROOT']=os.environ['FWROOT']
+    
+    os.environ.clear()
+    env = subprocess.check_output(setup_env, shell=True, env=mini_environ,
+      executable='/bin/bash')
+    for line in env.split('\n'):
+        try:
+            split=line.index('=')
+            key=line[:split]
+            value=line[split+1:]
+            os.environ[key]=value
+        except:
+            if not line: # Don't warn for empty line
+                continue 
+            print "WARN: Line '%s' from '%s' is not an environment variable" % (line, config)
+            continue
+    if print_result:
+        out = subprocess.check_output('env', shell=True, executable='/bin/bash')
+        print "Environment after loading %s" %config
+        print out