← Back to branch summary

~cerberus/nova/disk_config

« back to all changes in this revision

Viewing changes to nova/tests/integrated/test_servers.py

  • Committer: matt.dietz at rackspace
  • Date: 2011-09-21 19:48:25 UTC
  • mfrom: (1511.1.98 nova)
  • Revision ID: matt.dietz@rackspace.com-20110921194825-zv1w4qonfh6o1j2u
Merge from trunk, updated failing tests and pep8

Show diffs side-by-side

added added

removed removed

Lines of Context:
nova/tests/integrated/test_servers.py
28
28
 
29
29
class ServersTest(integrated_helpers._IntegratedTestBase):
30
30
 
31
 
    def _wait_for_creation(self, server):
32
 
        retries = 0
33
 
        while server['status'] == 'BUILD':
34
 
            time.sleep(1)
 
31
    def _wait_for_state_change(self, server, status):
 
32
        for i in xrange(0, 50):
35
33
            server = self.api.get_server(server['id'])
36
34
            print server
37
 
            retries = retries + 1
38
 
            if retries > 5:
 
35
            if server['status'] != status:
39
36
                break
 
37
            time.sleep(.1)
 
38
 
40
39
        return server
41
40
 
 
41
    def _restart_compute_service(self, periodic_interval=None):
 
42
        """restart compute service. NOTE: fake driver forgets all instances."""
 
43
        self.compute.kill()
 
44
        if periodic_interval:
 
45
            self.compute = self.start_service(
 
46
                'compute', periodic_interval=periodic_interval)
 
47
        else:
 
48
            self.compute = self.start_service('compute')
 
49
 
42
50
    def test_get_servers(self):
43
51
        """Simple check that listing servers works."""
44
52
        servers = self.api.get_servers()
102
110
        server_ids = [server['id'] for server in servers]
103
111
        self.assertTrue(created_server_id in server_ids)
104
112
 
105
 
        found_server = self._wait_for_creation(found_server)
 
113
        found_server = self._wait_for_state_change(found_server, 'BUILD')
106
114
 
107
115
        # It should be available...
108
116
        # TODO(justinsb): Mock doesn't yet do this...
114
122
 
115
123
        self._delete_server(created_server_id)
116
124
 
117
 
    def _delete_server(self, server_id):
118
 
        # Delete the server
119
 
        self.api.delete_server(server_id)
120
 
 
 
125
    def test_deferred_delete(self):
 
126
        """Creates, deletes and waits for server to be reclaimed."""
 
127
        self.flags(stub_network=True, reclaim_instance_interval=1)
 
128
 
 
129
        # enforce periodic tasks run in short time to avoid wait for 60s.
 
130
        self._restart_compute_service(periodic_interval=0.3)
 
131
 
 
132
        # Create server
 
133
        server = self._build_minimal_create_server_request()
 
134
 
 
135
        created_server = self.api.post_server({'server': server})
 
136
        LOG.debug("created_server: %s" % created_server)
 
137
        self.assertTrue(created_server['id'])
 
138
        created_server_id = created_server['id']
 
139
 
 
140
        # Wait for it to finish being created
 
141
        found_server = self._wait_for_state_change(created_server, 'BUILD')
 
142
 
 
143
        # It should be available...
 
144
        self.assertEqual('ACTIVE', found_server['status'])
 
145
 
 
146
        # Cannot restore unless instance is deleted
 
147
        self.api.post_server_action(created_server_id, {'restore': {}})
 
148
 
 
149
        # Check it's still active
 
150
        found_server = self.api.get_server(created_server_id)
 
151
        self.assertEqual('ACTIVE', found_server['status'])
 
152
 
 
153
        # Cannot forceDelete unless instance is deleted
 
154
        self.api.post_server_action(created_server_id, {'forceDelete': {}})
 
155
 
 
156
        # Check it's still active
 
157
        found_server = self.api.get_server(created_server_id)
 
158
        self.assertEqual('ACTIVE', found_server['status'])
 
159
 
 
160
        # Delete the server
 
161
        self.api.delete_server(created_server_id)
 
162
 
 
163
        # Wait for queued deletion
 
164
        found_server = self._wait_for_state_change(found_server, 'ACTIVE')
 
165
        self.assertEqual('DELETED', found_server['status'])
 
166
 
 
167
        # Wait for real deletion
 
168
        self._wait_for_deletion(created_server_id)
 
169
 
 
170
    def test_deferred_delete_restore(self):
 
171
        """Creates, deletes and restores a server."""
 
172
        self.flags(stub_network=True, reclaim_instance_interval=1)
 
