Changeset fe2333d in mainline for tools/config.py

Timestamp:

2010-12-09T00:08:57Z (14 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

0a5a950

Parents:

07b9203e (diff), c01f8e6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes

File:

• tools/config.py (modified) (14 diffs)

tools/config.py

@@ -47 +47 @@
 
 def read_config(fname, config):
-        "Read saved values from last configuration run"
+        "Read saved values from last configuration run or a preset file"
         
         inf = open(fname, 'r')
@@ -218 +218 @@
 # and verify that all variables have a value (previously specified or inferred).
 #
-# @param config Configuration to work on
-# @param rules  Rules
-#
-# @return       True if configuration is complete and valid, False
-#               otherwise.
+# @param config Configuration to work on
+# @param rules  Rules
+#
+# @return True if configuration is complete and valid, False
+#         otherwise.
 #
 def infer_verify_choices(config, rules):
@@ -229 +229 @@
         for rule in rules:
                 varname, vartype, name, choices, cond = rule
-
+                
                 if cond and (not check_condition(cond, config, rules)):
                         continue
@@ -237 +237 @@
                 else:
                         value = config[varname]
-
-                if not rule_value_is_valid(rule, value):
+                
+                if not validate_rule_value(rule, value):
                         value = None
-
-                default = rule_get_default(rule)
-                if default != None:
+                
+                default = get_default_rule(rule)
+
+                #
+                # If we don't have a value but we do have
+                # a default, use it.
+                #
+                if value == None and default != None:
+                        value = default
                         config[varname] = default
-
+                
                 if not varname in config:
                         return False
@@ -251 +257 @@
 
 ## Get default value from a rule.
-def rule_get_default(rule):
+def get_default_rule(rule):
         varname, vartype, name, choices, cond = rule
-
+        
         default = None
-
+        
         if vartype == 'choice':
                 # If there is just one option, use it
@@ -270 +276 @@
         else:
                 raise RuntimeError("Unknown variable type: %s" % vartype)
-
+        
         return default
 
 ## Get option from a rule.
 #
-# @param rule   Rule for a variable
-# @param value  Current value of the variable
+# @param rule  Rule for a variable
+# @param value Current value of the variable
 #
 # @return Option (string) to ask or None which means not to ask.
 #
-def rule_get_option(rule, value):
+def get_rule_option(rule, value):
         varname, vartype, name, choices, cond = rule
-
+        
         option = None
-
+        
         if vartype == 'choice':
                 # If there is just one option, don't ask
@@ -302 +308 @@
         else:
                 raise RuntimeError("Unknown variable type: %s" % vartype)
-
+        
         return option
 
 ## Check if variable value is valid.
 #
-# @param rule   Rule for the variable
-# @param value  Value of the variable
-#
-# @return       True if valid, False if not valid.
-#
-def rule_value_is_valid(rule, value):
+# @param rule  Rule for the variable
+# @param value Value of the variable
+#
+# @return True if valid, False if not valid.
+#
+def validate_rule_value(rule, value):
         varname, vartype, name, choices, cond = rule
         
         if value == None:
                 return True
-
+        
         if vartype == 'choice':
                 if not value in [choice[0] for choice in choices]:
@@ -335 +341 @@
         else:
                 raise RuntimeError("Unknown variable type: %s" % vartype)
-
+        
         return True
 
@@ -413 +419 @@
         return list
 
-## Choose a profile and load configuration presets.
-#
-def load_presets(root, fname, screen, config):
+## Ask user to choose a configuration profile.
+#
+def choose_profile(root, fname, screen, config):
         options = []
         opt2path = {}
@@ -436 +442 @@
                                         subprofile = True
                                         options.append("%s (%s)" % (name, subname))
-                                        opt2path[cnt] = (canon, subcanon)
+                                        opt2path[cnt] = [name, subname]
                                         cnt += 1
                         
                         if not subprofile:
                                 options.append(name)
-                                opt2path[cnt] = (canon, None)
+                                opt2path[cnt] = [name]
                                 cnt += 1
         
@@ -449 +455 @@
                 return None
         
-        read_config(opt2path[value][0], config)
-        if opt2path[value][1] != None:
-                read_config(opt2path[value][1], config)
+        return opt2path[value]
+
+## Read presets from a configuration profile.
+#
+# @param profile Profile to load from (a list of string components)
+# @param config  Output configuration
+#
+def read_presets(profile, config):
+        path = os.path.join(PRESETS_DIR, profile[0], MAKEFILE)
+        read_config(path, config)
+        
+        if len(profile) > 1:
+                path = os.path.join(PRESETS_DIR, profile[0], profile[1], MAKEFILE)
+                read_config(path, config)
+
+## Parse profile name (relative OS path) into a list of components.
+#
+# @param profile_name Relative path (using OS separator)
+# @return             List of components
+#
+def parse_profile_name(profile_name):
+        profile = []
+        
+        head, tail = os.path.split(profile_name)
+        if head != '':
+                profile.append(head)
+        
+        profile.append(tail)
+        return profile
 
 def main():
+        profile = None
         config = {}
         rules = []
@@ -460 +493 @@
         parse_rules(RULES_FILE, rules)
         
-        # Read configuration from previous run
-        if os.path.exists(MAKEFILE):
+        # Input configuration file can be specified on command line
+        # otherwise configuration from previous run is used.
+        if len(sys.argv) >= 4:
+                profile = parse_profile_name(sys.argv[3])
+                read_presets(profile, config)
+        elif os.path.exists(MAKEFILE):
                 read_config(MAKEFILE, config)
         
-        # Default mode: only check values and regenerate configuration files
+        # Default mode: check values and regenerate configuration files
         if (len(sys.argv) >= 3) and (sys.argv[2] == 'default'):
                 if (infer_verify_choices(config, rules)):
                         create_output(MAKEFILE, MACROS, config, rules)
                         return 0
+        
+        # Hands-off mode: check values and regenerate configuration files,
+        # but no interactive fallback
+        if (len(sys.argv) >= 3) and (sys.argv[2] == 'hands-off'):
+                # We deliberately test sys.argv >= 4 because we do not want
+                # to read implicitly any possible previous run configuration
+                if len(sys.argv) < 4:
+                        sys.stderr.write("Configuration error: No presets specified\n")
+                        return 2
+                
+                if (infer_verify_choices(config, rules)):
+                        create_output(MAKEFILE, MACROS, config, rules)
+                        return 0
+                
+                sys.stderr.write("Configuration error: The presets are ambiguous\n")
+                return 1
         
         # Check mode: only check configuration
@@ -507 +560 @@
                                         value = config[varname]
                                 
-                                if not rule_value_is_valid(rule, value):
+                                if not validate_rule_value(rule, value):
                                         value = None
-
-                                default = rule_get_default(rule)
-                                if default != None:
+                                
+                                default = get_default_rule(rule)
+
+                                #
+                                # If we don't have a value but we do have
+                                # a default, use it.
+                                #
+                                if value == None and default != None:
                                         value = default
                                         config[varname] = default
-
-                                option = rule_get_option(rule, value)
+                                
+                                option = get_rule_option(rule, value)
                                 if option != None:
                                         options.append(option)
+                                else:
+                                        continue
                                 
                                 opt2row[cnt] = (varname, vartype, name, choices)
@@ -539 +599 @@
                         
                         if value == 0:
-                                load_presets(PRESETS_DIR, MAKEFILE, screen, config)
+                                profile = choose_profile(PRESETS_DIR, MAKEFILE, screen, config)
+                                if profile != None:
+                                        read_presets(profile, config)
                                 position = 1
                                 continue