def __load_user_gconfs(gconfs): from arjuna.lib.core import ArjunaCore console = ArjunaCore.console ugcdir = ArjunaCore.config.value(UniteePropertyEnum.PROJECT_CONFIG_DIR) ugfpath = os.path.join(ugcdir, "groups.xml") def display_err_and_exit(msg): console.display_error((msg + " Fix groups template file: {}").format(ugfpath)) sys_utils.fexit() try: tree = ETree.parse(ugfpath) except Exception as e: print(e) display_err_and_exit("Groups definition file could not be loaded because of errors in XML.") else: root = tree.getroot() if root.tag != 'groups': display_err_and_exit("Invalid groups template file. Root element tag should be >>groups<<.") node_dict = etree_utils.convert_to_cidict(root) # Validate only group keys exist. if node_dict.keys() != {'group'}: display_err_and_exit(">>groups<< element can contain only one or more >>group<< elements.") elif not node_dict: display_err_and_exit(">>groups<< element must contain atleast one >>group<< element.") else: for group in list(root): run_conf_utils.validate_group_xml_child("session", ugfpath, group) group_attrs = etree_utils.convert_attribs_to_cidict(group) name = group_attrs['name'].strip() if not name: display_err_and_exit(">>name<< attribute in group definition can not be empty.") gconfs[name] = GroupConf(name, group, ugfpath)
def __process(self, group_hocon): def display_err_and_exit(msg): self.console.display_error((msg + " Fix session template file: {}").format(self.sdef.fpath)) sys_utils.fexit() stage_attrs = etree_utils.convert_attribs_to_cidict(self.root) if "name" in stage_attrs: self.name = stage_attrs['name'].strip() if not self.name: display_err_and_exit(">>name<< attribute in stage definition should be a non-empty string.") threads_err_msg = ">>threads<< attribute in stage definition can be integer >=1." if "threads" in stage_attrs: self.threads = stage_attrs['threads'].strip() try: self.threads = int(self.threads) except: display_err_and_exit(threads_err_msg) else: if self.threads <=0: display_err_and_exit(threads_err_msg) node_dict = etree_utils.convert_to_cidict(self.root) if "groups" not in node_dict: display_err_and_exit(">>stage<< element in session definition must contain >>groups<< element.") for child_tag, child in node_dict.items(): child_tag = child_tag.lower() if child_tag == 'evars': evars = child for child in evars: run_conf_utils.validate_evar_xml_child("session", self.sdef.fpath, child) run_conf_utils.add_evar_node_to_evars("session", self.evars, child) elif child_tag == 'fixtures': fixtures = child for child in fixtures: run_conf_utils.validate_fixture_xml_child("session", "stage", self.sdef.fpath, child) run_conf_utils.add_fixture_node_to_fixdefs(self.fixture_defs, child) elif child_tag =='groups': if "group" not in etree_utils.convert_to_cidict(child): display_err_and_exit(">>groups<< element in stage definition must contain atleast one >>group<< element.") groups = list(child) for index, group in enumerate(groups): run_conf_utils.validate_group_xml_child("session", self.sdef.fpath, group) node = GroupDef(self.sdef, self, len(self.gdefs) + 1, group) self.gdefs.append(node) else: display_err_and_exit("Unexpected element >>{}<< found in >>stage<< definition in session file.".format(child.tag))
def validate_rule_xml_child(conf_type, group_name, groups_path, rule_node): for k, v in rule_node.attrib.items(): if k.lower() not in ALLOWED_RULE_ATTRS: display_err_and_exit( conf_type, groups_path, ">>patten<< attributes can only be set as: {}. Check group: {}" .format(ALLOWED_RULE_ATTRS, group_name)) if not MANDATORY_RULE_ATTRS.issubset( etree_utils.convert_attribs_to_cidict(rule_node)): display_err_and_exit( conf_type, groups_path, ">>pattern<< element must define these attributes: {}. Check group: {}" .format(MANDATORY_RULE_ATTRS, group_name))
def validate_evar_xml_child(conf_type, session_path, evar_node): if evar_node.tag.lower() != 'evar': display_err_and_exit( conf_type, session_path, ">>evars<< element can only contain one or more children of type >>evar<<." ) for k, v in evar_node.attrib.items(): if k.lower() not in ALLOWED_EVAR_ATTRS: display_err_and_exit( conf_type, session_path, ">>evar<< attributes can only be set as: {}.".format( ALLOWED_EVAR_ATTRS)) if not MANDATORY_EVAR_ATTRS.issubset( etree_utils.convert_attribs_to_cidict(evar_node)): display_err_and_exit( conf_type, session_path, ">>evar<< element must define >>name<< and >>value<< attributes.")
def validate_gconf_xml_child(conf_type, groups_path, gconf_node): if gconf_node.tag.lower() != 'group': display_err_and_exit( conf_type, groups_path, ">>groups<< element can only contain one or more children of type >>group<<." ) for k, v in gconf_node.attrib.items(): if k.lower() not in ALLOWED_GCONF_ATTRS: display_err_and_exit( conf_type, groups_path, ">>group<< attributes can only be set as: {}.".format( ALLOWED_GCONF_ATTRS)) if not MANDATORY_GCONF_ATTRS.issubset( etree_utils.convert_attribs_to_cidict(gconf_node)): display_err_and_exit( conf_type, groups_path, ">>group<< element must define these attributes: {}".format( MANDATORY_GCONF_ATTRS))
def __process(self): def display_err_and_exit(msg): self.console.display_error( (msg + " Fix groups template file: {}").format(self.fpath)) sys_utils.fexit() node_dict = etree_utils.convert_to_cidict(self.root) pattern_set = {i.lower() for i in self._rule_dict.keys()} # Validate only pickers keys exist. if node_dict.keys() != {'picker'}: display_err_and_exit( ">>pickers<< element can contain only one or more >>picker<< element. Check group: {}" .format(self.gname)) elif not node_dict: display_err_and_exit( ">>pickers<< element must contain atleast one >>picker<< element.Check group: {}" .format(self.gname)) for pattern in list(self.root): run_conf_utils.validate_pattern_xml_child("groups", self.gname, self.fpath, pattern) pattern_dict = etree_utils.convert_attribs_to_cidict(pattern) pattern_name = pattern_dict['type'].lower() if pattern_name not in pattern_set: display_err_and_exit( ">>pickers<< element type attribute can only contain one of {}.Check group: {}" .format(pattern_set, self.gname)) pattern_value = pattern_dict['pattern'].strip() if not pattern_value: display_err_and_exit( ">>pickers<< element's >>pattern<< attribute can not be empty.Check group: {}" .format(pattern_set, self.gname)) if pattern_name in {'cm', 'im'}: self._rule_dict[pattern_name].append( re.compile(self.tm_prefix + pattern_value)) else: self._rule_dict[pattern_name].append(re.compile(pattern_value)) self.__module_matcher = NameMatcher(self._rule_dict['cm'], self._rule_dict['im']) self.__function_matcher = NameMatcher(self._rule_dict['cf'], self._rule_dict['if'])
def __process(self): def display_err_and_exit(msg): self.console.display_error((msg + " Fix session template file: {}").format(self.sdef.fpath)) sys_utils.fexit() group_attrs = etree_utils.convert_attribs_to_cidict(self.root) self.name = group_attrs['name'].strip() if not self.name: display_err_and_exit( ">>name<< attribute in group definition can not be empty.") if self.name not in Unitee.groups: display_err_and_exit( ">>name<< attribute in group definition is pointing to a non-existing group '{}'.".format(self.name)) else: self.__gconf = Unitee.groups[self.name] threads_err_msg = ">>threads<< attribute in stage definition can be integer >=1." if "threads" in group_attrs: self.threads = group_attrs['threads'].strip() try: self.threads = int(self.threads) except: display_err_and_exit(threads_err_msg) else: if self.threads <=0: display_err_and_exit(threads_err_msg) node_dict = etree_utils.convert_to_cidict(self.root) for child_name, child in node_dict.items(): if child.tag == 'evars': evars = child for child in evars: run_conf_utils.validate_evar_xml_child("session", self.sdef.fpath, child) run_conf_utils.add_evar_node_to_evars("session", self.__gconf.evars, child) else: display_err_and_exit("Unexpected element >>{}<< found in >>group<< definition in session file.".format(child.tag))
def __process(self): def display_err_and_exit(msg): self.console.display_error( (msg + " Fix groups template file: {}").format(self.fpath)) sys_utils.fexit() node_dict = etree_utils.convert_to_cidict(self.root) # Validate only pickers keys exist. if not set(node_dict.keys()).issubset({'modules', 'functions'}): display_err_and_exit( ">>rules<< element can contain only >>modules<< and/or >>functions<< elements. Check group: {}." .format(self.gname)) elif not node_dict: display_err_and_exit( ">>rules<< element is empty.Check group: {}.".format( self.gname)) # xyz -- boolean built-in property or flags pattern_1 = re.compile(r"^\s*(?P<object>\w+)\s*$", re.IGNORECASE) # tagged abc[,.....] pattern_2 = re.compile(r"^\s*tagged\s*(?P<object>(.+?))\s*$", re.IGNORECASE) # tags/bugs a[,....] are defined pattern_3 = re.compile( r"^\s*(?P<container>\w+)\s*(?P<object>.*?)\s+(?P<condition>are)\s+(?P<expression>defined|present)\s*$", re.IGNORECASE) # prop is DEFINED pattern_4 = re.compile( r"^\s*(?P<object>\w+)\s+(?P<condition>is)\s+(?P<expression>defined|present)\s*$", re.IGNORECASE) # xyz condition def condition_str = "is|eq|=|==|lt|le|gt|ge|matches|~=|contains|\*=" p5_raw = r"^\s*(?P<object>\w+)\s+(?P<condition>({}){{1,1}})\s+(?P<expression>.*?)\s*$".format( condition_str) pattern_5 = re.compile(p5_raw, re.IGNORECASE) # property_type xyz condition def condition_str = "is|eq|=|==|lt|le|gt|ge|matches|~=|contains|\*=" p6_raw = r"^\s*(?P<container>prop|evar|tag|bug)\s*(?P<object>\w+)\s+(?P<condition>({}){{1,1}})\s+(?P<expression>.*?)\s*$".format( condition_str) pattern_6 = re.compile(p6_raw, re.IGNORECASE) for target_object in list(self.root): tobject = target_object.tag.lower( ) == 'modules' and 'Module' or 'Function' for rule in list(target_object): if rule.tag not in {'include', 'exclude'}: display_err_and_exit( ">>{}<< element in >>rules<< element can contain only rules with >>include<< and/or >>exclude<< tags. Check group: {}." .format(target_object.tag, self.gname)) run_conf_utils.validate_rule_xml_child("groups", self.gname, self.fpath, rule) rule_dict = etree_utils.convert_attribs_to_cidict(rule) try: match = pattern_1.match(rule_dict['if']) if match: self.__create_1_word_boolean_rule( rule, tobject, rule.tag, match) continue match = pattern_2.match(rule_dict['if']) if match: self.__create_2_word_value_rule_for_tags( rule, tobject, rule.tag, match) continue match = pattern_3.match(rule_dict['if']) if match: self.__create_4_word_value_rule_for_multi_defined( rule, tobject, rule.tag, match) continue match = pattern_4.match(rule_dict['if']) if match: self.__create_3_word_value_rule_for_prop( rule, tobject, rule.tag, match) continue match = pattern_5.match(rule_dict['if']) if match: self.__create_3_word_value_rule_for_prop( rule, tobject, rule.tag, match) continue match = pattern_6.match(rule_dict['if']) if match: self.__create_4_word_rule_for_container( rule, tobject, rule.tag, match) continue # Invalid rule raise Exception( "The >>if<< condition content in the rule is invalid: " + rule_dict['if']) except Exception as e: import traceback traceback.print_exc() display_err_and_exit( "Exception in processing rule: {}. {}. Check group: {}." .format(ETree.tostring(rule).strip(), e, self.gname))