← Back to branch summary

~hudson-openstack/nova/trunk

« back to all changes in this revision

Viewing changes to nova/tests/network_unittest.py

  • Committer: Ewan Mellor
  • Date: 2010-08-09 11:10:27 UTC
  • mfrom: (212 trunk)
  • mto: (145.4.1 add-contains)
  • mto: This revision was merged to the branch mainline in revision 221.
  • Revision ID: ewan.mellor@citrix.com-20100809111027-xbdyu44l6nb68bvp
Merged with trunk again.

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/network_unittest.py
24
24
from nova import test
25
25
from nova import utils
26
26
from nova.auth import manager
27
 
from nova.compute import network
28
 
from nova.compute.exception import NoMoreAddresses
 
27
from nova.network import model
 
28
from nova.network import service
 
29
from nova.network import vpn
 
30
from nova.network.exception import NoMoreAddresses
29
31
 
30
32
FLAGS = flags.FLAGS
31
33
 
52
54
            self.projects.append(self.manager.create_project(name,
53
55
                                                             'netuser',
54
56
                                                             name))
55
 
        self.network = network.PublicNetworkController()
 
57
        self.network = model.PublicNetworkController()
 
58
        self.service = service.VlanNetworkService()
56
59
 
57
60
    def tearDown(self):
58
61
        super(NetworkTestCase, self).tearDown()
66
69
        self.assertTrue(IPy.IP(address) in pubnet)
67
70
        self.assertTrue(IPy.IP(address) in self.network.network)
68
71
 
69
 
    def test_allocate_deallocate_ip(self):
70
 
        address = network.allocate_ip(
71
 
                self.user.id, self.projects[0].id, utils.generate_mac())
 
72
    def test_allocate_deallocate_fixed_ip(self):
 
73
        result  = yield self.service.allocate_fixed_ip(
 
74
                self.user.id, self.projects[0].id)
 
75
        address = result['private_dns_name']
 
76
        mac = result['mac_address']
72
77
        logging.debug("Was allocated %s" % (address))
73
 
        net = network.get_project_network(self.projects[0].id, "default")
 
78
        net = model.get_project_network(self.projects[0].id, "default")
74
79
        self.assertEqual(True, is_in_project(address, self.projects[0].id))
75
 
        mac = utils.generate_mac()
76
80
        hostname = "test-host"
77
81
        self.dnsmasq.issue_ip(mac, address, hostname, net.bridge_name)
78
 
        rv = network.deallocate_ip(address)
 
82
        rv = self.service.deallocate_fixed_ip(address)
79
83
 
80
84
        # Doesn't go away until it's dhcp released
81
85
        self.assertEqual(True, is_in_project(address, self.projects[0].id))
84
88
        self.assertEqual(False, is_in_project(address, self.projects[0].id))
85
89
 
86
90
    def test_range_allocation(self):
87
 
        mac = utils.generate_mac()
88
 
        secondmac = utils.generate_mac()
89
91
        hostname = "test-host"
90
 
        address = network.allocate_ip(
91
 
                    self.user.id, self.projects[0].id, mac)
92
 
        secondaddress = network.allocate_ip(
93
 
                self.user, self.projects[1].id, secondmac)
94
 
        net = network.get_project_network(self.projects[0].id, "default")
95
 
        secondnet = network.get_project_network(self.projects[1].id, "default")
 
92
        result = yield self.service.allocate_fixed_ip(
 
93
                    self.user.id, self.projects[0].id)
 
94
        mac = result['mac_address']
 
95
        address = result['private_dns_name']
 
96
        result = yield self.service.allocate_fixed_ip(
 
97
                self.user, self.projects[1].id)
 
98
        secondmac = result['mac_address']
 
99
        secondaddress = result['private_dns_name']
 
100
 
 
101
        net = model.get_project_network(self.projects[0].id, "default")
 
102
        secondnet = model.get_project_network(self.projects[1].id, "default")
96
103
 
97
104
        self.assertEqual(True, is_in_project(address, self.projects[0].id))
98
105
        self.assertEqual(True, is_in_project(secondaddress, self.projects[1].id))
103
110
        self.dnsmasq.issue_ip(secondmac, secondaddress,
104
111
                                hostname, secondnet.bridge_name)
105
112
 
106
 
        rv = network.deallocate_ip(address)
 
113
        rv = self.service.deallocate_fixed_ip(address)
107
114
        self.dnsmasq.release_ip(mac, address, hostname, net.bridge_name)
108
115
        self.assertEqual(False, is_in_project(address, self.projects[0].id))
109
116
 
110
117
        # First address release shouldn't affect the second
111
118
        self.assertEqual(True, is_in_project(secondaddress, self.projects[1].id))
112
119
 
113
 
        rv = network.deallocate_ip(secondaddress)
 
120
        rv = self.service.deallocate_fixed_ip(secondaddress)
114
121
        self.dnsmasq.release_ip(secondmac, secondaddress,
115
122
                                hostname, secondnet.bridge_name)
116
123
        self.assertEqual(False, is_in_project(secondaddress, self.projects[1].id))
117
124
 
118
125
    def test_subnet_edge(self):
119
 
        secondaddress = network.allocate_ip(self.user.id, self.projects[0].id,
120
 
                                utils.generate_mac())
 
126
        result = yield self.service.allocate_fixed_ip(self.user.id,
 
127
                                                       self.projects[0].id)
 
128
        firstaddress = result['private_dns_name']
121
129
        hostname = "toomany-hosts"
122
130
        for i in range(1,5):
123
131
            project_id = self.projects[i].id
