Merge remote branch 'autotest-upstream/master' into try-box1

client/tests/kvm/kvm_config.py

 #!/usr/bin/python
 """
 KVM test configuration file parser
 
 @copyright: Red Hat 2008-2011
 """
 
-import re, os, sys, optparse, collections, string
+import re, os, sys, optparse, collections
 
 
 # Filter syntax:
 # , means OR
 # .. means AND
 # . means IMMEDIATELY-FOLLOWED-BY
 
 # Example:
 # qcow2..Fedora.14, RHEL.6..raw..boot, smp2..qcow2..migrate..ide
 # means match all dicts whose names have:
@@ skipping 111 matching lines @@
         return False
 
 
 class NoOnlyFilter(Filter):
     def __init__(self, line):
         Filter.__init__(self, line.split(None, 1)[1])
         self.line = line
 
 
 class OnlyFilter(NoOnlyFilter):
+    def is_irrelevant(self, ctx, ctx_set, descendant_labels):
+        return self.match(ctx, ctx_set)
+
+
+    def requires_action(self, ctx, ctx_set, descendant_labels):
+        return not self.might_match(ctx, ctx_set, descendant_labels)
+
+
     def might_pass(self, failed_ctx, failed_ctx_set, ctx, ctx_set,
                    descendant_labels):
         for word in self.filter:
             for block in word:
                 if (_match_adjacent(block, ctx, ctx_set) >
                     _match_adjacent(block, failed_ctx, failed_ctx_set)):
                     return self.might_match(ctx, ctx_set, descendant_labels)
         return False
 
 
 class NoFilter(NoOnlyFilter):
+    def is_irrelevant(self, ctx, ctx_set, descendant_labels):
+        return not self.might_match(ctx, ctx_set, descendant_labels)
+
+
+    def requires_action(self, ctx, ctx_set, descendant_labels):
+        return self.match(ctx, ctx_set)
+
+
     def might_pass(self, failed_ctx, failed_ctx_set, ctx, ctx_set,
                    descendant_labels):
         for word in self.filter:
             for block in word:
                 if (_match_adjacent(block, ctx, ctx_set) <
                     _match_adjacent(block, failed_ctx, failed_ctx_set)):
                     return not self.match(ctx, ctx_set)
         return False
 
 
 class Condition(NoFilter):
     def __init__(self, line):
         Filter.__init__(self, line.rstrip(":"))
         self.line = line
         self.content = []
 
 
+class NegativeCondition(OnlyFilter):
+    def __init__(self, line):
+        Filter.__init__(self, line.lstrip("!").rstrip(":"))
+        self.line = line
+        self.content = []
+
+
 class Parser(object):
     """
     Parse an input file or string that follows the KVM Test Config File format
     and generate a list of dicts that will be later used as configuration
     parameters by the KVM tests.
 
     @see: http://www.linux-kvm.org/page/KVM-Autotest/Test_Config_File
     """
 
     def __init__(self, filename=None, debug=False):
@@ skipping 41 matching lines @@
             #    new_content and unpack conditional blocks if appropriate.
             #    For example, if an 'only' statement fully matches ctx, it
             #    becomes irrelevant and is not appended to new_content.
             #    If a conditional block fully matches, its contents are
             #    unpacked into new_content.
             # 3. Move failed filters into failed_filters, so that next time we
             #    reach this node or one of its ancestors, we'll check those
             #    filters first.
             for t in content:
                 filename, linenum, obj = t
-                if type(obj) is str:
+                if type(obj) is Op:
                     new_content.append(t)
                     continue
-                elif type(obj) is OnlyFilter:
-                    if not obj.might_match(ctx, ctx_set, labels):
+                # obj is an OnlyFilter/NoFilter/Condition/NegativeCondition
+                if obj.requires_action(ctx, ctx_set, labels):
+                    # This filter requires action now
+                    if type(obj) is OnlyFilter or type(obj) is NoFilter:
                         self._debug("    filter did not pass: %r (%s:%s)",
                                     obj.line, filename, linenum)
                         failed_filters.append(t)
                         return False
-                    elif obj.match(ctx, ctx_set):
-                        continue
-                elif type(obj) is NoFilter:
-                    if obj.match(ctx, ctx_set):
-                        self._debug("    filter did not pass: %r (%s:%s)",
-                                    obj.line, filename, linenum)
-                        failed_filters.append(t)
-                        return False
-                    elif not obj.might_match(ctx, ctx_set, labels):
-                        continue
-                elif type(obj) is Condition:
-                    if obj.match(ctx, ctx_set):
+                    else:
                         self._debug("    conditional block matches: %r (%s:%s)",
                                     obj.line, filename, linenum)
                         # Check and unpack the content inside this Condition
                         # object (note: the failed filters should go into
                         # new_internal_filters because we don't expect them to
                         # come from outside this node, even if the Condition
                         # itself was external)
                         if not process_content(obj.content,
                                                new_internal_filters):
                             failed_filters.append(t)
                             return False
                         continue
