logconf.py

xen虚拟机源代码安装包

        label = Label(self, text="Filters:")
        label.grid(row=0, column=0, sticky='w')
        self.slist = ScrollList(self, height=4, background='white')
        self.slist.list.bind('<ButtonRelease-1>', self.onListChange)
        self.slist.grid(row=1, column=0, sticky="nsew")
        self.adu = ADUPanel(self)
        self.adu.grid(row=2, column=0, sticky="ew")
        label = Label(self, text="Properties of selected filter:")
        label.grid(row=3, column=0, sticky='w')
        self.pe = PropertyEditor(self, height=60, borderwidth=1)
        self.pe.grid(row=4, column=0, sticky='nsew')
        self.columnconfigure(0, weight=1)
        self.rowconfigure(1, weight=1)
        self.rowconfigure(4, weight=1)

    def setConfig(self, config):
        self.config = config
        #populate list of filters
        flist = config.getFilters()
        flist.sort(sortn)
        self.slist.list.delete(0, END)
        self.pe.body.clear()
        for filt in flist:
            self.slist.list.insert(END, filt.getPropValue("name"))

    def onAdd(self):
        self.pe.body.hideControls()
        filt = self.config.getFilter(None)
        self.slist.list.insert(END, filt.getProp("name").getValueText())
        self.slist.list.select_clear(0, END)
        i = self.slist.list.size()
        self.slist.list.select_set(i - 1)
        self.pe.setPropertyHolder(filt)

    def onDelete(self):
        self.pe.body.hideControls()
        items = self.slist.list.curselection()
        if not len(items):
            showerror("No Item Selected", "You haven't selected anything to delete")
        else:
            name = self.slist.list.get(int(items[0]))
            h = self.config.filterIsUsed(name)
            if h:
                showerror("Filter in use",
                          "The filter '%s' is being used by '%s'"\
                          ", so it cannot be deleted." % (
                          name, h))
            else:
                self.config.removeFilter(name)
                self.slist.list.delete(items)
                self.pe.body.clear()

    def onUpdate(self):
        self.pe.body.hideControls()

    def onListChange(self, event):
        self.pe.body.hideControls()
        items = self.slist.list.curselection()
        name = self.slist.list.get(int(items[0]))
        filt = self.config.getFilter(name)
        self.pe.setPropertyHolder(filt)

class ConfigPanel(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)
        self.parent = parent
        self.load = Button(self, text="Load...", command=parent.onLoad)
        self.load.pack(side=LEFT)
        self.save = Button(self, text="Save", command=parent.onSave)
        self.save.pack(side=LEFT)
        self.save = Button(self, text="Save as...", command=parent.onSaveAs)
        self.save.pack(side=LEFT)
        self.reset = Button(self, text="Reset", command=parent.onReset)
        self.reset.pack(side=RIGHT)

class Configurator(Frame):
    def __init__(self, parent):
        Frame.__init__(self, parent)
        self.parent = parent
        self.llist = LoggerPanel(self)
        self.llist.grid(row=0, column=0, rowspan=2, sticky='nsew')
        spacer = Canvas(self, width=2, highlightthickness=0)
        spacer.grid(row=0, column=1, rowspan=2, sticky='ns')
        self.hlist = HandlerPanel(self)
        self.hlist.grid(row=0, column=2, sticky='nsew')
        self.flist = FormatterPanel(self)
        self.flist.grid(row=1, column=2, sticky='nsew')
        self.cfg = ConfigPanel(self)
        self.cfg.grid(row=2, column=0, columnspan=2, sticky='w')
        self.filename = None

        self.rowconfigure(0, weight=1)
        self.columnconfigure(0, weight=1)
        self.columnconfigure(2, weight=1)

        label = Label(self, text="Copyright (C) 2002 Vinay Sajip. All rights reserved.", foreground='brown')
        label.grid(row=3, column=0, columnspan=2, sticky='w')

        if len(sys.argv) > 1:
            fn = sys.argv[1]
            try:
                self.loadFile(fn)
            except Exception, e:
                print e
                raise
        else:
            self.onReset(0)
        self.setTitle()
        self.focus_set()

    def setTitle(self):
        if self.filename:
            s = os.path.split(self.filename)[1]
        else:
            s = "untitled"
        self.winfo_toplevel().title("%s - Python Logging Configurator V%s" % (s, __version__))

    def loadFile(self, fn):
        self.config = LoggingConfig()
        self.config.read(fn)
        self.filename = fn
        self.llist.setConfig(self.config)
        self.hlist.setConfig(self.config)
        self.flist.setConfig(self.config)
        self.setTitle()

    def onLoad(self):
        fn = askopenfilename(title="Choose configuration file", filetypes=[("Logging configurations", "*.ini"), ("All files", "*.*")])
        if fn:
            self.loadFile(fn)

    def onSaveAs(self):
        if self.filename:
            fn = os.path.split(self.filename)[1]
        else:
            fn = DEFAULT_FILENAME
        fn = asksaveasfilename(title="Save configuration as", initialfile=fn, filetypes=[("Logging configurations", "*.ini"), ("All files", "*.*")])
        if fn:
            self.config.save(fn)
            self.filename = fn
            self.setTitle()

    def onSave(self):
        if not self.filename:
            self.onSaveAs()
        else:
            self.config.save(self.filename)

    def onReset(self, confirm=1):
        if not confirm:
            doit = 1
        else:
            doit = askyesno("Reset", "Are you sure you want to reset?")
        if doit:
            self.config = LoggingConfig()
            self.llist.setConfig(self.config)
            self.hlist.setConfig(self.config)
            self.flist.setConfig(self.config)
            self.setTitle()

