logconf.py

xen虚拟机源代码安装包

#!/usr/bin/env python
#
# Copyright 2001-2002 by Vinay Sajip. All Rights Reserved.
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose and without fee is hereby granted,
# provided that the above copyright notice appear in all copies and that
# both that copyright notice and this permission notice appear in
# supporting documentation, and that the name of Vinay Sajip
# not be used in advertising or publicity pertaining to distribution
# of the software without specific, written prior permission.
# VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
# ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
# VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
# ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
# IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#
# This file is part of the Python logging distribution. See
# http://www.red-dove.com/python_logging.html
#

"""
A simple-minded GUI configurator for the logging module, using Tkinter.

Should work under Python versions >= 1.5.2.

Copyright (C) 2002 Vinay Sajip. All Rights Reserved.

Configuration files are read/written using ConfigParser.
"""
"""

(C) 2002 Vinay Sajip. All rights reserved.
"""
from Tkinter import *
from tkFileDialog import *
from tkMessageBox import *

import os, sys, string, types
import ConfigParser

active = None

__version__ = "0.4.1"

DEFAULT_FILENAME = "logconf.ini"

LOGGING_LEVELS = (
    ("NOTSET", "NOTSET"),
    ("DEBUG", "DEBUG"),
    ("INFO", "INFO"),
    ("WARNING", "WARNING"),
    ("ERROR", "ERROR"),
    ("CRITICAL", "CRITICAL")
)

HANDLER_TYPES = (
    ("StreamHandlerProxy", "StreamHandler"),
    ("FileHandlerProxy", "FileHandler"),
    ("RotatingFileHandlerProxy", "RotatingFileHandler"),
    ("SocketHandlerProxy", "SocketHandler"),
    ("DatagramHandlerProxy", "DatagramHandler"),
    ("SysLogHandlerProxy", "SysLogHandler"),
    ("NTEventLogHandlerProxy", "NTEventLogHandler"),
    ("SMTPHandlerProxy", "SMTPHandler"),
    ("MemoryHandlerProxy", "MemoryHandler"),
    ("HTTPHandlerProxy", "HTTPHandler"),
#    ("SOAPHandlerProxy", "SOAPHandler"),
)

OUTPUT_STREAMS = (
    ("sys.stdout", "sys.stdout"),
    ("sys.stderr", "sys.stderr")
)

FILE_MODES = (
    ("a", "a"),
    ("w", "w")
 )

HTTP_METHODS = (
    ("GET", "GET"),
    ("POST", "POST")
)

SYSLOG_FACILITIES = (
    ("LOG_AUTH", "auth"),
    ("LOG_AUTHPRIV", "authpriv"),
    ("LOG_CRON", "cron"),
    ("LOG_DAEMON", "daemon"),
    ("LOG_KERN", "kern"),
    ("LOG_LPR", "lpr"),
    ("LOG_MAIL", "mail"),
    ("LOG_NEWS", "news"),
    ("LOG_AUTH", "security"),
    ("LOG_SYSLOG", "syslog"),
    ("LOG_USER", "user"),
    ("LOG_UUCP", "uucp"),
    ("LOG_LOCAL0", "local0"),
    ("LOG_LOCAL1", "local1"),
    ("LOG_LOCAL2", "local2"),
    ("LOG_LOCAL3", "local3"),
    ("LOG_LOCAL4", "local4"),
    ("LOG_LOCAL5", "local5"),
    ("LOG_LOCAL6", "local6"),
    ("LOG_LOCAL7", "local7"),
)

LOG_TYPES = (
    ("Application", "Application"),
    ("System", "System"),
    ("Security", "Security")
)

BOOLEAN_VALUES = (
    ("0", "False"),
    ("1", "True")
)

class Property:
    def __init__(self, name, caption, value=None, choices=None):
        self.name = name
        self.caption = caption
        self.value = value
        self.choices = choices

    def getChoices(self):
        return self.choices

    def isvalid(self, s):
        return 0

    def getCaption(self):
        return self.caption

    def getValue(self):
        return self.value

    def getChoiceText(self, val):
        rv = ""
        choices = self.getChoices()
        if choices:
            for choice in choices:
                if choice[0] == val:
                    rv = choice[1]
                    break
        return rv

    def setValue(self, val):
        self.value = val

    def getValueText(self):
        if type(self.value) in [types.ListType, types.TupleType]:
            v = list(self.value)
        else:
            v = [self.value]
        choices = self.getChoices()
        if choices:
            v = map(self.getChoiceText, v)
        return string.join(v, ',')

class PropertyHolder:
    def __init__(self, dict):
        self.dict = dict
        self.propnames = []
        self.onPropListChanged = None

    def getPropNames(self):
        """
        Return the property names in the order in which they are to
        be listed.
        """
        return self.propnames

    def getProp(self, name):
        return self.dict[name]

    def isReadonly(self, name):
        return 0

    #convenience methods
    def getPropValue(self, name):
        return self.dict[name].value

    def setPropValue(self, name, value):
        self.dict[name].setValue(value)

LINE_COLOUR = '#999999'

