def test_check_to_reclaim_local_vlan_multiple_ports(self):
        net1_port_info = self._form_port_info_dict("fake_vcenter", "fake_cluster", "net1")
        ovsvapp_db.get_local_vlan(net1_port_info)
        ovsvapp_db.get_local_vlan(net1_port_info)
        ovsvapp_db.get_local_vlan(net1_port_info)

        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(-1, lvid)
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(-1, lvid)
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(1, lvid)
    def test_get_stale_local_vlans_for_network(self):
        net1_port1_info = self._form_port_info_dict("fake_vcenter", "fake_cluster1", "net1")
        ovsvapp_db.get_local_vlan(net1_port1_info)

        net1_port2_info = self._form_port_info_dict("fake_vcenter", "fake_cluster2", "net1")
        ovsvapp_db.get_local_vlan(net1_port2_info)
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port1_info)
        self.assertEqual(1, lvid)
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port2_info)
        self.assertEqual(1, lvid)
        ret_val = ovsvapp_db.get_stale_local_vlans_for_network("net1")
        self.assertEqual([("fake_vcenter", "fake_cluster1", 1), ("fake_vcenter", "fake_cluster2", 1)], ret_val)
    def test_check_to_reclaim_local_vlan_multiple_ports(self):
        net1_port_info = self._form_port_info_dict('fake_vcenter',
                                                   'fake_cluster', 'net1')
        ovsvapp_db.get_local_vlan(net1_port_info)
        ovsvapp_db.get_local_vlan(net1_port_info)
        ovsvapp_db.get_local_vlan(net1_port_info)

        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(-1, lvid)
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(-1, lvid)
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(1, lvid)
    def test_get_stale_local_vlans_for_network(self):
        net1_port1_info = self._form_port_info_dict('fake_vcenter',
                                                    'fake_cluster1', 'net1')
        ovsvapp_db.get_local_vlan(net1_port1_info)

        net1_port2_info = self._form_port_info_dict('fake_vcenter',
                                                    'fake_cluster2', 'net1')
        ovsvapp_db.get_local_vlan(net1_port2_info)
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port1_info)
        self.assertEqual(1, lvid)
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port2_info)
        self.assertEqual(1, lvid)
        ret_val = ovsvapp_db.get_stale_local_vlans_for_network('net1')
        self.assertEqual([('fake_vcenter', 'fake_cluster1', 1),
                          ('fake_vcenter', 'fake_cluster2', 1)], ret_val)
Пример #5
0
 def delete_port_postcommit(self, context):
     """Delete port non-database commit event."""
     port = context.current
     if port and port['device_owner'].startswith('compute'):
         segment = context.bound_segment
         if segment and segment[api.NETWORK_TYPE] == p_const.TYPE_VXLAN:
             host = port[portbindings.HOST_ID]
             vcenter = None
             cluster = None
             agents = self.plugin.get_agents(
                 self.context,
                 filters={'agent_type': [constants.AGENT_TYPE_OVSVAPP],
                          'host': [host]})
             agent = agents[0]
             vcenter = agent['configurations']['vcenter']
             cluster = agent['configurations']['cluster_id']
             net_info = {'vcenter_id': vcenter,
                         'cluster_id': cluster,
                         'network_id': port['network_id'],
                         'segmentation_id': segment[api.SEGMENTATION_ID],
                         'host': host}
             try:
                 lvid = ovsvapp_db.check_to_reclaim_local_vlan(net_info)
                 if lvid >= 1:
                     net_info.update({'lvid': lvid})
                     LOG.debug("Spawning thread for releasing network "
                               "VNI allocations for %s.", net_info)
                     self.threadpool.spawn_n(self._notify_agent, net_info)
             except Exception:
                 LOG.exception(_("Failed to check for reclaiming "
                                 "local vlan."))
