async def _handle_handshake(self, writer, packet_id, data):
client_data = data
client_id = client_data.get('client_id')
client_token = client_data.get('token')
if self._token is not None and (client_token is None
or client_token != self._token):
response = create_header(0, HANDSHAKE_FAIL, packet_id)
writer.write(response)
return client_id, False
if 'client_type' not in client_data:
response = create_header(0, HANDSHAKE_FAIL, packet_id)
writer.write(response)
return client_id, False
if client_data.get('client_type') == 'listener':
await ClientManager.listener_connected(
writer.get_extra_info('peername'), writer, client_data)
logging.info(f'New listener with id: {client_id}')
elif client_data.get('client_type') == 'worker':
supported_modules = client_data.get('module')
if supported_modules is None:
logging.warning(f"New worker connected with id : {client_id}"
", but has no installed modules")
if version.parse(client_data.get('lib_version')) < version.parse(
ENODO_HUB_WORKER_MIN_VERSION):
logging.warning(
f"Worker with id : {client_id} tried to connect,"
"but has incompatible version")
response = create_header(0, HANDSHAKE_FAIL, packet_id)
writer.write(response)
return client_id, False
await ClientManager.worker_connected(
writer.get_extra_info('peername'), writer, client_data)
response = create_header(0, HANDSHAKE_OK, packet_id)
writer.write(response)
return client_id, True
if client_data.get('client_type') == 'listener':
update = qpack.packb(await
SeriesManager.get_listener_series_info())
header = create_header(len(update), UPDATE_SERIES, packet_id)
writer.write(header + update)
return client_id, True
async def _handle_heartbeat(self, writer, packet_id, data):
client_id = data
l_client = await ClientManager.get_listener_by_id(client_id)
w_client = await ClientManager.get_worker_by_id(client_id)
if l_client is not None:
logging.debug(f'Heartbeat from listener with id: {client_id}')
l_client.last_seen = time.time()
response = create_header(0, HEARTBEAT, packet_id)
writer.write(response)
elif w_client is not None:
logging.debug(f'Heartbeat from worker with id: {client_id}')
w_client.last_seen = time.time()
response = create_header(0, HEARTBEAT, packet_id)
writer.write(response)
else:
response = create_header(0, UNKNOWN_CLIENT, packet_id)
writer.write(response)
async def receive_new_series_points(writer, packet_type, packet_id, data,
client_id):
for series_name in data.keys():
async with SeriesManager.get_series(series_name) as series:
if series is not None:
await SeriesManager.add_to_datapoint_counter(
series_name, data.get(series_name))
response = create_header(0, RESPONSE_OK, packet_id)
writer.write(response)
async def _send_worker_cancel_job(cls, worker_id: str, job_id: int):
worker = await ClientManager.get_worker_by_id(worker_id)
if worker is None:
return
try:
logging.error(f"Asking worker {worker_id} to cancel job {job_id}")
data = qpack.packb({'job_id': job_id})
header = create_header(len(data), WORKER_JOB_CANCEL, 0)
worker.writer.write(header + data)
except Exception as e:
logging.error(
f"Something went wrong when sending worker to cancel job")
logging.debug(f"Corresponding error: {e}, "
f'exception class: {e.__class__.__name__}')
async def _send_worker_job_request(cls, worker: WorkerClient,
job: EnodoJob):
try:
series = await SeriesManager.get_series_read_only(job.series_name)
job_data = EnodoJobRequestDataModel(
job_id=job.rid,
job_config=job.job_config,
series_name=job.series_name,
series_config=series.config,
series_state=series.state,
siridb_ts_units=ServerState.siridb_ts_unit)
data = qpack.packb(job_data.serialize())
header = create_header(len(data), WORKER_JOB, 0)
worker.writer.write(header + data)
except Exception as e:
logging.error(
f"Something went wrong when sending job request to worker")
import traceback
traceback.print_exc()
logging.debug(f"Corresponding error: {e}, "
f'exception class: {e.__class__.__name__}')
def update_listener(cls, listener: ListenerClient, data: Any):
update = qpack.packb(data)
series_update = create_header(len(update), UPDATE_SERIES, 1)
listener.writer.write(series_update + update)
async def update_listeners(cls, series):
for listener in ClientManager.listeners.values():
update = qpack.packb(series)
series_update = create_header(len(update), UPDATE_SERIES, 0)
listener.writer.write(series_update + update)