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 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 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
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 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 advertise_resources(self, *, delegation: ABCPropertyGraph, delegation_name: str, client: AuthToken, caller: AuthToken) -> ResultStringAvro: result = ResultStringAvro() result.status = ResultAvro() if client is None or delegation is None or caller 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, *, actor: ABCActorMixin): self.actor = actor def run(self): return self.actor.advertise( delegation=delegation, delegation_name=delegation_name, client=client) self.logger.debug("Executing advertise on actor {} {} ({})".format( self.actor.get_name(), self.actor.get_name(), self.actor.__class__.__name__)) advertised = self.actor.execute_on_actor_thread_and_wait( runnable=Runner(actor=self.actor)) result.set_result(str(advertised)) except Exception as e: self.logger.error("advertise_resources: {}".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 add_reservation(self, *, reservation: TicketReservationAvro, caller: AuthToken) -> ResultStringAvro: result = ResultStringAvro() result.status = ResultAvro() if reservation is None or reservation.get_slice_id( ) is None or caller 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): return self.parent.add_reservation_private( reservation=reservation) rid, result.status = self.client.execute_on_actor_thread_and_wait( runnable=Runner(parent=self)) if rid is not None: result.set_result(str(rid)) except Exception as e: self.logger.error("add_reservation {}".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 test_consumer_producer(self): from threading import Thread import time conf = {'metadata.broker.list': 'localhost:19092', 'security.protocol': 'SSL', 'ssl.ca.location': '../../../secrets/snakeoil-ca-1.crt', 'ssl.key.location': '../../../secrets/kafkacat.client.key', 'ssl.key.password': '******', 'ssl.certificate.location': '../../../secrets/kafkacat-ca1-signed.pem'} # Create Admin API object api = AdminApi(conf=conf) for a in api.list_topics(): print("Topic {}".format(a)) topics = ['fabric_mb-mb-public-test1', 'fabric_mb-mb-public-test2'] # create topics api.delete_topics(topics) api.create_topics(topics, num_partitions=1, replication_factor=1) # load AVRO schema key_schema = "../schema/key.avsc" value_schema = "../schema/message.avsc" conf['schema.registry.url'] = "http://localhost:8081" # create a producer producer = AvroProducerApi(producer_conf=conf, key_schema_location=key_schema, value_schema_location=value_schema) # push messages to topics id_token = 'id_token' # udd udd = UpdateDataAvro() udd.message = "message" udd.failed = False auth = AuthAvro() auth.guid = "testguid" auth.name = "testactor" auth.oidc_sub_claim = "test-oidc" # query query = QueryAvro() query.message_id = "msg1" query.callback_topic = "topic" query.properties = {"abc": "def"} query.auth = auth query.id_token = id_token #print(query.to_dict()) producer.produce("fabric_mb-mb-public-test1", query) # query_result query_result = QueryResultAvro() query_result.message_id = "msg2" query_result.request_id = "req2" query_result.properties = {"abc": "def"} query_result.auth = auth #print(query_result.to_dict()) producer.produce("fabric_mb-mb-public-test2", query_result) # FailedRPC failed_rpc = FailedRpcAvro() failed_rpc.message_id = "msg3" failed_rpc.request_id = "req3" failed_rpc.reservation_id = "rsv_abc" failed_rpc.request_type = 1 failed_rpc.error_details = "test error message" failed_rpc.auth = auth #print(failed_rpc.to_dict()) producer.produce("fabric_mb-mb-public-test2", failed_rpc) claim_req = ClaimResourcesAvro() claim_req.guid = "dummy-guid" claim_req.auth = auth claim_req.broker_id = "brokerid" claim_req.reservation_id = "rsv_id" claim_req.delegation_id = "dlg_id" claim_req.message_id = "test_claim_1" claim_req.callback_topic = "test" claim_req.slice_id = "slice_1" claim_req.id_token = id_token #print(claim_req.to_dict()) producer.produce("fabric_mb-mb-public-test2", claim_req) reservation = ReservationAvro() reservation.reservation_id = "res123" reservation.sequence = 1 reservation.slice = SliceAvro() reservation.slice.guid = "slice-12" reservation.slice.slice_name = "test_slice" reservation.slice.description = "test description" reservation.slice.owner = auth term = TermAvro() term.start_time = 1593854111999 term.end_time = 1593854111999 term.new_start_time = 1593854111999 reservation.term = term reservation.resource_set = ResourceSetAvro() reservation.resource_set.units = 0 reservation.resource_set.type = "type1" unit = UnitAvro() unit.properties = {'test': 'value'} unit.rtype = "abc" unit.state = 1 unit.sequence = 0 unit.reservation_id = 'res_123' unit.actor_id = 'act_1' unit.slice_id = 'slc_2' reservation.resource_set.unit_set = [] reservation.resource_set.unit_set.append(unit) ticket = Ticket() ticket.authority = auth ticket.old_units = 0 ticket.delegation_id = "dlg123" rt = ResourceTicketAvro() rt.units = 1 rt.holder = "ab1" rt.issuer = "si1" rt.type = "rty1" rt.properties = {"foo": "bar"} rt.guid = "gid" rt.term = term ticket.resource_ticket = rt reservation.resource_set.ticket = ticket delegation = DelegationAvro() delegation.delegation_id = "dlg123" delegation.sequence = 1 delegation.slice = SliceAvro() delegation.slice.guid = "slice-12" delegation.slice.slice_name = "test_slice" delegation.slice.description = "test description" delegation.slice.owner = auth claimd = ClaimDelegationAvro() claimd.auth = auth claimd.message_id = "msg4" claimd.callback_topic = "test" claimd.delegation = delegation claimd.id_token = id_token #print(claim.to_dict()) producer.produce("fabric_mb-mb-public-test2", claimd) # redeem redeem = RedeemAvro() redeem.message_id = "msg4" redeem.callback_topic = "test" redeem.reservation = reservation redeem.auth = auth #print(redeem.to_dict()) producer.produce("fabric_mb-mb-public-test2", redeem) update_ticket = UpdateTicketAvro() update_ticket.auth = auth update_ticket.message_id = "msg11" update_ticket.callback_topic = "test" update_ticket.reservation = reservation update_ticket.update_data = UpdateDataAvro() update_ticket.update_data.failed = False update_ticket.update_data.message = "" #print(update_ticket.to_dict()) producer.produce("fabric_mb-mb-public-test2", update_ticket) update_d = UpdateDelegationAvro() update_d.auth = auth update_d.message_id = "msg11" update_d.callback_topic = "test" update_d.delegation = delegation update_d.update_data = UpdateDataAvro() update_d.update_data.failed = False update_d.update_data.message = "" update_d.id_token = id_token #print(update_ticket.to_dict()) producer.produce("fabric_mb-mb-public-test2", update_d) get_slice = GetSlicesRequestAvro() get_slice.auth = auth get_slice.message_id = "msg11" get_slice.callback_topic = "test" get_slice.guid = "guid" get_slice.id_token = id_token #print(get_slice.to_dict()) producer.produce("fabric_mb-mb-public-test2", get_slice) result = ResultAvro() result.code = 0 slice_res = ResultSliceAvro() slice_res.message_id = "msg11" slice_res.status = result s1 = SliceAvro() s1.set_slice_name("abc") s1.set_slice_id("11111") s1.set_owner(auth) s1.set_description("abcd") prop = {} s1.set_config_properties(prop) s1.set_resource_type('site.vm') s1.set_client_slice(False) s1.set_broker_client_slice(False) slice_res.slices = [] slice_res.slices.append(s1) #print(slice_res.to_dict()) producer.produce("fabric_mb-mb-public-test2", slice_res) res_req = GetReservationsRequestAvro() res_req.message_id = "abc123" res_req.callback_topic = "test" res_req.guid = "guid" res_req.reservation_id = "res123" res_req.reservation_type = "broker" res_req.auth = auth res_req.id_token = id_token print(res_req.to_dict()) producer.produce("fabric_mb-mb-public-test2", res_req) del_req = GetDelegationsAvro() del_req.message_id = "msg1" del_req.callback_topic = "test" del_req.guid = "guid" del_req.delegation_id = "1" del_req.auth = auth del_req.id_token = id_token print(del_req.to_dict()) producer.produce("fabric_mb-mb-public-test2", del_req) res = ReservationMng() res.reservation_id = "abcd123" res.rtype = 'site.baremetalce' res.notices = 'noice' res.slice_id = "slice_1" res.start = 1264827600000 res.end = 1927515600000 res.requested_end = 1927515600000 res.state = 2 res.pending_state = 1 res_list = [res] res_res = ResultReservationAvro() res_res.message_id = res_req.message_id res_res.status = result res_res.reservations = res_list #print(res_res.to_dict()) producer.produce("fabric_mb-mb-public-test2", res_res) remove_slice = RemoveSliceAvro() remove_slice.message_id = "msg1" remove_slice.guid = 'guid1' remove_slice.slice_id = 'slice1' remove_slice.callback_topic = 'test_topic' remove_slice.auth = auth #print(remove_slice.to_dict()) producer.produce("fabric_mb-mb-public-test2", remove_slice) status_resp = ResultStringAvro() status_resp.message_id = "msg1" status_resp.result = "abc" status_resp.status = result producer.produce("fabric_mb-mb-public-test2", status_resp) add_slice = AddSliceAvro() add_slice.message_id = "msg1" add_slice.guid = 'guid1' add_slice.slice_obj = s1 add_slice.callback_topic = 'test_topic' add_slice.auth = auth # print(add_slice.to_dict()) producer.produce("fabric_mb-mb-public-test2", add_slice) update_slice = UpdateSliceAvro() update_slice.message_id = "msg1" update_slice.guid = 'guid1' update_slice.slice_obj = s1 update_slice.callback_topic = 'test_topic' update_slice.auth = auth # print(update_slice.to_dict()) producer.produce("fabric_mb-mb-public-test2", update_slice) remove_res = RemoveReservationAvro() remove_res.message_id = "msg1" remove_res.guid = 'guid1' remove_res.reservation_id = 'rid1' remove_res.callback_topic = 'test_topic' remove_res.auth = auth # print(remove_res.to_dict()) producer.produce("fabric_mb-mb-public-test2", remove_res) close_res = CloseReservationsAvro() close_res.message_id = "msg1" close_res.guid = 'guid1' close_res.reservation_id = 'rid1' close_res.callback_topic = 'test_topic' close_res.auth = auth # print(close_res.to_dict()) producer.produce("fabric_mb-mb-public-test2", close_res) update_res = UpdateReservationAvro() update_res.message_id = "msg1" update_res.guid = 'guid1' update_res.reservation_obj = res update_res.callback_topic = 'test_topic' update_res.auth = auth print(update_res.to_dict()) producer.produce("fabric_mb-mb-public-test2", update_res) ticket = TicketReservationAvro() ticket.reservation_id = "abcd123" ticket.rtype = 'site.baremetalce' ticket.notices = 'noice' ticket.slice_id = "slice_1" ticket.start = 1264827600000 ticket.end = 1927515600000 ticket.requested_end = 1927515600000 ticket.state = 2 ticket.pending_state = 1 ticket.broker = "broker1" add_res = AddReservationAvro() add_res.message_id = "msg1" add_res.guid = 'guid1' add_res.reservation_obj = ticket add_res.callback_topic = 'test_topic' add_res.auth = auth print(add_res.to_dict()) producer.produce("fabric_mb-mb-public-test2", add_res) add_ress = AddReservationsAvro() add_ress.message_id = "msg1" add_ress.guid = 'guid1' add_ress.reservation_list = [] add_ress.reservation_list.append(ticket) add_ress.callback_topic = 'test_topic' add_ress.auth = auth print(add_ress.to_dict()) producer.produce("fabric_mb-mb-public-test2", add_ress) demand_res = DemandReservationAvro() demand_res.message_id = "msg1" demand_res.guid = 'guid1' demand_res.reservation_obj = res demand_res.callback_topic = 'test_topic' demand_res.auth = auth print(demand_res.to_dict()) producer.produce("fabric_mb-mb-public-test2", demand_res) extend_res = ExtendReservationAvro() extend_res.message_id = "msg1" extend_res.guid = 'guid1' extend_res.callback_topic = 'test_topic' extend_res.auth = auth extend_res.reservation_id = "rid1" extend_res.new_units = -1 extend_res.new_resource_type = "abc" extend_res.request_properties = {'abcd':'eee'} extend_res.config_properties = {'abcd':'eee'} extend_res.end_time = int(datetime.now().timestamp()) print(extend_res.to_dict()) producer.produce("fabric_mb-mb-public-test2", extend_res) close = CloseAvro() close.message_id = "msg1" close.reservation = reservation close.callback_topic = "topic1" close.auth = auth producer.produce("fabric_mb-mb-public-test2", close) extend_lease = ExtendLeaseAvro() extend_lease.message_id = "msg1" extend_lease.reservation = reservation extend_lease.callback_topic = "topic1" extend_lease.auth = auth producer.produce("fabric_mb-mb-public-test2", extend_lease) extend_ticket = ExtendTicketAvro() extend_ticket.message_id = "msg1" extend_ticket.reservation = reservation extend_ticket.callback_topic = "topic1" extend_ticket.auth = auth producer.produce("fabric_mb-mb-public-test2", extend_ticket) modify_lease = ModifyLeaseAvro() modify_lease.message_id = "msg1" modify_lease.reservation = reservation modify_lease.callback_topic = "topic1" modify_lease.auth = auth producer.produce("fabric_mb-mb-public-test2", modify_lease) update_lease = UpdateLeaseAvro() update_lease.message_id = "msg1" update_lease.reservation = reservation update_lease.callback_topic = "topic1" update_lease.update_data = UpdateDataAvro() update_lease.update_data.failed = False update_lease.update_data.message = "success" update_lease.auth = auth producer.produce("fabric_mb-mb-public-test2", update_lease) ticket = TicketAvro() ticket.message_id = "msg1" ticket.reservation = reservation ticket.callback_topic = "topic1" ticket.auth = auth producer.produce("fabric_mb-mb-public-test2", ticket) res_state_req = GetReservationsStateRequestAvro() res_state_req.guid = "gud1" res_state_req.message_id = "msg1" res_state_req.reservation_ids = [] res_state_req.reservation_ids.append("a1") res_state_req.callback_topic = "topic1" res_state_req.auth = auth res_state_req.id_token = id_token producer.produce("fabric_mb-mb-public-test2", res_state_req) res_strings = ResultStringsAvro() res_strings.status = result res_strings.message_id = "msg1" res_strings.result = [] res_strings.result.append("r1") producer.produce("fabric_mb-mb-public-test2", res_strings) res_state = ResultReservationStateAvro() res_state.status = result res_state.message_id = "msg1" res_state.reservation_states = [] ss = ReservationStateAvro() ss.state = 1 ss.pending_state = 2 ss.rid = "rid1" res_state.reservation_states.append(ss) producer.produce("fabric_mb-mb-public-test2", res_state) ru = GetReservationUnitsRequestAvro() ru.message_id = "msg1" ru.reservation_id = "rid1" ru.guid = "gud1" ru.message_id = "msg1" ru.auth = auth ru.callback_topic = "test" ru.id_token = id_token producer.produce("fabric_mb-mb-public-test2", ru) ruu = GetUnitRequestAvro() ruu.message_id = "msg1" ruu.unit_id = "uid1" ruu.guid = "gud1" ruu.message_id = "msg1" ruu.auth = auth ruu.callback_topic = "test" ruu.id_token = id_token producer.produce("fabric_mb-mb-public-test2", ruu) bqm_query = GetBrokerQueryModelRequestAvro() bqm_query.message_id = "msg1" bqm_query.guid = "gud1" bqm_query.message_id = "msg1" bqm_query.auth = auth bqm_query.callback_topic = "test" bqm_query.broker_id = "broker11" bqm_query.id_token = id_token producer.produce("fabric_mb-mb-public-test2", bqm_query) actors_req = GetActorsRequestAvro() actors_req.message_id = "msg1" actors_req.guid = "gud1" actors_req.message_id = "msg1" actors_req.auth = auth actors_req.callback_topic = "test" actors_req.type = "Broker" actors_req.id_token = id_token producer.produce("fabric_mb-mb-public-test2", actors_req) result_unit = ResultUnitsAvro() result_unit.message_id = "msg1" result_unit.status = result result_unit.units = [] result_unit.units.append(unit) producer.produce("fabric_mb-mb-public-test2", result_unit) result_proxy = ResultProxyAvro() proxy = ProxyAvro() proxy.protocol = "kafka" proxy.name = "name" proxy.guid = "guid" proxy.type = "abcd" proxy.kafka_topic = "kafka_topic" result_proxy.message_id = "msg1" result_proxy.status = result result_proxy.proxies = [] result_proxy.proxies.append(proxy) producer.produce("fabric_mb-mb-public-test2", result_proxy) result_model = ResultBrokerQueryModelAvro() result_model.model = BrokerQueryModelAvro() result_model.model.level = 1 with open('./abqm.graphml', 'r') as f: result_model.model.model = f.read() result_model.message_id = "msg1" result_model.status = result producer.produce("fabric_mb-mb-public-test2", result_model) result_actor = ResultActorAvro() actor = ActorAvro() actor.name = "abcd" actor.owner = auth actor.description = "desc" actor.policy_module = "pol" actor.policy_class = "cll" actor.policy_guid = "guid" actor.actor_module = "module" actor.actor_class = "class" actor.id = "a1" result_actor.message_id = "msg1" result_actor.status = result result_actor.actors = [] result_actor.actors.append(actor) producer.produce("fabric_mb-mb-public-test2", result_actor) props = {"mode": "True"} maint_req = MaintenanceRequestAvro(properties=props, actor_guid="am", callback_topic="test", id_token="id_token", message_id="mesg-id-1") producer.produce("fabric_mb-mb-public-test2", maint_req) #add_peer_req = AddPeerAvro(peer=proxy, callback_topic="test", id_token="token", message_id="mg-1") #producer.produce("fabric_mb-mb-public-test2", add_peer_req) # Fallback to earliest to ensure all messages are consumed conf['auto.offset.reset'] = "earliest" print("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++") print("++++++++++++++++++++++CONSUMER+++++++++++++++++++++") print("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++") class TestConsumer(AvroConsumerApi): def set_parent(self, parent): self.parent = parent def handle_message(self, message: AbcMessageAvro): if message.get_message_name() == AbcMessageAvro.query: self.parent.validate_query(message, query) elif message.get_message_name() == AbcMessageAvro.query_result: self.parent.validate_query_result(message, query_result) elif message.get_message_name() == AbcMessageAvro.failed_rpc: self.parent.validate_failed_rpc(message, failed_rpc) elif message.get_message_name() == AbcMessageAvro.claim_resources: self.parent.validate_request_by_id(message, claim_req) elif message.get_message_name() == AbcMessageAvro.claim_delegation: self.parent.validate_reservation_or_delegation_record(message, claimd) elif message.get_message_name() == AbcMessageAvro.redeem: self.parent.validate_reservation_or_delegation_record(message, redeem) elif message.get_message_name() == AbcMessageAvro.update_ticket: self.parent.validate_reservation_or_delegation_record(message, update_ticket) elif message.get_message_name() == AbcMessageAvro.update_delegation: self.parent.validate_reservation_or_delegation_record(message, update_d) elif message.get_message_name() == AbcMessageAvro.get_slices_request: self.parent.validate_request_by_id(message, get_slice) elif message.get_message_name() == AbcMessageAvro.result_slice: self.parent.validate_result_record(message, slice_res) elif message.get_message_name() == AbcMessageAvro.get_reservations_request: self.parent.validate_request_by_id(message, res_req) elif message.get_message_name() == AbcMessageAvro.get_delegations: self.parent.validate_request_by_id(message, del_req) elif message.get_message_name() == AbcMessageAvro.result_reservation: self.parent.validate_result_record(message, res_res) elif message.get_message_name() == AbcMessageAvro.remove_slice: self.parent.validate_request_by_id(message, remove_slice) elif message.get_message_name() == AbcMessageAvro.result_string: self.parent.validate_result_string(message, status_resp) elif message.get_message_name() == AbcMessageAvro.add_slice: self.parent.validate_add_update_slice(message, add_slice) elif message.get_message_name() == AbcMessageAvro.update_slice: self.parent.validate_add_update_slice(message, update_slice) elif message.get_message_name() == AbcMessageAvro.remove_reservation: self.parent.validate_request_by_id(message, remove_res) elif message.get_message_name() == AbcMessageAvro.close_reservations: self.parent.validate_request_by_id(message, close_res) elif message.get_message_name() == AbcMessageAvro.update_reservation: self.parent.validate_add_update_reservation_record(message, update_res) elif message.get_message_name() == AbcMessageAvro.add_reservation: self.parent.validate_add_update_reservation_record(message, add_res) elif message.get_message_name() == AbcMessageAvro.add_reservations: self.parent.validate_add_reservations(message, add_ress) elif message.get_message_name() == AbcMessageAvro.demand_reservation: self.parent.validate_add_update_reservation_record(message, demand_res) elif message.get_message_name() == AbcMessageAvro.extend_reservation: self.parent.validate_extend_reservation(message, extend_res) elif message.get_message_name() == AbcMessageAvro.close: self.parent.validate_reservation_or_delegation_record(message, close) elif message.get_message_name() == AbcMessageAvro.extend_lease: self.parent.validate_reservation_or_delegation_record(message, extend_lease) elif message.get_message_name() == AbcMessageAvro.extend_ticket: self.parent.validate_reservation_or_delegation_record(message, extend_ticket) elif message.get_message_name() == AbcMessageAvro.modify_lease: self.parent.validate_reservation_or_delegation_record(message, modify_lease) elif message.get_message_name() == AbcMessageAvro.update_lease: self.parent.validate_reservation_or_delegation_record(message, update_lease) elif message.get_message_name() == AbcMessageAvro.ticket: self.parent.validate_ticket(message, ticket) elif message.get_message_name() == AbcMessageAvro.get_reservations_state_request: self.parent.validate_get_reservations_state_request(message, res_state_req) elif message.get_message_name() == AbcMessageAvro.result_strings: self.parent.validate_result_strings(message, res_strings) elif message.get_message_name() == AbcMessageAvro.result_reservation_state: self.parent.validate_result_record(message, res_state) elif message.get_message_name() == AbcMessageAvro.get_reservation_units_request: self.parent.validate_request_by_id(message, ru) elif message.get_message_name() == AbcMessageAvro.get_unit_request: self.parent.validate_request_by_id(message, ruu) elif message.get_message_name() == AbcMessageAvro.get_broker_query_model_request: self.parent.validate_request_by_id(message, bqm_query) elif message.get_message_name() == AbcMessageAvro.get_actors_request: self.parent.validate_request_by_id(message, actors_req) elif message.get_message_name() == AbcMessageAvro.result_reservation: self.parent.validate_result_record(message, res_res) elif message.get_message_name() == AbcMessageAvro.result_units: self.parent.validate_result_record(message, result_unit) elif message.get_message_name() == AbcMessageAvro.result_proxy: self.parent.validate_result_record(message, result_proxy) elif message.get_message_name() == AbcMessageAvro.result_broker_query_model: self.parent.validate_result_record(message, result_model) elif message.get_message_name() == AbcMessageAvro.result_actor: self.parent.validate_result_record(message, result_actor) elif message.get_message_name() == AbcMessageAvro.maintenance_request: self.parent.assertEqual(message, maint_req) #elif message.get_message_name() == AbcMessageAvro.add_peer: # self.parent.assertEqual(message, add_peer_req) # create a consumer conf['group.id'] = 'ssl-host' consumer = TestConsumer(consumer_conf=conf, key_schema_location=key_schema, value_schema_location=value_schema, topics=topics) consumer.set_parent(self) # start a thread to consume messages consume_thread = Thread(target=consumer.consume, daemon=True) consume_thread.start() time.sleep(10) # trigger shutdown consumer.shutdown() # delete topics api.delete_topics(topics)
def add_slice(self, *, slice_obj: SliceAvro, caller: AuthToken, id_token: str = None) -> ResultStringAvro: result = ResultStringAvro() result.status = ResultAvro() if slice_obj is None or caller is None: result.status.set_code(ErrorCodes.ErrorInvalidArguments.value) result.status.set_message( ErrorCodes.ErrorInvalidArguments.interpret()) else: try: user_dn = None user_email = None if id_token is not None: fabric_token = AccessChecker.check_access( action_id=ActionId.query, resource_type=ResourceType.slice, token=id_token, logger=self.logger, actor_type=self.actor.get_type(), resource_id=str(slice_obj.slice_name)) user_dn = fabric_token.get_decoded_token().get( Constants.CLAIMS_SUB, None) user_email = fabric_token.get_decoded_token().get( Constants.CLAIMS_EMAIL, None) if user_dn is None: result.status.set_code( ErrorCodes.ErrorInvalidToken.value) result.status.set_message( ErrorCodes.ErrorInvalidToken.interpret()) return result slice_obj_new = SliceFactory.create( slice_id=ID(), name=slice_obj.get_slice_name()) slice_obj_new.set_description( description=slice_obj.get_description()) slice_obj_new.set_owner(owner=self.actor.get_identity()) slice_obj_new.get_owner().set_oidc_sub_claim( oidc_sub_claim=user_dn) slice_obj_new.get_owner().set_email(email=user_email) slice_obj_new.set_graph_id(graph_id=slice_obj.graph_id) slice_obj_new.set_config_properties( value=slice_obj.get_config_properties()) slice_obj_new.set_lease_end( lease_end=slice_obj.get_lease_end()) slice_obj_new.set_lease_start(lease_start=datetime.utcnow()) if slice_obj.get_inventory(): slice_obj_new.set_inventory(value=True) elif slice_obj.is_broker_client_slice(): slice_obj.set_broker_client_slice(value=True) elif slice_obj.is_client_slice(): slice_obj.set_client_slice(value=True) class Runner(ABCActorRunnable): def __init__(self, *, actor: ABCActorMixin): self.actor = actor def run(self): try: self.actor.register_slice( slice_object=slice_obj_new) except Exception as e: self.actor.get_plugin().release_slice( slice_obj=slice_obj_new) raise e return None self.actor.execute_on_actor_thread_and_wait(runnable=Runner( actor=self.actor)) result.set_result(str(slice_obj_new.get_slice_id())) except Exception as e: self.logger.error("add_slice: {}".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