def main(): # Clean logger.info("Clean memcached before init") memcached_host, memcached_port = get_memcached_config() mem_nfv = MemcachedNFV(memcached_host, memcached_port) mem_nfv.clean_memcached() mem_nfv.disconnect() # Init server list init_server_cached_list_api() # Scheduler for get statistic data_config = read_config_json_file(NFV_CONFIG_PATH) interval = int(data_config['interval']) executors = { 'default': { 'type': 'threadpool', 'max_workers': 20 }, 'processpool': ProcessPoolExecutor(max_workers=5) } job_defaults = {'coalesce': False, 'max_instances': 3} scheduler = BlockingScheduler() scheduler.configure(executors=executors, job_defaults=job_defaults) scheduler.add_job(scheduler_get_statistic_job, 'interval', seconds=interval) scheduler.start()
def get_used_addresses_on_bam(memcache): used_ipv4 = memcache.get_network("used_ipv4") used_ipv6 = memcache.get_network("used_ipv6") if used_ipv4: return used_ipv4, used_ipv6 if not is_check_available_bam(): return [], [] data_config = read_config_json_file(NFV_CONFIG_PATH) configuration_name = data_config['bam_config_name'] configuration_id = get_configuration_id(configuration_name) g.user.logger.info( 'Get list server of configure_id {}'.format(configuration_id)) servers = get_list_servers(configuration_id) ipv4_addresses, ipv6_addresses = [], [] for server in servers: server_mng_ip = get_list_ip_in_bam(server, "defaultInterfaceAddress") server_srv_ipv4 = get_list_ip_in_bam(server, "servicesIPv4Address") server_srv_ipv6 = get_list_ip_in_bam(server, "servicesIPv6Address") if server_mng_ip not in ipv4_addresses: ipv4_addresses.append(server_mng_ip) if server_srv_ipv4 is not None and server_srv_ipv4 not in ipv4_addresses: ipv4_addresses.append(server_srv_ipv4) if server_srv_ipv6 is not None and server_srv_ipv6 not in ipv6_addresses: ipv6_addresses.append(server_srv_ipv6) if ipv4_addresses: ipv4_str = ",".join(ipv4_addresses) memcache.set_network("used_ipv4", ipv4_str) if ipv6_addresses: ipv6_str = ",".join(ipv6_addresses) memcache.set_network("used_ipv6", ipv6_str) return ipv4_addresses, ipv6_addresses
def get_log_level(self): """ Get level log :return: """ nfv_config = read_config_json_file(NFV_CONFIG_PATH) logging_text_level = nfv_config["log_level"] return map_text_log_level(logging_text_level)
def init_server_cached_list_api(): """[Call api to gateway init server bam and bdds to memcached] """ data_config = read_config_json_file(NFV_CONFIG_PATH) logger.info("Statistics collection-init_server_cached_list_api") result = gateway_access.request_data( 'gateway_nfv_plugin/init_server_cached_list', data_config['bam'][0]['ip']) logger.info( "Statistics collection-init_server_cached_list_api - {}".format( result))
def init_server_cached_list(): """[init_server_cached_list: call api get servers in bam with CONFIGURATION_NAME] Returns: [json] -- [ Success: return {"Status": "SUCCESS"} Fail: return {"Status": "FAIL"}] """ try: data_config = read_config_json_file(NFV_CONFIG_PATH) memcached_host = data_config['memcached_host'] memcached_port = int(data_config['memcached_port']) configuration_name = data_config['bam_config_name'] g.user.logger.debug( 'Init_server_cached_list - configuration_name: {}'.format( configuration_name)) configuration_id = gateway_nfv_management.get_configuration_id( configuration_name) g.user.logger.info( 'Get list server of configure_id {}'.format(configuration_id)) list_servers = gateway_nfv_management.get_list_servers( configuration_id) g.user.logger.info( 'Init_server_cached_list - Number of get list server: {}'.format( len(list_servers))) # Init memcached mem_nfv = MemcachedNFV(memcached_host, memcached_port) # Set bam server info to memcached server bam_ip = data_config['bam'][0]['ip'] bam_name = data_config['bam'][0]['name'] mem_nfv.set_server({ 'name': bam_name, 'ipv4_address': bam_ip }, ServerType.BAM) # Set bdds server info to memcached server list_udf_name = [udf['name'] for udf in data_config['udfs_for_server']] for server in list_servers: mem_nfv.set_server(server, ServerType.BDDS, bam_ip, list_udf_name) # Set VM_HOST server info to memcached server vm_host_ip = data_config["vm_host_ip"] vm_name = data_config['vm_host_name'] mem_nfv.set_server({ 'name': vm_name, 'ipv4_address': vm_host_ip }, ServerType.VM_HOST) mem_nfv.disconnect() except Exception as exception: g.user.logger.error('Init_server_cached_list - {}'.format(exception)) g.user.logger.error(traceback.format_exc()) return jsonify({"Status": "FAIL"}) return jsonify({"Status": "SUCCESS"})
def get_metadata(): """ Get metadata from NFV_CONFIG_PATH :return: metadata """ data_config = read_config_json_file(NFV_CONFIG_PATH) list_metadata = [] for udf in data_config['udfs_for_server']: tmp = udf['name'] + '=' + str(udf['default_value']) list_metadata.append(tmp) metadata = '|'.join(list_metadata) return metadata
def get_memcached_config(): """[Get memcached config from nfv_config.json] Raises: Exception -- [Can not get config memcached from nfv_config.json] Returns: [String] -- [memcached_host] [Int] -- [memcached_host] """ data_config = read_config_json_file(NFV_CONFIG_PATH) try: memcached_host = data_config["memcached_host"] memcached_port = data_config["memcached_port"] except KeyError: raise KeyError("Can not get config memcached from nfv_config.json") return memcached_host, int(memcached_port)
def is_check_available_bam(): """ Check bam available :return: [True]- boolean [False]- boolean """ data_config = read_config_json_file(NFV_CONFIG_PATH) bam_ip = data_config['bam'][0]['ip'] try: check_status = urllib.request.urlopen(f"http://{bam_ip}").getcode() if check_status == 200: g.user.logger.info('Available for BAM IP : %s' % bam_ip) return True except URLError as ex: g.user.logger.info(f"Not available for BAM IP : {bam_ip} {ex}") return False
def get_memcached_config(): """[Get memcached config from NFV_CONFIG_PATH] Raises: Exception -- [Can not get config memcached from NFV_CONFIG_PATH] Returns: [String] -- [memcached_host] [Int] -- [memcached_host] """ data_config = read_config_json_file(NFV_CONFIG_PATH) try: memcached_host = data_config['memcached_host'] memcached_port = data_config['memcached_port'] except KeyError: raise KeyError("Can not get config memcached from NFV_CONFIG_PATH") logger.debug("Memcached_host: {} - Memcached_port: {}".format( memcached_host, memcached_port)) return memcached_host, int(memcached_port)
def call_k1_api(result_object, timeout=1): """[Call K1 API] :param result_object: :param timeout: default 1 :return: """ if not result_object: logger.debug("Result_object is none") return payload = prepare_payload_for_k1(result_object) logger.info(f'Payload of K1: {payload}') if is_kpi_none(payload): logger.info(f'KPIs are none. Do not call api k1') return data_config = read_config_json_file(NFV_CONFIG_PATH) headers = { 'Content-Type': 'application/json;charset=UTF-8', } try: host = data_config['k1_api']['address'] port = data_config['k1_api']['port'] uri = data_config['k1_api']['uri'] response = requests.post(f"http://{host}:{port}{uri}", headers=headers, data=json.dumps(payload), timeout=timeout) result_call = { 'content': response.content.decode('utf-8'), 'status_code': response.status_code } logger.info(f'Result call api k1: {result_call}') except KeyError as key_error: logger.error("Cannot get {} in config file {}".format(key_error)) logger.debug(traceback.format_exc()) except requests.RequestException: logger.error("Cannot request api to {}".format( data_config['k1_api']['address'])) logger.error("Payload of the failed request: {}".format(payload)) logger.debug(traceback.format_exc())
def get_available_addresses(management_network, service_network): management_ipv4_network = management_network.get("ip_v4", {}) if not management_ipv4_network: raise ValueError('Invalid management network data') management_ipv6_network = management_network.get("ip_v6", {}) mgnt_ipv4_cidr, mgnt_ipv4_start_ip, mgnt_ipv4_end_ip, mgnt_ipv4_gateway = get_network_detail( management_ipv4_network) mngt_ipv4_net_size = mgnt_ipv4_cidr.split("/")[1] mgnt_ipv6_cidr, mgnt_ipv6_start_ip, mgnt_ipv6_end_ip, mgnt_ipv6_gateway = get_network_detail( management_ipv6_network) if mgnt_ipv6_cidr: mngt_ipv6_net_size = mgnt_ipv6_cidr.split("/")[1] if all(e != "" for e in [ mgnt_ipv4_cidr, mgnt_ipv4_start_ip, mgnt_ipv4_end_ip, mgnt_ipv4_gateway ]): data_config = read_config_json_file(NFV_CONFIG_PATH) memcached_host = data_config['memcached_host'] memcached_port = int(data_config['memcached_port']) mem_nfv = MemcachedNFV(memcached_host, memcached_port) srv_ipv4_network = service_network.get("ip_v4", {}) srv_ipv6_network = service_network.get("ip_v6", {}) srv_cidr, srv_start_ip, srv_end_ip, srv_gateway = get_network_detail( srv_ipv4_network) srv_ipv6_cidr, srv_ipv6_start_ip, srv_ipv6_end_ip, srv_ipv6_gateway = get_network_detail( srv_ipv6_network) used_ipv4, used_ipv6 = get_used_addresses_on_bam(mem_nfv) if mgnt_ipv4_gateway: used_ipv4.append(mgnt_ipv4_gateway) if mgnt_ipv6_gateway: used_ipv6.append(mgnt_ipv6_gateway) if srv_gateway: used_ipv4.append(srv_gateway) if srv_ipv6_gateway: used_ipv6.append(srv_ipv6_gateway) mgnt_ipv4 = get_ip_in_list_in_used_ips(mem_nfv, mgnt_ipv4_start_ip, mgnt_ipv4_end_ip, used_ipv4) mgnt_ipv4_str = mgnt_ipv4 + "/" + mngt_ipv4_net_size mem_nfv.set_network(mgnt_ipv4, "0", 1800) if mgnt_ipv6_cidr: mgnt_ipv6 = get_ip_in_list_in_used_ips(mem_nfv, mgnt_ipv6_start_ip, mgnt_ipv6_end_ip, used_ipv6) mgnt_ipv6_str = mgnt_ipv6 + "/" + mngt_ipv6_net_size mem_nfv.set_network(mgnt_ipv6, "0", 1800) srv_ip_str = "" srv_ipv6_str = "" srv_ip = "" srv_ipv6_ip = "" if srv_cidr: srv_ip = get_ip_in_list_in_used_ips(mem_nfv, srv_start_ip, srv_end_ip, used_ipv4) if srv_ipv6_cidr: srv_ipv6_ip = get_ip_in_list_in_used_ips(mem_nfv, srv_ipv6_start_ip, srv_ipv6_end_ip, used_ipv6) if srv_ip: srv_ipv4_net_size = srv_cidr.split("/")[1] srv_ip_str = srv_ip + "/" + srv_ipv4_net_size mem_nfv.set_network(srv_ip, "0", 1800) if srv_ipv6_ip: srv_ipv6_net_size = srv_ipv6_cidr.split("/")[1] srv_ipv6_str = srv_ipv6_ip + "/" + srv_ipv6_net_size mem_nfv.set_network(srv_ipv6_ip, "0", 1800) result = dict() result["management"] = {} result["management"]["ip_v4"] = { "cidr": mgnt_ipv4_cidr, "gateway": mgnt_ipv4_gateway, "management_ipv4": mgnt_ipv4_str } if mgnt_ipv6_cidr: result["management"]["ip_v6"] = { "cidr": mgnt_ipv6_cidr, "gateway": mgnt_ipv6_gateway, "management_ipv6": mgnt_ipv6_str } if srv_cidr or srv_ipv6_cidr: result["service"] = {} if srv_cidr: tmp = { "cidr": srv_cidr, "gateway": srv_gateway, "service_ipv4": srv_ip_str } result["service"]["ip_v4"] = tmp if srv_ipv6_cidr: tmp = { "cidr": srv_ipv6_cidr, "gateway": srv_ipv6_gateway, "service_ipv6": srv_ipv6_str } result["service"]["ip_v6"] = tmp return result else: raise ValueError('Invalid management network data')
def scale_out(data): """ :param data: request in json for example: { "server_name": "bdd240s", "mgnt_server_ip": "192.168.88.240", "service_server_ipv4": "192.168.89.240", "service_server_ipv6": fdac::12, "service_server_netmask": 24, "service_server_v6_prefix": 64, "metadata": "can_scale_in=True" } :return: successful message """ try: g.user.logger.debug("Scale out request data: {}".format(data)) data_config = read_config_json_file(NFV_CONFIG_PATH) g.user.logger.debug("NFV config data: {}".format(data_config)) config_name = data_config['bam_config_name'] config_id = get_configuration_id(config_name) if not config_id: return jsonify({ "status": "Failed", "message": "Configuration id not found!" }), 404 g.user.logger.info('Starting check available server') server_ip = data['mgnt_server_ip'] server_ipv6 = None avail_server = is_check_available_server( server_ip, data_config['server_ssh_username'], data_config['server_ssh_password']) if not avail_server: return jsonify({ "status": "Failed", "message": "No available server ip!" }), 404 g.user.logger.info('Starting add server') server_properties = f"password={process_password.decrypt_password(data_config['server_deployment_password'])}|connected=true|upgrade=False" try: if data['metadata']: server_properties = f"{server_properties}|{data['metadata']}" except KeyError as exception: g.user.logger.error(str(exception)) g.user.logger.error(traceback.format_exc()) try: if (int(data['service_server_netmask']) <= 32) and (int(data['service_server_netmask']) > 0) and data['service_server_ipv4']: server_properties = f"{server_properties}|servicesIPv4Address={data['service_server_ipv4']}|servicesIPv4Netmask={cidr_to_netmask(data['service_server_netmask'])}" except KeyError as exception: g.user.logger.error(str(exception)) g.user.logger.error(traceback.format_exc()) try: if data['service_server_v6_prefix'] and data['service_server_ipv6']: server_ipv6 = data['service_server_ipv6'] + \ '/' + data['service_server_v6_prefix'] server_properties = f"{server_properties}|servicesIPv6Address={data['service_server_ipv6']}|servicesIPv6Subnet={data['service_server_v6_prefix']}" except KeyError as exception: g.user.logger.error(str(exception)) g.user.logger.error(traceback.format_exc()) if data_config['server_cap_profile']: g.user.logger.debug( f"Add server name {data['server_name']} server_ip {server_ip} profile {data_config['server_cap_profile']} properties {server_properties}" ) server_id = add_server(server_ip=server_ip, server_name=data['server_name'], config_id=config_id, profile=data_config['server_cap_profile'], properties=server_properties) else: g.user.logger.debug( f"Add server name {data['server_name']} server_ip {server_ip} properties {server_properties}" ) server_id = add_server(server_ip=server_ip, server_name=data['server_name'], config_id=config_id, properties=server_properties) g.user.logger.info('Starting create deployment roles') deploy_role = False if data_config['dns_view_names']: role_type = data.get("deploy_role", data_config['server_deploy_role']) for view_name in data_config['dns_view_names']: g.user.logger.debug( f"Create deployment role for server {data['server_name']} view_name {view_name} role_type {role_type}" ) role_id = create_deployment_roles( server_name=data['server_name'], server_id=server_id, config_id=config_id, view_name=view_name, role_type=role_type) if not role_id: g.user.logger.info( 'Cannot create deployment role for view name: %s' % view_name) continue deploy_role = True else: g.user.logger.info('dns_view_names not found!') if not deploy_role: g.user.logger.info('Cannot create any deployment roles!') return jsonify({ "status": "Failed", "message": "Create deployment role failed" }), 500 g.user.logger.info('Starting add raw option') g.user.logger.info( 'Starting deploy DNS configuration for server name: %s' % data['server_name']) deploy_server = deploy_server_config(server_id) if not deploy_server: g.user.logger.info('Deploy DNS configuration is failed!') g.user.logger.info( 'Starting wait for DNS deployment for server name: %s' % data['server_name']) deploy_status = wait_for_deployment(server_id) g.user.logger.info( 'Deployment status for server name %s, deploy status id %s' % (data['server_name'], deploy_status)) if 'anycast_config' in data_config: g.user.logger.info('Starting configure any cast') configure_anycast(server_ip, server_ipv6, data_config['server_ssh_username'], data_config['server_ssh_password'], data_config['anycast_config']) g.user.logger.info('Adding server to cache list') # Add BDDS to memcached bam_ip = data_config['bam'][0]['ip'] memcached_host = data_config['memcached_host'] memcached_port = int(data_config['memcached_port']) mem_nfv = MemcachedNFV(memcached_host, memcached_port) list_udf_name = [ value.split('=')[0].strip() for value in data['metadata'].split('|') ] mem_nfv.set_server( { 'id': server_id, 'name': data['server_name'], 'type': ServerType.BDDS, 'properties': f"defaultInterfaceAddress={server_ip}|{server_properties}" }, ServerType.BDDS, bam_ip, list_udf_name) g.user.logger.info( f"SUCCESS: Add server to memcached with info 'id': {server_id}, 'name': {data['server_name']}, 'type': {ServerType.BDDS}, 'bam_ip': {bam_ip}" ) g.user.logger.debug(f"'properties': {server_properties}") # Remove used candidate address on memcache mem_nfv.clean_network(data["mgnt_server_ip"]) mem_nfv.clean_network(data["service_server_ipv4"]) mem_nfv.clean_network(data["service_server_ipv6"]) # Add addresses to used list on memcache used_ipv4_memcache = mem_nfv.get_network("used_ipv4") used_ipv6_memcache = mem_nfv.get_network("used_ipv6") used_ipv4_memcache.append(data["mgnt_server_ip"]) if data["service_server_ipv4"]: used_ipv4_memcache.append(data["service_server_ipv4"]) if data["service_server_ipv6"]: used_ipv6_memcache.append(data["service_server_ipv6"]) ipv6_str = ",".join(used_ipv6_memcache) mem_nfv.set_network("used_ipv6", ipv6_str) ipv4_str = ",".join(used_ipv4_memcache) mem_nfv.set_network("used_ipv4", ipv4_str) except Exception as exception: g.user.logger.error(str(exception)) g.user.logger.error( f"Failed: Haven't add server to mem cached {exception}") g.user.logger.error(traceback.format_exc()) return jsonify({ "status": "Failed", "message": "Scale out failed", "error": str(exception) }), 500 return jsonify({ "status": "Successful", "message": "Scale out successfully", "error": "" }), 200
def scale_in(data): """ :param data: request in json example { "server_name": "bdd240s" } :return: successful message """ try: g.user.logger.debug("Scale out request data: {}".format(data)) data_config = read_config_json_file(NFV_CONFIG_PATH) g.user.logger.debug("NFV config data: {}".format(data_config)) config_name = data_config['bam_config_name'] config_id = get_configuration_id(config_name) if not config_id: return jsonify({"message": "Configuration id not found!"}), 404 server_name = data['server_name'] server = get_server_by_name(config_id, server_name) server_id = server['id'] if server_id == 0: return jsonify({ "status": "Failed", "message": "Scale in failed", "error": str('Server {} not found!'.format(server_name)) }), 403 if server['properties'].split('|')[0].split( '=')[0] == "defaultInterfaceAddress": server_ip = server['properties'].split('|')[0].split('=')[1] else: server_ip = server['properties'].split('|')[1].split('=')[1] # delete server roles g.user.logger.info('Starting remove server roles for server name: %s' % server_name) remove_roles = delete_server_roles(server_id) if not remove_roles: g.user.logger.info( 'Remove server roles failed! Starting stop anycast service ...' ) if 'anycast_config' in data_config: stop_anycast_service(server_ip, data_config['server_ssh_username'], data_config['server_ssh_password']) # deploy DNS server g.user.logger.info('Starting deploy DNS server for server name: %s' % server_name) deploy_server = deploy_server_config(server_id) if not deploy_server: g.user.logger.info('Deploy DNS server is failed!') # wait for deployment g.user.logger.info( 'Starting wait for DNS deployment for server name: %s' % server_name) deploy_status = wait_for_deployment(server_id) g.user.logger.info( 'Deployment status for server name %s, deploy status id %s' % (server_name, deploy_status)) g.user.logger.info('Anycast service stopped') # delete server from BAM g.user.logger.info('Deleting server %s from BAM' % server_name) delete_server = delete_entity(server_id) if not delete_server: g.user.logger.info('Delete server %s failed' % server_name) g.user.logger.info('Deleting server from cache list') bam_ip = data_config['bam'][0]['ip'] memcached_host = data_config['memcached_host'] memcached_port = int(data_config['memcached_port']) mem_nfv = MemcachedNFV(memcached_host, memcached_port) mem_nfv.delete_server(server_id, ServerType.BDDS, bam_ip) g.user.logger.info( f"SUCCESS: Delete server from memcached with info 'id': {server_id}" ) except Exception as exception: g.user.logger.error(str(exception)) g.user.logger.error(f"Failed: Can't delete server from memcached") g.user.logger.error(traceback.format_exc()) return jsonify({ "status": "Failed", "message": "Scale in failed", "error": str(exception) }), 500 return jsonify({ "status": "Successful", "message": "Scale in successfully", "error": "" }), 200
def collect_statistics(mem_nfv): """ :return: Array of statistic results """ # Get server list from memcached list_bdds, list_bam, list_vmhosts = mem_nfv.get_list_servers() logger.debug("List_bdds: {}\nList_bam: {}\nList_vmhost: {}".format( list_bdds, list_bam, list_vmhosts)) snmp_config = read_config_json_file(SNMP_CONFIG_PATH) logger.debug("Snmp config: {}".format(snmp_config)) list_servers = [] logger.info(f'List BDDS Size: {len(list_bdds)}') logger.info(f'Begin loop through list_bdds') for bdds in list_bdds: logger.debug(f'BDDS: {bdds}') bdds_config_name = get_snmp_server_config_name(snmp_config, bdds.name) logger.debug(f'BDDS config name {bdds_config_name}') try: list_servers.append({ 'server_type': ServerType.BDDS, 'server_name': bdds.name, 'address': bdds.ipv4_address, 'snmp_config_data': snmp_config[bdds_config_name], 'udf': bdds.udf }) except KeyError as exception: logger.error(f'Exception Key Error {exception}') logger.error(traceback.format_exc()) continue logger.info(f'List BAM Size: {len(list_bam)}') logger.info(f'Begin loop through list_bam') for bam in list_bam: try: logger.debug(f'BAM: {bam}') logger.debug(f'bam_name: {bam.name}') bam_config_name = get_snmp_server_config_name( snmp_config, bam.name) logger.debug(f'Bam config name {bam_config_name}') try: logger.info( f'Begin Append BAM server list Server {list_servers} ') list_servers.append({ 'server_type': ServerType.BAM, 'server_name': bam.name, 'address': bam.ipv4_address, 'snmp_config_data': snmp_config[bam_config_name] }) logger.info(f'End append BAM ===> List Server {list_servers}') except KeyError as exception: logger.error(f'Exception Key Error {exception}') logger.error(traceback.format_exc()) continue except Exception as exception: logger.info(f'Cant get bam.ipv4_address: {exception}') logger.info(f'List VMHOST Size: {len(list_vmhosts)}') logger.info(f'Begin loop through list_vmhosts') for vm_host in list_vmhosts: try: logger.debug(f'VM_HOST: {vm_host}') logger.debug(f'vm_name: {vm_host.name}') vm_host_config_name = get_snmp_server_config_name( snmp_config, vm_host.name) logger.debug(f'VM_HOST config name {vm_host_config_name}') try: logger.info( f'Begin Append VM_HOST server list Server {list_servers} ' ) list_servers.append({ 'server_type': ServerType.VM_HOST, 'server_name': vm_host.name, 'address': vm_host.ipv4_address, 'snmp_config_data': snmp_config[vm_host_config_name] }) logger.info( f'End append VM_HOST ===> List Server {list_servers}') except KeyError as exception: logger.error(f'Exception Key Error {exception}') logger.error(traceback.format_exc()) continue except Exception as exception: logger.info(f'Can not get vm_host.ip_address: {exception}') logger.info(f'Begin get statistic with list server {list_servers}') result = [] with PoolExecutor(max_workers=10) as executor: for result_object in executor.map(get_server_statistic, list_servers): result.append(result_object) return result