upstream/oracle/userland-gate: comparison components/openstack/neutron/files/evs/plugin.py

equal deleted inserted replaced

-:1a27f000029f
+:56ac2df1785b
 import rad.connect as radcon
 import rad.bindings.com.oracle.solaris.rad.evscntl_1 as evsbind
 from oslo.config import cfg
-from quantum.api.rpc.agentnotifiers import dhcp_rpc_agent_api
+from neutron.api.rpc.agentnotifiers import dhcp_rpc_agent_api
-from quantum.api.rpc.agentnotifiers import l3_rpc_agent_api
+from neutron.api.rpc.agentnotifiers import l3_rpc_agent_api
-from quantum.api.v2 import attributes
+from neutron.api.v2 import attributes
-from quantum.common import constants as l3_constants
+from neutron.common import constants as l3_constants
-from quantum.common import exceptions
+from neutron.common import exceptions
-from quantum.common import rpc as q_rpc
+from neutron.common import rpc as q_rpc
-from quantum.common import topics
+from neutron.common import topics
-from quantum.db import dhcp_rpc_base
+from neutron.db import db_base_plugin_v2
-from quantum.db import l3_rpc_base
+from neutron.db import dhcp_rpc_base
-from quantum.extensions import l3
+from neutron.db import external_net_db
-from quantum.extensions import providernet
+from neutron.db import l3_rpc_base
-from quantum.openstack.common import log as logging
+from neutron.extensions import external_net
-from quantum.openstack.common import rpc
+from neutron.extensions import providernet
-from quantum.plugins.evs.db import api as evs_db
+from neutron.openstack.common import lockutils
-from quantum.plugins.evs.db import l3nat as evs_l3nat
+from neutron.openstack.common import log as logging
-from quantum import quantum_plugin_base_v2
+from neutron.openstack.common import rpc
+from neutron.plugins.common import constants as svc_constants
+from neutron.plugins.evs.db import api as evs_db
+from neutron.plugins.evs.db import l3nat as evs_l3nat
+from neutron.plugins.evs.db import quotas_db
 LOG = logging.getLogger(__name__)
 evs_controller_opts = [
 cfg.StrOpt('evs_controller', default='ssh://evsuser@localhost',
 help=_("An URI that specifies an EVS controller"))
 ]
+evs_database_opts = [
+cfg.StrOpt('sql_connection',
+default='sqlite:////var/lib/neutron/neutron.sqlite',
+help=_("An URI that specifies SQL connectionr")),
+]
 cfg.CONF.register_opts(evs_controller_opts, "EVS")
+cfg.CONF.register_opts(evs_database_opts, "DATABASE")
 # Maps OpenStack network resource attributes to EVS properties
 NETWORK_EVS_ATTRIBUTE_MAP = {
 'tenant_id': 'tenant',
 'network_id': 'evs',
 'id': 'evs',
 'name': 'evs',
-l3.EXTERNAL: 'OpenStack:' + l3.EXTERNAL,
+external_net.EXTERNAL: 'OpenStack:' + external_net.EXTERNAL,
 }
 # Maps OpenStack subnet resource attributes to EVS' IPnet properties
 SUBNET_IPNET_ATTRIBUTE_MAP = {
 'tenant_id': 'tenant',
 'device_id': 'OpenStack:device_id',
 'device_owner': 'OpenStack:device_owner',
 }
-class EVSControllerError(exceptions.QuantumException):
+class EVSControllerError(exceptions.NeutronException):
 message = _("EVS controller: %(errmsg)s")
 def __init__(self, evs_errmsg):
 super(EVSControllerError, self).__init__(errmsg=evs_errmsg)
-class EVSOpNotSupported(exceptions.QuantumException):
+class EVSOpNotSupported(exceptions.NeutronException):
 message = _("Operation not supported by EVS plugin: %(opname)s")
 def __init__(self, evs_errmsg):
 super(EVSOpNotSupported, self).__init__(opname=evs_errmsg)
 class EVSRpcCallbacks(dhcp_rpc_base.DhcpRpcCallbackMixin,
 l3_rpc_base.L3RpcCallbackMixin):
