コード例 #1
0
    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")
コード例 #2
0
ファイル: main.py プロジェクト: heyuimd/keyword_spotting
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()
コード例 #3
0
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()
コード例 #4
0
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()
コード例 #5
0
ファイル: formdata.py プロジェクト: successtest9/pulsar
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)
コード例 #6
0
 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
コード例 #7
0
    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)
コード例 #8
0
ファイル: transport.py プロジェクト: s0b0lev/trinity
    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
コード例 #9
0
    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()
コード例 #10
0
ファイル: mproto.py プロジェクト: complyue/hastalk
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)