Example #1
0
    def _get_instance_port(self, tenant_id, instance_id, vif_id):
        """
        Return the device name for a reserved interface
        """
        found_blade_intf_data = None
        for ucsm_ip in self._inventory_state.keys():
            ucsm = self._inventory_state[ucsm_ip]
            for chassis_id in ucsm.keys():
                for blade_id in ucsm[chassis_id]:
                    blade_data = ucsm[chassis_id][blade_id]
                    blade_intf_data = blade_data[const.BLADE_INTF_DATA]
                    for blade_intf in blade_intf_data.keys():
                        if blade_intf_data[blade_intf]\
                           [const.BLADE_INTF_RESERVATION] == \
                           const.BLADE_INTF_RESERVED and \
                           blade_intf_data[blade_intf]\
                           [const.TENANTID] == tenant_id and \
                           blade_intf_data[blade_intf]\
                           [const.INSTANCE_ID] == instance_id:
                            found_blade_intf_data = blade_intf_data
                            LOG.debug("Found blade %s associated with this" \
                                      " instance: %s" % \
                                      (blade_id,
                                       instance_id))
                            break

        if found_blade_intf_data:
            blade_intf_data = found_blade_intf_data
            for blade_intf in blade_intf_data.keys():
                if blade_intf_data[blade_intf]\
                   [const.BLADE_INTF_RESERVATION] == \
                   const.BLADE_INTF_RESERVED and \
                   blade_intf_data[blade_intf]\
                   [const.TENANTID] == tenant_id and \
                   (not blade_intf_data[blade_intf][const.VIF_ID]):
                    blade_intf_data[blade_intf][const.VIF_ID] = \
                            vif_id
                    blade_intf_data[blade_intf]\
                            [const.INSTANCE_ID] = instance_id
                    port_binding = udb.get_portbinding_dn(blade_intf)
                    port_id = port_binding[const.PORTID]
                    udb.update_portbinding(port_id, instance_id=instance_id,
                                           vif_id=vif_id)
                    db.port_set_attachment_by_id(port_id, vif_id)
                    device_name = blade_intf_data[blade_intf]\
                            [const.BLADE_INTF_RHEL_DEVICE_NAME]
                    profile_name = port_binding[const.PORTPROFILENAME]
                    dynamicnic_details = \
                            {const.DEVICENAME: device_name,
                             const.UCSPROFILE: profile_name}
                    LOG.debug("Found reserved dynamic nic: %s" \
                              "associated with port %s" %
                              (blade_intf_data[blade_intf], port_id))
                    LOG.debug("Returning dynamic nic details: %s" %
                              dynamicnic_details)
                    return dynamicnic_details

        LOG.warn("Could not find a reserved dynamic nic for tenant: %s" %
                 tenant_id)
        return None
Example #2
0
    def _get_instance_port(self, tenant_id, instance_id, vif_id):
        """
        Return the device name for a reserved interface
        """
        found_blade_intf_data = None
        for ucsm_ip in self._inventory_state.keys():
            ucsm = self._inventory_state[ucsm_ip]
            for chassis_id in ucsm.keys():
                for blade_id in ucsm[chassis_id]:
                    blade_data = ucsm[chassis_id][blade_id]
                    blade_intf_data = blade_data[const.BLADE_INTF_DATA]
                    for blade_intf in blade_intf_data.keys():
                        intf_data = blade_intf_data[blade_intf]
                        if (intf_data[const.BLADE_INTF_RESERVATION]
                                == const.BLADE_INTF_RESERVED
                                and intf_data[const.TENANTID] == tenant_id and
                                intf_data[const.INSTANCE_ID] == instance_id):
                            found_blade_intf_data = blade_intf_data
                            LOG.debug(
                                ("Found blade %s associated with this"
                                 " instance: %s") % (blade_id, instance_id))
                            break

        if found_blade_intf_data:
            blade_intf_data = found_blade_intf_data
            for blade_intf in blade_intf_data.keys():
                intf_data = blade_intf_data[blade_intf]
                if (intf_data[const.BLADE_INTF_RESERVATION]
                        == const.BLADE_INTF_RESERVED
                        and intf_data[const.TENANTID] == tenant_id
                        and (not intf_data[const.VIF_ID])):
                    intf_data[const.VIF_ID] = vif_id
                    intf_data[const.INSTANCE_ID] = instance_id
                    port_binding = udb.get_portbinding_dn(blade_intf)
                    port_id = port_binding[const.PORTID]
                    udb.update_portbinding(port_id,
                                           instance_id=instance_id,
                                           vif_id=vif_id)
                    db.port_set_attachment_by_id(port_id,
                                                 vif_id + const.UNPLUGGED)
                    device_name = intf_data[const.BLADE_INTF_RHEL_DEVICE_NAME]
                    profile_name = port_binding[const.PORTPROFILENAME]
                    dynamicnic_details = {
                        const.DEVICENAME: device_name,
                        const.UCSPROFILE: profile_name,
                    }
                    LOG.debug(
                        ("Found reserved dynamic nic: %s"
                         "associated with port %s") % (intf_data, port_id))
                    LOG.debug("Returning dynamic nic details: %s" %
                              dynamicnic_details)
                    return dynamicnic_details

        LOG.warn("Could not find a reserved dynamic nic for tenant: %s" %
                 tenant_id)
        return None
