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)
