async def call_node(self, path: str, data):
self.log.info("Got request for path %s", path)
if path == "search":
if isinstance(data, query_pb2.Query):
query = data
else:
query = query_pb2.Query()
query.ParseFromString(data)
if not self._am_i_closer_and_update_query(query):
return []
data = query.SerializeToString()
elif path == "update":
self.error("GOT update", data)
if isinstance(data, update_pb2.Update):
data = data.SerializeToString()
result = await self.callMe(path, data)
if path == "update":
self.notify_update()
elif path == "search":
#TODO(AB): HACK. do this in a nice way
core_id = self._id.replace("-search", "-core").encode("UTF-8")
res = response_pb2.SearchResponse()
res.ParseFromString(result)
for r in res.result:
if r.key == core_id:
r.distance = self.location.distance(
query.directed_search.target.geo)
result = res.SerializeToString()
return result
def build_query(target=(200, 200), ttl=1):
q = query_pb2.Query()
q.model.description = "weather data"
q.ttl = ttl
q.directed_search.target.geo.lat = target[0]
q.directed_search.target.geo.lon = target[1]
return q
async def client(transport: Transport):
msg = query_pb2.Query()
msg.name = "Client"
await transport.write(msg.SerializeToString())
response = await transport.read()
if not response.success:
print("Error response for uri %s , code: %d, reason: %s", response.uri,
response.error_code, response.msg())
return
msg.ParseFromString(response.data)
print("Response from server: ", msg.name)
transport.close()
async def on_connection(transport: Transport):
print("Got client")
response = await transport.read()
if not response.success:
print("Error response for uri %s, code: %d, reason: %s", response.uri,
response.error_code, response.msg())
return
msg = query_pb2.Query()
msg.ParseFromString(response.data)
print("Got message from client: ", msg.name)
msg.name = "Server"
await transport.write(msg.SerializeToString())
await transport.drain()
transport.close()
async def handle_message(self, data: bytes, session: ComSession):
if not session.authenticated():
return await self.handshake(data, session)
envelope = agent_pb2.Envelope()
envelope.ParseFromString(data)
self.error("Got data: ", envelope)
resp = agent_pb2.Server.AgentMessage()
resp.answer_id = envelope.msg_id
no_answer = True
case = envelope.WhichOneof("payload")
if case == "send_message":
self.error("Case %s not yet supported", case)
elif case == "register_service":
try:
self.error("Register service...")
await self.com.async_register_service(
session.agent_id, envelope.register_service.description)
except Exception as e:
self.exception("Failed to register service: ", str(e))
resp.oef_error.operation = agent_pb2.Server.AgentMessage.OEFError.REGISTER_SERVICE
no_answer = False
elif case == "unregister_service":
self.error("Case %s not yet supported", case)
elif case == "register_description":
self.error("Case %s not yet supported", case)
elif case == "unregister_description":
self.error("Case %s not yet supported", case)
elif case == "search_services":
query = query_pb2.Query()
query.model.CopyFrom(envelope.search_services.query)
query.ttl = 2
qresp = await self.com.async_search(query)
self.error(qresp)
for agent in qresp.result:
resp.agents.agents.append(agent.key.decode("UTF-8"))
self.error(resp)
no_answer = False
elif case == "search_agents":
self.error("Case %s not yet supported", case)
if no_answer:
return b''
else:
return resp.SerializeToString()