Subversion Repositories c0or1k

"""

cmlsystem.py -- CML2 configurator front-end support

by Eric S. Raymond, <esr@thyrsus.com>

Mode-independent code for front ends.  This supplies one big class that you

initialize by loading a compiled rulebase.  The class provides functions for

doing tests and manipulations on the rulebase, and for writing out

configuration files.

"""

import os, sys, re

import cml

_eng = {

    "ABOUT":"About to write %s=%s (type %s)",

    "BADEQUALS":"bad token `%s' while expecting '='.",

    "BADVERSION":"Compiler/configurator version mismatch (%s/%s), recompile the rulebase please.\n",

    "BADTOKEN":"unrecognized name `%s' while expecting known symbol.",

    "BADTRIT":"Boolean symbol %s cannot have value m.",

    "BINDING":"    %sBinding from constraint: %s=%s (source %s)",

    "CHECKDONE":"    ...menu %s check done",

    "CHECKING":"    Checking menu %s...",

    "COMMIT":"    Committing new bindings.",

    "CONSTRAINT":"    Value %s for %s failed constraint %s",

    "DERIVED":"Cannot set derived symbol %s",

    "EXCLUDED":"    %s value %s excluded by %s",

    "FAILREQ":"    Failed constraint %s",

    #"FORBIDDEN":"%s=%s would violate %s",

    "FROZEN":" (frozen)",

    "HELPFLAG":"Help-required flag is %s",

    "INCONST":"Symbol %s forced to n during recovery attempt.\n",

    "INVISANC":"    %s not visible, ancestor %s false",

    "INVISANC2":"    %s not visible, ancestor %s invisible",

    "INVISHELP":"    %s not visible, no help",

    "INVISME":"    %s not visible, %s guard %s is false",

    "INVISSTART":"    is_visible(%s) called",

    "INVISUP":"    %s not visible, upward visibility",

    "MODULESN":"All M-valued symbols will be forced to Y.",

    "MODULESM":"All tristate symbols will default to M.",

    "MODULESY":"Tristate symbols won't default to M.",

    "NOHELP":"    %s not visible, it has no help",

    "NOTSAVED": "(not saveable) ",

    "NOVISIBLE":"No visible items at %s",

    "OLDVAL": "    %sOld value of %s is %s",

    "RADIOINVIS":"    Query of choices menu %s elided, button pressed",

    "READING":"Reading configuration from %s",

    "RECOVERY":"Attempting recovery from invalid configuration:",

    "RECOVEROK":"Recovery OK.",

    "REDUNDANT":"    %sRedundant assignment forced by %s",

    "RENAME":"Attempt to rename %s to %s failed.",

    "ROLLBACK":"    Rolling back new bindings: ",

    "SAVEEND":"#\n# That's all, folks!\n",

    "SETFAILED":"%sAttempt to set frozen symbol %s failed",

    "SETTING":"%s=%s",

    "SHAUTOGEN":"#\n# Automatically generated, don't edit\n#\n",

    "SHDERIVED":"#\n# Derived symbols\n#\n",

    "SIDEEFFECT":" (deduced from %s)",

    "SUBINVIS":"    %s not visible, all subqueries invisible.",

    "TRIGGER":"    Set of %s = %s triggered by guard %s",

    "TRITFLAG":"Trit flag is now %s",

    "TRITSOFF":"    %s not visible, trits are suppressed",

    "TYPEUNKNOWN":"Node %s unknown value type: %s %s",

    "UNCHANGED":"    %sSymbol %s unchanged",

    "UNCOMMIT": "#\n# Uncommitted bindings\n#\n",

    "UNLOAD1":"File load violated these constraints:",

    "UNLOAD2":"Undoing file loads, recovery failed these constraints:",

    #"UNSATISFIABLE":"Ruleset found unsatisfiable while setting %s",

    "UNSAVEABLE":"%s is not saveable",

    "USERSETTING":"User action on %s.",

    "VALIDRANGE":"    Valid range of %s is %s",

    "VALUNKNOWN":"Node %s %s has unknown value: %s",

    "VISIBLE":"    Query of %s *not* elided",

}

