def __init__(self, addr, sock=None): EventGen.__init__(self) self.addr = addr self.buf = bytearray() self._readypromise = Promise() self._closed = False self._writing = False self.sock = sock try: if not self.sock: self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) except IOError as e: if e.errno == errno.EMFILE: later(0.1, self._close, 'Too many open files - not opening socket.') else: logging.critical('IOError when creating socket: {0}'.format(errno.errorcode[e.errno])) later(0.1, self._close, 'IOError, {0}.'.format(e)) except Exception as e: logging.critical('Exception when creating socket: {0}'.format(e)) later(0.1, self._close, 'Exception, {0}.'.format(e)) else: self.sock.setblocking(False) #self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) self.write_watcher = pyev.Io(self.sock, pyev.EV_WRITE, default_loop, self._writable) self.read_watcher = pyev.Io(self.sock, pyev.EV_READ, default_loop, self._readable) self.initiate()
def __init__(self, loop, sock, read_cb, close_cb, max_size=1024 * 512): """Creates a socket transport that will perform the given functions whenever the socket is readable or has an error. Writting to the transport by default simply calls the send() function and checks for errors. If the error happens to be that the socket is unavailable (its buffer is full) the write is buffered until the max_size limit is reached writting out of the buffer whenever the socket is writtable. loop -- pyev loop sock -- python socket object read_cb -- read function (callback when the socket is read) close_cb -- closed function (callback when the socket has been closed) max_size -- maximum user space buffer """ self.loop = loop self.sock = sock self.read_cb = read_cb self.close_cb = close_cb self.max_size = max_size self.sock.setblocking(False) self.read_watcher = pyev.Io(self.sock, pyev.EV_READ, self.loop, self._readable) self.write_watcher = pyev.Io(self.sock, pyev.EV_WRITE, self.loop, self._writtable) self.write_buffer = bytearray() self.closed = False self.write = self.unbuffered_write
def __init__(self, start_server_ip="127.0.0.1", start_server_port=5000, num_server_workers=1): self.start_server_ip = start_server_ip self.start_server_port = start_server_port self.num_server_workers = num_server_workers self.listen_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.listen_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.listen_sock.bind((start_server_ip,start_server_port)) self.listen_sock.setblocking(0) self.listen_sock.settimeout(1) self.address = self.listen_sock.getsockname() self.worker_procs = [] self.worker_queues = [] for i in range(num_server_workers): # Create a pair of (inQ,outQ) for IPC with the worker worker_in_q = multiprocessing.Queue() worker_out_q = multiprocessing.Queue() self.worker_queues.append((worker_in_q,worker_out_q)) # Create the worker process object worker_proc = ServerWorker("SW."+str(i+1), worker_in_q, worker_out_q, ) worker_proc.daemon = True self.worker_procs.append(worker_proc) # Start the worker process worker_proc.start() # By now the server workers have been spawned # Setup the default Pyev loop in the master self.loop = pyev.default_loop(flags=pyev.recommended_backends()) # Prepare signal , out Q and connection watchers self.sig_watchers = [pyev.Signal(sig, self.loop, self.signal_cb) for sig in STOPSIGNALS] self.q_watchers = [pyev.Io(fd=worker.out_q._reader.fileno(), events=pyev.EV_READ, loop=self.loop, callback=self.out_q_cb, data=worker) for worker in self.worker_procs] self.socket_watchers = [pyev.Io(fd=self.listen_sock.fileno(), events=pyev.EV_READ, loop=self.loop, callback=self.io_cb)] self.next_worker = 0
def register(self, fd, event, handler, handler_args=()): """ event is one of ['r', 'w'] """ watcher = self._watchers.get(fd) if not watcher: if event == 'r': data = [(handler, handler_args, ), None] _event = self._in else: # w data = [None, (handler, handler_args, )] _event = self._out watcher = pyev.Io(fd, _event, self._loop, callback=self._callback, data=data, priority=100) self._watchers[fd] = watcher watcher.start() else: # one call to register can be significant overhead data = watcher.data if event == 'r': data[0] = (handler, handler_args, ) if data[1]: watcher.set(fd, self._in | self._out) else: # w data[1] = (handler, handler_args, ) if data[0]: watcher.set(fd, self._in | self._out) return True
def __init__( self, sock, remote_address, loop, cnxn_id, parent, ): self.sock = sock self.remote_address = remote_address self.loop = loop self.cnxn_id = cnxn_id self.parent = parent self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.setblocking(0) self.sock.settimeout(0.5) self.sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack('ii', 1, 0)) self.buf = '' self.watcher = pyev.Io(self.sock.fileno(), pyev.EV_READ, self.loop, self.io_cb) self.watcher.start() logging.debug('[{0}:{1}] Connection ready with [{2}]'.format(self.parent.name, self.cnxn_id, self.remote_address))
def connect(self): ''' Connect and set the app layer timeout ''' self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setblocking(0) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) logging.debug('EphemeralConnection : connecting to %s:%d' % (self.address[0], self.address[1])) res = self.sock.connect_ex(self.address) if res != errno.EINPROGRESS: logging.error( 'EphemeralConnection : unable to connect to %s:%d res=%d' % (self.address[0], self.address[1], res)) self.state = EphemeralConnection.STATE_ERROR self.handle_error('unable to connect') else: if not self.connect_cb: self.connect_cb = self.io_cb self.state = EphemeralConnection.STATE_CONNECTING self.watcher = pyev.Io(self.sock, pyev.EV_WRITE, self.loop, self.connect_cb) self.watcher.start() # start the application layer time out self.conn_timer = pyev.Timer(2, 0.0, self.loop, self.too_long_conn, self) self.conn_timer.start() return self.state
def __init__(self, sock, address, loop): self.sock = sock self.address = address self.sock.setblocking(0) self.buf = "" self.watcher = pyev.Io(self.sock._sock, pyev.EV_READ, loop, self.io_cb) self.watcher.start()
def __init__(self, sock, address, serverapp): self.serverapp = serverapp self.sock = sock self.sock.setblocking(0) # Tuple of (socket family, socket type, socket protocol, ssl) self.descr = ( _socket_families_map.get(self.sock.family, self.sock.family), _socket_type_map.get(self.sock.type, self.sock.type), _socket_proto_map.get(self.sock.proto, self.sock.proto), None #TODO: SSL goes here ... ) self.address = address self.connected_at = time.time() self.read_buf = "" self.write_buf = None self.yield_enabled = False self.return_expected = False # This is synchronization element used in asserts preventing IPC goes out of sync self.tailf_enabled = False self.watcher = pyev.Io(self.sock._sock, pyev.EV_READ, serverapp.loop, self.io_cb) self.watcher.start() L.debug("Console connection open ({0})".format(self.address))
def __init__(self, sock, address, loop): self.sock = sock self.address = address self.sock.setblocking(0) self.buf = "" self.watcher = pyev.Io(self.sock._sock, pyev.EV_READ, loop, self.io_cb) self.watcher.start() logging.debug("{0}: ready".format(self))
def __init__(self, sock, loop, address): self.sock = sock self.watcher = pyev.Io(self.sock, pyev.EV_READ, loop, self.io_cb) self.watcher.start() self.address = address self.state = Connection.STATE_CONNECTED self.loop = loop self.read_buf = '' self.write_buf = '' self.id = Connection._id Connection._id += 1 logging.debug("Connection.__init__ id=%d" % self.id)
def __init__(self, address): self.sock = socket.socket() self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind(address) self.sock.setblocking(0) self.address = self.sock.getsockname() self.loop = pyev.default_loop() self.watchers = [pyev.Signal(sig, self.loop, self.signal_cb) for sig in STOPSIGNALS] self.watchers.append(pyev.Io(self.sock._sock, pyev.EV_READ, self.loop, self.io_cb)) self.conns = weakref.WeakValueDictionary()
def server_run(sock, service, handler): """运行thrift server""" thread_info = ThreadInfo(sock, service, handler) main_loop = pyev.Loop(0, data=thread_info) io_watcher = pyev.Io(sock, pyev.EV_READ, main_loop, on_request) io_watcher.start() stop_watcher = pyev.Signal(signal.SIGINT, main_loop, on_stop, priority=5) stop_watcher.start() main_loop.start()
def __init__(self, mountdir, cli): FUSELL.__init__(self, mountdir) print 'bufsize chan', self.libfuse.fuse_chan_bufsize(self.chan) self.mountdir = mountdir self.c = cli self._closed = False fd = self._chanfd() fcntl.fcntl(fd, fcntl.F_SETFL, fcntl.fcntl(fd, fcntl.F_GETFL) | os.O_NONBLOCK) self.read_watcher = pyev.Io(fd, pyev.EV_READ, default_loop, self._readable) self.read_watcher.start()
def __init__(self, loop, sock, addr, timeout): self.loop = loop self.sock = sock self.addr = addr self.timeout = timeout self.connect_watcher = pyev.Io(self.sock, pyev.EV_WRITE, self.loop, self._connected) self.timeout_watcher = pyev.Timer(self.timeout, 0.0, self.loop, self._timeout) self.deferred = Deferred(self.loop) self.started = False self.connected = False self.timedout = False self.errored = False
def __init__(self, sock, address, ssl_config, loop, server): """Initialize the client socket. :param sock: A socket object returned from server's accept() call. :param address: Client's address as returned by server's accept() call. :param ssl_config: A dictionary containing keyword arguments for ssl.wrap_socket(). An empty dictionary will disable SSL. :param loop: A pyev.Loop object that will handle signals and I/O. :param server: The Server instance which created this client instance. :raises: ssl.SSLError when failing to SSL wrap the socket """ self._sock = sock self._address = address self._server = server self._sock.setblocking(0) if ssl_config: try: self._sock = ssl.wrap_socket(self._sock, **ssl_config) except ssl.SSLError: logger.exception("refused {0}: SSL socket wrap error ".format( self._address)) self._sock.close() raise else: self._sock.setblocking(0) self._read_watcher = pyev.Io(self._sock, pyev.EV_READ, loop, self._read_handler) self._write_watcher = pyev.Io(self._sock, pyev.EV_WRITE, loop, self._write_handler) self._timeout_watcher = pyev.Timer(server.timeout, server.timeout, loop, self._timeout_handler) self._read_watcher.start() self._timeout_watcher.reset()
def __init__(self, bind_host, handler): register.handler = handler self.bind_host = bind_host self.connections = {} self.loop = pyev.default_loop() self.watchers = [ pyev.Signal(sig, self.loop, self.signal_cb) for sig in STOPSIGNALS ] # create the socket and bind self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind(bind_host) self.sock.setblocking(0) # create the watcher that listens for new connections self.listen_watcher = pyev.Io(self.sock, pyev.EV_READ, self.loop, self.io_cb)
def __init__(self,name,in_q,out_q): multiprocessing.Process.__init__(self,group=None,name=name) self.in_q = in_q self.out_q = out_q self.loop = pyev.Loop(flags=pyev.recommended_backends()) self.watchers = [] self.client_count = 0 self.in_q_fd = self.in_q._reader.fileno() self.watchers.append(pyev.Io(self.in_q_fd, pyev.EV_READ, self.loop, self.in_q_cb)) self.cnxns = {} logging.debug("ServerWorker[{0}:{1}]: Instantiated.".format(os.getpid(),self.name))
def __init__(self, loop=MainLoop(), *args, **kw): """Initialize a X connection.""" super(Connection, self).__init__(*args, **kw) # Initialize IO watcher self._io = pyev.Io(self.get_file_descriptor(), pyev.EV_READ, loop, self._on_io) self._io.start() # Initialize Prepare watcher self._prepare = pyev.Prepare(loop, self._prepare) self._prepare.start() # Store loop self.loop = loop
def __init__(self, sock, remote_address, loop, cnxn_id, parent): self.sock = sock self.remote_address = remote_address self.loop = loop self.cnxn_id = cnxn_id self.parent = parent self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.setblocking(0) self.sock.settimeout(0.5) self.buf = "" self.watcher = pyev.Io(self.sock.fileno(), pyev.EV_READ, self.loop, self.io_cb) self.watcher.start() logging.debug("[{0}:{1}] Connection ready with [{2}]".format(self.parent.name,self.cnxn_id,self.remote_address))
def on_request(watcher, revents): thread_data = watcher.loop.data sock = thread_data.sock try: client_socket, address = sock.accept() logging.info("accept address: {}".format(address)) except socket.error as err: logging.error('error accepting a connection: {}'.format(err)) else: client_socket.setblocking(False) request = Request(client_socket, thread_data.service, thread_data.handler, address) request.io_watcher = pyev.Io(client_socket, pyev.EV_READ, watcher.loop, on_read, data=request) request.io_watcher.start() all_requests[address] = request
def _prepare(self): """Initialize server components which ``stop()`` may render invalid. :raises: socket.error on failure to create, or bind on socket. """ self._sock = socket.socket() self._sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self._sock.setblocking(0) self._sock.bind(self._address) self._watchers = [ pyev.Signal(sig, self._loop, self._signal_handler) for sig in self._HANDLED_SIGNALS ] self._watchers.append( pyev.Io(self._sock, pyev.EV_READ, self._loop, self._socket_handler)) self._worker_thread = self._thread_factory(self._tasks, self._shutdown_event, self._hup_event)
def __init__(self, loop, factory, sock, address): """Socket server listens on a given socket for incoming connections. When a new connection is available it accepts it and creates a new Connection and Protocol to handle reading and writting data. loop -- pyev loop factory -- protocol factory (object with build(loop) method that returns a protocol object) sock -- socket to listen on """ self.loop = loop self.factory = factory self.sock = sock self.address = address self.connections = set() self._closing = False self._shutdown = False self.interrupt_watcher = pyev.Signal(signal.SIGINT, self.loop, self._interrupt) self.interrupt_watcher.start() self.read_watcher = pyev.Io(self.sock, pyev.EV_READ, self.loop, self._readable)
def connect(self): self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setblocking(0) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) logging.info('connecting to %s:%d' % (self.address[0], self.address[1])) res = self.sock.connect_ex(self.address) if res != errno.EINPROGRESS: logging.error('unable to connect to %s:%d' % (self.address[0], self.address[1])) self.state = Connection.STATE_ERROR else: if not self.connect_cb: self.connect_cb = self.io_cb self.state = Connection.STATE_CONNECTING self.watcher = pyev.Io(self.sock, pyev.EV_WRITE, self.loop, self.connect_cb) self.watcher.start() # start the timer self.timer = pyev.Timer(1, 1, self.loop, self.set_qps) self.timer.start() return self.state
if sys.platform == 'win32': # There is no pyev.Child watcher on Windows; periodic check is used instead self.watchers.append( pyev.Periodic(0, 0.5, self.loop, self.__check_childs_cb)) else: self.watchers.append( pyev.Child(0, False, self.loop, self.__child_signal_cb)) for sock in self.cnssockets: sock.setblocking(0) # Watcher data are used (instead logical watcher.fd due to Win32 mismatch) self.watchers.append( pyev.Io(sock._sock, pyev.EV_READ, self.loop, self.__accept_cb, data=sock._sock.fileno())) self.conns = weakref.WeakSet() self.termstatus = None self.termstatus_change = None # Prepare also exit watcher - can be used to 'simulate' terminal signal (useful on Win32) self.exitwatcher = pyev.Async(self.loop, self.__terminal_signal_cb) self.exitwatcher.start() program_roaster.__init__(self) idlework_appmixin.__init__(self) # Build notificator component
def init_io_stderr(self): self.watchers["io"]["stderr"] = pyev.Io(self.process.stderr, pyev.EV_READ, self.loop, self.io_stderr_cb)
def init_io_stdout(self): self.watchers["io"]["stdout"] = pyev.Io(self.process.stdout, pyev.EV_READ, self.loop, self.io_stdout_cb)
class httpfend_app(object): STOPSIGNALS = [signal.SIGINT, signal.SIGTERM] NONBLOCKING = frozenset([errno.EAGAIN, errno.EWOULDBLOCK]) # Maximum number of worker threads serving the client requests MAX_WORKER_THREADS = 10 def __init__(self): # Read config read_config() # Configure logging try: loglvl = get_numeric_loglevel( config.get(os.environ['RAMONA_SECTION'], 'loglevel')) except: loglvl = logging.INFO logging.basicConfig( level=loglvl, stream=sys.stderr, format="%(asctime)s %(levelname)s: %(message)s", ) try: self.listenaddr = config.get(os.environ['RAMONA_SECTION'], 'listen') except (ConfigParser.NoSectionError, ConfigParser.NoOptionError): self.listenaddr = config_defaults['ramona:httpfend']['listenaddr'] self.username = None self.password = None try: self.username = config.get(os.environ['RAMONA_SECTION'], 'username') self.password = config.get(os.environ['RAMONA_SECTION'], 'password') except: pass if self.username is not None and self.password is None: L.fatal( "Configuration error: 'username' option is set, but 'password' option is not set. Please set 'password'" ) sys.exit(1) self.logmsgcnt = itertools.count() self.logmsgs = dict() self.workers = collections.deque() self.dyingws = collections.deque() # Dying workers self.svrsockets = [] for addr in self.listenaddr.split(','): socket_factory = socketuri.socket_uri(addr) try: socks = socket_factory.create_socket_listen() except socket.error, e: L.fatal( "It looks like that server is already running: {0}".format( e)) sys.exit(1) self.svrsockets.extend(socks) if len(self.svrsockets) == 0: L.fatal( "There is no http server listen address configured - considering this as fatal error" ) sys.exit(1) self.loop = pyev.default_loop() self.watchers = [ pyev.Signal(sig, self.loop, self.__terminal_signal_cb) for sig in self.STOPSIGNALS ] self.dyingwas = pyev.Async( self.loop, self.__wdied_cb) # Dying workers async. signaling self.watchers.append(self.dyingwas) for sock in self.svrsockets: sock.setblocking(0) self.watchers.append( pyev.Io(sock._sock, pyev.EV_READ, self.loop, self.__on_accept, data=sock._sock.fileno()))
def __init__(self, svrapp, config_section): _, self.ident = config_section.split(':', 2) self.state = program_state_enum.STOPPED self.subproc = None self.launch_cnt = 0 self.autorestart_cnt = 0 self.start_time = None self.stop_time = None self.exit_time = None self.exit_status = None self.coredump_enabled = None # If true, kill by SIGQUIT -> dump core if sys.platform != 'win32': # On Windows we are using periodic pipe check in win32_read_stdfd self.watchers = [ pyev.Io(0, 0, svrapp.loop, self.__read_stdfd, 0), pyev.Io(0, 0, svrapp.loop, self.__read_stdfd, 1), ] # Build configuration self.config = self.DEFAULTS.copy() self.config.update(config.items(config_section)) # Prepare program command line cmd = self.config.get('command') if cmd is None: L.error("Missing command option in {0} -> CFGERROR".format(config_section)) self.state = program_state_enum.CFGERROR return if cmd == '<httpfend>': cmd = get_python_exec(cmdline=["-u","-m","ramona.httpfend"]) elif cmd[:1] == '<': L.error("Unknown command option '{1}' in {0} -> CFGERROR".format(config_section, cmd)) self.state = program_state_enum.CFGERROR return cmd = cmd.replace('\\', '\\\\') self.cmdline = shlex.split(cmd) # Prepare stop signals if sys.platform != 'win32': self.stopsignals = parse_signals(self.config['killby']) if len(self.stopsignals) == 0: self.stopsignals = [signal.SIGTERM] self.act_stopsignals = None if self.config['stdin'] != '<null>': L.error("Unknown stdin option '{0}' in {1} -> CFGERROR".format(self.config['stdin'], config_section)) self.state = program_state_enum.CFGERROR return try: self.priority = int(self.config.get('priority')) except: L.error("Invalid priority option '{0}' in {1} -> CFGERROR".format(self.config['priority'], config_section)) self.state = program_state_enum.CFGERROR return try: dis = get_boolean(self.config.get('disabled')) except ValueError: L.error("Unknown/invalid 'disabled' option '{0}' in {1} -> CFGERROR".format(self.config.get('disabled'), config_section)) self.state = program_state_enum.CFGERROR return if dis: self.state = program_state_enum.DISABLED self.ulimits = {} #TODO: Enable other ulimits.. try: coredump = get_boolean(self.config.get('coredump',False)) except ValueError: L.error("Unknown 'coredump' option '{0}' in {1} -> CFGERROR".format(self.config.get('coredump','?'), config_section)) self.state = program_state_enum.CFGERROR return if coredump and resource is not None: self.ulimits[resource.RLIMIT_CORE] = (-1,-1) try: self.autorestart = get_boolean(self.config.get('autorestart',False)) except ValueError: L.error("Unknown 'autorestart' option '{0}' in {1} -> CFGERROR".format(self.config.get('autorestart','?'), config_section)) self.state = program_state_enum.CFGERROR return try: get_boolean(self.config.get('processgroup',True)) except ValueError: L.error("Unknown 'processgroup' option '{0}' in {1} -> CFGERROR".format(self.config.get('processgroup','?'), config_section)) self.state = program_state_enum.CFGERROR return umask = self.config.get('umask') if umask is not None: try: umask = int(umask, 8) except: L.error("Invalid umask option ({1}) in {0} -> CFGERROR".format(config_section, umask)) self.state = program_state_enum.CFGERROR return self.config['umask'] = umask # Prepare log files stdout_cnf = self.config['stdout'] stderr_cnf = self.config['stderr'] if (stdout_cnf == '<stderr>') and (stderr_cnf == '<stdout>'): L.error("Invalid stdout and stderr combination in {0} -> CFGERROR".format(config_section)) self.state = program_state_enum.CFGERROR return # Stdout settings if stdout_cnf == '<logdir>': if stderr_cnf in ('<stdout>','<null>') : fname = os.path.join(config.get('general','logdir'), self.ident + '.log') else: fname = os.path.join(config.get('general','logdir'), self.ident + '-out.log') self.log_out = log_mediator(self.ident, 'stdout', fname) elif stdout_cnf == '<stderr>': pass elif stdout_cnf == '<null>': self.log_out = log_mediator(self.ident, 'stdout', None) elif stdout_cnf[:1] == '<': L.error("Unknown stdout option in {0} -> CFGERROR".format(config_section)) self.state = program_state_enum.CFGERROR return else: self.log_out = log_mediator(self.ident, 'stdout', stdout_cnf) # Stderr settings if stderr_cnf == '<logdir>': if stdout_cnf in ('<stderr>','<null>') : fname = os.path.join(config.get('general','logdir'), self.ident + '.log') else: fname = os.path.join(config.get('general','logdir'), self.ident + '-err.log') self.log_err = log_mediator(self.ident, 'stderr', fname) elif stderr_cnf == '<stdout>': self.log_err = self.log_out elif stderr_cnf == '<null>': self.log_err = log_mediator(self.ident, 'stderr', None) elif stderr_cnf[:1] == '<': L.error("Unknown stderr option in {0} -> CFGERROR".format(config_section)) self.state = program_state_enum.CFGERROR return else: self.log_err = log_mediator(self.ident, 'stderr', stderr_cnf) if stdout_cnf == '<stderr>': self.log_out = self.log_err # Log scans for stream, logmed in [('stdout', self.log_out),('stderr', self.log_err)]: logscanval = self.config.get('logscan_{0}'.format(stream)).strip() if len(logscanval) == 0: logscanval = config.get('ramona:notify','logscan_{}'.format(stream)) if len(logscanval) == 0: logscanval = config.get('ramona:notify','logscan'.format(stream)) for logscanseg in logscanval.split(','): logscanseg = logscanseg.strip() if logscanseg == '': continue try: pattern, target = logscanseg.split('>',1) except ValueError: L.error("Unknown 'logscan_{2}' option '{0}' in {1} -> CFGERROR".format(logscanseg, config_section, stream)) self.state = program_state_enum.CFGERROR return if not validate_notify_target(target): L.error("Unknown 'logscan_{2}' option '{0}' in {1} -> CFGERROR".format(target, config_section, stream)) self.state = program_state_enum.CFGERROR return logmed.add_scanner(pattern, target) # Environment variables alt_env = self.config.get('env') self.env = get_env(alt_env) self.env['RAMONA_SECTION'] = config_section # Notification on state change to FATAL self.notify_fatal_target = self.config.get('notify_fatal', '<global>') if self.notify_fatal_target == '<global>': self.notify_fatal_target = config.get('ramona:notify','notify_fatal', 'now') if self.notify_fatal_target == '<none>': self.notify_fatal_target = None if (self.notify_fatal_target is not None) and not validate_notify_target(self.notify_fatal_target): L.warning("Invalid notify_fatal target: '{}'".format(self.notify_fatal_target)) self.notify_fatal_target = None
def __init__(self, sock): EventGen.__init__(self) self.sock = sock self.sock.setblocking(False) self.read_watcher = pyev.Io(self.sock, pyev.EV_READ, default_loop, self._readable) self.read_watcher.start()