-                    elif not obj.might_match(ctx, ctx_set, labels):
-                        continue
-                new_content.append(t)
+                elif obj.is_irrelevant(ctx, ctx_set, labels):
+                    # This filter is no longer relevant and can be removed
+                    continue
+                else:
+                    # Keep the filter and check it again later
+                    new_content.append(t)
             return True
 
         def might_pass(failed_ctx,
                        failed_ctx_set,
                        failed_external_filters,
                        failed_internal_filters):
             for t in failed_external_filters:
                 if t not in content:
                     return True
                 filename, linenum, filter = t
@@ skipping 48 matching lines @@
         count = 0
         for n in node.children:
             for d in self.get_dicts(n, ctx, new_content, shortname, dep):
                 count += 1
                 yield d
         # Reached leaf?
         if not node.children:
             self._debug("    reached leaf, returning it")
             d = {"name": name, "dep": dep, "shortname": ".".join(shortname)}
             for filename, linenum, op in new_content:
-                op.apply_to_dict(d, ctx, ctx_set)
+                op.apply_to_dict(d)
             yield d
         # If this node did not produce any dicts, remember the failed filters
         # of its descendants
         elif not count:
             new_external_filters = []
             new_internal_filters = []
             for n in node.children:
                 (failed_ctx,
                  failed_ctx_set,
                  failed_external_filters,
@@ skipping 78 matching lines @@
         while True:
             line, indent, linenum = cr.get_next_line(prev_indent)
             if not line:
                 break
 
             words = line.split(None, 1)
 
             # Parse 'variants'
             if line == "variants:":
                 # 'variants' is not allowed inside a conditional block
-                if isinstance(node, Condition):
+                if (isinstance(node, Condition) or
+                    isinstance(node, NegativeCondition)):
                     raise ParserError("'variants' is not allowed inside a "
                                       "conditional block",
                                       None, cr.filename, linenum)
                 node = self._parse_variants(cr, node, prev_indent=indent)
                 continue
 
             # Parse 'include' statements
             if words[0] == "include":
                 if len(words) < 2:
                     raise ParserError("Syntax error: missing parameter",
                                       line, cr.filename, linenum)
-                if not isinstance(cr, FileReader):
-                    raise ParserError("Cannot include because no file is "
-                                      "currently open",
-                                      line, cr.filename, linenum)
-                filename = os.path.join(os.path.dirname(cr.filename), words[1])
+                filename = os.path.expanduser(words[1])
+                if isinstance(cr, FileReader) and not os.path.isabs(filename):
+                    filename = os.path.join(os.path.dirname(cr.filename),
+                                            filename)
                 if not os.path.isfile(filename):
                     self._warn("%r (%s:%s): file doesn't exist or is not a "
                                "regular file", line, cr.filename, linenum)
                     continue
                 node = self._parse(FileReader(filename), node)
                 continue
 
             # Parse 'only' and 'no' filters
             if words[0] in ("only", "no"):
                 if len(words) < 2:
                     raise ParserError("Syntax error: missing parameter",
                                       line, cr.filename, linenum)
                 try:
                     if words[0] == "only":
                         f = OnlyFilter(line)
                     elif words[0] == "no":
                         f = NoFilter(line)
                 except ParserError, e:
                     e.line = line
                     e.filename = cr.filename
                     e.linenum = linenum
                     raise
                 node.content += [(cr.filename, linenum, f)]
                 continue
 
+            # Look for operators
+            op_match = _ops_exp.search(line)
+
             # Parse conditional blocks
-            if line.endswith(":"):
-                try:
-                    cond = Condition(line)
-                except ParserError, e:
-                    e.line = line
-                    e.filename = cr.filename
-                    e.linenum = linenum
-                    raise
-                self._parse(cr, cond, prev_indent=indent)
-                node.content += [(cr.filename, linenum, cond)]
-                continue
+            if ":" in line:
+                index = line.index(":")
+                if not op_match or index < op_match.start():
+                    index += 1
+                    cr.set_next_line(line[index:], indent, linenum)
+                    line = line[:index]
+                    try:
+                        if line.startswith("!"):
+                            cond = NegativeCondition(line)
+                        else:
+                            cond = Condition(line)
+                    except ParserError, e:
+                        e.line = line
+                        e.filename = cr.filename
+                        e.linenum = linenum
+                        raise
+                    self._parse(cr, cond, prev_indent=indent)
+                    node.content += [(cr.filename, linenum, cond)]
+                    continue
 
             # Parse regular operators
-            try:
-                op = Op(line)
-            except ParserError, e:
-                e.line = line
-                e.filename = cr.filename
-                e.linenum = linenum
-                raise
-            node.content += [(cr.filename, linenum, op)]
+            if not op_match:
+                raise ParserError("Syntax error", line, cr.filename, linenum)
+            node.content += [(cr.filename, linenum, Op(line, op_match))]
 
         return node
 
 
 # Assignment operators
 
 _reserved_keys = set(("name", "shortname", "dep"))
 
 
 def _op_set(d, key, value):
@@ skipping 44 matching lines @@
         "<=": (r"\<\=", _op_prepend),
         "?=": (r"\?\=", _op_regex_set),
         "?+=": (r"\?\+\=", _op_regex_append),
         "?<=": (r"\?\<\=", _op_regex_prepend),
         "del": (r"^del\b", _op_regex_del)}
 
 _ops_exp = re.compile("|".join([op[0] for op in _ops.values()]))
 
 
 class Op(object):
