def server_main(loop, path): """Run in the client after the fork.""" loop.fork() logger.debug('forked function') sigintwatcher = pyev.Signal( signal.SIGINT, loop, lambda watcher, events: logger.info('interrupt ignored')) sigintwatcher.start() sigtermwatcher = pyev.Signal(signal.SIGTERM, loop, server_stop) sigtermwatcher.start() adder = AdderService() dispatcher = ObjectDispatch(adder) pickle_factory = PickleProtocolFactory(dispatcher) pickle_server = UnixServer(loop, pickle_factory, path) pickle_server.start() msgpack_factory = MsgPackProtocolFactory(dispatcher) msgpack_server = UnixServer(loop, msgpack_factory, path + '_mp') msgpack_server.start() logger.debug('running server loop') import cProfile cProfile.runctx('loop.loop()', None, {'loop': loop}, 'server_profile') logger.debug('server unlooped')
def _do_wait(self, timeout): """Wait for the deferred to be completed for a period of time Raises TimeoutError if the wait times out before the future is done. Raises CancelledError if the future is cancelled before the timeout is done. """ if self._cancelled: raise CancelledError() if not self._done: self._wait = True self._sigint = pyev.Signal(signal.SIGINT, self.loop, lambda watcher, events: self._cancel(), None) self._sigint.start() if timeout and timeout > 0.0: self._timer = pyev.Timer(timeout, 0.0, self.loop, self._clear_wait, None) self._timer.start() while self._wait and not self._done and not self._cancelled: self.loop.start(pyev.EVRUN_ONCE) if self._cancelled: raise CancelledError() elif not self._done: raise TimeoutError()
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, datafile, probespath, probe_confs): self.active = False self.active_probes = 0 self.probespath = probespath self.loop = pyev.Loop() #self.queue = Queue() # initialize and start a idle watcher #self.idle_watcher = pyev.Idle(self.loop, self.idle_cb) #self.idle_watcher.start() # initialize and start a signal watchers sigterm_watcher = pyev.Signal(signal.SIGTERM, self.loop, self.sigterm_cb) sigterm_watcher.start() sigint_watcher = pyev.Signal(signal.SIGINT, self.loop, self.sigint_cb) sigint_watcher.start() self.loop.data = [sigterm_watcher, sigint_watcher] #self.loop.data.append(self.idle_watcher) # initialize storage logging.info("Init storage...") self.storage = Storage(datafile) # read in probes from config self.probes = [] index = 0 for probe_conf in probe_confs: self.check_command(probe_conf) self.check_data_type(probe_conf) self.check_dummy(probe_conf) # load filters self.load_filters(probe_conf) # load error filters self.load_error_filters(probe_conf) p = self.get_probe(index, self.storage, probe_conf, -1) p.register(self.loop) self.probes.append(p) if probe_conf.get("auto_start", False): self.start_probe(index) index = index + 1
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, iface, essid, bssid, channel, beacon_interval_sec, packet_callback): self.active = False self.iface = iface self.essid = essid self.bssid = bssid self.channel = channel self.beacon_interval_sec = beacon_interval_sec self.packet_callback = packet_callback self.start_time_secs = time.time() self.sc = 0 self.sender = PacketSender(self.iface) self.beacon_packet = dot11.Dot11(addr1='ff:ff:ff:ff:ff:ff', \ addr2=self.bssid, \ addr3=self.bssid) \ / dot11.Dot11Beacon(cap='ESS+privacy') \ / dot11.Dot11Elt(ID='SSID', \ info=self.essid) \ / dot11.Dot11Elt(ID='DSset', \ info=chr(self.channel)) \ / dot11.Dot11Elt(ID='Rates', \ info='\x82\x84\x0b\x16') \ / dot11.Dot11Elt(ID='RSNinfo', info='\x01\x00\x00\x0f\xac' \ '\x04\x01\x00\x00\x0f' \ '\xac\x04\x01\x00\x00' \ '\x0f\xac\x02\x00\x00') self.watchers = { "interval": None, "timeout": None } self.loop = pyev.Loop() # initialize and start a signal watchers sigterm_watcher = pyev.Signal(signal.SIGTERM, self.loop, self.sigterm_cb) sigterm_watcher.start() sigint_watcher = pyev.Signal(signal.SIGINT, self.loop, self.sigint_cb) sigint_watcher.start() self.loop.data = [sigterm_watcher, sigint_watcher] self.sniff_thread = Thread(target=self.sniff, kwargs=dict(), name='sniff-thread') self.sniff_thread.setDaemon(True)
def loop(l=default_loop): sigint_watcher = pyev.Signal(signal.SIGINT, default_loop, _sigint_cb) sigint_watcher.start() try: l.start() except OSError, e: traceback.print_exc() print 'oserror', e, e.args
def __init__(self, config): self.active = False self.config = config self.watcher = None self.loop = pyev.Loop() # initialize and start a signal watchers sigterm_watcher = pyev.Signal(signal.SIGTERM, self.loop, self.sigterm_cb) sigterm_watcher.start() sigint_watcher = pyev.Signal(signal.SIGINT, self.loop, self.sigint_cb) sigint_watcher.start() self.loop.data = [sigterm_watcher, sigint_watcher] # init GPIO GPIO.setmode(GPIO.BCM) GPIO.setup(config['GPIO_in'], GPIO.IN) GPIO.setup(config['GPIO_out'], GPIO.OUT, initial=GPIO.HIGH)
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, 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, loop, factory): self.loop = loop self.factory = factory self.connector = None self.connection = None self.connect_deferred = None self.sigint_watcher = pyev.Signal(signal.SIGINT, self.loop, self._interrupt) self.sigint_watcher.start() self.connector = None self.sock = None self.addr = None
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 _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 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()
def sig_cb(watcher, events): print("got SIGINT") # optional - stop all watchers if watcher.data: print("stopping watchers: {0}".format(watcher.data)) while watcher.data: watcher.data.pop().stop() # unloop all nested loop print("stopping the loop: {0}".format(watcher.loop)) watcher.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 = pyev.Timer(0, 2, loop, timer_cb, data=0) timer.start() # initialise and start a Signal watcher sig = pyev.Signal(signal.SIGINT, loop, sig_cb) sig.data = [timer, sig] # optional sig.start() # now wait for events to arrive loop.start()
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.cnssockets.extend(socks) if len(self.cnssockets) == 0: L.fatal( "There is no console socket 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.watchers.append( pyev.Signal(signal.SIGHUP, self.loop, self.__restart_signal_cb)) self.watchers.append(pyev.Periodic(0, 1.0, self.loop, self.__tick_cb)) 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:
def signal_init(self): self.sigintwatcher = pyev.Signal(signal.SIGINT, self.loop, self._stop) self.sigintwatcher.start() self.sigtermwatcher = pyev.Signal(signal.SIGTERM, self.loop, self._terminate) self.sigtermwatcher.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()))