def open_connection(host=None, port=None, *, limit, loop=None, parser=None, **kwds): # XXX: parser is not used (yet) if loop is None: loop = asyncio.get_event_loop() reader = StreamReader(limit=limit, loop=loop) protocol = asyncio.StreamReaderProtocol(reader, loop=loop) transport, _ = yield from loop.create_connection(lambda: protocol, host, port, **kwds) writer = asyncio.StreamWriter(transport, protocol, reader, loop) return reader, writer
async def input(prefix=""): print(prefix, sep='', end='', flush=True) loop = asyncio.get_event_loop() reader = asyncio.StreamReader(loop=loop) await loop.connect_read_pipe( lambda: asyncio.StreamReaderProtocol(reader, loop=loop), sys.stdin ) data = bytes() while True: char = await reader.read(1) if not char or char == b"\n" or char == b"\0" or char == b"\04": break data += char return data.decode()
async def handshake(self): try: if (isLinux): self.pipeReader, self.pipeWriter = await asyncio.open_unix_connection( self.IPCPipe, loop=self.loop) else: self.pipeReader = asyncio.StreamReader(loop=self.loop) self.pipeWriter, _ = await self.loop.create_pipe_connection( lambda: asyncio.StreamReaderProtocol(self.pipeReader, loop=self.loop), self.IPCPipe) self.write(0, {"v": 1, "client_id": self.clientID}) await self.read() self.running = True except Exception as e: self.child.log("[HANDSHAKE] " + str(e))
async def handshake(self): if sys.platform == 'linux': self.sock_reader, self.sock_writer = await asyncio.open_unix_connection( self.ipc_path, loop=self.loop) elif sys.platform == 'win32': self.sock_reader = asyncio.StreamReader(loop=self.loop) reader_protocol = asyncio.StreamReaderProtocol(self.sock_reader, loop=self.loop) self.sock_writer, _ = await self.loop.create_pipe_connection( lambda: reader_protocol, self.ipc_path) self.send_data(0, {'v': 1, 'client_id': self.client_id}) data = await self.sock_reader.read(1024) code, length = struct.unpack('<ii', data[:8]) print( f'OP Code: {code}; Length: {length}\nResponse:\n{json.loads(data[8:].decode("utf-8"))}\n' )
async def test(): reader = asyncio.StreamReader(loop=loop) protocol = asyncio.StreamReaderProtocol(reader) transport, _ = await loop.connect_read_pipe( lambda: protocol, self.read_pipe ) logger = Logger.with_default_handlers() await logger.info("Xablau") logged_content = await reader.readline() self.assertEqual(logged_content, b"Xablau\n") transport.close() await logger.shutdown()
async def async_stdio(loop=None): if loop is None: loop = asyncio.get_event_loop() reader = asyncio.StreamReader() reader_protocol = asyncio.StreamReaderProtocol(reader) writer_transport, writer_protocol = \ await loop.connect_write_pipe( streams.FlowControlMixin, os.fdopen(0, 'wb')) writer = streams.StreamWriter(writer_transport, writer_protocol, None, loop) await loop.connect_read_pipe(lambda: reader_protocol, sys.stdin) return reader, writer
def handshake(self): if sys.platform == 'linux' or sys.platform == 'darwin': self.sock_reader, self.sock_writer = yield from asyncio.open_unix_connection( self.ipc_path, loop=self.loop) elif sys.platform == 'win32' or sys.platform == 'win64': self.sock_reader = asyncio.StreamReader(loop=self.loop) reader_protocol = asyncio.StreamReaderProtocol(self.sock_reader, loop=self.loop) try: self.sock_writer, _ = yield from self.loop.create_pipe_connection( lambda: reader_protocol, self.ipc_path) except FileNotFoundError: raise InvalidPipe self.send_data(0, {'v': 1, 'client_id': self.client_id}) data = yield from self.sock_reader.read(1024) code, length = struct.unpack('<ii', data[:8])
async def handle_data(self): """handle data via stdin and stdout""" loop = asyncio.get_running_loop() reader = asyncio.StreamReader(loop=loop) reader_protocol = asyncio.StreamReaderProtocol(reader, loop=loop) await loop.connect_read_pipe(lambda: reader_protocol, sys.stdin) writer_transport, writer_protocol = await loop.connect_write_pipe( lambda: asyncio.Protocol(), sys.stdout) writer = asyncio.StreamWriter(writer_transport, writer_protocol, None, loop) # list of item update methods, each of which should be an awaitable itemlist = list(item.update() for item in self.items) await asyncio.gather(self.reader(reader), self.writer(writer), *itemlist)
async def _connect(self) -> None: """ Connnect to the peer node. :return: None """ if self._connection_attempts == 1: with open(self.log_file, "r") as f: self.logger.debug( "Couldn't connect to libp2p p2p process, logs:") self.logger.debug(f.read()) raise Exception("Couldn't connect to libp2p p2p process") # TOFIX(LR) use proper exception self._connection_attempts -= 1 self.logger.debug("Attempt opening pipes {}, {}...".format( self.libp2p_to_aea_path, self.aea_to_libp2p_path)) self._libp2p_to_aea = os.open(self.libp2p_to_aea_path, os.O_RDONLY | os.O_NONBLOCK) try: self._aea_to_libp2p = os.open(self.aea_to_libp2p_path, os.O_WRONLY | os.O_NONBLOCK) except OSError as e: if e.errno == errno.ENXIO: logger.debug("Sleeping for {}...".format( self._connection_timeout)) await asyncio.sleep(self._connection_timeout) await self._connect() return else: raise e # pragma: no cover # setup reader assert (self._libp2p_to_aea != -1 and self._aea_to_libp2p != -1 and self._loop is not None), "Incomplete initialization." self._stream_reader = asyncio.StreamReader(loop=self._loop) self._reader_protocol = asyncio.StreamReaderProtocol( self._stream_reader, loop=self._loop) self._fileobj = os.fdopen(self._libp2p_to_aea, "r") await self._loop.connect_read_pipe(lambda: self.reader_protocol, self._fileobj) self.logger.info("Successfully connected to libp2p node!") self.multiaddrs = self.get_libp2p_node_multiaddrs() self.logger.info("My libp2p addresses: {}".format(self.multiaddrs))
async def interactionsocket(self): """ Manage keyboard interaction in interactive mode """ server = None if self.config['mammutfsd']['interaction'] == "stdin": # We try not to have to connectthe stdin reader, if not neccessary writer_transport, writer_protocol = await self.loop.connect_write_pipe( asyncio.streams.FlowControlMixin, sys.stdout) stdout_writer = asyncio.StreamWriter(writer_transport, writer_protocol, None, self.loop) stdin_reader = asyncio.StreamReader() reader_protocol = asyncio.StreamReaderProtocol(stdin_reader) await self.loop.connect_read_pipe(lambda: reader_protocol, sys.stdin) stdin_task = self.loop.create_task( self.handle_client(stdin_reader, stdout_writer)) self._writers.append(stdout_writer) else: stdin_task = None port = self.config['mammutfsd']['port'] server = await asyncio.start_server(self.handle_client, '127.0.0.1', int(port), loop=self.loop) # This will wait forever - or until a CancelledError is thrown! noevent = asyncio.Event(loop=self.loop) try: await noevent.wait() except asyncio.CancelledError: pass finally: if stdin_task: stdin_task.cancel() try: await stdin_task except asyncio.CancelledError: pass server.close()
async def get_reader(self, source=FFMPEG_STDOUT) -> asyncio.StreamReader: """Create and return streamreader.""" reader = asyncio.StreamReader(loop=self._loop) reader_protocol = asyncio.StreamReaderProtocol(reader) # Attach stream if source == FFMPEG_STDOUT: await self._loop.connect_read_pipe( lambda: reader_protocol, self._proc.stdout ) else: await self._loop.connect_read_pipe( lambda: reader_protocol, self._proc.stderr ) # Start reader return reader
def stdio(self): """ :return: (reader, writer) connected to stdin/stdout """ loop = asyncio.get_event_loop() reader = asyncio.StreamReader() reader_protocol = asyncio.StreamReaderProtocol(reader) writer_transport, writer_protocol = yield from loop.connect_write_pipe( asyncio.streams.FlowControlMixin, os.fdopen(1, 'wb')) writer = asyncio.StreamWriter(writer_transport, writer_protocol, None, loop) yield from loop.connect_read_pipe(lambda: reader_protocol, sys.stdin) return reader, writer
async def record(midi_in: IO, loop: AbstractEventLoop): recording = False new_notes = [] new_velocities = [] new_timings = [] global PLAYING prev_time = None reader = asyncio.StreamReader(loop=loop) reader_protocol = asyncio.StreamReaderProtocol(reader) await loop.connect_read_pipe(lambda: reader_protocol, midi_in) while True: command = await reader.read(1) if command == b'\xB0': # It's a control. Let's get the next two bytes command += await reader.read(2) if command == b'\xB0\x40\x7F': # Sustain pedal pressed recording = True PLAYING = False print('Recording') elif command == b'\xB0\x40\x00': # Sustain pedal released recording = False PLAYING = True if len(new_timings) > 0: print('Updating notes') update_notes(new_notes) update_velocities(new_velocities) update_timings(new_timings) else: print('Not enough notes played') new_notes = [] new_velocities = [] new_timings = [] prev_time = None if recording and command == b'\x90': # It's a note. Let's get the next two bytes command += await reader.read(2) # We only care if the key has been pressed. Ignore key release if command[2] > 0: if prev_time: new_timings.append(int((time() - prev_time) * 1000)) new_notes.append(command[1]) new_velocities.append(command[2]) prev_time = time()
async def main(url): loop = asyncio.get_running_loop() loop.add_signal_handler(signal.SIGINT, loop.stop) reader = asyncio.StreamReader() protocol = asyncio.StreamReaderProtocol(reader) await loop.connect_read_pipe(lambda: protocol, sys.stdin) async with aiohttp.ClientSession() as session: async with session.ws_connect(url, autoclose=False, autoping=False) as ws: await asyncio.gather(input_task(loop, reader, ws), ws_loop(ws)) try: loop.run_forever() finally: loop.close()
def read_file(f): ": Lecture de fichier ligne par ligne" reader = asyncio.StreamReader() reader_protocol = asyncio.StreamReaderProtocol(reader) asyncio.get_event_loop().connect_read_pipe(lambda: reader_protocol, f) yield from asyncio.get_event_loop().connect_read_pipe( lambda: reader_protocol, f) log("ReadfileStart") while True: line = yield from reader.readline() if line == b'': break line = line.decode("utf-8").strip() log("Readfile:{}".format(line)) asyncio.ensure_future(md5sum(line)) # Ajoute une tâche log("ReadfileStop")
async def connect(self, timeout: float = PIPE_CONN_TIMEOUT) -> bool: """ Connect to the other end of the pipe :param timeout: timeout before failing :return: connection success """ if self._loop is None: self._loop = asyncio.get_event_loop() self._connection_timeout = timeout / PIPE_CONN_ATTEMPTS if timeout > 0 else 0 if self._connection_attempts <= 1: # pragma: no cover return False self._connection_attempts -= 1 self.logger.debug("Attempt opening pipes {}, {}...".format( self._in_path, self._out_path)) self._in = os.open(self._in_path, os.O_RDONLY | os.O_NONBLOCK | os.O_SYNC) try: self._out = os.open(self._out_path, os.O_WRONLY | os.O_NONBLOCK) except OSError as e: # pragma: no cover if e.errno == errno.ENXIO: self.logger.debug("Sleeping for {}...".format( self._connection_timeout)) await asyncio.sleep(self._connection_timeout) return await self.connect(timeout) raise e # setup reader enforce( self._in != -1 and self._out != -1 and self._loop is not None, "Incomplete initialization.", ) self._stream_reader = asyncio.StreamReader(loop=self._loop) self._reader_protocol = asyncio.StreamReaderProtocol( self._stream_reader, loop=self._loop) self._fileobj = os.fdopen(self._in, "r") await self._loop.connect_read_pipe(lambda: self.__reader_protocol, self._fileobj) return True
async def open_connection(host: str, port: int) -> [asyncio.StreamReader, asyncio.StreamWriter]: """ A wrapper for asyncio.open_connection() returning a (reader, writer) pair. :param host: hostname of the peer :param port: port to connect to :returns: `StreamReader` and `StreamWriter` instances to read and send messages. """ loop = asyncio.events.get_event_loop() reader = asyncio.StreamReader(loop=loop) protocol = asyncio.StreamReaderProtocol(reader, loop=loop) transport, _ = await loop.create_connection( lambda: protocol, host, port) transport.set_write_buffer_limits(0) # let the OS handle buffering writer = asyncio.StreamWriter(transport, protocol, reader, loop) return reader, writer
async def open_pipe_connection(path=None, *, loop=None, limit=DEFAULT_LIMIT, **kwargs): """ Connect to a server using a Windows named pipe. """ path = path.replace('/', '\\') loop = loop or asyncio.get_event_loop() reader = asyncio.StreamReader(limit=limit, loop=loop) protocol = asyncio.StreamReaderProtocol(reader, loop=loop) transport, _ = await loop.create_pipe_connection(lambda: protocol, path, **kwargs) writer = asyncio.StreamWriter(transport, protocol, reader, loop) return reader, writer
async def test_channel(): buffer = io.BytesIO() loop = asyncio.get_event_loop() reader = asyncio.StreamReader(loop=loop) await loop.connect_read_pipe( lambda: asyncio.StreamReaderProtocol(reader, loop=loop), buffer ) writer_transport, writer_protocol = await loop.connect_write_pipe( lambda: asyncio.streams.FlowControlMixin(loop=loop), buffer ) writer = asyncio.streams.StreamWriter( writer_transport, writer_protocol, None, loop) return reader, writer
async def worker(loop, handle_row): stdin = asyncio.StreamReader() await loop.connect_read_pipe(lambda: asyncio.StreamReaderProtocol(stdin), sys.stdin) try: while True: lines = 0 size = 0 async for row, line in stream_json(stdin): lines += 1 size += len(line) output = handle_row(row, line) if output: print(output, file=sys.stderr) sys.stdout.buffer.write(struct.pack("QQ", lines, size)) sys.stdout.flush() except EOFError: pass
async def open_unix_connection(address, *, limit, loop=None, parser=None, **kwds): # XXX: parser is not used (yet) if loop is not None and sys.version_info >= (3, 8): warnings.warn("The loop argument is deprecated", DeprecationWarning) reader = StreamReader(limit=limit) protocol = asyncio.StreamReaderProtocol(reader) transport, _ = await get_event_loop().create_unix_connection( lambda: protocol, address, **kwds) writer = asyncio.StreamWriter(transport, protocol, reader, loop=get_event_loop()) return reader, writer
async def read_progress(): i = 0 reader = asyncio.StreamReader() protocol = asyncio.StreamReaderProtocol(reader) await state.event_loop.connect_read_pipe( lambda: protocol, os.fdopen(self.progress_stream)) while not self.proc.returncode: line = await reader.readline() i += 1 if i % self.progress_sample: continue if not line: break line = line.strip() if not line: continue await self.update_progress_line( line.decode("utf-8"))
async def run(port): loop = asyncio.get_event_loop() # out command queue ans_queue = asyncio.Queue() stdreader = None stdwriter = None # stdio initiation # NOTE: os.fdopen(0, "wb") will not works in pipe # os.fdopen(sys.stdout, "wb") may crash print() writer_transport, writer_protocol = await loop.connect_write_pipe( FlowControlMixin, os.fdopen(sys.stdout.fileno(), "wb")) stdwriter = StreamWriter(writer_transport, writer_protocol, None, loop) stdreader = asyncio.StreamReader() reader_protocol = asyncio.StreamReaderProtocol(stdreader) await loop.connect_read_pipe(lambda: reader_protocol, sys.stdin.buffer) server_coro = None async def onclient(reader, writer): # read from socket async def coro_reader(): while True: data = await stdreader.readline() if not data: if server_coro: server_coro.cancel() break writer.write(data) await writer.drain() task = asyncio.ensure_future(coro_reader()) while True: data = await reader.readline() if not data: break stdwriter.write(data) await stdwriter.drain() task.cancel() server_coro = asyncio.start_server(onclient, port=port, backlog=1) sock_server = await server_coro await sock_server.wait_closed()
async def main(): reader = asyncio.StreamReader() await asyncio.get_event_loop().connect_read_pipe( lambda: asyncio.StreamReaderProtocol(reader), sys.stdin) decoder = codecs.getincrementaldecoder('utf_8')() parser = Parser() while True: byte = await reader.read(1) if not byte: break char = decoder.decode(byte) if char: if char == '\n': char = EOF else: print('Input char: "%s"' % repr(char)) await parser.asyncFeed(char)
async def handshake(self): if sys.platform == 'linux' or sys.platform == 'darwin': self.sock_reader, self.sock_writer = await asyncio.open_unix_connection( self.ipc_path, loop=self.loop) elif sys.platform == 'win32' or sys.platform == 'win64': self.sock_reader = asyncio.StreamReader(loop=self.loop) reader_protocol = asyncio.StreamReaderProtocol(self.sock_reader, loop=self.loop) try: self.sock_writer, _ = await self.loop.create_pipe_connection( lambda: reader_protocol, self.ipc_path) except FileNotFoundError: raise InvalidPipe self.send_data(0, {'v': 1, 'client_id': self.client_id}) preamble = await self.sock_reader.read(8) code, length = struct.unpack('<ii', preamble) data = await self.sock_reader.read(length) if self._events_on: self.sock_reader.feed_data = self.on_event
async def __async_open_fds(self): try: r_file = os.fdopen(self.infd, 'rb') w_file = os.fdopen(self.outfd, 'wb') reader = asyncio.StreamReader(loop=self.loop) r_protocol = asyncio.StreamReaderProtocol(reader) await self.loop.connect_read_pipe(lambda: r_protocol, r_file) w_transport, w_protocol = await self.loop.connect_write_pipe(asyncio.streams.FlowControlMixin, w_file) writer = asyncio.StreamWriter(transport=w_transport, reader=None, loop=self.loop, protocol=w_protocol) return reader, writer except Exception as e: print("Failed to open file descriptor pair:", e, file=sys.stderr) traceback.print_exc(file=sys.stderr) self.kill()
async def mc2tg(self) -> None: loop = asyncio.get_event_loop() reader = asyncio.StreamReader() read_protocol = asyncio.StreamReaderProtocol(reader) _, _ = await loop.connect_read_pipe( lambda: read_protocol, sys.stdin.buffer) sys.stdout = os.fdopen(1, mode='w', buffering=1) while not reader.at_eof(): lineb = await reader.readline() line = lineb.decode('utf-8', errors='replace').rstrip() if m := self.msg_re.match(line): logging.info('MC msg: %s', line) try: reply = self.process_msg(m.group(1)) if reply is not None: self.tg_q.put_nowait(reply) except Exception: logging.exception('error processing minecraft message %s', line)
async def get_urls(loop, stream): reader = asyncio.StreamReader(loop=loop) reader_protocol = asyncio.StreamReaderProtocol(reader) await loop.connect_read_pipe(lambda: reader_protocol, stream) while True: line = await reader.readline() if not line: break line = line.decode('utf-8') if line.startswith('{'): # interpret as json object obj = json.loads(line) url = obj['url'].strip() else: url = line.strip() yield url
async def stdio(limit=_DEFAULT_LIMIT, loop=None): """Create async standard in/out handlers.""" if loop is None: loop = asyncio.get_event_loop() if sys.platform == "win32": return _win32_stdio(loop) reader = asyncio.StreamReader(limit=limit, loop=loop) reader_protocol = asyncio.StreamReaderProtocol(reader, loop=loop) writer_transport, writer_protocol = await loop.connect_write_pipe( lambda: asyncio.streams.FlowControlMixin(loop=loop), os.fdopen(1, "wb")) writer = asyncio.streams.StreamWriter(writer_transport, writer_protocol, None, loop) await loop.connect_read_pipe(lambda: reader_protocol, sys.stdin) return reader, writer
async def _loop(self, worker): """NOTE: worker is a class""" self.worker = worker(self) funcs = { i[0]: (i[1].__doc__ or '') + '\nsignature:\n' + _format_parameter(inspect.signature(i[1])) for i in inspect.getmembers(worker, predicate=inspect.isfunction) if not i[0].startswith('_') } # completion register self._print({'op': 'completion', 'args': [funcs]}) loop = asyncio.get_event_loop() is_posix = os.name == 'posix' if is_posix: reader = asyncio.StreamReader() protocol = asyncio.StreamReaderProtocol(reader) await loop.connect_read_pipe(lambda: protocol, sys.stdin) # used in stdio server while True: if is_posix: # NOTE it doesn't work on on Windows (at least thinpc). data = await reader.readline() else: data = await loop.run_in_executor(None, sys.stdin.readline) if len(data.strip()) == 0: continue try: data = json.loads(data) except KeyboardInterrupt: sys.exit(-2) except: self._exception('invalid data: %s' % data, traceback.format_exc()) continue task = asyncio.create_task(self._handle(data)) task.add_done_callback(self._handle_fut_ex)