Example #1
0
    def test_get_dhcp_opts_for_nw01(self):
        def get_instance(_context, instance_id):
            print instance_id
            return instances[instance_id]

        self.stubs.Set(db, 'instance_get', get_instance)
        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

        db.network_get_associated_fixed_ips(
                mox.IgnoreArg(),
                mox.IgnoreArg()).AndReturn([fixed_ips[1], fixed_ips[2],
                                            fixed_ips[5]])
        db.virtual_interface_get_by_instance(
                mox.IgnoreArg(),
                mox.IgnoreArg()).AndReturn([vifs[0], vifs[1], vifs[4]])
        db.virtual_interface_get_by_instance(
                mox.IgnoreArg(),
                mox.IgnoreArg()).AndReturn([vifs[2], vifs[3], vifs[5]])
        self.mox.ReplayAll()

        expected_opts = "NW-i00000000-1,3"
        actual_opts = self.driver.get_dhcp_opts(self.context, networks[1])

        self.assertEquals(actual_opts, expected_opts)
Example #2
0
    def test_get_dhcp_opts_for_nw01(self):
        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[1],
                                                        fixed_ips[2],
                                                        fixed_ips[5]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[0],
                                                         vifs[1],
                                                         vifs[4]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[2],
                                                         vifs[3],
                                                         vifs[5]])
        self.mox.ReplayAll()

        expected_opts = "NW-i00000000-1,3"
        actual_opts = self.driver.get_dhcp_opts(None, networks[1])

        self.assertEquals(actual_opts, expected_opts)
Example #3
0
    def test_get_dhcp_opts_for_nw01(self):
        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[1],
                                                        fixed_ips[2],
                                                        fixed_ips[5]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[0],
                                                         vifs[1],
                                                         vifs[4]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[2],
                                                         vifs[3],
                                                         vifs[5]])
        self.mox.ReplayAll()

        expected_opts = "NW-i00000000-1,3"
        actual_opts = self.driver.get_dhcp_opts(None, networks[1])

        self.assertEquals(actual_opts, expected_opts)
Example #4
0
    def test_get_dhcp_opts_for_nw01(self):
        def get_instance(_context, instance_id):
            print instance_id
            return instances[instance_id]

        self.stubs.Set(db, 'instance_get', get_instance)
        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg()).AndReturn([
                                                fixed_ips[1], fixed_ips[2],
                                                fixed_ips[5]
                                            ])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg()).AndReturn(
                                                 [vifs[0], vifs[1], vifs[4]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg()).AndReturn(
                                                 [vifs[2], vifs[3], vifs[5]])
        self.mox.ReplayAll()

        expected_opts = "NW-i00000000-1,3"
        actual_opts = self.driver.get_dhcp_opts(self.context, networks[1])

        self.assertEquals(actual_opts, expected_opts)
Example #5
0
    def test_get_instance_nw_info(self):
        self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
        self.mox.StubOutWithMock(db, 'instance_type_get')

        db.fixed_ip_get_by_instance(mox.IgnoreArg(),
                                    mox.IgnoreArg()).AndReturn(fixed_ips)
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg()).AndReturn(vifs)
        db.instance_type_get(mox.IgnoreArg(),
                                   mox.IgnoreArg()).AndReturn(flavor)
        self.mox.ReplayAll()

        nw_info = self.network.get_instance_nw_info(None, 0, 0, None)

        self.assertTrue(nw_info)

        for i, nw in enumerate(nw_info):
            i8 = i + 8
            check = {'bridge': 'fa%s' % i,
                     'cidr': '192.168.%s.0/24' % i,
                     'cidr_v6': '2001:db%s::/64' % i8,
                     'id': i,
                     'multi_host': False,
                     'injected': 'DONTCARE',
                     'bridge_interface': 'fake_fa%s' % i,
                     'vlan': None}

            self.assertDictMatch(nw[0], check)

            check = {'broadcast': '192.168.%s.255' % i,
                     'dhcp_server': '192.168.%s.1' % i,
                     'dns': 'DONTCARE',
                     'gateway': '192.168.%s.1' % i,
                     'gateway6': '2001:db%s::1' % i8,
                     'ip6s': 'DONTCARE',
                     'ips': 'DONTCARE',
                     'label': 'test%s' % i,
                     'mac': 'DE:AD:BE:EF:00:0%s' % i,
                     'vif_uuid': ('00000000-0000-0000-0000-000000000000000%s' %
                                  i),
                     'rxtx_cap': 'DONTCARE',
                     'should_create_vlan': False,
                     'should_create_bridge': False}
            self.assertDictMatch(nw[1], check)

            check = [{'enabled': 'DONTCARE',
                      'ip': '2001:db%s::dcad:beff:feef:%s' % (i8, i),
                      'netmask': '64'}]
            self.assertDictListMatch(nw[1]['ip6s'], check)

            check = [{'enabled': '1',
                      'ip': '192.168.%s.100' % i,
                      'netmask': '255.255.255.0'}]
            self.assertDictListMatch(nw[1]['ips'], check)
Example #6
0
    def test_get_instance_nw_info(self):
        self.mox.StubOutWithMock(db, 'fixed_ip_get_by_instance')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
        self.mox.StubOutWithMock(db, 'instance_type_get')

        db.fixed_ip_get_by_instance(mox.IgnoreArg(),
                                    mox.IgnoreArg()).AndReturn(fixed_ips)
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg()).AndReturn(vifs)
        db.instance_type_get(mox.IgnoreArg(),
                                   mox.IgnoreArg()).AndReturn(flavor)
        self.mox.ReplayAll()

        nw_info = self.network.get_instance_nw_info(None, 0, 0, None)

        self.assertTrue(nw_info)

        for i, nw in enumerate(nw_info):
            i8 = i + 8
            check = {'bridge': 'fa%s' % i,
                     'cidr': '192.168.%s.0/24' % i,
                     'cidr_v6': '2001:db%s::/64' % i8,
                     'id': i,
                     'multi_host': False,
                     'injected': 'DONTCARE',
                     'bridge_interface': 'fake_fa%s' % i,
                     'vlan': None}

            self.assertDictMatch(nw[0], check)

            check = {'broadcast': '192.168.%s.255' % i,
                     'dhcp_server': '192.168.%s.1' % i,
                     'dns': 'DONTCARE',
                     'gateway': '192.168.%s.1' % i,
                     'gateway6': '2001:db%s::1' % i8,
                     'ip6s': 'DONTCARE',
                     'ips': 'DONTCARE',
                     'label': 'test%s' % i,
                     'mac': 'DE:AD:BE:EF:00:0%s' % i,
                     'vif_uuid': ('00000000-0000-0000-0000-000000000000000%s' %
                                  i),
                     'rxtx_cap': 'DONTCARE',
                     'should_create_vlan': False,
                     'should_create_bridge': False}
            self.assertDictMatch(nw[1], check)

            check = [{'enabled': 'DONTCARE',
                      'ip': '2001:db%s::dcad:beff:feef:%s' % (i8, i),
                      'netmask': '64'}]
            self.assertDictListMatch(nw[1]['ip6s'], check)

            check = [{'enabled': '1',
                      'ip': '192.168.%s.100' % i,
                      'netmask': '255.255.255.0'}]
            self.assertDictListMatch(nw[1]['ips'], check)
 def get_by_instance_uuid(cls,
                          context,
                          instance_uuid,
                          use_subordinate=False):
     db_vifs = db.virtual_interface_get_by_instance(
         context, instance_uuid, use_subordinate=use_subordinate)
     return base.obj_make_list(context, cls(), VirtualInterface, db_vifs)
