def get_tenant_id(funname, auth_info, tenant):
logger.debug("[%s]call get_tenant_id(%s)", funname, tenant)
keystone = auth_info["keystone"]
tids = [t.id for t in keystone.tenants.list() if t.name == tenant]
if not tids:
raise VimException("Tenant(%s) does not exist." % tenant)
logger.debug("[%s]tenant_id=%s", funname, tids[0])
return tids[0]
def login(self, connect_info):
self.vim_id = connect_info["vimid"]
self.tenant_name = connect_info["tenant"]
tenants = list_tenant(self.vim_id)
for tenant in tenants["tenants"]:
if self.tenant_name == tenant["name"]:
self.tenant_id = tenant["id"]
return [0, connect_info]
raise VimException(1, "Tenant(%s) not exist" % self.tenant_name)
def call(vim_id, tenant_id, res, method, data=''):
if data and not isinstance(data, (str, unicode)):
data = json.JSONEncoder().encode(data)
url = "{base_url}/{vim_id}{tenant_id}/{res}".format(
base_url=VIM_DRIVER_BASE_URL,
vim_id=vim_id,
tenant_id="/" + tenant_id if tenant_id else "",
res=res)
ret = req_by_msb(url, method, data)
if ret[0] > 0:
raise VimException(ret[1], ret[2])
return json.JSONDecoder().decode(ret[1]) if ret[1] else {}
def get_subnet_id(neutron, data, network_id):
subnet_id = None
if "subnet_name" in data and data["subnet_name"]:
all_subnets = neutron.list_subnets()
filter_subnets = [subnet for subnet in all_subnets["subnets"] if subnet["name"] == data["subnet_name"] and subnet["network_id"] == network_id]
count_filter_subnets = len(filter_subnets)
if 1 > count_filter_subnets:
logger.error("Subnet name(%s) does not exist" % data["subnet_name"])
raise VimException("Subnet name(%s) does not exist" % data["subnet_name"])
if 1 < count_filter_subnets:
for subnet in filter_subnets:
logger.error("subnet_id=%s", subnet["id"])
raise VimException("%d subnet(%s) exist in network(%s)"
% (count_filter_subnets, data["subnet_name"], data["network_name"]))
subnet_id = filter_subnets[0]['id']
else:
subnets = neutron.list_subnets()
filter_subnets = [subnet for subnet in subnets["subnets"] if subnet["network_id"] == network_id]
if filter_subnets:
subnet_id = filter_subnets[0]["id"]
return subnet_id
def call(vim_id, tenant_id, res, method, data=''):
if data and not isinstance(data, str):
data = json.JSONEncoder().encode(data)
vim_id = json.JSONDecoder().decode(vim_id) if isinstance(vim_id,
str) else vim_id
vim_id = "%s_%s" % (vim_id['cloud_owner'], vim_id['cloud_regionid'])
url = "{base_url}/{vim_id}{tenant_id}/{res}".format(
base_url=VIM_DRIVER_BASE_URL,
vim_id=vim_id,
tenant_id="/" + tenant_id if tenant_id else "",
res=res)
# url = "{base_url}/{cloud_owner}/{cloud_regionid}{tenant_id}/{res}".format(
# base_url=VIM_DRIVER_BASE_URL,
# cloud_owner=cloud_owner,
# cloud_regionid=cloud_regionid,
# tenant_id="/" + tenant_id if tenant_id else "",
# res=res)
ret = req_by_msb(url, method, data)
if ret[0] > 0:
raise VimException(ret[1], ret[2])
return json.JSONDecoder().decode(ret[1]) if ret[1] else {}
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 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]