def __init__(
        self,
        name="",
        host=None,
        port=None,
        usethread=False,
        logger=None,
        stdout=None,
        ev_quit=None,
        authDict=None,
        secure=ro.default_secure,
        cert_file=ro.default_cert,
        threadPool=None,
    ):

        # Logger for logging debug/error messages
        if not logger:
            self.logger = ro.nullLogger()
        else:
            self.logger = logger

        try:
            if stdout:
                self.logger.info("Using '%s' for default output" % stdout)
                self.stdout = open(stdout, "a")
            else:
                # self.stdout = open("/dev/null", "a")
                self.logger.info("Using STDOUT for default output")
                self.stdout = sys.stdout

        except IOError, e:
            self.logger.info("Using /dev/null for default output")
            self.stdout = open("/dev/null", "a")
    def __init__(
        self,
        name,
        start_cmd,
        stop_cmd=None,
        logger=None,
        stdout=None,
        stderr=None,
        autorestart=False,
        restart_threshold=10,
        restart_interval=1.0,
    ):
        self.name = name
        self.start_cmd = start_cmd
        self.stop_cmd = stop_cmd
        self.proc = None
        self.timestart = time.time()
        self.timecheck = self.timestart
        self.startcount = 0
        self.stopcount = 0
        self.autorestart = autorestart
        self.restart_threshold = restart_threshold
        self.restart_interval_init = restart_interval
        self.restart_interval = restart_interval
        self.lock = threading.RLock()
        # Seconds to wait after sending SIGTERM before trying SIGKILL
        self.killwait = 2.0

        # If no logger is passed in, create a simple one to stderr
        if not logger:
            self.logger = ro.nullLogger()
        else:
            self.logger = logger

        # Stdout/stderr messages
        if stdout:
            self.stdout = stdout
        else:
            # self.stdout = open("/dev/null", "w")
            self.stdout = sys.stdout
        if stderr:
            self.stderr = stderr
        else:
            # self.stderr = open("/dev/null", "w")
            self.stderr = sys.stderr
Beispiel #3
0
    def __init__(self, name, logger, dbpath=None, useSync=False,
                 ev_quit=None, threadPool=None, numthreads=20):

        self._store = NestedBunch.NestedBunch(dbpath=dbpath)
        self.defaultChannels = [name]

        self.lock = threading.RLock()

        # TEMP: to get around an infinite recursion issue for monitor
        # logging
        logger = ro.nullLogger()

        # Superclass initialization
        super(Monitor, self).__init__(name, logger,
#                                      ev_quit=None, threadPool=None,
                                      ev_quit=ev_quit, threadPool=threadPool,
                                      numthreads=numthreads)
            
        # number of seconds after which a delivery to a subscriber is
        # considered "late"
        self.update_limit = 10.0