Example #8
0
def _from_bm_node(instance_id, tenant_id):
    LOG.debug('_from_bm_node(instance_id=%s,tenant_id=%s)', instance_id,
              tenant_id)
    ctx = context.get_admin_context()
    info = []
    for vif in db.virtual_interface_get_by_instance(ctx, instance_id):
        LOG.debug('vif=%s', vif.__dict__)
        mac = vif.address
        network_ref = None
        if vif['network_id']:
            network_ref = db.network_get(ctx, vif['network_id'])
        if not network_ref:
            LOG.warn('vif.network is None')
            continue
        LOG.debug('vif.network=%s', network_ref.__dict__)
        network_uuid = network_ref.uuid
        if not network_uuid:
            LOG.warn('network_uuid is None')
            continue
        vifinfo_uuid = _get_vifinfo_uuid(tenant_id, network_uuid, vif.uuid)
        LOG.debug('vifinfo_uuid=%s', vifinfo_uuid)
        if not vifinfo_uuid:
            continue
        fixed_ips = db.fixed_ips_by_virtual_interface(ctx, vif.id)
        if not fixed_ips:
            LOG.warn('fixed_ip is None')
            continue
        addrs = [fip.address for fip in fixed_ips]
        info.append((vifinfo_uuid, network_uuid, mac, addrs))
    LOG.debug('_from_bm_node(instance_id=%s,tenant_id=%s) end: info=%s',
              instance_id, tenant_id, info)
    return info
def get_dhcp_opts(context, network_ref):
    """Get network's hosts config in dhcp-opts format."""
    hosts = []
    host = None
    if network_ref['multi_host']:
        host = FLAGS.host
    data = db.network_get_associated_fixed_ips(context,
                                               network_ref['id'],
                                               host=host)

    if data:
        #set of instance ids
        instance_set = set([datum['instance_id'] for datum in data])
        default_gw_vif = {}
        for instance_id in instance_set:
            vifs = db.virtual_interface_get_by_instance(context, instance_id)
            if vifs:
                #offer a default gateway to the first virtual interface
                default_gw_vif[instance_id] = vifs[0]['id']

        for datum in data:
            if instance_id in default_gw_vif:
                # we don't want default gateway for this fixed ip
                if default_gw_vif[instance_id] != datum['vif_id']:
                    hosts.append(_host_dhcp_opts(datum))
    return '\n'.join(hosts)
Example #10
0
def get_dhcp_opts(context, network_ref):
    """Get network's hosts config in dhcp-opts format."""
    hosts = []
    ips_ref = db.network_get_associated_fixed_ips(context, network_ref['id'])

    if ips_ref:
        #set of instance ids
        instance_set = set([fixed_ip_ref['instance_id']
                            for fixed_ip_ref in ips_ref])
        default_gw_network_node = {}
        for instance_id in instance_set:
            vifs = db.virtual_interface_get_by_instance(context, instance_id)
            if vifs:
                #offer a default gateway to the first virtual interface
                default_gw_network_node[instance_id] = vifs[0]['network_id']

        for fixed_ip_ref in ips_ref:
            instance_id = fixed_ip_ref['instance_id']
            try:
                instance_ref = db.instance_get(context, instance_id)
            except exception.InstanceNotFound:
                msg = _("Instance %(instance_id)s not found")
                LOG.debug(msg % {'instance_id': instance_id})
                continue

            if instance_id in default_gw_network_node:
                target_network_id = default_gw_network_node[instance_id]
                # we don't want default gateway for this fixed ip
                if target_network_id != fixed_ip_ref['network_id']:
                    hosts.append(_host_dhcp_opts(fixed_ip_ref,
                                                 instance_ref))
    return '\n'.join(hosts)
Example #11
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get('instance_id')
        project_id = kwargs.pop('project_id', None)

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context,
                                                    instance_id)

        for vif in vifs:
            network = db.network_get(admin_context, vif['network_id'])

            self.deallocate_port(vif['uuid'], network['uuid'], project_id,
                                 instance_id)

            ipam_tenant_id = self.deallocate_ip_address(context,
                                network['uuid'], project_id, vif, instance_id)

            if FLAGS.quantum_use_dhcp:
                self.update_dhcp(context, ipam_tenant_id, network,
                                 vif, project_id)

            db.virtual_interface_delete(admin_context, vif['id'])
Example #12
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get('instance_id')
        project_id = kwargs.pop('project_id', None)

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context,
                                                    instance_id)

        for vif in vifs:
            network = db.network_get(admin_context, vif['network_id'])

            self.deallocate_port(vif['uuid'], network['uuid'], project_id,
                                 instance_id)

            ipam_tenant_id = self.deallocate_ip_address(context,
                                network['uuid'], project_id, vif, instance_id)

            if FLAGS.quantum_use_dhcp:
                self.update_dhcp(context, ipam_tenant_id, network,
                                 vif, project_id)

            db.virtual_interface_delete(admin_context, vif['id'])
Example #13
0
def get_network_info(instance):
    # TODO(tr3buchet): this function needs to go away! network info
    #                  MUST be passed down from compute
    # TODO(adiantum) If we will keep this function
    # we should cache network_info
    admin_context = context.get_admin_context()

    try:
        fixed_ips = db.fixed_ip_get_by_instance(admin_context, instance['id'])
    except exception.FixedIpNotFoundForInstance:
        fixed_ips = []

    vifs = db.virtual_interface_get_by_instance(admin_context, instance['id'])
    flavor = db.instance_type_get(admin_context, instance['instance_type_id'])
    network_info = []

    for vif in vifs:
        network = vif['network']

        # determine which of the instance's IPs belong to this network
        network_ips = [
            fixed_ip['address'] for fixed_ip in fixed_ips
            if fixed_ip['network_id'] == network['id']
        ]

        def ip_dict(ip):
            return {'ip': ip, 'netmask': network['netmask'], 'enabled': '1'}

        def ip6_dict():
            prefix = network['cidr_v6']
            mac = vif['address']
            project_id = instance['project_id']
            return {
                'ip': ipv6.to_global(prefix, mac, project_id),
                'netmask': network['netmask_v6'],
                'enabled': '1'
            }

        mapping = {
            'label': network['label'],
            'gateway': network['gateway'],
            'broadcast': network['broadcast'],
            'dhcp_server': network['gateway'],
            'mac': vif['address'],
            'rxtx_cap': flavor['rxtx_cap'],
            'dns': [],
            'ips': [ip_dict(ip) for ip in network_ips]
        }

        if network['dns1']:
            mapping['dns'].append(network['dns1'])
        if network['dns2']:
            mapping['dns'].append(network['dns2'])

        if FLAGS.use_ipv6:
            mapping['ip6s'] = [ip6_dict()]
            mapping['gateway6'] = network['gateway_v6']

        network_info.append((network, mapping))
    return network_info
