source: SHX/trunk/SeismicHandler/config/runtime.py @ 529

# -*- coding: utf-8 -*-

#    This file is part of Seismic Handler eXtended (SHX).
#
#    SHX is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Lesser General Public License as published
#    by the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    SHX is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Lesser General Public License for more details.
#
#    You should have received a copy of the GNU Lesser General Public License
#    along with SHX.  If not, see <http://www.gnu.org/licenses/>.

"""
This object carries all settings for runtime including global variables.

E.g. Echo Channel, Cap Conversion, ...
"""

# Please note that in this file no logging takes place since configuration
# options for logging are initialized here first.
# Also _all_ code in modules/* use runtime.py so that any defined method under
# "modules" should not be used here (to avoid import loops).


import sys
import os
import ConfigParser
import warnings
from SeismicHandler.basics import Property, Singleton, AttribDict
from SeismicHandler.basics.messages import msgs, logMessage


class runtime(object):
    """
    >>> Settings = runtime()

    >>> print >> Settings.echo_channel, Settings.echo_channel
    >>> Settings.echo_channel = "TEST"
    >>> print >> Settings.echo_channel, Settings.echo_channel
    >>> Settings.echo_channel = ""
    >>> print >> Settings.echo_channel, Settings.echo_channel #doctest: +ELLIPSIS
    <doctest...
    
    Now a file named TEST should contain
    >>> open("TEST").read() #doctest: +ELLIPSIS
    "<open file 'TEST', mode 'ab' at 0x..."

    This is only for clean-up:
    >>> import os
    >>> os.unlink("TEST")
    """
    __metaclass__ = Singleton

    # see echo_channel()
    __echo_channel = sys.stdout
    
    # configuration is read from file
    config = None

    # global switches (see http://www.seismic-handler.org/portal/wiki/ShSwitch)
    _Switches = AttribDict({
        # convert to upper case
        "Capcnv": True,
        # echo command before execution
        "Echo": False,
        # verify command
        "Verify": False,
        # cancel script on error
        "Cmderrstop": True,
        # exit SH on error
        "Sherrstop": False,
        # no error message at all
        "Noerrmsg": False,
        # verbose
        "Chatty": True,
        # indicate startup file
        "Startup": False,
        # SHX: add new traces or discard old ones, to be altered only globally!
        "Keeptraces": True,
    })

    # dictionary of global variables
    Globals = AttribDict()

    # container for internal data like $status
    Runtime = AttribDict({
        "status": 0,
        "dsptrcs": 0,
        "tottrcs": 0,
    })

    def __init__(self):
        if not self.config:
            self.readConfig()
            msgs.subscribe(self._setRuntimeVar, 'runtime')

    def readConfig(self):
        """
        Read configuration file.

        Possible locations of shx.conf
        1. installation directory
        2. /etc/
        3. $HOME/.shx/
        All configurations files found are processed in this order!

        Finally the variable "conf" contains the full parsed configuration and
        "fullconfig" contains the merged configuration with replacements.
        """

        # helper function
        def __handlePlaceholdersVars(values, replacevars=False):
            """
            Replace placeholders in config file.
            """

            # split values
            if type(values) != list:
                values = map(str.strip, values.split(","))
            
            ret = []
            for v in values:
                if v.find("[") >= 0:
                    # replacement requested
                    for d in replace.keys():
                        if v.find("[%s]" % d) >= 0:
                            # do replacement
                            ret.append(v.replace("[%s]" % d, replace[d]))
                elif replacevars and v.startswith("$"):
                    # variable substitution
                    try:
                        ret.extend(vars[v.lower()])
                    except KeyError:
                        warnings.warn("Variable '%s' not found!" % v, SyntaxWarning)
                else:
                    ret.append(v)

            return ret

        # "main" function
        dirs_check = [
            ["SHX", os.path.abspath(__file__).rsplit(os.path.sep, 2)[0]],
            ["ETC", "/etc/SeismicHandler"], # XXX not portable!
        ]

        dir_home = os.getenv("HOME", None)

        if dir_home:
            dirs_check.append(["PRIVATE", os.path.join(dir_home, ".shx")])
            # XXX not portable!

        dirs = []
        replace = {}
        for d in dirs_check:
            src = os.path.join(d[1], "shx.conf")
            replace[d[0]] = d[1]
            if os.path.exists(src):
                dirs.append(src)

        conf = AttribDict()
        vars = AttribDict()

        # includes merged configuration without replacements
        # mainly useful for debugging
        mergedConfig = ConfigParser.SafeConfigParser()

        for src in dirs:
            config = ConfigParser.SafeConfigParser()
            config.read(src)

            for s in config.sections():
                if not mergedConfig.has_section(s):
                    mergedConfig.add_section(s)

                if s not in conf.keys():
                    conf[s] = AttribDict()

                for i in config.items(s):
                    mergedConfig.set(s, *i)
                    
                    # check for variable definition
                    if i[0].startswith("$"):
                        v = i[0].lower()
                        if v in vars:
                            warnings.warn("Variable '%s' defined more "
                                          "than once!" % v, SyntaxWarning)

                        vars[v] = __handlePlaceholdersVars(i[1])
                    else:
                        conf[s][i[0]] = __handlePlaceholdersVars(i[1])

                # check if include statement was defined -> process last
                if "include" in conf[s]:

                    # include sub configfile if requested
                    extra = ConfigParser.SafeConfigParser()
                    for e in conf[s]["include"]:
                        extra.read(e)

                        # only include current section
                        if not extra.has_section(s):
                            warnings.warn("To be included configuration file "
                                          "'%s' not found." % e, SyntaxWarning)
                            break

                        for ie in extra.items(s):
                            mergedConfig.set(s, *ie)
                            conf[s][ie[0]] = __handlePlaceholdersVars(ie[1])

                    del conf[s]["include"]
                    mergedConfig.remove_option(s, "include")

        # since configparser doesn't preserve order of entries, variables will
        # be processed last.
        for s in conf:
            for i in conf[s]:
                conf[s][i] = __handlePlaceholdersVars(conf[s][i], True)
                
        self.config = conf
        self.__mergedConfig = mergedConfig

    def __getattr__(self, name):
        if name.startswith("sw"):
            return getattr(self, "_Switches")[name[2:]]
        else:
            return object.__getattribute__(self, name)

    def __setattr__(self, name, value):
        if name.startswith("sw"):
            if not name[2:] in self.__class__.__dict__["_Switches"].keys():
                raise NameError("Unknown switch!")
            
            self.__class__.__dict__["_Switches"][name[2:]] = value
        elif name == "echo_channel":
            object.__setattr__(self, "echo_channel", value)
        else:
            self.__dict__[name] = value

    def _setRuntimeVar(self, name, value):
        logMessage(
            "debug.runtime",
            "Received internal update for '%s' (%s)" % (name, str(value))
        )
        self.Runtime[name] = value

    @Property
    def echo_channel():
        """
        The echo_channel is a special property used for data output. As
        default all output goes to stdout. Using the ECHO_CH command
        this can be redirected to a file.

        This method cares for proper handling of file-like objects. New
        feature: It's possible to use any object offering the methods
        "write" and "close", e.g. a stream.

        The actual target of output is stored in the class attribute
        "__echo_channel".
        """

        def fget(self):
            return self.__echo_channel

        def fset(self, value = None):
            # clear setting
            if not value:
                fdel(self)
                return

            # We assume that there's a file for output or a stream (actually I
            # don't really care about it's true nature, since it offers the
            # methods "write" and "close").
            if hasattr(value, "write") and hasattr(value, "close"):
                self.__echo_channel = value
            elif isinstance(value, basestring):
                # open file
                self.__echo_channel = open(value, "ab")
            else:
                raise ValueError("This echo channel cannot be used.")

        def fdel(self):
            if self.__echo_channel == sys.stdout:
                return

            # close open files/stream
            if not self.__echo_channel.closed:
                self.__echo_channel.close()

            self.__echo_channel = sys.stdout

        return locals()


if __name__ == "__main__":
    import doctest
    doctest.testmod(exclude_empty=True)