logconf.py

xen虚拟机源代码安装包

        ltype = self.getPropValue("logtype")
        file.write("logtype=%s\n" % ltype)
        file.write("args=('%s', '%s', '%s')\n\n" % (app, dll, ltype))

    def readConfig(self, sectname):
        prop = AppNameProperty(self.config.get(sectname, "appname"))
        self.dict["appname"] = prop
        prop = DLLNameProperty(self.config.get(sectname, "dllname"))
        self.dict["dllname"] = prop
        prop = LogTypeProperty(self.config.get(sectname, "logtype"))
        self.dict["logtype"] = prop
        self.propnames.extend(["appname", "dllname", "logtype"])

# -- logger properties and proxies

class ChannelProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "channel", "Name", value)

class HandlerProperty(Property):
    def __init__(self, config, value=None):
        self.config = config
        Property.__init__(self, "handler", "Handlers", value)

    def getChoices(self):
        return self.config.getHandlerChoice()

class FilterProperty(Property):
    def __init__(self, config, value=None):
        self.config = config
        Property.__init__(self, "filter", "Filters", value)

    def getChoices(self):
        return self.config.getFilterChoice()

class ParentProperty(Property):
    def __init__(self, config, value=None):
        self.config = config
        Property.__init__(self, "parent", "Parent", value)

    def getChoices(self):
        loggers = self.config.getLoggerChoice()
        nm = self.dict["name"].getValueText()
        #can't be own parent...
        return filter(lambda x,nm=nm: x[0] != nm, loggers)

    def getValueText(self):
        if self.dict.has_key("root"):
            return ""
        pn = Property.getValueText(self)
        rv = ""
        while pn != "(root)":
            parent = self.config.getLogger(pn)
            rv = parent.getPropValue("channel") + "." + rv
            pn = parent.getProp("parent").value
        return rv[:-1]

class PropagateProperty(Property):
    def __init__(self, config, value=None):
        self.config = config
        Property.__init__(self, "propagate", "Propagate", value)

    def getChoices(self):
        return BOOLEAN_VALUES

class LoggerProxy(PropertyHolder):
    def __init__(self, config, dict):
        self.config = config
        PropertyHolder.__init__(self, dict)
        prop = ChannelProperty(dict.get("channel", ""))
        self.dict["channel"] = prop
        prop = NameProperty(dict.get("name", ""))
        self.dict["name"] = prop
        prop = HandlerProperty(config, dict.get("handler", []))
        self.dict["handler"] = prop
        prop = LevelProperty(dict.get("level", "NOTSET"))
        self.dict["level"] = prop
        prop = PropagateProperty(self.config, dict.get("propagate", "1"))
        self.dict["propagate"] = prop
        prop = ParentProperty(config, dict.get("parent", "(root)"))
        prop.dict = self.dict
        self.dict["parent"] = prop
        self.propnames = ["parent", "channel", "level", "propagate", "handler"]
        self.onChannelChanged = None
        self.deleted = 0

    def isReadonly(self, name):
        return (name in ["channel", "parent", "propagate"]) and self.dict.has_key("root")

    def getQualifiedName(self):
        pt = self.getProp("parent").getValueText()
        nm = self.getPropValue("channel")
        if pt:
            pn =  pt + "." + nm
        else:
            pn = nm
            if pn == "":
                pn = "(root)"
        return pn

    def setPropValue(self, name, value):
        PropertyHolder.setPropValue(self, name, value)
        if (name == "channel"):
            nm = self.getPropValue("name")
            if self.onChannelChanged:
                self.onChannelChanged(nm, value)

    def writeConfig(self, file):
        if self.dict.has_key("root"):
            name = "root"
        else:
            name = self.getPropValue("name")
        file.write("[logger_%s]\n" % name)
        file.write("level=%s\n" % self.getPropValue("level"))
        file.write("propagate=%s\n" % self.getPropValue("propagate"))
        file.write("channel=%s\n" % self.getPropValue("channel"))
        file.write("parent=%s\n" % self.getPropValue("parent"))
        file.write("qualname=%s\n" % self.getQualifiedName())
        file.write("handlers=%s\n\n" %  string.join(self.getPropValue("handler"), ","))

# -- logging configuration

class LoggingConfig(ConfigParser.ConfigParser):
    def __init__(self, defaults=None):
        ConfigParser.ConfigParser.__init__(self, defaults)
        self.formatters = {}
        self.handlers = {}
        self.loggers = {}
