This script is the part of the SALOME installation procedure.
Author : Vadim SANDLER, Open CASCADE SAS (vadim.sandler@opencascade.com)
Created : Thu Dec 18 12:01:00 2002
-Copyright : 2002-2007 CEA
+Copyright : 2002-2008 CEA
"""
-__version__ = "1.0.1"
+__version__ = "1.1.5"
+
+# --- imports --- #
+import sys
+try:
+ import xml.sax, xml.dom.minidom
+ import os, re
+ import types
+ import random
+ import warnings
+except Exception, an_exc:
+ sys.exit("Error: %s! Please check the installed Python package." % str(an_exc))
+ pass
# --- avoid "deprecation" warnings --- #
-import warnings
warnings.filterwarnings("ignore", "", DeprecationWarning)
-# --- imports --- #
-import xmllib
-import sys, os, re
-import types
-import random
-
# --- global variables --- #
opt_parser = None
root_path = None
-# --- XML tags definition --- #
-__TAG__SOURCES__ = "install sources"
-__TAG__BINARIES__ = "install binaries"
-__TAG__NATIVE__ = "use native"
-__TAG__PREINSTALL__ = "not install"
-__TAG__BUILDSRC__ = "build sources"
+# --- actions definition --- #
+__BINARIES__ = "install_binary"
+__BUILDSRC__ = "install_source_and_build"
+__PREINSTALL__ = "try_preinstalled"
-# --- product context definition --- #
-__CTX__SALOME__SRC__ = "salome sources"
-__CTX__SALOME__BIN__ = "salome binaries"
+# --- product type definition --- #
+__CTX__COMPONENT__ = "component"
__CTX__PREREQUISITE__ = "prerequisite"
#------------------------------------------------------------------#
msg = "invalid type: %s : should be 'bool' or None" % self.type
raise OptError(msg, self)
# default
- if self.default:
+ if self.default is not None:
try:
if self.type == "string": self.default = str(self.default)
if self.type == "int": self.default = int(self.default)
if not args: args = sys.argv[1:]
values = Values()
for o in self.options:
- if o.default:
+ if o.default is not None:
setattr(values, o.dest, o.default)
elif not hasattr(values,o.dest):
setattr(values, o.dest, None)
theCaption = None,
theCopyright = None,
theLicense = None,
- thePlatforms = None,
- theTargetdir = None,
- theTmpdir = None):
+ theTargetdir = None):
self.version = strip(theVersion)
self.caption = strip(theCaption)
self.copyright = strip(theCopyright)
self.license = strip(theLicense)
- self.platforms = strip(thePlatforms)
self.targetdir = strip(theTargetdir)
- self.tmpdir = strip(theTmpdir)
-
-## #===================================================================
-## # class Path : default target, temporary directories options
-## #===================================================================
-## class Path :
-## """
-## Path options:
-## - default target directory
-## - default temporary directory
-## """
-## def __init__(self,
-## theTargetdir = None,
-## theTmpdir = None):
-## self.targetdir = strip(theTargetdir)
-## self.tmpdir = strip(theTmpdir)
-
+
#==============================================================
# class Product : pre-requisite product options
#==============================================================
Product options:
- name, version
- target Linux OS version
- - supported installation modes and the default one
- dependencies
- required disk space
- installation script
def __init__(self,
theName,
theType = None,
- theOS = None,
theVersion = None,
- theInstall = None,
- theSupportred = None,
theDependencies = None,
theInstalldiskspace = None,
- theTemporarydiskspace = None,
theScript = None,
thePickUpEnvironment = None):
self.name = strip(theName)
self.type = strip(theType)
- self.os = strip(theOS)
self.version = strip(theVersion)
- self.install = strip(theInstall)
- self.supported = strip(theSupportred)
self.dependencies = strip(theDependencies)
self.installdiskspace = strip(theInstalldiskspace)
- self.temporarydiskspace = strip(theTemporarydiskspace)
self.script = strip(theScript)
self.pickupEnv = strip(thePickUpEnvironment)
- self.whattodo = self.install
+ self.whattodo = __BUILDSRC__
- def hasContext(self, ctx):
- try:
- return ctx in [ strip(s) for s in self.context.split(",") ]
- except:
- pass
- return False
-
def setMode(self, mode):
- if mode not in [__TAG__SOURCES__, __TAG__BINARIES__, __TAG__NATIVE__, __TAG__PREINSTALL__]:
+ if mode not in [__BINARIES__, __BUILDSRC__, __PREINSTALL__]:
return
- try:
- supported = [ strip(s) for s in self.supported.split(",") ]
- if mode in supported or mode == __TAG__PREINSTALL__:
- self.install = mode
- self.whattodo = self.install
- salbin = self.hasContext(__CTX__SALOME__BIN__)
- salsrc = self.hasContext(__CTX__SALOME__SRC__)
- if mode == __TAG__SOURCES__:
- if salbin and not salsrc:
- self.install = __TAG__PREINSTALL__
- self.whattodo = self.install
- elif salsrc:
- self.whattodo = __TAG__BUILDSRC__
- except:
- pass
+ self.whattodo = mode
return
#===================================================================
# class ConfigParser : XML files parser implementation
#===================================================================
-class ConfigParser(xmllib.XMLParser):
+class ConfigParser:
"""
XML configuration files parser
"""
- def __init__(self, is_force_src=False):
- xmllib.XMLParser.__init__(self)
+ def __init__(self):
+ self.docElem = None
self.products = []
- self.currentdata = []
-## self.path = None
+ self.full_prods_list = []
self.config = None
- self.is_force_src = is_force_src
+ self.pltname = None
+ pass
- def handle_data(self, data):
- self.currentdata.append(data)
+ def parse_config(self):
+ # Parse 'config' part of the XML file
+ configElem = self.docElem.getElementsByTagName('config')[0]
- def start_config(self, attrs):
- self.config = Config(attrs.get('version', None),
- attrs.get('caption', None),
- attrs.get('copyright', None),
- attrs.get('license', None),
- attrs.get('platforms', None),
- attrs.get('targetdir', None),
- attrs.get('tempdir', None))
+ self.config = Config(configElem.getAttribute('version').strip(),
+ configElem.getAttribute('caption').strip(),
+ configElem.getAttribute('copyright').strip(),
+ configElem.getAttribute('license').strip(),
+ configElem.getAttribute('targetdir').strip())
pass
- def end_config(self):
- pass
-
- def start_product(self, attrs):
- if not attrs.get('name', '').strip(): return
- if check_bool(attrs.get('disable', 'false')): return
- aProduct = Product(attrs.get('name'),
- attrs.get('type', None),
- attrs.get('version', None),
- attrs.get('install', None),
- attrs.get('supported', None),
- attrs.get('dependancies', None),
- attrs.get('installdiskspace', None),
- attrs.get('temporarydiskspace', None),
- attrs.get('script', None),
- attrs.get('pickupenv', None))
- if self.is_force_src:
- aProduct.setMode(__TAG__SOURCES__)
- self.products.append(aProduct)
+ def parse_dependencies(self):
+ # Parse 'dependencies' part of the XML file
+ depsMap = {}
+ if not len(self.docElem.getElementsByTagName('dependencies')):
+ return depsMap;
+ depsElem = self.docElem.getElementsByTagName('dependencies')[0]
+ for prodElem in depsElem.getElementsByTagName('product'):
+ prodName = prodElem.getAttribute('name').strip()
+ if not prodName: continue
+ depsList = []
+ for depElem in prodElem.getElementsByTagName('dep'):
+ depsList.append(depElem.firstChild.data)
+ pass
+ depsMap[prodName] = depsList
+ pass
+ return depsMap
+
+ def parse_product(self):
+ # Parse 'products' part of the XML file
+ depsMap = self.parse_dependencies()
+ prodsElem = self.docElem.getElementsByTagName('products')[0]
+ sal_prods_list = []; req_prods_list = []
+ modules_list = []; prereqs_list = []
+ for prodElem in prodsElem.getElementsByTagName('product'):
+ prodName = prodElem.getAttribute('name').strip()
+ if not prodName: continue
+ instElems = prodElem.getElementsByTagName('installation')
+ instElem = None
+ for node in instElems:
+ if not self.pltname or self.pltname == node.getAttribute('os').strip():
+ instElem = node
+ break
+ pass
+ if not instElem: continue
+ if check_bool(str(instElem.getAttribute('disable').strip())): continue
+ depsList = []
+ if prodName in depsMap: depsList = depsMap[prodName]
+ aProduct = Product(prodName,
+ prodElem.getAttribute('type').strip(),
+ instElem.getAttribute('version').strip(),
+ depsList,
+ instElem.getAttribute('installdiskspace').strip(),
+ instElem.getAttribute('script').strip())
+ if prodElem.getAttribute('type').strip() == "component":
+ sal_prods_list.append(aProduct)
+ # fill an ordered modules list -----------
+ modules_list.append(prodName)
+ modules_list.append(prodName + "_src")
+ pass
+ else: #prerequisite
+ req_prods_list.append(aProduct)
+ # fill an ordered prerequisites list -----------
+ prereqs_list.append(prodName)
+ pass
+ pass
+ self.products.extend( req_prods_list )
+ self.products.extend( sal_prods_list )
+ self.full_prods_list.extend( prereqs_list )
+ self.full_prods_list.extend( modules_list )
pass
- def end_product(self):
- pass
+ def parse(self, xml_file):
+ filehandle = open(xml_file)
+ sax_parser = xml.sax.make_parser()
+ doc = xml.dom.minidom.parse(filehandle, sax_parser)
+ filehandle.close()
- def start_installation(self, attrs):
-## anInstallation = Installation(attrs.get('os', None),
-## attrs.get('type', None),
-## attrs.get('version', None),
-## attrs.get('install', None),
-## attrs.get('supported', None),
-## attrs.get('dependancies', None),
-## attrs.get('installdiskspace', None),
-## attrs.get('temporarydiskspace', None),
-## attrs.get('script', None),
-## attrs.get('pickupenv', None))
+ self.docElem = doc.documentElement
+ self.parse_config()
+ self.parse_product()
pass
-
- def end_installation(self):
- pass
-
-## def start_path (self, attrs):
-## self.path = Path(attrs.get('targetdir', None),
-## attrs.get('tempdir', None))
-## pass
-
-## def end_path(self):
-## pass
def getProduct(self, prod):
for product in self.products:
return product
return None
- def getInstallation(self, os):
- for product in self.products:
- if product.name == prod:
- return product
- return None
#------------------------------------------------------------------#
# #
dest="gui",
help=help_str)
help_str = "The configuration xml file.\n"
- help_str += "If this parameter is missing, then the program tries to define the "
- help_str += "Linux platform and use the corresponding xml file. For example, "
- help_str += "for Red Hat 8.0 config_RedHat_8.0.xml file is used in this case. "
+ help_str += "If this parameter is missing, then the default 'config.xml'"
+ help_str += "configuration file will be used."
opt_parser.add_option("-f",
"--file",
action="store",
dest="target_dir",
metavar="DIR",
help=help_str)
- help_str = "The directory to be used for temporary files.\n"
- help_str += "When used this parameter overrides the default temporary directory "
- help_str += "defined in the configuration xml file."
- opt_parser.add_option("-t",
- "--tmp",
- action="store",
- dest="tmp_dir",
- metavar="DIR",
- help=help_str)
help_str = "Prints version information and quits."
opt_parser.add_option("-v",
"--version",
os.system(cmd)
print ""
sys.exit(0)
- return [options.xmlfile, options.target_dir, options.tmp_dir, options.gui]
+ return [options.xmlfile, options.target_dir, options.gui]
#=================================================================
# strip : removes spaces at the beginning and at the end of the
#=================================================================
def get_dependencies(prods):
"""
- Gets full list of pre-requisite products.
+ Gets a list of installed and required products.
"""
- list = []
+ prods_list = []
for product in prods:
- deps = product.dependencies.split(",")
- for dep in deps:
- if dep and not dep in list:
- list.append( dep )
-
- if product and not product in list:
- list.append( product.name )
+ for dep in product.dependencies:
+ if dep and dep not in prods_list:
+ prods_list.append( dep )
+ dep_name = dep
+ if product.whattodo == __BUILDSRC__:
+ dep_name = dep + "_src"
+ if dep_name not in parser.full_prods_list:
+ msg = "Prerequisite '%s' is required for '%s' product,\n"%(dep, product.name)
+ msg += "but the first one is absent in the list of products to be installed!\n"
+ msg += "Please check your XML file."
+ warning(msg)
+
+ if product.name and product.name not in prods_list:
+ prods_list.append( product.name )
- return " ".join( list )
+ return " ".join( prods_list )
#==============================================================
# create_dir : creates a directory with (optional) permissions,
# check_disk_space : checks the disk space;
# quits if there is no enough disk space
#===============================================================
-def check_disk_space(products, scripts_dir, target_dir, tmp_dir, is_force_src=False):
+def check_disk_space(products, scripts_dir, target_dir):
"""
Checks if there is enough disk space to install products.
Quits with error if there is no enough disk space.
install_space = 0
temporary_space = 0
for product in products:
- if product.install in [__TAG__NATIVE__, __TAG__PREINSTALL__]:
- continue
prod_space = 0
try:
spaces = product.installdiskspace.split(',')
prod_space = int( spaces[0] )
- if len( spaces ) > 1 and product.install == __TAG__SOURCES__ and not is_force_src:
- prod_space = int( spaces[1] )
+ if product.whattodo == __BINARIES__:
+ prod_space = int( spaces[0] )
+ if product.type == __CTX__COMPONENT__:
+ prod_space += int( spaces[1] )
+ else:
+ if product.type == __CTX__PREREQUISITE__:
+ prod_space = int( spaces[0] )
+ else:
+ prod_space = int( spaces[2] )
except:
pass
install_space = install_space + prod_space
- if product.install == __TAG__SOURCES__:
- tmp_space = 0
- try:
- tmp_space = int( product.temporarydiskspace )
- except:
- pass
- temporary_space = max( temporary_space, tmp_space )
pass
res = os.system("%s/%s %s %d"%(scripts_dir, "checkSize.sh", target_dir, install_space))
if res:
msg = "There is no enough space to install the products. Stopped..."
error_exit(msg, False)
-
- res = os.system("%s/%s %s %d"%(scripts_dir, "checkSize.sh", tmp_dir, temporary_space))
- if res:
- msg = "There is no enough space for temporary directory. Stopped..."
- error_exit(msg, False)
pass
#===============================================================
Returns True if some product is installed in 'binaries' mode.
"""
for product in products:
- if product.install == __TAG__BINARIES__:
+ if product.whattodo == __BINARIES__:
return True
return False
Returns True if some product is installed in 'sources' mode.
"""
for product in products:
- if product.install == __TAG__SOURCES__:
+ if product.whattodo == __BUILDSRC__:
return True
return False
return "%s/%s%d"%(dir, dir_prefix, random.randint(range_bottom,range_top))
#==============================================================
-# get_current_platform : gets name, version and bit of
-# the current user's Linux platform
+# get_os_release : gets OS release; the OS name, version and
+# architecture
+# For example:
+# RedHat, 8.0; Mandriva, 2006.0, 64
#===============================================================
-def get_current_platform():
- """
- Gets name, version and bit of
- the current user's Linux platform.
- """
- plt_name = ""; plt_ver = ""; plt_bit = ""
- if os.path.exists("/etc/issue"):
- data = open("/etc/issue").readline()
- res = re.search(r'(.*)[L|l]inux.*release\s+([\d.]*)', data)
- if not res:
- # Debian identification
- res = re.search(r'(.*)GNU/Linux\s+([\d.]*)', data)
- if res:
- plt_name = "".join(res.group(1).split())
- plt_ver = res.group(2)
- if re.search(r'x86_64', data):
- plt_bit = "_64"
- pass
+def get_os_release():
+ filename = "/etc/issue"
+ # ---
+ plt_name = "unknown"
+ plt_ver = ""
+ plt_arch = ""
+ if os.path.exists(filename):
+ # ---
+ f = open(filename)
+ lines = f.readlines()
+ f.close()
+ # --- = re.compile("(.*)\s+[^\s]*[R|r]elease[^\s]*\s+([\d.]*)")
+ regvar1 = re.compile("(.*)\s+[^\s]*[L|l][I|i][N|n][U|u][X|x][^\s]*(.*)\s+([\d.]*)\s+")
+ for l in lines:
+ res = re.search(regvar, l)
+ if not res:
+ res = re.search(regvar1, l)
+ if res:
+ plt_name = " ".join(" ".join(res.groups()[:len(res.groups())-1]).split())
+ # workaround for Mandrake and other platforms
+ plt_name = plt_name.replace("Linux", "").replace("linux", "").replace("LINUX", "").strip()
+ # workaround for SuSe
+ plt_name = plt_name.replace("Welcome to", "").strip()
+ # ---
+ plt_name = " ".join(plt_name.split())
+ plt_ver = res.group(len(res.groups()))
+ if re.search(r'x86_64', l):
+ plt_arch = "64bit"
+ pass
+ # workaround for Red Hat Enterprise
+ if not plt_arch:
+ try:
+ import platform
+ if platform.machine() == "x86_64":
+ plt_arch = "64bit"
+ pass
+ pass
+ except:
+ pass
+ pass
+ break
pass
pass
- return plt_name, plt_ver, plt_bit
+ return plt_name, plt_ver, plt_arch
#==============================================================
# check_xml_file : checks XML file existence and readability
corresponding configuration files.
"""
platforms_map = {}
- xml_file_list = list()
if xml_file:
- xml_file_list = [ xml_file ]
+ xml_file_list = [xml_file]
+ pass
else:
- entry_list = os.listdir(get_program_path())
- for entry in entry_list:
- if re.search(r'(.*).xml', entry):
- xml_file_list.append(os.path.abspath(entry))
+ xml_file_list = filter(lambda i: i.endswith(".xml"), os.listdir(get_program_path()))
+ while 'config.xml' in xml_file_list: xml_file_list.remove('config.xml')
+ if os.path.exists(os.path.join(get_program_path(), 'config.xml')):
+ xml_file_list.append('config.xml')
+ xml_file_list = [os.path.abspath(i) for i in xml_file_list]
+ pass
for an_xml_file in xml_file_list: # XML files parsing
check_xml_file(an_xml_file)
- filehandle = open(an_xml_file)
- data = filehandle.read()
- filehandle.close()
parser = ConfigParser()
- parser.feed(data)
- parser.close()
+ parser.parse(an_xml_file)
if parser.config.platforms is not None:
for plt in parser.config.platforms.split(","):
if not plt or plt in platforms_map.keys(): continue
-## print "plt = %s, xml = %s"%(strip(plt), an_xml_file)
platforms_map[strip(plt)] = an_xml_file
+ pass
+ pass
+ pass
return platforms_map
+#==============================================================
+# Print menu with list of supported platform
+# and return user choice
+#===============================================================
+def select_platform(all_platforms):
+ platforms = all_platforms.keys()
+ platforms.sort()
+ pltname = None
+ while not pltname:
+ print "Please, select any platform from the list below."
+ print "--------------------------"
+ for idx in range(len(platforms)):
+ print " %2d. %s" % (idx+1, " ".join(platforms[idx].split("_")))
+ print " 0. Exit"
+ print "--------------------------"
+ print "Type your choice (%d-%d) and press <Enter>:" % (0, len(platforms)),
+ try:
+ idx = raw_input()
+ except:
+ sys.exit(1)
+ try:
+ idx = int(idx)
+ except:
+ warning("Invalid input!")
+ pass
+ if idx == 0: sys.exit(0)
+ if idx > 0 and idx <= len(platforms):
+ pltname = platforms[idx-1]
+ else:
+ warning("Invalid input!")
+ pass
+ return pltname, all_platforms[pltname]
+
#------------------------------------------------------------------#
# #
# EXECUTION STARTS HERE #
#------------------------------------------------------------------#
if __name__ == "__main__":
+ # get program dir
+ cur_dir = get_program_path()
# parse command line
- [xml_file, target_dir, tmp_dir, is_gui] = parse_parameters()
+ [xml_file, target_dir, is_gui] = parse_parameters()
if xml_file: xml_file = os.path.abspath(xml_file)
+ else: xml_file = os.path.join(cur_dir, "config.xml")
if target_dir: target_dir = os.path.abspath(target_dir)
- if tmp_dir: tmp_dir = os.path.abspath(tmp_dir)
- # get program dir
- cur_dir = get_program_path()
#---- GUI ----------------
if not env.has_key("LD_LIBRARY_PATH") :
env["LD_LIBRARY_PATH"] = ""
- env["LD_LIBRARY_PATH"] = ".:" + env["LD_LIBRARY_PATH"]
+ env["LD_LIBRARY_PATH"] = "./bin/lib:" + ".:" + env["LD_LIBRARY_PATH"]
env["PATH"] = ".:" + env["PATH"]
cmd = "./bin/SALOME_InstallWizard"
cmd += " --file %s"%xml_file
if target_dir is not None:
cmd += " --target %s"%target_dir
- if tmp_dir is not None:
- cmd += " --tmp %s"%tmp_dir
cmd += "&"
sys.exit(os.system(cmd))
#----- TUI ---------------------
-
- # get program dir
- cur_dir = get_program_path()
-
- # get current Linux platform
- plt_name = ""; plt_ver = ""; plt_bit = ""
- plt_name, plt_ver, plt_bit = get_current_platform()
- full_plt_name = plt_name + plt_ver + plt_bit
- print "full_plt_name = %s" % full_plt_name
-
- # get supported Linux platforms
- supported_plts_map = get_supported_platforms(xml_file)
- # check: whether the current platform is supported
- if supported_plts_map.has_key(full_plt_name):
- # define xml file to be used
- xml_file = supported_plts_map.get(full_plt_name, "")
- print "set xml_file = %s" % os.path.basename(xml_file)
- pass
- else:
- msg = "Not supported Linux platform!\n"
- warning(msg)
-
+ #
+ # check XML file
+ check_xml_file(xml_file)
# parse XML file -----------
message("Parsing XML configuration file: %s"%xml_file)
- filehandle = open(xml_file)
- data = filehandle.read()
- filehandle.close()
- parser = ConfigParser(is_force_src)
- parser.feed(data)
- parser.close()
-
- # actions map
- what_to_do = { __TAG__SOURCES__ : "install_source",
- __TAG__BINARIES__ : "install_binary",
- __TAG__NATIVE__ : "try_native",
- __TAG__PREINSTALL__ : "try_preinstalled",
- __TAG__BUILDSRC__ : "install_source_and_build"}
+ parser = ConfigParser()
+ parser.parse(xml_file)
+
# source directory map
- bin_dir = ""
- if parser.config.os:
- bin_dir += "/%s"%parser.config.os
- subdir = { __TAG__SOURCES__ : "SOURCES",
- __TAG__BINARIES__ : "BINARIES" + bin_dir,
- __TAG__NATIVE__ : "",
- __TAG__PREINSTALL__ : ""}
+ subdir = { __BUILDSRC__ : "SOURCES" }
# check scripts directory -----------
scripts_dir = "%s/%s"%(cur_dir, "config_files")
check_dir(source_dir)
if has_src:
- check_dir("%s/%s"%(source_dir,subdir[__TAG__SOURCES__]))
+ check_dir("%s/%s"%(source_dir,subdir[__BUILDSRC__]))
if has_bin:
- check_dir("%s/%s"%(source_dir,subdir[__TAG__BINARIES__]))
+ check_dir("%s/%s"%(source_dir,subdir[__BINARIES__]))
# check/create target dir -----------
if target_dir is None:
- target_dir = parser.path.targetdir
+ target_dir = parser.config.targetdir
target_dir = substituteVars(target_dir)
message("Creating target directory: " + target_dir)
if not os.access(target_dir, os.W_OK) :
error_exit("There is no write permissions for the directory: " + target_dir)
- # check/create temporary dir -----------
- if tmp_dir is None:
- tmp_dir = parser.path.tmpdir
- if not tmp_dir:
- tmp_dir = "/tmp"
- tmp_dir = substituteVars(tmp_dir)
- tmp_dir = get_tmp_dir(tmp_dir)
-
- message("Creating temporary directory: " + tmp_dir)
- root_path = create_dir(tmp_dir, 0755)
-
- if not os.path.exists(tmp_dir):
- error_exit("Invalid temporary directory: " + tmp_dir)
-
- if not os.access(tmp_dir, os.W_OK) :
- error_exit("There is no write permissions for the directory: " + tmp_dir)
-
# check available disk space -----------
message("Checking available disk space")
- check_disk_space(parser.products, scripts_dir, target_dir, tmp_dir, is_force_src)
+ check_disk_space(parser.products, scripts_dir, target_dir)
# change current directory -----------
os.chdir(scripts_dir)
# get dependencies list -----------
- list_of_dep = get_dependencies(parser.products)
+ products_string = " ".join(parser.full_prods_list)
+
+ # don't remove sources and tmp files, by default -----------
+ rm_src_tmp = "FALSE"
# starting -----------
message("Starting ...")
# install products -----------
for product in parser.products:
message("... processing %s ..."%product.name)
- cmd = '%s/%s %s %s %s/%s %s "%s" %s'%(scripts_dir,
- product.script,
- what_to_do[product.whattodo],
- tmp_dir,
- source_dir,
- subdir[product.install],
- target_dir,
- list_of_dep,
- product.name)
+ cmd = '%s/%s %s %s/%s %s "%s" %s "%s" %s/%s' % (
+ scripts_dir, product.script,
+ product.whattodo,
+ source_dir, subdir[product.whattodo],
+ target_dir,
+ products_string,
+ product.name,
+ products_string,
+ source_dir, subdir[__BUILDSRC__],
+ )
res = os.system(cmd)
+ pass
- # pickup environment -----------
- message("Creating environment files")
- for product in parser.products :
- if check_bool(product.pickupEnv):
- cmd = '%s/%s pickup_env %s %s/%s %s "%s" %s'%(scripts_dir,
- product.script,
- tmp_dir,
- source_dir,
- subdir[product.install],
- target_dir,
- list_of_dep,
- product.name)
- res = os.system(cmd)
-
- # clean temporary directory -----------
- message("Cleaning temporary directory")
- clean_all()
-
# finishing -----------
message("Finished!")
pass
