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