class DummyLogFile(object):
    '''Dummy log file used for testing.'''
    def __init__(
            self, worker_id, directory, rotateLength, maxRotatedFiles):
        self.worker_id = worker_id
        self.directory = directory
        self.rotateLength = rotateLength
        self.maxRotatedFiles = maxRotatedFiles
        self.closed_count = 0
        self.logfile = LogFile(
            worker_id, directory, rotateLength=rotateLength,
            maxRotatedFiles=maxRotatedFiles)
        self.path = self.logfile.path

    @property
    def logs(self):
        reader = self.logfile.getCurrentLog()
        logs = []
        lines = reader.readLines()
        while lines:
            logs.extend(lines)
            lines = reader.readLines()
        return logs

    def write(self, data):
        self.logfile.write(data)
        self.logfile.flush()

    def close(self):
        self.closed_count += 1

    def listLogs(self):
        return []

 def __init__(self, name,group):
   self.orgName = name
   self.name = "".join([x for x in name if x.isalnum()])
   self.group = group
   self.logFile = LogFile(self.name+".log",group.groupDir,rotateLength=100000000,maxRotatedFiles=10)#10M
   self.updateLogFile = LogFile(self.name+".ulog",group.groupDir,rotateLength=100000000,maxRotatedFiles=5)
   self.ssLogFile = LogFile(self.name+".slog",group.groupDir,rotateLength=100000000,maxRotatedFiles=5)
   self.status = PROC_STATUS.STOP
   self.endTime = None
   self.startMemo = ''

 def startService(self):
     self.logfile = LogFile(
         self.worker_id, self.path, rotateLength=self.rotate,
         maxRotatedFiles=self.max_files)
     self.log_observer = JunebugLogObserver(self.logfile, self.worker_id)
     self.logger.addObserver(self.log_observer)
     return super(JunebugLoggerService, self).startService()

 def __init__(
         self, worker_id, path, rotateLength, maxRotatedFiles):
     self.worker_id = worker_id
     self.path = path
     self.rotateLength = rotateLength
     self.maxRotatedFiles = maxRotatedFiles
     self.closed_count = 0
     self.logfile = LogFile.fromFullPath(
         path, rotateLength=rotateLength, maxRotatedFiles=maxRotatedFiles)

 def startService(self):
     if not os.path.exists(self.path):
         os.makedirs(self.path, 0755)
     self.logfile = LogFile(
         self.worker_id, self.path, rotateLength=self.rotate,
         maxRotatedFiles=self.max_files)
     self.log_observer = JunebugLogObserver(self.logfile, self.worker_id)
     self.logger.addObserver(self.log_observer)
     return super(JunebugLoggerService, self).startService()

    def __init__(self, nick, server, channel, port, loggingfile=None):
        self.server = server
        self.port = port

        if loggingfile is not None:
            log.startLogging(LogFile.fromFullPath(loggingfile))
        self.factory = ConversationBotFactory(self, ConversationBotClient,
                                              nick,
                                              channel)