class CMLSystem(cml.CMLRulebase):

    "A rulebase, from the point of view of a front end."

    relational_map ={ \

                    "==":"!=", "!=":"==", \

                    ">":"<=", "<=":">", \

                    "<":">=", ">=":"<", \

                    }

    def clear(self):

        "Clear the runtime value state."

        for entry in self.dictionary.values():

            entry.iced = 0               # True if it has been frozen

            if entry.type == "choices":

                entry.menuvalue = entry.default

            else:

                entry.menuvalue = None

            entry.bindingcache = []     # Symbol's value stack

        self.oldbindings = {}

        self.newbindings = {}

        self.chilled = {}

        self.touched = []               # Does it have an uncommitted binding?

        self.changes_to_frozen = []     # Frozen change violations

        self.inclusions = []

    def __init__(self, rules):

        "Make a configuration state object from a compiled rulebase."

        # Interpret a string as the name of a file containing pickled rules.

        if type(rules) == type(""):

            import cPickle

            rules = cPickle.load(open(rules, "rb"))

        # Copy the symbol table.   Since a python object's members are all

        # stored in a single hash table, we can steal its contents and

        # then discard the original object.

        self.__dict__ = rules.__dict__

        self.clear()

        # Enhance the ConfigSymbol methods to deal with the value state.

        if 'oldeval' not in dir(cml.ConfigSymbol):

            cml.ConfigSymbol.oldeval = cml.ConfigSymbol.eval

            def _neweval(symbol, debug=0, self=self):    # Not a method!

                value = self.__bindeval(symbol)

                if value != None:

                    return value

                value = cml.ConfigSymbol.oldeval(symbol, debug)

                if value != None:

                    return value

                elif symbol.type in ("decimal", "hexadecimal"):

                    return 0

                elif symbol.type == "string":

                    return ""

                elif symbol.is_logical():

                    return cml.n

                else:

                    return None # for menu, choices, and message-valued symbols

            cml.ConfigSymbol.eval = _neweval

            def _newstr(symbol):                # Not a method!

                res = "%s={" % (symbol.name)

                res = res + symbol.dump()

                if symbol.setcount:

                    res = res + " has been set,"

                if symbol.included:

                    res = res + " was loaded,"

                if symbol.frozen():

                    res = res + " frozen,"

                value = symbol.eval()

                if value != None:

                    res = res + " value " + str(value) + ","

                return res[:-1] + "}"

            cml.ConfigSymbol.__str__ = _newstr

            def _freeze(symbol):

                "Freeze a symbol."

                symbol.iced = 1

                if symbol.menu and symbol.menu.type == "choices":

                    symbol.menu.iced = 1

                    symbol.menu.value = symbol.name

                    for sibling in symbol.menu.items:

                        sibling.iced = 1

            cml.ConfigSymbol.freeze = _freeze

            def _frozen(symbol, self=self):

                "Is the symbol frozen?"

                if symbol.iced or symbol.type == "message":

                    return 1

                if symbol.type in ("menu", "choices"):

                    for item in symbol.items:

                        if self.is_visible(item) and not item.frozen():

                            return 0

                    return 1

                return 0

            cml.ConfigSymbol.frozen = _frozen

        # Extra state for the configuration object

        self.debug = 0                   # Initially, no status logging

        self.cdepth = 0                  # Constraint recursion xdepth

        self.errout = sys.stderr        # Where to do status logging

        self.suppressions = 1           # Yes, do visibility checks

        self.interactive = 1            # Are we doing a file inclusion?

        self.commits = 0         # Value sets since last save 

        self.lang = _eng                # Someday we'll support more languages.

        self.side_effects = []          # Track side effects

        self.trits_enabled = not self.trit_tie or self.trit_tie.eval()

        if rules.version != cml.version:

            sys.stderr.write(self.lang["BADVERSION"] % (rules.version, cml.version))

            raise SystemExit, 1

    def is_new(self, symbol):

        return self.inclusions and not symbol.included and symbol.is_symbol()

    # Utility code

    def debug_emit(self, threshold, msg):

        "Conditionally emit a debug message to the designated error stream."

        if self.debug >= threshold:

            self.errout.write(msg + "\n")

    # Handling of symbol bindings is encapsulated here.  The semantics

    # we want is for every side-effect to be associated with the

    # symbol whose user-specified change in value triggered it (the

    # primary).  That way, if and when the user changes the primary's

    # value again, we can back out all previous side-effects

    # contingent on that symbol.

    #

    # Essentially what we're doing here is journalling all bindings.

    # It has to be this way, because different values of the same

    # symbol could trigger completely different side effects depending

    # on how the constraints are written.

    #

    class __Binding:

        def __init__(self, symbol, value, link):

            # We don't track a binding's source in the __Binding

            # object itself because they always live in chains hanging

            # off a primary-symbol cell.

            self.symbol = symbol

            self.value = value

            self.link = link    # Next link in the primary's side-effect chain

            self.visible = 1

        def __repr__(self):

            return "%s=%s" % (self.symbol.name, self.value)

    def __bindeval(self, symbol):

        "Get the most recent visible value for symbol off the binding stack."

        #self.debug_emit(2, "    bindeval(%s)" % (symbol.name))

        if not hasattr(symbol, "bindingcache"):

            return None

        for binding in symbol.bindingcache:

            if binding.visible:

                return binding.value

    def __bindmark(self, symbol):

        # Mark it to be written

        menu = symbol

        while menu:

            menu.setcount += 1

            menu = menu.menu

    def __bindsymbol(self, symbol, value, source=None, sort=0, suppress=0):

        "Bind symbol to a given value."

        self.debug_emit(2, "    %sbindsymbol(%s, %s, %s, %s)" % (' '*self.cdepth,symbol.name, value, `source`, sort))

        if not source:

            source = symbol

        # Avoid creating duplicate bindings.

        if self.newbindings.has_key(source):

            bindings = self.newbindings[source]

            while bindings:

                if bindings.symbol == symbol and bindings.value == value:

                    return

                bindings = bindings.link

        # Side-effect tracking.  Note we don't record side effects

        # unless the binding is actually modified.  Otherwise we'd get

        # a huge plethora of mostly redundant side effects on file loads.

        if value != symbol.eval():

            if source == None or source == symbol:

                side = ""

            else:

                side = self.lang["SIDEEFFECT"] % (`source`,)

            side = self.lang["SETTING"] % (symbol.name, value) + side

            if source and source != symbol and not suppress:

                self.side_effects.append(side)

            if symbol == self.trit_tie:

                if value == cml.n:

                    self.side_effects.append(self.lang["MODULESN"])

                elif value == cml.m:

                    self.side_effects.append(self.lang["MODULESM"])

                elif value == cml.y:

                    self.side_effects.append(self.lang["MODULESY"])

            # Debugging support

            if self.debug:

                self.debug_emit(1, "    " + side)

        # Here is the actual binding-stack hack

        newbinding = self.__Binding(symbol,value, self.newbindings.get(source))

        self.newbindings[source] = newbinding

        insertpoint = 0

        if sort != 0:

            # Hide new binding behind any binding with greater (or lesser)

            # value, according to the sort type.

            for i in range(len(symbol.bindingcache)):

                if cmp(symbol.bindingcache[i].value, value) == sort:

                    insertpoint = i + 1

                else:

                    break

        symbol.bindingcache.insert(insertpoint, newbinding)

        self.__bindmark(symbol)

    def __unbindsymbol(self, symbol, context):

        "Remove all bindings of a given symbol from a given context"

        listhead = context.get(symbol)

        if listhead:

            while listhead:

                listhead.symbol.bindingcache.remove(listhead)

                listhead = listhead.link

            del context[symbol]

            if symbol.menu.type == "choices":

                for sibling in symbol.menu.items:

                    if sibling.eval():

                        symbol.menu.menuvalue = sibling

                        break

    def __find_commit_set(self):

        "Find all symbols which need to have their old bindings removed"

        undo = []

        # When we undo side-effects from a choice symbol, all the side-effects

        # from setting its siblings have to be backed out too.

        for primary in self.newbindings.keys():

            if primary.menu.type == "choices":

                undo.extend(primary.menu.items)

            else:

                undo.append(primary)

        return undo

    def __bindcommit(self):

        "Commit all new bindings."

        # This is the magic moment that undoes side-effects

        for symbol in self.__find_commit_set():

            self.__unbindsymbol(symbol, self.oldbindings)

        self.oldbindings.update(self.newbindings)

        self.newbindings.clear()

        self.commits = self.commits + 1

    def __bindreveal(self, primary):

        "Make every old binding of symbol visible."

        bindings = self.oldbindings.get(primary)

        if bindings:

            listhead = bindings

            while listhead:

                listhead.visible = 1

                listhead = listhead.link

    def __bindconceal(self, primary):

        "Temporarily make old bindings hanging on a given primary invisible."

        bindings = self.oldbindings.get(primary)

        if bindings:

            listhead = bindings

            while listhead:

                listhead.visible = 0

                listhead = listhead.link

    def binddump(self, context=None):

        "Dump the state of the bindings stack."

        # Each line consists of a bound symbol and its side effects.

        # Most recent bindings are listed first.

        res = ""

        if context == None:

            context=self.oldbindings

        for (primary, bindings) in context.items():

            res = res + "# %s(%s, touched=%d): " % (primary.name,("inactive","active")[bindings.visible], primary in self.touched)

            while bindings:

                res = res + `bindings` + ", "

                bindings = bindings.link

            res = res[:-2] + "\n"

        return res

    #

    # Loading and saving

    #

    def loadcommit(self, freeze):

        "Attempt to commit the results of a file load."

        errors = ""

        violations = self.sanecheck()

        if not violations:

            self.__commit(freeze)

        else:

            errors += self.lang["UNLOAD1"]+"\n" + "\n".join(map(repr,violations)) + "\n"

            # This is an attempt to recover from inconsistent

            # configurations.  (Unusual case -- typically happens only

            # when a new constraint is added to a rulebase, not in the

            # more common case of new symbols.)  General recovery is

            # very hard, it involves constrained satisfaction problems

            # for which there are not just no good algorithms, there

            # are no clean definitions.  We settle for a simple,

            # stupid hack.  Force all the unfrozen symbols in the

            # violated constraints to n and see what happens.

            nukem = []

            self.debug_emit(1, self.lang["RECOVERY"])

            for i in range(len(self.constraints)):

                if not cml.evaluate(self.reduced[i], self.debug):

                    flattened = cml.flatten_expr(self.constraints[i].predicate)

                    for sym in flattened:

                        if not sym in nukem and not sym.frozen() and sym.is_logical():

                            nukem.append(sym)

            if nukem:

                errors += self.lang["RECOVERY"] + "\n"

                for sym in nukem:

                    errors += self.lang["INCONST"] % (sym.name,)

                    self.__set_symbol_internal(sym, cml.n)

                    self.chilled.clear()

                violations = self.sanecheck()

                if not violations:

                    self.__commit(freeze)

                    errors += self.lang["RECOVEROK"]

                else:

                    self.__rollback()

                    errors += self.lang["UNLOAD2"]+"\n" + "\n".join(map(repr, violations)) + "\n"

        return errors

    def load(self, file, freeze=0):

        "Load bindings from a defconfig-format configuration file."

        import shlex

        stream = shlex.shlex(open(file), file)

        stream.wordchars += "$"

        self.debug_emit(1, self.lang["READING"] % (file,))

        changes = 0

        errors = ""

        stash = self.interactive

        self.interactive = 0

        self.side_effects = []  # Not needed if we're using set_symbol below 

        while 1:

            dobind = 1

            symname = stream.get_token()

            if not symname:

                break

            # Parse directives

            if symname == "$$commit":

                self.loadcommit(0)

                changes = 0

                continue

            elif symname == "$$freeze":

                self.loadcommit(1)

                changes = 0

                continue

            # Now parse ordinary symbol sets

            if len(self.prefix) and symname[0:len(self.prefix)] == self.prefix:

                symname = symname[len(self.prefix):]

            if self.dictionary.has_key(symname):

                symbol = self.dictionary[symname]

            else:

                symbol = None

                errmsg = stream.error_leader()+self.lang["BADTOKEN"]%(symname)

                errors = errors + errmsg + "\n"

                dobind = 0

            sep = stream.get_token()

            if sep != '=':

                errmsg = stream.error_leader()+self.lang["BADEQUALS"]%(sep,)

                errors = errors + errmsg + "\n"

                dobind = 0

            value = stream.get_token()

            # Do this check early to avoid Python errors if the file

            # is malformed.

            if not dobind:

                continue

            if value[0] in stream.quotes:

                value = value[1:-1]

            if not symbol:

                continue

            # We can't permit these files to override derivations

            if symbol.is_derived():

                self.debug_emit(2, stream.error_leader()+self.lang["DERIVED"]%(symbol.name,))

                continue

            # Michael Chastain's case -- treat variable as new if

            # value is m but the type has been changed to bool

            if value == 'm' and symbol.type == "bool":

                errmsg = stream.error_leader()+self.lang["BADTRIT"]%(symbol.name,)

                errors = errors + errmsg + "\n"

                continue

            # Note that we've seen this in an inclusion -- it's not new.

            symbol.included = 1

            # If we load a configuration with trit values,

            # force those to be enabled.

            if symbol.type == "trit" and value == "m":

                self.trits_enabled = 1

            # Don't count changes to variables that are already set at the

            # desired value.  Do them, though, so they can be frozen.

            oldval = symbol.eval()

            # Use this for consistency checking by file

            newval = self.value_from_string(symbol,value)

            self.__set_symbol_internal(symbol,

                                       newval)

            self.chilled.clear()

            if newval != oldval:

                changes = changes + 1

        stream.instream.close()

        if changes:

            errors += self.loadcommit(freeze)

        self.inclusions.append(file)

        self.interactive = stash

        return (changes, errors)

    def saveable(self, node, mode="normal"):

        "Should this symbol be visible in the configuration written out?"

        # Fix for loaded symbols from old configuration being written back without visibility check.

        if node.setcount > 0 and self.is_visible(node):

            return 1

        if node.is_derived() and (not node.visibility or cml.evaluate(node.visibility)):

            return 1

        if node.saveability:

            return cml.evaluate(node.saveability)

        if mode == "probe":

            return 0

        if not self.is_visible(node):

            return 0

        return 1

    def save(self, outfile=sys.stdout, baton=None, mode="normal"):

        "Save a configuration to the named output stream or file."

        #print "save(outfile=%s, baton=%s, mode=%s)" % (outfile, baton, mode)

        newbindings = None

        if self.newbindings:

            newbindings = self.newbindings

            self.newbindings = {}

        try:

            if type(outfile) == type(""):

                shelltemp = ".tmpconfig%d.sh" % os.getpid()

                outfp = open(shelltemp, "w")

                outfp.write(self.lang["SHAUTOGEN"])

            else:

                outfp = outfile

            # Write an informative header so we can identify this file.

            if mode != "list":

                try:

                    from time import gmtime, strftime

                    import socket

                    outfp.write("# Generated on: "+socket.gethostname()+"\n")

                    outfp.write("# At: " + strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime()) + "\n")

                    infp = open("/proc/version", "r")

                    outfp.write("# " + infp.read())

                    infp.close()

                except:

                    pass

            # Write mutable symbols, including defaulted modular symbols.

            self.__save_recurse(self.start, outfp, baton, mode)

            # Write all derived symbols

            if mode != "list":

                if filter(lambda x: x.is_derived(), self.dictionary.values()):

                    outfp.write(self.lang["SHDERIVED"])

                for entry in self.dictionary.values():

                    if entry.is_derived():

                        if baton:

                            baton.twirl()

                        self.__save_recurse(entry, outfp, baton, mode)

            # Perhaps this is a crash dump from an inconsistent ruleset?

            if newbindings:

                self.newbindings = newbindings

                outfp.write(self.lang["UNCOMMIT"])

                outfp.write(self.binddump(self.newbindings))

            if mode == "normal":

                outfp.write(self.lang["SAVEEND"])

            if type(outfile) == type(""):

                outfp.close()

                try:

                    os.rename(shelltemp, outfile)

                except OSError:

                    reason  = self.lang["RENAME"] % (shelltemp, outfile,)

                    raise IOError, reason

            self.commits = 0

            if baton:

                baton.end()

            return None

        except IOError, details:

            return details.args[0]

    def save_symbol(self, symbol, shellstream, label=""):

        symname = self.prefix + symbol.name

        value = symbol.eval(self.debug)

        self.debug_emit(2, self.lang["ABOUT"] %(symname,value,type(value)))

        try:

            if symbol.type == "decimal":

                shellstream.write("%s=%d" % (symname, value))

            elif symbol.type == "hexadecimal":

                shellstream.write("%s=0x%x" % (symname, value))

            elif symbol.type == "string":

                shellstream.write("%s=\"%s\"" % (symname, value))

            elif symbol.type in ("bool", "trit"):

                shellstream.write("%s=%s" % (symname, `value`))

            elif value == None and symbol.is_logical():

                shellstream.write("%s=n" % (symname,))

            else:

                raise ValueError, self.lang["VALUNKNOWN"] % (symbol,symbol.type,value)

            if label:

                shellstream.write("\t# " + label)

            shellstream.write("\n")

        except:

            (errtype, errval, errtrace) = sys.exc_info()

            print "Internal error %s while writing %s." % (errtype, symbol)

            raise SystemExit, 1

    def __save_recurse(self, node, shellstream, baton=None, mode="normal"):

        saveable = self.saveable(node, mode)

        if not saveable:

            self.debug_emit(2, self.lang["UNSAVEABLE"] % node.name)

            return

        elif node.items:

            shellstream.write("\n#\n# %s\n#\n" % (node.prompt,))

            # In case this is a choice menu not previously visited.

            self.visit(node)

            for child in node.items:

                self.__save_recurse(child, shellstream, baton, mode)

            shellstream.write("\n")

        elif node.type != 'message':

            label = ""

            if node.properties:

                label += node.showprops()

            if node.properties and mode=="list" and not saveable:

                label += " "

            if mode == "list" and not saveable:

                label += self.lang["NOTSAVED"]

            self.save_symbol(node, shellstream, label)

        if baton:

            baton.twirl()

    # Symbol predicates.

    def is_mutable(self, symbol):

        "Is a term mutable (symbol, not frozen)?"

        return isinstance(symbol, cml.ConfigSymbol) and not symbol.frozen()

    def is_visible(self, query):

        "Should we ask this question?"

        self.debug_emit(2, self.lang["INVISSTART"] % (query.name,))

        # Maybe we're not doing elisions

        if not self.suppressions:

            return 1

        # Maybe it has no help.

        if not self.__help_visible(query):

            self.debug_emit(2, self.lang["INVISHELP"] % (query.name,))

            return 0

        # Check to see if the symbol or any menu in the chain above it

        # is suppressed by a visibility constraint or ancestry.

        if not self.__upward_visible(query):

            self.debug_emit(2, self.lang["INVISUP"] % (query.name,))

            return 0

        # Elide a message if everything between it and the next message

        # is invisible.

        if query.type == "message":

            for i in range(query.menu.items.index(query)+1, len(query.menu.items)):

                if query.menu.items[i].type == "message":

                    break

                elif self.is_visible(query.menu.items[i]):

                    return 1

            return 0

        # Elide a menu if all subqueries are invisible, or a choices if one is.

        if not self.__subqueries_visible(query):

            return 0

        # All tests passed, it's visible

        self.debug_emit(2, self.lang["VISIBLE"] % (query.name))

        return 1

    def is_visible_menus_choices(self, query):