Пример #6
0
    def test_check_to_reclaim_local_vlan(self):
        net1_port1_info = self._form_port_info_dict(
            'fake_vcenter', 'fake_cluster', 'net1')
        ovsvapp_db.get_local_vlan(net1_port1_info)

        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port1_info)
        self.assertEqual(1, lvid)
Пример #7
0
 def delete_port_postcommit(self, context):
     """Delete port non-database commit event."""
     port = context.current
     if port and port['device_owner'].startswith('compute'):
         segment = context.top_bound_segment
         if (segment and segment[api.NETWORK_TYPE]
                 in self.supported_network_types):
             LOG.debug(
                 "OVSvApp Mech driver - delete_port_postcommit for "
                 "port: %s with network_type as %s.", port['id'],
                 segment[api.NETWORK_TYPE])
             vni = segment[api.SEGMENTATION_ID]
             network_type = segment[api.NETWORK_TYPE]
             host = port[portbindings.HOST_ID]
             agent = None
             vcenter = None
             cluster = None
             net_info = None
             agents = self.plugin.get_agents(
                 self.context,
                 filters={
                     'agent_type': [ovsvapp_const.AGENT_TYPE_OVSVAPP],
                     'host': [host]
                 })
             if agents:
                 agent = agents[0]
                 vcenter = agent['configurations']['vcenter_id']
                 cluster = agent['configurations']['cluster_id']
                 net_info = {
                     'vcenter_id': vcenter,
                     'cluster_id': cluster,
                     'network_id': port['network_id'],
                     'segmentation_id': vni,
                     'network_type': network_type,
                     'host': host
                 }
             else:
                 LOG.debug("Not a valid ESX port: %s.", port['id'])
                 return
             try:
                 lvid = ovsvapp_db.check_to_reclaim_local_vlan(net_info)
                 if lvid >= 1:
                     net_info.update({'lvid': lvid})
                     LOG.debug(
                         "Spawning thread for releasing network "
                         "VNI allocations for %s.", net_info)
                     self.threadpool.spawn_n(self._notify_agent, net_info)
                     LOG.info(
                         _LI("Spawned a thread for releasing network "
                             "vni allocations for network: %s."), net_info)
             except Exception:
                 LOG.exception(
                     _LE("Failed to check for reclaiming "
                         "local vlan."))
     else:
         self._check_and_fire_provider_update(port)
    def test_release_local_vlan(self):
        net1_port_info = self._form_port_info_dict("fake_vcenter", "fake_cluster", "net1")
        # Allocate network.
        ovsvapp_db.get_local_vlan(net1_port_info)

        # Setup for release.
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(1, lvid)
        with mock.patch("networking_vsphere.db.ovsvapp_db." "LOG.error") as error_log:
            ovsvapp_db.release_local_vlan(net1_port_info)
            self.assertFalse(error_log.called)
    def test_get_stale_local_vlans_for_network_no_stale_networks(self):
        net1_port_info = self._form_port_info_dict("fake_vcenter", "fake_cluster", "net1")
        # Allocate network.
        ovsvapp_db.get_local_vlan(net1_port_info)

        # Setup for release.
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(1, lvid)
        ovsvapp_db.release_local_vlan(net1_port_info)
        ret_val = ovsvapp_db.get_stale_local_vlans_for_network("net1")
        self.assertIsNone(ret_val)
Пример #10
0
    def test_get_stale_local_vlans_for_network_no_stale_networks(self):
        net1_port_info = self._form_port_info_dict('fake_vcenter',
                                                   'fake_cluster', 'net1')
        # Allocate network.
        ovsvapp_db.get_local_vlan(net1_port_info)

        # Setup for release.
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(1, lvid)
        ovsvapp_db.release_local_vlan(net1_port_info)
        ret_val = ovsvapp_db.get_stale_local_vlans_for_network('net1')
        self.assertIsNone(ret_val)
Пример #11
0
    def test_release_local_vlan(self):
        net1_port_info = self._form_port_info_dict('fake_vcenter',
                                                   'fake_cluster', 'net1')
        # Allocate network.
        ovsvapp_db.get_local_vlan(net1_port_info)

        # Setup for release.
        lvid = ovsvapp_db.check_to_reclaim_local_vlan(net1_port_info)
        self.assertEqual(1, lvid)
        with mock.patch('networking_vsphere.db.ovsvapp_db.'
                        'LOG.error') as error_log:
            ovsvapp_db.release_local_vlan(net1_port_info)
            self.assertFalse(error_log.called)
Пример #12
0
 def delete_port_postcommit(self, context):
     """Delete port non-database commit event."""
     port = context.current
     if port and port['device_owner'].startswith('compute'):
         segment = context.top_bound_segment
         if (segment and
                 segment[api.NETWORK_TYPE] in self.supported_network_types):
             LOG.debug("OVSvApp Mech driver - delete_port_postcommit for "
                       "port: %s with network_type as %s.",
                       port['id'], segment[api.NETWORK_TYPE])
             vni = segment[api.SEGMENTATION_ID]
             network_type = segment[api.NETWORK_TYPE]
             host = port[portbindings.HOST_ID]
             agent = None
             vcenter = None
             cluster = None
             net_info = None
             agents = self.plugin.get_agents(
                 self.context,
                 filters={'agent_type': [ovsvapp_const.AGENT_TYPE_OVSVAPP],
                          'host': [host]})
             if agents:
                 agent = agents[0]
                 vcenter = agent['configurations']['vcenter_id']
                 cluster = agent['configurations']['cluster_id']
                 net_info = {'vcenter_id': vcenter,
                             'cluster_id': cluster,
                             'network_id': port['network_id'],
                             'segmentation_id': vni,
                             'network_type': network_type,
                             'host': host}
             else:
                 LOG.debug("Not a valid ESX port: %s.", port['id'])
                 return
             try:
                 lvid = ovsvapp_db.check_to_reclaim_local_vlan(net_info)
                 if lvid >= 1:
                     net_info.update({'lvid': lvid})
                     LOG.debug("Spawning thread for releasing network "
                               "VNI allocations for %s.", net_info)
                     self.threadpool.spawn_n(self._notify_agent, net_info)
                     LOG.info(_LI("Spawned a thread for releasing network "
                                  "vni allocations for network: %s."),
                              net_info)
             except Exception:
                 LOG.exception(_LE("Failed to check for reclaiming "
                                   "local vlan."))
     else:
         self._check_and_fire_provider_update(port)
Пример #13
0
 def delete_port_postcommit(self, context):
     """Delete port non-database commit event."""
     port = context.current
     if port and port['device_owner'].startswith('compute'):
         segment = context.bound_segment
         if segment and segment[api.NETWORK_TYPE] == p_const.TYPE_VXLAN:
             host = port[portbindings.HOST_ID]
             vcenter = None
             cluster = None
             agents = self.plugin.get_agents(
                 self.context,
                 filters={
                     'agent_type': [constants.AGENT_TYPE_OVSVAPP],
                     'host': [host]
                 })
             agent = agents[0]
             vcenter = agent['configurations']['vcenter']
             cluster = agent['configurations']['cluster_id']
             net_info = {
                 'vcenter_id': vcenter,
                 'cluster_id': cluster,
                 'network_id': port['network_id'],
                 'segmentation_id': segment[api.SEGMENTATION_ID],
                 'host': host
             }
             try:
                 lvid = ovsvapp_db.check_to_reclaim_local_vlan(net_info)
                 if lvid >= 1:
                     net_info.update({'lvid': lvid})
                     LOG.debug(
                         "Spawning thread for releasing network "
                         "VNI allocations for %s.", net_info)
                     self.threadpool.spawn_n(self._notify_agent, net_info)
             except Exception:
                 LOG.exception(
                     _("Failed to check for reclaiming "
                       "local vlan."))