def __init__(self, name, processes=1, maxQueueSize=100, args=None): try: self.pool = [] self.resultQueue = DeQueue(maxQueueSize) self.dataQueue = DeQueue(maxQueueSize) self.debugQueue = Queue() self.name = name self.variables = {} print ("processes for {} = {}".format(name, processes)) for i in range(processes): if args: p = Process(target=self.process, args=args) else: p = Process(target=self.process) self.pool.append(p) p.start() asyncio.get_event_loop().create_task(self.poll()) except: exc_type, exc_value, exc_traceback = sys.exc_info() traceback.print_tb(exc_traceback, limit=1, file=sys.stdout) traceback.print_exception(exc_type, exc_value, exc_traceback, limit=2, file=sys.stdout)
def _send_servo_commands(self): servo_started_up = False while True: if ((not servo_started_up) and self.mech_driver and self.mech_driver.servo): servo_started_up = True # Reset all servos on startup, as they may have had an pending # error due to power glitch or something similar. self.logger.info('Rebooting servos on startup') yield From(self.mech_driver.servo.reboot()) if not self.servo_send_now.is_set(): # Make sure we wake up periodically asyncio.get_event_loop().call_later( SERVO_SEND_INTERVAL, self.servo_send_now.set) yield From(self.servo_send_now.wait()) self.servo_send_now.clear() new_pkt = self.net_packet old_pkt = self.servo_packet if new_pkt is not None: yield From(self._send_servo_commands_once( new_pkt, old_pkt)) self.servo_packet = new_pkt # send any status updates self.status_send_now.set()
def __init__(self, cameras=[], port=9004, users_file="users.json", recognition_db="recognition.db"): Server.__init__(self, port=port, usessl=False) self.recognition_db = recognition_db self.last_user_uuid = "" self.last_len_persons_detected = -1 self.last_len_users = -1 self.camera_clients = [] self.recognizer = Recognizer(users_file) self.cameras = cameras self.start() self.method_handlers = {} self.method_handlers["list_users"] = self.list_users self.method_handlers["select_camera"] = self.select_camera self.method_handlers["list_users_with_level"] = self.list_users_with_level self.method_handlers["add_association"] = self.add_association self.users_recognized = [] asyncio.get_event_loop().create_task(self.poll())
def __init__(self, pollRate = MINS(10), port=9001, sslcert = "server.crt", sslkey= "server.key", privateKeyFile = 'dhserver.key', clientsFile = "clients.json"): Server.__init__(self, True, port, sslcert, sslkey, privateKeyFile = privateKeyFile, clientsFile = clientsFile) self.pollRate = pollRate self.port = port self.numclients = len(self.clients) asyncio.get_event_loop().create_task(self.poll())
def test_async_flush_fail(self): """Test async_flush in the case that the last heap sent failed. This is arranged by filling up the queue slots first. """ for i in range(5): trollius.async(self.stream.async_send_heap(self.heap)) # The above only queues up the async sends on the event loop. The rest of the # test needs to be run from inside the event loop trollius.get_event_loop().run_until_complete(self._test_async_flush())
def test_send_error(self): """An error in sending must be reported through the future.""" # Create a stream with a packet size that is bigger than the likely # MTU. It should cause an error. stream = UdpStream( spead2.ThreadPool(), "localhost", 8888, spead2.send.StreamConfig(max_packet_size=100000), buffer_size=0) future = stream.async_send_heap(self.heap) trollius.get_event_loop().run_until_complete(self._test_send_error(future))
def session_made(self, conn): """ called when we established a session to the router we can look up names/b32 but can't send messages to others yet :param conn: our i2cp connection that we are using """ self.conn = conn self._log.info('session made we are {}'.format(conn.dest)) asyncio.get_event_loop().call_later(self._delay, self._send)
def main(): logging.basicConfig(level=logging.WARN, stream=sys.stdout) parser = optparse.OptionParser(description=__doc__) MechDriver.add_options(parser) options, args = parser.parse_args() task = Task(start(options)) asyncio.get_event_loop().run_until_complete(task)
def onJoin(self, details): print("Session Joined.") #Setting variables self.lastServoValue = 417 #Assumes it starts in the middle self.servoMin = 315 # Min pulse length out of 4096 self.servoMax = 520 # Max pulse length out of 4096 self.servoMiddle = 417 # middle servo value self.servoChannel = 3 print "What is happening????" self.motorMiddle = 1500 self.motorChannel = 2 self.subscribe(self.joyMonitor, 'aero.near.joystream') print "joystream ok" #subscribe to methods to prevent register conflicts self.subscribe(self.honkCommand, 'aero.near.honkHorn') print "honk ok" self.subscribe(self.emergencyStop, 'aero.near.emergStop') print "emergstop ok" self.subscribe(self.manualOverride, 'aero.near.override') print "About to make the loop" self.gps_data = {'latitude': 0,'longitude': 0,'heading': 0,'speed': 0} self.loop = asyncio.get_event_loop() # self.loop.stop() # future = asyncio.Future() # print "the future exists" # asyncio.async(self.gpsUpdate()) # self.loop.run_until_complete(future) # self.loop = asyncio.new_event_loop() # tasks = [ # asyncio.async(self.honk()), # # asyncio.async(self.lidarRead())] # # asyncio.async(self.gpsUpdate())] # # asyncio.async(self.internet_on())] # print tasks # swag.system('cls' if swag.name == 'nt' else 'clear') # try: self.loop = asyncio.get_event_loop() tasks = [ asyncio.async(self.netDisconnect())] print tasks try: done, pending = yield self.loop.run_until_complete(asyncio.wait(tasks)) except Exception as e: print e print tasks #print "running" self.loop.close() # done, pending = yield self.loop.run_until_complete(asyncio.wait(tasks)) # except Exception as e: # print e # print tasks print "running"
def _connect_dual_stack(self, primary_address, secondary_address): '''Connect using happy eyeballs.''' self._primary_connection = self._connection_factory(primary_address) self._secondary_connection = self._connection_factory(secondary_address) @trollius.coroutine def connect_primary(): yield From(self._primary_connection.connect()) raise Return(self._primary_connection) @trollius.coroutine def connect_secondary(): yield From(self._secondary_connection.connect()) raise Return(self._secondary_connection) primary_fut = connect_primary() secondary_fut = connect_secondary() failed = False for fut in trollius.as_completed((primary_fut, secondary_fut)): if not self._active_connection: try: self._active_connection = yield From(fut) except NetworkError: if not failed: _logger.debug('Original dual stack exception', exc_info=True) failed = True else: raise else: _logger.debug('Got first of dual stack.') else: @trollius.coroutine def cleanup(): try: conn = yield From(fut) except NetworkError: pass else: conn.close() _logger.debug('Closed abandoned connection.') trollius.get_event_loop().create_task(cleanup()) if self._active_connection.address == secondary_address: preferred_addr = secondary_address else: preferred_addr = primary_address self._happy_eyeballs_table.set_preferred(preferred_addr, primary_address, secondary_address)
def _start_tls(self): '''Start SSL protocol on the socket.''' socket_ = self._writer.get_extra_info('socket') try: trollius.get_event_loop().remove_reader(socket_.fileno()) except ValueError as error: raise trollius.ConnectionAbortedError() from error self._writer.write(b'HTTP/1.1 200 Connection established\r\n\r\n') yield From(self._writer.drain()) try: trollius.get_event_loop().remove_writer(socket_.fileno()) except ValueError as error: raise trollius.ConnectionAbortedError() from error ssl_socket = ssl.wrap_socket( socket_, server_side=True, certfile=self._cert_filename, keyfile=self._key_filename, do_handshake_on_connect=False ) # FIXME: this isn't how to START TLS for dummy in range(1200): try: ssl_socket.do_handshake() break except ssl.SSLError as error: if error.errno in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE): _logger.debug('Do handshake %s', error) yield From(trollius.sleep(0.05)) else: raise else: _logger.error(_('Unable to handshake.')) ssl_socket.close() self._reject_request('Could not start TLS') raise trollius.ConnectionAbortedError('Could not start TLS') loop = trollius.get_event_loop() reader = trollius.StreamReader(loop=loop) protocol = trollius.StreamReaderProtocol(reader, loop=loop) transport, dummy = yield From(loop.create_connection( lambda: protocol, sock=ssl_socket)) writer = trollius.StreamWriter(transport, protocol, reader, loop) self._reader = reader self._writer = writer
def cancel_after_first_completed(tasks, interrupted_cb, loop=None): @asyncio.coroutine def _cancel_after_first_completed(tasks): while tasks: done, pending = yield asyncio.From(asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED, loop=loop)) for task in done: info(task) assert task in tasks tasks.remove(task) for task in pending: task.cancel() assert tasks if not loop: loop = asyncio.get_event_loop() main_task = asyncio.Task(_cancel_after_first_completed(tasks[:]), loop=loop) while True: try: loop.run_until_complete(main_task) break except (KeyboardInterrupt, SystemExit): interrupted_cb() for task in tasks: assert task.done() if task.done() and not task.cancelled(): exc = task.exception() if exc is not None: raise exc
def setUp(self): self.loop = trollius.get_event_loop() self.graph = GraphDatabase("ws://localhost:8182/", username="******", password="******", loop=self.loop, future_class=Future)
def _main(): module_interpreters = _find_module_interpreters() enabled_modules = [] for mod_type, mod_name, mod_socket_path, mod_runas in \ _find_all_enabled_modules(): module_interpreter = module_interpreters.get(mod_name) if module_interpreter is None: raise RuntimeError('Unable to find right interpreter for module ' '"%s"' % mod_name) enabled_modules.append( (mod_type, mod_name, module_interpreter, mod_socket_path, mod_runas)) _log.info('%u enabled module instances found', len(enabled_modules)) loop = trollius.get_event_loop() for sig_num in signal.SIGINT, signal.SIGTERM: loop.add_signal_handler(sig_num, lambda: _stop(sig_num, loop)) list(map(lambda module: _spawn_process(loop, *module), enabled_modules)) try: loop.run_forever() finally: loop.close()
def __init__(self, *args, **kwargs): if 'loop' in kwargs: self._loop = kwargs.pop('loop') else: self._loop = trollius.get_event_loop() super(UdpStream, self).__init__(*args, **kwargs) self._active = 0
def __init__(self, *args, **kwargs): self._loop = kwargs.pop('loop', None) super(Wrapped, self).__init__(*args, **kwargs) if self._loop is None: self._loop = trollius.get_event_loop() self._active = 0 self._last_queued_future = None
def connect_read_pipe(file): loop = asyncio.get_event_loop() stream_reader = asyncio.StreamReader(loop=loop) def factory(): return asyncio.StreamReaderProtocol(stream_reader) transport, _ = yield From(loop.connect_read_pipe(factory, file)) raise Return(stream_reader, transport)
def create_client(client_klass, host=None, port=None, loop=None, timeouts=None, client_type=None): """ create a Trollius thrift client and return a context manager for it This is a coroutine :param client_klass: thrift Client class :param host: hostname/ip, None = loopback :param port: port number :param loop: Trollius event loop :returns: a Context manager which provides the thrift client """ if not loop: loop = asyncio.get_event_loop() transport, protocol = yield From( loop.create_connection( ThriftClientProtocolFactory( client_klass, loop=loop, timeouts=timeouts, client_type=client_type, ), host=host, port=port, ) ) raise Return(protocol_manager(protocol))
def __init__(self, log, max_pool=10, max_tasks=5): self.log = log self.max_pool = max_pool # Overall limit. self.max_tasks = max_tasks # Per-key limit. self.loop = asyncio.get_event_loop() self.connections = {} # {(host, port, ssl): [Connection, ...], ...} self.queue = [] # [Connection, ...]
def analyze_body(sdf, address=("127.0.0.1", 11346)): """ Single body analyzer. Opens a new connection, analyzes the body, and returns the result. If you already have a manager running doing other things, create an instance of `BodyAnalyzer` instead. :param sdf: SDF object consisting of BodyPart instances. :type sdf: SDF :param address: Tuple of the hostname and port where the analyzer resides. Note that the default is one up from the default Gazebo port, since it is meant to be used with the `run-analyzer.sh` tool. :type address: (str, int) :return: :rtype: (bool, (float, float, float)) """ response_obj = [None] @trollius.coroutine def internal_analyze(): analyzer = yield From(BodyAnalyzer.create(address)) response_obj[0] = yield From(analyzer.analyze_sdf(sdf)) loop = trollius.get_event_loop() loop.run_until_complete(internal_analyze()) return response_obj[0]
def main(): global SERVER try: loop = trollius.get_event_loop() coro = trollius.start_server( handle_client, host=None, port=pagure.APP.config['EVENTSOURCE_PORT'], loop=loop) SERVER = loop.run_until_complete(coro) log.info('Serving server at {}'.format(SERVER.sockets[0].getsockname())) if pagure.APP.config.get('EV_STATS_PORT'): stats_coro = trollius.start_server( stats, host=None, port=pagure.APP.config.get('EV_STATS_PORT'), loop=loop) stats_server = loop.run_until_complete(stats_coro) log.info('Serving stats at {}'.format( stats_server.sockets[0].getsockname())) loop.run_forever() except KeyboardInterrupt: pass except trollius.ConnectionResetError: pass # Close the server SERVER.close() if pagure.APP.config.get('EV_STATS_PORT'): stats_server.close() log.info("End Connection") loop.run_until_complete(server.wait_closed()) loop.close() log.info("End")
def produce_record(self, stream, key, data): record = Record(key, data, stream) stream = self.runner.streams[stream] loop = trollius.get_event_loop() for subscriber in stream.subscribers: loop.call_soon(subscriber.process_record, self, record)
def find_master(): loop = asyncio.get_event_loop() ServerState.logger.info('Attempting to locate master CoreMQ server for replication...') servers = ServerState.cluster_nodes[:] removals = [] port = str(ServerState.listen_address[1]) for s in servers: sp = s if ':' not in s: sp += ':6747' if ServerState.name.split('.', 1)[0] == sp.split('.', 1)[0] and port == sp.split(':')[-1]: removals.append(s) for r in removals: servers.remove(r) if not servers: ServerState.logger.info('This server is the only one listed in cluster_nodes, Assuming role of master MQ') return factory = CoreMqClientFactory(ReplicationClientProtocol, servers, loop=loop) yield asyncio.From(factory.connect()) factory.lost_connection_callback = promote_to_master if not factory.connection: ServerState.logger.warn('No other CoreMQ servers found. Assuming role of master MQ') else: conn = factory.connection[1] conn.connected_future.add_done_callback( lambda _: conn.begin_replication('%s:%s' % (ServerState.name, ServerState.listen_address[1])) ) ServerState.master = conn
def loop(self): loop = asyncio.get_event_loop() dispatcher = td.AsyncioCallbackDispatcher(loop) core = td.TelldusCore(callback_dispatcher=dispatcher) core.register_sensor_event(self.sensor_event) print("Starting loop") loop.run_forever()
def handler(self, message): loop = asyncio.get_event_loop() block = message[0:4] after = message[5:] if block == "NICK": self.nick = after print("{} is identified as {}".format(self.peer, after)) self.prefix = "~{}!{}@{}".format(self.nick, self.ident, self.addr) return if block == "USER": if self.connected == False: self.connected = True self.real = after.split(':')[1] data = after.split(':')[0].split() self.ident = data[0] self.host = data[1] self.serv = data[2] print("First Task") task = asyncio.Task(self.first_connection()) self.tasks[task] = (self.peer, loop.time()) task.add_done_callback(self.task_done) return if block == "PONG": print("Client {} PONG".format(self.peer)) return if block != "PONG": print("Recieved '{}' from {} identified as {} - {}".format(repr(message), self.peer, self.nick, timer())) self.transport.write("{}\r\n".format(message).encode()) print("Sent '{}' to {}".format(repr(message), self.peer))
def __init__(self, config_file): super(Tourbillon, self).__init__() self._aio_run_event = asyncio.Event() self._thr_run_event = threading.Event() self._loop = asyncio.get_event_loop() self._tasks = [] self._pluginconfig = {} with open(config_file, 'r') as f: self._config = json.load(f) formatter = logging.Formatter(fmt=self._config['log_format']) handler = logging.handlers.WatchedFileHandler( self._config['log_file']) handler.setFormatter(formatter) handler.setLevel(getattr(logging, self._config['log_level'])) logging.getLogger().addHandler(handler) logging.getLogger().setLevel( getattr(logging, self._config['log_level'])) logger.info('Use config file: %s', config_file) self._load_plugins_config(os.path.abspath( os.path.dirname(config_file))) self._influxdb = InfluxDBClient(**self._config['database']) self._databases = [i['name'] for i in self._influxdb.get_list_database()] print(self._databases)
def test_queue_overload(self): http = HTTPConnectionPool('httpbin.org', maxsize=3, block=True, timeout=3) testLoop = asyncio.get_event_loop() testLoop.set_debug(True) global test_queue_overload_count test_queue_overload_count = 0 @asyncio.coroutine def get_page(): global test_queue_overload_count try: resp = yield From(http.request('GET', '/delay/1', pool_timeout=3)) pg = yield From(resp.data) self.assertTrue(b'Connection' in pg, pg) except EmptyPoolError: pass except Exception as e: raise else: test_queue_overload_count += 1 pageGetters = [get_page(), get_page(), get_page(), get_page(), get_page()] testLoop.run_until_complete(asyncio.wait(pageGetters, return_when=asyncio.ALL_COMPLETED)) self.assertGreater(test_queue_overload_count, 4, 'not all page_getters ran')
def __init__(self, handler, lookup=None, session_options={}, keyfile='i2cp.key', i2cp_host='127.0.0.1', i2cp_port=7654, evloop=None): self._i2cp_host, self._i2cp_port = i2cp_host, i2cp_port self._sid = None self._lookup = lookup self._done = False self.dest = None self._connected = False self._created = False self.handler = handler or I2CPHandler() self.keyfile = keyfile self.opts = dict(session_options) self.opts['i2cp.fastReceive'] = 'true' self.send_dgram = self.send_dsa_dgram self._host_lookups = dict() # create encryption key for LS per session self._enckey = crypto.ElGamalGenerate() self._msg_handlers = { messages.message_type.SessionStatus : self._msg_handle_session_status, messages.message_type.RequestLS : self._msg_handle_request_ls, messages.message_type.SetDate : self._msg_handle_set_date, messages.message_type.Disconnect : self._msg_handle_disconnect, messages.message_type.RequestVarLS : self._msg_handle_request_var_ls, messages.message_type.HostLookupReply : self._msg_handle_host_lookup_reply, messages.message_type.MessagePayload : self._msg_handle_message_payload, } self._dest_cache = dict() if evloop is None: self._loop = asyncio.get_event_loop() else: self._loop = evloop self.generate_dest(self.keyfile)
def get_async(self, urls, callback): def get(url, headers): resp = requests.get(url, headers=headers) if resp: si = self.process_response(resp) callback(si, resp.url) @asyncio.coroutine def run(urls, concurrency, loop): urls = list(urls) pending = [loop.run_in_executor(None, get, url, self.headers) for url in urls[:concurrency]] rest = urls[concurrency:] while pending: done, pending = yield asyncio.From(asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)) while rest and len(pending) < concurrency: pending.add(loop.run_in_executor(None, get, rest.pop(), self.headers)) for future in done: try: si = future.result() # callback(si, si.original_url) except Exception: logger.info("failed on url", exc_info=True) loop = asyncio.get_event_loop() # TODO: make magic concurrency number a parameter loop.run_until_complete(run(urls, concurrency=32, loop=loop))
def ThriftAsyncServerFactory( processor, interface=None, port=0, loop=None, nthreads=None, sock=None, backlog=100 ): if loop is None: loop = asyncio.get_event_loop() if not isinstance(processor, TProcessor): try: processor = processor._processor_type(processor, loop=loop) except AttributeError: raise TypeError( "Unsupported processor type: {}".format(type(processor)), ) if nthreads: from concurrent.futures import ThreadPoolExecutor loop.set_default_executor( ThreadPoolExecutor(max_workers=nthreads), ) event_handler = TServerEventHandler() pfactory = ThriftServerProtocolFactory(processor, event_handler, loop) server = yield From(loop.create_server( pfactory, interface, port, sock=sock, backlog=backlog, )) if server.sockets: for socket in server.sockets: event_handler.preServe(socket.getsockname()) raise Return(server)
def __init__(self, pollRate=MINS(10), port=9001, sslcert="server.crt", sslkey="server.key", privateKeyFile='dhserver.key', clientsFile="clients.json"): Server.__init__(self, True, port, sslcert, sslkey, privateKeyFile=privateKeyFile, clientsFile=clientsFile) self.pollRate = pollRate self.port = port self.numclients = len(self.clients) asyncio.get_event_loop().create_task(self.poll())
def main(): loop = asyncio.get_event_loop() # creates a server and starts listening to TCP connections server = MyServer() server.start(loop) @asyncio.coroutine def client(): reader, writer = yield From(asyncio.streams.open_connection( '127.0.0.1', 12345, loop=loop)) def send(msg): print("> " + msg) writer.write((msg + '\n').encode("utf-8")) def recv(): msgback = (yield From(reader.readline())) msgback = msgback.decode("utf-8").rstrip() print("< " + msgback) raise Return(msgback) # send a line send("add 1 2") msg = yield From(recv()) Ns = list(range(100, 100000, 10000)) times = [] for N in Ns: t0 = time.time() send("repeat {0} hello world ".format(N)) msg = yield From(recv()) assert msg == 'begin' while True: msg = (yield From(reader.readline())) msg = msg.decode("utf-8").rstrip() if msg == 'end': break t1 = time.time() dt = t1 - t0 print("Time taken: {0:.3f} seconds ({1:.6f} per repetition)" .format(dt, dt/N)) times.append(dt) writer.close() yield From(asyncio.sleep(0.5)) # creates a client and connects to our server try: loop.run_until_complete(client()) server.stop(loop) finally: loop.close()
def __init__(self, builder, human_format_speed=True): super().__init__() self._builder = builder self._human_format_speed = human_format_speed self._event_loop = trollius.get_event_loop() self._exit_code = 0 self._statistics = None self.stop_observer = wpull.observer.Observer() self._server_tasks = [] self._servers = [] self.register_hook('exit_status', 'finishing_statistics')
def __init__(self, protocol, ip='127.0.0.1', port=9000): ip_str = str(ip) port_int = int(port) wsip = u"ws://" + ip_str + u":" + str(port_int) factory = WebSocketServerFactory(wsip) factory.protocol = protocol self.loop = trollius.get_event_loop() #self.loop.set_debug(False) self.coro = self.loop.create_server(factory, ip_str, port_int) self.server = self.loop.run_until_complete(self.coro) print("WebSockets configured on %s" % wsip)
def runner(): args = prepare() loop = asyncio.get_event_loop() # wrap asyncio to suppress stacktraces if args.debug: loop.run_until_complete(main(args)) else: try: loop.run_until_complete(main(args)) except Exception as e: print(e.message) loop.close()
def datagram_received(self, data, addr): header = data[0] payload = data[1:] if header == _JOYSTICK_AXIS_HEADER: axis, value = _JOYSTICK_AXIS_DATA.unpack(payload) print("Received axis {0} data: {1}".format(axis, value)) self.transport.sendto(_PING_BACK) else: print('Unknown packet data: "{0}"'.format(data)) self.transport.close() loop = asyncio.get_event_loop() loop.close()
def async_test(f): testLoop = asyncio.get_event_loop() testLoop.set_debug(True) @functools.wraps(f) def wrapper(*args, **kwargs): coro = asyncio.coroutine(f) future = coro(*args, **kwargs) testLoop.run_until_complete(future) return wrapper
def main(): logging.basicConfig(level=logging.WARN, stream=sys.stdout) asyncio.set_event_loop_policy(asyncio_qt.QtEventLoopPolicy()) app = QtGui.QApplication(sys.argv) app.setApplicationName('mjscore_manager') parser = optparse.OptionParser() parser.add_option('-s', '--serial', help='serial port to use') options, args = parser.parse_args() assert len(args) == 0 manager = ManagerMainWindow() if options.serial: manager.open_serial(options.serial) manager.show() asyncio.get_event_loop().run_forever()
def start(self): self._loop = asyncio.get_event_loop() self._face = ThreadsafeFace(self._loop, "") self._face.setCommandSigningInfo(self._keyChain, self._certificateName) self._face.registerPrefix(self.prefix, self.onPlayingCommand, self.onRegisterFailed) try: self._loop.run_forever() except KeyboardInterrupt: sys.exit() finally: self.stop()
def start(self): self.loop = asyncio.get_event_loop() self.face = ThreadsafeFace(self.loop, "") self.face.setCommandSigningInfo(self.keychain, self.certificateName) self.songName = raw_input( "Song Name(each song separated by a comma): ") self.device = raw_input("Music Player: ") self.issueSongCommand() try: self.loop.run_forever() finally: self.stop()
def main(): asyncio.set_event_loop_policy(asyncio_qt.QtEventLoopPolicy()) app = QtGui.QApplication(sys.argv) dialog = QtGui.QDialog() button = QtGui.QPushButton("text", dialog) button.clicked.connect(start_other) dialog.show() loop = asyncio.get_event_loop() asyncio.Task(simple_coroutine()) loop.run_forever()
def test_decorate_asyncio_coroutine(): buf = StringIO() @asyncio.coroutine @debug.log(print_to=buf, module=False, stacktrace=2, result_repr=repr) def coro(): yield asyncio.From(asyncio.sleep(0.01)) raise StopIteration("result") loop = asyncio.get_event_loop() loop.run_until_complete(coro()) output = buf.getvalue() assert 'coro => %r' % 'result' in output
def get_stocks_by_range(self, index): loop = asyncio.get_event_loop() # response = yield From(loop.run_in_executor(None,self.get_url_data_R, # (self.sina_stock_api + self.stock_list[index]))) response = yield From( loop.run_in_executor( None, requests.get, (self.sina_stock_api + self.stock_list[index]))) # response = yield (requests.get(self.sina_stock_api + self.stock_list[index])) # log.debug("url:%s"%(self.sina_stock_api + self.stock_list[index])) # log.debug("res_encoding:%s" % response.encoding[:10]) self.stock_data.append(response.text)
def main(): config = load_configuration() ServerState.logger = get_logger(config, 'CoreWS') address = config.get('CoreWS', 'address', '0.0.0.0') port = int(config.get('CoreWS', 'port', '9000')) mq_servers = comma_string_to_list( config.get('CoreMQ', 'cluster_nodes', '').split(',')) ServerState.logger.info('CoreWS Starting up...') ws_factory = WebSocketServerFactory('ws://%s:%s/ws' % (address, port)) ws_factory.protocol = WsProtocol loop = asyncio.get_event_loop() server_coro = loop.create_server(ws_factory, address, port) server = loop.run_until_complete(server_coro) ServerState.logger.info('WebSocket Server running') mq_factory = CoreMqClientFactory(WsMqClient, mq_servers, loop=loop) @asyncio.coroutine def connect(*args): ServerState.mq_connection = None while True: yield asyncio.From(mq_factory.connect()) if not mq_factory.connection: ServerState.logger.warn( 'No CoreMQ servers found. Retrying in 3 seconds...') yield asyncio.From(asyncio.sleep(3)) else: conn = mq_factory.connection[1] conn.connected_future.add_done_callback( lambda _: conn.begin_replication('%s:%s' % ( socket.gethostname(), port))) ServerState.mq_connection = conn break mq_factory.lost_connection_callback = connect loop.run_until_complete(connect()) try: loop.run_forever() except KeyboardInterrupt: pass finally: ServerState.logger.info('Shutting down WebSocket Server...') server.close() ServerState.logger.info('Shutting down MQ Client...') mq_factory.close() loop.close() ServerState.logger.info('CoreWS is now shut down')
def get_nginx_stats(agent): yield From(agent.run_event.wait()) logger.debug('starting get_nginx_stats') config = agent.config['nginx'] logger.debug('get_nginx_stats config retrieved') db_config = config['database'] yield From(agent.async_create_database(**db_config)) logger.debug('getting event loop') loop = asyncio.get_event_loop() while agent.run_event.is_set(): logger.debug('in while loop') try: yield From(asyncio.sleep(config['frequency'])) url = config['url'] res = yield From(loop.run_in_executor(None, requests.get, url)) if res.status_code == 200: text = res.text logger.debug(text) status = text.strip().split('\n') conn = status[0].strip().split(': ')[-1] accepts, handled, num_req = status[2].strip().split(' ') reading, writing, waiting = re.split(r'[:\s]\s*', status[-1].strip())[1::2] data = [{ 'measurement': 'nginx_stats', 'tags': { 'hostname': config['host'] }, 'fields': { 'connections': int(conn), 'total_accepts': int(accepts), 'total_handled': int(handled), 'total_requests': int(num_req), 'reading': int(reading), 'writing': int(writing), 'waiting': int(waiting) } }] logger.debug('nginx data: {}'.format(data)) yield From(agent.async_push(data, db_config['name'])) else: logger.warning('cannot get nginx stats: status={}'.format( res.status_code)) except: logger.exception('cannot get nginx stats') logger.info('get_nginx_status terminated')
def work(work_q, send_q, data, metadata_addr, address, loop=None): """ Work coroutine Input Channels: work_q: Main mailbox, get work requests from control metadata_addr: This directly communicates with the MDStore via ZMQ data: A dictionary of local data. This manages some state. Output Channels: send_q: Send acknowledgements of task finished (or failed) to requeter data: A (possibly modified) dictionary of local data. """ print("Worker boots up") loop = loop or asyncio.get_event_loop() while True: addr, msg = yield From(work_q.get()) if msg == 'close': break key, func, args, kwargs, needed = \ get(['key', 'function', 'args', 'kwargs', 'needed'], msg, None) try: d = yield From(get_data(loop, needed, data, metadata_addr)) except KeyError as e: out = {'op': 'computation-failed', 'key': msg['key'], 'error': e} else: args2 = keys_to_data(args or (), d) kwargs2 = keys_to_data(kwargs or {}, d) # result = yield From(delay(loop, func, *args2, **kwargs2)) result = func(*args2, **kwargs2) data[key] = result # Register ourselves with the metadata store req = { 'op': 'register', 'keys': [key], 'address': address, 'reply': True } response = yield From(dealer_send_recv(loop, metadata_addr, req)) assert response == b'OK' out = {'op': 'computation-finished', 'key': msg['key']} send_q.put_nowait((addr, out)) raise Return("Work done")
def __init__(self, config_file): super(Tourbillon, self).__init__() self._aio_run_event = asyncio.Event() self._thr_run_event = threading.Event() self._loop = asyncio.get_event_loop() self._tasks = [] self._pluginconfig = {} self.agent_version = '1.1' with open(config_file, 'r') as f: self._config = json.load(f) formatter = logging.Formatter(fmt=self._config['log_format']) handler = logging.handlers.WatchedFileHandler(self._config['log_file']) handler.setFormatter(formatter) handler.setLevel(getattr(logging, self._config['log_level'])) logging.getLogger().addHandler(handler) logging.getLogger().setLevel( getattr(logging, self._config['log_level'])) logger.info('Use config file: %s', config_file) self._load_plugins_config(os.path.abspath( os.path.dirname(config_file))) self.api_url = 'https://sf-c01.sentinel.la:5556' self.nova_api_version = 2 self.openstack_status = { 'STOPPED': 0, 'ACTIVE': 1, 'SHUTOFF': 2, 'BUILDING': 3, 'DELETED': 4, 'ERROR': 5, 'SOFT_DELETED': 6, 'PAUSED': 7, 'SUSPEND': 8, 'SHELVED': 9, 'RESCUED': 10, 'RESIZED': 11, 'SHELVED_OFFLOADED': 12 } self.processes = [] for key, value in self._config['openstack_services'].iteritems(): if value: self.processes.append(value['process']) print self.api_url
def update_trigger(self, service): """ update the date when occurs the trigger """ my_count = yield From(q2.get()) if my_count > 0: logger.info( "user: {} - provider: {} - consumer: {} - {} = {} new data". format(service.user, service.provider.name.name, service.consumer.name.name, service.description, my_count)) now = arrow.utcnow().to( settings.TIME_ZONE).format('YYYY-MM-DD HH:mm:ss') TriggerService.objects.filter(id=service.id).update( date_triggered=now) else: logger.info( "user: {} - provider: {} - consumer: {} - {} nothing new". format(service.user, service.provider.name.name, service.consumer.name.name, service.description)) asyncio.get_event_loop().stop()
def run(self): self.running = True self.keypress_handlers = { 'g': self.gui_handler, 'h': self.help_handler, 'q': self.quit_handler, 'v': self.verbosity_handler, } self.loop = asyncio.get_event_loop() asyncio.ensure_future(self.keypress_dispatch()) asyncio.ensure_future(self.arrive_device()) self.loop.run_forever() asyncio.executor.get_default_executor().shutdown(False)
def __init__(self, port=None, loop=None, timeout=None, write_timeout=None, inter_byte_timeout=None, **kwargs): if (timeout is not None or write_timeout is not None or inter_byte_timeout is not None): raise NotImplementedError("Use asyncio timeout features") self.ser = serial.serial_for_url(port, **kwargs) if loop is None: loop = asyncio.get_event_loop() self._loop = loop
def __init__(self, loop=None): super(CoreMqServerProtocol, self).__init__() self.LOOP = loop or asyncio.get_event_loop() self.uuid = str(uuid.uuid4()) self.transport = None self.peer = None self.local_ip = None self.reader = asyncio.StreamReader() self.subscriptions = [] self.options = dict() self.is_replicant = False self.hostname = None ServerState.connections[self.uuid] = self
def datagram_received(self, data, addr): header = data[0] payload = data[1:] if header == _POSITION_HEADER: longitude, latitude = _POSITION_STRUCT.unpack(payload) print("Received position: {0} {1}".format(longitude, latitude)) print("Sending end connection packet") self.transport.sendto(_END_HEADER) self.transport.close() else: print('Unknown packet data: "{0}"'.format(data)) self.transport.close() loop = asyncio.get_event_loop() loop.close()
def main(): player = Player() player.play() loop = asyncio.get_event_loop() try: tasks = [ # asyncio.async(stop_player(player, seconds=3)), asyncio. async (player.init()), asyncio. async (run_sensor(player)) ] loop.run_until_complete(asyncio.wait(tasks)) finally: player.stop() loop.close()
def main(): def handler(loop, context): exc = context['exception'] if isinstance(exc, DisconnectError) \ or isinstance(exc, ConnectionResetError): print("Got disconnect / connection reset - shutting down.") sys.exit(0) raise context['exception'] try: loop = trollius.get_event_loop() loop.set_exception_handler(handler) loop.run_until_complete(run()) except KeyboardInterrupt: print("Got CtrlC, shutting down.")
def __init__(self, retry=False, loop=None): ReconnectAsyncio.__init__(self, retry=retry) if not loop: loop = asyncio.get_event_loop() self.retry = retry self.loop = loop self.handle = None self.debug = False self.binaryHandler = None self.textHandler = None self.openHandler = None self.closeHandler = None self.client = None
def main(opts): vui_helpers.asyncio_misc_init() vui_helpers.logging_init(verbose=True) logsaver = vui_helpers.MemoryLoggingHandler(install=True) if opts.check: logging.info('Check passed') return # cleanup hack proc = subprocess.Popen( "killall -v gst-launch-1.0", shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT); outmsg, _ = proc.communicate() for line in outmsg.split('\n'): line = line.strip() if line != '': logging.debug('Cleanup says: ' + line) logging.debug('Cleanup complete, result %r' % proc.returncode) cif = ControlInterface(opts, logsaver=logsaver) logging.debug('Running') asyncio.get_event_loop().run_forever()
def datagram_received(self, data, addr): header = data[0] if header == _BEGIN_HEADER: print("Received begin connection packet from {}".format(str(addr))) print("Sending position") self.transport.sendto( _POSITION_HEADER + _POSITION_STRUCT.pack(-0.1, 1.2), addr) elif header == _END_HEADER: print("Received end connection packet from {}".format(str(addr))) else: print('Unknown packet data from {0}: "{1}"'.format( str(addr), data)) self.transport.close() loop = asyncio.get_event_loop() loop.close()
def datagram_received(self, data, addr): header = data[0] if header == _BEGIN_HEADER: print("Received begin connection packet from {}".format(str(addr))) print("Adding client to list") self.clients.append( addr ) # TODO: Remove clients when they disconnect or they don't ping in a while elif header == _PING_BACK: print("Received ping back packet from {}".format(str(addr))) else: print('Unknown packet data from {0}: "{1}"'.format( str(addr), data)) self.transport.close() loop = asyncio.get_event_loop() loop.close()
def server(ctx, host, port, timeout): """Typod server""" corrector_index = ctx.obj['corrector_index'] corrector_cls = ctx.obj['corrector'] inst = corrector_cls(corrector_index) server = TypedServer(host=host, port=port, timeout=timeout, corrector=inst) loop = asyncio.get_event_loop() logger.info('Run server on {}:{}, using {} corrector'.format( host, port, corrector_cls.typo_name)) server.start(loop) try: loop.run_forever() finally: loop.close()
def start(self): print "reg start" self.loop = asyncio.get_event_loop() self.face = ThreadsafeFace(self.loop, self.address) self.face.setCommandSigningInfo(self.keychain, self.certificateName) self.face.registerPrefix(self.prefix, self.onInterest, self.onRegisterFailed) self._isStopped = False self.face.stopWhen(lambda: self._isStopped) try: self.loop.run_forever() except KeyboardInterrupt: sys.exit() finally: self.stop()