Python l2network_db.add_vlan_binding函数代码示例

    def test_delete_port(self):
        """
        Tests Deletion of a port on a specified Virtual Network,
        if the port contains a remote interface attachment,
        the remote interface should first be un-plugged and
        then the port can be deleted.
        """
        LOG.debug("UCSVICTestPlugin:_test_delete_port() called\n")
        new_network = db.network_create(self.tenant_id, self.net_name)
        cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
                             new_network[const.UUID])
        new_net_dict = self._cisco_ucs_plugin.create_network(
                self.tenant_id, new_network[const.NETWORKNAME],
                new_network[const.UUID], self.vlan_name, self.vlan_id,
                device_ip=self.device_ip)
        new_port = db.port_create(new_network[const.UUID], const.PORT_UP)
        port_dict = self._cisco_ucs_plugin.create_port(
                            self.tenant_id, self.net_id, const.PORT_UP,
                            new_port[const.UUID], device_ip=self.device_ip,
                            ucs_inventory=self._ucs_inventory,
                            least_rsvd_blade_dict=self._ucs_inventory.\
                            _get_least_reserved_blade())
        port_bind = self._cisco_ucs_plugin.delete_port(
                         self.tenant_id, new_net_dict[const.NET_ID],
                         port_dict[const.PORTID], device_ip=self.device_ip,
                         ucs_inventory=self._ucs_inventory,
                         chassis_id=self.chassis_id, blade_id=self.blade_id,
                         blade_intf_distinguished_name=self.\
                         blade_intf_distinguished_name,
                         least_rsvd_blade_dict=self._ucs_inventory.\
                         _get_least_reserved_blade())

        self.assertEqual(port_bind[const.PORTID], new_port[const.UUID])
        self.tearDownNetwork(self.tenant_id, new_net_dict[const.NET_ID])

    def test_delete_network(self):
        """
        Create a network on a catalyst switch and then delete it
        """

        LOG.debug("test_delete_network - START\n")
        # network dict for create
        net = {'name': self.network_name,
               'admin_status_up': self.admin_status_up}
        # create a network using a locally defined method
        # and call create_network in the catalyst plugin
        network_created = self.create_network(context, net)
        cdb.add_vlan_binding(self.vlan_name, self.vlan_id,
                             network_created['id'])
        network_plugin = self._cisco_catalyst_plugin.create_network(
            context, network_created, self.vlan_name, self.vlan_id)
        # delete the created network by calling delete_network defined at the cat plugin
        # returns a dictionary
        deleted_network_dict = self._cisco_catalyst_plugin.delete_network(
            context, network_created['id'])
        # Check if network id returned by delete_network and create_network
        # are the same
        self.assertEqual(deleted_network_dict[const.ID],
                         network_created['id'])
        # destroy the created network
        self.tearDownNetwork(network_created)
        LOG.debug("test_delete_network - END\n")

    def _test_get_port_details(self, port_state):
        """
        Tests whether  user is able  to retrieve a remote interface
        that is attached to this particular port when port state is Up.
        """
        LOG.debug("UCSVICTestPlugin:_test_get_port_details() called\n")
        new_network = db.network_create(self.tenant_id, self.net_name)
        cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
                             new_network[const.UUID])
        new_net_dict = self._cisco_ucs_plugin.create_network(
            self.tenant_id, new_network[const.NETWORKNAME],
            new_network[const.UUID], self.vlan_name, self.vlan_id,
            device_ip=self.device_ip)
        new_port = db.port_create(new_network[const.UUID], port_state)
        port_dict = self._cisco_ucs_plugin.create_port(
            self.tenant_id, self.net_id, port_state,
            new_port[const.UUID], device_ip=self.device_ip,
            ucs_inventory=self._ucs_inventory,
            least_rsvd_blade_dict=(
                self._ucs_inventory._get_least_reserved_blade()))

        port_detail = self._cisco_ucs_plugin.get_port_details(
            self.tenant_id, new_net_dict[const.NET_ID],
            port_dict[const.PORTID], device_ip=self.device_ip)
        self.assertEqual(str(port_dict), str(port_detail))
        self.tear_down_network_port(
            self.tenant_id, new_net_dict[const.NET_ID],
            port_dict[const.PORTID])

    def test_update_network(self):
        """Support for the Quantum core API call"""
        LOG.debug("test_update_network - START")

        self.net_id = db.network_create(tenant_id, net_name)[const.UUID]

        self._l2network_multiblade.create_network([tenant_id,
                                                   net_name,
                                                   self.net_id,
                                                   vlan_name(self.net_id),
                                                   vlan_id])
        cdb.add_vlan_binding(vlan_id, vlan_name(self.net_id), self.net_id)

        net_details = db.network_update(self.net_id, tenant_id,
                                        name=new_net_name)
        networks = self._l2network_multiblade.update_network([
            tenant_id,
            self.net_id,
            {'name': new_net_name},
            ])

        for network in networks:
            self.assertEqual(network[const.NET_ID], self.net_id)
            self.assertEqual(network[const.NET_NAME], new_net_name)
        LOG.debug("test_update_network - END")

    def test_delete_port(self):
        """Support for the Quantum core API call"""
        LOG.debug("test_delete_port - START")
        self.net_id = db.network_create(tenant_id, net_name)[const.UUID]
        self._l2network_multiblade.create_network([tenant_id,
                                                   net_name,
                                                   self.net_id,
                                                   vlan_name(self.net_id),
                                                   vlan_id])
        cdb.add_vlan_binding(vlan_id, vlan_name(self.net_id), self.net_id)

        self.port_id = db.port_create(self.net_id, port_state)[const.UUID]
        self._l2network_multiblade.create_port([tenant_id,
                                                self.net_id,
                                                port_state, self.port_id])

        port = self._l2network_multiblade.delete_port([tenant_id,
                                                       self.net_id,
                                                       self.port_id])

        self.assertEqual(self.port_id, port[0][const.PORTID])

        # Recreating port so tear down doesn't cause an error
        self.port_id = db.port_create(self.net_id, port_state)[const.UUID]
        self._l2network_multiblade.create_port([tenant_id,
                                                self.net_id,
                                                port_state, self.port_id])

        LOG.debug("test_delete_port - END")

 def test_plug_interface(self, remote_interface_id=None,
                         new_vlanid=10, new_vlan_name='new_vlan'):
     """
     Attaches a remote interface to the specified port on the
     specified Virtual Network.
     """
     LOG.debug("UCSVICTestPlugin:_test_plug_interface() called\n")
     new_network = db.network_create(self.tenant_id, self.net_name)
     cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
                          new_network[const.UUID])
     new_net_dict = self._cisco_ucs_plugin.create_network(
         self.tenant_id, new_network[const.NETWORKNAME],
         new_network[const.UUID], self.vlan_name, self.vlan_id,
         device_ip=self.device_ip)
     new_port = db.port_create(new_network[const.UUID], const.PORT_UP)
     port_dict = self._cisco_ucs_plugin.create_port(
         self.tenant_id, new_net_dict[const.NET_ID],
         const.PORT_UP, new_port[const.UUID],
         device_ip=self.device_ip,
         ucs_inventory=self._ucs_inventory,
         least_rsvd_blade_dict=(
             self._ucs_inventory._get_least_reserved_blade()))
     cdb.update_vlan_binding(new_network[const.UUID],
                             str(new_vlanid), new_vlan_name)
     port_bind = self._cisco_ucs_plugin.plug_interface(
         self.tenant_id, new_net_dict[const.NET_ID],
         port_dict[const.PORTID], remote_interface_id,
         device_ip=self.device_ip)
     self.assertEqual(port_bind[const.VLANNAME], new_vlan_name)
     self.assertEqual(port_bind[const.VLANID], new_vlanid)
     self.tear_down_network_port_interface(
         self.tenant_id, new_net_dict[const.NET_ID],
         new_port[const.UUID])

    def test_get_vlan_id_for_network(self, net_tenant_id=None,
                                     network_name=None):
        """
        Tests retrieval of vlan id for a Virtual Networks .
        """

        LOG.debug("test_get_vlan_id_for_network - START")
        if net_tenant_id:
            tenant_id = net_tenant_id
        else:
            tenant_id = self.tenant_id
        if network_name:
            net_name = network_name
        else:
            net_name = self.net_name

        network_created = self.create_network(tenant_id, net_name)
        cdb.add_vlan_binding(self.vlan_id, self.vlan_name,
                             network_created["net-id"])
        new_net_dict = self._cisco_nexus_plugin.create_network(
            tenant_id, self.net_name, network_created["net-id"],
            self.vlan_name, self.vlan_id)
        result_vlan_id = self._cisco_nexus_plugin._get_vlan_id_for_network(
            tenant_id, network_created["net-id"])
        self.assertEqual(result_vlan_id, self.vlan_id)
        self.tearDownNetwork(tenant_id, new_net_dict[const.NET_ID])
        LOG.debug("test_get_vlan_id_for_network - END")

    def test_delete_network(self, net_tenant_id=None, network_name=None):
        """
        Tests deletion of a Virtual Network.
        """

        LOG.debug("test_delete_network - START")

        if net_tenant_id:
            tenant_id = net_tenant_id
        else:
            tenant_id = self.tenant_id
        if network_name:
            net_name = network_name
        else:
            net_name = self.net_name

        network_created = self.create_network(tenant_id, net_name)
        cdb.add_vlan_binding(self.vlan_id, self.vlan_name,
                             network_created["net-id"])
        new_net_dict = self._cisco_nexus_plugin.create_network(
            tenant_id, self.net_name, network_created["net-id"],
            self.vlan_name, self.vlan_id)
        deleted_net_dict = self._cisco_nexus_plugin.delete_network(
            tenant_id, new_net_dict[const.NET_ID])
        self.assertEqual(deleted_net_dict[const.NET_ID],
                         network_created["net-id"])
        LOG.debug("test_delete_network - END")

    def test_list_all_networks(self, net_tenant_id=None):
        """
        Tests listing of all the Virtual Networks .
        """

        LOG.debug("test_list_all_networks - START")
        if net_tenant_id:
            tenant_id = net_tenant_id
        else:
            tenant_id = self.tenant_id

        network_created = self.create_network(tenant_id, self.net_name)
        cdb.add_vlan_binding(self.vlan_id, self.vlan_name,
                             network_created["net-id"])
        new_net_dict1 = self._cisco_nexus_plugin.create_network(
            tenant_id, self.net_name, network_created["net-id"],
            self.vlan_name, self.vlan_id)
        network_created2 = self.create_network(tenant_id, 'test_network2')
        cdb.add_vlan_binding(self.second_vlan_id, 'second_vlan',
                             network_created2["net-id"])
        new_net_dict2 = self._cisco_nexus_plugin.create_network(
            tenant_id, "New_Network2", network_created2["net-id"],
            "second_vlan", self.second_vlan_id)
        list_net_dict = self._cisco_nexus_plugin.get_all_networks(tenant_id)
        net_temp_list = [new_net_dict1, new_net_dict2]
        self.assertTrue(net_temp_list[0] in list_net_dict)
        self.assertTrue(net_temp_list[1] in list_net_dict)
        self.tearDownNetwork(tenant_id, new_net_dict1[const.NET_ID])
        self.tearDownNetwork(tenant_id, new_net_dict2[const.NET_ID])
        LOG.debug("test_list_all_networks - END")

    def test_get_network_details(self, net_tenant_id=None, network_name=None):
        """
        Tests displays details of a Virtual Network .
        """

        LOG.debug("test_get_network_details - START")

        if net_tenant_id:
            tenant_id = net_tenant_id
        else:
            tenant_id = self.tenant_id
        if network_name:
            net_name = network_name
        else:
            net_name = self.net_name

        network_created = self.create_network(tenant_id, net_name)
        cdb.add_vlan_binding(self.vlan_id, self.vlan_name,
                             network_created["net-id"])
        new_net_dict = self._cisco_nexus_plugin.create_network(
            tenant_id, self.net_name, network_created["net-id"],
            self.vlan_name, self.vlan_id)
        check_net_dict = self._cisco_nexus_plugin.get_network_details(
            tenant_id, network_created["net-id"])
        self.assertEqual(check_net_dict[const.NET_ID],
                         network_created["net-id"])
        self.assertEqual(check_net_dict[const.NET_NAME], self.net_name)
        self.assertEqual(check_net_dict[const.NET_VLAN_NAME], self.vlan_name)
        self.assertEqual(check_net_dict[const.NET_VLAN_ID], self.vlan_id)
        self.tearDownNetwork(tenant_id, new_net_dict[const.NET_ID])
        LOG.debug("test_get_network_details - END")

    def test_unplug_interface(self):
        """Support for the Quantum core API call"""
        LOG.debug("test_unplug_interface - START")
        self.net_id = db.network_create(tenant_id, net_name)[const.UUID]
        self._l2network_multiblade.create_network([tenant_id,
                                                   net_name,
                                                   self.net_id,
                                                   vlan_name(self.net_id),
                                                   vlan_id])
        cdb.add_vlan_binding(vlan_id, vlan_name(self.net_id), self.net_id)

        self.port_id = db.port_create(self.net_id, port_state)[const.UUID]
        self._l2network_multiblade.create_port([tenant_id,
                                                self.net_id,
                                                port_state, self.port_id])

        self._l2network_multiblade.plug_interface([tenant_id, self.net_id,
                                                   self.port_id, interface_id])
        db.port_set_attachment(self.net_id, self.port_id, interface_id)
        interface = self._l2network_multiblade.unplug_interface([tenant_id,
                                                                 self.net_id,
                                                                 self.port_id])

        self.assertEqual(self.port_id, interface[0][const.PORTID])
        LOG.debug("test_unplug_interface - END")

    def test_create_port(self):
        """
        Tests creation of a port on the specified Virtual Network.
        """
        LOG.debug("UCSVICTestPlugin:_test_create_port() called\n")

        new_network = db.network_create(self.tenant_id, self.net_name)
        cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
                             new_network[const.UUID])
        new_net_dict = self._cisco_ucs_plugin.create_network(
            self.tenant_id, new_network[const.NETWORKNAME],
            new_network[const.UUID], self.vlan_name, self.vlan_id,
            device_ip=self.device_ip)
        new_port = db.port_create(new_network[const.UUID], const.PORT_UP)
        port_dict = self._cisco_ucs_plugin.create_port(
            self.tenant_id, self.net_id, const.PORT_UP,
            new_port[const.UUID], device_ip=self.device_ip,
            ucs_inventory=self._ucs_inventory,
            least_rsvd_blade_dict=(
                self._ucs_inventory._get_least_reserved_blade()))
        self.assertEqual(port_dict[const.PORTID], new_port[const.UUID])
        profile_name = (
            self._cisco_ucs_plugin._get_profile_name(port_dict[const.PORTID]))
        self.assertTrue(profile_name is not None)
        self.tear_down_network_port(
            self.tenant_id, new_net_dict[const.NET_ID],
            port_dict[const.PORTID])

    def test_get_all_networks(self):
        """
        Tests whether  dictionary is returned containing all
        <network_uuid, network_name> for
        the specified tenant.
        """
        LOG.debug("UCSVICTestPlugin:test_get_all_networks() called\n")
        new_network1 = db.network_create(self.tenant_id, self.net_name)
        cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
                             new_network1[const.UUID])
        new_net_dict1 = self._cisco_ucs_plugin.create_network(
            self.tenant_id, new_network1[const.NETWORKNAME],
            new_network1[const.UUID], self.vlan_name, self.vlan_id,
            device_ip=self.device_ip)
        new_network2 = db.network_create(self.tenant_id, "test_network2")
        cdb.add_vlan_binding("6", "q-000006vlan", new_network2[const.UUID])
        new_net_dict2 = self._cisco_ucs_plugin.create_network(
            self.tenant_id, new_network2[const.NETWORKNAME],
            new_network2[const.UUID], "q-000006vlan", "6",
            device_ip=self.device_ip)

        net_list = self._cisco_ucs_plugin.get_all_networks(
            self.tenant_id, device_ip=self.device_ip)
        net_id_list = [new_net_dict1, new_net_dict2]

        self.assertTrue(net_list[0] in net_id_list)
        self.assertTrue(net_list[1] in net_id_list)
        self.tear_down_network(self.tenant_id, new_network1[const.UUID])
        self.tear_down_network(self.tenant_id, new_network2[const.UUID])

 def test_get_vlan_id_for_network(self):
     LOG.debug("UCSVICTestPlugin:test_get_vlan_id_for_network() called\n")
     new_network = db.network_create(self.tenant_id, self.net_name)
     cdb.add_vlan_binding(str(self.vlan_id), self.vlan_name,
                          new_network[const.UUID])
     vlan_bind_id = self._cisco_ucs_plugin._get_vlan_id_for_network(
                                 self.tenant_id, new_network[const.UUID])
     self.assertEqual(str(vlan_bind_id), self.vlan_id)

 def test_release_segmentation_id(self):
     LOG.debug("test_release_segmentation_id - START")
     db.network_create(self.tenant_id, self.net_name)
     vlan_id = self.vlan_mgr.reserve_segmentation_id(self.tenant_id,
                                                     self.net_name)
     cdb.add_vlan_binding(vlan_id, self.vlan_name, self.net_id)
     release_return = self.vlan_mgr.release_segmentation_id(self.tenant_id,
                                                            self.net_id)
     self.assertEqual(release_return, False)
     LOG.debug("test_release_segmentation_id - END")