Example #3
0
    def test_unplug_interface(self,
                              tenant_id='test_tenant',
                              instance_tenant_id='nova',
                              nova_user_id='novaadmin',
                              instance_id=10,
                              vif_id='fe701ddf-26a2-42ea-b9e6-7313d1c522cc'):
        """
        Tests detaachment of an interface to a port
        """
        LOG.debug("test_unplug_interface - START")
        new_net_dict = self._l2network_plugin.create_network(
            tenant_id, self.network_name)
        port_dict = self._l2network_plugin.create_port(
            tenant_id, new_net_dict[const.NET_ID], self.state)
        instance_desc = {'project_id': tenant_id, 'user_id': nova_user_id}
        host_list = self._l2network_plugin.schedule_host(
            instance_tenant_id, instance_id, instance_desc)
        instance_vif_desc = {
            'project_id': tenant_id,
            'user_id': nova_user_id,
            'vif_id': vif_id
        }

        if conf.PLUGINS[const.PLUGINS].keys():
            vif_description = self._l2network_plugin.associate_port(
                instance_tenant_id, instance_id, instance_vif_desc)
        else:
            db.port_set_attachment_by_id(
                port_dict[const.PORT_ID],
                instance_vif_desc['vif_id'] + const.UNPLUGGED)

        self._l2network_plugin.plug_interface(tenant_id,
                                              new_net_dict[const.NET_ID],
                                              port_dict[const.PORT_ID], vif_id)
        self._l2network_plugin.unplug_interface(tenant_id,
                                                new_net_dict[const.NET_ID],
                                                port_dict[const.PORT_ID])
        port = db.port_get(new_net_dict[const.NET_ID],
                           port_dict[const.PORT_ID])
        vif_id_unplugged = vif_id + '(detached)'
        self.assertEqual(port[const.INTERFACEID], vif_id_unplugged)
        self.tearDownNetworkPortInterface(tenant_id, instance_tenant_id,
                                          instance_id, instance_vif_desc,
                                          new_net_dict[const.NET_ID],
                                          port_dict[const.PORT_ID])

        LOG.debug("test_unplug_interface - END")
    def test_unplug_interface(self, tenant_id='test_tenant',
                              instance_tenant_id='nova',
                              nova_user_id='novaadmin', instance_id=10,
                              vif_id='fe701ddf-26a2-42ea-b9e6-7313d1c522cc'):
        """
        Tests detaachment of an interface to a port
        """
        LOG.debug("test_unplug_interface - START")
        new_net_dict = self._l2network_plugin.create_network(tenant_id,
                                                             self.network_name)
        port_dict = self._l2network_plugin.create_port(
            tenant_id, new_net_dict[const.NET_ID], self.state)
        instance_desc = {'project_id': tenant_id,
                         'user_id': nova_user_id}
        host_list = self._l2network_plugin.schedule_host(instance_tenant_id,
                                                         instance_id,
                                                         instance_desc)
        instance_vif_desc = {'project_id': tenant_id, 'user_id': nova_user_id,
                             'vif_id': vif_id}

        if conf.PLUGINS[const.PLUGINS].keys():
            vif_description = self._l2network_plugin. associate_port(
                instance_tenant_id,
                instance_id,
                instance_vif_desc)
        else:
            db.port_set_attachment_by_id(port_dict[const.PORT_ID],
                                         instance_vif_desc['vif_id'] +
                                         const.UNPLUGGED)

        self._l2network_plugin.plug_interface(tenant_id,
                                              new_net_dict[const.NET_ID],
                                              port_dict[const.PORT_ID], vif_id)
        self._l2network_plugin.unplug_interface(tenant_id,
                                                new_net_dict[const.NET_ID],
                                                port_dict[const.PORT_ID])
        port = db.port_get(new_net_dict[const.NET_ID],
                           port_dict[const.PORT_ID])
        vif_id_unplugged = vif_id + '(detached)'
        self.assertEqual(port[const.INTERFACEID], vif_id_unplugged)
        self.tearDownNetworkPortInterface(tenant_id, instance_tenant_id,
                                          instance_id, instance_vif_desc,
                                          new_net_dict[const.NET_ID],
                                          port_dict[const.PORT_ID])

        LOG.debug("test_unplug_interface - END")