124
 
            mac = utils.generate_mac()
125
 
            mac2 = utils.generate_mac()
126
 
            mac3 = utils.generate_mac()
127
 
            address = network.allocate_ip(
128
 
                    self.user, project_id, mac)
129
 
            address2 = network.allocate_ip(
130
 
                    self.user, project_id, mac2)
131
 
            address3 = network.allocate_ip(
132
 
                    self.user, project_id, mac3)
 
132
            result = yield self.service.allocate_fixed_ip(
 
133
                    self.user, project_id)
 
134
            mac = result['mac_address']
 
135
            address = result['private_dns_name']
 
136
            result = yield self.service.allocate_fixed_ip(
 
137
                    self.user, project_id)
 
138
            mac2 = result['mac_address']
 
139
            address2 = result['private_dns_name']
 
140
            result = yield self.service.allocate_fixed_ip(
 
141
                   self.user, project_id)
 
142
            mac3 = result['mac_address']
 
143
            address3 = result['private_dns_name']
133
144
            self.assertEqual(False, is_in_project(address, self.projects[0].id))
134
145
            self.assertEqual(False, is_in_project(address2, self.projects[0].id))
135
146
            self.assertEqual(False, is_in_project(address3, self.projects[0].id))
136
 
            rv = network.deallocate_ip(address)
137
 
            rv = network.deallocate_ip(address2)
138
 
            rv = network.deallocate_ip(address3)
139
 
            net = network.get_project_network(project_id, "default")
 
147
            rv = self.service.deallocate_fixed_ip(address)
 
148
            rv = self.service.deallocate_fixed_ip(address2)
 
149
            rv = self.service.deallocate_fixed_ip(address3)
 
150
            net = model.get_project_network(project_id, "default")
140
151
            self.dnsmasq.release_ip(mac, address, hostname, net.bridge_name)
141
152
            self.dnsmasq.release_ip(mac2, address2, hostname, net.bridge_name)
142
153
            self.dnsmasq.release_ip(mac3, address3, hostname, net.bridge_name)
143
 
        net = network.get_project_network(self.projects[0].id, "default")
144
 
        rv = network.deallocate_ip(secondaddress)
145
 
        self.dnsmasq.release_ip(mac, secondaddress, hostname, net.bridge_name)
 
154
        net = model.get_project_network(self.projects[0].id, "default")
 
155
        rv = self.service.deallocate_fixed_ip(firstaddress)
 
156
        self.dnsmasq.release_ip(mac, firstaddress, hostname, net.bridge_name)
 
157
 
 
158
    def test_212_vpn_ip_and_port_looks_valid(self):
 
159
        vpn.NetworkData.create(self.projects[0].id)
 
160
        self.assert_(self.projects[0].vpn_ip)
 
161
        self.assert_(self.projects[0].vpn_port >= FLAGS.vpn_start_port)
 
162
        self.assert_(self.projects[0].vpn_port <= FLAGS.vpn_end_port)
 
163
 
 
164
    def test_too_many_vpns(self):
 
165
        vpns = []
 
166
        for i in xrange(vpn.NetworkData.num_ports_for_ip(FLAGS.vpn_ip)):
 
167
            vpns.append(vpn.NetworkData.create("vpnuser%s" % i))
 
168
        self.assertRaises(vpn.NoMorePorts, vpn.NetworkData.create, "boom")
 
169
        for network_datum in vpns:
 
170
            network_datum.destroy()
146
171
 
147
172
    def test_release_before_deallocate(self):
148
173
        pass
169
194
                                               NUM_RESERVED_VPN_IPS)
170
195
        usable addresses
171
196
        """
172
 
        net = network.get_project_network(self.projects[0].id, "default")
 
197
        net = model.get_project_network(self.projects[0].id, "default")
173
198
 
174
199
        # Determine expected number of available IP addresses
175
200
        num_static_ips = net.num_static_ips
183
208
        macs = {}
184
209
        addresses = {}
185
210
        for i in range(0, (num_available_ips - 1)):
186
 
            macs[i] = utils.generate_mac()
187
 
            addresses[i] = network.allocate_ip(self.user.id, self.projects[0].id, macs[i])
 
211
            result = yield self.service.allocate_fixed_ip(self.user.id, self.projects[0].id)
 
212
            macs[i] = result['mac_address']
 
213
            addresses[i] = result['private_dns_name']
188
214
            self.dnsmasq.issue_ip(macs[i], addresses[i], hostname, net.bridge_name)
189
215
 
190
 
        self.assertRaises(NoMoreAddresses, network.allocate_ip, self.user.id, self.projects[0].id, utils.generate_mac())
 
216
        self.assertFailure(self.service.allocate_fixed_ip(self.user.id, self.projects[0].id), NoMoreAddresses)
191
217
 
192
218
        for i in range(0, (num_available_ips - 1)):
193
 
            rv = network.deallocate_ip(addresses[i])
 
219
            rv = self.service.deallocate_fixed_ip(addresses[i])
194
220
            self.dnsmasq.release_ip(macs[i], addresses[i], hostname, net.bridge_name)
195
221
 
196
222
def is_in_project(address, project_id):
197
 
    return address in network.get_project_network(project_id).list_addresses()
 
223
    return address in model.get_project_network(project_id).list_addresses()
198
224
 
199
225
def _get_project_addresses(project_id):
200
226
    project_addresses = []
201
 
    for addr in network.get_project_network(project_id).list_addresses():
 
227
    for addr in model.get_project_network(project_id).list_addresses():
202
228
        project_addresses.append(addr)
203
229
    return project_addresses
204
230