class ScrollingList(Frame):
    def __init__(self, parent, *args, **kwargs):
        Frame.__init__(self, parent)
        self.parent = parent
        self.listener = self.parent
        self.sb = Scrollbar(self, orient=VERTICAL)
        kwargs["yscrollcommand"] = self.sb.set
        self.list = apply(Listbox, (self,) + args, kwargs)
        self.sb.config(command=self.list.yview)
        self.sb.pack(side=RIGHT, fill=Y)
        self.list.pack(side=LEFT, fill=BOTH,expand=1)
        self.list.bind('<ButtonRelease-1>', self.onListChange)
        self.choices = None

    def setContents(self, choices, value):
        self.choices = choices
        self.value = value
        self.list.delete(0, END)
        if type(value) == types.ListType:
            sm = EXTENDED
        else:
            sm = BROWSE
        self.list.configure(selectmode=sm)
        i = 0
        for choice in choices:
            self.list.insert(END, choice[1])
            if sm == EXTENDED:
                if choice[0] in value:
                    self.list.select_set(i)
            else:
                if choice[0] == value:
                    self.list.select_set(i)
            i = i + 1

    def getValue(self):
        if type(self.value) == types.ListType:
            multi = 1
            rv = []
        else:
            multi = 0
        for i in xrange(len(self.choices)):
            if self.list.select_includes(i):
                if not multi:
                    rv = self.choices[i][0]
                    break
                else:
                    rv.append(self.choices[i][0])
        return rv

    def onListChange(self, event):
        self.value = self.getValue()
        self.listener.onListChange(self.value)

class PropertyHeader(Canvas):
    def __init__(self, parent, *args, **kwargs):
        self.namewidth = 120
        if kwargs.has_key("namewidth"):
            self.namewidth = kwargs["namewidth"]
            del kwargs["namewidth"]
        self.rowheight = 16
        if kwargs.has_key("rowheight"):
            self.rowheight = kwargs["rowheight"]
            del kwargs["rowheight"]
        apply(Canvas.__init__, (self, parent)+args, kwargs)
        self.bind('<Configure>', self.onConfigure)
        x = 5
        y = 0
        wid = int(self.cget('width'))
        self.create_text(x, y, text='Property', anchor='nw')
        self.create_text(x + self.namewidth, y, text='Value', anchor='nw')
        self.create_line(self.namewidth, 0, self.namewidth, self.rowheight, fill=LINE_COLOUR)
        self.tline = self.create_line(0, 0, wid, 0, fill=LINE_COLOUR)
        #self.create_line(0, 0, 0, self.rowheight, fill=LINE_COLOUR)
        #self.create_line(wid - 1, 0, wid - 1, self.rowheight, fill=LINE_COLOUR)

    def onConfigure(self, event):
        self.delete(self.tline)
        self.tline = self.create_line(0, 0, event.width, 0, fill=LINE_COLOUR)

_popup = None

class PropertyCanvas(Canvas):
    def __init__(self, parent, *args, **kwargs):
        self.namewidth = 120
        if kwargs.has_key("namewidth"):
            self.namewidth = kwargs["namewidth"]
            del kwargs["namewidth"]
        self.rowheight = 16
        if kwargs.has_key("rowheight"):
            self.rowheight = kwargs["rowheight"]
            del kwargs["rowheight"]
        apply(Canvas.__init__, (self, parent)+args, kwargs)
        self.namitems = []
        self.valitems = []
        self.lines = []
        self.pnames = []
        #Event bindings...
        self.bind('<Enter>', self.onEnter)
        self.bind('<Button-1>', self.onClick)
        self.bind('<Configure>', self.onConfigure)
        self.button = Button(height=self.rowheight, width=self.rowheight, text='...', command=self.onEdit)
        self.btnitem = None
        self.editor = Entry()
        self.edititem = None
        self.popup = Toplevel()
        self.popup.withdraw()
        self.popup.overrideredirect(1)
        self.list = ScrollingList(self.popup, background='white', relief=FLAT, borderwidth=0)
        self.list.pack(fill=BOTH, expand=1)
        self.list.listener = self
        self.listvisible = 0

    def clear(self):
        for itm in self.namitems:
            self.delete(itm)
        self.namitems = []
        for itm in self.valitems:
            self.delete(itm)
        self.valitems = []
        for lin in self.lines:
            self.delete(lin)
        self.lines = []

    def setPropertyHolder(self, ph):
        self.ph = ph
        self.pnames = ph.getPropNames()
        wid = int(self.cget('width'))
        hei = int(self.cget('height'))
        self.clear()
        x = 5
        y = 0
        i = 0
        self.props = []
        for n in self.pnames:
            prop = self.ph.getProp(n)
            self.props.append(prop)
            tn = "n%d" % i
            tv = "v%d" % i
            self.namitems.append(self.create_text(x, y + 2, text=prop.getCaption(), anchor='nw', tags=tn))
            self.valitems.append(self.create_text(x + self.namewidth, y + 2, text=prop.getValueText(), anchor='nw', tags=tv))
            y = y + self.rowheight
            i = i + 1
        self.drawLines(wid, hei)
        #self.config(height=y)

    def drawLines(self, wid, hei):
        for lin in self.lines:
            self.delete(lin)
        self.lines = []
        y = 0
        for i in xrange(len(self.pnames)):
            self.lines.append(self.create_line(0, y, wid, y, fill=LINE_COLOUR))
            y = y + self.rowheight
        self.lines.append(self.create_line(0, y, wid, y, fill=LINE_COLOUR))
        self.create_line(self.namewidth, 0, self.namewidth, hei, fill=LINE_COLOUR)

    def onEnter(self, event):
        if not self.edititem and not self.listvisible: