#!/usr/bin/env python # vim: tabstop=4 shiftwidth=4 softtabstop=4 # Copyright 2011 Nicira Networks, Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. # @author: Somik Behera, Nicira Networks, Inc. # @author: Brad Hall, Nicira Networks, Inc. # @author: Dan Wendlandt, Nicira Networks, Inc. # @author: Dave Lapsley, Nicira Networks, Inc. # @author: Aaron Rosen, Nicira Networks, Inc. import logging import sys import time import eventlet from sqlalchemy.ext import sqlsoup from quantum.agent import rpc as agent_rpc from quantum.agent.linux import ovs_lib from quantum.agent.linux import utils from quantum.common import constants from quantum.common import config as logging_config from quantum.common import topics from quantum.openstack.common import cfg from quantum.openstack.common import context from quantum.openstack.common import rpc from quantum.openstack.common.rpc import dispatcher from quantum.plugins.openvswitch.common import config logging.basicConfig() LOG = logging.getLogger(__name__) # A placeholder for dead vlans. DEAD_VLAN_TAG = "4095" # A class to represent a VIF (i.e., a port that has 'iface-id' and 'vif-mac' # attributes set). class LocalVLANMapping: def __init__(self, vlan, lsw_id, vif_ids=None): if vif_ids is None: vif_ids = [] self.vlan = vlan self.lsw_id = lsw_id self.vif_ids = vif_ids def __str__(self): return "lv-id = %s ls-id = %s" % (self.vlan, self.lsw_id) class Port(object): """Represents a quantum port. Class stores port data in a ORM-free way, so attributres are still available even if a row has been deleted. """ def __init__(self, p): self.id = p.id self.network_id = p.network_id self.device_id = p.device_id self.admin_state_up = p.admin_state_up self.status = p.status def __eq__(self, other): '''Compare only fields that will cause us to re-wire.''' try: return (self and other and self.id == other.id and self.admin_state_up == other.admin_state_up) except: return False def __ne__(self, other): return not self.__eq__(other) def __hash__(self): return hash(self.id) class OVSRpcCallbacks(): # Set RPC API version to 1.0 by default. RPC_API_VERSION = '1.0' def __init__(self, context, int_br, local_ip=None, tun_br=None): self.context = context self.int_br = int_br # Tunneling variables self.local_ip = local_ip self.tun_br = tun_br def network_delete(self, context, **kwargs): LOG.debug("network_delete received") network_id = kwargs.get('network_id') # (TODO) garyk delete the bridge interface LOG.debug("Delete %s", network_id) def port_update(self, context, **kwargs): LOG.debug("port_update received") port = kwargs.get('port') vif_port = self.int_br.get_vif_port_by_id(port['id']) if vif_port: if port['admin_state_up']: vlan_id = kwargs.get('vlan_id') # create the networking for the port self.int_br.set_db_attribute("Port", vif_port.port_name, "tag", str(vlan_id)) self.int_br.delete_flows(in_port=vif_port.ofport) else: self.int_br.clear_db_attribute("Port", vif_port.port_name, "tag") def tunnel_update(self, context, **kwargs): LOG.debug("tunnel_update received") tunnel_ip = kwargs.get('tunnel_ip') tunnel_id = kwargs.get('tunnel_id') if tunnel_ip == self.local_ip: return tun_name = 'gre-%s' % tunnel_id self.tun_br.add_tunnel_port(tun_name, tunnel_ip) 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 dispatcher.RpcDispatcher([self]) class OVSQuantumAgent(object): def __init__(self, integ_br, root_helper, polling_interval, reconnect_interval, rpc): self.root_helper = root_helper self.setup_integration_br(integ_br) self.polling_interval = polling_interval self.reconnect_interval = reconnect_interval self.rpc = rpc if rpc: self.setup_rpc(integ_br) def setup_rpc(self, integ_br): mac = utils.get_interface_mac(integ_br) self.agent_id = '%s' % (mac.replace(":", "")) self.topic = topics.AGENT self.plugin_rpc = agent_rpc.PluginApi(topics.PLUGIN) # RPC network init self.context = context.RequestContext('quantum', 'quantum', is_admin=False) # Handle updates from service self.callbacks = OVSRpcCallbacks(self.context, self.int_br) self.dispatcher = self.callbacks.create_rpc_dispatcher() # Define the listening consumers for the agent consumers = [[topics.PORT, topics.UPDATE], [topics.NETWORK, topics.DELETE]] self.connection = agent_rpc.create_consumers(self.dispatcher, self.topic, consumers) def port_bound(self, port, vlan_id): self.int_br.set_db_attribute("Port", port.port_name, "tag", str(vlan_id)) self.int_br.delete_flows(in_port=port.ofport) def port_unbound(self, port, still_exists): if still_exists: self.int_br.clear_db_attribute("Port", port.port_name, "tag") def setup_integration_br(self, integ_br): self.int_br = ovs_lib.OVSBridge(integ_br, self.root_helper) self.int_br.remove_all_flows() # switch all traffic using L2 learning self.int_br.add_flow(priority=1, actions="normal") def db_loop(self, db_connection_url): '''Main processing loop for Non-Tunneling Agent. :param options: database information - in the event need to reconnect ''' self.local_vlan_map = {} old_local_bindings = {} old_vif_ports = {} db_connected = False while True: if not db_connected: time.sleep(self.reconnect_interval) db = sqlsoup.SqlSoup(db_connection_url) db_connected = True LOG.info("Connecting to database \"%s\" on %s" % (db.engine.url.database, db.engine.url.host)) all_bindings = {} try: ports = db.ports.all() except Exception, e: LOG.info("Unable to get port bindings! Exception: %s" % e) db_connected = False continue for port in ports: all_bindings[port.id] = port vlan_bindings = {} try: vlan_binds = db.vlan_bindings.all() except Exception, e: LOG.info("Unable to get vlan bindings! Exception: %s" % e) db_connected = False continue for bind in vlan_binds: vlan_bindings[bind.network_id] = bind.vlan_id new_vif_ports = {} new_local_bindings = {} vif_ports = self.int_br.get_vif_ports() for p in vif_ports: new_vif_ports[p.vif_id] = p if p.vif_id in all_bindings: net_id = all_bindings[p.vif_id].network_id new_local_bindings[p.vif_id] = net_id else: # no binding, put him on the 'dead vlan' self.int_br.set_db_attribute("Port", p.port_name, "tag", DEAD_VLAN_TAG) self.int_br.add_flow(priority=2, in_port=p.ofport, actions="drop") old_b = old_local_bindings.get(p.vif_id, None) new_b = new_local_bindings.get(p.vif_id, None) if old_b != new_b: if old_b is not None: LOG.info("Removing binding to net-id = %s for %s" % (old_b, str(p))) self.port_unbound(p, True) if p.vif_id in all_bindings: all_bindings[p.vif_id].status = ( constants.PORT_STATUS_DOWN) if new_b is not None: # If we don't have a binding we have to stick it on # the dead vlan net_id = all_bindings[p.vif_id].network_id vlan_id = vlan_bindings.get(net_id, DEAD_VLAN_TAG) self.port_bound(p, vlan_id) if p.vif_id in all_bindings: all_bindings[p.vif_id].status = ( constants.PORT_STATUS_ACTIVE) LOG.info(("Adding binding to net-id = %s " "for %s on vlan %s") % (new_b, str(p), vlan_id)) for vif_id in old_vif_ports: if vif_id not in new_vif_ports: LOG.info("Port Disappeared: %s" % vif_id) if vif_id in old_local_bindings: old_b = old_local_bindings[vif_id] self.port_unbound(old_vif_ports[vif_id], False) if vif_id in all_bindings: all_bindings[vif_id].status = ( constants.PORT_STATUS_DOWN) old_vif_ports = new_vif_ports old_local_bindings = new_local_bindings try: db.commit() except Exception, e: LOG.info("Unable to commit to database! Exception: %s" % e) db.rollback() old_local_bindings = {} old_vif_ports = {} time.sleep(self.polling_interval) def update_ports(self, registered_ports): ports = self.int_br.get_vif_port_set() if ports == registered_ports: return added = ports - registered_ports removed = registered_ports - ports return {'current': ports, 'added': added, 'removed': removed} def treat_devices_added(self, devices): resync = False for device in devices: LOG.info("Port %s added", device) try: details = self.plugin_rpc.get_device_details(self.context, device, self.agent_id) except Exception as e: LOG.debug("Unable to get port details for %s: %s", device, e) resync = True continue if 'port_id' in details: LOG.info("Port %s updated. Details: %s", device, details) port = self.int_br.get_vif_port_by_id(details['port_id']) if port: if details['admin_state_up']: self.port_bound(port, details['vlan_id']) else: self.port_unbound(port, True) else: LOG.debug("Device %s not defined on plugin", device) return resync def treat_devices_removed(self, devices): resync = False for device in devices: LOG.info("Attachment %s removed", device) try: details = self.plugin_rpc.update_device_down(self.context, device, self.agent_id) except Exception as e: LOG.debug("port_removed failed for %s: %s", device, e) resync = True if details['exists']: LOG.info("Port %s updated.", device) # Nothing to do regarding local networking else: LOG.debug("Device %s not defined on plugin", device) return resync def process_network_ports(self, port_info): resync_a = False resync_b = False if 'added' in port_info: resync_a = self.treat_devices_added(port_info['added']) if 'removed' in port_info: resync_b = self.treat_devices_removed(port_info['removed']) # If one of the above opertaions fails => resync with plugin return (resync_a | resync_b) def rpc_loop(self): sync = True ports = set() while True: start = time.time() if sync: LOG.info("Agent out of sync with plugin!") ports.clear() sync = False port_info = self.update_ports(ports) # notify plugin about port deltas if port_info: LOG.debug("Agent loop has new devices!") # If treat devices fails - indicates must resync with plugin sync = self.process_network_ports(port_info) ports = port_info['current'] # sleep till end of polling interval elapsed = (time.time() - start) if (elapsed < self.polling_interval): time.sleep(self.polling_interval - elapsed) else: LOG.debug("Loop iteration exceeded interval (%s vs. %s)!", self.polling_interval, elapsed) def daemon_loop(self, db_connection_url): if self.rpc: self.rpc_loop() else: self.db_loop(db_connection_url) class OVSQuantumTunnelAgent(object): '''Implements OVS-based tunneling. Two local bridges are created: an integration bridge (defaults to 'br-int') and a tunneling bridge (defaults to 'br-tun'). All VM VIFs are plugged into the integration bridge. VMs for a given tenant share a common "local" VLAN (i.e. not propagated externally). The VLAN id of this local VLAN is mapped to a Logical Switch (LS) identifier and is used to differentiate tenant traffic on inter-HV tunnels. A mesh of tunnels is created to other Hypervisors in the cloud. These tunnels originate and terminate on the tunneling bridge of each hypervisor. Port patching is done to connect local VLANs on the integration bridge to inter-hypervisor tunnels on the tunnel bridge. ''' # Lower bound on available vlans. MIN_VLAN_TAG = 1 # Upper bound on available vlans. MAX_VLAN_TAG = 4094 def __init__(self, integ_br, tun_br, local_ip, root_helper, polling_interval, reconnect_interval, rpc): '''Constructor. :param integ_br: name of the integration bridge. :param tun_br: name of the tunnel bridge. :param local_ip: local IP address of this hypervisor. :param root_helper: utility to use when running shell cmds. :param polling_interval: interval (secs) to poll DB. :param reconnect_internal: retry interval (secs) on DB error. :param rpc: if True use RPC interface to interface with plugin. ''' self.root_helper = root_helper self.available_local_vlans = set( xrange(OVSQuantumTunnelAgent.MIN_VLAN_TAG, OVSQuantumTunnelAgent.MAX_VLAN_TAG)) self.setup_integration_br(integ_br) self.local_vlan_map = {} self.polling_interval = polling_interval self.reconnect_interval = reconnect_interval self.local_ip = local_ip self.tunnel_count = 0 self.setup_tunnel_br(tun_br) self.rpc = rpc if rpc: self.setup_rpc(integ_br) def setup_rpc(self, integ_br): mac = utils.get_interface_mac(integ_br) self.agent_id = '%s%s' % ('ovs', (mac.replace(":", ""))) self.topic = topics.AGENT self.plugin_rpc = agent_rpc.PluginApi(topics.PLUGIN) # RPC network init self.context = context.RequestContext('quantum', 'quantum', is_admin=False) # Handle updates from service self.callbacks = OVSRpcCallbacks(self.context, self.int_br, self.local_ip, self.tun_br) self.dispatcher = self.callbacks.create_rpc_dispatcher() # Define the listening consumers for the agent consumers = [[topics.PORT, topics.UPDATE], [topics.NETWORK, topics.DELETE], [config.TUNNEL, topics.UPDATE]] self.connection = agent_rpc.create_consumers(self.dispatcher, self.topic, consumers) def provision_local_vlan(self, net_uuid, lsw_id): '''Provisions a local VLAN. :param net_uuid: the uuid of the network associated with this vlan. :param lsw_id: the logical switch id of this vlan.''' if not self.available_local_vlans: raise Exception("No local VLANs available for ls-id = %s" % lsw_id) lvid = self.available_local_vlans.pop() LOG.info("Assigning %s as local vlan for net-id=%s" % (lvid, net_uuid)) self.local_vlan_map[net_uuid] = LocalVLANMapping(lvid, lsw_id) # outbound self.tun_br.add_flow(priority=4, in_port=self.patch_int_ofport, dl_vlan=lvid, actions="set_tunnel:%s,normal" % lsw_id) # inbound bcast/mcast self.tun_br.add_flow(priority=3, tun_id=lsw_id, dl_dst="01:00:00:00:00:00/01:00:00:00:00:00", actions="mod_vlan_vid:%s,output:%s" % (lvid, self.patch_int_ofport)) def reclaim_local_vlan(self, net_uuid, lvm): '''Reclaim a local VLAN. :param net_uuid: the network uuid associated with this vlan. :param lvm: a LocalVLANMapping object that tracks (vlan, lsw_id, vif_ids) mapping.''' LOG.info("reclaming vlan = %s from net-id = %s" % (lvm.vlan, net_uuid)) self.tun_br.delete_flows(tun_id=lvm.lsw_id) self.tun_br.delete_flows(dl_vlan=lvm.vlan) del self.local_vlan_map[net_uuid] self.available_local_vlans.add(lvm.vlan) def port_bound(self, port, net_uuid, lsw_id): '''Bind port to net_uuid/lsw_id and install flow for inbound traffic to vm. :param port: a ovslib.VifPort object. :param net_uuid: the net_uuid this port is to be associated with. :param lsw_id: the logical switch this port is to be associated with. ''' if net_uuid not in self.local_vlan_map: self.provision_local_vlan(net_uuid, lsw_id) lvm = self.local_vlan_map[net_uuid] lvm.vif_ids.append(port.vif_id) # inbound unicast self.tun_br.add_flow(priority=3, tun_id=lsw_id, dl_dst=port.vif_mac, actions="mod_vlan_vid:%s,normal" % lvm.vlan) self.int_br.set_db_attribute("Port", port.port_name, "tag", str(lvm.vlan)) if int(port.ofport) != -1: self.int_br.delete_flows(in_port=port.ofport) def port_unbound(self, port, net_uuid): '''Unbind port. Removes corresponding local vlan mapping object if this is its last VIF. :param port: a ovslib.VifPort object. :param net_uuid: the net_uuid this port is associated with.''' if net_uuid not in self.local_vlan_map: LOG.info('port_unbound() net_uuid %s not in local_vlan_map' % net_uuid) return lvm = self.local_vlan_map[net_uuid] if port.vif_id in lvm.vif_ids: lvm.vif_ids.remove(port.vif_id) else: LOG.info('port_unbound: vid_id %s not in list' % port.vif_id) if not lvm.vif_ids: self.reclaim_local_vlan(net_uuid, lvm) def port_dead(self, port): '''Once a port has no binding, put it on the "dead vlan". :param port: a ovs_lib.VifPort object.''' self.int_br.set_db_attribute("Port", port.port_name, "tag", DEAD_VLAN_TAG) self.int_br.add_flow(priority=2, in_port=port.ofport, actions="drop") def setup_integration_br(self, integ_br): '''Setup the integration bridge. Create patch ports and remove all existing flows. :param integ_br: the name of the integration bridge.''' self.int_br = ovs_lib.OVSBridge(integ_br, self.root_helper) self.int_br.delete_port("patch-tun") self.patch_tun_ofport = self.int_br.add_patch_port("patch-tun", "patch-int") self.int_br.remove_all_flows() # switch all traffic using L2 learning self.int_br.add_flow(priority=1, actions="normal") def setup_tunnel_br(self, tun_br): '''Setup the tunnel bridge. Creates tunnel bridge, and links it to the integration bridge using a patch port. :param tun_br: the name of the tunnel bridge.''' self.tun_br = ovs_lib.OVSBridge(tun_br, self.root_helper) self.tun_br.reset_bridge() self.patch_int_ofport = self.tun_br.add_patch_port("patch-int", "patch-tun") self.tun_br.remove_all_flows() self.tun_br.add_flow(priority=1, actions="drop") def manage_tunnels(self, tunnel_ips, old_tunnel_ips, db): if self.local_ip in tunnel_ips: tunnel_ips.remove(self.local_ip) else: db.tunnel_ips.insert(ip_address=self.local_ip) new_tunnel_ips = tunnel_ips - old_tunnel_ips if new_tunnel_ips: LOG.info("adding tunnels to: %s" % new_tunnel_ips) for ip in new_tunnel_ips: tun_name = "gre-" + str(self.tunnel_count) self.tun_br.add_tunnel_port(tun_name, ip) self.tunnel_count += 1 def rollback_until_success(self, db): while True: time.sleep(self.reconnect_interval) try: db.rollback() break except: LOG.exception("Problem connecting to database") def db_loop(self, db_connection_url): '''Main processing loop for Tunneling Agent. :param options: database information - in the event need to reconnect ''' old_local_bindings = {} old_vif_ports = {} old_tunnel_ips = set() db = sqlsoup.SqlSoup(db_connection_url) LOG.info("Connecting to database \"%s\" on %s" % (db.engine.url.database, db.engine.url.host)) while True: try: all_bindings = dict((p.id, Port(p)) for p in db.ports.all()) all_bindings_vif_port_ids = set(all_bindings) lsw_id_bindings = dict((bind.network_id, bind.vlan_id) for bind in db.vlan_bindings.all()) tunnel_ips = set(x.ip_address for x in db.tunnel_ips.all()) self.manage_tunnels(tunnel_ips, old_tunnel_ips, db) # Get bindings from OVS bridge. vif_ports = self.int_br.get_vif_ports() new_vif_ports = dict([(p.vif_id, p) for p in vif_ports]) new_vif_ports_ids = set(new_vif_ports.keys()) old_vif_ports_ids = set(old_vif_ports.keys()) dead_vif_ports_ids = (new_vif_ports_ids - all_bindings_vif_port_ids) dead_vif_ports = [new_vif_ports[p] for p in dead_vif_ports_ids] disappeared_vif_ports_ids = (old_vif_ports_ids - new_vif_ports_ids) new_local_bindings_ids = (all_bindings_vif_port_ids. intersection(new_vif_ports_ids)) new_local_bindings = dict([(p, all_bindings.get(p)) for p in new_vif_ports_ids]) new_bindings = set( (p, old_local_bindings.get(p), new_local_bindings.get(p)) for p in new_vif_ports_ids) changed_bindings = set([b for b in new_bindings if b[2] != b[1]]) LOG.debug('all_bindings: %s', all_bindings) LOG.debug('lsw_id_bindings: %s', lsw_id_bindings) LOG.debug('new_vif_ports_ids: %s', new_vif_ports_ids) LOG.debug('dead_vif_ports_ids: %s', dead_vif_ports_ids) LOG.debug('old_vif_ports_ids: %s', old_vif_ports_ids) LOG.debug('new_local_bindings_ids: %s', new_local_bindings_ids) LOG.debug('new_local_bindings: %s', new_local_bindings) LOG.debug('new_bindings: %s', new_bindings) LOG.debug('changed_bindings: %s', changed_bindings) # Take action. for p in dead_vif_ports: LOG.info("No quantum binding for port " + str(p) + "putting on dead vlan") self.port_dead(p) for b in changed_bindings: port_id, old_port, new_port = b p = new_vif_ports[port_id] if old_port: old_net_uuid = old_port.network_id LOG.info("Removing binding to net-id = " + old_net_uuid + " for " + str(p) + " added to dead vlan") self.port_unbound(p, old_net_uuid) if p.vif_id in all_bindings: all_bindings[p.vif_id].status = ( constants.PORT_STATUS_DOWN) if not new_port: self.port_dead(p) if new_port: new_net_uuid = new_port.network_id if new_net_uuid not in lsw_id_bindings: LOG.warn("No ls-id binding found for net-id '%s'" % new_net_uuid) continue lsw_id = lsw_id_bindings[new_net_uuid] self.port_bound(p, new_net_uuid, lsw_id) all_bindings[p.vif_id].status = ( constants.PORT_STATUS_ACTIVE) LOG.info("Port %s on net-id = %s bound to %s " % ( str(p), new_net_uuid, str(self.local_vlan_map[new_net_uuid]))) for vif_id in disappeared_vif_ports_ids: LOG.info("Port Disappeared: " + vif_id) if vif_id in all_bindings: all_bindings[vif_id].status = ( constants.PORT_STATUS_DOWN) old_port = old_local_bindings.get(vif_id) if old_port: self.port_unbound(old_vif_ports[vif_id], old_port.network_id) # commit any DB changes and expire # data loaded from the database db.commit() # sleep and re-initialize state for next pass time.sleep(self.polling_interval) old_tunnel_ips = tunnel_ips old_vif_ports = new_vif_ports old_local_bindings = new_local_bindings except: LOG.exception("Main-loop Exception:") self.rollback_until_success(db) def update_ports(self, registered_ports): ports = self.int_br.get_vif_port_set() if ports == registered_ports: return added = ports - registered_ports removed = registered_ports - ports return {'current': ports, 'added': added, 'removed': removed} def treat_devices_added(self, devices): resync = False for device in devices: LOG.info("Port %s added", device) try: details = self.plugin_rpc.get_device_details(self.context, device, self.agent_id) except Exception as e: LOG.debug("Unable to get port details for %s: %s", device, e) resync = True continue if 'port_id' in details: LOG.info("Port %s updated. Details: %s", device, details) port = self.int_br.get_vif_port_by_id(details['port_id']) if port: if details['admin_state_up']: self.port_bound(port, details['network_id'], details['vlan_id']) else: self.port_unbound(port, details['network_id']) else: LOG.debug("Device %s not defined on plugin", device) return resync def treat_devices_removed(self, devices): resync = False for device in devices: LOG.info("Attachment %s removed", device) try: details = self.plugin_rpc.update_device_down(self.context, device, self.agent_id) except Exception as e: LOG.debug("port_removed failed for %s: %s", device, e) resync = True if details['exists']: LOG.info("Port %s updated.", device) # Nothing to do regarding local networking else: LOG.debug("Device %s not defined on plugin", device) return resync def process_network_ports(self, port_info): resync_a = False resync_b = False if 'added' in port_info: resync_a = self.treat_devices_added(port_info['added']) if 'removed' in port_info: resync_b = self.treat_devices_removed(port_info['removed']) # If one of the above opertaions fails => resync with plugin return (resync_a | resync_b) def tunnel_sync(self): resync = False try: details = self.plugin_rpc.tunnel_sync(self.context, self.local_ip) tunnels = details['tunnels'] for tunnel in tunnels: if self.local_ip != tunnel['ip_address']: tun_name = 'gre-%s' % tunnel['id'] self.tun_br.add_tunnel_port(tun_name, tunnel['ip_address']) except Exception as e: LOG.debug("Unable to sync tunnel IP %s: %s", self.local_ip, e) resync = True return resync def rpc_loop(self): sync = True ports = set() tunnel_sync = True while True: start = time.time() if sync: LOG.info("Agent out of sync with plugin!") ports.clear() sync = False # Notify the plugin of tunnel IP if tunnel_sync: LOG.info("Agent tunnel out of sync with plugin!") tunnel_sync = self.tunnel_sync() port_info = self.update_ports(ports) # notify plugin about port deltas if port_info: LOG.debug("Agent loop has new devices!") # If treat devices fails - indicates must resync with plugin sync = self.process_network_ports(port_info) ports = port_info['current'] # sleep till end of polling interval elapsed = (time.time() - start) if (elapsed < self.polling_interval): time.sleep(self.polling_interval - elapsed) else: LOG.debug("Loop iteration exceeded interval (%s vs. %s)!", self.polling_interval, elapsed) def daemon_loop(self, db_connection_url): if self.rpc: self.rpc_loop() else: self.db_loop(db_connection_url) def main(): cfg.CONF(args=sys.argv, project='quantum') # (TODO) gary - swap with common logging logging_config.setup_logging(cfg.CONF) # Determine which agent type to use. enable_tunneling = cfg.CONF.OVS.enable_tunneling integ_br = cfg.CONF.OVS.integration_bridge db_connection_url = cfg.CONF.DATABASE.sql_connection polling_interval = cfg.CONF.AGENT.polling_interval reconnect_interval = cfg.CONF.DATABASE.reconnect_interval root_helper = cfg.CONF.AGENT.root_helper rpc = cfg.CONF.AGENT.rpc if enable_tunneling: # Get parameters for OVSQuantumTunnelAgent tun_br = cfg.CONF.OVS.tunnel_bridge # Mandatory parameter. local_ip = cfg.CONF.OVS.local_ip plugin = OVSQuantumTunnelAgent(integ_br, tun_br, local_ip, root_helper, polling_interval, reconnect_interval, rpc) else: # Get parameters for OVSQuantumAgent. plugin = OVSQuantumAgent(integ_br, root_helper, polling_interval, reconnect_interval, rpc) # Start everything. plugin.daemon_loop(db_connection_url) sys.exit(0) if __name__ == "__main__": eventlet.monkey_patch() main()