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)
