Synnefo

import os

import datetime

import logging

class SynnefoOutputWrapper(object):

    """Wrapper around stdout/stderr

    This class replaces Django's 'OutputWrapper' which doesn't handle

    logging to file.

    Since 'BaseCommand' doesn't initialize the 'stdout' and 'stderr'

    attributes at '__init__' but sets them only when it needs to,

    this class has to be a descriptor.

    We will use the old 'OutputWrapper' class for print to the screen and

    a logger for logging to the file.

    """

    def __init__(self):

        self.django_wrapper = None

        self.logger = None

    def __set__(self, obj, value):

        self.django_wrapper = value

    def __getattr__(self, name):

        return getattr(self.django_wrapper, name)

    def init_argv(self, argv):

        """Initialize this class using the command line

        Takes the command arguments, generate the filename where

        we are going to log, initialize our logger and return the

        generated filename.

        """

        curr_time = datetime.datetime.now()

        curr_time = datetime.datetime.strftime(curr_time, "%y%m%d%H%M%S")

        command = argv[1]

        pid = os.getpid()

        basename = "%s_%s_%s.log" % (curr_time, command, pid)

        filename = os.path.join("/var/log/synnefo/", basename)

        self.init_file(filename)

        self.logger.info(" ".join(map(str, argv)) + "\n\n")

        return filename

    def init_file(self, filename):

        """Create a logger for the filename"""

        basename = os.path.splitext(os.path.basename(filename))[0]

        self.logger = logging.getLogger(basename)

        self.logger.setLevel(logging.DEBUG)

        self.logger.propagate = False

        if not self.logger.handlers:

            handler = logging.FileHandler(filename)

            self.logger.addHandler(handler)

            # Also set all other logger to log to this file

            logging.getLogger().addHandler(handler)

    def write(self, msg, *args, **kwargs):

        if self.logger is not None:

            self.logger.info(msg)

        if self.django_wrapper is not None:

            self.django_wrapper.write(msg, *args, **kwargs)

    stdout = SynnefoOutputWrapper()

    stderr = SynnefoOutputWrapper()

    def run_from_argv(self, argv):

        """Initialize 'SynnefoOutputWrapper' and call super

        The two wrappers have to write to the same filename, so we cannot

        initialze both of them (each will create a new filename).  Furthermore

        we cannot have only one wrapper (BaseCommand has both 'stdout' and

        'stderr'). So call 'init_argv' for the first wrapper and give the

        resulting filename to the second.

        XXX: Find a better way to do the above.

        """

        filename = self.stdout.init_argv(argv)

        self.stderr.init_file(filename)

        super(SynnefoCommand, self).run_from_argv(argv)

                objects = objects.exclude(**{key: value})