class JunebugLoggerService(Service):
    '''Service for :class:`junebug.logging.JunebugLogObserver`'''
    log_observer = None

    def __init__(self, worker_id, path, rotate, max_files, logger=None):
        '''
        Create the service for the Junebug Log Observer.

        :param str worker_id: ID of the worker to observe logs for.
        :param str path: Path to place the log files.
        :param int rotate: Size (in bytes) before rotating log file.
        :param int max_files:
            Maximum amount of log files before old log files
            start to get deleted.
        :param logger:
            logger to add observer to. Defaults to
            twisted.python.log.theLogPublisher
        :type logger: :class:`twisted.python.log.LogPublisher`
        '''
        self.setName('Junebug Worker Logger')
        self.logger = logger if logger is not None else log.theLogPublisher
        self.worker_id = worker_id
        self.path = path
        self.rotate = rotate
        self.max_files = max_files

    def startService(self):
        if not os.path.exists(self.path):
            os.makedirs(self.path, 0755)
        self.logfile = LogFile(
            self.worker_id, self.path, rotateLength=self.rotate,
            maxRotatedFiles=self.max_files)
        self.log_observer = JunebugLogObserver(self.logfile, self.worker_id)
        self.logger.addObserver(self.log_observer)
        return super(JunebugLoggerService, self).startService()

    def stopService(self):
        if self.running:
            self.logger.removeObserver(self.log_observer)
            self.logfile.close()
        return super(JunebugLoggerService, self).stopService()

    def registered(self):
        return self.log_observer in self.logger.observers

 def _openLogFile(self, path):
     try:
         from twisted.python.logfile import LogFile
         log.msg("Setting up http.log rotating %s files of %s bytes each" %
                 (maxRotatedFiles, rotateLength))
         if hasattr(LogFile, "fromFullPath"):  # not present in Twisted-2.5.0
             return LogFile.fromFullPath(path, rotateLength=rotateLength, maxRotatedFiles=maxRotatedFiles)
         else:
             log.msg("WebStatus: rotated http logs are not supported on this version of Twisted")
     except ImportError, e:
         log.msg("WebStatus: Unable to set up rotating http.log: %s" % e)

 def startService(self):
     Service.startService(self)
     if self.filename != '-':
         self.logfile = LogFile.fromFullPath(
             self.filename, rotateLength=None, defaultMode=0o644)
         self.__previous_signal_handler = signal.signal(
             signal.SIGUSR1, self._signal_handler)
     else:
         self.logfile = sys.stdout
     self.observer = FileLogObserver(self.logfile)
     self.observer.start()

 def __init__(
         self, worker_id, directory, rotateLength, maxRotatedFiles):
     self.worker_id = worker_id
     self.directory = directory
     self.rotateLength = rotateLength
     self.maxRotatedFiles = maxRotatedFiles
     self.closed_count = 0
     self.logfile = LogFile(
         worker_id, directory, rotateLength=rotateLength,
         maxRotatedFiles=maxRotatedFiles)
     self.path = self.logfile.path

 def __init__(self, logfilename):
     if logfilename is None:
         logFile = sys.stdout
     else:
         logFile = LogFile.fromFullPath(logfilename, rotateLength=None)
         # Override if signal is set to None or SIG_DFL (0)
         if not signal.getsignal(signal.SIGUSR1):
             def signalHandler(signal, frame):
                 from twisted.internet import reactor
                 reactor.callFromThread(logFile.reopen)
             signal.signal(signal.SIGUSR1, signalHandler)
     self.observer = log.FileLogObserver(logFile)

def setup_logging():
    filename = LOG_SETTINGS['file_path']
    log_file = LogFile.fromFullPath(
        filename,
        rotateLength=LOG_SETTINGS['max_bytes'],
        maxRotatedFiles=LOG_SETTINGS['max_backups']
    ) if filename is not None else sys.stdout

    log_level = getattr(logging, LOG_SETTINGS['level'])

    observer = LevelFileLogObserver(log_file, log_level)
    observer.timeFormat = LOG_SETTINGS['time_format']
    observer.start()

 def opt_logfile(self, logfile_path):
     """
     Log to a file. Log is written to ``stdout`` by default. The logfile
     directory is created if it does not already exist.
     """
     logfile = FilePath(logfile_path)
     logfile_directory = logfile.parent()
     if not logfile_directory.exists():
         logfile_directory.makedirs()
     self['logfile'] = LogFile.fromFullPath(
         logfile.path,
         rotateLength=LOGFILE_LENGTH,
         maxRotatedFiles=LOGFILE_COUNT,
     )

    def setServiceParent(self, app):
        MultiService.setServiceParent(self, app)

        if config.ErrorLogEnabled:
            errorLogFile = LogFile.fromFullPath(
                config.ErrorLogFile,
                rotateLength=config.ErrorLogRotateMB * 1024 * 1024,
                maxRotatedFiles=config.ErrorLogMaxRotatedFiles
            )
            errorLogObserver = FileLogObserver(errorLogFile).emit

            # Registering ILogObserver with the Application object
            # gets our observer picked up within AppLogger.start( )
            app.setComponent(ILogObserver, errorLogObserver)

 def msg(self, content=""):
     head = "=="*10+"START"+"=="*10
     tail = "=="*10+"=END="+"=="*10
     LogFile.write(self, "\n%d:%s\n" % (self.Counter, head))
     for line in content.split('\n'):
         if line != "":
             LogFile.write(self, "%d:%s\n" % (self.Counter, line))
     LogFile.write(self, "%d:%s\n" % (self.Counter, tail))
     self.Counter += 1

 def emmit(self, event):
     if event.get("isDebug", False) and is_production():
         return  # Don't log debug messages in production.
     location, prefix, log_time, log_time_str, entry_text = self.parse_from(event)
     folder, name = build_file(self.folder, location, self.extension)
     try:
         log = LogFile(name, folder)
         log.write("%s %s\n\t%s\n" % (prefix, log_time_str, entry_text.replace("\n", "\n\t\t")))
         log.flush()
         log.close()
     finally:
         if event.get("transmit", False) and not event.get("isDebug", False):
             self.service.write_entry(location, log_time, entry_text)

