def get_reservations_by_category(
self,
*,
caller: AuthToken,
category: ReservationCategory,
slice_id: ID = None,
id_token: str = None) -> ResultReservationAvro:
result = ResultReservationAvro()
result.status = ResultAvro()
if caller is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
res_list = None
try:
if category == ReservationCategory.Client:
if slice_id is None:
res_list = self.db.get_client_reservations()
else:
res_list = self.db.get_client_reservations_by_slice_id(
slice_id=slice_id)
elif category == ReservationCategory.Broker:
res_list = self.db.get_broker_reservations()
elif category == ReservationCategory.Inventory:
if slice_id is None:
res_list = self.db.get_holdings()
else:
res_list = self.db.get_holdings_by_slice_id(
slice_id=slice_id)
except Exception as e:
self.logger.error("do_get_reservations:db access {}".format(e))
result.status.set_code(ErrorCodes.ErrorDatabaseError.value)
result.status.set_message(
ErrorCodes.ErrorDatabaseError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
if res_list is not None:
result.result = []
for r in res_list:
slice_obj = self.get_slice_by_guid(guid=r.get_slice_id())
r.restore(actor=self.actor,
slice_obj=slice_obj,
logger=self.logger)
rr = Converter.fill_reservation(reservation=r, full=True)
result.result.append(rr)
except Exception as e:
self.logger.error("do_get_reservations: {}".format(e))
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def get_authority_reservations(
self,
*,
caller: AuthToken,
id_token: str = None) -> ResultReservationAvro:
result = ResultReservationAvro()
result.status = ResultAvro()
if caller is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
AccessChecker.check_access(action_id=ActionId.query,
resource_type=ResourceType.sliver,
token=id_token,
logger=self.logger,
actor_type=self.actor.get_type())
res_list = None
try:
res_list = self.db.get_authority_reservations()
except Exception as e:
self.logger.error(
"get_authority_reservations:db access {}".format(e))
result.status.set_code(ErrorCodes.ErrorDatabaseError.value)
result.status.set_message(
ErrorCodes.ErrorDatabaseError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
if res_list is not None:
result.reservations = []
for r in res_list:
slice_obj = self.get_slice_by_guid(guid=r.get_slice_id())
r.restore(actor=self.actor,
slice_obj=slice_obj,
logger=self.logger)
rr = Converter.fill_reservation(reservation=r, full=True)
result.reservations.append(rr)
except ReservationNotFoundException as e:
self.logger.error("get_authority_reservations: {}".format(e))
result.status.set_code(ErrorCodes.ErrorNoSuchReservation.value)
result.status.set_message(e.text)
except Exception as e:
self.logger.error("get_authority_reservations: {}".format(e))
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def add_broker(self, *, broker: ProxyAvro,
caller: AuthToken) -> ResultAvro:
result = ResultAvro()
if broker is None or caller is None:
result.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
proxy = Converter.get_agent_proxy(mng=broker)
if proxy is None:
result.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
else:
self.client.add_broker(broker=proxy)
except Exception as e:
self.logger.error("add_broker {}".format(e))
result.set_code(ErrorCodes.ErrorInternalError.value)
result.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result = ManagementObject.set_exception_details(result=result, e=e)
return result
def extend_reservation(self, *, request: ExtendReservationAvro) -> ResultStringAvro:
result = ResultStringAvro()
result.message_id = request.message_id
try:
if request.guid is None or request.reservation_id is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
end_time = ActorClock.from_milliseconds(milli_seconds=request.end_time)
rtype = None
if request.new_resource_type is not None:
rtype = ResourceType(resource_type=request.new_resource_type)
result.status = mo.extend_reservation(rid=ID(uid=request.reservation_id), new_end_time=end_time,
new_units=request.new_units, new_resource_type=rtype,
request_properties=request.request_properties,
config_properties=request.config_properties, caller=auth)
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(result=result.status, e=e)
result.message_id = request.message_id
return result
def get_reservations_by_category(
self, *, request: GetReservationsRequestAvro,
category: ReservationCategory) -> ResultReservationAvro:
result = ResultReservationAvro()
result.status = ResultAvro()
result.message_id = request.message_id
try:
if request.guid is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
result = mo.get_reservations_by_category(
caller=auth,
category=category,
id_token=request.get_id_token(),
slice_id=request.slice_id)
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
result.message_id = request.message_id
return result
def add_client_slice(self, *, request: AddSliceAvro) -> ResultStringAvro:
result = ResultStringAvro()
result.status = ResultAvro()
result.message_id = request.message_id
try:
if request.guid is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
result = mo.add_client_slice(caller=auth,
slice_obj=request.slice_obj)
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
result.message_id = request.message_id
return result
def demand_reservation(self, *, request: DemandReservationAvro) -> ResultStringAvro:
result = ResultStringAvro()
result.status = ResultAvro()
result.message_id = request.message_id
try:
if request.guid is None or (request.reservation_id is None and request.reservation_obj is None):
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
if request.reservation_obj is not None and request.reservation_id is not None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
if request.reservation_id is not None:
result.status = mo.demand_reservation_rid(rid=ID(uid=request.reservation_id), caller=auth)
else:
result.status = mo.demand_reservation(reservation=request.reservation_obj, caller=auth)
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(result=result.status, e=e)
result.message_id = request.message_id
return result
def get_delegations(self, *, request: GetDelegationsAvro) -> ResultDelegationAvro:
result = ResultDelegationAvro()
result.status = ResultAvro()
result.message_id = request.message_id
try:
if request.guid is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
if request.get_delegation_id() is not None:
result = mo.get_delegations(caller=auth, did=ID(uid=request.get_delegation_id()),
id_token=request.get_id_token(), state=request.delegation_state)
elif request.get_slice_id() is not None:
result = mo.get_delegations(caller=auth, slice_id=ID(uid=request.get_slice_id()),
id_token=request.get_id_token(), state=request.delegation_state)
else:
result = mo.get_delegations(caller=auth, id_token=request.get_id_token(),
state=request.delegation_state)
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(result=result.status, e=e)
result.message_id = request.message_id
return result
def get_slices_by_slice_type(self, *, request: GetSlicesRequestAvro,
slice_type: SliceTypes) -> ResultSliceAvro:
result = ResultSliceAvro()
result.status = ResultAvro()
result.message_id = request.message_id
try:
if request.guid is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
result = mo.get_slices_by_slice_type(
caller=auth,
slice_type=slice_type,
id_token=request.get_id_token())
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
result.message_id = request.message_id
return result
def run(self):
result = ResultAvro()
r = self.actor.get_reservation(rid=rid)
if r is None:
result.set_code(
ErrorCodes.ErrorNoSuchReservation.value)
result.set_message(
ErrorCodes.ErrorNoSuchReservation.interpret())
return result
r = ManagementUtils.update_reservation(res_obj=r,
rsv_mng=reservation)
r.set_dirty()
try:
self.actor.get_plugin().get_database(
).update_reservation(reservation=r)
except Exception as e:
print("Could not commit slice update {}".format(e))
result.set_code(ErrorCodes.ErrorDatabaseError.value)
result.set_message(
ErrorCodes.ErrorDatabaseError.interpret(
exception=e))
result = ManagementObject.set_exception_details(
result=result, e=e)
return result
def get_broker_query_model(self, *, request: GetBrokerQueryModelRequestAvro) -> ResultBrokerQueryModelAvro:
result = ResultBrokerQueryModelAvro()
result.status = ResultAvro()
result.message_id = request.message_id
try:
if request.guid is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
graph_format = GraphFormat(request.graph_format)
result = mo.get_broker_query_model(broker=ID(uid=request.broker_id), caller=auth,
id_token=request.get_id_token(), graph_format=graph_format)
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(result=result.status, e=e)
result.message_id = request.message_id
return result
def register_client(self, *, client: ClientMng, kafka_topic: str,
caller: AuthToken) -> ResultAvro:
result = ResultAvro()
if client is None or kafka_topic is None or caller is None:
result.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
client_obj = Converter.fill_client(client_mng=client)
client_obj.set_kafka_topic(kafka_topic=kafka_topic)
class Runner(ABCActorRunnable):
def __init__(self, *, actor: ABCActorMixin):
self.actor = actor
def run(self):
self.actor.register_client(client=client_obj)
return None
self.actor.execute_on_actor_thread_and_wait(runnable=Runner(
actor=self.actor))
except Exception as e:
self.logger.error("register_client: {}".format(e))
result.set_code(ErrorCodes.ErrorInternalError.value)
result.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result = ManagementObject.set_exception_details(result=result, e=e)
return result
def run(self):
result = ResultAvro()
slice_obj = self.actor.get_slice(slice_id=slice_id)
if slice_obj is None:
result.set_code(ErrorCodes.ErrorNoSuchSlice.value)
result.set_message(
ErrorCodes.ErrorNoSuchSlice.interpret())
return result
slice_obj = ManagementUtils.update_slice(
slice_obj=slice_obj, slice_mng=slice_mng)
slice_obj.set_dirty()
try:
self.actor.get_plugin().get_database().update_slice(
slice_object=slice_obj)
except Exception as e:
print("Could not commit slice update {}".format(e))
result.set_code(ErrorCodes.ErrorDatabaseError.value)
result.set_message(
ErrorCodes.ErrorDatabaseError.interpret(
exception=e))
result = ManagementObject.set_exception_details(
result=result, e=e)
return result
def unregister_client(self, *, guid: ID, caller: AuthToken) -> ResultAvro:
result = ResultAvro()
if guid is None or caller is None:
result.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
class Runner(ABCActorRunnable):
def __init__(self, *, actor: ABCActorMixin):
self.actor = actor
def run(self):
self.actor.unregister_client(guid=guid)
return None
self.actor.execute_on_actor_thread_and_wait(runnable=Runner(
actor=self.actor))
except Exception as e:
self.logger.error("unregister_client: {}".format(e))
result.set_code(ErrorCodes.ErrorInternalError.value)
result.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result = ManagementObject.set_exception_details(result=result, e=e)
return result
def do_get_actors(self,
*,
atype: int,
caller: AuthToken,
id_token: str = None) -> ResultActorAvro:
result = ResultActorAvro()
result.status = ResultAvro()
if caller is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.name)
return result
try:
act_list = self.get_actors_from_registry(atype=atype,
caller=caller)
result.actors = Converter.fill_actors(act_list=act_list)
except Exception as e:
self.logger.error("get_actors {}".format(e))
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def close_reservations(self, *, request: CloseReservationsAvro) -> ResultStringAvro:
result = ResultStringAvro()
result.status = ResultAvro()
result.message_id = request.message_id
try:
if request.guid is None or (request.get_slice_id() is None and request.get_reservation_id() is None):
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
if request.get_slice_id() is not None:
result.status = mo.close_slice_reservations(caller=auth, slice_id=ID(uid=request.slice_id),
id_token=request.id_token)
else:
result.status = mo.close_reservation(caller=auth, rid=ID(uid=request.reservation_id),
id_token=request.id_token)
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(result=result.status, e=e)
result.message_id = request.message_id
return result
def get_slices(self, *, request: GetSlicesRequestAvro) -> ResultSliceAvro:
result = ResultSliceAvro()
result.status = ResultAvro()
result.message_id = request.message_id
try:
if request.guid is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
slice_id = None
if request.slice_id is not None:
slice_id = ID(uid=request.slice_id)
result = mo.get_slices(slice_id=slice_id, caller=auth, id_token=request.get_id_token(),
slice_name=request.slice_name, email=request.get_email())
except Exception as e:
self.logger.error(traceback.format_exc())
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(result=result.status, e=e)
result.message_id = request.message_id
return result
def get_slices_by_slice_type(self,
*,
caller: AuthToken,
slice_type: SliceTypes,
id_token: str = None) -> ResultSliceAvro:
result = ResultSliceAvro()
result.status = ResultAvro()
if caller is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
slc_list = None
try:
if slice_type == SliceTypes.ClientSlice:
slc_list = self.db.get_client_slices()
elif slice_type == SliceTypes.InventorySlice:
slc_list = self.db.get_inventory_slices()
except Exception as e:
self.logger.error(
"get_slices_by_slice_type:db access {}".format(e))
result.status.set_code(ErrorCodes.ErrorDatabaseError.value)
result.status.set_message(
ErrorCodes.ErrorDatabaseError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
if slc_list is not None:
result.result = Translate.fill_slices(slice_list=slc_list,
full=True)
except Exception as e:
self.logger.error("get_slices_by_slice_type: {}".format(e))
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def extend_reservation(self, *, reservation: id, new_end_time: datetime,
new_units: int, caller: AuthToken) -> ResultAvro:
result = ResultAvro()
if reservation is None or caller is None or new_end_time is None:
result.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
class Runner(ABCActorRunnable):
def __init__(self, *, actor: ABCActorMixin):
self.actor = actor
def run(self):
result = ResultAvro()
r = self.actor.get_reservation(rid=reservation)
if r is None:
result.set_code(
ErrorCodes.ErrorNoSuchReservation.value)
result.set_message(
ErrorCodes.ErrorNoSuchReservation.interpret())
return result
rset = ResourceSet()
if new_units == Constants.EXTEND_SAME_UNITS:
rset.set_units(units=r.get_resources().get_units())
else:
rset.set_units(units=new_units)
rset.set_type(rtype=r.get_resources().get_type())
tmp_start_time = r.get_term().get_start_time()
new_term = r.get_term().extend()
new_term.set_end_time(date=new_end_time)
new_term.set_new_start_time(date=tmp_start_time)
new_term.set_start_time(date=tmp_start_time)
self.actor.extend(rid=r.get_reservation_id(),
resources=rset,
term=new_term)
return result
result = self.client.execute_on_actor_thread_and_wait(
runnable=Runner(actor=self.client))
except Exception as e:
self.logger.error("extend_reservation {}".format(e))
result.set_code(ErrorCodes.ErrorInternalError.value)
result.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result = ManagementObject.set_exception_details(result=result, e=e)
return result
def add_reservations(self, *, reservations: List[TicketReservationAvro],
caller: AuthToken) -> ResultStringsAvro:
result = ResultStringsAvro()
result.status = ResultAvro()
if reservations is None or caller is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
for r in reservations:
if r.get_slice_id() is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
class Runner(ABCActorRunnable):
def __init__(self, *, parent):
self.parent = parent
def run(self):
result = []
try:
for r in reservations:
rr, status = self.parent.add_reservation_private(
reservation=r)
if rr is not None:
result.append(str(rr))
else:
raise ManageException(
"Could not add reservation")
except Exception:
for r in reservations:
self.parent.client.unregister(reservation=r)
result.clear()
return result
rids, result.status = self.client.execute_on_actor_thread_and_wait(
runnable=Runner(parent=self))
if result.status.get_code() == 0:
for r in rids:
result.result.append(r)
except Exception as e:
self.logger.error("add_reservations {}".format(e))
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def get_reservation_unit(self,
*,
caller: AuthToken,
uid: ID,
id_token: str = None) -> ResultUnitsAvro:
result = ResultUnitsAvro()
result.status = ResultAvro()
if caller is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
AccessChecker.check_access(action_id=ActionId.query,
resource_type=ResourceType.sliver,
token=id_token,
logger=self.logger,
actor_type=self.actor.get_type())
units_list = None
try:
unit = self.db.get_unit(uid=uid)
units_list = [unit]
except Exception as e:
self.logger.error(
"get_reservation_unit:db access {}".format(e))
result.status.set_code(ErrorCodes.ErrorDatabaseError.value)
result.status.set_message(
ErrorCodes.ErrorDatabaseError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
if units_list is not None:
result.units = Converter.fill_units(unit_list=units_list)
except Exception as e:
self.logger.error("get_reservation_unit: {}".format(e))
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def do_get_actors_from_database(self,
*,
caller: AuthToken,
status: int = None,
id_token: str = None) -> ResultActorAvro:
result = ResultActorAvro()
result.status = ResultAvro()
if caller is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.name)
return result
try:
act_list = None
try:
act_list = self.get_container_management_database().get_actors(
)
except Exception as e:
self.logger.error("get_actors_from_database {}".format(e))
result.status.set_code(ErrorCodes.ErrorDatabaseError.value)
result.status.set_message(
ErrorCodes.ErrorDatabaseError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
if act_list is not None:
if status is None:
result.actors = Converter.fill_actors_from_db(
act_list=act_list)
else:
result.actors = Converter.fill_actors_from_db_status(
act_list=act_list, status=status)
except Exception as e:
self.logger.error("get_actors_from_database {}".format(e))
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def get_reservations(self, *, request: GetReservationsRequestAvro) -> ResultReservationAvro:
result = ResultReservationAvro()
result.status = ResultAvro()
result.message_id = request.message_id
try:
if request.guid is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
auth = Translate.translate_auth_from_avro(auth_avro=request.auth)
mo = self.get_actor_mo(guid=ID(uid=request.guid))
slice_id = None
if request.slice_id is not None:
slice_id = ID(uid=request.slice_id)
rid = None
if request.get_reservation_id() is not None:
rid = ID(uid=request.get_reservation_id())
if rid is not None:
result = mo.get_reservations(caller=auth, rid=rid, id_token=request.get_id_token())
elif slice_id is not None:
if request.get_reservation_state() is not None and \
request.get_reservation_state() != Constants.ALL_RESERVATION_STATES:
result = mo.get_reservations(caller=auth, slice_id=slice_id,
state=request.get_reservation_state(),
id_token=request.get_id_token())
else:
result = mo.get_reservations(caller=auth, slice_id=slice_id,
id_token=request.get_id_token())
else:
if request.get_reservation_state() is not None and \
request.get_reservation_state() != Constants.ALL_RESERVATION_STATES:
result = mo.get_reservations(caller=auth, state=request.get_reservation_state(),
id_token=request.get_id_token(), email=request.get_email())
else:
result = mo.get_reservations(caller=auth, id_token=request.get_id_token(),
email=request.get_email())
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(result=result.status, e=e)
result.message_id = request.message_id
return result
def close_slice_reservations(self,
*,
caller: AuthToken,
slice_id: ID,
id_token: str = None) -> ResultAvro:
result = ResultAvro()
if slice_id is None or caller is None:
result.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
if id_token is not None:
AccessChecker.check_access(action_id=ActionId.close,
resource_type=ResourceType.slice,
token=id_token,
logger=self.logger,
actor_type=self.actor.get_type(),
resource_id=str(slice_id))
class Runner(ABCActorRunnable):
def __init__(self, *, actor: ABCActorMixin):
self.actor = actor
def run(self):
self.actor.close_slice_reservations(slice_id=slice_id)
return None
self.actor.execute_on_actor_thread_and_wait(runnable=Runner(
actor=self.actor))
except SliceNotFoundException as e:
self.logger.error("close_slice_reservations: {}".format(e))
result.set_code(ErrorCodes.ErrorNoSuchSlice.value)
result.set_message(e.text)
result = ManagementObject.set_exception_details(result=result, e=e)
except Exception as e:
self.logger.error("close_slice_reservations: {}".format(e))
result.set_code(ErrorCodes.ErrorInternalError.value)
result.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result = ManagementObject.set_exception_details(result=result, e=e)
return result
def update_reservation(self, *, reservation: ReservationMng,
caller: AuthToken) -> ResultAvro:
result = ResultAvro()
if reservation is None or caller is None:
result.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
rid = ID(uid=reservation.get_reservation_id())
class Runner(ABCActorRunnable):
def __init__(self, *, actor: ABCActorMixin):
self.actor = actor
def run(self):
result = ResultAvro()
r = self.actor.get_reservation(rid=rid)
if r is None:
result.set_code(
ErrorCodes.ErrorNoSuchReservation.value)
result.set_message(
ErrorCodes.ErrorNoSuchReservation.interpret())
return result
r = ManagementUtils.update_reservation(res_obj=r,
rsv_mng=reservation)
r.set_dirty()
try:
self.actor.get_plugin().get_database(
).update_reservation(reservation=r)
except Exception as e:
print("Could not commit slice update {}".format(e))
result.set_code(ErrorCodes.ErrorDatabaseError.value)
result.set_message(
ErrorCodes.ErrorDatabaseError.interpret(
exception=e))
result = ManagementObject.set_exception_details(
result=result, e=e)
return result
result = self.actor.execute_on_actor_thread_and_wait(
runnable=Runner(actor=self.actor))
except ReservationNotFoundException as e:
self.logger.error("update_reservation: {}".format(e))
result.set_code(ErrorCodes.ErrorNoSuchReservation.value)
result.set_message(e.text)
except Exception as e:
self.logger.error("update_reservation: {}".format(e))
result.set_code(ErrorCodes.ErrorInternalError.value)
result.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result = ManagementObject.set_exception_details(result=result, e=e)
return result
def update_slice(self, *, slice_mng: SliceAvro,
caller: AuthToken) -> ResultAvro:
result = ResultAvro()
if slice_mng is None or slice_mng.get_slice_id(
) is None or caller is None:
result.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
slice_id = ID(uid=slice_mng.get_slice_id())
class Runner(ABCActorRunnable):
def __init__(self, *, actor: ABCActorMixin):
self.actor = actor
def run(self):
result = ResultAvro()
slice_obj = self.actor.get_slice(slice_id=slice_id)
if slice_obj is None:
result.set_code(ErrorCodes.ErrorNoSuchSlice.value)
result.set_message(
ErrorCodes.ErrorNoSuchSlice.interpret())
return result
slice_obj = ManagementUtils.update_slice(
slice_obj=slice_obj, slice_mng=slice_mng)
slice_obj.set_dirty()
try:
self.actor.get_plugin().get_database().update_slice(
slice_object=slice_obj)
except Exception as e:
print("Could not commit slice update {}".format(e))
result.set_code(ErrorCodes.ErrorDatabaseError.value)
result.set_message(
ErrorCodes.ErrorDatabaseError.interpret(
exception=e))
result = ManagementObject.set_exception_details(
result=result, e=e)
return result
result = self.actor.execute_on_actor_thread_and_wait(
runnable=Runner(actor=self.actor))
except Exception as e:
self.logger.error("update_slice: {}".format(e))
result.set_code(ErrorCodes.ErrorInternalError.value)
result.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result = ManagementObject.set_exception_details(result=result, e=e)
return result
def get_reservation_units(self,
*,
caller: AuthToken,
rid: ID,
id_token: str = None) -> ResultUnitsAvro:
result = ResultUnitsAvro()
result.status = ResultAvro()
if caller is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
units_list = None
try:
units_list = self.db.get_units(rid=rid)
except Exception as e:
self.logger.error(
"get_reservation_units:db access {}".format(e))
result.status.set_code(ErrorCodes.ErrorDatabaseError.value)
result.status.set_message(
ErrorCodes.ErrorDatabaseError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
if units_list is not None:
result.result = Converter.fill_units(unit_list=units_list)
except Exception as e:
self.logger.error("get_reservation_units: {}".format(e))
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def get_broker_query_model(
self, *, broker: ID, caller: AuthToken, id_token: str, level: int,
graph_format: GraphFormat) -> ResultBrokerQueryModelAvro:
result = ResultBrokerQueryModelAvro()
result.status = ResultAvro()
if broker is None or caller is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(
ErrorCodes.ErrorInvalidArguments.interpret())
return result
try:
if id_token is not None:
AccessChecker.check_access(
action_id=ActionId.query,
resource_type=AuthResourceType.resources,
token=id_token,
logger=self.logger,
actor_type=self.client.get_type())
b = self.client.get_broker(guid=broker)
if b is not None:
request = BrokerPolicy.get_broker_query_model_query(
level=level, bqm_format=graph_format)
response = ManagementUtils.query(actor=self.client,
actor_proxy=b,
query=request,
id_token=id_token)
result.model = Translate.translate_to_broker_query_model(
query_response=response, level=level)
else:
result.status.set_code(ErrorCodes.ErrorNoSuchBroker.value)
result.status.set_message(
ErrorCodes.ErrorNoSuchBroker.interpret())
except Exception as e:
self.logger.error("get_broker_query_model {}".format(e))
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(
result=result.status, e=e)
return result
def modify_reservation(self, *, rid: ID, modify_properties: dict,
caller: AuthToken) -> ResultAvro:
result = ResultAvro()
if rid is None or modify_properties is None:
result.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
self.logger.debug("reservation: {} | modifyProperties= {}".format(
rid, modify_properties))
try:
class Runner(ABCActorRunnable):
def __init__(self, *, actor: ABCActorMixin):
self.actor = actor
def run(self):
result = ResultAvro()
r = self.actor.get_reservation(rid=rid)
if r is None:
result.set_code(
ErrorCodes.ErrorNoSuchReservation.value)
result.set_message(
ErrorCodes.ErrorNoSuchReservation.interpret())
return result
self.actor.modify(reservation_id=rid,
modify_properties=modify_properties)
return result
result = self.client.execute_on_actor_thread_and_wait(
runnable=Runner(actor=self.client))
except Exception as e:
self.logger.error("modify_reservation {}".format(e))
result.set_code(ErrorCodes.ErrorInternalError.value)
result.set_message(
ErrorCodes.ErrorInternalError.interpret(exception=e))
result = ManagementObject.set_exception_details(result=result, e=e)
return result
def maintenance_request(self, *, request: MaintenanceRequestAvro) -> ResultStringAvro:
result = ResultStringAvro()
result.status = ResultAvro()
try:
if request.actor_guid is None:
result.status.set_code(ErrorCodes.ErrorInvalidArguments.value)
result.status.set_message(ErrorCodes.ErrorInvalidArguments.interpret())
return result
mo = self.get_actor_mo(guid=ID(uid=request.actor_guid))
mode_str = request.get_properties().get(Constants.MODE)
mode = json.loads(mode_str.lower())
mo.toggle_maintenance_mode(mode=mode)
except Exception as e:
result.status.set_code(ErrorCodes.ErrorInternalError.value)
result.status.set_message(ErrorCodes.ErrorInternalError.interpret(exception=e))
result.status = ManagementObject.set_exception_details(result=result.status, e=e)
result.message_id = request.message_id
return result
