def _handler(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter): logger.debug('handle') while True: cmd = Command.unpack((yield from reader.readexactly(len(Command)))) method = cmd.key.lower() if method not in self.implements: yield from self.response( writer, Code.INTERNAL_SERVER_ERROR, bytes('ERROR : method `%s` not implemented\n' % method.strip()) ) continue args_length = Types.ulong.unpack(( yield from reader.readexactly(len(Types.ulong)) )) kwargs = msgpack.loads((yield from reader.readexactly(args_length))) try: code, result = yield from asyncio.coroutine(getattr(self, method))(**kwargs) yield from self.response(writer, code, result) except Exception as e: yield from self.response(writer, Code.INTERNAL_SERVER_ERROR, bytes('ERROR : %s' % e)) logger.exception("Exception when handling request %r")
def handle_stream(reader: StreamReader, writer: StreamWriter): addr = writer.get_extra_info('peername') print("Connect from %r" % (addr, )) labels_list = load_labels('labels/labels.txt') load_graph('model/my_frozen_graph_okyonsei.pb') model = load_model() count = 0 detected_count = 0 last_data_dict = dict() try: while True: count += 1 data = yield from reader.readexactly(8) user_id, body_len = struct.unpack("!II", data) data = yield from reader.readexactly(body_len) last_data = last_data_dict.get(user_id) last_data_dict[user_id] = data if last_data is None: continue print(count) wav_data, np_data = convert_pcm_to_wav(last_data + data) with open(f'data/{count:06}.wav', 'wb') as fout: fout.write(wav_data) detected, prediction = run_graph(wav_data, labels_list, 3) if detected: if detected_count: detected_count = 0 continue try: start_p = max(np_data.argmax() - 300, 0) name = find_who(model, np_data[start_p:]) msg = f'안녕하세요. {name} [정확도: {int(prediction * 100)} %]' msg_encoded = str.encode(msg) header = struct.pack("!II", user_id, len(msg_encoded)) writer.write(header + msg_encoded) yield from writer.drain() detected_count += 1 except Exception: pass else: detected_count = 0 except Exception as e: print(e) writer.close()
async def tcp_recv(reader: asyncio.StreamReader, delimiter: bytes = b'\n', timeout=None) -> str: """ Receives string result. Handle Incomplete error on your own. """ try: data_length: bytes = await asyncio.wait_for( reader.readuntil(delimiter), timeout=timeout) except TypeError: msg = "tcp_recv: expects" if not isinstance(delimiter, bytes): print(msg, f"<bytes> for delimiter, got {type(delimiter)} instead.") if not isinstance(timeout, Number) and timeout is not None: print(msg, f"<numbers> for delimiter, got {type(timeout)} instead.") raise # why this is ignored??? why I am getting ConnReset directly?? except ConnectionResetError: print("tcp_recv: Disconnected from Server.") raise except asyncio.IncompleteReadError: print("tcp_recv: Incomplete read error.") raise data = await asyncio.wait_for(reader.readexactly( int(data_length.strip(delimiter))), timeout=timeout) return data.decode()
async def _connect_streams(reader: asyncio.StreamReader, writer: asyncio.StreamWriter, queue: "asyncio.Queue[int]", token: CancelToken) -> None: try: while not token.triggered: if reader.at_eof(): break try: size = queue.get_nowait() except asyncio.QueueEmpty: await asyncio.sleep(0) continue data = await token.cancellable_wait(reader.readexactly(size)) writer.write(data) queue.task_done() await token.cancellable_wait(writer.drain()) except OperationCancelled: pass finally: writer.write_eof() if reader.at_eof(): reader.feed_eof()
class HttpBodyReader(): _expect_sent = None _waiting = None def __init__(self, headers, parser, transport, **kw): self.headers = headers self.parser = parser self.reader = StreamReader(**kw) self.reader.set_transport(transport) self.feed_data = self.reader.feed_data self.feed_eof = self.reader.feed_eof def waiting_expect(self): '''``True`` when the client is waiting for 100 Continue. ''' if self._expect_sent is None: if (not self.reader.at_eof() and self.headers.has('expect', '100-continue')): return True self._expect_sent = '' return False def can_continue(self): if self.waiting_expect(): if self.parser.get_version() < (1, 1): raise HttpException(status=417) else: msg = '%s 100 Continue\r\n\r\n' % http_protocol(self.parser) self._expect_sent = msg self.reader._transport.write(msg.encode(DEFAULT_CHARSET)) def fail(self): if self.waiting_expect(): raise HttpException(status=417) def read(self, n=-1): self.can_continue() return self.reader.read(n=n) def readline(self): self.can_continue() return self.reader.readline() def readexactly(self, n): self.can_continue() return self.reader.readexactly(n)
async def wait_handshake(self, reader: asyncio.StreamReader, protocol: TCPProtocolV1) -> typing.Optional[Node]: bs = b'' try: bs = await asyncio.wait_for( reader.readexactly(protocol.handshake_recv_len), timeout=protocol.handshake_timeout, ) except asyncio.TimeoutError: self.logger.error('recv handshake from remote timeout', ) return None except asyncio.IncompleteReadError as ex: self.logger.error( 'recv handshake receive early EOF, got: %s', b2a_hex(ex.partial), ) return None remote = protocol.parse_handshake(bs) return remote
async def _handle_client(self, client_reader: StreamReader, client_writer: StreamWriter): peer = client_writer.get_extra_info('peername') rospy.loginfo(f"Client at {peer}") data = await asyncio.wait_for(client_reader.readexactly(34), timeout=30) public_key, model = _parse_header(data) self.sessions[peer] = { "public": public_key, "model": model, "buffer": bytearray(), "measurement": Measurement() } rospy.loginfo(f"Welcome to the party: ({public_key},{model})") try: while True: try: # Timeout is kinda big but it covers the maximum timeout for SDS011 sensor # and gets rid of dropped connections data = await asyncio.wait_for(client_reader.read(128), timeout=2000.0) self.sessions[peer]["buffer"].extend(data) except: rospy.logwarn("Timeout") return if data: status, measurement = self._parse_frame(peer) if status: self.sessions[peer]["measurement"] = measurement rospy.logdebug(measurement) else: rospy.logwarn("Received no data") # exit echo loop and disconnect return except Exception as e: rospy.logwarn(e)
async def receive_connection(cls, reader: asyncio.StreamReader, writer: asyncio.StreamWriter, private_key: datatypes.PrivateKey, token: CancelToken) -> TransportAPI: try: msg = await token.cancellable_wait( reader.readexactly(ENCRYPTED_AUTH_MSG_LEN), timeout=REPLY_TIMEOUT, ) except asyncio.IncompleteReadError as err: raise HandshakeFailure from err try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, private_key, ) except DecryptionError as non_eip8_err: # Try to decode as EIP8 msg_size = big_endian_to_int(msg[:2]) remaining_bytes = msg_size - ENCRYPTED_AUTH_MSG_LEN + 2 try: msg += await token.cancellable_wait( reader.readexactly(remaining_bytes), timeout=REPLY_TIMEOUT, ) except asyncio.IncompleteReadError as err: raise HandshakeFailure from err try: ephem_pubkey, initiator_nonce, initiator_pubkey = decode_authentication( msg, private_key, ) except DecryptionError as eip8_err: raise HandshakeFailure( f"Failed to decrypt both EIP8 handshake: {eip8_err} and " f"non-EIP8 handshake: {non_eip8_err}") else: got_eip8 = True else: got_eip8 = False peername = writer.get_extra_info("peername") if peername is None: socket = writer.get_extra_info("socket") sockname = writer.get_extra_info("sockname") raise HandshakeFailure( "Received incoming connection with no remote information:" f"socket={repr(socket)} sockname={sockname}") ip, socket, *_ = peername remote_address = Address(ip, socket) cls.logger.debug("Receiving handshake from %s", remote_address) initiator_remote = Node(initiator_pubkey, remote_address) responder = HandshakeResponder(initiator_remote, private_key, got_eip8, token) responder_nonce = secrets.token_bytes(HASH_LEN) auth_ack_msg = responder.create_auth_ack_message(responder_nonce) auth_ack_ciphertext = responder.encrypt_auth_ack_message(auth_ack_msg) # Use the `writer` to send the reply to the remote writer.write(auth_ack_ciphertext) await token.cancellable_wait(writer.drain()) # Call `HandshakeResponder.derive_shared_secrets()` and use return values to create `Peer` aes_secret, mac_secret, egress_mac, ingress_mac = responder.derive_secrets( initiator_nonce=initiator_nonce, responder_nonce=responder_nonce, remote_ephemeral_pubkey=ephem_pubkey, auth_init_ciphertext=msg, auth_ack_ciphertext=auth_ack_ciphertext) transport = cls( remote=initiator_remote, private_key=private_key, reader=reader, writer=writer, aes_secret=aes_secret, mac_secret=mac_secret, egress_mac=egress_mac, ingress_mac=ingress_mac, ) return transport
def handler(self, reader: StreamReader, writer: StreamWriter) -> Generator[Any, None, None]: data: Optional[bytes] try: host, port = writer.get_extra_info("peername") version: Optional[Version] = None cow_version: Optional[Version] = None self.log.info("Incoming connection from %s:%s." % (host, port)) # Initial handshake writer.write( struct.pack(">QQH", self.INIT_PASSWD, self.CLISERV_MAGIC, self.NBD_HANDSHAKE_FLAGS)) yield from writer.drain() data = yield from reader.readexactly(4) try: client_flags = struct.unpack(">L", data)[0] except struct.error: raise IOError("Handshake failed, disconnecting.") # We support both fixed and unfixed new-style negotiation. # The specification actually allows a client supporting "fixed" to not set this bit in its reply ("SHOULD"). fixed = (client_flags & self.NBD_FLAG_FIXED_NEWSTYLE) != 0 if not fixed: self.log.warning( "Client did not signal fixed new-style handshake.") client_flags ^= self.NBD_FLAG_FIXED_NEWSTYLE if client_flags > 0: raise IOError( "Handshake failed, unknown client flags %s, disconnecting." % (client_flags)) # Negotiation phase while True: header = yield from reader.readexactly(16) try: (magic, opt, length) = struct.unpack(">QLL", header) except struct.error: raise IOError( "Negotiation failed: Invalid request, disconnecting.") if magic != self.CLISERV_MAGIC: raise IOError("Negotiation failed: Bad magic number: %s." % magic) if length: data = yield from reader.readexactly(length) if len(data) != length: raise IOError( "Negotiation failed: %s bytes expected." % length) else: data = None self.log.debug("[%s:%s]: opt=%s, length=%s, data=%s" % (host, port, opt, length, data)) if opt == self.NBD_OPT_EXPORTNAME: if not data: raise IOError( "Negotiation failed: No export name was provided.") version_uid = VersionUid(data.decode("ascii")) if version_uid not in [ v.uid for v in self.store.get_versions() ]: if not fixed: raise IOError( "Negotiation failed: Unknown export name.") writer.write( struct.pack(">QLLL", self.NBD_OPT_REPLY_MAGIC, opt, self.NBD_REP_ERR_UNSUP, 0)) yield from writer.drain() continue self.log.info("[%s:%s] Negotiated export: %s." % (host, port, version_uid.v_string)) # We have negotiated a version and it will be used until the client disconnects version = self.store.get_versions( version_uid=version_uid)[0] self.store.open(version) self.log.info("[%s:%s] Version %s has been opened." % (host, port, version.uid)) export_flags = self.NBD_EXPORT_FLAGS if self.read_only: export_flags |= self.NBD_FLAG_READ_ONLY self.log.info("[%s:%s] Export is read only." % (host, port)) else: self.log.info("[%s:%s] Export is read/write." % (host, port)) # In case size is not a multiple of 4096 we extend it to the the maximum support block # size of 4096 size = math.ceil(version.size / 4096) * 4096 writer.write(struct.pack('>QH', size, export_flags)) writer.write(b"\x00" * 124) yield from writer.drain() # Transition to transmission phase break elif opt == self.NBD_OPT_LIST: # Don't use version as a loop variable so we don't conflict with the outer scope usage for list_version in self.store.get_versions(): list_version_encoded = list_version.uid.v_string.encode( "ascii") writer.write( struct.pack(">QLLL", self.NBD_OPT_REPLY_MAGIC, opt, self.NBD_REP_SERVER, len(list_version_encoded) + 4)) writer.write( struct.pack(">L", len(list_version_encoded))) writer.write(list_version_encoded) yield from writer.drain() writer.write( struct.pack(">QLLL", self.NBD_OPT_REPLY_MAGIC, opt, self.NBD_REP_ACK, 0)) yield from writer.drain() elif opt == self.NBD_OPT_ABORT: writer.write( struct.pack(">QLLL", self.NBD_OPT_REPLY_MAGIC, opt, self.NBD_REP_ACK, 0)) yield from writer.drain() raise _NbdServerAbortedNegotiationError() else: # We don't support any other option if not fixed: raise IOError("Unsupported option: %s." % (opt)) writer.write( struct.pack(">QLLL", self.NBD_OPT_REPLY_MAGIC, opt, self.NBD_REP_ERR_UNSUP, 0)) yield from writer.drain() # Transmission phase while True: header = yield from reader.readexactly(28) try: (magic, cmd, handle, offset, length) = struct.unpack(">LLQQL", header) except struct.error: raise IOError("Invalid request, disconnecting.") if magic != self.NBD_REQUEST_MAGIC: raise IOError("Bad magic number, disconnecting.") cmd_flags = cmd & self.NBD_CMD_MASK_FLAGS cmd = cmd & self.NBD_CMD_MASK_COMMAND self.log.debug( "[%s:%s]: cmd=%s, cmd_flags=%s, handle=%s, offset=%s, len=%s" % (host, port, cmd, cmd_flags, handle, offset, length)) # We don't support any command flags if cmd_flags != 0: yield from self.nbd_response(writer, handle, error=self.EINVAL) continue if cmd == self.NBD_CMD_DISC: self.log.info("[%s:%s] disconnecting" % (host, port)) break elif cmd == self.NBD_CMD_WRITE: data = yield from reader.readexactly(length) if len(data) != length: raise IOError("%s bytes expected, disconnecting." % length) if self.read_only: yield from self.nbd_response(writer, handle, error=self.EPERM) continue if not cow_version: cow_version = self.store.get_cow_version(version) try: self.store.write(cow_version, offset, data) except Exception as exception: self.log.error( "[%s:%s] NBD_CMD_WRITE: %s\n%s." % (host, port, exception, traceback.format_exc())) yield from self.nbd_response(writer, handle, error=self.EIO) continue yield from self.nbd_response(writer, handle) elif cmd == self.NBD_CMD_READ: try: data = self.store.read(version, cow_version, offset, length) except Exception as exception: self.log.error( "[%s:%s] NBD_CMD_READ: %s\n%s." % (host, port, exception, traceback.format_exc())) yield from self.nbd_response(writer, handle, error=self.EIO) continue yield from self.nbd_response(writer, handle, data=data) elif cmd == self.NBD_CMD_FLUSH: # Return success right away when we're read only or when we haven't written anything yet. if self.read_only or not cow_version: yield from self.nbd_response(writer, handle) continue try: self.store.flush(cow_version) except Exception as exception: self.log.error( "[%s:%s] NBD_CMD_FLUSH: %s\n%s." % (host, port, exception, traceback.format_exc())) yield from self.nbd_response(writer, handle, error=self.EIO) continue yield from self.nbd_response(writer, handle) else: self.log.warning("[%s:%s] Unknown cmd %s, ignoring." % (host, port, cmd)) yield from self.nbd_response(writer, handle, error=self.EINVAL) continue except _NbdServerAbortedNegotiationError: self.log.info("[%s:%s] Client aborted negotiation." % (host, port)) except (asyncio.IncompleteReadError, IOError) as exception: self.log.error("[%s:%s] %s" % (host, port, exception)) finally: if cow_version: self.store.fixate(cow_version) if version: self.store.close(version) writer.close()
async def receivePacketStream( peer_site: str, intake: asyncio.StreamReader, pkt_sink: PacketSink, eos: asyncio.Future, ): """ Receive all packets being streamed to the specified intake stream The caller is responsible to close the intake/outlet streams anyway appropriate, but only after eos is signaled. """ readahead = b"" async def parse_hdr(): nonlocal readahead while True: if len(readahead) < 1: readahead = await read_stream(eos, intake.read(MAX_HEADER_LENGTH)) if readahead is EndOfStream: return EndOfStream # reached end-of-stream if not readahead: return EndOfStream # reached end-of-stream if b"["[0] != readahead[0]: logger.error(f"readahead: {readahead!r}") raise EdhPeerError(peer_site, "missing packet header") hdr_end_pos = readahead.find(b"]") if hdr_end_pos < 0: readmore = await read_stream(eos, intake.read(MAX_HEADER_LENGTH)) if readmore is EndOfStream: raise RuntimeError("premature end of packet stream") readahead += readmore continue # got a full packet header hdr = readahead[1:hdr_end_pos].decode("utf-8") readahead = readahead[hdr_end_pos + 1:] plls, dir_ = hdr.split("#", 1) payload_len = int(plls) return payload_len, dir_ try: while True: hdr = await parse_hdr() if hdr is EndOfStream: # normal eos, try mark and done if not eos.done(): eos.set_result(EndOfStream) break payload_len, dir_ = hdr more2read = payload_len - len(readahead) if more2read == 0: payload = readahead readahead = b"" elif more2read > 0: more_payload = await read_stream(eos, intake.readexactly(more2read)) if more_payload is EndOfStream: raise RuntimeError("premature end of packet stream") payload = readahead + more_payload readahead = b"" else: # readahead contains more than this packet payload = readahead[:more2read] readahead = readahead[more2read:] await pkt_sink(Packet(dir_, payload)) except Exception as exc: if not eos.done(): eos.set_exception(exc)