Example #14
0
def get_dhcp_opts(context, network_ref):
    """Get network's hosts config in dhcp-opts format."""
    hosts = []
    host = None
    if network_ref['multi_host']:
        host = FLAGS.host
    data = db.network_get_associated_fixed_ips(context,
                                               network_ref['id'],
                                               host=host)

    if data:
        #set of instance ids
        instance_set = set([datum['instance_id'] for datum in data])
        default_gw_vif = {}
        for instance_id in instance_set:
            vifs = db.virtual_interface_get_by_instance(context, instance_id)
            if vifs:
                #offer a default gateway to the first virtual interface
                default_gw_vif[instance_id] = vifs[0]['id']

        for datum in data:
            if instance_id in default_gw_vif:
                # we don't want default gateway for this fixed ip
                if default_gw_vif[instance_id] != datum['vif_id']:
                    hosts.append(_host_dhcp_opts(datum))
    return '\n'.join(hosts)
Example #15
0
def get_network_info(instance):
    # TODO(tr3buchet): this function needs to go away! network info
    #                  MUST be passed down from compute
    # TODO(adiantum) If we will keep this function
    # we should cache network_info
    admin_context = context.get_admin_context()

    try:
        fixed_ips = db.fixed_ip_get_by_instance(admin_context, instance['id'])
    except exception.FixedIpNotFoundForInstance:
        fixed_ips = []

    vifs = db.virtual_interface_get_by_instance(admin_context, instance['id'])
    flavor = db.instance_type_get(admin_context,
                                        instance['instance_type_id'])
    network_info = []

    for vif in vifs:
        network = vif['network']

        # determine which of the instance's IPs belong to this network
        network_ips = [fixed_ip['address'] for fixed_ip in fixed_ips if
                       fixed_ip['network_id'] == network['id']]

        def ip_dict(ip):
            return {
                'ip': ip,
                'netmask': network['netmask'],
                'enabled': '1'}

        def ip6_dict():
            prefix = network['cidr_v6']
            mac = vif['address']
            project_id = instance['project_id']
            return  {
                'ip': ipv6.to_global(prefix, mac, project_id),
                'netmask': network['netmask_v6'],
                'enabled': '1'}

        mapping = {
            'label': network['label'],
            'gateway': network['gateway'],
            'broadcast': network['broadcast'],
            'dhcp_server': network['gateway'],
            'mac': vif['address'],
            'rxtx_cap': flavor['rxtx_cap'],
            'dns': [],
            'ips': [ip_dict(ip) for ip in network_ips]}

        if network['dns1']:
            mapping['dns'].append(network['dns1'])
        if network['dns2']:
            mapping['dns'].append(network['dns2'])

        if FLAGS.use_ipv6:
            mapping['ip6s'] = [ip6_dict()]
            mapping['gateway6'] = network['gateway_v6']

        network_info.append((network, mapping))
    return network_info
Example #16
0
def get_dhcp_opts(context, network_ref):
    """Get network's hosts config in dhcp-opts format."""
    hosts = []
    ips_ref = db.network_get_associated_fixed_ips(context, network_ref['id'])

    if ips_ref:
        #set of instance ids
        instance_set = set(
            [fixed_ip_ref['instance_id'] for fixed_ip_ref in ips_ref])
        default_gw_network_node = {}
        for instance_id in instance_set:
            vifs = db.virtual_interface_get_by_instance(context, instance_id)
            if vifs:
                #offer a default gateway to the first virtual interface
                default_gw_network_node[instance_id] = vifs[0]['network_id']

        for fixed_ip_ref in ips_ref:
            instance_id = fixed_ip_ref['instance_id']
            try:
                instance_ref = db.instance_get(context, instance_id)
            except exception.InstanceNotFound:
                msg = _("Instance %(instance_id)s not found")
                LOG.debug(msg % {'instance_id': instance_id})
                continue

            if instance_id in default_gw_network_node:
                target_network_id = default_gw_network_node[instance_id]
                # we don't want default gateway for this fixed ip
                if target_network_id != fixed_ip_ref['network_id']:
                    hosts.append(_host_dhcp_opts(fixed_ip_ref, instance_ref))
    return '\n'.join(hosts)
def _from_phy_host(instance_id, tenant_id):
    LOG.debug('_from_phy_host(instance_id=%s,tenant_id=%s)', instance_id, tenant_id)
    ctx = context.get_admin_context()
    info = []
    for vif in db.virtual_interface_get_by_instance(ctx, instance_id):
        LOG.debug('vif=%s', vif.__dict__)
        mac = vif.address
        network_ref = vif.network
        if not network_ref:
            LOG.warn('vif.network is None')
            continue
        LOG.debug('vif.network=%s', network_ref.__dict__)
        network_uuid = network_ref.uuid
        if not network_uuid:
            LOG.warn('network_uuid is None')
            continue
        vifinfo_uuid = _get_vifinfo_uuid(tenant_id, vif.uuid)
        LOG.debug('vifinfo_uuid=%s', vifinfo_uuid)
        if not vifinfo_uuid:
            continue
        fixed_ip = db.fixed_ip_get_by_virtual_interface(ctx, vif.id)
        if not fixed_ip:
            LOG.warn('fixed_ip is None')
            continue
        addrs = [ fip.address for fip in fixed_ip ]
        info.append( (vifinfo_uuid, network_uuid, mac, addrs) )
    LOG.debug('_from_phy_host(instance_id=%s,tenant_id=%s) end: info=%s', instance_id, tenant_id, info)
    return info