#        self.filters = {}
        #create root logger
        d = { "name": "(root)", "root": 1, "parent": "" }
        self.loggers["(root)"] = LoggerProxy(self, d)

    def read(self, fn):
        ConfigParser.ConfigParser.read(self, fn)
        llist = self.get("loggers", "keys")
        llist = string.split(llist, ",")
        llist.remove("root")
        sectname = "logger_root"
        log = self.loggers["(root)"]
        log.setPropValue("level", self.get(sectname, "level"))
        hlist = self.get(sectname, "handlers")
        hlist = string.split(hlist, ",")
        log.setPropValue("handler", hlist)
        for log in llist:
            sectname = "logger_%s" % log
            hlist = self.get(sectname, "handlers")
            hlist = string.split(hlist, ",")
            d = {
                "name"      : log,
                "level"     : self.get(sectname, "level"),
                "channel"   : self.get(sectname, "channel"),
                "parent"    : self.get(sectname, "parent"),
                "propagate" : self.get(sectname, "propagate"),
                "handler"   : hlist,
            }
            self.loggers[log] = LoggerProxy(self, d)
        hlist = self.get("handlers", "keys")
        if len(hlist):
            hlist = string.split(hlist, ",")
            for hand in hlist:
                sectname = "handler_%s" % hand
                klass = self.get(sectname, "class")
                if klass[:9] == "handlers.":
                    klass = klass[9:]
                d = {
                    "name"      : hand,
                    "class"     : "%sProxy" % klass,
                    "level"     : self.get(sectname, "level"),
                    "formatter" : self.get(sectname, "formatter"),
                }
                hobj = HandlerProxy(self, d)
                hobj.__class__ = eval("%sProxy" % klass)
                hobj.readConfig(sectname)
                self.handlers[hand] = hobj

        flist = self.get("formatters", "keys")
        if len(flist):
            flist = string.split(flist, ",")
            for form in flist:
                sectname = "formatter_%s" % form
                d = {
                    "name"   : form,
                    "format" : self.get(sectname, "format", 1),
                    "datefmt" : self.get(sectname, "datefmt", 1),
                }
                self.formatters[form] = FormatterProxy(self, d)

#        flist = self.get("filters", "keys")
#        if len(flist):
#            flist = string.split(flist, ",")
#            for filt in flist:
#                sectname = "filter_%s" % filt
#                d = {
#                    "name"   : filt,
#                    "lname"  : self.get(sectname, "lname", 1),
#                }
#                self.filters[filt] = FilterProxy(self, d)

    def getFormatter(self, name):
        if name:
            fmt = self.formatters[name]
        else:
            n = len(self.formatters.keys()) + 1
            name = "form%02d" % n
            fmt = FormatterProxy(self, {"name": name})
            self.formatters[name] = fmt
        return fmt

    def getHandler(self, name):
        if name:
            hand = self.handlers[name]
        else:
            n = len(self.handlers.keys()) + 1
            name = "hand%02d" % n
            hand = StreamHandlerProxy(self, {"name": name})
            self.handlers[name] = hand
        return hand

    def getLogger(self, name):
        if name:
            log = self.loggers[name]
        else:
            n = len(self.loggers.keys()) + 1
            name = "log%02d" % n
            log = LoggerProxy(self, {"name": name, "channel": name})
            self.loggers[name] = log
        return log

    def getFormatterChoice(self):
        values = []
        keys = self.formatters.keys()
        keys.sort()
        for f in keys:
            values.append((f, f))
        return tuple(values)

    def getHandlerChoice(self):
        values = []
        keys = self.handlers.keys()
        keys.sort()
        for f in keys:
            values.append((f, f))
        return tuple(values)

    def getFilterChoice(self):
        values = []
        keys = self.filters.keys()
        keys.sort()
        for f in keys:
            values.append((f, f))
        return tuple(values)

    def getLoggerChoice(self):
        values = []
        keys = self.loggers.keys()
        keys.sort()
        for f in keys:
            values.append((f, f))
        return tuple(values)

    def getLoggers(self):
        return self.loggers.values()

    def getHandlers(self):
        return self.handlers.values()

    def getFormatters(self):
        return self.formatters.values()

    def formatterIsUsed(self, name):
        rv = None
        for h in self.handlers.keys():
            if self.handlers[h].getPropValue("formatter") == name:
                rv = h
                break
        return rv

    def handlerIsUsed(self, name):
        rv = None
        for log in self.loggers.keys():
            if name in self.loggers[log].getPropValue("handler"):
                rv = log
                break
        return rv

    def removeFormatter(self, name):
        del self.formatters[name]

    def removeHandler(self, name):
        del self.handlers[name]

    def removeLogger(self, name):
        del self.loggers[name]

    def save(self, fn):
        #needed because 1.5.2 ConfigParser should be supported
        file = open(fn, "w")
        #Write out the keys
        loggers = self.loggers.keys()
        loggers.remove("(root)")
        loggers = filter(lambda x, d=self.loggers: not d[x].deleted, loggers)
        loggers.sort()
        list = ["root"]
        list.extend(loggers)
        file.write("[loggers]\nkeys=%s\n\n" % string.join(list, ","))
        handlers = self.handlers.keys()
        handlers.sort()
        file.write("[handlers]\nkeys=%s\n\n" % string.join(handlers, ","))
        formatters = self.formatters.keys()
        formatters.sort()
        file.write("[formatters]\nkeys=%s\n\n" % string.join(formatters, ","))
        #write out the root logger properties
        log = self.loggers["(root)"]
        log.writeConfig(file)
        #write out other logger properties
        for log in loggers:
            log = self.loggers[log]
            log.writeConfig(file)
        #write out handler properties
        for hand in handlers:
            hand = self.handlers[hand]
            hand.writeConfig(file)
        #write out formatter properties
        for form in formatters:
            form = self.formatters[form]
            form.writeConfig(file)
        file.close()

root = None

def onClose():
    if _popup:
        _popup.withdraw()
    root.destroy()

def main():
    global root
    root=Tk()
    cfg = Configurator(root)
    cfg.pack(side=LEFT, fill=BOTH, expand=1)
    root.protocol("WM_DELETE_WINDOW", onClose)
    root.mainloop()

if __name__ == "__main__":
    main()