def getObjects(self, request, context):
try:
object_ids = set()
for oid in request.objectIDS:
object_ids.add(Utils.get_id(oid))
already_obtained_objects = set()
for oid in request.alreadyObtainedObjects:
already_obtained_objects.add(Utils.get_id(oid))
result = self.execution_environment.get_objects(Utils.get_id(request.sessionID),
object_ids, already_obtained_objects,
request.recursive,
Utils.get_id(request.destBackendID),
request.updateReplicaLocs)
obj_list = []
for entry in result:
obj_list.append(Utils.get_obj_with_data_param_or_return(entry))
return dataservice_messages_pb2.GetObjectsResponse(objects=obj_list)
except Exception as ex:
traceback.print_exc()
return dataservice_messages_pb2.GetObjectsResponse(
excInfo=self.get_exception_info(ex)
)
def removeObjects(self, request, context):
try:
object_ids = set()
for oid in request.getObjectsIDSList():
object_ids.add(Utils.get_id(oid))
result = self.client.ds_remove_objects(Utils.get_id(request.sessionID),
object_ids,
request.recursive,
request.moving,
Utils.get_id(request.newHint))
rem_obj = dict()
for k, v in result.items():
rem_obj[str(k)] = str(v)
return dataservice_messages_pb2.RemoveObjectsResponse(
removedObjects=rem_obj
)
except Exception as ex:
return dataservice_messages_pb2.RemoveObjectsResponse(
excInfo=self.get_exception_info(ex)
)
def detachObjectFromSession(self, request, context):
try:
self.execution_environment.detach_object_from_session(Utils.get_id(request.objectID),
Utils.get_id(request.sessionID))
return common_messages_pb2.ExceptionInfo()
except Exception as ex:
return self.get_exception_info(ex)
def deleteAlias(self, request, context):
try:
self.execution_environment.delete_alias(Utils.get_id(request.sessionID),
Utils.get_id(request.objectID))
return common_messages_pb2.ExceptionInfo()
except Exception as ex:
return self.get_exception_info(ex)
def consolidateVersion(self, request, context):
try:
self.execution_environment.consolidate_version(Utils.get_id(request.sessionID),
Utils.get_id(request.versionObjectID))
return common_messages_pb2.ExceptionInfo()
except Exception as ex:
return self.get_exception_info(ex)
def unfederate(self, request, context):
try:
logger.verbose("Unfederation started")
self.execution_environment.unfederate(Utils.get_id(request.sessionID),
Utils.get_id(request.objectID),
Utils.get_id(request.externalExecutionEnvironmentID),
request.recursive)
logger.verbose("Unfederation finished, sending response")
return common_messages_pb2.ExceptionInfo()
except Exception 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 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 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 get_object_from_alias(self, session_id, alias):
request = logicmodule_messages_pb2.GetObjectFromAliasRequest(
sessionID=Utils.get_msg_id(session_id), alias=alias)
lm_function = lambda request: self.lm_stub.getObjectFromAlias.future(
request=request, metadata=self.metadata_call)
response = self._call_logicmodule(request, lm_function)
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
t = (Utils.get_id(response.objectID), Utils.get_id(response.classID),
Utils.get_id(response.hint))
return t
def notifyUnfederation(self, request, context):
try:
logger.verbose("Notify Unfederation started")
session_id = Utils.get_id(request.sessionID)
object_ids = set()
for oid in request.objectIDs:
object_ids.add(Utils.get_id(oid))
self.execution_environment.notify_unfederation(session_id, object_ids)
logger.verbose("Notify Unfederation finished, sending response")
return common_messages_pb2.ExceptionInfo()
except Exception as ex:
traceback.print_exc()
return self.get_exception_info(ex)
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 closeSessionInDS(self, request, context):
try:
self.execution_environment.close_session_in_ee(Utils.get_id(request.sessionID))
return common_messages_pb2.ExceptionInfo()
except Exception as ex:
return self.get_exception_info(ex)
def ds_remove_objects(self, session_id, object_ids, recursive, moving,
new_hint):
obj_ids_list = []
for oid in object_ids:
obj_ids_list.append(Utils.get_msg_id(oid))
request = dataservice_messages_pb2.RemoveObjectsRequest(
sessionID=Utils.get_msg_id(session_id),
objectIDs=obj_ids_list,
recursive=recursive,
moving=moving,
newHint=Utils.get_msg_id(new_hint))
try:
response = self.ds_stub.removeObjects(request,
metadata=self.metadata_call)
except RuntimeError as e:
raise e
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
result = dict()
for k, v in response.removedObjects.items():
result[Utils.get_idd(k)] = Utils.get_id(v)
return result
def register_objects(self, reg_infos, backend_id, lang):
reg_infos_msg = list()
for reg_info in reg_infos:
msg_reg_info = CommonMessages.RegistrationInfo(
objectID=Utils.get_msg_id(reg_info.object_id),
classID=Utils.get_msg_id(reg_info.class_id),
sessionID=Utils.get_msg_id(reg_info.store_session_id),
dataSetID=Utils.get_msg_id(reg_info.dataset_id),
alias=reg_info.alias)
reg_infos_msg.append(msg_reg_info)
request = logicmodule_messages_pb2.RegisterObjectsRequest(
regInfos=reg_infos_msg,
backendID=Utils.get_msg_id(backend_id),
lang=lang)
lm_function = lambda request: self.lm_stub.registerObjects.future(
request=request, metadata=self.metadata_call)
response = self._call_logicmodule(request, lm_function)
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
result = list()
for oid in response.objectIDs:
result.append(Utils.get_id(oid))
return result
def ds_new_version(self, session_id, object_id, metadata_info):
logger.info("This new_version is called somewhere?")
request = dataservice_messages_pb2.NewVersionRequest(
sessionID=Utils.get_msg_options['session'](session_id),
objectID=Utils.get_msg_options['object'](object_id),
metadataInfo=dataclay_yaml_dump(metadata_info))
try:
response = self.ds_stub.newVersion(request)
except RuntimeError as e:
raise e
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
result = dict()
oid = Utils.get_id(response.objectID)
for k, v in response.versionedIDs:
result[Utils.get_id_from_uuid(k)] = Utils.get_id_from_uuid(v)
t = (oid, result)
return t
def ds_move_objects(self, session_id, object_id, dest_st_location,
recursive):
request = dataservice_messages_pb2.MoveObjectsRequest(
sessionID=Utils.get_msg_id(session_id),
objectID=Utils.get_msg_id(object_id),
destLocID=Utils.get_msg_id(dest_st_location),
recursive=recursive)
try:
response = self.ds_stub.moveObjects(request,
metadata=self.metadata_call)
except RuntimeError as e:
raise e
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
result = set()
for oid in response.movedObjects:
result.add(Utils.get_id(oid))
return result
def exists(self, request, context):
try:
exists = self.execution_environment.exists(
Utils.get_id(request.objectID))
return dataservice_messages_pb2.ExistsResponse(exists=exists)
except Exception as ex:
return dataservice_messages_pb2.ExistsResponse(
excInfo=self.get_exception_info(ex))
def newVersion(self, request, context):
try:
version_object_id = self.execution_environment.new_version(
Utils.get_id(request.sessionID),
Utils.get_id(request.objectID),
Utils.get_id(request.destBackendID)
)
return dataservice_messages_pb2.NewVersionResponse(
objectID=Utils.get_msg_id(version_object_id)
)
except Exception as ex:
traceback.print_exc()
return dataservice_messages_pb2.NewVersionResponse(
excInfo=self.get_exception_info(ex)
)
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 getReferencedObjectsIDs(self, request, context):
try:
object_ids = set()
for oid in request.objectIDS:
object_ids.add(Utils.get_id(oid))
result = self.execution_environment.get_referenced_objects_ids(
Utils.get_id(request.sessionID), object_ids)
obj_list = []
for entry in result:
obj_list.append(Utils.get_msg_options['object'](entry))
return dataservice_messages_pb2.GetReferencedObjectIDsResponse(
objectIDs=obj_list)
except Exception as ex:
return dataservice_messages_pb2.GetReferencedObjectIDsResponse(
excInfo=self.get_exception_info(ex))
def newReplica(self, request, context):
try:
result = self.execution_environment.new_replica(Utils.get_id(request.sessionID),
Utils.get_id(request.objectID),
Utils.get_id(request.destBackendID),
request.recursive)
repl_ids_list = []
for oid in result:
repl_ids_list.append(Utils.get_msg_id(oid))
return dataservice_messages_pb2.NewReplicaResponse(
replicatedObjects=repl_ids_list
)
except Exception as ex:
traceback.print_exc()
return dataservice_messages_pb2.NewReplicaResponse(
excInfo=self.get_exception_info(ex)
)
def get_dataclay_id(self):
lm_function = lambda request: self.lm_stub.getDataClayID.future(
request=request, metadata=self.metadata_call)
response = self._call_logicmodule(CommonMessages.EmptyMessage(),
lm_function)
if response.excInfo.isException:
raise DataClayException(response.exceptionMessage)
return Utils.get_id(response.dataClayID)
def storeObjects(self, request, context):
try:
objects_list = []
for vol_param in request.objects:
param = Utils.get_obj_with_data_param_or_return(vol_param)
objects_list.append(param)
ids_with_alias_set = set()
session_id = Utils.get_id(request.sessionID)
if request.idsWithAlias is not None and len(request.idsWithAlias) > 0:
for ids_with_alias in request.idsWithAlias:
ids_with_alias_set.add(Utils.get_id(ids_with_alias))
self.execution_environment.store_objects(session_id, objects_list, request.moving, ids_with_alias_set)
return common_messages_pb2.ExceptionInfo()
except Exception as ex:
return self.get_exception_info(ex)
def get_external_dataclay_id(self, dcHost, dcPort):
request = logicmodule_messages_pb2.GetExternalDataclayIDRequest(
host=dcHost, port=dcPort)
lm_function = lambda request: self.lm_stub.getExternalDataclayId.future(
request=request, metadata=self.metadata_call)
response = self._call_logicmodule(request, lm_function)
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
return Utils.get_id(response.extDataClayID)
def getFederatedObjects(self, request, context):
try:
object_ids = set()
for oid in request.objectIDS:
object_ids.add(Utils.get_id(oid))
result = self.execution_environment.get_federated_objects(
Utils.get_id(request.extDataClayID), object_ids)
obj_list = []
for entry in result:
obj_list.append(Utils.get_obj_with_data_param_or_return(entry))
return dataservice_messages_pb2.GetFederatedObjectsResponse(
objects=obj_list)
except DataClayException as ex:
return dataservice_messages_pb2.GetFederatedObjectsResponse(
excInfo=self.get_exception_info(ex))
def get_storage_location_id(self, sl_name):
request = logicmodule_messages_pb2.GetStorageLocationIDRequest(
slName=sl_name, )
lm_function = lambda request: self.lm_stub.getStorageLocationID.future(
request=request, metadata=self.metadata_call)
response = self._call_logicmodule(request, lm_function)
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
st_loc_id = Utils.get_id(response.storageLocationID)
return st_loc_id
def register_external_dataclay(self, exthostname, extport):
request = logicmodule_messages_pb2.RegisterExternalDataClayRequest(
hostname=exthostname, port=extport)
lm_function = lambda request: self.lm_stub.registerExternalDataClay.future(
request=request, metadata=self.metadata_call)
response = self._call_logicmodule(request, lm_function)
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
return Utils.get_id(response.extDataClayID)
def delete_alias(self, session_id, alias):
request = logicmodule_messages_pb2.DeleteAliasRequest(
sessionID=Utils.get_msg_id(session_id), alias=alias)
lm_function = lambda request: self.lm_stub.deleteAlias.future(
request=request, metadata=self.metadata_call)
response = self._call_logicmodule(request, lm_function)
if response.excInfo.isException:
raise DataClayException(response.excInfo.exceptionMessage)
return Utils.get_id(response.objectID)
def moveObjects(self, request, context):
try:
result = self.execution_environment.move_objects(Utils.get_id(request.sessionID),
Utils.get_id(request.objectID),
Utils.get_id(request.destLocID),
request.recursive)
mov_obj_list = []
for oid in result:
mov_obj_list.append(Utils.get_msg_id(oid))
return dataservice_messages_pb2.MoveObjectsResponse(
movedObjects=mov_obj_list
)
except Exception as ex:
return dataservice_messages_pb2.MoveObjectsResponse(
excInfo=self.get_exception_info(ex)
)