Example #18
0
    def test_update_dhcp_for_nw01(self):
        self.flags(use_single_default_gateway=True)

        def get_vif(_context, vif_id):
            return vifs[vif_id]

        def get_instance(_context, instance_id):
            return instances[instance_id]

        self.stubs.Set(db, 'virtual_interface_get', get_vif)
        self.stubs.Set(db, 'instance_get', get_instance)
        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
        self.mox.StubOutWithMock(self.driver, 'write_to_file')
        self.mox.StubOutWithMock(self.driver, 'ensure_path')
        self.mox.StubOutWithMock(os, 'chmod')

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[1],
                                                        fixed_ips[2]])

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[1],
                                                        fixed_ips[2]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[0], vifs[1]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[2], vifs[3]])
        self.driver.write_to_file(mox.IgnoreArg(), mox.IgnoreArg())
        self.driver.write_to_file(mox.IgnoreArg(), mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        os.chmod(mox.IgnoreArg(), mox.IgnoreArg())
        os.chmod(mox.IgnoreArg(), mox.IgnoreArg())

        self.mox.ReplayAll()

        self.driver.update_dhcp(self.context, "eth0", networks[0])
Example #19
0
    def test_update_dhcp_for_nw01(self):
        self.flags(use_single_default_gateway=True)

        def get_vif(_context, vif_id):
            return vifs[vif_id]

        def get_instance(_context, instance_id):
            return instances[instance_id]

        self.stubs.Set(db, 'virtual_interface_get', get_vif)
        self.stubs.Set(db, 'instance_get', get_instance)
        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
        self.mox.StubOutWithMock(self.driver, 'write_to_file')
        self.mox.StubOutWithMock(self.driver, 'ensure_path')
        self.mox.StubOutWithMock(os, 'chmod')

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[1],
                                                        fixed_ips[2]])

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[1],
                                                        fixed_ips[2]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[0], vifs[1]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[2], vifs[3]])
        self.driver.write_to_file(mox.IgnoreArg(), mox.IgnoreArg())
        self.driver.write_to_file(mox.IgnoreArg(), mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        os.chmod(mox.IgnoreArg(), mox.IgnoreArg())
        os.chmod(mox.IgnoreArg(), mox.IgnoreArg())

        self.mox.ReplayAll()

        self.driver.update_dhcp(self.context, "eth0", networks[0])
Example #20
0
    def test_get_instance_nw_info(self):
        self.mox.StubOutWithMock(db, "fixed_ip_get_by_instance")
        self.mox.StubOutWithMock(db, "virtual_interface_get_by_instance")
        self.mox.StubOutWithMock(db, "instance_type_get_by_id")

        db.fixed_ip_get_by_instance(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(fixed_ips)
        db.virtual_interface_get_by_instance(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(vifs)
        db.instance_type_get_by_id(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(flavor)
        self.mox.ReplayAll()

        nw_info = self.network.get_instance_nw_info(None, 0, 0)

        self.assertTrue(nw_info)

        for i, nw in enumerate(nw_info):
            i8 = i + 8
            check = {
                "bridge": "fa%s" % i,
                "cidr": "192.168.%s.0/24" % i,
                "cidr_v6": "2001:db%s::/64" % i8,
                "id": i,
                "injected": "DONTCARE",
            }

            self.assertDictMatch(nw[0], check)

            check = {
                "broadcast": "192.168.%s.255" % i,
                "dns": "DONTCARE",
                "gateway": "192.168.%s.1" % i,
                "gateway6": "2001:db%s::1" % i8,
                "ip6s": "DONTCARE",
                "ips": "DONTCARE",
                "label": "test%s" % i,
                "mac": "DE:AD:BE:EF:00:0%s" % i,
                "rxtx_cap": "DONTCARE",
            }
            self.assertDictMatch(nw[1], check)

            check = [{"enabled": "DONTCARE", "ip": "2001:db%s::dcad:beff:feef:%s" % (i8, i), "netmask": "64"}]
            self.assertDictListMatch(nw[1]["ip6s"], check)

            check = [{"enabled": "1", "ip": "192.168.%s.100" % i, "netmask": "255.255.255.0"}]
            self.assertDictListMatch(nw[1]["ips"], check)
Example #21
0
    def test_update_dhcp_for_nw00(self):
        self.flags(use_single_default_gateway=True)

        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')
        self.mox.StubOutWithMock(self.driver, 'write_to_file')
        self.mox.StubOutWithMock(self.driver, 'ensure_path')
        self.mox.StubOutWithMock(os, 'chmod')

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[0],
                                                        fixed_ips[3]])

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[0],
                                                        fixed_ips[3]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[0], vifs[1]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[2], vifs[3]])
        self.driver.write_to_file(mox.IgnoreArg(), mox.IgnoreArg())
        self.driver.write_to_file(mox.IgnoreArg(), mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        self.driver.ensure_path(mox.IgnoreArg())
        os.chmod(mox.IgnoreArg(), mox.IgnoreArg())
        os.chmod(mox.IgnoreArg(), mox.IgnoreArg())

        self.mox.ReplayAll()

        self.driver.update_dhcp(None, "eth0", networks[0])
 def test_multi_nic(self):
     """
     Multinic - Verify that nics as specified in the database are created
     in the guest
     """
     vifs = db.virtual_interface_get_by_instance(context.get_admin_context(),
                                                 instance_info.local_id)
     for vif in vifs:
         fixed_ip = db.fixed_ip_get_by_virtual_interface(context.get_admin_context(),
                                                         vif['id'])
         vz_ip = get_vz_ip_for_device(instance_info.local_id,
                                      vif['network']['bridge_interface'])
         assert_equal(vz_ip, fixed_ip[0]['address'])
Example #23
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get("instance_id")
        project_id = kwargs.pop("project_id", None)

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context, instance_id)
        for vif_ref in vifs:
            interface_id = vif_ref["uuid"]
            q_tenant_id = project_id

            network_ref = db.network_get(admin_context, vif_ref["network_id"])
            net_id = network_ref["uuid"]

            # port deallocate block
            try:
                port_id = None
                port_id = self.q_conn.get_port_by_attachment(q_tenant_id, net_id, interface_id)
                if not port_id:
                    q_tenant_id = FLAGS.quantum_default_tenant_id
                    port_id = self.q_conn.get_port_by_attachment(q_tenant_id, net_id, interface_id)

                if not port_id:
                    LOG.error("Unable to find port with attachment: %s" % (interface_id))
                else:
                    self.q_conn.detach_and_delete_port(q_tenant_id, net_id, port_id)
            except:
                # except anything so the rest of deallocate can succeed
                msg = _("port deallocation failed for instance: " "|%(instance_id)s|, port_id: |%(port_id)s|")
                LOG.critical(msg % locals())

            # ipam deallocation block
            try:
                ipam_tenant_id = self.ipam.get_tenant_id_by_net_id(context, net_id, vif_ref["uuid"], project_id)

                self.ipam.deallocate_ips_by_vif(context, ipam_tenant_id, net_id, vif_ref)
                db.virtual_interface_delete(admin_context, vif_ref["id"])

                # If DHCP is enabled on this network then we need to update the
                # leases and restart the server.
                if FLAGS.quantum_use_dhcp:
                    self.update_dhcp(context, ipam_tenant_id, network_ref, vif_ref, project_id)
            except:
                # except anything so the rest of deallocate can succeed
                vif_uuid = vif_ref["uuid"]
                msg = _("ipam deallocation failed for instance: " "|%(instance_id)s|, vif_uuid: |%(vif_uuid)s|")
                LOG.critical(msg % locals())