173
 
 
174
        # Create server
 
175
        server = self._build_minimal_create_server_request()
 
176
 
 
177
        created_server = self.api.post_server({'server': server})
 
178
        LOG.debug("created_server: %s" % created_server)
 
179
        self.assertTrue(created_server['id'])
 
180
        created_server_id = created_server['id']
 
181
 
 
182
        # Wait for it to finish being created
 
183
        found_server = self._wait_for_state_change(created_server, 'BUILD')
 
184
 
 
185
        # It should be available...
 
186
        self.assertEqual('ACTIVE', found_server['status'])
 
187
 
 
188
        # Delete the server
 
189
        self.api.delete_server(created_server_id)
 
190
 
 
191
        # Wait for queued deletion
 
192
        found_server = self._wait_for_state_change(found_server, 'ACTIVE')
 
193
        self.assertEqual('DELETED', found_server['status'])
 
194
 
 
195
        # Restore server
 
196
        self.api.post_server_action(created_server_id, {'restore': {}})
 
197
 
 
198
        # Wait for server to become active again
 
199
        found_server = self._wait_for_state_change(found_server, 'DELETED')
 
200
        self.assertEqual('ACTIVE', found_server['status'])
 
201
 
 
202
    def test_deferred_delete_force(self):
 
203
        """Creates, deletes and force deletes a server."""
 
204
        self.flags(stub_network=True, reclaim_instance_interval=1)
 
205
 
 
206
        # Create server
 
207
        server = self._build_minimal_create_server_request()
 
208
 
 
209
        created_server = self.api.post_server({'server': server})
 
210
        LOG.debug("created_server: %s" % created_server)
 
211
        self.assertTrue(created_server['id'])
 
212
        created_server_id = created_server['id']
 
213
 
 
214
        # Wait for it to finish being created
 
215
        found_server = self._wait_for_state_change(created_server, 'BUILD')
 
216
 
 
217
        # It should be available...
 
218
        self.assertEqual('ACTIVE', found_server['status'])
 
219
 
 
220
        # Delete the server
 
221
        self.api.delete_server(created_server_id)
 
222
 
 
223
        # Wait for queued deletion
 
224
        found_server = self._wait_for_state_change(found_server, 'ACTIVE')
 
225
        self.assertEqual('DELETED', found_server['status'])
 
226
 
 
227
        # Force delete server
 
228
        self.api.post_server_action(created_server_id, {'forceDelete': {}})
 
229
 
 
230
        # Wait for real deletion
 
231
        self._wait_for_deletion(created_server_id)
 
232
 
 
233
    def _wait_for_deletion(self, server_id):
121
234
        # Wait (briefly) for deletion
122
 
        for _retries in range(5):
 
235
        for _retries in range(50):
123
236
            try:
124
237
                found_server = self.api.get_server(server_id)
125
238
            except client.OpenStackApiNotFoundException:
132
245
            # TODO(justinsb): Mock doesn't yet do accurate state changes
133
246
            #if found_server['status'] != 'deleting':
134
247
            #    break
135
 
            time.sleep(1)
 
248
            time.sleep(.1)
136
249
 
137
250
        # Should be gone
138
251
        self.assertFalse(found_server)
139
252
 
 
253
    def _delete_server(self, server_id):
 
254
        # Delete the server
 
255
        self.api.delete_server(server_id)
 
256
        self._wait_for_deletion(server_id)
 
257
 
140
258
    def test_create_server_with_metadata(self):
141
259
        """Creates a server with metadata."""
142
260
 
194
312
        self.assertTrue(created_server['id'])
195
313
        created_server_id = created_server['id']
196
314
 
197
 
        created_server = self._wait_for_creation(created_server)
 
315
        created_server = self._wait_for_state_change(created_server, 'BUILD')
198
316
 
199
317
        # rebuild the server with metadata
200
318
        post = {}
228
346
        self.assertTrue(created_server['id'])
229
347
        created_server_id = created_server['id']
230
348
 
231
 
        created_server = self._wait_for_creation(created_server)
 
349
        created_server = self._wait_for_state_change(created_server, 'BUILD')
232
350
 
233
351
        # rebuild the server with metadata
234
352
        post = {}
274
392
        self.assertTrue(created_server['id'])
275
393
        created_server_id = created_server['id']
276
394
 
277
 
        created_server = self._wait_for_creation(created_server)
 
395
        created_server = self._wait_for_state_change(created_server, 'BUILD')
278
396
 
279
397
        # rebuild the server with metadata
280
398
        post = {}