def delete_port(auth_info, port_id): neutron = neutronbase.get_neutron_default(fun_name(), auth_info) try: neutron.delete_port(port_id) except NeutronClientException as e: logger.warn("[%s]NeutronClientException: %s", fun_name(), e.message) return [0, e.message] return [0, "Port(%s) is deleted" % port_id]
def delete_subnet(auth_info, subnet_id): neutron = neutronbase.get_neutron_default(fun_name(), auth_info) try: neutron.delete_subnet(subnet_id) except NeutronClientException as e: logger.warn("[%s]NetworkNotFoundClient: %s", fun_name(), e.message) return [0, e.message] return [0, "Subnet(%s) is deleted" % subnet_id]
def rollback(neutron, network_data): for subnet_data in network_data["subnet_list"]: if subnet_data[const.RES_TYPE_KEY] == const.RES_TYPE_NEW: try: logger.info("[%s]call neutron.delete_subnet(%s)" % (fun_name(), subnet_data["id"])) neutron.delete_subnet(subnet_data["subnet_id"]) except: logger.error("[%s]%s", fun_name(), str(sys.exc_info())) if network_data and network_data[const.RES_TYPE_KEY] == const.RES_TYPE_NEW: try: logger.info("[%s]call neutron.delete_network(%s)" % (fun_name(), network_data["id"])) neutron.delete_network(network_data["id"]) except: logger.error("[%s]%s", fun_name(), str(sys.exc_info()))
def create_image(auth_info, data): ret = None glance = glancebase.get_glance(fun_name(), auth_info) exist_img = [ img for img in glance.images.list() if img.name == data["image_name"] ] if exist_img: ret = [ 0, { "id": exist_img[0].id, "name": data["image_name"], const.RES_TYPE_KEY: const.RES_TYPE_EXIST } ] else: img = glance.images.create(name=data["image_name"], disk_format=data["image_type"], visibility='public', container_format='bare') ret = [ 0, { "id": img.id, "name": data["image_name"], const.RES_TYPE_KEY: const.RES_TYPE_NEW } ] try: ImageUploadThread(glance, img.id, data["image_path"]).start() except: logger.error(traceback.format_exc()) logger.error(str(sys.exc_info())) return ret
def login(connect_info): url, user = connect_info["url"], connect_info["user"] passwd, tenant = connect_info["passwd"], connect_info["tenant"] cacert, clientcert, clientkey = None, None, None insecure = url.startswith('https') logger.info( "[%s]client.Client(auth_url='%s'," "username='******',password='******'," "tenant_name='%s',insecure=%s,cert='%s',key='%s',cacert='%s')" % (fun_name(), url, user, passwd, tenant, insecure, clientcert, clientkey, cacert)) connect_info["cacert"] = cacert connect_info["clientcert"] = clientcert connect_info["clientkey"] = clientkey connect_info["insecure"] = insecure connect_info["keystone"] = client.Client(auth_url=url, username=user, password=passwd, interface='public', tenant_name=tenant, insecure=insecure, cert=clientcert, key=clientkey, cacert=cacert, debug=True) ret = [0, connect_info] return ret
def delete_image(auth_info, image_id): from glanceclient.exc import HTTPNotFound glance = glancebase.get_glance(fun_name(), auth_info) try: glance.images.delete(image_id) except HTTPNotFound: logger.warn("Exception: %s" % str(sys.exc_info())) return [0, "Image(%s) does not exist" % image_id] return [0, "Image(%s) has been deleted" % image_id]
def create_api(self, connectInfo): vimtype = connectInfo['vimtype'] if 'vimtype' in connectInfo else None logger.info("call %s, vimtype=%s" % (fun_name(), vimtype)) if vimtype == const.VIM_OPENSTACK: from lcm.pub.nfvi.vim.api.openstack.api import OpenstackApi self.apiImpl = OpenstackApi() elif vimtype == const.VIM_VMWARE: from lcm.pub.nfvi.vim.api.multivim.api import MultiVimApi self.apiImpl = MultiVimApi() else: self.authInfo = [1, "Unsupported vimtype(%s)" % vimtype]
def delete_network(auth_info, network_id): neutron = neutronbase.get_neutron_default(fun_name(), auth_info) try: neutron.delete_network(network_id) except Exception as ex: logger.error(traceback.format_exc()) msg = ex.message if ex.message else str(sys.exc_info()) logger.error(msg) if 404 == ex.status_code: return [0, ex.message] return [1, "Vim exception."] return [0, "Network(%s) is deleted" % network_id]
def get_image(auth_info, image_id): from glanceclient.exc import HTTPNotFound glance = glancebase.get_glance(fun_name(), auth_info) img = None try: img = glance.images.get(image_id) except HTTPNotFound: logger.warn("Exception: %s" % str(sys.exc_info())) return [2, "Image(%s) does not exist" % image_id] ret_img_info = get_single_image(img) if 'status' in ret_img_info and 'deleted' == ret_img_info["status"]: return [2, "Image(%s) is deleted" % image_id] return [0, ret_img_info]
def force_login(self, connectInfo): if self.apiImpl: logger.info("call %s(%s)" % (fun_name(), connectInfo)) try: self.authInfo = self.apiImpl.login(connectInfo) except VimException as e: self.authInfo = [1, e.args[0]] except Exception as e: logger.error(traceback.format_exc()) logger.error(str(sys.exc_info())) self.authInfo = [ 1, e.args[0] if e.args[0] else str(sys.exc_info()) ] except: logger.error(traceback.format_exc()) self.authInfo = [1, str(sys.exc_info())] logger.info("self.authInfo=%s" % self.authInfo)
def query_subnet(auth_info, subnet_id): neutron = neutronbase.get_neutron_default(fun_name(), auth_info) subnet_info = None try: subnet_info = neutron.show_subnet(subnet_id)["subnet"] except SubnetNotFound as e: logger.warn("SubnetNotFound: %s", e.message) return [2, e.message] ret = [0, {}] ret[1]["id"] = subnet_id ret[1]["name"] = subnet_info["name"] ret[1]["status"] = "" ret[1]["ip_version"] = subnet_info["ip_version"] ret[1]["cidr"] = subnet_info["cidr"] ret[1]["allocation_pools"] = subnet_info["allocation_pools"] ret[1]["enable_dhcp"] = subnet_info["enable_dhcp"] ret[1]["gateway_ip"] = subnet_info["gateway_ip"] ret[1]["host_routes"] = subnet_info["host_routes"] ret[1]["dns_nameservers"] = subnet_info["dns_nameservers"] return ret
def create_subnet(neutron, network_id, data): all_subnets = neutron.list_subnets() filter_subnets = [subnet for subnet in all_subnets["subnets"] if subnet["network_id"] == network_id and subnet["name"] == data["subnet_name"]] if filter_subnets: return [0, { "id": filter_subnets[0]["id"], "name": data["subnet_name"], const.RES_TYPE_KEY: const.RES_TYPE_EXIST}] try: create_params = { 'subnet': { 'network_id': network_id, 'name': data["subnet_name"], 'cidr': data["cidr"], 'ip_version': int(data["ip_version"]) if "ip_version" in data else const.IPV4, }} create_params["subnet"]["enable_dhcp"] = ("enable_dhcp" in data and int(data["enable_dhcp"]) == const.ENABLE_DHCP) if "gateway_ip" in data and data["gateway_ip"]: create_params["subnet"]["gateway_ip"] = data["gateway_ip"] else: create_params["subnet"]["gateway_ip"] = None if "dns_nameservers" in data and data["dns_nameservers"]: create_params["subnet"]["dns_nameservers"] = data["dns_nameservers"] if "allocation_pools" in data and data["allocation_pools"]: create_params["subnet"]["allocation_pools"] = data["allocation_pools"] if "host_routes" in data and data["host_routes"]: create_params["subnet"]["host_routes"] = data["host_routes"] logger.info("[%s]call neutron.create_subnet(%s)" % (fun_name(), str(create_params))) subnet_created = neutron.create_subnet(create_params) return [0, {"id": subnet_created["subnet"]["id"], "name": data["subnet_name"], const.RES_TYPE_KEY: const.RES_TYPE_NEW}] except Exception as ex: logger.error(traceback.format_exc()) logger.error(str(sys.exc_info())) return [1, ex.message if ex.message else str(sys.exc_info())]
def query_nets(auth_info): neutron = neutronbase.get_neutron_default(fun_name(), auth_info) keystone = auth_info["keystone"] tenants_map = {} tenants = keystone.tenants.list() for tenant in tenants: tenants_map[tenant.id] = tenant.name nets = neutron.list_networks() return [0, {"networks": [{ "id": net["id"], "name": net["name"], "status": net["status"], "admin_state_up": net["admin_state_up"], "network_type": net["provider:network_type"], "physical_network": net["provider:physical_network"], "segmentation_id": net["provider:segmentation_id"], "tenant_id": net["tenant_id"], "tenant_name": tenants_map[net["tenant_id"]] if net["tenant_id"] in tenants_map else "unknown", "subnets": net["subnets"], "shared": net["shared"], "router_external": net["router:external"] } for net in nets["networks"]]}]
def query_port(auth_info, port_id): neutron = neutronbase.get_neutron_default(fun_name(), auth_info) port_info = None try: port_info = neutron.show_port(port_id)["port"] except NeutronClientException as e: logger.warn("NeutronClientException: %s", e.message) return [2, e.message] ret = [0, {}] ret[1]["id"] = port_id ret[1]["name"] = port_info["name"] ret[1]["network_id"] = port_info["network_id"] ret[1]["tenant_id"] = port_info["tenant_id"] if "fixed_ips" in port_info and port_info["fixed_ips"]: ret[1]["ip"] = port_info["fixed_ips"][0]["ip_address"] ret[1]["subnet_id"] = port_info["fixed_ips"][0]["subnet_id"] else: ret[1]["ip"] = "" ret[1]["subnet_id"] = "" ret[1]["mac_address"] = port_info["mac_address"] ret[1]["status"] = port_info["status"] ret[1]["admin_state_up"] = port_info["admin_state_up"] ret[1]["device_id"] = port_info["device_id"] return ret
def query_net(auth_info, net_id): neutron = neutronbase.get_neutron_default(fun_name(), auth_info) net = None try: net = neutron.show_network(net_id)["network"] keystone = auth_info["keystone"] tenant = keystone.tenants.get(tenant_id=net["tenant_id"]) except NetworkNotFoundClient as e: logger.warn("NetworkNotFoundClient: %s", e.message) return [2, e.message] return [0, { "id": net["id"], "name": net["name"], "status": net["status"], "admin_state_up": net["admin_state_up"], "network_type": net["provider:network_type"], "physical_network": net["provider:physical_network"], "segmentation_id": net["provider:segmentation_id"], "tenant_id": net["tenant_id"], "tenant_name": tenant.name, "subnets": net["subnets"], "shared": net["shared"], "router_external": net["router:external"] }]
def query_subnet(self, subnet_id): return self.api_call(fun_name(), self.apiImpl.query_subnet, subnet_id)
def query_nets(self): return self.api_call(fun_name(), self.apiImpl.query_nets)
def create_api(self, connectInfo): vimtype = connectInfo['vimtype'] if 'vimtype' in connectInfo else None logger.info("call %s, vimtype=%s" % (fun_name(), vimtype)) from lcm.pub.nfvi.vim.api.multivim.api import MultiVimApi self.apiImpl = MultiVimApi()
def delete_port(self, port_id): return self.api_call(fun_name(), self.apiImpl.delete_port, port_id)
def get_image(self, image_id): return self.api_call(fun_name(), self.apiImpl.get_image, image_id)
def delete_network(self, network_id): return self.api_call(fun_name(), self.apiImpl.delete_network, network_id)
def create_network(self, data): return self.api_call(fun_name(), self.apiImpl.create_network, data)
def delete_image(self, image_id): return self.api_call(fun_name(), self.apiImpl.delete_image, image_id)
def create_port(auth_info, data): tenant_id = project.get_tenant_id(fun_name(), auth_info, data["tenant_name"]) neutron_admin = neutronbase.get_neutron_default(fun_name(), auth_info) all_nets = neutron_admin.list_networks() filter_nets = [net for net in all_nets['networks'] if net['name'] == data["network_name"]] sel_nets = [net for net in filter_nets if net['tenant_id'] == tenant_id or (net['tenant_id'] != tenant_id and net['shared'])] count_sel_nets = len(sel_nets) if 1 > count_sel_nets: logger.error("Network(%s) does not exist" % data["network_name"]) raise VimException("Network(%s) does not exist" % data["network_name"]) if 1 < count_sel_nets: for net in sel_nets: logger.error("net_id=%s", net["id"]) raise VimException("%d networks(%s) exist in tenant(%s)" % (count_sel_nets, data["network_name"], data["tenant_name"])) network_id = sel_nets[0]['id'] if tenant_id != sel_nets[0]['tenant_id']: neutron = neutronbase.get_neutron_by_tenant_id(fun_name(), auth_info, sel_nets[0]['tenant_id']) else: neutron = neutronbase.get_neutron(fun_name(), auth_info, data["tenant_name"]) # get subnet id subnet_id = get_subnet_id(neutron_admin, data, network_id) # check port port_data = None ports = neutron.list_ports() sel_ports = [port for port in ports['ports'] if port['tenant_id'] == tenant_id and port['network_id'] == network_id] filter_ports = [] for port in sel_ports: if port['name'] == data["port_name"] and port['fixed_ips']: for fixed_ip in port['fixed_ips']: if fixed_ip['subnet_id'] == subnet_id: filter_ports.append(port) break count_filter_ports = len(filter_ports) if 1 < count_filter_ports: for port in filter_ports: logger.error("port_id=%s", port["id"]) raise VimException("%d port(%s) exist in subnet(%s)" % (count_filter_ports, data["port_name"], data["subnet_name"])) if 1 == len(filter_ports): logger.debug("Port(%s) is exist!" % data["port_name"]) port_data = {'status': filter_ports[0]['status'], 'id': filter_ports[0]['id'], 'name': filter_ports[0]['name'], 'network_id': filter_ports[0]['network_id'], const.RES_TYPE_KEY: const.RES_TYPE_EXIST} return [0, port_data] # create port create_param = {'port': { 'name': data["port_name"], 'admin_state_up': True, 'network_id': network_id, 'security_groups': [], 'tenant_id': tenant_id}} if "mac_address" in data and data["mac_address"]: create_param['port']['mac_address'] = data["mac_address"] if "vnic_type" in data and data["vnic_type"]: create_param['port']['binding:vnic_type'] = data["vnic_type"] if "bandwidth" in data and data["bandwidth"]: create_param['port']['bandwidth'] = int(data["bandwidth"]) if "bond" in data and data["bond"]: create_param['port']['bond'] = int(data["bond"]) if "macbond" in data and data["macbond"]: if 'mac_address' in create_param['port']: create_param['port']['mac_address'] += (',' + data["macbond"]) else: create_param['port']['mac_address'] = data["macbond"] if "ip" in data and data["ip"]: if subnet_id: create_param['port']['fixed_ips'] = [{"subnet_id": subnet_id, "ip_address": data["ip"]}] if "allowed_address_pairs" in data and data["allowed_address_pairs"]: create_param['port']['allowed_address_pairs'] = data["allowed_address_pairs"] logger.info("[%s]call neutron.create_port(%s)" % (fun_name(), str(create_param))) port_created = None try: port_created = neutron.create_port(create_param) except NeutronClientException as ex: logger.info("create_port exception: %s, %s", str(sys.exc_info()), ex.message) create_param['port'].pop('security_groups') if 'allowed_address_pairs' in create_param['port']: create_param['port'].pop('allowed_address_pairs') logger.info("[%s]recall neutron.create_port(%s)" % (fun_name(), str(create_param))) port_created = neutron.create_port(create_param) if port_created: port_data = {'status': port_created['port']['status'], 'id': port_created['port']['id'], 'name': port_created['port']['name'], 'network_id': port_created['port']['network_id'], const.RES_TYPE_KEY: const.RES_TYPE_NEW} return [0, port_data]
def create_network(auth_info, data): neutron = neutronbase.get_neutron(fun_name(), auth_info, data["tenant"]) tenant_id = project.get_tenant_id(fun_name(), auth_info, data["tenant"]) neutron_admin = neutronbase.get_neutron_default(fun_name(), auth_info) all_nets = neutron_admin.list_networks() filter_nets = [net for net in all_nets['networks'] if net['name'] == data["network_name"]] sel_nets = [net for net in filter_nets if net['tenant_id'] == tenant_id or (net['tenant_id'] != tenant_id and net['shared'])] count_sel_nets = len(sel_nets) if 1 < count_sel_nets: for sel_net in sel_nets: logger.info("net_id=%s, net_tenant_id=%s", sel_net["id"], sel_net['tenant_id']) raise VimException("Already %d networks are found with name %s" % (count_sel_nets, data["network_name"])) network_data = None if sel_nets: if sel_nets[0]['tenant_id'] != tenant_id: neutron = neutronbase.get_neutron_by_tenant_id(fun_name(), auth_info, sel_nets[0]['tenant_id']) all_subnets = neutron_admin.list_subnets() filter_subnets = [subnet for subnet in all_subnets["subnets"] if subnet["network_id"] == sel_nets[0]["id"]] network_data = {"status": sel_nets[0]["status"], "id": sel_nets[0]["id"], "name": data["network_name"], "provider:segmentation_id": sel_nets[0]["provider:segmentation_id"], "provider:network_type": sel_nets[0]["provider:network_type"], const.RES_TYPE_KEY: const.RES_TYPE_EXIST, "subnet_list": [{ "id": subnet["id"], "name": subnet["name"], const.RES_TYPE_KEY: const.RES_TYPE_EXIST } for subnet in filter_subnets]} else: create_params = { 'network': { 'name': data["network_name"], 'admin_state_up': True, 'tenant_id': tenant_id, 'shared': "shared" in data and int(data["shared"]) == const.SHARED_NET}} if "mtu" in data and int(data["mtu"]) != const.DEFAULT_MTU: create_params['network']['mtu'] = int(data["mtu"]) if "vlan_transparent" in data and int(data["vlan_transparent"]) == const.SUPPORT_VLAN_TRANSPARENT: create_params['network']['vlan-transparent'] = True if "network_type" in data and data['network_type']: create_params['network']['provider:network_type'] = data['network_type'] if "segmentation_id" in data and data['segmentation_id']: create_params['network']['provider:segmentation_id'] = int(data['segmentation_id']) if "physical_network" in data and data['physical_network']: create_params['network']['provider:physical_network'] = data['physical_network'] logger.info("[%s]call neutron.create_network(%s)" % (fun_name(), str(create_params))) network_created = neutron.create_network(create_params) network_data = {"status": network_created['network']['status'], "id": network_created['network']['id'], "name": data["network_name"], "provider:segmentation_id": network_created['network']['provider:segmentation_id'], "provider:network_type": network_created['network']['provider:network_type'], const.RES_TYPE_KEY: const.RES_TYPE_NEW, "subnet_list": []} # subnet create exist_subnet_names = [subnet["name"] for subnet in network_data["subnet_list"]] need_rollback, ret_error = False, None if "subnet_list" in data and data["subnet_list"]: for subnet_data in data["subnet_list"]: if subnet_data["subnet_name"] in exist_subnet_names: continue ret = create_subnet(neutron, network_data["id"], subnet_data) if ret[0] != 0: need_rollback, ret_error = True, ret break network_data["subnet_list"].append(ret[1]) # rollback when failed to create subnet if need_rollback: rollback(neutron_admin, network_data) return ret_error return [0, network_data]
def query_port(self, port_id): return self.api_call(fun_name(), self.apiImpl.query_port, port_id)
def create_image(self, data): return self.api_call(fun_name(), self.apiImpl.create_image, data)
def delete_subnet(self, subnet_id): return self.api_call(fun_name(), self.apiImpl.delete_subnet, subnet_id)
def get_images(self): return self.api_call(fun_name(), self.apiImpl.get_images)
def create_port(self, data): return self.api_call(fun_name(), self.apiImpl.create_port, data)