Example #24
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get('instance_id')
        project_id = kwargs.pop('project_id', None)

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context,
                                                    instance_id)
        for vif_ref in vifs:
            interface_id = vif_ref['uuid']
            q_tenant_id = project_id

            network_ref = db.network_get(admin_context, vif_ref['network_id'])
            net_id = network_ref['uuid']

            port_id = self.q_conn.get_port_by_attachment(q_tenant_id,
                                                         net_id, interface_id)
            if not port_id:
                q_tenant_id = FLAGS.quantum_default_tenant_id
                port_id = self.q_conn.get_port_by_attachment(
                    q_tenant_id, net_id, interface_id)

            if not port_id:
                LOG.error("Unable to find port with attachment: %s" %
                          (interface_id))
            else:
                self.q_conn.detach_and_delete_port(q_tenant_id,
                                                   net_id, port_id)

            ipam_tenant_id = self.ipam.get_tenant_id_by_net_id(context,
                net_id, vif_ref['uuid'], project_id)

            self.ipam.deallocate_ips_by_vif(context, ipam_tenant_id,
                                            net_id, vif_ref)

            # If DHCP is enabled on this network then we need to update the
            # leases and restart the server.
            if FLAGS.quantum_use_dhcp:
                self.update_dhcp(context, ipam_tenant_id, network_ref, vif_ref,
                    project_id)
        try:
            db.virtual_interface_delete_by_instance(admin_context,
                                                    instance_id)
        except exception.InstanceNotFound:
            LOG.error(_("Attempted to deallocate non-existent instance: %s" %
                        (instance_id)))
Example #25
0
 def test_multi_nic(self):
     """
     Multinic - Verify that nics as specified in the database are created
     in the guest
     """
     admin_context = context.get_admin_context()
     vifs = db.virtual_interface_get_by_instance(admin_context(),
                                                 instance_info.local_id)
     for vif in vifs:
         fixed_ip = db.fixed_ip_get_by_virtual_interface(
             admin_context(), vif['id'])
         vz_ip = get_vz_ip_for_device(instance_info.local_id,
                                      vif['network']['bridge_interface'])
         assert_equal(vz_ip, fixed_ip[0]['address'])
Example #26
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get('instance_id')
        project_id = kwargs.pop('project_id', None)

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context,
                                                    instance_id)
        for vif_ref in vifs:
            interface_id = vif_ref['uuid']
            q_tenant_id = project_id

            network_ref = db.network_get(admin_context, vif_ref['network_id'])
            net_id = network_ref['uuid']

            port_id = self.q_conn.get_port_by_attachment(q_tenant_id,
                                                         net_id, interface_id)
            if not port_id:
                q_tenant_id = FLAGS.quantum_default_tenant_id
                port_id = self.q_conn.get_port_by_attachment(
                    q_tenant_id, net_id, interface_id)

            if not port_id:
                LOG.error("Unable to find port with attachment: %s" %
                          (interface_id))
            else:
                self.q_conn.detach_and_delete_port(q_tenant_id,
                                                   net_id, port_id)

            ipam_tenant_id = self.ipam.get_tenant_id_by_net_id(context,
                net_id, vif_ref['uuid'], project_id)

            self.ipam.deallocate_ips_by_vif(context, ipam_tenant_id,
                                            net_id, vif_ref)

            # If DHCP is enabled on this network then we need to update the
            # leases and restart the server.
            if FLAGS.quantum_use_dhcp:
                self.update_dhcp(context, ipam_tenant_id, network_ref, vif_ref,
                    project_id)
        try:
            db.virtual_interface_delete_by_instance(admin_context,
                                                    instance_id)
        except exception.InstanceNotFound:
            LOG.error(_("Attempted to deallocate non-existent instance: %s" %
                        (instance_id)))
Example #27
0
    def test_update_dhcp_for_nw01(self):
        self.flags(use_single_default_gateway=True)
        self.mox.StubOutWithMock(db, 'network_get_associated_fixed_ips')
        self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance')

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[1],
                                                        fixed_ips[2]])

        db.network_get_associated_fixed_ips(mox.IgnoreArg(),
                                            mox.IgnoreArg())\
                                            .AndReturn([fixed_ips[1],
                                                        fixed_ips[2]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[0], vifs[1]])
        db.virtual_interface_get_by_instance(mox.IgnoreArg(),
                                             mox.IgnoreArg())\
                                             .AndReturn([vifs[2], vifs[3]])
        self.mox.ReplayAll()

        self.driver.update_dhcp(None, "eth0", networks[0])
Example #28
0
    def get_instance_nw_info(self, context, instance_id, instance_uuid,
                                            instance_type_id, host):
        """This method is used by compute to fetch all network data
           that should be used when creating the VM.

           The method simply loops through all virtual interfaces
           stored in the nova DB and queries the IPAM lib to get
           the associated IP data.

           The format of returned data is 'defined' by the initial
           set of NetworkManagers found in nova/network/manager.py .
           Ideally this 'interface' will be more formally defined
           in the future.
        """
        admin_context = context.elevated()
        project_id = context.project_id
        vifs = db.virtual_interface_get_by_instance(context, instance_id)
        instance_type = instance_types.get_instance_type(instance_type_id)

        net_tenant_dict = dict((net_id, tenant_id)
                               for (net_id, tenant_id)
                               in self.ipam.get_project_and_global_net_ids(
                                                          context, project_id))
        networks = {}
        for vif in vifs:
            if vif.get('network_id') is not None:
                network = db.network_get(admin_context, vif['network_id'])
                net_tenant_id = net_tenant_dict[network['uuid']]
                if net_tenant_id is None:
                    net_tenant_id = FLAGS.quantum_default_tenant_id
                network = {'id': network['id'],
                           'uuid': network['uuid'],
                           'bridge': 'ovs_flag',
                           'label': self.q_conn.get_network_name(net_tenant_id,
                                                              network['uuid']),
                           'project_id': net_tenant_id}
                networks[vif['uuid']] = network

        # update instance network cache and return network_info
        nw_info = self.build_network_info_model(context, vifs, networks,
                                                     instance_type, host)
        db.instance_info_cache_update(context, instance_uuid,
                                      {'network_info': nw_info.as_cache()})

        return nw_info