-RPC_API_VERSION = '1.0'
+RPC_API_VERSION = '1.1'
 def create_rpc_dispatcher(self):
 '''Get the rpc dispatcher for this manager.
 If a manager would like to set an rpc API version, or support more than
 one class as the target of rpc messages, override this method.
 '''
 return q_rpc.PluginRpcDispatcher([self])
-class EVSQuantumPluginV2(quantum_plugin_base_v2.QuantumPluginBaseV2,
+class EVSNeutronPluginV2(db_base_plugin_v2.NeutronDbPluginV2,
+external_net_db.External_net_db_mixin,
 evs_l3nat.EVS_L3_NAT_db_mixin):
 """Implements v2 Neutron Plug-in API specification.
-All the quantum API calls to create/delete/retrieve Network/Subnet/Port
+All the neutron API calls to create/delete/retrieve Network/Subnet/Port
 are forwarded to EVS controller through Solaris RAD. The RAD connection
 to EVS Controller is over SSH. In order that this plugin can communicate
 with EVS Controller non-interactively and securely, one should setup SSH
 authentication with pre-shared keys between the host running neutron-server
 and the host running EVS controller.
 | -- security_groups  | -- Not Supported |                              |
 | -- admin_state_up   | Always UP        |                              |
 |---------------------+------------------+------------------------------|
 """
-_supported_extension_aliases = ["provider", "router", "quotas"]
+# These attribute specifies whether the plugin supports or not
+# bulk/pagination/sorting operations.
+__native_bulk_support = False
+__native_pagination_support = False
+__native_sorting_support = False
+_supported_extension_aliases = ["provider", "external-net", "router",
+"quotas"]
 def __init__(self):
 # Since EVS Framework does not support router and floatingip
 # resources, the plugin itself will maintain a DB for these
 # two resources
 self._evsc = self._rc.get_object(evsbind.EVSController())
 self._setup_rpc()
 def _setup_rpc(self):
 # RPC support
-self.topic = topics.PLUGIN
+self.service_topics = {svc_constants.CORE: topics.PLUGIN,
+svc_constants.L3_ROUTER_NAT: topics.L3PLUGIN}
 self.conn = rpc.create_connection(new=True)
 self.callbacks = EVSRpcCallbacks()
 self.dispatcher = self.callbacks.create_rpc_dispatcher()
-self.conn.create_consumer(self.topic, self.dispatcher, fanout=False)
+for svc_topic in self.service_topics.values():
+self.conn.create_consumer(svc_topic, self.dispatcher, fanout=False)
 # Consume from all consumers in a thread
 self.conn.consume_in_thread()
 self.dhcp_agent_notifier = dhcp_rpc_agent_api.DhcpAgentNotifyAPI()
 @property
 def supported_extension_aliases(self):
 return self._supported_extension_aliases
-def _fields(self, resource, fields):
-if fields:
-return dict(((key, item) for key, item in resource.iteritems()
-if key in fields))
-return resource
 def _convert_evs_to_network(self, evs):
 """Converts an EVS structure into Neutron Network structure."""
 networkdict = dict()
 networkdict['name'] = evs.name
 networkdict['id'] = evs.uuid
 networkdict['subnets'] = ([ipnet.uuid for ipnet in evs.ipnets]
 if evs.ipnets else [])
 networkdict['tenant_id'] = evs.tenantname
-networkdict[l3.EXTERNAL] = False
+networkdict[external_net.EXTERNAL] = False
 for prop in evs.props:
 if prop.name == 'l2-type':
 networkdict[providernet.NETWORK_TYPE] = prop.value
 if prop.name == 'vlanid' or prop.name == 'vni':
 networkdict[providernet.SEGMENTATION_ID] = int(prop.value)
-if prop.name == NETWORK_EVS_ATTRIBUTE_MAP[l3.EXTERNAL]:
+if prop.name == NETWORK_EVS_ATTRIBUTE_MAP[external_net.EXTERNAL]:
-networkdict[l3.EXTERNAL] = \
+networkdict[external_net.EXTERNAL] = \
 (True if prop.value == 'True' else False)
 # fixed values as EVS framework doesn't support this
 networkdict['admin_state_up'] = True
 networkdict['status'] = 'ACTIVE'
 networkdict['shared'] = False
 start_ip = netaddr.IPAddress(ipnet.start)
 end_ip = netaddr.IPAddress(ipnet.end)
 gw_ip = netaddr.IPAddress(subnetdict['gateway_ip'])
 pools = []
 if gw_ip == start_ip:
-pools.append({'start' : str(netaddr.IPAddress(start_ip + 1)),
+pools.append({'start': str(netaddr.IPAddress(start_ip + 1)),
 'end': str(netaddr.IPAddress(end_ip))})
 elif gw_ip == end_ip:
-pools.append({'start' : str(netaddr.IPAddress(start_ip)),
+pools.append({'start': str(netaddr.IPAddress(start_ip)),
 'end': str(netaddr.IPAddress(end_ip - 1))})
 else:
 pools.append({'start': str(netaddr.IPAddress(start_ip)),
-'end' : str(netaddr.IPAddress(gw_ip - 1))})
+'end': str(netaddr.IPAddress(gw_ip - 1))})
 pools.append({'start': str(netaddr.IPAddress(gw_ip + 1)),
-'end' : str(netaddr.IPAddress(end_ip))})
+'end': str(netaddr.IPAddress(end_ip))})
 subnetdict['allocation_pools'] = pools
 subnetdict['shared'] = False
 return subnetdict
 portdict = dict()
 portdict['admin_state_up'] = True
 portdict['id'] = vport.uuid
 portdict['name'] = vport.name
 portdict['network_id'] = vport.evsuuid
-#TODO(gmoodalb): set to host/zonename/vnicname?
+# TODO(gmoodalb): set to host/zonename/vnicname?
 portdict['device_id'] = ''
 portdict['device_owner'] = ''
 for prop in vport.props:
 if (prop.name == 'macaddr'):
 portdict['mac_address'] = prop.value
 break
 for rsrc in rsrc_to_remove:
 rsrclist.remove(rsrc)
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_addIPnet(self, tenantname, evsname, ipnetname, propstr):
+try:
+pat = radcli.ADRGlobPattern(
+{'name': evsname, 'tenant': tenantname})
+evs = self._rc.get_object(evsbind.EVS(), pat)
+ipnet = evs.addIPnet(propstr, ipnetname)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
+return ipnet
 def create_subnet(self, context, subnet):
 """Creates a subnet(IPnet) for a given network(EVS).
 An IP network represents a block of either IPv4 or IPv6 addresses
 (i.e., subnet) along with a default router for the block. Only one
 IPnet can be associated with an EVS. All the zones/VNICs that
 connect to the EVS, through a VPort, will get an IP address from the
 IPnet associated with the EVS.
 """
+if (subnet['subnet']['allocation_pools'] is not
+attributes.ATTR_NOT_SPECIFIED):
+# user specified --allocation-pool and we don't support it
+raise EVSOpNotSupported(_("cannot use --allocation-pool"))
 ipnetname = subnet['subnet']['name']
 if not ipnetname:
 ipnetname = None
 proplist = ['subnet=%s' % (subnet['subnet']['cidr'])]
 # obtain the optional default router
 defrouter = subnet['subnet']['gateway_ip']
 if defrouter is None:
-# user specified --no-gateway, we don't support it
+# user specified --no-gateway and we don't support it
 raise EVSOpNotSupported(_("cannot use --no-gateway"))
 if defrouter is not attributes.ATTR_NOT_SPECIFIED:
 proplist.append('defrouter=%s' % (defrouter))
 # obtain the optional DNS nameservers
 nameservers = subnet['subnet']['dns_nameservers']
 if attributes.is_attr_set(nameservers):
 proplist.append('%s=%s' %
 (SUBNET_IPNET_ATTRIBUTE_MAP['dns_nameservers'],
 ','.join(nameservers)))
 # obtain the host routes
 hostroutes = subnet['subnet']['host_routes']
 if attributes.is_attr_set(hostroutes):
 hrlist = ['%s,%s' % (destination, nexthop)
 if proplist:
 propstr = ",".join(proplist)
 # TODO(gmoodalb): extract the tenant id if an admin is creating for
 # someone else
-try:
+evsname = subnet['subnet']['network_id']
-evsuuid = subnet['subnet']['network_id']
+tenantname = subnet['subnet']['tenant_id']
-tenantname = subnet['subnet']['tenant_id']
+ipnet = self.evs_controller_addIPnet(tenantname, evsname, ipnetname,
-pat = radcli.ADRGlobPattern(
+propstr)
-{'name': evsuuid, 'tenant': tenantname})
-evs = self._rc.get_object(evsbind.EVS(), pat)
-ipnet = evs.addIPnet(propstr, ipnetname)
-except radcli.ObjectError as oe:
-raise EVSControllerError(oe.get_payload().errmsg)
 retval = self._convert_ipnet_to_subnet(ipnet)
 # notify dhcp agent of subnet creation
 self.dhcp_agent_notifier.notify(context, {'subnet': retval},
 'subnet.create.end')
 return retval
-def update_subnet(self, context, id, subnet):
+@lockutils.synchronized('evs-plugin', 'neutron-')
-evs_rpccall_sync = subnet.pop('evs_rpccall_sync', False)
+def evs_controller_updateIPnet(self, ipnetuuid, propstr):
-if not (set(subnet['subnet'].keys()) == set(('enable_dhcp',))):
+try:
-raise EVSOpNotSupported(_("only enable_dhcp can be updated"))
+pat = radcli.ADRGlobPattern({'uuid': ipnetuuid})
-propstr = "%s=%s" % (SUBNET_IPNET_ATTRIBUTE_MAP['enable_dhcp'],
-subnet['subnet']['enable_dhcp'])
-try:
-pat = radcli.ADRGlobPattern({'uuid': id})
 ipnetlist = self._rc.list_objects(evsbind.IPnet(), pat)
 assert len(ipnetlist) == 1
 ipnet = self._rc.get_object(ipnetlist[0])
 ipnet.setProperty(propstr)
 except radcli.ObjectError as oe:
 raise EVSControllerError(oe.get_payload().errmsg)
+def update_subnet(self, context, id, subnet):
+evs_rpccall_sync = subnet.pop('evs_rpccall_sync', False)
+if not (set(subnet['subnet'].keys()) == set(('enable_dhcp',))):
+raise EVSOpNotSupported(_("only subnets with enable_dhcp "
+"set can be updated"))
+propstr = "%s=%s" % (SUBNET_IPNET_ATTRIBUTE_MAP['enable_dhcp'],
+subnet['subnet']['enable_dhcp'])
+self.evs_controller_updateIPnet(id, propstr)
 retval = self.get_subnet(context, id)
 # notify dhcp agent of subnet update
 methodname = 'subnet.update.end'
 payload = {'subnet': retval}
 methodname.replace(".", "_"), payload=payload)
 self.dhcp_agent_notifier.call(context, msg,
 topic=topics.DHCP_AGENT)
 return retval
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_getIPnet(self, ipnetuuid):
+try:
+ipnetlist = self._evsc.getIPnetInfo('ipnet=%s' % (ipnetuuid))
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
+return (ipnetlist[0] if ipnetlist else None)
 def get_subnet(self, context, id, fields=None):
-try:
+ipnet = self.evs_controller_getIPnet(id)
-ipnetlist = self._evsc.getIPnetInfo('ipnet=%s' % (id))
+if not ipnet:
-except radcli.ObjectError as oe:
+return {}
-raise EVSControllerError(oe.get_payload().errmsg)
+subnetdict = self._convert_ipnet_to_subnet(ipnet)
+return self._fields(subnetdict, fields)
-if ipnetlist:
-subnetdict = self._convert_ipnet_to_subnet(ipnetlist[0])
+@lockutils.synchronized('evs-plugin', 'neutron-')
-return self._fields(subnetdict, fields)
+def evs_controller_getIPnetList(self, filterstr):
-return {}
+try:
+ipnetlist = self._evsc.getIPnetInfo(filterstr)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
+return ipnetlist
 def get_subnets(self, context, filters=None, fields=None,
 sorts=None, limit=None, marker=None, page_reverse=False):
 filterstr = None
 ipnet_props[SUBNET_IPNET_ATTRIBUTE_MAP[key]] = value
 continue
 key = SUBNET_IPNET_ATTRIBUTE_MAP.get(key, key)
 if isinstance(value, list):
 value = ",".join([str(val) for val in value])
+if not value:
+continue
 filterlist.append("%s=%s" % (key, value))
 if filterlist:
 filterstr = ",".join(filterlist)
 LOG.debug(_("calling ListIPnet from get_subnets() filterstr: '%s'")
 % (filterstr))
-try:
-ipnetlist = self._evsc.getIPnetInfo(filterstr)
+ipnetlist = self.evs_controller_getIPnetList(filterstr)
-except radcli.ObjectError as oe:
-raise EVSControllerError(oe.get_payload().errmsg)
 self._apply_rsrc_props_filter(ipnetlist, ipnet_props)
 retme = []
 for ipnet in ipnetlist:
 subnetdict = self._convert_ipnet_to_subnet(ipnet)
 retme.append(self._fields(subnetdict, fields))
 return retme
 def get_subnets_count(self, context, filters=None):
-return len(self.get_ipnets(context, filters))
+return len(self.get_subnets(context, filters))
 def _release_subnet_dhcp_port(self, context, subnet, delete_network):
 """Release any dhcp port associated with the subnet"""
 filters = dict(evs=subnet['network_id'])
 portlist = self.get_ports(context, filters)
 update_subnet = len(portlist) == 1
 if update_subnet:
 # the lone port is a dhcp port created by dhcp agent
 # it must be released before we can delete the subnet
 subnet_update = {'subnet': {'enable_dhcp': False},
 'evs_rpccall_sync': True}
 self.update_subnet(context, subnet['id'], subnet_update)
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_removeIPnet(self, tenantname, evsname, ipnetuuid):
+pat = radcli.ADRGlobPattern({'name': evsname, 'tenant': tenantname})
+try:
+evs = self._rc.get_object(evsbind.EVS(), pat)
+evs.removeIPnet(ipnetuuid)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
 def delete_subnet(self, context, id):
-try:
+subnet = self.get_subnet(context, id)
-subnet = self.get_subnet(context, id)
+if not subnet:
-if not subnet:
+return
-return
-pat = radcli.ADRGlobPattern({'name': subnet['network_id'],
+# If the subnet is dhcp_enabled, then the dhcp agent would have
-'tenant': subnet['tenant_id']})
+# created a port connected to this subnet. We need to remove
-evs = self._rc.get_object(evsbind.EVS(), pat)
+# that port before we can proceed with subnet delete operation.
-# If the subnet is dhcp_enabled, then the dhcp agent would have
+# Since, there is no subnet.delete.start event, we use an another
-# created a port connected to this subnet. We need to remove
+# approach of updating the subnet's enable_dhcp attribute to
-# that port before we can proceed with subnet delete operation.
+# False that in turn sends a subnet.udpate notification. This
-# Since, there is no subnet.delete.start event, we use an another
+# results in DHCP agent releasing the port.
-# approach of updating the subnet's enable_dhcp attribute to
+if subnet['enable_dhcp']:
-# False that in turn sends a subnet.udpate notification. This
-# results in DHCP agent releasing the port.
-if subnet['enable_dhcp']:
 self._release_subnet_dhcp_port(context, subnet, False)
-evs.removeIPnet(id)
+self.evs_controller_removeIPnet(subnet['tenant_id'],
-except radcli.ObjectError as oe:
+subnet['network_id'], id)
-raise EVSControllerError(oe.get_payload().errmsg)
 # notify dhcp agent
 payload = {
 'subnet': {
 'network_id': subnet['network_id'],
 'id': id,
 }
 }
 self.dhcp_agent_notifier.notify(context, payload, 'subnet.delete.end')
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_createEVS(self, tenantname, evsname, propstr):
+try:
+evs = self._evsc.createEVS(propstr, tenantname, evsname)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
+return evs
 def create_network(self, context, network):
 """Creates a network(EVS) for a given tenant.
 An Elastic Virtual Switch (EVS) is a virtual switch that spans
 else:
 raise EVSControllerError(_("specified "
 "provider:network_type '%s' not "
 "supported") % network_type)
-router_external = network['network'][l3.EXTERNAL]
+router_external = network['network'][external_net.EXTERNAL]
 if attributes.is_attr_set(router_external):
-proplist.append("%s=%s" % (NETWORK_EVS_ATTRIBUTE_MAP[l3.EXTERNAL],
+proplist.append("%s=%s" %
-router_external))
+(NETWORK_EVS_ATTRIBUTE_MAP[external_net.EXTERNAL],
+router_external))
 propstr = None
 if proplist:
 propstr = ",".join(proplist)
-try:
+evs = self.evs_controller_createEVS(tenantname, evsname, propstr)
-evs = self._evsc.createEVS(propstr, tenantname, evsname)
-except radcli.ObjectError as oe:
-raise EVSControllerError(oe.get_payload().errmsg)
 return self._convert_evs_to_network(evs)
 def update_network(self, context, id, network):
 raise EVSOpNotSupported(_("net-update"))
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_getEVS(self, evsuuid):
+try:
+evslist = self._evsc.getEVSInfo('evs=%s' % evsuuid)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.getpayload().errmsg)
+return (evslist[0] if evslist else None)
 def get_network(self, context, id, fields=None):
-try:
+evs = self.evs_controller_getEVS(id)
-evslist = self._evsc.getEVSInfo('evs=%s' % id)
+if not evs:
-except radcli.ObjectError as oe:
+return {}
-raise EVSControllerError(oe.getpayload().errmsg)
+networkdict = self._convert_evs_to_network(evs)
+return self._fields(networkdict, fields)
-if evslist:
-networkdict = self._convert_evs_to_network(evslist[0])
+@lockutils.synchronized('evs-plugin', 'neutron-')
-return self._fields(networkdict, fields)
+def evs_controller_getEVSList(self, filterstr):
-return {}
+try:
+evslist = self._evsc.getEVSInfo(filterstr)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
+return evslist
 def get_networks(self, context, filters=None, fields=None,
 sorts=None, limit=None, marker=None, page_reverse=False):
 filterstr = None
 evs_props[NETWORK_EVS_ATTRIBUTE_MAP[key]] = value
 continue
 key = NETWORK_EVS_ATTRIBUTE_MAP.get(key, key)
 if isinstance(value, list):
 value = ",".join([str(val) for val in value])
+if not value:
+continue
 filterlist.append("%s=%s" % (key, value))
 if filterlist:
 filterstr = ",".join(filterlist)
 LOG.debug(_("calling ListEVswitch from get_networks(): '%s'")
 % (filterstr))
-try:
+evslist = self.evs_controller_getEVSList(filterstr)
-evslist = self._evsc.getEVSInfo(filterstr)
-except radcli.ObjectError as oe:
-raise EVSControllerError(oe.get_payload().errmsg)
 self._apply_rsrc_props_filter(evslist, evs_props)
 retme = []
 for evs in evslist:
 networkdict = self._convert_evs_to_network(evs)
 return retme
 def get_networks_count(self, context, filters=None):
 return len(self.get_networks(context, filters))
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_deleteEVS(self, tenantname, evsuuid):
+try:
+self._evsc.deleteEVS(evsuuid, tenantname)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
 def delete_network(self, context, id):
-try:
+# Check if it is an external network and whether addresses in that
-filters = dict(network_id=id)
+# network are being used for floating ips
-subnets = self.get_subnets(context, filters=filters)
+evs = self.get_network(context, id)
-dhcp_subnets = [s for s in subnets if s['enable_dhcp']]
+if evs[external_net.EXTERNAL]:
-for subnet in dhcp_subnets:
+filters = dict(evs=id)
-self._release_subnet_dhcp_port(context, subnet, True)
+portlist = self.get_ports(context, filters)
-self._evsc.deleteEVS(id, context.tenant_id)
+ports_with_deviceid = [port for port in portlist
-except radcli.ObjectError as oe:
+if port['device_id'] != '']
-raise EVSControllerError(oe.get_payload().errmsg)
+if ports_with_deviceid:
+raise exceptions.NetworkInUse(net_id=id)
+filters = dict(network_id=id)
+subnets = self.get_subnets(context, filters=filters)
+dhcp_subnets = [s for s in subnets if s['enable_dhcp']]
+for subnet in dhcp_subnets:
+self._release_subnet_dhcp_port(context, subnet, True)
+self.evs_controller_deleteEVS(context.tenant_id, id)
 # notify dhcp agent of network deletion
 self.dhcp_agent_notifier.notify(context, {'network': {'id': id}},
 'network.delete.end')
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_addVPort(self, tenantname, evsname, vportname, propstr):
+try:
+pat = radcli.ADRGlobPattern({'name': evsname,
+'tenant': tenantname})
+evs = self._rc.get_object(evsbind.EVS(), pat)
+vport = evs.addVPort(propstr, vportname)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
+return vport
 def create_port(self, context, port):
 """Creates a port(VPort) for a given network(EVS).
 A VPort represents the point of attachment between the VNIC and an
 device_owner = port['port']['device_owner']
 if attributes.is_attr_set(device_owner) and device_owner:
 proplist.append("%s=%s" %
 (PORT_VPORT_ATTRIBUTE_MAP['device_owner'],
 device_owner))
 propstr = None
 if proplist:
 propstr = ",".join(proplist)
-try:
+evsname = port['port']['network_id']
-evsuuid = port['port']['network_id']
+tenantname = port['port']['tenant_id']
-tenantname = port['port']['tenant_id']
+# TODO(gmoodalb): -- pull it from the network_id!!
-# TODO(gmoodalb): -- pull it from the network_id!!
+if not tenantname:
-if not tenantname:
+tenantname = context.tenant_id
-tenantname = context.tenant_id
+vport = self.evs_controller_addVPort(tenantname, evsname, vportname,
-pat = radcli.ADRGlobPattern({'name': evsuuid,
+propstr)
-'tenant': tenantname})
-evs = self._rc.get_object(evsbind.EVS(), pat)
-vport = evs.addVPort(propstr, vportname)
-except radcli.ObjectError as oe:
-raise EVSControllerError(oe.get_payload().errmsg)
 retval = self._convert_vport_to_port(context, vport)
 # notify dhcp agent of port creation
 self.dhcp_agent_notifier.notify(context, {'port': retval},
 'port.create.end')
 return retval
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_updateVPort(self, vportuuid, proplist):
+try:
+pat = radcli.ADRGlobPattern({'uuid': vportuuid})
+vportlist = self._rc.list_objects(evsbind.VPort(), pat)
+assert len(vportlist) == 1
+vport = self._rc.get_object(vportlist[0])
+for prop in proplist:
+vport.setProperty(prop)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
 def update_port(self, context, id, port):
 # EVS does not allow updating certain attributes
 if not (set(port['port'].keys()) <=
 set(('device_id', 'device_owner'))):
 if device_owner is not None:
 if len(device_owner) == 0:
 device_owner = " "
 proplist.append("%s=%s" %
 (PORT_VPORT_ATTRIBUTE_MAP['device_owner'],
 device_owner))
 if not proplist:
 return dict()
-try:
+self.evs_controller_updateVPort(id, proplist)
-pat = radcli.ADRGlobPattern({'uuid': id})
-vportlist = self._rc.list_objects(evsbind.VPort(), pat)
-assert len(vportlist) == 1
-vport = self._rc.get_object(vportlist[0])
-for prop in proplist:
-vport.setProperty(prop)
-except radcli.ObjectError as oe:
-raise EVSControllerError(oe.get_payload().errmsg)
 retval = self.get_port(context, id)
 # notify dhcp agent of port update
 self.dhcp_agent_notifier.notify(context, {'port': retval},
 'port.update.end')
 return retval
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_getVPort(self, vportuuid):
+try:
+vportlist = self._evsc.getVPortInfo('vport=%s' % (vportuuid))
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
+return (vportlist[0] if vportlist else None)
 def get_port(self, context, id, fields=None):
-try:
+vport = self.evs_controller_getVPort(id)
-vportlist = self._evsc.getVPortInfo('vport=%s' % (id))
+if not vport:
-except radcli.ObjectError as oe:
+return {}
-raise EVSControllerError(oe.get_payload().errmsg)
+portdict = self._convert_vport_to_port(context, vport)
+return self._fields(portdict, fields)
-if vportlist:
-portdict = self._convert_vport_to_port(context, vportlist[0])
+@lockutils.synchronized('evs-plugin', 'neutron-')
-return self._fields(portdict, fields)
+def evs_controller_getVPortList(self, filterstr):
-return {}
+try:
+vportlist = self._evsc.getVPortInfo(filterstr)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
+return vportlist
 def get_ports(self, context, filters=None, fields=None,
 sorts=None, limit=None, marker=None, page_reverse=False):
 LOG.debug(_("inside the get_ports() method: filters: '%s'") %
 str(filters))
 vport_props[PORT_VPORT_ATTRIBUTE_MAP[key]] = value
 continue
 key = PORT_VPORT_ATTRIBUTE_MAP.get(key, key)
 if isinstance(value, list):
 value = ",".join([str(val) for val in value])
+if not value:
+continue
 filterlist.append("%s=%s" % (key, value))
 if filterlist:
 filterstr = ",".join(filterlist)
 LOG.debug(_("calling getVPortInfo from get_ports(): '%s'") %
 (filterstr))
-try:
+vportlist = self.evs_controller_getVPortList(filterstr)
-vportlist = self._evsc.getVPortInfo(filterstr)
-except radcli.ObjectError as oe:
-raise EVSControllerError(oe.get_payload().errmsg)
 self._apply_rsrc_props_filter(vportlist, vport_props)
 retme = []
 for vport in vportlist:
 portdict = self._convert_vport_to_port(context, vport)
 'device_id': '',
 'device_owner': ''
 }
 }
 self.update_port(context, port['id'], port_update)
