def ds_execute_implementation(self, object_id, implementation_id,
session_id, params):
logger.debug("Client performing ExecuteImplementation")
request = dataservice_messages_pb2.ExecuteImplementationRequest(
sessionID=Utils.get_msg_options['session'](session_id),
implementationID=Utils.get_msg_options['implem'](
implementation_id),
params=Utils.get_param_or_return(params),
objectID=Utils.get_msg_options['object'](object_id))
try:
response = self.ds_stub.executeImplementation(request)
except RuntimeError as e:
logger.error('Failed to execute implementation', exc_info=True)
raise e
if response.excInfo.isException:
try:
exception = pickle.loads(response.excInfo.serializedException)
except:
raise DataClayException(response.excInfo.exceptionMessage)
else:
raise exception
if response.ret is not None:
return Utils.get_param_or_return(response.ret)
else:
return None
def execute_implementation(self, session_id, operation_id,
remote_implementation, object_id, params):
request = logicmodule_messages_pb2.ExecuteImplementationRequest(
sessionID=Utils.get_msg_id(session_id),
operationID=Utils.get_msg_id(operation_id),
implementationID=Utils.get_msg_id(remote_implementation[0]),
contractID=Utils.get_msg_id(remote_implementation[1]),
interfaceID=Utils.get_msg_id(remote_implementation[2]),
params=Utils.get_param_or_return(params),
objectID=Utils.get_msg_id(object_id))
lm_function = lambda request: self.lm_stub.executeImplementation.future(
request=request, metadata=self.metadata_call)
response = self._call_logicmodule(request, lm_function)
if response.excInfo.isException:
try:
exception = pickle.loads(response.excInfo.serializedException)
except:
raise DataClayException(response.excInfo.exceptionMessage)
else:
raise exception
if response.ret is not None:
return Utils.get_param_or_return(response.ret)
else:
return None
def ds_new_persistent_instance(self, session_id, class_id,
implementation_id, i_face_bitmaps, params):
logger.debug(
"Ready to call to a DS to build a new persistent instance for class {%s}",
class_id)
temp_iface_b = dict()
temp_param = None
if i_face_bitmaps is not None:
for k, v in i_face_bitmaps.items():
temp_iface_b[k] = v
if params is not None:
temp_param = Utils.get_param_or_return(params)
request = dataservice_messages_pb2.NewPersistentInstanceRequest(
sessionID=Utils.get_msg_options['session'](session_id),
classID=Utils.get_msg_options['meta_class'](class_id),
implementationID=Utils.get_msg_options['implem'](
implementation_id),
ifaceBitMaps=temp_iface_b,
params=temp_param)
try:
response = self.ds_stub.newPersistentInstance(request)
except RuntimeError as e:
raise e
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
return Utils.get_id(response.objectID)
def executeImplementation(self, request, context):
logger.debug("Starting ExecuteImplementation handling")
try:
object_id = Utils.get_id(request.objectID)
implementation_id = Utils.get_id(request.implementationID)
serialized_params = Utils.get_param_or_return(request.params)
session_id = Utils.get_id(request.sessionID)
result = self.execution_environment.ds_exec_impl(object_id, implementation_id, serialized_params, session_id)
logger.verbose("ExecuteImplementation finished, sending response")
return dataservice_messages_pb2.ExecuteImplementationResponse(ret=Utils.get_param_or_return(result))
except Exception as ex:
traceback.print_exc()
return dataservice_messages_pb2.ExecuteImplementationResponse(
excInfo=self.get_exception_info(ex))
def federate(self, request, context):
try:
logger.verbose("Federation started")
objects_to_persist = Utils.get_param_or_return(request.params)
session_id = Utils.get_id(request.sessionID)
self.execution_environment.federate(session_id, objects_to_persist)
logger.verbose("Federation finished, sending response")
return common_messages_pb2.ExceptionInfo()
except Exception as ex:
return self.get_exception_info(ex)
def synchronize(self, request, context):
try:
object_id = Utils.get_id(request.objectID)
implementation_id = Utils.get_id(request.implementationID)
serialized_params = Utils.get_param_or_return(request.params)
session_id = Utils.get_id(request.sessionID)
calling_backend_id = Utils.get_id(request.callingBackendID)
self.execution_environment.synchronize(session_id, object_id, implementation_id,
serialized_params, calling_backend_id)
return common_messages_pb2.ExceptionInfo()
except DataClayException as ex:
return self.get_exception_info(ex)
def getCopyOfObject(self, request, context):
try:
result = self.execution_environment.get_copy_of_object(
Utils.get_id(request.sessionID),
Utils.get_id(request.objectID), request.recursive)
return dataservice_messages_pb2.GetCopyOfObjectResponse(
ret=Utils.get_param_or_return(result))
except Exception as ex:
return dataservice_messages_pb2.GetObjectsResponse(
excInfo=self.get_exception_info(ex))
def makePersistent(self, request, context):
try:
objects_to_persist = Utils.get_param_or_return(request.params)
session_id = Utils.get_id(request.sessionID)
self.execution_environment.make_persistent(session_id,
objects_to_persist)
logger.verbose("MakePersistent finished, sending response")
return common_messages_pb2.ExceptionInfo()
except Exception as ex:
traceback.print_exc()
return self.get_exception_info(ex)
def ds_update_object(self, session_id, into_object_id, from_object):
request = dataservice_messages_pb2.UpdateObjectRequest(
sessionID=Utils.get_msg_options['session'](session_id),
intoObjectID=Utils.get_msg_options['object'](into_object_id),
fromObject=Utils.get_param_or_return(from_object))
try:
response = self.ds_stub.updateObject(request)
except RuntimeError as e:
raise e
if response.isException:
raise DataClayException(response.exceptionMessage)
def updateObject(self, request, context):
try:
self.execution_environment.update_object(
Utils.get_id(request.sessionID),
Utils.get_id(request.intoObjectID),
Utils.get_param_or_return(request.fromObject))
logger.verbose("updateObject finished, sending response")
return common_messages_pb2.ExceptionInfo()
except DataClayException as ex:
return self.get_exception_info(ex)
def synchronize(self, session_id, object_id, implementation_id, params,
calling_backend_id):
request = dataservice_messages_pb2.SynchronizeRequest(
sessionID=Utils.get_msg_id(session_id),
objectID=Utils.get_msg_id(object_id),
implementationID=Utils.get_msg_id(implementation_id),
params=Utils.get_param_or_return(params),
callingBackendID=Utils.get_msg_id(calling_backend_id))
try:
response = self.ds_stub.synchronize(request,
metadata=self.metadata_call)
except RuntimeError as e:
raise e
if response.isException:
raise DataClayException(response.exceptionMessage)
def federate(self, session_id, params):
request = dataservice_messages_pb2.FederateRequest(
sessionID=Utils.get_msg_options['session'](session_id),
params=Utils.get_param_or_return(params),
)
try:
response = self.ds_stub.federate(request)
except RuntimeError as e:
logger.error('Failed to federate', exc_info=True)
raise e
if response.isException:
raise DataClayException(response.exceptionMessage)
def make_persistent(self, session_id, params):
logger.debug("Client performing MakePersistent")
request = dataservice_messages_pb2.MakePersistentRequest(
sessionID=Utils.get_msg_options['session'](session_id),
params=Utils.get_param_or_return(params),
)
try:
response = self.ds_stub.makePersistent(request)
except RuntimeError as e:
logger.error('Failed to make persistent', exc_info=True)
raise e
if response.isException:
raise DataClayException(response.exceptionMessage)
def ds_get_copy_of_object(self, session_id, object_id, recursive):
request = dataservice_messages_pb2.GetCopyOfObjectRequest(
sessionID=Utils.get_msg_options['session'](session_id),
objectID=Utils.get_msg_options['object'](object_id),
recursive=recursive,
)
try:
response = self.ds_stub.getCopyOfObject(request)
except RuntimeError as e:
raise e
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
serialized_obj = Utils.get_param_or_return(response.ret)
return serialized_obj
def synchronize_federated_object(self, dataclay_id, object_id, impl_id,
params):
if params is not None:
request = logicmodule_messages_pb2.SynchronizeFederatedObjectRequest(
extDataClayID=Utils.get_msg_id(dataclay_id),
objectID=Utils.get_msg_id(object_id),
implementationID=Utils.get_msg_id(impl_id),
params=Utils.get_param_or_return(params))
else:
request = logicmodule_messages_pb2.SynchronizeFederatedObjectRequest(
extDataClayID=Utils.get_msg_id(dataclay_id),
objectID=Utils.get_msg_id(object_id),
implementationID=Utils.get_msg_id(impl_id),
)
lm_function = lambda request: self.lm_stub.synchronizeFederatedObject.future(
request=request, metadata=self.metadata_call)
response = self._call_logicmodule(request, lm_function)
if response.isException:
raise DataClayException(response.exceptionMessage)
def newPersistentInstance(self, request, context):
try:
iface_bit_maps = {}
for k, v in request.ifaceBitMaps.items():
iface_bit_maps[Utils.get_id_from_uuid(k)] = Utils.prepare_bytes(v)
params = []
if request.params:
params = Utils.get_param_or_return(request.params)
oid = self.client.ds_new_persistent_instance(Utils.get_id(request.sessionID),
Utils.get_id(request.classID),
Utils.get_id(request.implementationID),
iface_bit_maps,
params)
return dataservice_messages_pb2.NewPersistentInstanceResponse(objectID=Utils.get_msg_id(oid))
except Exception as ex:
return dataservice_messages_pb2.NewPersistentInstanceResponse(
excInfo=self.get_exception_info(ex))