Example #29
0
    def get_instance_nw_info(self, context, instance_id, instance_uuid,
                             rxtx_factor, host, **kwargs):
        """This method is used by compute to fetch all network data
           that should be used when creating the VM.

           The method simply loops through all virtual interfaces
           stored in the nova DB and queries the IPAM lib to get
           the associated IP data.

           The format of returned data is 'defined' by the initial
           set of NetworkManagers found in nova/network/manager.py .
           Ideally this 'interface' will be more formally defined
           in the future.
        """
        project_id = kwargs['project_id']
        vifs = db.virtual_interface_get_by_instance(context, instance_id)

        net_tenant_dict = dict(
            (net_id, tenant_id) for (net_id, tenant_id) in
            self.ipam.get_project_and_global_net_ids(context, project_id))
        networks = {}
        for vif in vifs:
            if vif.get('network_id') is not None:
                network = db.network_get(context.elevated(), vif['network_id'])
                net_tenant_id = net_tenant_dict[network['uuid']]
                if net_tenant_id is None:
                    net_tenant_id = FLAGS.quantum_default_tenant_id
                network = {
                    'id': network['id'],
                    'uuid': network['uuid'],
                    'bridge': '',  # Quantum ignores this field
                    'label': network['label'],
                    'injected': FLAGS.flat_injected,
                    'project_id': net_tenant_id
                }
                networks[vif['uuid']] = network

        # update instance network cache and return network_info
        nw_info = self.build_network_info_model(context, vifs, networks,
                                                rxtx_factor, host)
        db.instance_info_cache_update(context, instance_uuid,
                                      {'network_info': nw_info.as_cache()})

        return nw_info
Example #30
0
    def get_instance_nw_info(self, context, instance_id, instance_uuid, rxtx_factor, host):
        """This method is used by compute to fetch all network data
           that should be used when creating the VM.

           The method simply loops through all virtual interfaces
           stored in the nova DB and queries the IPAM lib to get
           the associated IP data.

           The format of returned data is 'defined' by the initial
           set of NetworkManagers found in nova/network/manager.py .
           Ideally this 'interface' will be more formally defined
           in the future.
        """
        admin_context = context.elevated()
        project_id = context.project_id
        vifs = db.virtual_interface_get_by_instance(context, instance_id)

        net_tenant_dict = dict(
            (net_id, tenant_id) for (net_id, tenant_id) in self.ipam.get_project_and_global_net_ids(context, project_id)
        )
        networks = {}
        for vif in vifs:
            if vif.get("network_id") is not None:
                network = db.network_get(admin_context, vif["network_id"])
                net_tenant_id = net_tenant_dict[network["uuid"]]
                if net_tenant_id is None:
                    net_tenant_id = FLAGS.quantum_default_tenant_id
                network = {
                    "id": network["id"],
                    "uuid": network["uuid"],
                    "bridge": "",  # Quantum ignores this field
                    "label": network["label"],
                    "project_id": net_tenant_id,
                }
                networks[vif["uuid"]] = network

        # update instance network cache and return network_info
        nw_info = self.build_network_info_model(context, vifs, networks, rxtx_factor, host)
        db.instance_info_cache_update(context, instance_uuid, {"network_info": nw_info.as_cache()})

        return nw_info
Example #31
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get('instance_id')
        project_id = kwargs.pop('project_id', None)

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context, instance_id)

        for vif in vifs:
            network = db.network_get(admin_context, vif['network_id'])

            self.deallocate_port(vif['uuid'], network['uuid'], project_id,
                                 instance_id)

            ipam_tenant_id = self.deallocate_ip_address(
                context, network['uuid'], project_id, vif, instance_id)

            if FLAGS.quantum_use_dhcp:
                if network['host'] == self.host:
                    self.update_dhcp(context, ipam_tenant_id, network, vif,
                                     project_id)
                else:
                    topic = self.db.queue_get_for(context, FLAGS.network_topic,
                                                  network['host'])
                    rpc.call(
                        context, topic, {
                            'method': 'update_dhcp',
                            'args': {
                                'ipam_tenant_id': ipam_tenant_id,
                                'network_ref': network,
                                'vif_ref': vif,
                                'project_id': network['project_id']
                            }
                        })

            db.virtual_interface_delete(admin_context, vif['id'])
Example #32
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get("instance_id")
        project_id = kwargs.pop("project_id", None)

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context, instance_id)

        for vif in vifs:
            network = db.network_get(admin_context, vif["network_id"])

            self.deallocate_port(vif["uuid"], network["uuid"], project_id, instance_id)

            ipam_tenant_id = self.deallocate_ip_address(context, network["uuid"], project_id, vif, instance_id)

            if FLAGS.quantum_use_dhcp:
                if network["host"] == self.host:
                    self.update_dhcp(context, ipam_tenant_id, network, vif, project_id)
                else:
                    topic = self.db.queue_get_for(context, FLAGS.network_topic, network["host"])
                    rpc.call(
                        context,
                        topic,
                        {
                            "method": "update_dhcp",
                            "args": {
                                "ipam_tenant_id": ipam_tenant_id,
                                "network_ref": network,
                                "vif_ref": vif,
                                "project_id": network["project_id"],
                            },
                        },
                    )

            db.virtual_interface_delete(admin_context, vif["id"])
Example #33
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get('instance_id')
        project_id = kwargs.pop('project_id', None)

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context,
                                                    instance_id)
        for vif_ref in vifs:
            interface_id = vif_ref['uuid']
            q_tenant_id = project_id
            ipam_tenant_id = project_id
            (net_id, port_id) = self.q_conn.get_port_by_attachment(q_tenant_id,
                                            interface_id)
            if not net_id:
                q_tenant_id = FLAGS.quantum_default_tenant_id
                ipam_tenant_id = None
                (net_id, port_id) = self.q_conn.get_port_by_attachment(
                                        q_tenant_id, interface_id)
            if not net_id:
                LOG.error("Unable to find port with attachment: %s" %
                          (interface_id))
                continue
            self.q_conn.detach_and_delete_port(q_tenant_id,
                                               net_id, port_id)

            self.ipam.deallocate_ips_by_vif(context, ipam_tenant_id,
                                            net_id, vif_ref)

        try:
            db.virtual_interface_delete_by_instance(admin_context,
                                                    instance_id)
        except exception.InstanceNotFound:
            LOG.error(_("Attempted to deallocate non-existent instance: %s" %
                        (instance_id)))
Example #34
0
def get_dhcp_opts(context, network_ref):
    """Get network's hosts config in dhcp-opts format."""
    hosts = []
    ips_ref = db.network_get_associated_fixed_ips(context, network_ref["id"])

    if ips_ref:
        # set of instance ids
        instance_set = set([fixed_ip_ref["instance_id"] for fixed_ip_ref in ips_ref])
        default_gw_network_node = {}
        for instance_id in instance_set:
            vifs = db.virtual_interface_get_by_instance(context, instance_id)
            if vifs:
                # offer a default gateway to the first virtual interface
                default_gw_network_node[instance_id] = vifs[0]["network_id"]

        for fixed_ip_ref in ips_ref:
            instance_id = fixed_ip_ref["instance_id"]
            if instance_id in default_gw_network_node:
                target_network_id = default_gw_network_node[instance_id]
                # we don't want default gateway for this fixed ip
                if target_network_id != fixed_ip_ref["network_id"]:
                    hosts.append(_host_dhcp_opts(fixed_ip_ref))
    return "\n".join(hosts)