-    def __init__(self, line):
-        m = re.search(_ops_exp, line)
-        if not m:
-            raise ParserError("Syntax error: missing operator")
-        left = line[:m.start()].strip()
+    def __init__(self, line, m):
+        self.func = _ops[m.group()][1]
+        self.key = line[:m.start()].strip()
         value = line[m.end():].strip()
-        if value and ((value[0] == '"' and value[-1] == '"') or
-                      (value[0] == "'" and value[-1] == "'")):
+        if value and (value[0] == value[-1] == '"' or
+                      value[0] == value[-1] == "'"):
             value = value[1:-1]
-        filters_and_key = map(str.strip, left.split(":"))
-        self.filters = [Filter(f) for f in filters_and_key[:-1]]
-        self.key = filters_and_key[-1]
         self.value = value
-        self.func = _ops[m.group()][1]
 
 
-    def apply_to_dict(self, d, ctx, ctx_set):
-        for f in self.filters:
-            if not f.match(ctx, ctx_set):
-                return
+    def apply_to_dict(self, d):
         self.func(d, self.key, self.value)
 
 
 # StrReader and FileReader
 
 class StrReader(object):
     """
     Preprocess an input string for easy reading.
     """
     def __init__(self, s):
         """
         Initialize the reader.
 
         @param s: The string to parse.
         """
         self.filename = "<string>"
         self._lines = []
         self._line_index = 0
+        self._stored_line = None
         for linenum, line in enumerate(s.splitlines()):
             line = line.rstrip().expandtabs()
             stripped_line = line.lstrip()
             indent = len(line) - len(stripped_line)
             if (not stripped_line
                 or stripped_line.startswith("#")
                 or stripped_line.startswith("//")):
                 continue
             self._lines.append((stripped_line, indent, linenum + 1))
 
 
     def get_next_line(self, prev_indent):
         """
-        Get the next non-empty, non-comment line in the string, whose
-        indentation level is higher than prev_indent.
+        Get the next line in the current block.
 
         @param prev_indent: The indentation level of the previous block.
         @return: (line, indent, linenum), where indent is the line's
             indentation level.  If no line is available, (None, -1, -1) is
             returned.
         """
+        if self._stored_line:
+            ret = self._stored_line
+            self._stored_line = None
+            return ret
         if self._line_index >= len(self._lines):
             return None, -1, -1
         line, indent, linenum = self._lines[self._line_index]
         if indent <= prev_indent:
             return None, -1, -1
         self._line_index += 1
         return line, indent, linenum
 
 
+    def set_next_line(self, line, indent, linenum):
+        """
+        Make the next call to get_next_line() return the given line instead of
+        the real next line.
+        """
+        line = line.strip()
+        if line:
+            self._stored_line = line, indent, linenum
+
+
 class FileReader(StrReader):
     """
     Preprocess an input file for easy reading.
     """
     def __init__(self, filename):
         """
         Initialize the reader.
 
         @parse filename: The name of the input file.
         """
         StrReader.__init__(self, open(filename).read())
         self.filename = filename
 
 
 if __name__ == "__main__":
-    parser = optparse.OptionParser("usage: %prog [options] <filename>")
+    parser = optparse.OptionParser('usage: %prog [options] filename '
+                                   '[extra code] ...\n\nExample:\n\n    '
+                                   '%prog tests.cfg "only my_set" "no qcow2"')
     parser.add_option("-v", "--verbose", dest="debug", action="store_true",
                       help="include debug messages in console output")
     parser.add_option("-f", "--fullname", dest="fullname", action="store_true",
                       help="show full dict names instead of short names")
     parser.add_option("-c", "--contents", dest="contents", action="store_true",
                       help="show dict contents")
 
     options, args = parser.parse_args()
     if not args:
         parser.error("filename required")
 
     c = Parser(args[0], debug=options.debug)
+    for s in args[1:]:
+        c.parse_string(s)
+
     for i, d in enumerate(c.get_dicts()):
         if options.fullname:
             print "dict %4d:  %s" % (i + 1, d["name"])
         else:
             print "dict %4d:  %s" % (i + 1, d["shortname"])
         if options.contents:
             keys = d.keys()
             keys.sort()
             for key in keys:
                 print "    %s = %s" % (key, d[key])