def makeService(config):

    # install simple, blocking DNS resolver.
    from twisted.internet import reactor
    from twisted.internet.base import BlockingResolver
    reactor.installResolver(BlockingResolver())

    try:
        # Create dbus mainloop
        import dbus.mainloop.glib
        dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
    except ImportError:
        warnings.warn('Failed to import the dbus module, some functionality might not work.')

    # Check if it is the right thing
    if not hasattr(config.module, 'Application'):
        raise usage.UsageError("Invalid application module: " + config.appName)

    # Instantiate the main application
    s = config.module.Application(config.appName, config.opts, config.appOpts)

    # Set quitflag
    s.quitFlag = launcher.QuitFlag(s.path("temp").child("quitflag"))

    # Set the name
    s.setName(config.appName)

    # make sure the relevant paths exist
    for kind in ["temp", "db"]:
        path = s.path(kind)
        if not path.exists():
            path.createDirectory()

    # Set up logging
    logFile = s.path("logfile")
    if not logFile.parent().exists():
        logFile.parent().createDirectory()
    filename = s.path("logfile").path

    if config.opts['no-logrotate']:
        observer = RotatableFileLogObserver(filename)
    else:
        logFile = LogFile.fromFullPath(filename, maxRotatedFiles=9)
        observer = log.FileLogObserver(logFile).emit
    log.addObserver(observer)

    return s

 def postOptions(self):
     if self["journald"]:
         destination = JournaldDestination()
     else:
         if self["logfile"] is None:
             logfile = self._sys_module.stdout
         else:
             logfilepath = FilePath(self["logfile"])
             logfilepath_directory = logfilepath.parent()
             if not logfilepath_directory.exists():
                 logfilepath_directory.makedirs()
             # A twisted.python.logfile which has write and flush methods
             # but which also rotates the log file.
             logfile = LogFile.fromFullPath(
                 logfilepath.path, rotateLength=LOGFILE_LENGTH, maxRotatedFiles=LOGFILE_COUNT
             )
         destination = FileDestination(file=logfile)
     self.eliot_destination = destination
     original_postOptions(self)

    def receive_logs(self, logs, transport):
        client_mac = self.__stations[transport.client].mac;
        client_mac = client_mac.translate(None, ":|/\\")
        files = {}
        for time, location, msg in logs:
            if location in files:
                log_file = files[location]
            else:
                loc = [client_mac] + list(location)
                folder, name = build_file(self.__output_folder, loc, self.__extension)
                log_file = LogFile(name, folder)
                files[location] = log_file
            log_time_str = strftime("%Y-%m-%d %H:%M:%S:%f", gmtime(time))
            log_file.write(">%s\n\t%s\n" % (log_time_str, msg.replace("\n", "\n\t\t")))

        # Now close those files
        for log_file in files.itervalues():
            log_file.flush()
            log_file.close()
        return {"accepted": True}

 def initialize_twisted_logging(self):
     twenty_megabytes = 20000000
     log_file = LogFile.fromFullPath(self.configuration['log_filename'],
                                     maxRotatedFiles=10,
                                     rotateLength=twenty_megabytes)
     log.startLogging(log_file)