Example #35
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get('instance_id')
        project_id = kwargs.pop('project_id', None)

        admin_context = context.elevated()
        instance = db.instance_get(context, instance_id)
        vifs = db.virtual_interface_get_by_instance(admin_context,
                                                    instance['uuid'])

        for vif in vifs:
            network = db.network_get(admin_context, vif['network_id'])

            self.deallocate_port(vif['uuid'], network['uuid'], project_id,
                                 instance_id)

            ipam_tenant_id = self.deallocate_ip_address(context,
                                network['uuid'], project_id, vif, instance_id)

            if FLAGS.quantum_use_dhcp:
                if network['host'] == self.host:
                    self.update_dhcp(context, ipam_tenant_id, network,
                                 vif, project_id)
                else:
                    topic = rpc.queue_get_for(context,
                                FLAGS.network_topic, network['host'])
                    rpc.call(context, topic, {'method': 'update_dhcp',
                        'args': {'ipam_tenant_id': ipam_tenant_id,
                        'network_ref': network,
                        'vif_ref': vif,
                        'project_id': network['project_id']}})

            db.virtual_interface_delete(admin_context, vif['id'])
Example #36
0
    def deallocate_for_instance(self, context, **kwargs):
        """Called when a VM is terminated.  Loop through each virtual
           interface in the Nova DB and remove the Quantum port and
           clear the IP allocation using the IPAM.  Finally, remove
           the virtual interfaces from the Nova DB.
        """
        instance_id = kwargs.get('instance_id')
        project_id = kwargs.pop('project_id', None)

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context, instance_id)
        for vif_ref in vifs:
            interface_id = vif_ref['uuid']
            q_tenant_id = project_id
            ipam_tenant_id = project_id
            (net_id, port_id) = self.q_conn.get_port_by_attachment(
                q_tenant_id, interface_id)
            if not net_id:
                q_tenant_id = FLAGS.quantum_default_tenant_id
                ipam_tenant_id = None
                (net_id, port_id) = self.q_conn.get_port_by_attachment(
                    q_tenant_id, interface_id)
            if not net_id:
                LOG.error("Unable to find port with attachment: %s" %
                          (interface_id))
                continue
            self.q_conn.detach_and_delete_port(q_tenant_id, net_id, port_id)

            self.ipam.deallocate_ips_by_vif(context, ipam_tenant_id, net_id,
                                            vif_ref)

        try:
            db.virtual_interface_delete_by_instance(admin_context, instance_id)
        except exception.InstanceNotFound:
            LOG.error(
                _("Attempted to deallocate non-existent instance: %s" %
                  (instance_id)))
Example #37
0
File: manager.py Project: bgh/nova
    def get_instance_nw_info(self, context, instance_id, instance_type_id, host):
        """This method is used by compute to fetch all network data
           that should be used when creating the VM.

           The method simply loops through all virtual interfaces
           stored in the nova DB and queries the IPAM lib to get
           the associated IP data.

           The format of returned data is 'defined' by the initial
           set of NetworkManagers found in nova/network/manager.py .
           Ideally this 'interface' will be more formally defined
           in the future.
        """
        network_info = []
        instance = db.instance_get(context, instance_id)
        project_id = instance.project_id

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context, instance_id)
        for vif in vifs:
            net = db.network_get(admin_context, vif["network_id"])
            net_id = net["uuid"]

            if not net_id:
                # TODO(bgh): We need to figure out a way to tell if we
                # should actually be raising this exception or not.
                # In the case that a VM spawn failed it may not have
                # attached the vif and raising the exception here
                # prevents deletion of the VM.  In that case we should
                # probably just log, continue, and move on.
                raise Exception(_("No network for for virtual interface %s") % vif["uuid"])

            ipam_tenant_id = self.ipam.get_tenant_id_by_net_id(context, net_id, vif["uuid"], project_id)
            v4_subnets, v6_subnets = self.ipam.get_subnets_by_net_id(context, ipam_tenant_id, net_id, vif["uuid"])

            v4_ips = self.ipam.get_v4_ips_by_interface(context, net_id, vif["uuid"], project_id=ipam_tenant_id)
            v6_ips = self.ipam.get_v6_ips_by_interface(context, net_id, vif["uuid"], project_id=ipam_tenant_id)

            def _make_network_dict_and_info(subnet, ips, net, vif, v6=False):
                def ip_dict(ip, subnet):
                    return {"ip": ip, "netmask": subnet["netmask"], "enabled": "1"}

                network_dict = {"injected": True, "bridge": net["bridge"], "multi_host": False}

                q_tenant_id = project_id or FLAGS.quantum_default_tenant_id
                info = {
                    "label": self.q_conn.get_network_name(q_tenant_id, net["uuid"]),
                    "gateway": subnet["gateway"],
                    "dhcp_server": subnet["gateway"],
                    "broadcast": subnet["broadcast"],
                    "mac": vif["address"],
                    "vif_uuid": vif["uuid"],
                    "dns": [],
                }

                if not v6:
                    network_dict["cidr"] = subnet["cidr"]
                    info["ips"] = [ip_dict(ip, subnet) for ip in ips]
                else:
                    if subnet["cidr"]:
                        network_dict["cidr_v6"] = subnet["cidr"]
                        info["ip6s"] = [ip_dict(ip, subnet) for ip in ips]

                    if subnet["gateway"]:
                        info["gateway6"] = subnet["gateway"]

                dns_dict = {}
                for k in ["dns1", "dns2"]:
                    if k in subnet and subnet[k]:
                        dns_dict[subnet[k]] = None
                info["dns"] = [d for d in dns_dict.keys()]
                return network_dict, info

            for subnet in v4_subnets:
                network_dict, info = _make_network_dict_and_info(subnet, v4_ips, net, vif, False)
                network_info.append((network_dict, info))
            for subnet in v6_subnets:
                network_dict, info = _make_network_dict_and_info(subnet, v6_ips, net, vif, True)
                network_info.append((network_dict, info))
        return network_info
 def _db_virtual_interface_get_by_instance(context,
                                           instance_uuid,
                                           use_slave=False):
     return db.virtual_interface_get_by_instance(context, instance_uuid)
