+"""
# vim: tabstop=4 shiftwidth=4 softtabstop=4
#
# Copyright 2011 Cisco Systems, Inc. All rights reserved.
#
# @author: Sumit Naiksatam, Cisco Systems, Inc.
#
-
+"""
import logging as LOG
from quantum.common import exceptions as exc
}
"""
+
class UCSInventory(object):
+ """
+ Manages the state of all the UCS chasses, and blades in
+ the system
+ """
_inventory = {}
_host_names = {}
return blade_data
def get_all_ucsms(self):
+ """Get the IPs of all the UCSMs in the system"""
return self._inventory.keys()
def reload_inventory(self):
"""Reload the inventory from a conf file"""
self._load_inventory()
- pass
-
+
def build_inventory_state(self):
"""Populate the state of all the blades"""
for ucsm_ip in self._inventory.keys():
const.BLADE_INTF_RESERVED
blade_intf_data[blade_intf][const.TENANTID] = tenant_id
blade_intf_data[blade_intf][const.PORTID] = port_id
- blade_intf_data[blade_intf][const.PROFILEID] = portprofile_name
+ blade_intf_data[blade_intf][const.PROFILE_ID] = \
+ portprofile_name
blade_intf_data[blade_intf][const.INSTANCE_ID] = None
dev_eth_name = blade_intf_data[blade_intf] \
[const.BLADE_INTF_RHEL_DEVICE_NAME]
blade_intf_info = {const.UCSM_IP: ucsm_ip,
const.CHASSIS_ID: chassis_id,
const.BLADE_ID: blade_id,
- const.BLADE_INTF_DN:
+ const.BLADE_INTF_DN:
interface_dn}
return blade_intf_info
return None
def get_host_name(self, tenant_id, instance_id):
"""
- Return the hostname of the blade with a reserved instance
+ Return the hostname of the blade with a reserved instance
for this tenant
"""
for ucsm_ip in self._inventory_state.keys():
print "No more unreserved blades\n"
break
- least_reserved_blade_ucsm = reserved_blade_dict[const.LEAST_RSVD_BLADE_UCSM]
+ least_reserved_blade_ucsm = \
+ reserved_blade_dict[const.LEAST_RSVD_BLADE_UCSM]
least_reserved_blade_chassis = \
reserved_blade_dict[const.LEAST_RSVD_BLADE_CHASSIS]
least_reserved_blade_id = \
least_reserved_blade_chassis,
least_reserved_blade_id,
least_reserved_blade_data,
- "demo")
+ "demo", "12345", "profilename")
if reserved_nic_dict:
reserved_intf_nic_info = {const.RESERVED_INTERFACE_UCSM:
least_reserved_blade_ucsm,
"\" classId=\"vnicEther\"" + \
" inHierarchical=\"false\">" + \
" <inFilter> <eq class=\"vnicEther\" property=\"equipmentDn\"" + \
- " value=\"sys/chassis-" + CHASSIS_VALUE +"/blade-" + \
+ " value=\"sys/chassis-" + CHASSIS_VALUE + "/blade-" + \
BLADE_VALUE + "/adaptor-1/host-eth-?\"/> " + \
"</inFilter> </configResolveClass>"
data = DELETE_PROFILE.replace(PROFILE_NAME, profile_name)
return data
- def _get_next_dynamic_nic(self):
- """Get an avaialble dynamic nic on the host"""
- dynamic_nic_id = gvif.get_next_dynic()
- if len(dynamic_nic_id) > 0:
- return dynamic_nic_id
- else:
- raise cexc.NoMoreNics()
-
def _get_blade_interfaces_post_data(self, chassis_number, blade_number):
+ """Create command"""
data = GET_BLADE_INTERFACES.replace(CHASSIS_VALUE, chassis_number)
data = data.replace(BLADE_VALUE, blade_number)
return data
-
- def _get_blade_interface_state_post_data(self, blade_dn):
+
+ def _get_blade_intf_st_post_data(self, blade_dn):
+ """Create command"""
data = GET_BLADE_INTERFACE_STATE.replace(BLADE_DN_VALUE, blade_dn)
return data
-
+
def _get_blade_interfaces(self, chassis_number, blade_number, ucsm_ip,
ucsm_username, ucsm_password):
+ """Create command"""
data = self._get_blade_interfaces_post_data(chassis_number,
blade_number)
response = self._post_data(ucsm_ip, ucsm_username, ucsm_password, data)
- """
- print("***Sumit: ucsmp_ip %s ucsm_username %s ucsm_password %s data %s \
- response %s") % (ucsm_ip, ucsm_username, ucsm_password, data,
- response)
- """
elements = \
et.XML(response).find("outConfigs").findall("adaptorHostEthIf")
- bladeInterfaces = {}
+ blade_interfaces = {}
for element in elements:
- dn = element.get("dn", default=None)
- if dn:
+ dist_name = element.get("dn", default=None)
+ if dist_name:
order = element.get("order", default=None)
- bladeInterface = {const.BLADE_INTF_DN: dn,
+ blade_interface = {const.BLADE_INTF_DN: dist_name,
const.BLADE_INTF_ORDER: order,
const.BLADE_INTF_LINK_STATE: None,
const.BLADE_INTF_OPER_STATE: None,
const.BLADE_INTF_INST_TYPE: None,
const.BLADE_INTF_RHEL_DEVICE_NAME:
self._get_rhel_device_name(order)}
- bladeInterfaces[dn] = bladeInterface
+ blade_interfaces[dist_name] = blade_interface
- return bladeInterfaces
+ return blade_interfaces
- def _get_blade_interface_state(self, bladeIntf, ucsm_ip,
+ def _get_blade_interface_state(self, blade_intf, ucsm_ip,
ucsm_username, ucsm_password):
+ """Create command"""
data = \
- self._get_blade_interface_state_post_data(bladeIntf[const.BLADE_INTF_DN])
+ self._get_blade_intf_st_post_data(blade_intf[const.BLADE_INTF_DN])
response = self._post_data(ucsm_ip, ucsm_username, ucsm_password, data)
elements = \
et.XML(response).find("outConfigs").findall("dcxVIf")
for element in elements:
- bladeIntf[const.BLADE_INTF_LINK_STATE] = element.get("linkState",
+ blade_intf[const.BLADE_INTF_LINK_STATE] = element.get("linkState",
default=None)
- bladeIntf[const.BLADE_INTF_OPER_STATE] = element.get("operState",
+ blade_intf[const.BLADE_INTF_OPER_STATE] = element.get("operState",
default=None)
- bladeIntf[const.BLADE_INTF_INST_TYPE] = element.get("instType",
+ blade_intf[const.BLADE_INTF_INST_TYPE] = element.get("instType",
default=None)
def _get_rhel_device_name(self, order):
- deviceName = const.RHEL_DEVICE_NAME_REPFIX + str(int(order) - 1)
- return deviceName
-
- def _get_dynamic_interface(self, chassis_number, blade_number,
- ucsm_ip,ucsm_username,
- ucsm_password):
- bladeInterfaces = client._get_blade_interfaces(chassis_number,
- blade_number,
- ucsm_ip,
- ucsm_username,
- ucsm_password)
- for bladeIntf in bladeInterfaces.values():
- client._get_blade_interface_state(bladeIntf, ucsm_ip,
- ucsm_username, ucsm_password)
- if bladeIntf[const.BLADE_INTF_INST_TYPE] == \
- const.BLADE_INTF_DYNAMIC and \
- bladeIntf[const.BLADE_INTF_LINK_STATE] == \
- const.BLADE_INTF_STATE_UNKNOWN and \
- bladeIntf[const.BLADE_INTF_OPER_STATE] == \
- const.BLADE_INTF_STATE_UNKNOWN:
- return bladeIntf
+ """Get the device name as on the RHEL host"""
+ device_name = const.RHEL_DEVICE_NAME_REPFIX + str(int(order) - 1)
+ return device_name
def create_vlan(self, vlan_name, vlan_id, ucsm_ip, ucsm_username,
ucsm_password):
new_vlan_name)
self._post_data(ucsm_ip, ucsm_username, ucsm_password, data)
- def get_dynamic_nic(self, host):
- """Get an avaialble dynamic nic on the host"""
- # TODO (Sumit): Check availability per host
- # TODO (Sumit): If not available raise exception
- # TODO (Sumit): This simple logic assumes that create-port and
- # spawn-VM happens in lock-step
- # But we should support multiple create-port calls,
- # followed by spawn-VM calls
- # That would require managing a pool of available
- # dynamic vnics per host
- dynamic_nic_name = self._get_next_dynamic_nic()
- LOG.debug("Reserving dynamic nic %s" % dynamic_nic_name)
- return dynamic_nic_name
-
def get_blade_data(self, chassis_number, blade_number,
- ucsm_ip,ucsm_username,
+ ucsm_ip, ucsm_username,
ucsm_password):
"""
Returns only the dynamic interfaces on the blade
"""
- bladeInterfaces = self._get_blade_interfaces(chassis_number,
+ blade_interfaces = self._get_blade_interfaces(chassis_number,
blade_number,
ucsm_ip,
ucsm_username,
ucsm_password)
- for bladeIntf in bladeInterfaces.keys():
- self._get_blade_interface_state(bladeInterfaces[bladeIntf], ucsm_ip,
- ucsm_username, ucsm_password)
- if bladeInterfaces[bladeIntf][const.BLADE_INTF_INST_TYPE] != \
+ for blade_intf in blade_interfaces.keys():
+ self._get_blade_interface_state(blade_interfaces[blade_intf],
+ ucsm_ip, ucsm_username,
+ ucsm_password)
+ if blade_interfaces[blade_intf][const.BLADE_INTF_INST_TYPE] != \
const.BLADE_INTF_DYNAMIC:
- bladeInterfaces.pop(bladeIntf)
+ blade_interfaces.pop(blade_intf)
- return bladeInterfaces
+ return blade_interfaces
def delete_vlan(self, vlan_name, ucsm_ip, ucsm_username, ucsm_password):
"""Create request for UCSM"""
"""Create request for UCSM"""
data = self._delete_profile_post_data(profile_name)
self._post_data(ucsm_ip, ucsm_username, ucsm_password, data)
-
- def release_dynamic_nic(self, host):
- """Release a reserved dynamic nic on the host"""
- # TODO (Sumit): Release on a specific host
- pass
ucs_inventory.reserve_blade_interface(self._ucsm_ip, chassis_id,
blade_id, blade_data_dict,
tenant_id, port_id,
- portprofile_name)
+ profile_name)
return new_port_dict
def delete_port(self, tenant_id, net_id, port_id, **kwargs):
LOG.debug("UCSVICPlugin:delete_port() called\n")
self._set_ucsm(kwargs[const.DEVICE_IP])
ucs_inventory = kwargs[const.UCS_INVENTORY]
- chassis_id = kwargs[const.const.CHASSIS_ID]
- blade_id = kwargs[const.const.BLADE_ID]
+ chassis_id = kwargs[const.CHASSIS_ID]
+ blade_id = kwargs[const.BLADE_ID]
interface_dn = kwargs[const.BLADE_INTF_DN]
port = self._get_port(tenant_id, net_id, port_id)
if port[const.ATTACHMENT]:
port_profile[const.PROFILE_NAME])
net = self._get_network(tenant_id, net_id)
net[const.NET_PORTS].pop(port_id)
- ucs_inventory.unreserve_blade_interface(ucsm_ip, chassis_id,
+ ucs_inventory.unreserve_blade_interface(self._ucsm_ip, chassis_id,
blade_id, interface_dn)
except KeyError:
raise exc.PortNotFound(net_id=net_id, port_id=port_id)
self._port_profile_counter -= 1
def _set_ucsm(self, ucsm_ip):
+ """Set the UCSM IP, username, and password"""
self._ucsm_ip = ucsm_ip
self._ucsm_username = cred.Store.getUsername(conf.UCSM_IP_ADDRESS)
self._ucsm_password = cred.Store.getPassword(conf.UCSM_IP_ADDRESS)
-
Code Review / openstack-build / neutron-build.git / commitdiff