async def _write_object(self, request):
key = request[OBJECT_NID_KEY]
if key not in self._objects:
raise exceptions.CommandException(f'{key} not found')
elif SYSTEM_GROUP in request[GROUP_LIST_KEY] and key >= OBJECT_NID_START:
raise exceptions.CommandException(f'Group {SYSTEM_GROUP} is reserved for system objects')
self._objects[key] = request
return self._get_obj(key)
async def _write_object(self, request):
key = request['nid']
if key not in self._objects:
raise exceptions.CommandException(f'{key} not found')
elif const.SYSTEM_GROUP in request['groups'] and key >= const.USER_NID_START:
raise exceptions.CommandException(f'Group {const.SYSTEM_GROUP} is reserved for system objects')
self._objects[key] = request
return self._get_obj(key)
def decoded_response(self) -> dict:
if self._decoded_response is not None:
return self._decoded_response
if self._encoded_response is None:
return None
combined = self._encoded_response.split(VALUE_SEPARATOR)
errcode = self._parse(ErrorcodeEnum, combined[0], False)
try:
if int(errcode) != 0:
raise exceptions.CommandException(
f'{self.name} failed with code {errcode}')
response = self._parse(self.response, combined[0])
if self.values:
response[self.values_key] = [
self._parse(self.values, v) for v in combined[1:]
]
self._decoded_response = response
except exceptions.CommandException as ex:
self._decoded_response = ex
return self._decoded_response
async def test_check_connection(app, client, mocker):
s = spark.fget(app)
await s.check_connection()
m_wait_sync = mocker.patch(TESTED + '.service_status.wait_synchronized', AsyncMock())
m_wait_sync.return_value = False
m_cmder = Mock()
m_cmder.execute = AsyncMock()
m_cmder.start_reconnect = AsyncMock()
mocker.patch(TESTED + '.commander.fget').return_value = m_cmder
await s.check_connection()
assert m_cmder.execute.await_count == 0
assert m_cmder.start_reconnect.await_count == 0
m_wait_sync.return_value = True
await s.check_connection()
assert m_cmder.execute.await_count == 1
assert m_cmder.start_reconnect.await_count == 0
m_cmder.execute.side_effect = exceptions.CommandException()
await s.check_connection()
assert m_cmder.execute.await_count == 2
assert m_cmder.start_reconnect.await_count == 1
async def _execute(
self,
opcode: Opcode,
payload: Optional[EncodedPayload],
/,
) -> list[EncodedPayload]:
msg_id = self._next_id()
request = EncodedRequest(msgId=msg_id, opcode=opcode, payload=payload)
_, request_data = await self._codec.encode((codec.REQUEST_TYPE, None),
request.dict())
fut: asyncio.Future[EncodedResponse] = asyncio.get_running_loop(
).create_future()
self._active_messages[msg_id] = fut
try:
await self._conn.write(request_data)
enc_response = await asyncio.wait_for(fut, timeout=self._timeout)
if enc_response.error != ErrorCode.OK:
raise exceptions.CommandException(
f'{opcode.name}, {enc_response.error.name}')
return enc_response.payload
except asyncio.TimeoutError:
raise exceptions.CommandTimeout(opcode.name)
finally:
del self._active_messages[msg_id]
async def _create_object(self, request):
key = request.get('nid')
obj = request
if not key:
key = next(self._id_counter)
obj['nid'] = key
elif key < const.USER_NID_START:
raise exceptions.CommandException(f'Id {key} is reserved for system objects')
elif key in self._objects:
raise exceptions.CommandException(f'Object {key} already exists')
if const.SYSTEM_GROUP in obj['groups']:
raise exceptions.CommandException(f'Group {const.SYSTEM_GROUP} is reserved for system objects')
self._objects[key] = obj
return obj
async def _create_object(self, request):
key = request.get(OBJECT_NID_KEY)
obj = request
if not key:
key = next(self._id_counter)
obj[OBJECT_NID_KEY] = key
elif key < OBJECT_NID_START:
raise exceptions.CommandException(f'Id {key} is reserved for system objects')
elif key in self._objects:
raise exceptions.CommandException(f'Object {key} already exists')
if SYSTEM_GROUP in obj[GROUP_LIST_KEY]:
raise exceptions.CommandException(f'Group {SYSTEM_GROUP} is reserved for system objects')
self._objects[key] = obj
return obj
async def _read_stored_object(self, request):
try:
return self._objects[request['nid']]
except KeyError:
raise exceptions.CommandException(f'{request} not found')
async def _read_object(self, request):
try:
return self._get_obj(request[OBJECT_NID_KEY])
except KeyError:
raise exceptions.CommandException(f'{request} not found')
