def init_service(klass_name, options):
create_logger(options)
if options.signal_debug:
import pyev
pyev.default_loop(pyev.EVFLAG_NOSIGMASK)
service_klass = load_service_klass(klass_name)
return service_klass(options)
def serve(address="0.0.0.0",port=24414):
global config, conn_sock, ifname, tunfd
name, public_key, secret_key = load_identity()
if name is not None:
print("Your identity is:")
print(name + " " + get_fingerprint(public_key))
print("Verify this fingerprint is valid when connecting")
else:
name, public_key, secret_key = new_key_interface()
config = configparser.RawConfigParser()
config.read("netshrink.cfg")
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
conn_sock = sock
sock.bind((address,port))
loop = pyev.default_loop()
io = pyev.Io(sock, pyev.EV_READ, loop, serve_cb)
io.start()
sigint = pyev.Signal(2, loop, sigint_cb)
sigint.start()
print("Starting tun interface...")
iface_name = config.get("netshrink", "iface_name").encode("utf8")
#start the tun interface
try:
tunfd = os.open("/dev/net/tun", os.O_RDWR)
ifname = ioctl(tunfd, TUNSETIFF,
struct.pack("16sH", iface_name, IFF_TUN))
except IOError:
print("You do not have permissions to create a tunnel interface.")
sys.exit(1)
ifname = ifname[:ifname.find(b'\0')]
tunio = pyev.Io(tunfd, pyev.EV_READ, loop, tun_cb)
tunio.start()
print("Listening for new connections")
loop.start()
def main():
path = "adder_service"
name = "adder"
loop = pyev.default_loop()
sigwatcher = pyev.Signal(
signal.SIGINT, loop,
lambda watcher, events: watcher.loop.stop(pyev.EVBREAK_ALL))
sigwatcher.start()
service = spawn(Adder, loop, name, path)
sproxy = ServiceProxy(loop, path)
sproxy.connect()
clients = []
proxies = []
# to push the server further (to see how fast it will really go...)
# just add more clients!
for x in range(30):
bpath = "adder_bench_%i" % x
client = spawn(AdderBench, loop, bpath, bpath, path)
bproxy = ServiceProxy(loop, "adder_bench_1")
bproxy.connect()
clients.append(client)
proxies.append(bproxy)
loop.start()
def __init__(
self,
parameters=None,
on_open_callback=None,
on_open_error_callback=None,
on_close_callback=None,
stop_ioloop_on_close=False,
custom_ioloop=None,
on_signal_callback=None,
):
"""Create a new instance of the LibevConnection class, connecting
to RabbitMQ automatically
:param pika.connection.Parameters parameters: Connection parameters
:param on_open_callback: The method to call when the connection is open
:type on_open_callback: method
:param on_open_error_callback: Method to call if the connection cannot
be opened
:type on_open_error_callback: method
:param bool stop_ioloop_on_close: Call ioloop.stop() if disconnected
:param custom_ioloop: Override using the default IOLoop in libev
:param on_signal_callback: Method to call if SIGINT or SIGTERM occur
:type on_signal_callback: method
"""
self.ioloop = custom_ioloop or pyev.default_loop()
self._on_signal_callback = on_signal_callback
self._io_watcher = None
self._active_timers = {}
self._stopped_timers = deque()
super(LibevConnection, self).__init__(
parameters, on_open_callback, on_open_error_callback, on_close_callback, self.ioloop, stop_ioloop_on_close
)
def __init__(self, start_server_ip="127.0.0.1", start_server_port=5000, num_server_workers=8):
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 main():
path = "adder_service"
name = "adder"
loop = pyev.default_loop()
sigwatcher = pyev.Signal(signal.SIGINT, loop, lambda watcher, events: watcher.loop.stop(pyev.EVBREAK_ALL))
sigwatcher.start()
service = spawn(Adder, loop, name, path)
sproxy = ServiceProxy(loop, path)
sproxy.connect()
clients = []
proxies = []
# to push the server further (to see how fast it will really go...)
# just add more clients!
for x in range(30):
bpath = "adder_bench_%i" % x
client = spawn(AdderBench, loop, bpath, bpath, path)
bproxy = ServiceProxy(loop, "adder_bench_1")
bproxy.connect()
clients.append(client)
proxies.append(bproxy)
loop.start()
def start(self):
try:
self.loop = pyev.default_loop(debug=self.options.get('debug',False))
sig_int = self.loop.signal(signal.SIGINT,self.sig_cb)
sig_int.start()
sig_term = self.loop.signal(signal.SIGTERM,self.sig_cb)
sig_term.start()
self.writer = ReportWriter(self.options.get('root_path'))
self.writer.start()
accounts = []
for a in self.options.get('accounts'):
accounts.append(a)
builder = ClientBuilder(accounts,self.options,self.addClient)
builder.start(self.loop)
self.loop.start()
finally:
if self.loop is not None:
self.loop.stop(pyev.EVBREAK_ALL)
self.loop = None
self.builder = None
self.sploop = None
self.statis = None
if self.writer is not None:
self.writer.stop()
self.writer = None
def __init__(self, address=("",8888), console=("",9876)):
# init proxy socket
self.sock = socket.socket()
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind(address)
self.sock.setblocking(0)
self.proxyaddress = self.sock.getsockname()
# init console socket
self.console = socket.socket()
self.console.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.console.bind(console)
self.console.setblocking(0)
self.consoleaddress = self.console.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.watchers.append(pyev.Io(self.console._sock, pyev.EV_READ, self.loop,
self.console_cb))
self.connection_count = 0
self.conns = {}
def __init__(self,
parameters=None,
on_open_callback=None,
on_open_error_callback=None,
on_close_callback=None,
stop_ioloop_on_close=False,
custom_ioloop=None,
on_signal_callback=None):
"""Create a new instance of the LibevConnection class, connecting
to RabbitMQ automatically
:param pika.connection.Parameters parameters: Connection parameters
:param on_open_callback: The method to call when the connection is open
:type on_open_callback: method
:param on_open_error_callback: Method to call if the connection cannot
be opened
:type on_open_error_callback: method
:param bool stop_ioloop_on_close: Call ioloop.stop() if disconnected
:param custom_ioloop: Override using the default IOLoop in libev
:param on_signal_callback: Method to call if SIGINT or SIGTERM occur
:type on_signal_callback: method
"""
self.ioloop = custom_ioloop or pyev.default_loop()
self._on_signal_callback = on_signal_callback
self._io_watcher = None
self._active_timers = {}
self._stopped_timers = deque()
super(LibevConnection,
self).__init__(parameters, on_open_callback,
on_open_error_callback, on_close_callback,
self.ioloop, stop_ioloop_on_close)
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 __init__(self,
start_client_ip="127.0.0.1",
start_client_port=10000,
end_client_port=60000,
num_cnxn_per_client=10,
num_cnxn_per_sec=1,
start_server_ip="127.0.0.1",
start_server_port=5000,
num_client_workers=1):
self.worker_procs = []
self.worker_queues = []
client_ip = start_client_ip
server_ip = start_server_ip
for i in range(num_client_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 = ClientWorker("CW."+str(i+1),
worker_in_q,
worker_out_q,
client_ip,
start_client_port,
end_client_port,
num_cnxn_per_client,
num_cnxn_per_sec,
server_ip,
start_server_port
)
worker_proc.daemon = True
self.worker_procs.append(worker_proc)
# Start the worker process
worker_proc.start()
# By now the client workers have been spawned
# Setup the default Pyev loop in the master
self.loop = pyev.default_loop(flags=pyev.EVBACKEND_EPOLL)
# Prepare signal and out Q 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]
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 __init__(self,address):
self.address = address
self.sock = socket.socket()
self.sock.bind(address)
self.sock.setblocking(0)
self.sock.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEPORT,1)
#self.address = self.sock.getsockname()
self.loop = pyev.default_loop()
self.watchers = [pyev.Signal(sig, self.loop, self.signal_cb)\
for sig in STOPSIGNAL]
self.watchers.append(pyev.Io(self.sock,pyev.EV_READ,self.loop, self.io_cb))
def serve(self, sock, nevents=None):
loop = pyev.default_loop()
self.clients = {}
main = pyev.Io(sock, pyev.EV_READ, loop, self.accept, data=sock)
main.start()
sigint = pyev.Signal(signal.SIGINT, loop, self.sigint, data=[main])
sigint.start()
loop.loop()
def __init__(self, dsp_endpoints, event_endpoint, balance_conn_timeout):
'''
Constructor
dsp_endpoints : is a list of tuples(endpoint, qps) where
enpoint is a string like '192.168.10.152:5869'
and qps is the value indicating queries per
second for that enpoint.
balance_conn_timeout : is the time period for rebalancing
available connections.
'''
# list containing tuples in the form
# (endpoint, expected qps, current qps)
self.dest_eps = [[ep[0], ep[1], 0] for ep in dsp_endpoints]
self.event_endpoint = event_endpoint
self.conns = {}
self.awaiting_conns = {}
self.event_conn_queue = []
self.event_conns = {}
self.event_connections = 0
self.keep_alive_resp_waiting = {}
self.balance_conn_to = balance_conn_timeout
self.loop = pyev.default_loop()
self.watchers = [
pyev.Signal(sig, self.loop, self.signal_cb) for sig in STOPSIGNALS
]
self.watchers.append(
pyev.Timer(self.balance_conn_to, self.balance_conn_to, self.loop,
self.balance))
self.watchers.append(
pyev.Timer(CHECK_CONNS_TO, CHECK_CONNS_TO, self.loop,
self.check_established_connections))
self.watchers.append(
pyev.Timer(CHECK_PENDING_TO, CHECK_PENDING_TO, self.loop,
self.check_pending_wins))
if EVENT_CONN_KEEP_ALIVE_TO:
self.watchers.append(
pyev.Timer(EVENT_CONN_KEEP_ALIVE_TO, EVENT_CONN_KEEP_ALIVE_TO,
self.loop, self.send_keep_alives))
self.current_connections = 0
self.request_fact = RTBRequestFactory(TEMPLATE_FILENAME)
self.adserver = AdServer(self.loop)
self.request_fact.initialize()
self.request_fact.set_parameter_plug(PARAMETER_PLUGIN, self.adserver)
if PLUGIN_DO_TO:
self.watchers.append(
pyev.Timer(PLUGIN_DO_TO, PLUGIN_DO_TO, self.loop,
self.request_fact.plugin_instance.do))
self.pending_wins = []
def __init__(self, logger=None):
#self._loop = pyev.default_loop(io_interval=timeout/1000.0, timeout_interval=timeout/1000.0)
#self._loop = pyev.default_loop(timeout_interval=timeout)
self._loop = pyev.default_loop()
self._timer = pyev.Timer(0.01, 0, self._loop, self._timer_callback)
self._timeout = 100
# print self._loop.backend, pyev.EVBACKEND_EPOLL
self._watchers = dict() # key is fd
self._empty = []
self.logger = logger
self._in = pyev.EV_READ
self._out = pyev.EV_WRITE
def __init__(self, hooks):
self.sequenceid = None
self._need_synch = False
self.indata = None
self.outdata = ''
self.hooks = hooks
loop = pyev.default_loop()
self.watcher = pyev.Io(self._file.fileno(), pyev.EV_READ, loop,
self.io, self)
self.watcher.start()
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 __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 main():
loop = pyev.default_loop()
signal_handler = whizzer.signal_handler(loop)
signal_handler.start()
factory = HTTPProtocolFactory()
server = whizzer.TcpServer(loop, factory, "127.0.0.1", 2000, 256)
signal_handler.start()
server.start()
loop.loop()
def main():
loop = pyev.default_loop()
signal_handler = whizzer.signal_handler(loop)
signal_handler.start()
factory = HTTPProtocolFactory()
server = whizzer.TcpServer(loop, factory, "127.0.0.1", 2000, 256)
signal_handler.start()
server.start()
loop.loop()
def start_periodic_tasks():
loop = pyev.default_loop(pyev.EVFLAG_FORKCHECK)
def sig_cb(watcher, revents):
loop.stop(pyev.EVBREAK_ALL)
for t, l in _tasks:
l.stop(pyev.EVBREAK_ALL)
# t.join()
for t,l in _tasks:
t.start()
# now wait for events to arrive
sig = loop.signal(signal.SIGINT, sig_cb)
sig.start()
loop.start()
def init(self, args):
self.current = 0
debug('init')
l = pyev.default_loop()
self.timer = pyev.Timer(30.0, 30.0, l, self.do_timer)
self.timer.start()
return {
'output': self.do_output,
}
def connect(address, port=24414):
global config, connection_map
name, public_key, secret_key = load_identity()
if name is not None:
print("Your identity is:")
print(name + " " + get_fingerprint(public_key))
print("Verify this fingerprint is valid when connecting")
else:
name, public_key, secret_key = new_key_interface()
config = configparser.RawConfigParser()
config.read("netshrink.cfg")
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
loop = pyev.default_loop()
connection_map[0] = Connection(sock, (address, port))
def run(self):
"""Start the bot and its event loop"""
self.loop = pyev.default_loop()
self.loop.debug = self.app.debug
delay = self.app.config['IRC_RECONNECT_DELAY']
self._reconnect_tmr = pyev.Timer(delay, delay, self.loop, self._reconnect_cb)
for name in self.app.config['IRC_MODULES']:
self.load_module(name)
self.logger.info('Starting event loop')
self._connect()
self._sigwatchers = [pyev.Signal(sig, self.loop, self._sig_cb)
for sig in STOPSIGNALS.iterkeys()]
for watcher in self._sigwatchers:
watcher.start()
self.loop.start()
def main():
loop = pyev.default_loop()
signal_handler = whizzer.signal_handler(loop)
factory = whizzer.ProtocolFactory()
factory.protocol = EchoClientProtocol
clients = []
# number of parallel clients
for x in range(0, 2):
clients.append(EchoClient(x, loop, factory))
signal_handler.start()
loop.loop()
def main():
loop = pyev.default_loop()
signal_handler = whizzer.signal_handler(loop)
factory = whizzer.ProtocolFactory()
factory.protocol = EchoClientProtocol
clients = []
# number of parallel clients
for x in range(0, 2):
clients.append(EchoClient(x, loop, factory))
signal_handler.start()
loop.loop()
def main():
loop = pyev.default_loop()
signal_handler = whizzer.signal_handler(loop)
signal_handler.start()
factory = EchoProtocolFactory()
server = whizzer.TcpServer(loop, factory, "127.0.0.1", 2000, 256)
stats = EchoStatistics(loop, factory)
signal_handler.start()
server.start()
stats.start()
loop.loop()
def main():
loop = pyev.default_loop()
signal_handler = whizzer.signal_handler(loop)
signal_handler.start()
factory = EchoProtocolFactory()
server = whizzer.TcpServer(loop, factory, "127.0.0.1", 2000, 256)
stats = EchoStatistics(loop, factory)
signal_handler.start()
server.start()
stats.start()
loop.loop()
def __init__(self, config):
logger.debug('hpfeedhandler init')
self.client = hpclient(config['server'], int(config['port']), config['ident'], config['secret'])
ihandler.__init__(self, '*')
self.dynip_resolve = config.get('dynip_resolve', '')
self.dynip_timer = None
self.ownip = None
if self.dynip_resolve and 'http' in self.dynip_resolve:
if pyev == None:
logger.debug('You are missing the python pyev binding in your dionaea installation.')
else:
logger.debug('hpfeedihandler will use dynamic IP resolving!')
self.loop = pyev.default_loop()
self.dynip_timer = pyev.Timer(2., 300, self.loop, self._dynip_resolve)
self.dynip_timer.start()
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, config):
logger.debug('hpfeedhandler init')
self.client = hpclient(config['server'], int(config['port']), config['ident'], config['secret'])
ihandler.__init__(self, '*')
self.dynip_resolve = config.get('dynip_resolve', '')
self.dynip_timer = None
self.ownip = None
if self.dynip_resolve and 'http' in self.dynip_resolve:
if pyev == None:
logger.debug('You are missing the python pyev binding in your dionaea installation.')
else:
logger.debug('hpfeedihandler will use dynamic IP resolving!')
self.loop = pyev.default_loop()
self.dynip_timer = pyev.Timer(2., 300, self.loop, self._dynip_resolve)
self.dynip_timer.start()
def __init__(self, int_cb, int_sock):
self.sock = int_sock
loop = pyev.default_loop()
io = loop.io(int_sock, pyev.EV_READ, self.io_cb)
io.start()
sig = loop.signal(signal.SIGINT, self.sig_cb)
sig.start()
loop.data = [io, sig]
self.loop = loop
self.int_cb = int_cb
def __init__(self, dsp_endpoints, event_endpoint, balance_conn_timeout):
"""
Constructor
dsp_endpoints : is a list of tuples(endpoint, qps) where
enpoint is a string like '192.168.10.152:5869'
and qps is the value indicating queries per
second for that enpoint.
balance_conn_timeout : is the time period for rebalancing
available connections.
"""
# list containing tuples in the form
# (endpoint, expected qps, current qps)
self.dest_eps = [[ep[0], ep[1], 0] for ep in dsp_endpoints]
self.event_endpoint = event_endpoint
self.conns = {}
self.awaiting_conns = {}
self.event_conn_queue = []
self.event_conns = {}
self.event_connections = 0
self.keep_alive_resp_waiting = {}
self.balance_conn_to = balance_conn_timeout
self.loop = pyev.default_loop()
self.watchers = [pyev.Signal(sig, self.loop, self.signal_cb) for sig in STOPSIGNALS]
self.watchers.append(pyev.Timer(self.balance_conn_to, self.balance_conn_to, self.loop, self.balance))
self.watchers.append(pyev.Timer(CHECK_CONNS_TO, CHECK_CONNS_TO, self.loop, self.check_established_connections))
self.watchers.append(pyev.Timer(CHECK_PENDING_TO, CHECK_PENDING_TO, self.loop, self.check_pending_wins))
if EVENT_CONN_KEEP_ALIVE_TO:
self.watchers.append(
pyev.Timer(EVENT_CONN_KEEP_ALIVE_TO, EVENT_CONN_KEEP_ALIVE_TO, self.loop, self.send_keep_alives)
)
self.current_connections = 0
self.request_fact = RTBRequestFactory(TEMPLATE_FILENAME)
self.adserver = AdServer(self.loop)
self.request_fact.initialize()
self.request_fact.set_parameter_plug(PARAMETER_PLUGIN, self.adserver)
if PLUGIN_DO_TO:
self.watchers.append(
pyev.Timer(PLUGIN_DO_TO, PLUGIN_DO_TO, self.loop, self.request_fact.plugin_instance.do)
)
self.pending_wins = []
def __init__(
self,
parameters=None,
on_open_callback=None,
on_open_error_callback=None,
on_close_callback=None,
stop_ioloop_on_close=False,
custom_ioloop=None,
on_signal_callback=None,
):
"""Create a new instance of the LibevConnection class, connecting
to RabbitMQ automatically
:param pika.connection.Parameters parameters: Connection parameters
:param on_open_callback: The method to call when the connection is open
:type on_open_callback: method
:param method on_open_error_callback: Called if the connection can't
be established: on_open_error_callback(connection, str|exception)
:param method on_close_callback: Called when the connection is closed:
on_close_callback(connection, reason_code, reason_text)
:param bool stop_ioloop_on_close: Call ioloop.stop() if disconnected
:param custom_ioloop: Override using the default IOLoop in libev
:param on_signal_callback: Method to call if SIGINT or SIGTERM occur
:type on_signal_callback: method
"""
if custom_ioloop:
self.ioloop = custom_ioloop
else:
with warnings.catch_warnings():
warnings.simplefilter("ignore", RuntimeWarning)
self.ioloop = pyev.default_loop()
self.ioloop.update()
self.async = None
self._on_signal_callback = on_signal_callback
self._io_watcher = None
self._active_timers = {}
self._stopped_timers = deque()
super(LibevConnection, self).__init__(
parameters, on_open_callback, on_open_error_callback, on_close_callback, self.ioloop, stop_ioloop_on_close
)
def __init__(self, interface="", tcp_port=11211, max_bytes=1024*1024*1024):
self.loop = pyev.default_loop()
self.watchers = [pyev.Signal(sig, self.loop, self.signal_cb)
for sig in STOPSIGNALS]
self.sock = socket.socket()
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
address = (interface, tcp_port)
self.sock.bind(address)
self.sock.setblocking(0)
# pylint: disable=W0212
self.watchers.append(
pyev.Io(self.sock._sock, pyev.EV_READ, self.loop, self.io_cb))
# pylint: enable=W0212
self.logger = mc_log.MemcachedLogger(address)
self.conns = weakref.WeakValueDictionary()
self.stats = ConnectionStats()
self.cache = memory_cache.Memcached(self.stats, max_bytes=max_bytes)
def __init__(self,
parameters=None,
on_open_callback=None,
on_open_error_callback=None,
on_close_callback=None,
stop_ioloop_on_close=False,
custom_ioloop=None,
on_signal_callback=None):
"""Create a new instance of the LibevConnection class, connecting
to RabbitMQ automatically
:param pika.connection.Parameters parameters: Connection parameters
:param on_open_callback: The method to call when the connection is open
:type on_open_callback: method
:param method on_open_error_callback: Called if the connection can't
be established: on_open_error_callback(connection, str|exception)
:param method on_close_callback: Called when the connection is closed:
on_close_callback(connection, reason_code, reason_text)
:param bool stop_ioloop_on_close: Call ioloop.stop() if disconnected
:param custom_ioloop: Override using the default IOLoop in libev
:param on_signal_callback: Method to call if SIGINT or SIGTERM occur
:type on_signal_callback: method
"""
if custom_ioloop:
self.ioloop = custom_ioloop
else:
with warnings.catch_warnings():
warnings.simplefilter("ignore", RuntimeWarning)
self.ioloop = pyev.default_loop()
self.ioloop.update()
self. async = None
self._on_signal_callback = on_signal_callback
self._io_watcher = None
self._active_timers = {}
self._stopped_timers = deque()
super(LibevConnection,
self).__init__(parameters, on_open_callback,
on_open_error_callback, on_close_callback,
self.ioloop, stop_ioloop_on_close)
def __init__(self, CombaClient_instance):
"""
Constructor
@type CombaClient_instance: object
@param CombaClient_instance: Der Client für Liquidsoap
"""
self.client = CombaClient_instance
# Messenger für Systemzustände initieren
self.messenger = CombaMessenger()
self.messenger.setChannel('monitor')
self.messenger.setSection('execjob')
self.playlistwatchers = []
self.watchers = []
# das pyev Loop-Object
self.loop = pyev.default_loop()
self.playlistwatcher_loop = pyev.Loop()
# Die Signale, die Abbruch signalisieren
self.stopsignals = (signal.SIGTERM, signal.SIGINT)
# Das ist kein Reload
self.initial = True
self.config = object
self.config_path = ""
self.stop_time = ''
self.start_time = ''
self.duration = ""
# Der Monitor wartet noch auf den Start Befehl
self.ready = False
self.block_combine = False
errors_file = os.path.dirname(os.path.realpath(__file__)) + '/error/combam_error.js'
json_data = open(errors_file)
self.errorData = simplejson.load(json_data)
self.livetime = False
self.messenger.send('Monitor started', '0000', 'success', 'initApp' , None, 'appinternal')
def __init__(self, logger, options=None, loop=None):
setproctitle("flux: %s" % self.__class__.__name__)
self.self_test()
super(ServiceBase, self).__init__()
self.logger = logger
if options:
term_debug = options.debug and not options.daemon
else:
term_debug = False
if loop:
self.loop = loop
else:
self.loop = loop = pyev.default_loop(debug=term_debug)
loop.data = weakref.proxy(self)
self.shutdown_signal = loop. async (lambda w, r: w.loop.stop())
self.shutdown_signal.start()
def __init__(self, CombaClient_instance, config):
"""
Constructor
@type CombaClient_instance: object
@param CombaClient_instance: Der Client für Liquidsoap
@type config: string
@param config: Pfad zum scheduler.xml
"""
self.client = CombaClient_instance
self.loadConfig()
# Messenger für Systemzustände initieren
self.messenger = CombaMessenger()
self.messenger.setChannel('scheduler')
self.messenger.setSection('execjob')
self.messenger.setMailAddresses(self.get('frommail'), self.get('adminmail'))
self.config_path = config
self.config = object
# Die Signale, die Abbruch signalisieren
self.stopsignals = (signal.SIGTERM, signal.SIGINT)
# das pyev Loop-Object
self.loop = pyev.default_loop()
# Das ist kein Reload
self.initial = True
# Der Scheduler wartet noch auf den Start Befehl
self.ready = False
# DIe Config laden
self._loadConfig()
self.scriptdir = os.path.dirname(os.path.abspath(__file__)) + '/..'
errors_file = os.path.dirname(os.path.realpath(__file__)) + '/error/combas_error.js'
json_data = open(errors_file)
self.errorData = simplejson.load(json_data)
self.messenger.send('Scheduler started', '0000', 'success', 'initApp', None, 'appinternal')
print("got SIGINT")
loop = watcher.loop
# optional - stop all watchers
if loop.data:
print("stopping watchers: {0}".format(loop.data))
while loop.data:
loop.data.pop().stop()
# unloop all nested loop
print("stopping the loop: {0}".format(loop))
loop.stop(pyev.EVBREAK_ALL)
def timer_cb(watcher, revents):
watcher.data += 1
print("timer.data: {0}".format(watcher.data))
print("timer.loop.iteration: {0}".format(watcher.loop.iteration))
print("timer.loop.now(): {0}".format(watcher.loop.now()))
if __name__ == "__main__":
loop = pyev.default_loop()
# initialise and start a repeating timer
timer = loop.timer(0, 2, timer_cb, 0)
timer.start()
# initialise and start a Signal watcher
sig = loop.signal(signal.SIGINT, sig_cb)
sig.start()
loop.data = [timer, sig] # optional
# now wait for events to arrive
loop.start()
def __init__(self):
self._ev_loop = pyev.default_loop()
self._ev_timers = {}
self._ev_fdmap = {}
AbstractEventHub.__init__(self)
import signal
import pyev
import getface
def sig_cb(watcher, revents):
print("got SIGINT")
loop = watcher.loop
# unloop all nested loop
loop.stop(pyev.EVBREAK_ALL)
def timer_cb(watcher, revents):
loop.data.look_for_faces()
if __name__ == "__main__":
get_face = getface.GetFace()
loop = pyev.default_loop(data=get_face)
# initialise and start a repeating timer
timer = loop.timer(0, 2.0, timer_cb, 0)
timer.start()
# initialise and start a Signal watcher
sig = loop.signal(signal.SIGINT, sig_cb)
sig.start()
# now wait for events to arrive
loop.start()
logger.critical("Unhandled exception", exc_info=exc_info)
sys.excepthook = hook
if ( (options.key is not None and options.cert is None) or
(options.key is None and options.cert is None) ):
logger.critical("An SSL certificate and private key must be provided")
sys.exit(1)
ssl_config = dict(
keyfile=options.key,
certfile=options.cert,
server_side=True,
cert_reqs=ssl.CERT_NONE,
ssl_version=ssl.PROTOCOL_SSLv23, # Maximum compatibility.
ca_certs=None,
do_handshake_on_connect=False,
suppress_ragged_eofs=False,
ciphers=None
)
def thread_factory(tasks, shutdown_event, hup_event):
return BroccoliWorker(tasks, shutdown_event, hup_event,
options.bro, options.out)
server = Server(SSHDAuditMuxClient, thread_factory, ssl_config,
pyev.default_loop(), (options.addr, options.port),
options.timeout)
p.destroy()
server.start()
import pyev
import signal
import tagservice
def sib_cb(watcher, revents):
loop.stop(pyev.EVBREAK_ALL)
loop = pyev.default_loop()
sig = loop.signal(signal.SIGINT, sib_cb)
sig.start()
tagservice.start(loop)
loop.start()
def __init__(self, reactor):
super(RThread, self).__init__()
self.loop = pyev.default_loop()
self.reactor = reactor
def main():
path = 'adder_socket'
loop = pyev.default_loop()
sigwatcher = pyev.Signal(
signal.SIGINT, loop,
lambda watcher, events: watcher.loop.unloop(pyev.EVUNLOOP_ALL))
sigwatcher.start()
p = Process(loop, server_main, loop, 'adder_socket')
p.start()
pickle_factory = PickleProtocolFactory()
pickle_client = UnixClient(loop, pickle_factory, path)
retries = 10
while retries:
try:
pickle_client.connect().result()
retries = 0
except Exception as e:
time.sleep(0.1)
retries -= 1
proxy = pickle_factory.proxy(0).result()
start = time.time()
s = 0
for i in range(10000):
s = proxy.call('add', 1, s)
stop = time.time()
logger.info(
'pickle-rpc took {} seconds to perform {} calls, {} calls per second',
stop - start, s, s / (stop - start))
start = time.time()
for i in range(10000):
proxy.notify('add', 1, s)
proxy.call('add', 1, s)
stop = time.time()
logger.info(
'pickle-rpc took {} seconds to perform {} notifications, {} notifies per second',
stop - start, 10000, 10000 / (stop - start))
msgpack_factory = MsgPackProtocolFactory()
msgpack_client = UnixClient(loop, msgpack_factory, path + '_mp')
retries = 10
while retries:
try:
msgpack_client.connect().result()
retries = 0
except Exception as e:
time.sleep(0.1)
retries -= 1
proxy = msgpack_factory.proxy(0).result()
start = time.time()
s = 0
for i in range(10000):
s = proxy.call('add', 1, s)
stop = time.time()
logger.info(
'msgpack-rpc took {} seconds to perform {} calls, {} calls per second',
stop - start, s, s / (stop - start))
start = time.time()
for i in range(10000):
proxy.notify('add', 1, s)
proxy.call('add', 1, s)
stop = time.time()
logger.info(
'msgpack-rpc took {} seconds to perform {} notifications, {} notifies per second',
stop - start, 10000, 10000 / (stop - start))
p.stop()
import signal
import pyev
import getface
def sig_cb(watcher, revents):
print("got SIGINT")
loop = watcher.loop
# unloop all nested loop
loop.stop(pyev.EVBREAK_ALL)
def timer_cb(watcher, revents):
loop.data.look_for_faces()
if __name__ == "__main__":
get_face = getface.GetFace()
loop = pyev.default_loop(data=get_face)
# initialise and start a repeating timer
timer = loop.timer(0, 2.0, timer_cb, 0)
timer.start()
# initialise and start a Signal watcher
sig = loop.signal(signal.SIGINT, sig_cb)
sig.start()
# now wait for events to arrive
loop.start()
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()))
traceback.print_exception(*exc_info)
logger.critical("Unhandled exception", exc_info=exc_info)
sys.excepthook = hook
if ((options.key is not None and options.cert is None)
or (options.key is None and options.cert is None)):
logger.critical("An SSL certificate and private key must be provided")
sys.exit(1)
ssl_config = dict(
keyfile=options.key,
certfile=options.cert,
server_side=True,
cert_reqs=ssl.CERT_NONE,
ssl_version=ssl.PROTOCOL_SSLv23, # Maximum compatibility.
ca_certs=None,
do_handshake_on_connect=False,
suppress_ragged_eofs=False,
ciphers=None)
def thread_factory(tasks, shutdown_event, hup_event):
return BroccoliWorker(tasks, shutdown_event, hup_event, options.bro,
options.out)
server = Server(SSHDAuditMuxClient, thread_factory, ssl_config,
pyev.default_loop(), (options.addr, options.port),
options.timeout)
p.destroy()
server.start()