-routers = self.get_sync_data(context.elevated(), [router_id])
 msg = l3_rpc_agent_api.L3AgentNotify.make_msg("routers_updated",
-routers=routers)
+routers=[router_id])
 l3_rpc_agent_api.L3AgentNotify.call(context, msg,
 topic=topics.L3_AGENT)
+@lockutils.synchronized('evs-plugin', 'neutron-')
+def evs_controller_removeVPort(self, tenantname, evsname, vportuuid):
+try:
+pat = radcli.ADRGlobPattern({'name': evsname,
+'tenant': tenantname})
+evs = self._rc.get_object(evsbind.EVS(), pat)
+evs.removeVPort(vportuuid)
+except radcli.ObjectError as oe:
+raise EVSControllerError(oe.get_payload().errmsg)
 def delete_port(self, context, id, l3_port_check=True):
 if l3_port_check:
 self.prevent_l3_port_deletion(context, id)
-try:
+self.disassociate_floatingips(context, id)
-self.disassociate_floatingips(context, id)
+port = self.get_port(context, id)
-port = self.get_port(context, id)
+if not port:
-if not port:
+return
-return
+if not l3_port_check:
-if not l3_port_check:
+self._release_l3agent_internal_port(context, port)
-self._release_l3agent_internal_port(context, port)
+self.evs_controller_removeVPort(port['tenant_id'], port['network_id'],
-pat = radcli.ADRGlobPattern({'name': port['network_id'],
+id)
-'tenant': port['tenant_id']})
-evs = self._rc.get_object(evsbind.EVS(), pat)
-evs.removeVPort(id)
-except radcli.ObjectError as oe:
-raise EVSControllerError(oe.get_payload().errmsg)
 # notify dhcp agent of port deletion
 payload = {
 'port': {
 'network_id': port['network_id'],
 # needed for DHCP agent support
 def update_fixed_ip_lease_expiration(self, context, network_id,
 ip_address, lease_remaining):
 pass
+# needed for L3 agent support
+def _get_network(self, context, network_id):
+return self.get_network(context, network_id)
+def _get_subnet(self, context, subnet_id):
+return self.get_subnet(context, subnet_id)
+def _get_port(self, context, port_id):
+return self.get_port(context, port_id)
+def _delete_port(self, context, port_id):
+return self.delete_port(context, port_id)
+def _get_subnets_by_network(self, context, network_id):
+return self.get_subnets(context, filters={'network_id': network_id})
+def _network_is_external(self, context, net_id):
+try:
+evs = self.get_network(context, net_id)
+return evs[external_net.EXTERNAL]
+except:
+return False

changeset 1944	56ac2df1785b
parent 1832	30ac428a2aaf
child 1959	ba86b21a837b
child 3196	4c06db2d9388