Example #5
0
    def test_plug_interface_portInUse(self,
                                      tenant_id='test_tenant',
                                      instance_tenant_id='nova',
                                      nova_user_id='novaadmin',
                                      instance_id=10,
                                      vif_id='fe701ddf-26a2-42ea-'
                                      'b9e6-7313d1c522cc',
                                      remote_interface='new_interface'):
        """
        Tests attachment of new interface to the port when there is an
        existing attachment
        """
        LOG.debug("test_plug_interface_portInUse - START")
        new_net_dict = self._l2network_plugin.create_network(
            tenant_id, self.network_name)
        port_dict = self._l2network_plugin.create_port(
            tenant_id, new_net_dict[const.NET_ID], self.state)
        instance_desc = {'project_id': tenant_id, 'user_id': nova_user_id}
        host_list = self._l2network_plugin.schedule_host(
            instance_tenant_id, instance_id, instance_desc)
        instance_vif_desc = {
            'project_id': tenant_id,
            'user_id': nova_user_id,
            'vif_id': vif_id
        }

        if conf.PLUGINS[const.PLUGINS].keys():
            vif_description = self._l2network_plugin.associate_port(
                instance_tenant_id, instance_id, instance_vif_desc)
        else:
            db.port_set_attachment_by_id(
                port_dict[const.PORT_ID],
                instance_vif_desc['vif_id'] + const.UNPLUGGED)

        self.assertRaises(exc.PortInUse, self._l2network_plugin.plug_interface,
                          tenant_id, new_net_dict[const.NET_ID],
                          port_dict[const.PORT_ID], remote_interface)
        self.tearDownNetworkPortInterface(tenant_id, instance_tenant_id,
                                          instance_id, instance_vif_desc,
                                          new_net_dict[const.NET_ID],
                                          port_dict[const.PORT_ID])

        LOG.debug("test_plug_interface_portInUse - END")
    def test_plug_interface_portInUse(self, tenant_id='test_tenant',
                                      instance_tenant_id='nova',
                                      nova_user_id='novaadmin',
                                      instance_id=10,
                                      vif_id='fe701ddf-26a2-42ea-'
                                             'b9e6-7313d1c522cc',
                                      remote_interface='new_interface'):
        """
        Tests attachment of new interface to the port when there is an
        existing attachment
        """
        LOG.debug("test_plug_interface_portInUse - START")
        new_net_dict = self._l2network_plugin.create_network(tenant_id,
                                                             self.network_name)
        port_dict = self._l2network_plugin.create_port(
            tenant_id, new_net_dict[const.NET_ID], self.state)
        instance_desc = {'project_id': tenant_id, 'user_id': nova_user_id}
        host_list = self._l2network_plugin.schedule_host(instance_tenant_id,
                                                         instance_id,
                                                         instance_desc)
        instance_vif_desc = {'project_id': tenant_id, 'user_id': nova_user_id,
                             'vif_id': vif_id}

        if conf.PLUGINS[const.PLUGINS].keys():
            vif_description = self._l2network_plugin.associate_port(
                instance_tenant_id, instance_id, instance_vif_desc)
        else:
            db.port_set_attachment_by_id(port_dict[const.PORT_ID],
                                         instance_vif_desc['vif_id'] +
                                         const.UNPLUGGED)

        self.assertRaises(exc.PortInUse, self._l2network_plugin.plug_interface,
                          tenant_id, new_net_dict[const.NET_ID],
                          port_dict[const.PORT_ID], remote_interface)
        self.tearDownNetworkPortInterface(tenant_id, instance_tenant_id,
                                          instance_id, instance_vif_desc,
                                          new_net_dict[const.NET_ID],
                                          port_dict[const.PORT_ID])

        LOG.debug("test_plug_interface_portInUse - END")
