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()
