NullServer

Complexity

Total Complexity

17

Size/Duplication

Total Lines	77
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	load()	0	16	4
B	__init__()	0	23	5
B	stop()	0	15	5
A	start()	0	11	3

# -*- coding: utf-8 -*-
"""Plumd main entry point."""
import sys
import time
import random

import plumd
from plumd.load import PluginRegistry
import plumd.server

PY3 = sys.version_info > (3,)

__author__ = 'Kenny Freeman'
__email__ = 'kenny.freeman@gmail.com'
__license__ = "ISCL"
__docformat__ = 'reStructuredText'


class NullServer(plumd.server.Server):
    """A 'null' server that simply spawns Reader/Writer threads."""

    defaults = {
        'thread.daemon': True,
        'shutdown.timeout': 5,
        'delay.startup': 5
    }

    def __init__(self, log, config):
        """Create and return a ready to use NullServer instance.

        :param log: A logger.
        :type log: logging.Logger
        :param config: A config object.
        :type config: plumd.config.Conf
        """
        super(NullServer, self).__init__(log, config)
        self.config.defaults(NullServer.defaults)
        self.registry = PluginRegistry(log, config)
        # maintain a mapping of reader/writer threads => reader/writer plugins
        self.readers = dict()
        self.writers = dict()
        if self.registry.nplugins < 1:
            raise plumd.ConfigError("no plugins loaded")
        elif self.registry.nreaders < 1:
            raise plumd.ConfigError("no reader plugins loaded")
        elif self.registry.nrenders < 1:
            raise plumd.ConfigError("no render plugins loaded")
        elif self.registry.nwriters < 1:
            raise plumd.ConfigError("no writer plugins loaded")
        self.load()

    def load(self):
        """Create and initialize the Reader/Writer plugin threads."""
        # create writer threads, set their render source
        for pname, writer in self.registry.get_writers():
            wthread = plumd.WriterThread(self.log, self.config, writer)
            rname = writer.config.get('render', exception=True)
            render = self.registry.get_render(rname)
            wthread.register(render)
            self.writers[pname] = wthread
        # create reader threads, set their render output(s)
        for pname, reader in self.registry.get_readers():
            rthread = plumd.ReaderThread(self.log, self.config, reader)
            for rname in reader.config.get("render", exception=True):
                render = self.registry.get_render(rname)
                rthread.register(render)
            self.readers[pname] = rthread

    def start(self):
        """Start the Reader/Writer plugin threads."""
        # no stampeding herds on restart
        time.sleep(random.randrange(int(self.config.get('delay.startup'))))

        # start writer plugins first
        for writer in self.writers.values():
            writer.start()
        # start reader plugins
        for reader in self.readers.values():
            reader.start()

    def stop(self):
        """Stop the Reader/Writer plugin threads."""
        # first stop readers
        for reader in self.readers.values():
            reader.stop()
        # ensure they've all stopped
        for reader in self.readers.values():
            reader.join(timeout=self.config.get('shutdown.timeout'))

        # stop writers last
        for writer in self.writers.values():
            writer.stop()
        # ensure they've all stopped
        for writer in self.writers.values():
            writer.join(timeout=self.config.get('shutdown.timeout'))