Example #7
0
    def test_delete_networkInUse(self,
                                 tenant_id='test_tenant',
                                 instance_tenant_id='nova',
                                 nova_user_id='novaadmin',
                                 instance_id=10,
                                 vif_id='fe701ddf-26a2-'
                                 '42ea-b9e6-7313d1c522cc'):
        """
        Tests deletion of a Virtual Network when Network is in Use.
        """
        LOG.debug("test_delete_networkInUse - START")

        new_net_dict = self._l2network_plugin.create_network(
            tenant_id, self.network_name)
        port_dict = self._l2network_plugin.create_port(
            tenant_id, new_net_dict[const.NET_ID], self.state)
        instance_desc = {'project_id': tenant_id, 'user_id': nova_user_id}
        host_list = self._l2network_plugin.schedule_host(
            instance_tenant_id, instance_id, instance_desc)
        instance_vif_desc = {
            'project_id': tenant_id,
            'user_id': nova_user_id,
            'vif_id': vif_id
        }
        if conf.PLUGINS[const.PLUGINS].keys():
            vif_description = self._l2network_plugin.associate_port(
                instance_tenant_id, instance_id, instance_vif_desc)
        else:
            db.port_set_attachment_by_id(
                port_dict[const.PORT_ID],
                instance_vif_desc['vif_id'] + const.UNPLUGGED)
        self.assertRaises(exc.NetworkInUse,
                          self._l2network_plugin.delete_network, tenant_id,
                          new_net_dict[const.NET_ID])
        self.tearDownNetworkPortInterface(tenant_id, instance_tenant_id,
                                          instance_id, instance_vif_desc,
                                          new_net_dict[const.NET_ID],
                                          port_dict[const.PORT_ID])
        LOG.debug("test_delete_networkInUse - END")
    def test_delete_networkInUse(self, tenant_id='test_tenant',
                                 instance_tenant_id='nova',
                                 nova_user_id='novaadmin', instance_id=10,
                                 vif_id='fe701ddf-26a2-'
                                        '42ea-b9e6-7313d1c522cc'):

        """
        Tests deletion of a Virtual Network when Network is in Use.
        """
        LOG.debug("test_delete_networkInUse - START")

        new_net_dict = self._l2network_plugin.create_network(
            tenant_id, self.network_name)
        port_dict = self._l2network_plugin.create_port(
            tenant_id, new_net_dict[const.NET_ID], self.state)
        instance_desc = {'project_id': tenant_id,
                         'user_id': nova_user_id}
        host_list = self._l2network_plugin.schedule_host(instance_tenant_id,
                                                         instance_id,
                                                         instance_desc)
        instance_vif_desc = {'project_id': tenant_id,
                             'user_id': nova_user_id,
                             'vif_id': vif_id}
        if conf.PLUGINS[const.PLUGINS].keys():
            vif_description = self._l2network_plugin.associate_port(
                instance_tenant_id, instance_id, instance_vif_desc)
        else:
            db.port_set_attachment_by_id(port_dict[const.PORT_ID],
                                         instance_vif_desc['vif_id'] +
                                         const.UNPLUGGED)
        self.assertRaises(exc.NetworkInUse,
                          self._l2network_plugin.delete_network, tenant_id,
                          new_net_dict[const.NET_ID])
        self.tearDownNetworkPortInterface(
            tenant_id, instance_tenant_id, instance_id, instance_vif_desc,
            new_net_dict[const.NET_ID], port_dict[const.PORT_ID])
        LOG.debug("test_delete_networkInUse - END")