← Back to branch summary

~ubuntu-branches/ubuntu/raring/nova/raring-proposed

« back to all changes in this revision

Viewing changes to nova/tests/network/test_manager.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, Adam Gandelman, Chuck Short
  • Date: 2012-11-23 09:04:58 UTC
  • mfrom: (1.1.66)
  • Revision ID: package-import@ubuntu.com-20121123090458-91565o7aev1i1h71
Tags: 2013.1~g1-0ubuntu1
https://launchpad.net/bugs/1073289
https://launchpad.net/bugs/1076442
[ Adam Gandelman ]
* debian/control: Ensure novaclient is upgraded with nova,
  require python-keystoneclient >= 1:2.9.0. (LP: #1073289)
* debian/patches/{ubuntu/*, rbd-security.patch}: Dropped, applied
  upstream.
* debian/control: Add python-testtools to Build-Depends.

[ Chuck Short ]
* New upstream version.
* Refreshed debian/patches/avoid_setuptools_git_dependency.patch.
* debian/rules: FTBFS if missing binaries.
* debian/nova-scheudler.install: Add missing rabbit-queues and
  nova-rpc-zmq-receiver.
* Remove nova-volume since it doesnt exist anymore, transition to cinder-*.
* debian/rules: install apport hook in the right place.
* debian/patches/ubuntu-show-tests.patch: Display test failures.
* debian/control: Add depends on genisoimage
* debian/control: Suggest guestmount.
* debian/control: Suggest websockify. (LP: #1076442)
* debian/nova.conf: Disable nova-volume service.
* debian/control: Depend on xen-system-* rather than the hypervisor.
* debian/control, debian/mans/nova-conductor.8, debian/nova-conductor.init,
  debian/nova-conductor.install, debian/nova-conductor.logrotate
  debian/nova-conductor.manpages, debian/nova-conductor.postrm
  debian/nova-conductor.upstart.in: Add nova-conductor service.
* debian/control: Add python-fixtures as a build deps.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/network/test_manager.py
17
17
# under the License.
18
18
import mox
19
19
import shutil
20
 
import sys
21
20
import tempfile
22
21
 
23
22
from nova import context
24
23
from nova import db
 
24
from nova.db.sqlalchemy import models
25
25
from nova import exception
26
26
from nova.network import linux_net
27
27
from nova.network import manager as network_manager
30
30
from nova.openstack.common import rpc
31
31
import nova.policy
32
32
from nova import test
 
33
from nova.tests import fake_ldap
33
34
from nova.tests import fake_network
 
35
from nova.tests import matchers
34
36
from nova import utils
35
37
 
36
38
 
60
62
             'vlan': None,
61
63
             'host': HOST,
62
64
             'project_id': 'fake_project',
63
 
             'vpn_public_address': '192.168.0.2'},
 
65
             'vpn_public_address': '192.168.0.2',
 
66
             'vpn_public_port': '22',
 
67
             'vpn_private_address': '10.0.0.2'},
64
68
            {'id': 1,
65
69
             'uuid': 'bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb',
66
70
             'label': 'test1',
80
84
             'vlan': None,
81
85
             'host': HOST,
82
86
             'project_id': 'fake_project',
83
 
             'vpn_public_address': '192.168.1.2'}]
 
87
             'vpn_public_address': '192.168.1.2',
 
88
             'vpn_public_port': '22',
 
89
             'vpn_private_address': '10.0.0.2'}]
84
90
 
85
91
fixed_ips = [{'id': 0,
86
92
              'network_id': FAKEUUID,
133
139
        self.tempdir = tempfile.mkdtemp()
134
140
        self.flags(logdir=self.tempdir)
135
141
        self.network = network_manager.FlatManager(host=HOST)
136
 
        temp = importutils.import_object('nova.network.minidns.MiniDNS')
137
 
        self.network.instance_dns_manager = temp
 
142
        self.network.instance_dns_manager = importutils.import_object(
 
143
                'nova.network.minidns.MiniDNS')
138
144
        self.network.instance_dns_domain = ''
139
145
        self.network.db = db
140
146
        self.context = context.RequestContext('testuser', 'testproject',
163
169
                     'bridge_interface': None,
164
170
                     'vlan': None}
165
171
 
166
 
            self.assertDictMatch(nw, check)
 
172
            self.assertThat(nw, matchers.DictMatches(check))
167
173
 
168
174
            check = {'broadcast': '192.168.%d.255' % nid,
169
175
                     'dhcp_server': '192.168.1.1',
179
185
                        '00000000-0000-0000-0000-00000000000000%02d' % nid,
180
186
                     'should_create_vlan': False,
181
187
                     'should_create_bridge': False}
182
 
            self.assertDictMatch(info, check)
 
188
            self.assertThat(info, matchers.DictMatches(check))
183
189
 
184
190
            check = [{'enabled': 'DONTCARE',
185
191
                      'ip': '2001:db8:0:1::%x' % nid,
186
192
                      'netmask': 64,
187
193
                      'gateway': 'fe80::def'}]
188
 
            self.assertDictListMatch(info['ip6s'], check)
 
194
            self.assertThat(info['ip6s'], matchers.DictListMatches(check))
189
195
 
190
196
            num_fixed_ips = len(info['ips'])
191
197
            check = [{'enabled': 'DONTCARE',
193
199
                      'netmask': '255.255.255.0',
194
200
                      'gateway': '192.168.%d.1' % nid}
195
201
                      for ip_num in xrange(1, num_fixed_ips + 1)]
196
 
            self.assertDictListMatch(info['ips'], check)
 
202
            self.assertThat(info['ips'], matchers.DictListMatches(check))
197
203
 
198
204
    def test_validate_networks(self):
199
205
        self.mox.StubOutWithMock(db, 'network_get')
427
433
                              'virtual_interface_get_by_instance_and_network')
428
434
 
429
435
        db.instance_get(mox.IgnoreArg(),
430
 
                        mox.IgnoreArg()).AndReturn({'uuid': '42'})
 
436
                        mox.IgnoreArg()).AndReturn({'uuid': '42',
 
437
                                                    'display_name': HOST})
431
438
        db.fixed_ip_associate(mox.IgnoreArg(),
432
439
                              mox.IgnoreArg(),
433
440
                              mox.IgnoreArg(),
442
449
 
443
450
        network = dict(networks[0])
444
451
        network['vpn_private_address'] = '192.168.0.2'
445
 
        self.network.allocate_fixed_ip(None, 0, network, vpn=True)
 
452
        self.network.allocate_fixed_ip(self.context, 0, network, vpn=True)
446
453
 
447
454
    def test_vpn_allocate_fixed_ip_no_network_id(self):
448
455
        network = dict(networks[0])
466
473
        self.mox.StubOutWithMock(db, 'instance_get')
467
474
 
468
475
        db.instance_get(mox.IgnoreArg(),
469
 
                        mox.IgnoreArg()).AndReturn({'uuid': FAKEUUID})
 
476
                    mox.IgnoreArg()).AndReturn({'display_name': HOST,
 
477
                                                'uuid': FAKEUUID})
470
478
        db.instance_get(mox.IgnoreArg(),
471
479
                        mox.IgnoreArg()).AndReturn({'security_groups':
472
480
                                                             [{'id': 0}]})
826
834
        def fake7(*args, **kwargs):
827
835
            self.local = True
828
836
 
 
837
        def fake8(*args, **kwargs):
 
838
            return {'address': '10.0.0.1',
 
839
                    'pool': 'nova',
 
840
                    'interface': 'eth0',
 
841
                    'fixed_ip_id': 1,
 
842
                    'auto_assigned': True,
 
843
                    'project_id': ctxt.project_id}
 
844
 
829
845
        self.stubs.Set(self.network, '_floating_ip_owned_by_project', fake1)
830
846
 
831
847
        # raises because floating_ip is not associated to a fixed_ip
853
869
        self.network.disassociate_floating_ip(ctxt, mox.IgnoreArg())
854
870
        self.assertTrue(self.local)
855
871
 
 
872
        # raises because auto_assigned floating IP cannot be disassociated
 
873
        self.stubs.Set(self.network.db, 'floating_ip_get_by_address', fake8)
 
874
        self.assertRaises(exception.CannotDisassociateAutoAssignedFloatingIP,
 
875
                          self.network.disassociate_floating_ip,
 
876
                          ctxt,
 
877
                          mox.IgnoreArg())
 
878
 
856
879
    def test_add_fixed_ip_instance_without_vpn_requested_networks(self):
857
880
        self.mox.StubOutWithMock(db, 'network_get')
858
881
        self.mox.StubOutWithMock(db, 'fixed_ip_associate_pool')
862
885
        self.mox.StubOutWithMock(db, 'fixed_ip_update')
863
886
 
864
887
        db.instance_get(mox.IgnoreArg(),
865
 
                        mox.IgnoreArg()).AndReturn({'uuid': FAKEUUID})
 
888
                        mox.IgnoreArg()).AndReturn({'uuid': FAKEUUID,
 
889
                                                    'display_name': HOST})
866
890
        db.fixed_ip_update(mox.IgnoreArg(),
867
891
                           mox.IgnoreArg(),
868
892
                           mox.IgnoreArg())
1500
1524
        self.assertEqual(rval, address)
1501
1525
 
1502
1526
 
 
1527
class BackdoorPortTestCase(test.TestCase):
 
1528
    """Tests nova.network.manager.get_backdoor_port"""
 
1529
    def setUp(self):
 
1530
        super(BackdoorPortTestCase, self).setUp()
 
1531
        self.manager = network_manager.NetworkManager()
 
1532
        self.manager.backdoor_port = 59697
 
1533
        self.context = context.RequestContext('fake', 'fake')
 
1534
 
 
1535
    def test_backdoor_port(self):
 
1536
        port = self.manager.get_backdoor_port(self.context)
 
1537
        self.assertEqual(port, self.manager.backdoor_port)
 
1538
 
 
1539
 
1503
1540
class TestFloatingIPManager(network_manager.FloatingIP,
1504
1541
        network_manager.NetworkManager):
1505
1542
    """Dummy manager that implements FloatingIP"""
1549
1586
        self.tempdir = tempfile.mkdtemp()
1550
1587
        self.flags(logdir=self.tempdir)
1551
1588
        self.network = TestFloatingIPManager()
1552
 
        temp = importutils.import_object('nova.network.minidns.MiniDNS')
1553
 
        self.network.floating_dns_manager = temp
 
1589
        self.network.floating_dns_manager = importutils.import_object(
 
1590
                'nova.network.minidns.MiniDNS')
1554
1591
        self.network.db = db
1555
1592
        self.project_id = 'testproject'
1556
1593
        self.context = context.RequestContext('testuser', self.project_id,
1612
1649
        self.network.deallocate_for_instance(self.context,
1613
1650
                instance_id=instance['id'])
1614
1651
 
 
1652
    def test_migrate_instance_start(self):
 
1653
        called = {'count': 0}
 
1654
 
 
1655
        def fake_floating_ip_get_by_address(context, address):
 
1656
            return {'address': address,
 
1657
                    'fixed_ip_id': 0}
 
1658
 
 
1659
        def fake_is_stale_floating_ip_address(context, floating_ip):
 
1660
            return floating_ip['address'] == '172.24.4.23'
 
1661
 
 
1662
        def fake_fixed_ip_get(context, fixed_ip_id):
 
1663
            return {'instance_uuid': 'fake_uuid',
 
1664
                    'address': '10.0.0.2'}
 
1665
 
 
1666
        def fake_remove_floating_ip(floating_addr, fixed_addr, interface):
 
1667
            called['count'] += 1
 
1668
 
 
1669
        def fake_floating_ip_update(context, address, args):
 
1670
            pass
 
1671
 
 
1672
        self.stubs.Set(self.network.db, 'floating_ip_get_by_address',
 
1673
                       fake_floating_ip_get_by_address)
 
1674
        self.stubs.Set(self.network, '_is_stale_floating_ip_address',
 
1675
                                 fake_is_stale_floating_ip_address)
 
1676
        self.stubs.Set(self.network.db, 'fixed_ip_get', fake_fixed_ip_get)
 
1677
        self.stubs.Set(self.network.db, 'floating_ip_update',
 
1678
                       fake_floating_ip_update)
 
1679
        self.stubs.Set(self.network.l3driver, 'remove_floating_ip',
 
1680
                       fake_remove_floating_ip)
 
1681
        self.mox.ReplayAll()
 
1682
        addresses = ['172.24.4.23', '172.24.4.24', '172.24.4.25']
 
1683
        self.network.migrate_instance_start(self.context,
 
1684
                                            instance_uuid=FAKEUUID,
 
1685
                                            floating_addresses=addresses,
 
1686
                                            rxtx_factor=3,
 
1687
                                            project_id=self.project_id,
 
1688
                                            source='fake_source',
 
1689
                                            dest='fake_dest')
 
1690
 
 
1691
        self.assertEqual(called['count'], 2)
 
1692
 
 
1693
    def test_migrate_instance_finish(self):
 
1694
        called = {'count': 0}
 
1695
 
 
1696
        def fake_floating_ip_get_by_address(context, address):
 
1697
            return {'address': address,
 
1698
                    'fixed_ip_id': 0}
 
1699
 
 
1700
        def fake_is_stale_floating_ip_address(context, floating_ip):
 
1701
            return floating_ip['address'] == '172.24.4.23'
 
1702
 
 
1703
        def fake_fixed_ip_get(context, fixed_ip_id):
 
1704
            return {'instance_uuid': 'fake_uuid',
 
1705
                    'address': '10.0.0.2'}
 
1706
 
 
1707
        def fake_add_floating_ip(floating_addr, fixed_addr, interface):
 
1708
            called['count'] += 1
 
1709
 
 
1710
        def fake_floating_ip_update(context, address, args):
 
1711
            pass
 
1712
 
 
1713
        self.stubs.Set(self.network.db, 'floating_ip_get_by_address',
 
1714
                       fake_floating_ip_get_by_address)
 
1715
        self.stubs.Set(self.network, '_is_stale_floating_ip_address',
 
1716
                                 fake_is_stale_floating_ip_address)
 
1717
        self.stubs.Set(self.network.db, 'fixed_ip_get', fake_fixed_ip_get)
 
1718
        self.stubs.Set(self.network.db, 'floating_ip_update',
 
1719
                       fake_floating_ip_update)
 
1720
        self.stubs.Set(self.network.l3driver, 'add_floating_ip',
 
1721
                       fake_add_floating_ip)
 
1722
        self.mox.ReplayAll()
 
1723
        addresses = ['172.24.4.23', '172.24.4.24', '172.24.4.25']
 
1724
        self.network.migrate_instance_finish(self.context,
 
1725
                                             instance_uuid=FAKEUUID,
 
1726
                                             floating_addresses=addresses,
 
1727
                                             host='fake_dest',
 
1728
                                             rxtx_factor=3,
 
1729
                                             project_id=self.project_id,
 
1730
                                             source='fake_source')
 
1731
 
 
1732
        self.assertEqual(called['count'], 2)
 
1733
 
1615
1734
    def test_floating_dns_create_conflict(self):
1616
1735
        zone = "example.org"
1617
1736
        address1 = "10.10.10.11"
1752
1871
        self.network.delete_dns_domain(context_admin, domain1)
1753
1872
        self.network.delete_dns_domain(context_admin, domain2)
1754
1873
 
 
1874
    def test_mac_conflicts(self):
 
1875
        """Make sure MAC collisions are retried"""
 
1876
        self.flags(create_unique_mac_address_attempts=3)
 
1877
        ctxt = context.RequestContext('testuser', 'testproject', is_admin=True)
 
1878
        macs = ['bb:bb:bb:bb:bb:bb', 'aa:aa:aa:aa:aa:aa']
 
1879
 
 
1880
        # Create a VIF with aa:aa:aa:aa:aa:aa
 
1881
        crash_test_dummy_vif = {
 
1882
            'address': macs[1],
 
1883
            'instance_uuid': 'fake_uuid',
 
1884
            'network_id': 'fake_net',
 
1885
            'uuid': 'fake_uuid',
 
1886
            }
 
1887
        self.network.db.virtual_interface_create(ctxt, crash_test_dummy_vif)
 
1888
 
 
1889
        # Hand out a collision first, then a legit MAC
 
1890
        def fake_gen_mac():
 
1891
            return macs.pop()
 
1892
        self.stubs.Set(utils, 'generate_mac_address', fake_gen_mac)
 
1893
 
 
1894
        # SQLite doesn't seem to honor the uniqueness constraint on the
 
1895
        # address column, so fake the collision-avoidance here
 
1896
        def fake_vif_save(vif):
 
1897
            if vif.address == crash_test_dummy_vif['address']:
 
1898
                raise exception.DBError("If you're smart, you'll retry!")
 
1899
        self.stubs.Set(models.VirtualInterface, 'save', fake_vif_save)
 
1900
 
 
1901
        # Attempt to add another and make sure that both MACs are consumed
 
1902
        # by the retry loop
 
1903
        self.network.add_virtual_interface(ctxt, 'fake_uuid', 'fake_net')
 
1904
        self.assertEqual(macs, [])
 
1905
 
1755
1906
 
1756
1907
class NetworkPolicyTestCase(test.TestCase):
1757
1908
    def setUp(self):
1787
1938
        self.tempdir = tempfile.mkdtemp()
1788
1939
        self.flags(logdir=self.tempdir)
1789
1940
        self.network = TestFloatingIPManager()
1790
 
        temp = importutils.import_object('nova.network.minidns.MiniDNS')
1791
 
        self.network.instance_dns_manager = temp
1792
 
        temp = importutils.import_object('nova.network.dns_driver.DNSDriver')
1793
 
        self.network.floating_dns_manager = temp
 
1941
        self.network.instance_dns_manager = importutils.import_object(
 
1942
                'nova.network.minidns.MiniDNS')
 
1943
        self.network.floating_dns_manager = importutils.import_object(
 
1944
                'nova.network.dns_driver.DNSDriver')
1794
1945
        self.network.db = db
1795
1946
        self.project_id = 'testproject'
1796
1947
        self.context = context.RequestContext('testuser', self.project_id,
1832
1983
    def setUp(self):
1833
1984
        super(LdapDNSTestCase, self).setUp()
1834
1985
 
1835
 
        self.saved_ldap = sys.modules.get('ldap')
1836
 
        import nova.auth.fakeldap
1837
 
        sys.modules['ldap'] = nova.auth.fakeldap
 
1986
        self.stub_module('ldap', fake_ldap)
 
1987
        dns_class = 'nova.network.ldapdns.LdapDNS'
 
1988
        self.driver = importutils.import_object(dns_class)
1838
1989
 
1839
 
        temp = importutils.import_object('nova.network.ldapdns.FakeLdapDNS')
1840
 
        self.driver = temp
 
1990
        attrs = {'objectClass': ['domainrelatedobject', 'dnsdomain',
 
1991
                                 'domain', 'dcobject', 'top'],
 
1992
                 'associateddomain': ['root'],
 
1993
                 'dc': ['root']}
 
1994
        self.driver.lobj.add_s("ou=hosts,dc=example,dc=org", attrs.items())
1841
1995
        self.driver.create_domain(domain1)
1842
1996
        self.driver.create_domain(domain2)
1843
1997
 
1844
1998
    def tearDown(self):
1845
1999
        self.driver.delete_domain(domain1)
1846
2000
        self.driver.delete_domain(domain2)
1847
 
        sys.modules['ldap'] = self.saved_ldap
1848
2001
        super(LdapDNSTestCase, self).tearDown()
1849
2002
 
1850
2003
    def test_ldap_dns_domains(self):