Example #39
0
    def get_instance_nw_info(self, context, instance_id,
                                instance_type_id, host):
        """This method is used by compute to fetch all network data
           that should be used when creating the VM.

           The method simply loops through all virtual interfaces
           stored in the nova DB and queries the IPAM lib to get
           the associated IP data.

           The format of returned data is 'defined' by the initial
           set of NetworkManagers found in nova/network/manager.py .
           Ideally this 'interface' will be more formally defined
           in the future.
        """
        network_info = []
        instance = db.instance_get(context, instance_id)
        project_id = instance.project_id

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context,
                                                    instance_id)
        for vif in vifs:
            q_tenant_id = project_id
            ipam_tenant_id = project_id
            net_id, port_id = self.q_conn.get_port_by_attachment(q_tenant_id,
                                                                 vif['uuid'])
            if not net_id:
                q_tenant_id = FLAGS.quantum_default_tenant_id
                ipam_tenant_id = None
                net_id, port_id = self.q_conn.get_port_by_attachment(
                                             q_tenant_id, vif['uuid'])
            if not net_id:
                # TODO(bgh): We need to figure out a way to tell if we
                # should actually be raising this exception or not.
                # In the case that a VM spawn failed it may not have
                # attached the vif and raising the exception here
                # prevents deletion of the VM.  In that case we should
                # probably just log, continue, and move on.
                raise Exception(_("No network for for virtual interface %s") %
                                vif['uuid'])
            (v4_subnet, v6_subnet) = self.ipam.get_subnets_by_net_id(context,
                                        ipam_tenant_id, net_id)
            v4_ips = self.ipam.get_v4_ips_by_interface(context,
                                        net_id, vif['uuid'],
                                        project_id=ipam_tenant_id)
            v6_ips = self.ipam.get_v6_ips_by_interface(context,
                                        net_id, vif['uuid'],
                                        project_id=ipam_tenant_id)

            quantum_net_id = v4_subnet['network_id'] or v6_subnet['network_id']

            def ip_dict(ip, subnet):
                return {
                    "ip": ip,
                    "netmask": subnet["netmask"],
                    "enabled": "1"}

            network_dict = {
                'cidr': v4_subnet['cidr'],
                'injected': True,
                'multi_host': False}

            info = {
                'gateway': v4_subnet['gateway'],
                'dhcp_server': v4_subnet['gateway'],
                'broadcast': v4_subnet['broadcast'],
                'mac': vif['address'],
                'vif_uuid': vif['uuid'],
                'dns': [],
                'ips': [ip_dict(ip, v4_subnet) for ip in v4_ips]}

            if v6_subnet:
                if v6_subnet['cidr']:
                    network_dict['cidr_v6'] = v6_subnet['cidr']
                    info['ip6s'] = [ip_dict(ip, v6_subnet) for ip in v6_ips]

                if v6_subnet['gateway']:
                    info['gateway6'] = v6_subnet['gateway']

            dns_dict = {}
            for s in [v4_subnet, v6_subnet]:
                for k in ['dns1', 'dns2']:
                    if s and s[k]:
                        dns_dict[s[k]] = None
            info['dns'] = [d for d in dns_dict.keys()]

            network_info.append((network_dict, info))
        return network_info
 def get_by_instance_uuid(cls, context, instance_uuid, use_slave=False):
     db_vifs = db.virtual_interface_get_by_instance(context, instance_uuid,
             use_slave=use_slave)
     return base.obj_make_list(context, cls(context),
                               objects.VirtualInterface, db_vifs)
Example #41
0
    def get_instance_nw_info(self, context, instance_id, instance_type_id,
                             host):
        """This method is used by compute to fetch all network data
           that should be used when creating the VM.

           The method simply loops through all virtual interfaces
           stored in the nova DB and queries the IPAM lib to get
           the associated IP data.

           The format of returned data is 'defined' by the initial
           set of NetworkManagers found in nova/network/manager.py .
           Ideally this 'interface' will be more formally defined
           in the future.
        """
        network_info = []
        instance = db.instance_get(context, instance_id)
        project_id = instance.project_id

        admin_context = context.elevated()
        vifs = db.virtual_interface_get_by_instance(admin_context, instance_id)
        for vif in vifs:
            q_tenant_id = project_id
            ipam_tenant_id = project_id
            net_id, port_id = self.q_conn.get_port_by_attachment(
                q_tenant_id, vif['uuid'])
            if not net_id:
                q_tenant_id = FLAGS.quantum_default_tenant_id
                ipam_tenant_id = None
                net_id, port_id = self.q_conn.get_port_by_attachment(
                    q_tenant_id, vif['uuid'])
            if not net_id:
                # TODO(bgh): We need to figure out a way to tell if we
                # should actually be raising this exception or not.
                # In the case that a VM spawn failed it may not have
                # attached the vif and raising the exception here
                # prevents deletion of the VM.  In that case we should
                # probably just log, continue, and move on.
                raise Exception(
                    _("No network for for virtual interface %s") % vif['uuid'])
            (v4_subnet, v6_subnet) = self.ipam.get_subnets_by_net_id(
                context, ipam_tenant_id, net_id)
            v4_ips = self.ipam.get_v4_ips_by_interface(
                context, net_id, vif['uuid'], project_id=ipam_tenant_id)
            v6_ips = self.ipam.get_v6_ips_by_interface(
                context, net_id, vif['uuid'], project_id=ipam_tenant_id)

            quantum_net_id = v4_subnet['network_id'] or v6_subnet['network_id']

            def ip_dict(ip, subnet):
                return {"ip": ip, "netmask": subnet["netmask"], "enabled": "1"}

            network_dict = {
                'cidr': v4_subnet['cidr'],
                'injected': True,
                'multi_host': False
            }

            q_tenant_id = project_id or FLAGS.quantum_default_tenant_id
            info = {
                'label': self.q_conn.get_network_name(q_tenant_id, net_id),
                'gateway': v4_subnet['gateway'],
                'dhcp_server': v4_subnet['gateway'],
                'broadcast': v4_subnet['broadcast'],
                'mac': vif['address'],
                'vif_uuid': vif['uuid'],
                'dns': [],
                'ips': [ip_dict(ip, v4_subnet) for ip in v4_ips]
            }

            if v6_subnet:
                if v6_subnet['cidr']:
                    network_dict['cidr_v6'] = v6_subnet['cidr']
                    info['ip6s'] = [ip_dict(ip, v6_subnet) for ip in v6_ips]

                if v6_subnet['gateway']:
                    info['gateway6'] = v6_subnet['gateway']

            dns_dict = {}
            for s in [v4_subnet, v6_subnet]:
                for k in ['dns1', 'dns2']:
                    if s and s[k]:
                        dns_dict[s[k]] = None
            info['dns'] = [d for d in dns_dict.keys()]

            network_info.append((network_dict, info))
        return network_info
 def get_by_instance_uuid(cls, context, instance_uuid, use_slave=False):
     db_vifs = db.virtual_interface_get_by_instance(context,
                                                    instance_uuid,
                                                    use_slave=use_slave)
     return base.obj_make_list(context, cls(context),
                               objects.VirtualInterface, db_vifs)
Example #43
0
 def _db_virtual_interface_get_by_instance(context, instance_uuid,
                                           use_slave=False):
     return db.virtual_interface_get_by_instance(context, instance_uuid)