# -- general properties

class NameProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "name", "Name", value)

class LevelProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "level", "Level", value)

    def getChoices(self):
        return LOGGING_LEVELS

# -- formatter properties

class FormatProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "format", "Format", value)

class DateFormatProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "datefmt", "Date Format", value)

class FormatterProxy(PropertyHolder):
    def __init__(self, config, dict):
        self.config = config
        PropertyHolder.__init__(self, dict)
        prop = NameProperty(dict.get("name", ""))
        self.dict["name"] = prop
        prop = FormatProperty(dict.get("format", "%(asctime)s %(levelname)s %(message)s"))
        self.dict["format"] = prop
        prop = DateFormatProperty(dict.get("datefmt", ""))
        self.dict["datefmt"] = prop
        self.propnames = ["name", "format", "datefmt"]

    def isReadonly(self, name):
        return name == "name"

    def writeConfig(self, file):
        file.write("[formatter_%s]\n" % self.getPropValue("name"))
        file.write("format=%s\n" % self.getPropValue("format"))
        file.write("datefmt=%s\n\n" % self.getPropValue("datefmt"))

# -- filter properties

class LoggerNameProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "lname", "Name", value)

class FilterProxy(PropertyHolder):
    def __init__(self, config, dict):
        self.config = config
        PropertyHolder.__init__(self, dict)
        prop = NameProperty(dict.get("name", ""))
        self.dict["name"] = prop
        prop = LoggerNameProperty(dict.get("lname", ""))
        self.dict["lname"] = prop
        self.propnames = ["name", "lname"]

    def isReadonly(self, name):
        return name == "name"

    def writeConfig(self, file):
        file.write("[filter_%s]\n" % self.getPropValue("name"))
        file.write("lname=%s\n" % self.getPropValue("lname"))

# -- handler properties and proxies

class HandlerTypeProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "class", "Type", value)

    def getChoices(self):
        return HANDLER_TYPES

class FormatterProperty(Property):
    def __init__(self, config, value=None):
        self.config = config
        Property.__init__(self, "formatter", "Formatter", value)

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

class HandlerProxy(PropertyHolder):
    def __init__(self, config, dict):
        self.config = config
        PropertyHolder.__init__(self, dict)
        prop = NameProperty(dict.get("name", ""))
        self.dict["name"] = prop
        prop = HandlerTypeProperty(dict.get("class", "StreamHandlerProxy"))
        self.dict["class"] = prop
        prop = FormatterProperty(self.config, dict.get("formatter", ""))
        self.dict["formatter"] = prop
        prop = LevelProperty(dict.get("level", "NOTSET"))
        self.dict["level"] = prop
        self.propnames = ["name", "class", "level", "formatter"]

    def isReadonly(self, name):
        return (name == "name")

    def setPropValue(self, name, value):
        PropertyHolder.setPropValue(self, name, value)
        if (name == "class"):   #morph type of handler
            #print "try morph -> %s" % value
            try:
                klass = eval(value)
            except Exception, e:
                print e
                klass = None
            if klass:
                n = self.getPropValue("name")
                d = {
                        "name": n,
                        "class": value,
                        "formatter": self.getPropValue("formatter"),
                        "level": self.getPropValue("level"),
                        }
                newhand = klass(self.config, d)
                self.config.handlers[n] = newhand   #FIXME encapsulation
                if self.onPropListChanged:
                    self.onPropListChanged(newhand)

    def writeConfig(self, file):
        file.write("[handler_%s]\n" % self.getPropValue("name"))
        s = self.getProp("class").getValueText()
        if not s in ["StreamHandler", "FileHandler"]:
            s = "handlers." + s
        file.write("class=%s\n" % s)
        file.write("level=%s\n" % self.getPropValue("level"))
        file.write("formatter=%s\n" % self.getPropValue("formatter"))

class StreamProperty(Property):
    def __init__(self, config, value=None):
        self.config = config
        Property.__init__(self, "stream", "Stream", value)

    def getChoices(self):
        return OUTPUT_STREAMS

class StreamHandlerProxy(HandlerProxy):
    def __init__(self, config, dict):
        HandlerProxy.__init__(self, config, dict)
        prop = StreamProperty(self.config, dict.get("stream", "sys.stderr"))
        self.dict["stream"] = prop
        self.propnames.append("stream")

    def writeConfig(self, file):
        HandlerProxy.writeConfig(self, file)
        file.write("stream=%s\n" % self.getPropValue("stream"))
        file.write("args=(%s,)\n\n" % self.getPropValue("stream"))

    def readConfig(self, sectname):
        prop = StreamProperty(self.config, self.config.get(sectname, "stream"))
        self.dict["stream"] = prop
        self.propnames.append("stream")

class FilenameProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "filename", "File name", value)

class ModeProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "mode", "Mode", value)

    def getChoices(self):
        return FILE_MODES

class MaxSizeProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "maxsize", "Maximum Size (bytes)", value)

class BackupCountProperty(Property):
    def __init__(self, value=None):
        Property.__init__(self, "backcount", "Backup Count", value)

class FileHandlerProxy(HandlerProxy):
    def __init__(self, config, dict):
        HandlerProxy.__init__(self, config, dict)
        prop = FilenameProperty(dict.get("filename", "python.log"))
        self.dict["filename"] = prop
        prop = ModeProperty(dict.get("mode", "a"))
        self.dict["mode"] = prop
        self.propnames.extend(["filename", "mode"])

    def writeConfig(self, file):
        HandlerProxy.writeConfig(self, file)
        fn = self.getPropValue("filename")
        file.write("filename=%s\n" % fn)