class ControlledConnection:
def __init__(self, data, limit, leave_open=False):
self._reader = StreamReader(limit)
self._reader.feed_data(data)
if not leave_open:
self._reader.feed_eof()
self._mock_write_data = b""
def get_mock_write_data(self):
return self._mock_write_data
async def read(self, size):
try:
return await self._reader.read(min(size, 100))
except Exception:
raise MalformedDataError
async def readuntil(self, delim):
try:
return await self._reader.readuntil(delim)
except Exception:
raise MalformedDataError
async def readexactly(self, amount):
try:
return await self._reader.readexactly(amount)
except Exception:
raise MalformedDataError
async def write(self, data):
self._mock_write_data += data
def close(self):
pass
def make(data, *, limit=None):
if limit is not None:
r = StreamReader(loop=event_loop, limit=limit)
else:
r = StreamReader(loop=event_loop)
w = mock_stream_writers()
r.feed_data(data)
r.feed_eof()
return r, w
def make(data, *, limit=None, exc=None):
if limit is not None:
r = StreamReader(loop=event_loop, limit=limit)
else:
r = StreamReader(loop=event_loop)
w = mock_stream_writers()
r.feed_data(data)
if exc is not None:
r.set_exception(exc)
else:
r.feed_eof()
return r, w
def stream_reader_writer_slots_before_units(hass):
"""Create a StreamReader and fill it with connection messages."""
reader = StreamReader()
reader.feed_data(
b"\x1b[H\x1b[2JWelcome to the Folding@home Client command server.\n")
reader.feed_data(b"OK\n")
reader.feed_data(b"> \n")
reader.feed_data(b"> \n")
reader.feed_data(b"> \n")
reader.feed_data(b"> \n")
reader.feed_data(b"PyON 1 slots\n")
reader.feed_data(
b'[{"id": "00", "status": "READY", "description": "cpu: 3", "options": {"idle": "false"}, "reason": "", "idle": False}]\n'
)
reader.feed_data(b"---\n")
reader.feed_data(b"> \n")
reader.feed_data(b"> \n")
reader.feed_data(b"> \n")
reader.feed_data(b"> \n")
reader.feed_data(b"PyON 1 units\n")
reader.feed_data(b"""[{
"id": "00",
"state": "RUNNING",
"error": "NO_ERROR",
"project": 11777,
"run": 0,
"clone": 17250,
"gen": 0,
"core": "0x22",
"unit": "0x00000003287234c95e774a8488c5d4ea",
"percentdone": "72.51%",
"eta": "1 hours 04 mins",
"ppd": "359072",
"creditestimate": "58183",
"waitingon": "",
"nextattempt": "0.00 secs",
"timeremaining": "8.08 days",
"totalframes": 100,
"framesdone": 72,
"assigned": "2020-03-28T08: 33: 55Z",
"timeout": "2020-03-29T08: 33: 55Z",
"deadline": "2020-04-05T13: 21: 54Z",
"ws": "40.114.52.201",
"cs": "13.82.98.119",
"attempts": 0,
"slot": "00",
"tpf": "2 mins 20 secs",
"basecredit": "9405"
}
]\n""")
reader.feed_data(b"---\n")
reader.feed_data(b"> \n")
reader.feed_data(b"> \n")
reader.feed_data(b"> \n")
reader.feed_data(b"> \n")
reader.feed_eof()
stream_writer = AsyncMock()
stream_writer.close = MagicMock()
return (reader, stream_writer)
class ControlledConnection:
def __init__(self, limit=100000000):
self._reader = StreamReader(limit)
self._mock_write_data = b""
self._closed = False
self._closed_by_us = False
def _feed_data(self, data):
self._reader.feed_data(data)
def _feed_eof(self):
self._reader.feed_eof()
def _get_mock_write_data(self):
return self._mock_write_data
def _check_eof(self):
if self._reader.at_eof():
self._closed = True
async def read(self, size):
self._check_eof()
try:
return await self._reader.read(min(size, 100))
except Exception:
self._closed = True
raise MalformedDataError
async def readuntil(self, delim):
self._check_eof()
try:
return await self._reader.readuntil(delim)
except Exception:
self._closed = True
raise MalformedDataError
async def readexactly(self, amount):
self._check_eof()
try:
return await self._reader.readexactly(amount)
except Exception:
self._closed = True
raise MalformedDataError
async def write(self, data):
self._mock_write_data += data
return not self._closed
async def add_header(self, header):
pass
def close(self):
self._closed = True
self._closed_by_us = True
async def wait_closed(self):
while not self._closed:
await asyncio.sleep(1)
def closed_by_us(self):
return self._closed_by_us
class HTTPProtocol(asyncio.Protocol):
request_cls = Request
def __init__(self, app=None):
self.app = app
self.router = app.router
self.transport = None
self.reader = None
self.writer = None
self._request: Request = None
self.keep_alive = False
self.loop = asyncio.get_event_loop()
@property
def request(self):
if self._request is None:
self._request = self.request_cls()
self._request.remote_addr = self.remoteaddr
return self._request
@cachedproperty
def remoteaddr(self):
return '{}:{}'.format(*self.transport.get_extra_info('peername'))
def _del_req(self):
self._request = None
def connection_made(self, transport):
self.reader = StreamReader(loop=self.loop)
self.transport = transport
self.request.remote_addr = self.remoteaddr
self.reader.set_transport(transport)
self.loop.create_task(self.parse())
def data_received(self, data):
self.reader.feed_data(data)
# noinspection PyProtectedMember
async def parse(self):
while True:
req = self.request
line = await self.reader.readline()
if not req._f:
req._f = True
_ = _parse_first_line(line)
if not _ or len(_) != 4:
req.parse_error = BadRequestError()
return await self.finish()
req.method, req.path, req.query_string, req.hv = _
else:
if req._body_length:
req._body_lines.append(line)
req._body_length += len(line)
if req._body_length > req.content_length + 1:
raise BadRequestError
elif req._body_length == req.content_length + 1:
return await self.finish()
else:
if line == b'\r\n':
if req.method in {'GET', 'HEAD'
} or not req.content_length:
return await self.finish()
req._body_length = 1
req._body_lines = []
else:
error = _parse_header_line(line, req)
if error is not None:
req.parse_error = error
return await self.finish()
async def finish(self):
req = self.request
delattr(req, '_f')
delattr(req, '_body_length')
self._del_req()
await self.app.handle(req, self)
if req.keepalive:
await self.parse()
else:
self.transport.close()
def send(self, bs):
self.transport.write(bs)
def error(self, err, **kwargs):
handler = self.app.error_handlers.get(err.status)
if handler:
return handler(err, **kwargs)
else:
return err.make_response(**kwargs)
def connection_prepared_stream_reader():
"""Create a StreamReader and fill it with connection messages."""
reader = StreamReader()
reader.feed_data(
b"\x1b[H\x1b[2JWelcome to the Folding@home Client command server.\n")
return reader
