def test_grpc_serialization(self) -> None:
client = oaas.get_client(test_pb2_grpc.TestServiceStub)
result = client.ping(test_pb2.Ping(text="ping"))
self.assertEqual("ping-pong", result.text)
self.assertEqual(4, result.len)
client = oaas.get_client(test_pb2_grpc.TestServiceStub)
result = client.ping_copy(test_pb2.Ping(text="ping"))
self.assertEqual("ping-pong", result.text)
self.assertEqual(4, result.len)
client = oaas.get_client(test_pb2_grpc.TestServiceStub)
result = client.ping(test_pb2.Ping(text="ping"))
self.assertEqual("ping-pong", result.text)
self.assertEqual(4, result.len)
def serve(self) -> None:
# we ensure we're serving with the gRPC server first
self._grpc_server.serve()
# we can get the registry only after the server is servicing
# in case this _is_ the registry.
registry = oaas.get_client(OaasRegistryStub)
# we register the services
locations = find_ips(port=self.port)
for service_definition in oaas.registrations.services:
if self._grpc_server.can_serve(service_definition=service_definition):
continue
print(
f"Added SIMPLE service: {service_definition.gav} as {service_definition.code}"
)
registry.register_service(
OaasServiceDefinition(
namespace=service_definition.namespace,
name=service_definition.name,
version=service_definition.version,
tags={
"_protocol": "simple",
},
locations=locations,
)
)
def test_service_calls(self) -> None:
data_store = oaas.get_client(DataStore)
self.assertIsNone(data_store.get_item("a"))
data_store.put_item("a", "avalue")
self.assertEqual("avalue", data_store.get_item("a"))
data_store.remove_item("a")
self.assertIsNone(data_store.get_item("a"))
def oaas_registry() -> OaasRegistry:
global _oaas_registry
if _oaas_registry:
return _oaas_registry
_oaas_registry = oaas.get_client(OaasRegistry) # type: ignore
return _oaas_registry
def oaas_registry() -> OaasRegistryStub:
"""
Get a reference to the `oaas-registry`
"""
global _oaas_registry
if _oaas_registry:
LOG.debug("oaas_registry() Using cached registry client")
return _oaas_registry
LOG.debug("oaas_registry() Using new registry client")
_oaas_registry = oaas.get_client(OaasRegistryStub) # type: ignore
return _oaas_registry
def serve(self) -> None:
if self._is_serving:
return
self._is_serving = True
ensure_grpc_client()
server_address: str = f"[::]:{self.port}"
self.server = grpc.server(futures.ThreadPoolExecutor())
# we add the types to the server and only after we start it we
# notify the oaas registry about the new services
for service_definition in registrations.services:
if not self.can_serve(service_definition):
continue
LOG.info(
"Adding GRPC service: %s as %s",
service_definition.gav,
service_definition.code,
)
try:
find_add_to_server_base(
service_definition.code).add_to_server( # type: ignore
service_definition.code(), self.server)
except Exception as e:
raise Exception(
f"Failure adding GRPC {service_definition.gav}", e)
port = self.server.add_insecure_port(server_address)
locations = find_ips(port=self.port)
LOG.info("listening on %d", port)
self.server.start()
# we register the services
registry = oaas.get_client(OaasRegistryStub)
for service_definition in registrations.services:
registry.register_service(
OaasServiceDefinition(
namespace=service_definition.namespace,
name=service_definition.name,
version=service_definition.version,
locations=locations,
))
def test_grpc_service_error(self) -> None:
error_thrown = False
try:
client = oaas.get_client(test_pb2_grpc.TestServiceStub)
client.ping_exception(test_pb2.Ping(text="ping"))
except Exception as e:
error_thrown = True
str_e = str(e)
# the error message should be available
self.assertIn(
"ping call failed",
str_e,
msg="The call should contain the error message",
)
self.assertTrue(error_thrown, "An error should have been thrown")
def publish(
self,
instance: Any,
name: str,
namespace: str = "default",
version: str = "1",
tags: Optional[Dict[str, str]] = None,
) -> str:
find_add_to_server_base(type(instance)).add_to_server( # type: ignore
instance, self.server)
registry = oaas.get_client(OaasRegistryStub)
locations = find_ips(port=self.port)
result = registry.register_service(
OaasServiceDefinition(
namespace=namespace,
name=name,
version=version,
tags=tags,
locations=locations,
))
return result.id
def test_simple_serialization(self) -> None:
client = oaas.get_client(TestSimpleServiceClient)
result = client.ping("ping")
self.assertEqual("ping-pong", result["text"])
self.assertEqual(4, result["len"])
def unpublish(self, id: str) -> None:
registry = oaas.get_client(OaasRegistryStub)
registry.unregister_service(OaasServiceId(id=id))
def send_clicked(self) -> None:
oaas.get_client(AdhesiveProcess).generate_event(self.task_id)
