1
=== modified file 'bin/nova-api'
2
--- bin/nova-api	2010-12-11 20:10:24 +0000
3
+++ bin/nova-api	2010-12-16 20:49:10 +0000
4
@@ -17,9 +17,8 @@
5
17
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6
18
#    See the License for the specific language governing permissions and
18
#    See the License for the specific language governing permissions and
7
19
#    limitations under the License.
19
#    limitations under the License.
11
20
"""
20
12
21
Nova API daemon.
21
"""Starter script for Nova API."""
10
22
"""
13
23
22
14
24
import gettext
23
import gettext
15
25
import os
24
import os
16
@@ -35,9 +34,11 @@
17
35
34
18
36
gettext.install('nova', unicode=1)
35
gettext.install('nova', unicode=1)
19
37
36
20
37
from nova import api
21
38
from nova import flags
38
from nova import flags
22
39
from nova import utils
39
from nova import utils
24
40
from nova import server
40
from nova import wsgi
25
41
26
41
42
27
42
FLAGS = flags.FLAGS
43
FLAGS = flags.FLAGS
28
43
flags.DEFINE_integer('osapi_port', 8774, 'OpenStack API port')
44
flags.DEFINE_integer('osapi_port', 8774, 'OpenStack API port')
29
@@ -46,15 +47,10 @@
30
46
flags.DEFINE_string('ec2api_host', '0.0.0.0', 'EC2 API host')
47
flags.DEFINE_string('ec2api_host', '0.0.0.0', 'EC2 API host')
31
47
48
32
48
49
36
49
def main(_args):
50
if __name__ == '__main__':
37
50
    from nova import api
51
    utils.default_flagfile()
38
51
    from nova import wsgi
52
    FLAGS(sys.argv)
39
52
    server = wsgi.Server()
53
    server = wsgi.Server()
40
53
    server.start(api.API('os'), FLAGS.osapi_port, host=FLAGS.osapi_host)
54
    server.start(api.API('os'), FLAGS.osapi_port, host=FLAGS.osapi_host)
41
54
    server.start(api.API('ec2'), FLAGS.ec2api_port, host=FLAGS.ec2api_host)
55
    server.start(api.API('ec2'), FLAGS.ec2api_port, host=FLAGS.ec2api_host)
42
55
    server.wait()
56
    server.wait()
43
56
44
57
45
58
if __name__ == '__main__':
46
59
    utils.default_flagfile()
47
60
    server.serve('nova-api', main)
48
61
57
49
=== added file 'bin/nova-combined'
50
--- bin/nova-combined	1970-01-01 00:00:00 +0000
51
+++ bin/nova-combined	2010-12-16 20:49:10 +0000
52
@@ -0,0 +1,65 @@
53
1
#!/usr/bin/env python
54
2
# vim: tabstop=4 shiftwidth=4 softtabstop=4
55
3
56
4
# Copyright 2010 United States Government as represented by the
57
5
# Administrator of the National Aeronautics and Space Administration.
58
6
# All Rights Reserved.
59
7
#
60
8
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
61
9
#    not use this file except in compliance with the License. You may obtain
62
10
#    a copy of the License at
63
11
#
64
12
#         http://www.apache.org/licenses/LICENSE-2.0
65
13
#
66
14
#    Unless required by applicable law or agreed to in writing, software
67
15
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
68
16
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
69
17
#    License for the specific language governing permissions and limitations
70
18
#    under the License.
71
19
72
20
"""Combined starter script for Nova services."""
73
21
74
22
import eventlet
75
23
eventlet.monkey_patch()
76
24
77
25
import os
78
26
import sys
79
27
80
28
# If ../nova/__init__.py exists, add ../ to Python search path, so that
81
29
# it will override what happens to be installed in /usr/(local/)lib/python...
82
30
possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
83
31
                                   os.pardir,
84
32
                                   os.pardir))
85
33
if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
86
34
    sys.path.insert(0, possible_topdir)
87
35
88
36
from nova import api
89
37
from nova import flags
90
38
from nova import service
91
39
from nova import utils
92
40
from nova import wsgi
93
41
94
42
95
43
FLAGS = flags.FLAGS
96
44
flags.DEFINE_integer('osapi_port', 8774, 'OpenStack API port')
97
45
flags.DEFINE_string('osapi_host', '0.0.0.0', 'OpenStack API host')
98
46
flags.DEFINE_integer('ec2api_port', 8773, 'EC2 API port')
99
47
flags.DEFINE_string('ec2api_host', '0.0.0.0', 'EC2 API host')
100
48
101
49
102
50
if __name__ == '__main__':
103
51
    utils.default_flagfile()
104
52
    FLAGS(sys.argv)
105
53
106
54
    compute = service.Service.create(binary='nova-compute')
107
55
    network = service.Service.create(binary='nova-network')
108
56
    volume = service.Service.create(binary='nova-volume')
109
57
    scheduler = service.Service.create(binary='nova-scheduler')
110
58
    #objectstore = service.Service.create(binary='nova-objectstore')
111
59
112
60
    service.serve(compute, network, volume, scheduler)
113
61
114
62
    server = wsgi.Server()
115
63
    server.start(api.API('os'), FLAGS.osapi_port, host=FLAGS.osapi_host)
116
64
    server.start(api.API('ec2'), FLAGS.ec2api_port, host=FLAGS.ec2api_host)
117
65
    server.wait()
118
0
66
119
=== modified file 'bin/nova-compute'
120
--- bin/nova-compute	2010-12-11 20:10:24 +0000
121
+++ bin/nova-compute	2010-12-16 20:49:10 +0000
122
@@ -17,9 +17,10 @@
123
17
#    License for the specific language governing permissions and limitations
17
#    License for the specific language governing permissions and limitations
124
18
#    under the License.
18
#    under the License.
125
19
19
129
20
"""
20
"""Starter script for Nova Compute."""
130
21
  Twistd daemon for the nova compute nodes.
21
131
22
"""
22
import eventlet
132
23
eventlet.monkey_patch()
133
23
24
134
24
import gettext
25
import gettext
135
25
import os
26
import os
136
@@ -36,13 +37,9 @@
137
36
gettext.install('nova', unicode=1)
37
gettext.install('nova', unicode=1)
138
37
38
139
38
from nova import service
39
from nova import service
140
39
from nova import twistd
141
40
from nova import utils
40
from nova import utils
142
41
41
143
42
144
43
if __name__ == '__main__':
42
if __name__ == '__main__':
145
44
    utils.default_flagfile()
43
    utils.default_flagfile()
150
45
    twistd.serve(__file__)
44
    service.serve()
151
46
45
    service.wait()
148
47
if __name__ == '__builtin__':
149
48
    application = service.Service.create()  # pylint: disable=C0103
152
49
46
153
=== modified file 'bin/nova-network'
154
--- bin/nova-network	2010-12-14 23:22:03 +0000
155
+++ bin/nova-network	2010-12-16 20:49:10 +0000
156
@@ -17,9 +17,10 @@
157
17
#    License for the specific language governing permissions and limitations
17
#    License for the specific language governing permissions and limitations
158
18
#    under the License.
18
#    under the License.
159
19
19
163
20
"""
20
"""Starter script for Nova Network."""
164
21
  Twistd daemon for the nova network nodes.
21
165
22
"""
22
import eventlet
166
23
eventlet.monkey_patch()
167
23
24
168
24
import gettext
25
import gettext
169
25
import os
26
import os
170
@@ -36,13 +37,9 @@
171
36
gettext.install('nova', unicode=1)
37
gettext.install('nova', unicode=1)
172
37
38
173
38
from nova import service
39
from nova import service
174
39
from nova import twistd
175
40
from nova import utils
40
from nova import utils
176
41
41
177
42
178
43
if __name__ == '__main__':
42
if __name__ == '__main__':
179
44
    utils.default_flagfile()
43
    utils.default_flagfile()
184
45
    twistd.serve(__file__)
44
    service.serve()
185
46
45
    service.wait()
182
47
if __name__ == '__builtin__':
183
48
    application = service.Service.create()  # pylint: disable-msg=C0103
186
49
46
187
=== modified file 'bin/nova-scheduler'
188
--- bin/nova-scheduler	2010-12-14 23:22:03 +0000
189
+++ bin/nova-scheduler	2010-12-16 20:49:10 +0000
190
@@ -17,9 +17,10 @@
191
17
#    License for the specific language governing permissions and limitations
17
#    License for the specific language governing permissions and limitations
192
18
#    under the License.
18
#    under the License.
193
19
19
197
20
"""
20
"""Starter script for Nova Scheduler."""
198
21
  Twistd daemon for the nova scheduler nodes.
21
199
22
"""
22
import eventlet
200
23
eventlet.monkey_patch()
201
23
24
202
24
import gettext
25
import gettext
203
25
import os
26
import os
204
@@ -36,13 +37,9 @@
205
36
gettext.install('nova', unicode=1)
37
gettext.install('nova', unicode=1)
206
37
38
207
38
from nova import service
39
from nova import service
208
39
from nova import twistd
209
40
from nova import utils
40
from nova import utils
210
41
41
211
42
212
43
if __name__ == '__main__':
42
if __name__ == '__main__':
213
44
    utils.default_flagfile()
43
    utils.default_flagfile()
218
45
    twistd.serve(__file__)
44
    service.serve()
219
46
45
    service.wait()
216
47
if __name__ == '__builtin__':
217
48
    application = service.Service.create()
220
49
46
221
=== modified file 'bin/nova-volume'
222
--- bin/nova-volume	2010-12-14 23:22:03 +0000
223
+++ bin/nova-volume	2010-12-16 20:49:10 +0000
224
@@ -17,9 +17,10 @@
225
17
#    License for the specific language governing permissions and limitations
17
#    License for the specific language governing permissions and limitations
226
18
#    under the License.
18
#    under the License.
227
19
19
231
20
"""
20
"""Starter script for Nova Volume."""
232
21
  Twistd daemon for the nova volume nodes.
21
233
22
"""
22
import eventlet
234
23
eventlet.monkey_patch()
235
23
24
236
24
import gettext
25
import gettext
237
25
import os
26
import os
238
@@ -36,13 +37,9 @@
239
36
gettext.install('nova', unicode=1)
37
gettext.install('nova', unicode=1)
240
37
38
241
38
from nova import service
39
from nova import service
242
39
from nova import twistd
243
40
from nova import utils
40
from nova import utils
244
41
41
245
42
246
43
if __name__ == '__main__':
42
if __name__ == '__main__':
247
44
    utils.default_flagfile()
43
    utils.default_flagfile()
252
45
    twistd.serve(__file__)
44
    service.serve()
253
46
45
    service.wait()
250
47
if __name__ == '__builtin__':
251
48
    application = service.Service.create()  # pylint: disable-msg=C0103
254
49
46
255
=== modified file 'nova/compute/disk.py'
256
--- nova/compute/disk.py	2010-11-16 18:49:18 +0000
257
+++ nova/compute/disk.py	2010-12-16 20:49:10 +0000
258
@@ -26,8 +26,6 @@
259
26
import os
26
import os
260
27
import tempfile
27
import tempfile
261
28
28
262
29
from twisted.internet import defer
263
30
264
31
from nova import exception
29
from nova import exception
265
32
from nova import flags
30
from nova import flags
266
33
31
267
@@ -39,7 +37,6 @@
268
39
                     'block_size to use for dd')
37
                     'block_size to use for dd')
269
40
38
270
41
39
271
42
@defer.inlineCallbacks
272
43
def partition(infile, outfile, local_bytes=0, resize=True,
40
def partition(infile, outfile, local_bytes=0, resize=True,
273
44
              local_type='ext2', execute=None):
41
              local_type='ext2', execute=None):
274
45
    """
42
    """
275
@@ -64,10 +61,10 @@
276
64
    file_size = os.path.getsize(infile)
61
    file_size = os.path.getsize(infile)
277
65
    if resize and file_size < FLAGS.minimum_root_size:
62
    if resize and file_size < FLAGS.minimum_root_size:
278
66
        last_sector = FLAGS.minimum_root_size / sector_size - 1
63
        last_sector = FLAGS.minimum_root_size / sector_size - 1
283
67
        yield execute('dd if=/dev/zero of=%s count=1 seek=%d bs=%d'
64
        execute('dd if=/dev/zero of=%s count=1 seek=%d bs=%d'
284
68
                      % (infile, last_sector, sector_size))
65
                % (infile, last_sector, sector_size))
285
69
        yield execute('e2fsck -fp %s' % infile, check_exit_code=False)
66
        execute('e2fsck -fp %s' % infile, check_exit_code=False)
286
70
        yield execute('resize2fs %s' % infile)
67
        execute('resize2fs %s' % infile)
287
71
        file_size = FLAGS.minimum_root_size
68
        file_size = FLAGS.minimum_root_size
288
72
    elif file_size % sector_size != 0:
69
    elif file_size % sector_size != 0:
289
73
        logging.warn("Input partition size not evenly divisible by"
70
        logging.warn("Input partition size not evenly divisible by"
290
@@ -86,30 +83,29 @@
291
86
    last_sector = local_last  # e
83
    last_sector = local_last  # e
292
87
84
293
88
    # create an empty file
85
    # create an empty file
296
89
    yield execute('dd if=/dev/zero of=%s count=1 seek=%d bs=%d'
86
    execute('dd if=/dev/zero of=%s count=1 seek=%d bs=%d'
297
90
                  % (outfile, mbr_last, sector_size))
87
            % (outfile, mbr_last, sector_size))
298
91
88
299
92
    # make mbr partition
89
    # make mbr partition
301
93
    yield execute('parted --script %s mklabel msdos' % outfile)
90
    execute('parted --script %s mklabel msdos' % outfile)
302
94
91
303
95
    # append primary file
92
    # append primary file
306
96
    yield execute('dd if=%s of=%s bs=%s conv=notrunc,fsync oflag=append'
93
    execute('dd if=%s of=%s bs=%s conv=notrunc,fsync oflag=append'
307
97
                  % (infile, outfile, FLAGS.block_size))
94
            % (infile, outfile, FLAGS.block_size))
308
98
95
309
99
    # make primary partition
96
    # make primary partition
312
100
    yield execute('parted --script %s mkpart primary %ds %ds'
97
    execute('parted --script %s mkpart primary %ds %ds'
313
101
                  % (outfile, primary_first, primary_last))
98
            % (outfile, primary_first, primary_last))
314
102
99
315
103
    if local_bytes > 0:
100
    if local_bytes > 0:
316
104
        # make the file bigger
101
        # make the file bigger
319
105
        yield execute('dd if=/dev/zero of=%s count=1 seek=%d bs=%d'
102
        execute('dd if=/dev/zero of=%s count=1 seek=%d bs=%d'
320
106
                      % (outfile, last_sector, sector_size))
103
                % (outfile, last_sector, sector_size))
321
107
        # make and format local partition
104
        # make and format local partition
327
108
        yield execute('parted --script %s mkpartfs primary %s %ds %ds'
105
        execute('parted --script %s mkpartfs primary %s %ds %ds'
328
109
                      % (outfile, local_type, local_first, local_last))
106
                % (outfile, local_type, local_first, local_last))
329
110
107
330
111
108
326
112
@defer.inlineCallbacks
331
113
def inject_data(image, key=None, net=None, partition=None, execute=None):
109
def inject_data(image, key=None, net=None, partition=None, execute=None):
332
114
    """Injects a ssh key and optionally net data into a disk image.
110
    """Injects a ssh key and optionally net data into a disk image.
333
115
111
334
@@ -119,26 +115,26 @@
335
119
    If partition is not specified it mounts the image as a single partition.
115
    If partition is not specified it mounts the image as a single partition.
336
120
116
337
121
    """
117
    """
339
122
    out, err = yield execute('sudo losetup -f --show %s' % image)
118
    out, err = execute('sudo losetup -f --show %s' % image)
340
123
    if err:
119
    if err:
341
124
        raise exception.Error('Could not attach image to loopback: %s' % err)
120
        raise exception.Error('Could not attach image to loopback: %s' % err)
342
125
    device = out.strip()
121
    device = out.strip()
343
126
    try:
122
    try:
344
127
        if not partition is None:
123
        if not partition is None:
345
128
            # create partition
124
            # create partition
347
129
            out, err = yield execute('sudo kpartx -a %s' % device)
125
            out, err = execute('sudo kpartx -a %s' % device)
348
130
            if err:
126
            if err:
349
131
                raise exception.Error('Failed to load partition: %s' % err)
127
                raise exception.Error('Failed to load partition: %s' % err)
350
132
            mapped_device = '/dev/mapper/%sp%s' % (device.split('/')[-1],
128
            mapped_device = '/dev/mapper/%sp%s' % (device.split('/')[-1],
351
133
                                                   partition)
129
                                                   partition)
352
134
        else:
130
        else:
353
135
            mapped_device = device
131
            mapped_device = device
355
136
        out, err = yield execute('sudo tune2fs -c 0 -i 0 %s' % mapped_device)
132
        out, err = execute('sudo tune2fs -c 0 -i 0 %s' % mapped_device)
356
137
133
357
138
        tmpdir = tempfile.mkdtemp()
134
        tmpdir = tempfile.mkdtemp()
358
139
        try:
135
        try:
359
140
            # mount loopback to dir
136
            # mount loopback to dir
361
141
            out, err = yield execute(
137
            out, err = execute(
362
142
                    'sudo mount %s %s' % (mapped_device, tmpdir))
138
                    'sudo mount %s %s' % (mapped_device, tmpdir))
363
143
            if err:
139
            if err:
364
144
                raise exception.Error('Failed to mount filesystem: %s' % err)
140
                raise exception.Error('Failed to mount filesystem: %s' % err)
365
@@ -146,24 +142,23 @@
366
146
            try:
142
            try:
367
147
                if key:
143
                if key:
368
148
                    # inject key file
144
                    # inject key file
370
149
                    yield _inject_key_into_fs(key, tmpdir, execute=execute)
145
                    _inject_key_into_fs(key, tmpdir, execute=execute)
371
150
                if net:
146
                if net:
373
151
                    yield _inject_net_into_fs(net, tmpdir, execute=execute)
147
                    _inject_net_into_fs(net, tmpdir, execute=execute)
374
152
            finally:
148
            finally:
375
153
                # unmount device
149
                # unmount device
377
154
                yield execute('sudo umount %s' % mapped_device)
150
                execute('sudo umount %s' % mapped_device)
378
155
        finally:
151
        finally:
379
156
            # remove temporary directory
152
            # remove temporary directory
381
157
            yield execute('rmdir %s' % tmpdir)
153
            execute('rmdir %s' % tmpdir)
382
158
            if not partition is None:
154
            if not partition is None:
383
159
                # remove partitions
155
                # remove partitions
385
160
                yield execute('sudo kpartx -d %s' % device)
156
                execute('sudo kpartx -d %s' % device)
386
161
    finally:
157
    finally:
387
162
        # remove loopback
158
        # remove loopback
392
163
        yield execute('sudo losetup -d %s' % device)
159
        execute('sudo losetup -d %s' % device)
393
164
160
394
165
161
391
166
@defer.inlineCallbacks
395
167
def _inject_key_into_fs(key, fs, execute=None):
162
def _inject_key_into_fs(key, fs, execute=None):
396
168
    """Add the given public ssh key to root's authorized_keys.
163
    """Add the given public ssh key to root's authorized_keys.
397
169
164
398
@@ -171,22 +166,21 @@
399
171
    fs is the path to the base of the filesystem into which to inject the key.
166
    fs is the path to the base of the filesystem into which to inject the key.
400
172
    """
167
    """
401
173
    sshdir = os.path.join(os.path.join(fs, 'root'), '.ssh')
168
    sshdir = os.path.join(os.path.join(fs, 'root'), '.ssh')
405
174
    yield execute('sudo mkdir -p %s' % sshdir)  # existing dir doesn't matter
169
    execute('sudo mkdir -p %s' % sshdir)  # existing dir doesn't matter
406
175
    yield execute('sudo chown root %s' % sshdir)
170
    execute('sudo chown root %s' % sshdir)
407
176
    yield execute('sudo chmod 700 %s' % sshdir)
171
    execute('sudo chmod 700 %s' % sshdir)
408
177
    keyfile = os.path.join(sshdir, 'authorized_keys')
172
    keyfile = os.path.join(sshdir, 'authorized_keys')
413
178
    yield execute('sudo tee -a %s' % keyfile, '\n' + key.strip() + '\n')
173
    execute('sudo tee -a %s' % keyfile, '\n' + key.strip() + '\n')
414
179
174
415
180
175
412
181
@defer.inlineCallbacks
416
182
def _inject_net_into_fs(net, fs, execute=None):
176
def _inject_net_into_fs(net, fs, execute=None):
417
183
    """Inject /etc/network/interfaces into the filesystem rooted at fs.
177
    """Inject /etc/network/interfaces into the filesystem rooted at fs.
418
184
178
419
185
    net is the contents of /etc/network/interfaces.
179
    net is the contents of /etc/network/interfaces.
420
186
    """
180
    """
421
187
    netdir = os.path.join(os.path.join(fs, 'etc'), 'network')
181
    netdir = os.path.join(os.path.join(fs, 'etc'), 'network')
425
188
    yield execute('sudo mkdir -p %s' % netdir)  # existing dir doesn't matter
182
    execute('sudo mkdir -p %s' % netdir)  # existing dir doesn't matter
426
189
    yield execute('sudo chown root:root %s' % netdir)
183
    execute('sudo chown root:root %s' % netdir)
427
190
    yield execute('sudo chmod 755 %s' % netdir)
184
    execute('sudo chmod 755 %s' % netdir)
428
191
    netfile = os.path.join(netdir, 'interfaces')
185
    netfile = os.path.join(netdir, 'interfaces')
430
192
    yield execute('sudo tee %s' % netfile, net)
186
    execute('sudo tee %s' % netfile, net)
431
193
187
432
=== modified file 'nova/compute/manager.py'
433
--- nova/compute/manager.py	2010-12-02 18:58:13 +0000
434
+++ nova/compute/manager.py	2010-12-16 20:49:10 +0000
435
@@ -37,8 +37,6 @@
436
37
import datetime
37
import datetime
437
38
import logging
38
import logging
438
39
39
439
40
from twisted.internet import defer
440
41
441
42
from nova import exception
40
from nova import exception
442
43
from nova import flags
41
from nova import flags
443
44
from nova import manager
42
from nova import manager
444
@@ -78,13 +76,11 @@
445
78
            state = power_state.NOSTATE
76
            state = power_state.NOSTATE
446
79
        self.db.instance_set_state(context, instance_id, state)
77
        self.db.instance_set_state(context, instance_id, state)
447
80
78
448
81
    @defer.inlineCallbacks
449
82
    @exception.wrap_exception
79
    @exception.wrap_exception
450
83
    def refresh_security_group(self, context, security_group_id, **_kwargs):
80
    def refresh_security_group(self, context, security_group_id, **_kwargs):
451
84
        """This call passes stright through to the virtualization driver."""
81
        """This call passes stright through to the virtualization driver."""
453
85
        yield self.driver.refresh_security_group(security_group_id)
82
        self.driver.refresh_security_group(security_group_id)
454
86
83
455
87
    @defer.inlineCallbacks
456
88
    @exception.wrap_exception
84
    @exception.wrap_exception
457
89
    def run_instance(self, context, instance_id, **_kwargs):
85
    def run_instance(self, context, instance_id, **_kwargs):
458
90
        """Launch a new instance with specified options."""
86
        """Launch a new instance with specified options."""
459
@@ -105,7 +101,7 @@
460
105
                                   'spawning')
101
                                   'spawning')
461
106
102
462
107
        try:
103
        try:
464
108
            yield self.driver.spawn(instance_ref)
104
            self.driver.spawn(instance_ref)
465
109
            now = datetime.datetime.utcnow()
105
            now = datetime.datetime.utcnow()
466
110
            self.db.instance_update(context,
106
            self.db.instance_update(context,
467
111
                                    instance_id,
107
                                    instance_id,
468
@@ -119,7 +115,6 @@
469
119
115
470
120
        self._update_state(context, instance_id)
116
        self._update_state(context, instance_id)
471
121
117
472
122
    @defer.inlineCallbacks
473
123
    @exception.wrap_exception
118
    @exception.wrap_exception
474
124
    def terminate_instance(self, context, instance_id):
119
    def terminate_instance(self, context, instance_id):
475
125
        """Terminate an instance on this machine."""
120
        """Terminate an instance on this machine."""
476
@@ -134,12 +129,11 @@
477
134
            self.db.instance_destroy(context, instance_id)
129
            self.db.instance_destroy(context, instance_id)
478
135
            raise exception.Error('trying to destroy already destroyed'
130
            raise exception.Error('trying to destroy already destroyed'
479
136
                                  ' instance: %s' % instance_id)
131
                                  ' instance: %s' % instance_id)
481
137
        yield self.driver.destroy(instance_ref)
132
        self.driver.destroy(instance_ref)
482
138
133
483
139
        # TODO(ja): should we keep it in a terminated state for a bit?
134
        # TODO(ja): should we keep it in a terminated state for a bit?
484
140
        self.db.instance_destroy(context, instance_id)
135
        self.db.instance_destroy(context, instance_id)
485
141
136
486
142
    @defer.inlineCallbacks
487
143
    @exception.wrap_exception
137
    @exception.wrap_exception
488
144
    def reboot_instance(self, context, instance_id):
138
    def reboot_instance(self, context, instance_id):
489
145
        """Reboot an instance on this server."""
139
        """Reboot an instance on this server."""
490
@@ -159,10 +153,9 @@
491
159
                                   instance_id,
153
                                   instance_id,
492
160
                                   power_state.NOSTATE,
154
                                   power_state.NOSTATE,
493
161
                                   'rebooting')
155
                                   'rebooting')
495
162
        yield self.driver.reboot(instance_ref)
156
        self.driver.reboot(instance_ref)
496
163
        self._update_state(context, instance_id)
157
        self._update_state(context, instance_id)
497
164
158
498
165
    @defer.inlineCallbacks
499
166
    @exception.wrap_exception
159
    @exception.wrap_exception
500
167
    def rescue_instance(self, context, instance_id):
160
    def rescue_instance(self, context, instance_id):
501
168
        """Rescue an instance on this server."""
161
        """Rescue an instance on this server."""
502
@@ -175,10 +168,9 @@
503
175
                                   instance_id,
168
                                   instance_id,
504
176
                                   power_state.NOSTATE,
169
                                   power_state.NOSTATE,
505
177
                                   'rescuing')
170
                                   'rescuing')
507
178
        yield self.driver.rescue(instance_ref)
171
        self.driver.rescue(instance_ref)
508
179
        self._update_state(context, instance_id)
172
        self._update_state(context, instance_id)
509
180
173
510
181
    @defer.inlineCallbacks
511
182
    @exception.wrap_exception
174
    @exception.wrap_exception
512
183
    def unrescue_instance(self, context, instance_id):
175
    def unrescue_instance(self, context, instance_id):
513
184
        """Rescue an instance on this server."""
176
        """Rescue an instance on this server."""
514
@@ -191,7 +183,7 @@
515
191
                                   instance_id,
183
                                   instance_id,
516
192
                                   power_state.NOSTATE,
184
                                   power_state.NOSTATE,
517
193
                                   'unrescuing')
185
                                   'unrescuing')
519
194
        yield self.driver.unrescue(instance_ref)
186
        self.driver.unrescue(instance_ref)
520
195
        self._update_state(context, instance_id)
187
        self._update_state(context, instance_id)
521
196
188
522
197
    @exception.wrap_exception
189
    @exception.wrap_exception
523
@@ -203,7 +195,6 @@
524
203
195
525
204
        return self.driver.get_console_output(instance_ref)
196
        return self.driver.get_console_output(instance_ref)
526
205
197
527
206
    @defer.inlineCallbacks
528
207
    @exception.wrap_exception
198
    @exception.wrap_exception
529
208
    def attach_volume(self, context, instance_id, volume_id, mountpoint):
199
    def attach_volume(self, context, instance_id, volume_id, mountpoint):
530
209
        """Attach a volume to an instance."""
200
        """Attach a volume to an instance."""
531
@@ -211,12 +202,12 @@
532
211
        logging.debug("instance %s: attaching volume %s to %s", instance_id,
202
        logging.debug("instance %s: attaching volume %s to %s", instance_id,
533
212
            volume_id, mountpoint)
203
            volume_id, mountpoint)
534
213
        instance_ref = self.db.instance_get(context, instance_id)
204
        instance_ref = self.db.instance_get(context, instance_id)
537
214
        dev_path = yield self.volume_manager.setup_compute_volume(context,
205
        dev_path = self.volume_manager.setup_compute_volume(context,
538
215
                                                                  volume_id)
206
                                                            volume_id)
539
216
        try:
207
        try:
543
217
            yield self.driver.attach_volume(instance_ref['name'],
208
            self.driver.attach_volume(instance_ref['name'],
544
218
                                            dev_path,
209
                                      dev_path,
545
219
                                            mountpoint)
210
                                      mountpoint)
546
220
            self.db.volume_attached(context,
211
            self.db.volume_attached(context,
547
221
                                    volume_id,
212
                                    volume_id,
548
222
                                    instance_id,
213
                                    instance_id,
549
@@ -227,12 +218,12 @@
550
227
            #             ecxception below.
218
            #             ecxception below.
551
228
            logging.exception("instance %s: attach failed %s, removing",
219
            logging.exception("instance %s: attach failed %s, removing",
552
229
                              instance_id, mountpoint)
220
                              instance_id, mountpoint)
555
230
            yield self.volume_manager.remove_compute_volume(context,
221
            self.volume_manager.remove_compute_volume(context,
556
231
                                                            volume_id)
222
                                                      volume_id)
557
232
            raise exc
223
            raise exc
561
233
        defer.returnValue(True)
224
562
234
225
        return True
563
235
    @defer.inlineCallbacks
226
564
236
    @exception.wrap_exception
227
    @exception.wrap_exception
565
237
    def detach_volume(self, context, instance_id, volume_id):
228
    def detach_volume(self, context, instance_id, volume_id):
566
238
        """Detach a volume from an instance."""
229
        """Detach a volume from an instance."""
567
@@ -246,8 +237,8 @@
568
246
            logging.warn("Detaching volume from unknown instance %s",
237
            logging.warn("Detaching volume from unknown instance %s",
569
247
                         instance_ref['name'])
238
                         instance_ref['name'])
570
248
        else:
239
        else:
574
249
            yield self.driver.detach_volume(instance_ref['name'],
240
            self.driver.detach_volume(instance_ref['name'],
575
250
                                            volume_ref['mountpoint'])
241
                                      volume_ref['mountpoint'])
576
251
        yield self.volume_manager.remove_compute_volume(context, volume_id)
242
        self.volume_manager.remove_compute_volume(context, volume_id)
577
252
        self.db.volume_detached(context, volume_id)
243
        self.db.volume_detached(context, volume_id)
579
253
        defer.returnValue(True)
244
        return True
580
254
245
581
=== modified file 'nova/flags.py'
582
--- nova/flags.py	2010-12-03 20:21:18 +0000
583
+++ nova/flags.py	2010-12-16 20:49:10 +0000
584
@@ -159,6 +159,7 @@
585
159
                return str(val)
159
                return str(val)
586
160
        raise KeyError(name)
160
        raise KeyError(name)
587
161
161
588
162
589
162
FLAGS = FlagValues()
163
FLAGS = FlagValues()
590
163
gflags.FLAGS = FLAGS
164
gflags.FLAGS = FLAGS
591
164
gflags.DEFINE_flag(gflags.HelpFlag(), FLAGS)
165
gflags.DEFINE_flag(gflags.HelpFlag(), FLAGS)
592
@@ -183,6 +184,12 @@
593
183
DEFINE_spaceseplist = _wrapper(gflags.DEFINE_spaceseplist)
184
DEFINE_spaceseplist = _wrapper(gflags.DEFINE_spaceseplist)
594
184
DEFINE_multistring = _wrapper(gflags.DEFINE_multistring)
185
DEFINE_multistring = _wrapper(gflags.DEFINE_multistring)
595
185
DEFINE_multi_int = _wrapper(gflags.DEFINE_multi_int)
186
DEFINE_multi_int = _wrapper(gflags.DEFINE_multi_int)
596
187
DEFINE_flag = _wrapper(gflags.DEFINE_flag)
597
188
598
189
599
190
HelpFlag = gflags.HelpFlag
600
191
HelpshortFlag = gflags.HelpshortFlag
601
192
HelpXMLFlag = gflags.HelpXMLFlag
602
186
193
603
187
194
604
188
def DECLARE(name, module_string, flag_values=FLAGS):
195
def DECLARE(name, module_string, flag_values=FLAGS):
605
189
196
606
=== modified file 'nova/manager.py'
607
--- nova/manager.py	2010-12-01 17:24:39 +0000
608
+++ nova/manager.py	2010-12-16 20:49:10 +0000
609
@@ -55,7 +55,6 @@
610
55
from nova import flags
55
from nova import flags
611
56
from nova.db import base
56
from nova.db import base
612
57
57
613
58
from twisted.internet import defer
614
59
58
615
60
FLAGS = flags.FLAGS
59
FLAGS = flags.FLAGS
616
61
60
617
@@ -67,10 +66,9 @@
618
67
        self.host = host
66
        self.host = host
619
68
        super(Manager, self).__init__(db_driver)
67
        super(Manager, self).__init__(db_driver)
620
69
68
621
70
    @defer.inlineCallbacks
622
71
    def periodic_tasks(self, context=None):
69
    def periodic_tasks(self, context=None):
623
72
        """Tasks to be run at a periodic interval"""
70
        """Tasks to be run at a periodic interval"""
625
73
        yield
71
        pass
626
74
72
627
75
    def init_host(self):
73
    def init_host(self):
628
76
        """Do any initialization that needs to be run if this is a standalone
74
        """Do any initialization that needs to be run if this is a standalone
629
77
75
630
=== modified file 'nova/network/manager.py'
631
--- nova/network/manager.py	2010-11-23 23:56:26 +0000
632
+++ nova/network/manager.py	2010-12-16 20:49:10 +0000
633
@@ -49,7 +49,6 @@
634
49
import math
49
import math
635
50
50
636
51
import IPy
51
import IPy
637
52
from twisted.internet import defer
638
53
52
639
54
from nova import context
53
from nova import context
640
55
from nova import db
54
from nova import db
641
@@ -399,10 +398,9 @@
642
399
    instances in its subnet.
398
    instances in its subnet.
643
400
    """
399
    """
644
401
400
645
402
    @defer.inlineCallbacks
646
403
    def periodic_tasks(self, context=None):
401
    def periodic_tasks(self, context=None):
647
404
        """Tasks to be run at a periodic interval."""
402
        """Tasks to be run at a periodic interval."""
649
405
        yield super(VlanManager, self).periodic_tasks(context)
403
        super(VlanManager, self).periodic_tasks(context)
650
406
        now = datetime.datetime.utcnow()
404
        now = datetime.datetime.utcnow()
651
407
        timeout = FLAGS.fixed_ip_disassociate_timeout
405
        timeout = FLAGS.fixed_ip_disassociate_timeout
652
408
        time = now - datetime.timedelta(seconds=timeout)
406
        time = now - datetime.timedelta(seconds=timeout)
653
409
407
654
=== modified file 'nova/objectstore/image.py'
655
--- nova/objectstore/image.py	2010-12-14 00:20:27 +0000
656
+++ nova/objectstore/image.py	2010-12-16 20:49:10 +0000
657
@@ -267,6 +267,7 @@
658
267
        if err:
267
        if err:
659
268
            raise exception.Error("Failed to decrypt initialization "
268
            raise exception.Error("Failed to decrypt initialization "
660
269
                                  "vector: %s" % err)
269
                                  "vector: %s" % err)
661
270
662
270
        _out, err = utils.execute(
271
        _out, err = utils.execute(
663
271
                'openssl enc -d -aes-128-cbc -in %s -K %s -iv %s -out %s'
272
                'openssl enc -d -aes-128-cbc -in %s -K %s -iv %s -out %s'
664
272
                 % (encrypted_filename, key, iv, decrypted_filename),
273
                 % (encrypted_filename, key, iv, decrypted_filename),
665
273
274
666
=== removed file 'nova/process.py'
667
--- nova/process.py	2010-10-21 18:49:51 +0000
668
+++ nova/process.py	1970-01-01 00:00:00 +0000
669
@@ -1,209 +0,0 @@
670
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
671
2
672
3
# Copyright 2010 United States Government as represented by the
673
4
# Administrator of the National Aeronautics and Space Administration.
674
5
# Copyright 2010 FathomDB Inc.
675
6
# All Rights Reserved.
676
7
#
677
8
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
678
9
#    not use this file except in compliance with the License. You may obtain
679
10
#    a copy of the License at
680
11
#
681
12
#         http://www.apache.org/licenses/LICENSE-2.0
682
13
#
683
14
#    Unless required by applicable law or agreed to in writing, software
684
15
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
685
16
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
686
17
#    License for the specific language governing permissions and limitations
687
18
#    under the License.
688
19
689
20
"""
690
21
Process pool using twisted threading
691
22
"""
692
23
693
24
import logging
694
25
import StringIO
695
26
696
27
from twisted.internet import defer
697
28
from twisted.internet import error
698
29
from twisted.internet import protocol
699
30
from twisted.internet import reactor
700
31
701
32
from nova import flags
702
33
from nova.exception import ProcessExecutionError
703
34
704
35
FLAGS = flags.FLAGS
705
36
flags.DEFINE_integer('process_pool_size', 4,
706
37
                     'Number of processes to use in the process pool')
707
38
708
39
709
40
# This is based on _BackRelay from twister.internal.utils, but modified to
710
41
#  capture both stdout and stderr, without odd stderr handling, and also to
711
42
#  handle stdin
712
43
class BackRelayWithInput(protocol.ProcessProtocol):
713
44
    """
714
45
    Trivial protocol for communicating with a process and turning its output
715
46
    into the result of a L{Deferred}.
716
47
717
48
    @ivar deferred: A L{Deferred} which will be called back with all of stdout
718
49
        and all of stderr as well (as a tuple).  C{terminate_on_stderr} is true
719
50
        and any bytes are received over stderr, this will fire with an
720
51
        L{_ProcessExecutionError} instance and the attribute will be set to
721
52
        C{None}.
722
53
723
54
    @ivar onProcessEnded: If C{terminate_on_stderr} is false and bytes are
724
55
        received over stderr, this attribute will refer to a L{Deferred} which
725
56
        will be called back when the process ends.  This C{Deferred} is also
726
57
        associated with the L{_ProcessExecutionError} which C{deferred} fires
727
58
        with earlier in this case so that users can determine when the process
728
59
        has actually ended, in addition to knowing when bytes have been
729
60
        received via stderr.
730
61
    """
731
62
732
63
    def __init__(self, deferred, cmd, started_deferred=None,
733
64
                 terminate_on_stderr=False, check_exit_code=True,
734
65
                 process_input=None):
735
66
        self.deferred = deferred
736
67
        self.cmd = cmd
737
68
        self.stdout = StringIO.StringIO()
738
69
        self.stderr = StringIO.StringIO()
739
70
        self.started_deferred = started_deferred
740
71
        self.terminate_on_stderr = terminate_on_stderr
741
72
        self.check_exit_code = check_exit_code
742
73
        self.process_input = process_input
743
74
        self.on_process_ended = None
744
75
745
76
    def _build_execution_error(self, exit_code=None):
746
77
        return ProcessExecutionError(cmd=self.cmd,
747
78
                                     exit_code=exit_code,
748
79
                                     stdout=self.stdout.getvalue(),
749
80
                                     stderr=self.stderr.getvalue())
750
81
751
82
    def errReceived(self, text):
752
83
        self.stderr.write(text)
753
84
        if self.terminate_on_stderr and (self.deferred is not None):
754
85
            self.on_process_ended = defer.Deferred()
755
86
            self.deferred.errback(self._build_execution_error())
756
87
            self.deferred = None
757
88
            self.transport.loseConnection()
758
89
759
90
    def outReceived(self, text):
760
91
        self.stdout.write(text)
761
92
762
93
    def processEnded(self, reason):
763
94
        if self.deferred is not None:
764
95
            stdout, stderr = self.stdout.getvalue(), self.stderr.getvalue()
765
96
            exit_code = reason.value.exitCode
766
97
            if self.check_exit_code and exit_code != 0:
767
98
                self.deferred.errback(self._build_execution_error(exit_code))
768
99
            else:
769
100
                try:
770
101
                    if self.check_exit_code:
771
102
                        reason.trap(error.ProcessDone)
772
103
                    self.deferred.callback((stdout, stderr))
773
104
                except:
774
105
                    # NOTE(justinsb): This logic is a little suspicious to me.
775
106
                    # If the callback throws an exception, then errback will
776
107
                    # be called also. However, this is what the unit tests
777
108
                    # test for.
778
109
                    exec_error = self._build_execution_error(exit_code)
779
110
                    self.deferred.errback(exec_error)
780
111
        elif self.on_process_ended is not None:
781
112
            self.on_process_ended.errback(reason)
782
113
783
114
    def connectionMade(self):
784
115
        if self.started_deferred:
785
116
            self.started_deferred.callback(self)
786
117
        if self.process_input:
787
118
            self.transport.write(str(self.process_input))
788
119
        self.transport.closeStdin()
789
120
790
121
791
122
def get_process_output(executable, args=None, env=None, path=None,
792
123
                       process_reactor=None, check_exit_code=True,
793
124
                       process_input=None, started_deferred=None,
794
125
                       terminate_on_stderr=False):
795
126
    if process_reactor is None:
796
127
        process_reactor = reactor
797
128
    args = args and args or ()
798
129
    env = env and env and {}
799
130
    deferred = defer.Deferred()
800
131
    cmd = executable
801
132
    if args:
802
133
        cmd = " ".join([cmd] + args)
803
134
    logging.debug("Running cmd: %s", cmd)
804
135
    process_handler = BackRelayWithInput(
805
136
            deferred,
806
137
            cmd,
807
138
            started_deferred=started_deferred,
808
139
            check_exit_code=check_exit_code,
809
140
            process_input=process_input,
810
141
            terminate_on_stderr=terminate_on_stderr)
811
142
    # NOTE(vish): commands come in as unicode, but self.executes needs
812
143
    #             strings or process.spawn raises a deprecation warning
813
144
    executable = str(executable)
814
145
    if not args is None:
815
146
        args = [str(x) for x in args]
816
147
    process_reactor.spawnProcess(process_handler, executable,
817
148
                                 (executable,) + tuple(args), env, path)
818
149
    return deferred
819
150
820
151
821
152
class ProcessPool(object):
822
153
    """ A simple process pool implementation using Twisted's Process bits.
823
154
824
155
    This is pretty basic right now, but hopefully the API will be the correct
825
156
    one so that it can be optimized later.
826
157
    """
827
158
    def __init__(self, size=None):
828
159
        self.size = size and size or FLAGS.process_pool_size
829
160
        self._pool = defer.DeferredSemaphore(self.size)
830
161
831
162
    def simple_execute(self, cmd, **kw):
832
163
        """ Weak emulation of the old utils.execute() function.
833
164
834
165
        This only exists as a way to quickly move old execute methods to
835
166
        this new style of code.
836
167
837
168
        NOTE(termie): This will break on args with spaces in them.
838
169
        """
839
170
        parsed = cmd.split(' ')
840
171
        executable, args = parsed[0], parsed[1:]
841
172
        return self.execute(executable, args, **kw)
842
173
843
174
    def execute(self, *args, **kw):
844
175
        deferred = self._pool.acquire()
845
176
846
177
        def _associate_process(proto):
847
178
            deferred.process = proto.transport
848
179
            return proto.transport
849
180
850
181
        started = defer.Deferred()
851
182
        started.addCallback(_associate_process)
852
183
        kw.setdefault('started_deferred', started)
853
184
854
185
        deferred.process = None
855
186
        deferred.started = started
856
187
857
188
        deferred.addCallback(lambda _: get_process_output(*args, **kw))
858
189
        deferred.addBoth(self._release)
859
190
        return deferred
860
191
861
192
    def _release(self, retval=None):
862
193
        self._pool.release()
863
194
        return retval
864
195
865
196
866
197
class SharedPool(object):
867
198
    _instance = None
868
199
869
200
    def __init__(self):
870
201
        if SharedPool._instance is None:
871
202
            self.__class__._instance = ProcessPool()
872
203
873
204
    def __getattr__(self, key):
874
205
        return getattr(self._instance, key)
875
206
876
207
877
208
def simple_execute(cmd, **kwargs):
878
209
    return SharedPool().simple_execute(cmd, **kwargs)
879
210
0
880
=== modified file 'nova/rpc.py'
881
--- nova/rpc.py	2010-11-22 22:48:44 +0000
882
+++ nova/rpc.py	2010-12-16 20:49:10 +0000
883
@@ -25,18 +25,18 @@
884
25
import logging
25
import logging
885
26
import sys
26
import sys
886
27
import time
27
import time
887
28
import traceback
888
28
import uuid
29
import uuid
889
29
30
890
30
from carrot import connection as carrot_connection
31
from carrot import connection as carrot_connection
891
31
from carrot import messaging
32
from carrot import messaging
892
32
from eventlet import greenthread
33
from eventlet import greenthread
893
33
from twisted.internet import defer
894
34
from twisted.internet import task
895
35
34
896
35
from nova import context
897
36
from nova import exception
36
from nova import exception
898
37
from nova import fakerabbit
37
from nova import fakerabbit
899
38
from nova import flags
38
from nova import flags
901
39
from nova import context
39
from nova import utils
902
40
40
903
41
41
904
42
FLAGS = flags.FLAGS
42
FLAGS = flags.FLAGS
905
@@ -128,17 +128,9 @@
906
128
128
907
129
    def attach_to_eventlet(self):
129
    def attach_to_eventlet(self):
908
130
        """Only needed for unit tests!"""
130
        """Only needed for unit tests!"""
920
131
        def fetch_repeatedly():
131
        timer = utils.LoopingCall(self.fetch, enable_callbacks=True)
921
132
            while True:
132
        timer.start(0.1)
922
133
                self.fetch(enable_callbacks=True)
133
        return timer
912
134
                greenthread.sleep(0.1)
913
135
        greenthread.spawn(fetch_repeatedly)
914
136
915
137
    def attach_to_twisted(self):
916
138
        """Attach a callback to twisted that fires 10 times a second"""
917
139
        loop = task.LoopingCall(self.fetch, enable_callbacks=True)
918
140
        loop.start(interval=0.1)
919
141
        return loop
923
142
134
924
143
135
925
144
class Publisher(messaging.Publisher):
136
class Publisher(messaging.Publisher):
926
@@ -196,11 +188,13 @@
927
196
        node_func = getattr(self.proxy, str(method))
188
        node_func = getattr(self.proxy, str(method))
928
197
        node_args = dict((str(k), v) for k, v in args.iteritems())
189
        node_args = dict((str(k), v) for k, v in args.iteritems())
929
198
        # NOTE(vish): magic is fun!
190
        # NOTE(vish): magic is fun!
935
199
        # pylint: disable-msg=W0142
191
        try:
936
200
        d = defer.maybeDeferred(node_func, context=ctxt, **node_args)
192
            rval = node_func(context=ctxt, **node_args)
937
201
        if msg_id:
193
            if msg_id:
938
202
            d.addCallback(lambda rval: msg_reply(msg_id, rval, None))
194
                msg_reply(msg_id, rval, None)
939
203
            d.addErrback(lambda e: msg_reply(msg_id, None, e))
195
        except Exception as e:
940
196
            if msg_id:
941
197
                msg_reply(msg_id, None, sys.exc_info())
942
204
        return
198
        return
943
205
199
944
206
200
945
@@ -242,13 +236,15 @@
946
242
def msg_reply(msg_id, reply=None, failure=None):
236
def msg_reply(msg_id, reply=None, failure=None):
947
243
    """Sends a reply or an error on the channel signified by msg_id
237
    """Sends a reply or an error on the channel signified by msg_id
948
244
238
950
245
    failure should be a twisted failure object"""
239
    failure should be a sys.exc_info() tuple.
951
240
952
241
    """
953
246
    if failure:
242
    if failure:
956
247
        message = failure.getErrorMessage()
243
        message = str(failure[1])
957
248
        traceback = failure.getTraceback()
244
        tb = traceback.format_exception(*failure)
958
249
        logging.error("Returning exception %s to caller", message)
245
        logging.error("Returning exception %s to caller", message)
961
250
        logging.error(traceback)
246
        logging.error(tb)
962
251
        failure = (failure.type.__name__, str(failure.value), traceback)
247
        failure = (failure[0].__name__, str(failure[1]), tb)
963
252
    conn = Connection.instance()
248
    conn = Connection.instance()
964
253
    publisher = DirectPublisher(connection=conn, msg_id=msg_id)
249
    publisher = DirectPublisher(connection=conn, msg_id=msg_id)
965
254
    try:
250
    try:
966
@@ -313,7 +309,6 @@
967
313
    _pack_context(msg, context)
309
    _pack_context(msg, context)
968
314
310
969
315
    class WaitMessage(object):
311
    class WaitMessage(object):
970
316
971
317
        def __call__(self, data, message):
312
        def __call__(self, data, message):
972
318
            """Acks message and sets result."""
313
            """Acks message and sets result."""
973
319
            message.ack()
314
            message.ack()
974
@@ -337,41 +332,15 @@
975
337
    except StopIteration:
332
    except StopIteration:
976
338
        pass
333
        pass
977
339
    consumer.close()
334
    consumer.close()
978
335
    # NOTE(termie): this is a little bit of a change from the original
979
336
    #               non-eventlet code where returning a Failure
980
337
    #               instance from a deferred call is very similar to
981
338
    #               raising an exception
982
339
    if isinstance(wait_msg.result, Exception):
983
340
        raise wait_msg.result
984
340
    return wait_msg.result
341
    return wait_msg.result
985
341
342
986
342
343
987
343
def call_twisted(context, topic, msg):
988
344
    """Sends a message on a topic and wait for a response"""
989
345
    LOG.debug("Making asynchronous call...")
990
346
    msg_id = uuid.uuid4().hex
991
347
    msg.update({'_msg_id': msg_id})
992
348
    LOG.debug("MSG_ID is %s" % (msg_id))
993
349
    _pack_context(msg, context)
994
350
995
351
    conn = Connection.instance()
996
352
    d = defer.Deferred()
997
353
    consumer = DirectConsumer(connection=conn, msg_id=msg_id)
998
354
999
355
    def deferred_receive(data, message):
1000
356
        """Acks message and callbacks or errbacks"""
1001
357
        message.ack()
1002
358
        if data['failure']:
1003
359
            return d.errback(RemoteError(*data['failure']))
1004
360
        else:
1005
361
            return d.callback(data['result'])
1006
362
1007
363
    consumer.register_callback(deferred_receive)
1008
364
    injected = consumer.attach_to_twisted()
1009
365
1010
366
    # clean up after the injected listened and return x
1011
367
    d.addCallback(lambda x: injected.stop() and x or x)
1012
368
1013
369
    publisher = TopicPublisher(connection=conn, topic=topic)
1014
370
    publisher.send(msg)
1015
371
    publisher.close()
1016
372
    return d
1017
373
1018
374
1019
375
def cast(context, topic, msg):
344
def cast(context, topic, msg):
1020
376
    """Sends a message on a topic without waiting for a response"""
345
    """Sends a message on a topic without waiting for a response"""
1021
377
    LOG.debug("Making asynchronous cast...")
346
    LOG.debug("Making asynchronous cast...")
1022
378
347
1023
=== removed file 'nova/server.py'
1024
--- nova/server.py	2010-11-23 20:52:00 +0000
1025
+++ nova/server.py	1970-01-01 00:00:00 +0000
1026
@@ -1,151 +0,0 @@
1027
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
1028
2
1029
3
# Copyright 2010 United States Government as represented by the
1030
4
# Administrator of the National Aeronautics and Space Administration.
1031
5
# All Rights Reserved.
1032
6
#
1033
7
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
1034
8
#    not use this file except in compliance with the License. You may obtain
1035
9
#    a copy of the License at
1036
10
#
1037
11
#         http://www.apache.org/licenses/LICENSE-2.0
1038
12
#
1039
13
#    Unless required by applicable law or agreed to in writing, software
1040
14
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
1041
15
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
1042
16
#    License for the specific language governing permissions and limitations
1043
17
#    under the License.
1044
18
1045
19
"""
1046
20
Base functionality for nova daemons - gradually being replaced with twistd.py.
1047
21
"""
1048
22
1049
23
import daemon
1050
24
from daemon import pidlockfile
1051
25
import logging
1052
26
import logging.handlers
1053
27
import os
1054
28
import signal
1055
29
import sys
1056
30
import time
1057
31
1058
32
from nova import flags
1059
33
1060
34
1061
35
FLAGS = flags.FLAGS
1062
36
flags.DEFINE_bool('daemonize', False, 'daemonize this process')
1063
37
# NOTE(termie): right now I am defaulting to using syslog when we daemonize
1064
38
#               it may be better to do something else -shrug-
1065
39
# NOTE(Devin): I think we should let each process have its own log file
1066
40
#              and put it in /var/logs/nova/(appname).log
1067
41
#              This makes debugging much easier and cuts down on sys log
1068
42
#              clutter.
1069
43
flags.DEFINE_bool('use_syslog', True, 'output to syslog when daemonizing')
1070
44
flags.DEFINE_string('logfile', None, 'log file to output to')
1071
45
flags.DEFINE_string('logdir',  None, 'directory to keep log files in '
1072
46
                                     '(will be prepended to $logfile)')
1073
47
flags.DEFINE_string('pidfile', None, 'pid file to output to')
1074
48
flags.DEFINE_string('working_directory', './', 'working directory...')
1075
49
flags.DEFINE_integer('uid', os.getuid(), 'uid under which to run')
1076
50
flags.DEFINE_integer('gid', os.getgid(), 'gid under which to run')
1077
51
1078
52
1079
53
def stop(pidfile):
1080
54
    """
1081
55
    Stop the daemon
1082
56
    """
1083
57
    # Get the pid from the pidfile
1084
58
    try:
1085
59
        pid = int(open(pidfile, 'r').read().strip())
1086
60
    except IOError:
1087
61
        message = "pidfile %s does not exist. Daemon not running?\n"
1088
62
        sys.stderr.write(message % pidfile)
1089
63
        return
1090
64
1091
65
    # Try killing the daemon process
1092
66
    try:
1093
67
        while 1:
1094
68
            os.kill(pid, signal.SIGTERM)
1095
69
            time.sleep(0.1)
1096
70
    except OSError, err:
1097
71
        err = str(err)
1098
72
        if err.find("No such process") > 0:
1099
73
            if os.path.exists(pidfile):
1100
74
                os.remove(pidfile)
1101
75
        else:
1102
76
            print str(err)
1103
77
            sys.exit(1)
1104
78
1105
79
1106
80
def serve(name, main):
1107
81
    """Controller for server"""
1108
82
    argv = FLAGS(sys.argv)
1109
83
1110
84
    if not FLAGS.pidfile:
1111
85
        FLAGS.pidfile = '%s.pid' % name
1112
86
1113
87
    logging.debug("Full set of FLAGS: \n\n\n")
1114
88
    for flag in FLAGS:
1115
89
        logging.debug("%s : %s", flag, FLAGS.get(flag, None))
1116
90
1117
91
    action = 'start'
1118
92
    if len(argv) > 1:
1119
93
        action = argv.pop()
1120
94
1121
95
    if action == 'stop':
1122
96
        stop(FLAGS.pidfile)
1123
97
        sys.exit()
1124
98
    elif action == 'restart':
1125
99
        stop(FLAGS.pidfile)
1126
100
    elif action == 'start':
1127
101
        pass
1128
102
    else:
1129
103
        print 'usage: %s [options] [start|stop|restart]' % argv[0]
1130
104
        sys.exit(1)
1131
105
    daemonize(argv, name, main)
1132
106
1133
107
1134
108
def daemonize(args, name, main):
1135
109
    """Does the work of daemonizing the process"""
1136
110
    logging.getLogger('amqplib').setLevel(logging.WARN)
1137
111
    files_to_keep = []
1138
112
    if FLAGS.daemonize:
1139
113
        logger = logging.getLogger()
1140
114
        formatter = logging.Formatter(
1141
115
                name + '(%(name)s): %(levelname)s %(message)s')
1142
116
        if FLAGS.use_syslog and not FLAGS.logfile:
1143
117
            syslog = logging.handlers.SysLogHandler(address='/dev/log')
1144
118
            syslog.setFormatter(formatter)
1145
119
            logger.addHandler(syslog)
1146
120
            files_to_keep.append(syslog.socket)
1147
121
        else:
1148
122
            if not FLAGS.logfile:
1149
123
                FLAGS.logfile = '%s.log' % name
1150
124
            if FLAGS.logdir:
1151
125
                FLAGS.logfile = os.path.join(FLAGS.logdir, FLAGS.logfile)
1152
126
            logfile = logging.FileHandler(FLAGS.logfile)
1153
127
            logfile.setFormatter(formatter)
1154
128
            logger.addHandler(logfile)
1155
129
            files_to_keep.append(logfile.stream)
1156
130
        stdin, stdout, stderr = None, None, None
1157
131
    else:
1158
132
        stdin, stdout, stderr = sys.stdin, sys.stdout, sys.stderr
1159
133
1160
134
    if FLAGS.verbose:
1161
135
        logging.getLogger().setLevel(logging.DEBUG)
1162
136
    else:
1163
137
        logging.getLogger().setLevel(logging.WARNING)
1164
138
1165
139
    with daemon.DaemonContext(
1166
140
            detach_process=FLAGS.daemonize,
1167
141
            working_directory=FLAGS.working_directory,
1168
142
            pidfile=pidlockfile.TimeoutPIDLockFile(FLAGS.pidfile,
1169
143
                                                   acquire_timeout=1,
1170
144
                                                   threaded=False),
1171
145
            stdin=stdin,
1172
146
            stdout=stdout,
1173
147
            stderr=stderr,
1174
148
            uid=FLAGS.uid,
1175
149
            gid=FLAGS.gid,
1176
150
            files_preserve=files_to_keep):
1177
151
        main(args)
1178
152
0
1179
=== added file 'nova/service.py'
1180
--- nova/service.py	1970-01-01 00:00:00 +0000
1181
+++ nova/service.py	2010-12-16 20:49:10 +0000
1182
@@ -0,0 +1,234 @@
1183
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
1184
2
1185
3
# Copyright 2010 United States Government as represented by the
1186
4
# Administrator of the National Aeronautics and Space Administration.
1187
5
# All Rights Reserved.
1188
6
#
1189
7
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
1190
8
#    not use this file except in compliance with the License. You may obtain
1191
9
#    a copy of the License at
1192
10
#
1193
11
#         http://www.apache.org/licenses/LICENSE-2.0
1194
12
#
1195
13
#    Unless required by applicable law or agreed to in writing, software
1196
14
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
1197
15
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
1198
16
#    License for the specific language governing permissions and limitations
1199
17
#    under the License.
1200
18
1201
19
"""
1202
20
Generic Node baseclass for all workers that run on hosts
1203
21
"""
1204
22
1205
23
import inspect
1206
24
import logging
1207
25
import os
1208
26
import sys
1209
27
1210
28
from eventlet import event
1211
29
from eventlet import greenthread
1212
30
from eventlet import greenpool
1213
31
1214
32
from nova import context
1215
33
from nova import db
1216
34
from nova import exception
1217
35
from nova import flags
1218
36
from nova import rpc
1219
37
from nova import utils
1220
38
1221
39
1222
40
FLAGS = flags.FLAGS
1223
41
flags.DEFINE_integer('report_interval', 10,
1224
42
                     'seconds between nodes reporting state to datastore',
1225
43
                     lower_bound=1)
1226
44
1227
45
flags.DEFINE_integer('periodic_interval', 60,
1228
46
                     'seconds between running periodic tasks',
1229
47
                     lower_bound=1)
1230
48
1231
49
flags.DEFINE_string('pidfile', None,
1232
50
                    'pidfile to use for this service')
1233
51
1234
52
1235
53
flags.DEFINE_flag(flags.HelpFlag())
1236
54
flags.DEFINE_flag(flags.HelpshortFlag())
1237
55
flags.DEFINE_flag(flags.HelpXMLFlag())
1238
56
1239
57
1240
58
class Service(object):
1241
59
    """Base class for workers that run on hosts."""
1242
60
1243
61
    def __init__(self, host, binary, topic, manager, report_interval=None,
1244
62
                 periodic_interval=None, *args, **kwargs):
1245
63
        self.host = host
1246
64
        self.binary = binary
1247
65
        self.topic = topic
1248
66
        self.manager_class_name = manager
1249
67
        self.report_interval = report_interval
1250
68
        self.periodic_interval = periodic_interval
1251
69
        super(Service, self).__init__(*args, **kwargs)
1252
70
        self.saved_args, self.saved_kwargs = args, kwargs
1253
71
        self.timers = []
1254
72
1255
73
    def start(self):
1256
74
        manager_class = utils.import_class(self.manager_class_name)
1257
75
        self.manager = manager_class(host=self.host, *self.saved_args,
1258
76
                                                     **self.saved_kwargs)
1259
77
        self.manager.init_host()
1260
78
        self.model_disconnected = False
1261
79
        ctxt = context.get_admin_context()
1262
80
        try:
1263
81
            service_ref = db.service_get_by_args(ctxt,
1264
82
                                                 self.host,
1265
83
                                                 self.binary)
1266
84
            self.service_id = service_ref['id']
1267
85
        except exception.NotFound:
1268
86
            self._create_service_ref(ctxt)
1269
87
1270
88
        conn1 = rpc.Connection.instance(new=True)
1271
89
        conn2 = rpc.Connection.instance(new=True)
1272
90
        if self.report_interval:
1273
91
            consumer_all = rpc.AdapterConsumer(
1274
92
                    connection=conn1,
1275
93
                    topic=self.topic,
1276
94
                    proxy=self)
1277
95
            consumer_node = rpc.AdapterConsumer(
1278
96
                    connection=conn2,
1279
97
                    topic='%s.%s' % (self.topic, self.host),
1280
98
                    proxy=self)
1281
99
1282
100
            self.timers.append(consumer_all.attach_to_eventlet())
1283
101
            self.timers.append(consumer_node.attach_to_eventlet())
1284
102
1285
103
            pulse = utils.LoopingCall(self.report_state)
1286
104
            pulse.start(interval=self.report_interval, now=False)
1287
105
            self.timers.append(pulse)
1288
106
1289
107
        if self.periodic_interval:
1290
108
            periodic = utils.LoopingCall(self.periodic_tasks)
1291
109
            periodic.start(interval=self.periodic_interval, now=False)
1292
110
            self.timers.append(periodic)
1293
111
1294
112
    def _create_service_ref(self, context):
1295
113
        service_ref = db.service_create(context,
1296
114
                                        {'host': self.host,
1297
115
                                         'binary': self.binary,
1298
116
                                         'topic': self.topic,
1299
117
                                         'report_count': 0})
1300
118
        self.service_id = service_ref['id']
1301
119
1302
120
    def __getattr__(self, key):
1303
121
        manager = self.__dict__.get('manager', None)
1304
122
        return getattr(manager, key)
1305
123
1306
124
    @classmethod
1307
125
    def create(cls,
1308
126
               host=None,
1309
127
               binary=None,
1310
128
               topic=None,
1311
129
               manager=None,
1312
130
               report_interval=None,
1313
131
               periodic_interval=None):
1314
132
        """Instantiates class and passes back application object.
1315
133
1316
134
        Args:
1317
135
            host, defaults to FLAGS.host
1318
136
            binary, defaults to basename of executable
1319
137
            topic, defaults to bin_name - "nova-" part
1320
138
            manager, defaults to FLAGS.<topic>_manager
1321
139
            report_interval, defaults to FLAGS.report_interval
1322
140
            periodic_interval, defaults to FLAGS.periodic_interval
1323
141
        """
1324
142
        if not host:
1325
143
            host = FLAGS.host
1326
144
        if not binary:
1327
145
            binary = os.path.basename(inspect.stack()[-1][1])
1328
146
        if not topic:
1329
147
            topic = binary.rpartition("nova-")[2]
1330
148
        if not manager:
1331
149
            manager = FLAGS.get('%s_manager' % topic, None)
1332
150
        if not report_interval:
1333
151
            report_interval = FLAGS.report_interval
1334
152
        if not periodic_interval:
1335
153
            periodic_interval = FLAGS.periodic_interval
1336
154
        logging.warn("Starting %s node", topic)
1337
155
        service_obj = cls(host, binary, topic, manager,
1338
156
                          report_interval, periodic_interval)
1339
157
1340
158
        return service_obj
1341
159
1342
160
    def kill(self):
1343
161
        """Destroy the service object in the datastore"""
1344
162
        self.stop()
1345
163
        try:
1346
164
            db.service_destroy(context.get_admin_context(), self.service_id)
1347
165
        except exception.NotFound:
1348
166
            logging.warn("Service killed that has no database entry")
1349
167
1350
168
    def stop(self):
1351
169
        for x in self.timers:
1352
170
            try:
1353
171
                x.stop()
1354
172
            except Exception:
1355
173
                pass
1356
174
        self.timers = []
1357
175
1358
176
    def periodic_tasks(self):
1359
177
        """Tasks to be run at a periodic interval"""
1360
178
        self.manager.periodic_tasks(context.get_admin_context())
1361
179
1362
180
    def report_state(self):
1363
181
        """Update the state of this service in the datastore."""
1364
182
        ctxt = context.get_admin_context()
1365
183
        try:
1366
184
            try:
1367
185
                service_ref = db.service_get(ctxt, self.service_id)
1368
186
            except exception.NotFound:
1369
187
                logging.debug("The service database object disappeared, "
1370
188
                              "Recreating it.")
1371
189
                self._create_service_ref(ctxt)
1372
190
                service_ref = db.service_get(ctxt, self.service_id)
1373
191
1374
192
            db.service_update(ctxt,
1375
193
                             self.service_id,
1376
194
                             {'report_count': service_ref['report_count'] + 1})
1377
195
1378
196
            # TODO(termie): make this pattern be more elegant.
1379
197
            if getattr(self, "model_disconnected", False):
1380
198
                self.model_disconnected = False
1381
199
                logging.error("Recovered model server connection!")
1382
200
1383
201
        # TODO(vish): this should probably only catch connection errors
1384
202
        except Exception:  # pylint: disable-msg=W0702
1385
203
            if not getattr(self, "model_disconnected", False):
1386
204
                self.model_disconnected = True
1387
205
                logging.exception("model server went away")
1388
206
1389
207
1390
208
def serve(*services):
1391
209
    argv = FLAGS(sys.argv)
1392
210
1393
211
    if not services:
1394
212
        services = [Service.create()]
1395
213
1396
214
    name = '_'.join(x.binary for x in services)
1397
215
    logging.debug("Serving %s" % name)
1398
216
1399
217
    logging.getLogger('amqplib').setLevel(logging.WARN)
1400
218
1401
219
    if FLAGS.verbose:
1402
220
        logging.getLogger().setLevel(logging.DEBUG)
1403
221
    else:
1404
222
        logging.getLogger().setLevel(logging.WARNING)
1405
223
1406
224
    logging.debug("Full set of FLAGS:")
1407
225
    for flag in FLAGS:
1408
226
        logging.debug("%s : %s" % (flag, FLAGS.get(flag, None)))
1409
227
1410
228
    for x in services:
1411
229
        x.start()
1412
230
1413
231
1414
232
def wait():
1415
233
    while True:
1416
234
        greenthread.sleep(5)
1417
0
235
1418
=== removed file 'nova/service.py'
1419
--- nova/service.py	2010-11-15 19:43:50 +0000
1420
+++ nova/service.py	1970-01-01 00:00:00 +0000
1421
@@ -1,195 +0,0 @@
1422
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
1423
2
1424
3
# Copyright 2010 United States Government as represented by the
1425
4
# Administrator of the National Aeronautics and Space Administration.
1426
5
# All Rights Reserved.
1427
6
#
1428
7
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
1429
8
#    not use this file except in compliance with the License. You may obtain
1430
9
#    a copy of the License at
1431
10
#
1432
11
#         http://www.apache.org/licenses/LICENSE-2.0
1433
12
#
1434
13
#    Unless required by applicable law or agreed to in writing, software
1435
14
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
1436
15
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
1437
16
#    License for the specific language governing permissions and limitations
1438
17
#    under the License.
1439
18
1440
19
"""
1441
20
A service is a very thin wrapper around a Manager object.  It exposes the
1442
21
manager's public methods to other components of the system via rpc.  It will
1443
22
report state periodically to the database and is responsible for initiating
1444
23
any periodic tasts that need to be executed on a given host.
1445
24
1446
25
This module contains Service, a generic baseclass for all workers.
1447
26
"""
1448
27
1449
28
import inspect
1450
29
import logging
1451
30
import os
1452
31
1453
32
from twisted.internet import defer
1454
33
from twisted.internet import task
1455
34
from twisted.application import service
1456
35
1457
36
from nova import context
1458
37
from nova import db
1459
38
from nova import exception
1460
39
from nova import flags
1461
40
from nova import rpc
1462
41
from nova import utils
1463
42
1464
43
1465
44
FLAGS = flags.FLAGS
1466
45
flags.DEFINE_integer('report_interval', 10,
1467
46
                     'seconds between nodes reporting state to datastore',
1468
47
                     lower_bound=1)
1469
48
1470
49
flags.DEFINE_integer('periodic_interval', 60,
1471
50
                     'seconds between running periodic tasks',
1472
51
                     lower_bound=1)
1473
52
1474
53
1475
54
class Service(object, service.Service):
1476
55
    """Base class for workers that run on hosts."""
1477
56
1478
57
    def __init__(self, host, binary, topic, manager, report_interval=None,
1479
58
                 periodic_interval=None, *args, **kwargs):
1480
59
        self.host = host
1481
60
        self.binary = binary
1482
61
        self.topic = topic
1483
62
        self.manager_class_name = manager
1484
63
        self.report_interval = report_interval
1485
64
        self.periodic_interval = periodic_interval
1486
65
        super(Service, self).__init__(*args, **kwargs)
1487
66
        self.saved_args, self.saved_kwargs = args, kwargs
1488
67
1489
68
    def startService(self):  # pylint: disable-msg C0103
1490
69
        manager_class = utils.import_class(self.manager_class_name)
1491
70
        self.manager = manager_class(host=self.host, *self.saved_args,
1492
71
                                                     **self.saved_kwargs)
1493
72
        self.manager.init_host()
1494
73
        self.model_disconnected = False
1495
74
        ctxt = context.get_admin_context()
1496
75
        try:
1497
76
            service_ref = db.service_get_by_args(ctxt,
1498
77
                                                 self.host,
1499
78
                                                 self.binary)
1500
79
            self.service_id = service_ref['id']
1501
80
        except exception.NotFound:
1502
81
            self._create_service_ref(ctxt)
1503
82
1504
83
        conn = rpc.Connection.instance()
1505
84
        if self.report_interval:
1506
85
            consumer_all = rpc.AdapterConsumer(
1507
86
                    connection=conn,
1508
87
                    topic=self.topic,
1509
88
                    proxy=self)
1510
89
            consumer_node = rpc.AdapterConsumer(
1511
90
                    connection=conn,
1512
91
                    topic='%s.%s' % (self.topic, self.host),
1513
92
                    proxy=self)
1514
93
1515
94
            consumer_all.attach_to_twisted()
1516
95
            consumer_node.attach_to_twisted()
1517
96
1518
97
            pulse = task.LoopingCall(self.report_state)
1519
98
            pulse.start(interval=self.report_interval, now=False)
1520
99
1521
100
        if self.periodic_interval:
1522
101
            pulse = task.LoopingCall(self.periodic_tasks)
1523
102
            pulse.start(interval=self.periodic_interval, now=False)
1524
103
1525
104
    def _create_service_ref(self, context):
1526
105
        service_ref = db.service_create(context,
1527
106
                                        {'host': self.host,
1528
107
                                         'binary': self.binary,
1529
108
                                         'topic': self.topic,
1530
109
                                         'report_count': 0})
1531
110
        self.service_id = service_ref['id']
1532
111
1533
112
    def __getattr__(self, key):
1534
113
        manager = self.__dict__.get('manager', None)
1535
114
        return getattr(manager, key)
1536
115
1537
116
    @classmethod
1538
117
    def create(cls,
1539
118
               host=None,
1540
119
               binary=None,
1541
120
               topic=None,
1542
121
               manager=None,
1543
122
               report_interval=None,
1544
123
               periodic_interval=None):
1545
124
        """Instantiates class and passes back application object.
1546
125
1547
126
        Args:
1548
127
            host, defaults to FLAGS.host
1549
128
            binary, defaults to basename of executable
1550
129
            topic, defaults to bin_name - "nova-" part
1551
130
            manager, defaults to FLAGS.<topic>_manager
1552
131
            report_interval, defaults to FLAGS.report_interval
1553
132
            periodic_interval, defaults to FLAGS.periodic_interval
1554
133
        """
1555
134
        if not host:
1556
135
            host = FLAGS.host
1557
136
        if not binary:
1558
137
            binary = os.path.basename(inspect.stack()[-1][1])
1559
138
        if not topic:
1560
139
            topic = binary.rpartition("nova-")[2]
1561
140
        if not manager:
1562
141
            manager = FLAGS.get('%s_manager' % topic, None)
1563
142
        if not report_interval:
1564
143
            report_interval = FLAGS.report_interval
1565
144
        if not periodic_interval:
1566
145
            periodic_interval = FLAGS.periodic_interval
1567
146
        logging.warn("Starting %s node", topic)
1568
147
        service_obj = cls(host, binary, topic, manager,
1569
148
                          report_interval, periodic_interval)
1570
149
1571
150
        # This is the parent service that twistd will be looking for when it
1572
151
        # parses this file, return it so that we can get it into globals.
1573
152
        application = service.Application(binary)
1574
153
        service_obj.setServiceParent(application)
1575
154
        return application
1576
155
1577
156
    def kill(self):
1578
157
        """Destroy the service object in the datastore"""
1579
158
        try:
1580
159
            db.service_destroy(context.get_admin_context(), self.service_id)
1581
160
        except exception.NotFound:
1582
161
            logging.warn("Service killed that has no database entry")
1583
162
1584
163
    @defer.inlineCallbacks
1585
164
    def periodic_tasks(self):
1586
165
        """Tasks to be run at a periodic interval"""
1587
166
        yield self.manager.periodic_tasks(context.get_admin_context())
1588
167
1589
168
    @defer.inlineCallbacks
1590
169
    def report_state(self):
1591
170
        """Update the state of this service in the datastore."""
1592
171
        ctxt = context.get_admin_context()
1593
172
        try:
1594
173
            try:
1595
174
                service_ref = db.service_get(ctxt, self.service_id)
1596
175
            except exception.NotFound:
1597
176
                logging.debug("The service database object disappeared, "
1598
177
                              "Recreating it.")
1599
178
                self._create_service_ref(ctxt)
1600
179
                service_ref = db.service_get(ctxt, self.service_id)
1601
180
1602
181
            db.service_update(ctxt,
1603
182
                             self.service_id,
1604
183
                             {'report_count': service_ref['report_count'] + 1})
1605
184
1606
185
            # TODO(termie): make this pattern be more elegant.
1607
186
            if getattr(self, "model_disconnected", False):
1608
187
                self.model_disconnected = False
1609
188
                logging.error("Recovered model server connection!")
1610
189
1611
190
        # TODO(vish): this should probably only catch connection errors
1612
191
        except Exception:  # pylint: disable-msg=W0702
1613
192
            if not getattr(self, "model_disconnected", False):
1614
193
                self.model_disconnected = True
1615
194
                logging.exception("model server went away")
1616
195
        yield
1617
196
0
1618
=== modified file 'nova/test.py'
1619
--- nova/test.py	2010-10-26 15:48:20 +0000
1620
+++ nova/test.py	2010-12-16 20:49:10 +0000
1621
@@ -25,11 +25,12 @@
1622
25
import datetime
25
import datetime
1623
26
import sys
26
import sys
1624
27
import time
27
import time
1625
28
import unittest
1626
28
29
1627
29
import mox
30
import mox
1628
30
import stubout
31
import stubout
1629
31
from twisted.internet import defer
32
from twisted.internet import defer
1631
32
from twisted.trial import unittest
33
from twisted.trial import unittest as trial_unittest
1632
33
34
1633
34
from nova import context
35
from nova import context
1634
35
from nova import db
36
from nova import db
1635
@@ -55,7 +56,89 @@
1636
55
    return _skipper
56
    return _skipper
1637
56
57
1638
57
58
1640
58
class TrialTestCase(unittest.TestCase):
59
class TestCase(unittest.TestCase):
1641
60
    """Test case base class for all unit tests"""
1642
61
    def setUp(self):
1643
62
        """Run before each test method to initialize test environment"""
1644
63
        super(TestCase, self).setUp()
1645
64
        # NOTE(vish): We need a better method for creating fixtures for tests
1646
65
        #             now that we have some required db setup for the system
1647
66
        #             to work properly.
1648
67
        self.start = datetime.datetime.utcnow()
1649
68
        ctxt = context.get_admin_context()
1650
69
        if db.network_count(ctxt) != 5:
1651
70
            network_manager.VlanManager().create_networks(ctxt,
1652
71
                                                          FLAGS.fixed_range,
1653
72
                                                          5, 16,
1654
73
                                                          FLAGS.vlan_start,
1655
74
                                                          FLAGS.vpn_start)
1656
75
1657
76
        # emulate some of the mox stuff, we can't use the metaclass
1658
77
        # because it screws with our generators
1659
78
        self.mox = mox.Mox()
1660
79
        self.stubs = stubout.StubOutForTesting()
1661
80
        self.flag_overrides = {}
1662
81
        self.injected = []
1663
82
        self._monkey_patch_attach()
1664
83
        self._original_flags = FLAGS.FlagValuesDict()
1665
84
1666
85
    def tearDown(self):
1667
86
        """Runs after each test method to finalize/tear down test
1668
87
        environment."""
1669
88
        try:
1670
89
            self.mox.UnsetStubs()
1671
90
            self.stubs.UnsetAll()
1672
91
            self.stubs.SmartUnsetAll()
1673
92
            self.mox.VerifyAll()
1674
93
            # NOTE(vish): Clean up any ips associated during the test.
1675
94
            ctxt = context.get_admin_context()
1676
95
            db.fixed_ip_disassociate_all_by_timeout(ctxt, FLAGS.host,
1677
96
                                                    self.start)
1678
97
            db.network_disassociate_all(ctxt)
1679
98
            rpc.Consumer.attach_to_eventlet = self.originalAttach
1680
99
            for x in self.injected:
1681
100
                try:
1682
101
                    x.stop()
1683
102
                except AssertionError:
1684
103
                    pass
1685
104
1686
105
            if FLAGS.fake_rabbit:
1687
106
                fakerabbit.reset_all()
1688
107
1689
108
            db.security_group_destroy_all(ctxt)
1690
109
            super(TestCase, self).tearDown()
1691
110
        finally:
1692
111
            self.reset_flags()
1693
112
1694
113
    def flags(self, **kw):
1695
114
        """Override flag variables for a test"""
1696
115
        for k, v in kw.iteritems():
1697
116
            if k in self.flag_overrides:
1698
117
                self.reset_flags()
1699
118
                raise Exception(
1700
119
                        'trying to override already overriden flag: %s' % k)
1701
120
            self.flag_overrides[k] = getattr(FLAGS, k)
1702
121
            setattr(FLAGS, k, v)
1703
122
1704
123
    def reset_flags(self):
1705
124
        """Resets all flag variables for the test.  Runs after each test"""
1706
125
        FLAGS.Reset()
1707
126
        for k, v in self._original_flags.iteritems():
1708
127
            setattr(FLAGS, k, v)
1709
128
1710
129
    def _monkey_patch_attach(self):
1711
130
        self.originalAttach = rpc.Consumer.attach_to_eventlet
1712
131
1713
132
        def _wrapped(innerSelf):
1714
133
            rv = self.originalAttach(innerSelf)
1715
134
            self.injected.append(rv)
1716
135
            return rv
1717
136
1718
137
        _wrapped.func_name = self.originalAttach.func_name
1719
138
        rpc.Consumer.attach_to_eventlet = _wrapped
1720
139
1721
140
1722
141
class TrialTestCase(trial_unittest.TestCase):
1723
59
    """Test case base class for all unit tests"""
142
    """Test case base class for all unit tests"""
1724
60
    def setUp(self):
143
    def setUp(self):
1725
61
        """Run before each test method to initialize test environment"""
144
        """Run before each test method to initialize test environment"""
1726
@@ -78,7 +161,6 @@
1727
78
        self.stubs = stubout.StubOutForTesting()
161
        self.stubs = stubout.StubOutForTesting()
1728
79
        self.flag_overrides = {}
162
        self.flag_overrides = {}
1729
80
        self.injected = []
163
        self.injected = []
1730
81
        self._monkey_patch_attach()
1731
82
        self._original_flags = FLAGS.FlagValuesDict()
164
        self._original_flags = FLAGS.FlagValuesDict()
1732
83
165
1733
84
    def tearDown(self):
166
    def tearDown(self):
1734
@@ -94,7 +176,6 @@
1735
94
            db.fixed_ip_disassociate_all_by_timeout(ctxt, FLAGS.host,
176
            db.fixed_ip_disassociate_all_by_timeout(ctxt, FLAGS.host,
1736
95
                                                    self.start)
177
                                                    self.start)
1737
96
            db.network_disassociate_all(ctxt)
178
            db.network_disassociate_all(ctxt)
1738
97
            rpc.Consumer.attach_to_twisted = self.originalAttach
1739
98
            for x in self.injected:
179
            for x in self.injected:
1740
99
                try:
180
                try:
1741
100
                    x.stop()
181
                    x.stop()
1742
@@ -147,14 +228,3 @@
1743
147
            return d
228
            return d
1744
148
        _wrapped.func_name = func.func_name
229
        _wrapped.func_name = func.func_name
1745
149
        return _wrapped
230
        return _wrapped
1746
150
1747
151
    def _monkey_patch_attach(self):
1748
152
        self.originalAttach = rpc.Consumer.attach_to_twisted
1749
153
1750
154
        def _wrapped(innerSelf):
1751
155
            rv = self.originalAttach(innerSelf)
1752
156
            self.injected.append(rv)
1753
157
            return rv
1754
158
1755
159
        _wrapped.func_name = self.originalAttach.func_name
1756
160
        rpc.Consumer.attach_to_twisted = _wrapped
1757
161
231
1758
=== modified file 'nova/tests/access_unittest.py'
1759
--- nova/tests/access_unittest.py	2010-10-22 07:48:27 +0000
1760
+++ nova/tests/access_unittest.py	2010-12-16 20:49:10 +0000
1761
@@ -35,7 +35,7 @@
1762
35
    pass
35
    pass
1763
36
36
1764
37
37
1766
38
class AccessTestCase(test.TrialTestCase):
38
class AccessTestCase(test.TestCase):
1767
39
    def setUp(self):
39
    def setUp(self):
1768
40
        super(AccessTestCase, self).setUp()
40
        super(AccessTestCase, self).setUp()
1769
41
        um = manager.AuthManager()
41
        um = manager.AuthManager()
1770
42
42
1771
=== modified file 'nova/tests/auth_unittest.py'
1772
--- nova/tests/auth_unittest.py	2010-10-22 07:48:27 +0000
1773
+++ nova/tests/auth_unittest.py	2010-12-16 20:49:10 +0000
1774
@@ -326,12 +326,12 @@
1775
326
            self.assertTrue(user.is_admin())
326
            self.assertTrue(user.is_admin())
1776
327
327
1777
328
328
1779
329
class AuthManagerLdapTestCase(AuthManagerTestCase, test.TrialTestCase):
329
class AuthManagerLdapTestCase(AuthManagerTestCase, test.TestCase):
1780
330
    auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
330
    auth_driver = 'nova.auth.ldapdriver.FakeLdapDriver'
1781
331
331
1782
332
    def __init__(self, *args, **kwargs):
332
    def __init__(self, *args, **kwargs):
1783
333
        AuthManagerTestCase.__init__(self)
333
        AuthManagerTestCase.__init__(self)
1785
334
        test.TrialTestCase.__init__(self, *args, **kwargs)
334
        test.TestCase.__init__(self, *args, **kwargs)
1786
335
        import nova.auth.fakeldap as fakeldap
335
        import nova.auth.fakeldap as fakeldap
1787
336
        FLAGS.redis_db = 8
336
        FLAGS.redis_db = 8
1788
337
        if FLAGS.flush_db:
337
        if FLAGS.flush_db:
1789
@@ -343,7 +343,7 @@
1790
343
                self.skip = True
343
                self.skip = True
1791
344
344
1792
345
345
1794
346
class AuthManagerDbTestCase(AuthManagerTestCase, test.TrialTestCase):
346
class AuthManagerDbTestCase(AuthManagerTestCase, test.TestCase):
1795
347
    auth_driver = 'nova.auth.dbdriver.DbDriver'
347
    auth_driver = 'nova.auth.dbdriver.DbDriver'
1796
348
348
1797
349
349
1798
350
350
1799
=== modified file 'nova/tests/cloud_unittest.py'
1800
--- nova/tests/cloud_unittest.py	2010-12-09 17:30:03 +0000
1801
+++ nova/tests/cloud_unittest.py	2010-12-16 20:49:10 +0000
1802
@@ -27,8 +27,6 @@
1803
27
import time
27
import time
1804
28
28
1805
29
from eventlet import greenthread
29
from eventlet import greenthread
1806
30
from twisted.internet import defer
1807
31
import unittest
1808
32
from xml.etree import ElementTree
30
from xml.etree import ElementTree
1809
33
31
1810
34
from nova import context
32
from nova import context
1811
@@ -53,7 +51,7 @@
1812
53
os.makedirs(IMAGES_PATH)
51
os.makedirs(IMAGES_PATH)
1813
54
52
1814
55
53
1816
56
class CloudTestCase(test.TrialTestCase):
54
class CloudTestCase(test.TestCase):
1817
57
    def setUp(self):
55
    def setUp(self):
1818
58
        super(CloudTestCase, self).setUp()
56
        super(CloudTestCase, self).setUp()
1819
59
        self.flags(connection_type='fake', images_path=IMAGES_PATH)
57
        self.flags(connection_type='fake', images_path=IMAGES_PATH)
1820
@@ -199,7 +197,7 @@
1821
199
        logging.debug("Need to watch instance %s until it's running..." %
197
        logging.debug("Need to watch instance %s until it's running..." %
1822
200
                      instance['instance_id'])
198
                      instance['instance_id'])
1823
201
        while True:
199
        while True:
1825
202
            rv = yield defer.succeed(time.sleep(1))
200
            greenthread.sleep(1)
1826
203
            info = self.cloud._get_instance(instance['instance_id'])
201
            info = self.cloud._get_instance(instance['instance_id'])
1827
204
            logging.debug(info['state'])
202
            logging.debug(info['state'])
1828
205
            if info['state'] == power_state.RUNNING:
203
            if info['state'] == power_state.RUNNING:
1829
206
204
1830
=== modified file 'nova/tests/compute_unittest.py'
1831
--- nova/tests/compute_unittest.py	2010-12-03 20:21:18 +0000
1832
+++ nova/tests/compute_unittest.py	2010-12-16 20:49:10 +0000
1833
@@ -22,8 +22,6 @@
1834
22
import datetime
22
import datetime
1835
23
import logging
23
import logging
1836
24
24
1837
25
from twisted.internet import defer
1838
26
1839
27
from nova import context
25
from nova import context
1840
28
from nova import db
26
from nova import db
1841
29
from nova import exception
27
from nova import exception
1842
@@ -33,10 +31,11 @@
1843
33
from nova.auth import manager
31
from nova.auth import manager
1844
34
from nova.compute import api as compute_api
32
from nova.compute import api as compute_api
1845
35
33
1846
34
1847
36
FLAGS = flags.FLAGS
35
FLAGS = flags.FLAGS
1848
37
36
1849
38
37
1851
39
class ComputeTestCase(test.TrialTestCase):
38
class ComputeTestCase(test.TestCase):
1852
40
    """Test case for compute"""
39
    """Test case for compute"""
1853
41
    def setUp(self):
40
    def setUp(self):
1854
42
        logging.getLogger().setLevel(logging.DEBUG)
41
        logging.getLogger().setLevel(logging.DEBUG)
1855
@@ -94,24 +93,22 @@
1856
94
            db.security_group_destroy(self.context, group['id'])
93
            db.security_group_destroy(self.context, group['id'])
1857
95
            db.instance_destroy(self.context, ref[0]['id'])
94
            db.instance_destroy(self.context, ref[0]['id'])
1858
96
95
1859
97
    @defer.inlineCallbacks
1860
98
    def test_run_terminate(self):
96
    def test_run_terminate(self):
1861
99
        """Make sure it is possible to  run and terminate instance"""
97
        """Make sure it is possible to  run and terminate instance"""
1862
100
        instance_id = self._create_instance()
98
        instance_id = self._create_instance()
1863
101
99
1865
102
        yield self.compute.run_instance(self.context, instance_id)
100
        self.compute.run_instance(self.context, instance_id)
1866
103
101
1867
104
        instances = db.instance_get_all(context.get_admin_context())
102
        instances = db.instance_get_all(context.get_admin_context())
1868
105
        logging.info("Running instances: %s", instances)
103
        logging.info("Running instances: %s", instances)
1869
106
        self.assertEqual(len(instances), 1)
104
        self.assertEqual(len(instances), 1)
1870
107
105
1872
108
        yield self.compute.terminate_instance(self.context, instance_id)
106
        self.compute.terminate_instance(self.context, instance_id)
1873
109
107
1874
110
        instances = db.instance_get_all(context.get_admin_context())
108
        instances = db.instance_get_all(context.get_admin_context())
1875
111
        logging.info("After terminating instances: %s", instances)
109
        logging.info("After terminating instances: %s", instances)
1876
112
        self.assertEqual(len(instances), 0)
110
        self.assertEqual(len(instances), 0)
1877
113
111
1878
114
    @defer.inlineCallbacks
1879
115
    def test_run_terminate_timestamps(self):
112
    def test_run_terminate_timestamps(self):
1880
116
        """Make sure timestamps are set for launched and destroyed"""
113
        """Make sure timestamps are set for launched and destroyed"""
1881
117
        instance_id = self._create_instance()
114
        instance_id = self._create_instance()
1882
@@ -119,42 +116,40 @@
1883
119
        self.assertEqual(instance_ref['launched_at'], None)
116
        self.assertEqual(instance_ref['launched_at'], None)
1884
120
        self.assertEqual(instance_ref['deleted_at'], None)
117
        self.assertEqual(instance_ref['deleted_at'], None)
1885
121
        launch = datetime.datetime.utcnow()
118
        launch = datetime.datetime.utcnow()
1887
122
        yield self.compute.run_instance(self.context, instance_id)
119
        self.compute.run_instance(self.context, instance_id)
1888
123
        instance_ref = db.instance_get(self.context, instance_id)
120
        instance_ref = db.instance_get(self.context, instance_id)
1889
124
        self.assert_(instance_ref['launched_at'] > launch)
121
        self.assert_(instance_ref['launched_at'] > launch)
1890
125
        self.assertEqual(instance_ref['deleted_at'], None)
122
        self.assertEqual(instance_ref['deleted_at'], None)
1891
126
        terminate = datetime.datetime.utcnow()
123
        terminate = datetime.datetime.utcnow()
1893
127
        yield self.compute.terminate_instance(self.context, instance_id)
124
        self.compute.terminate_instance(self.context, instance_id)
1894
128
        self.context = self.context.elevated(True)
125
        self.context = self.context.elevated(True)
1895
129
        instance_ref = db.instance_get(self.context, instance_id)
126
        instance_ref = db.instance_get(self.context, instance_id)
1896
130
        self.assert_(instance_ref['launched_at'] < terminate)
127
        self.assert_(instance_ref['launched_at'] < terminate)
1897
131
        self.assert_(instance_ref['deleted_at'] > terminate)
128
        self.assert_(instance_ref['deleted_at'] > terminate)
1898
132
129
1899
133
    @defer.inlineCallbacks
1900
134
    def test_reboot(self):
130
    def test_reboot(self):
1901
135
        """Ensure instance can be rebooted"""
131
        """Ensure instance can be rebooted"""
1902
136
        instance_id = self._create_instance()
132
        instance_id = self._create_instance()
1906
137
        yield self.compute.run_instance(self.context, instance_id)
133
        self.compute.run_instance(self.context, instance_id)
1907
138
        yield self.compute.reboot_instance(self.context, instance_id)
134
        self.compute.reboot_instance(self.context, instance_id)
1908
139
        yield self.compute.terminate_instance(self.context, instance_id)
135
        self.compute.terminate_instance(self.context, instance_id)
1909
140
136
1910
141
    @defer.inlineCallbacks
1911
142
    def test_console_output(self):
137
    def test_console_output(self):
1912
143
        """Make sure we can get console output from instance"""
138
        """Make sure we can get console output from instance"""
1913
144
        instance_id = self._create_instance()
139
        instance_id = self._create_instance()
1915
145
        yield self.compute.run_instance(self.context, instance_id)
140
        self.compute.run_instance(self.context, instance_id)
1916
146
141
1918
147
        console = yield self.compute.get_console_output(self.context,
142
        console = self.compute.get_console_output(self.context,
1919
148
                                                        instance_id)
143
                                                        instance_id)
1920
149
        self.assert_(console)
144
        self.assert_(console)
1922
150
        yield self.compute.terminate_instance(self.context, instance_id)
145
        self.compute.terminate_instance(self.context, instance_id)
1923
151
146
1924
152
    @defer.inlineCallbacks
1925
153
    def test_run_instance_existing(self):
147
    def test_run_instance_existing(self):
1926
154
        """Ensure failure when running an instance that already exists"""
148
        """Ensure failure when running an instance that already exists"""
1927
155
        instance_id = self._create_instance()
149
        instance_id = self._create_instance()
1933
156
        yield self.compute.run_instance(self.context, instance_id)
150
        self.compute.run_instance(self.context, instance_id)
1934
157
        self.assertFailure(self.compute.run_instance(self.context,
151
        self.assertRaises(exception.Error,
1935
158
                                                     instance_id),
152
                          self.compute.run_instance,
1936
159
                           exception.Error)
153
                          self.context,
1937
160
        yield self.compute.terminate_instance(self.context, instance_id)
154
                          instance_id)
1938
155
        self.compute.terminate_instance(self.context, instance_id)
1939
161
156
1940
=== modified file 'nova/tests/flags_unittest.py'
1941
--- nova/tests/flags_unittest.py	2010-10-22 07:48:27 +0000
1942
+++ nova/tests/flags_unittest.py	2010-12-16 20:49:10 +0000
1943
@@ -24,7 +24,7 @@
1944
24
flags.DEFINE_string('flags_unittest', 'foo', 'for testing purposes only')
24
flags.DEFINE_string('flags_unittest', 'foo', 'for testing purposes only')
1945
25
25
1946
26
26
1948
27
class FlagsTestCase(test.TrialTestCase):
27
class FlagsTestCase(test.TestCase):
1949
28
28
1950
29
    def setUp(self):
29
    def setUp(self):
1951
30
        super(FlagsTestCase, self).setUp()
30
        super(FlagsTestCase, self).setUp()
1952
31
31
1953
=== modified file 'nova/tests/misc_unittest.py'
1954
--- nova/tests/misc_unittest.py	2010-12-15 10:57:56 +0000
1955
+++ nova/tests/misc_unittest.py	2010-12-16 20:49:10 +0000
1956
@@ -20,7 +20,7 @@
1957
20
from nova.utils import parse_mailmap, str_dict_replace
20
from nova.utils import parse_mailmap, str_dict_replace
1958
21
21
1959
22
22
1961
23
class ProjectTestCase(test.TrialTestCase):
23
class ProjectTestCase(test.TestCase):
1962
24
    def test_authors_up_to_date(self):
24
    def test_authors_up_to_date(self):
1963
25
        if os.path.exists('../.bzr'):
25
        if os.path.exists('../.bzr'):
1964
26
            contributors = set()
26
            contributors = set()
1965
27
27
1966
=== modified file 'nova/tests/network_unittest.py'
1967
--- nova/tests/network_unittest.py	2010-11-17 02:23:20 +0000
1968
+++ nova/tests/network_unittest.py	2010-12-16 20:49:10 +0000
1969
@@ -33,7 +33,7 @@
1970
33
FLAGS = flags.FLAGS
33
FLAGS = flags.FLAGS
1971
34
34
1972
35
35
1974
36
class NetworkTestCase(test.TrialTestCase):
36
class NetworkTestCase(test.TestCase):
1975
37
    """Test cases for network code"""
37
    """Test cases for network code"""
1976
38
    def setUp(self):
38
    def setUp(self):
1977
39
        super(NetworkTestCase, self).setUp()
39
        super(NetworkTestCase, self).setUp()
1978
40
40
1979
=== modified file 'nova/tests/objectstore_unittest.py'
1980
--- nova/tests/objectstore_unittest.py	2010-10-22 07:48:27 +0000
1981
+++ nova/tests/objectstore_unittest.py	2010-12-16 20:49:10 +0000
1982
@@ -54,7 +54,7 @@
1983
54
os.makedirs(os.path.join(OSS_TEMPDIR, 'buckets'))
54
os.makedirs(os.path.join(OSS_TEMPDIR, 'buckets'))
1984
55
55
1985
56
56
1987
57
class ObjectStoreTestCase(test.TrialTestCase):
57
class ObjectStoreTestCase(test.TestCase):
1988
58
    """Test objectstore API directly."""
58
    """Test objectstore API directly."""
1989
59
59
1990
60
    def setUp(self):
60
    def setUp(self):
1991
@@ -191,7 +191,7 @@
1992
191
    protocol = TestHTTPChannel
191
    protocol = TestHTTPChannel
1993
192
192
1994
193
193
1996
194
class S3APITestCase(test.TrialTestCase):
194
class S3APITestCase(test.TestCase):
1997
195
    """Test objectstore through S3 API."""
195
    """Test objectstore through S3 API."""
1998
196
196
1999
197
    def setUp(self):
197
    def setUp(self):
2000
198
198
2001
=== removed file 'nova/tests/process_unittest.py'
2002
--- nova/tests/process_unittest.py	2010-10-22 07:48:27 +0000
2003
+++ nova/tests/process_unittest.py	1970-01-01 00:00:00 +0000
2004
@@ -1,132 +0,0 @@
2005
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2006
2
2007
3
# Copyright 2010 United States Government as represented by the
2008
4
# Administrator of the National Aeronautics and Space Administration.
2009
5
# All Rights Reserved.
2010
6
#
2011
7
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
2012
8
#    not use this file except in compliance with the License. You may obtain
2013
9
#    a copy of the License at
2014
10
#
2015
11
#         http://www.apache.org/licenses/LICENSE-2.0
2016
12
#
2017
13
#    Unless required by applicable law or agreed to in writing, software
2018
14
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
2019
15
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
2020
16
#    License for the specific language governing permissions and limitations
2021
17
#    under the License.
2022
18
2023
19
import logging
2024
20
from twisted.internet import defer
2025
21
from twisted.internet import reactor
2026
22
from xml.etree import ElementTree
2027
23
2028
24
from nova import exception
2029
25
from nova import flags
2030
26
from nova import process
2031
27
from nova import test
2032
28
from nova import utils
2033
29
2034
30
FLAGS = flags.FLAGS
2035
31
2036
32
2037
33
class ProcessTestCase(test.TrialTestCase):
2038
34
    def setUp(self):
2039
35
        logging.getLogger().setLevel(logging.DEBUG)
2040
36
        super(ProcessTestCase, self).setUp()
2041
37
2042
38
    def test_execute_stdout(self):
2043
39
        pool = process.ProcessPool(2)
2044
40
        d = pool.simple_execute('echo test')
2045
41
2046
42
        def _check(rv):
2047
43
            self.assertEqual(rv[0], 'test\n')
2048
44
            self.assertEqual(rv[1], '')
2049
45
2050
46
        d.addCallback(_check)
2051
47
        d.addErrback(self.fail)
2052
48
        return d
2053
49
2054
50
    def test_execute_stderr(self):
2055
51
        pool = process.ProcessPool(2)
2056
52
        d = pool.simple_execute('cat BAD_FILE', check_exit_code=False)
2057
53
2058
54
        def _check(rv):
2059
55
            self.assertEqual(rv[0], '')
2060
56
            self.assert_('No such file' in rv[1])
2061
57
2062
58
        d.addCallback(_check)
2063
59
        d.addErrback(self.fail)
2064
60
        return d
2065
61
2066
62
    def test_execute_unexpected_stderr(self):
2067
63
        pool = process.ProcessPool(2)
2068
64
        d = pool.simple_execute('cat BAD_FILE')
2069
65
        d.addCallback(lambda x: self.fail('should have raised an error'))
2070
66
        d.addErrback(lambda failure: failure.trap(IOError))
2071
67
        return d
2072
68
2073
69
    def test_max_processes(self):
2074
70
        pool = process.ProcessPool(2)
2075
71
        d1 = pool.simple_execute('sleep 0.01')
2076
72
        d2 = pool.simple_execute('sleep 0.01')
2077
73
        d3 = pool.simple_execute('sleep 0.005')
2078
74
        d4 = pool.simple_execute('sleep 0.005')
2079
75
2080
76
        called = []
2081
77
2082
78
        def _called(rv, name):
2083
79
            called.append(name)
2084
80
2085
81
        d1.addCallback(_called, 'd1')
2086
82
        d2.addCallback(_called, 'd2')
2087
83
        d3.addCallback(_called, 'd3')
2088
84
        d4.addCallback(_called, 'd4')
2089
85
2090
86
        # Make sure that d3 and d4 had to wait on the other two and were called
2091
87
        # in order
2092
88
        # NOTE(termie): there may be a race condition in this test if for some
2093
89
        #               reason one of the sleeps takes longer to complete
2094
90
        #               than it should
2095
91
        d4.addCallback(lambda x: self.assertEqual(called[2], 'd3'))
2096
92
        d4.addCallback(lambda x: self.assertEqual(called[3], 'd4'))
2097
93
        d4.addErrback(self.fail)
2098
94
        return d4
2099
95
2100
96
    def test_kill_long_process(self):
2101
97
        pool = process.ProcessPool(2)
2102
98
2103
99
        d1 = pool.simple_execute('sleep 1')
2104
100
        d2 = pool.simple_execute('sleep 0.005')
2105
101
2106
102
        timeout = reactor.callLater(0.1, self.fail, 'should have been killed')
2107
103
2108
104
        # kill d1 and wait on it to end then cancel the timeout
2109
105
        d2.addCallback(lambda _: d1.process.signalProcess('KILL'))
2110
106
        d2.addCallback(lambda _: d1)
2111
107
        d2.addBoth(lambda _: timeout.active() and timeout.cancel())
2112
108
        d2.addErrback(self.fail)
2113
109
        return d2
2114
110
2115
111
    def test_process_exit_is_contained(self):
2116
112
        pool = process.ProcessPool(2)
2117
113
2118
114
        d1 = pool.simple_execute('sleep 1')
2119
115
        d1.addCallback(lambda x: self.fail('should have errbacked'))
2120
116
        d1.addErrback(lambda fail: fail.trap(IOError))
2121
117
        reactor.callLater(0.05, d1.process.signalProcess, 'KILL')
2122
118
2123
119
        return d1
2124
120
2125
121
    def test_shared_pool_is_singleton(self):
2126
122
        pool1 = process.SharedPool()
2127
123
        pool2 = process.SharedPool()
2128
124
        self.assertEqual(id(pool1._instance), id(pool2._instance))
2129
125
2130
126
    def test_shared_pool_works_as_singleton(self):
2131
127
        d1 = process.simple_execute('sleep 1')
2132
128
        d2 = process.simple_execute('sleep 0.005')
2133
129
        # lp609749: would have failed with
2134
130
        # exceptions.AssertionError: Someone released me too many times:
2135
131
        # too many tokens!
2136
132
        return d1
2137
133
0
2138
=== modified file 'nova/tests/quota_unittest.py'
2139
--- nova/tests/quota_unittest.py	2010-11-24 22:52:10 +0000
2140
+++ nova/tests/quota_unittest.py	2010-12-16 20:49:10 +0000
2141
@@ -32,7 +32,7 @@
2142
32
FLAGS = flags.FLAGS
32
FLAGS = flags.FLAGS
2143
33
33
2144
34
34
2146
35
class QuotaTestCase(test.TrialTestCase):
35
class QuotaTestCase(test.TestCase):
2147
36
    def setUp(self):
36
    def setUp(self):
2148
37
        logging.getLogger().setLevel(logging.DEBUG)
37
        logging.getLogger().setLevel(logging.DEBUG)
2149
38
        super(QuotaTestCase, self).setUp()
38
        super(QuotaTestCase, self).setUp()
2150
39
39
2151
=== modified file 'nova/tests/rpc_unittest.py'
2152
--- nova/tests/rpc_unittest.py	2010-10-22 07:48:27 +0000
2153
+++ nova/tests/rpc_unittest.py	2010-12-16 20:49:10 +0000
2154
@@ -20,8 +20,6 @@
2155
20
"""
20
"""
2156
21
import logging
21
import logging
2157
22
22
2158
23
from twisted.internet import defer
2159
24
2160
25
from nova import context
23
from nova import context
2161
26
from nova import flags
24
from nova import flags
2162
27
from nova import rpc
25
from nova import rpc
2163
@@ -31,7 +29,7 @@
2164
31
FLAGS = flags.FLAGS
29
FLAGS = flags.FLAGS
2165
32
30
2166
33
31
2168
34
class RpcTestCase(test.TrialTestCase):
32
class RpcTestCase(test.TestCase):
2169
35
    """Test cases for rpc"""
33
    """Test cases for rpc"""
2170
36
    def setUp(self):
34
    def setUp(self):
2171
37
        super(RpcTestCase, self).setUp()
35
        super(RpcTestCase, self).setUp()
2172
@@ -40,23 +38,22 @@
2173
40
        self.consumer = rpc.AdapterConsumer(connection=self.conn,
38
        self.consumer = rpc.AdapterConsumer(connection=self.conn,
2174
41
                                            topic='test',
39
                                            topic='test',
2175
42
                                            proxy=self.receiver)
40
                                            proxy=self.receiver)
2177
43
        self.consumer.attach_to_twisted()
41
        self.consumer.attach_to_eventlet()
2178
44
        self.context = context.get_admin_context()
42
        self.context = context.get_admin_context()
2179
45
43
2180
46
    def test_call_succeed(self):
44
    def test_call_succeed(self):
2181
47
        """Get a value through rpc call"""
45
        """Get a value through rpc call"""
2182
48
        value = 42
46
        value = 42
2185
49
        result = yield rpc.call_twisted(self.context,
47
        result = rpc.call(self.context, 'test', {"method": "echo",
2184
50
                                        'test', {"method": "echo",
2186
51
                                                 "args": {"value": value}})
48
                                                 "args": {"value": value}})
2187
52
        self.assertEqual(value, result)
49
        self.assertEqual(value, result)
2188
53
50
2189
54
    def test_context_passed(self):
51
    def test_context_passed(self):
2190
55
        """Makes sure a context is passed through rpc call"""
52
        """Makes sure a context is passed through rpc call"""
2191
56
        value = 42
53
        value = 42
2195
57
        result = yield rpc.call_twisted(self.context,
54
        result = rpc.call(self.context,
2196
58
                                        'test', {"method": "context",
55
                          'test', {"method": "context",
2197
59
                                                 "args": {"value": value}})
56
                                   "args": {"value": value}})
2198
60
        self.assertEqual(self.context.to_dict(), result)
57
        self.assertEqual(self.context.to_dict(), result)
2199
61
58
2200
62
    def test_call_exception(self):
59
    def test_call_exception(self):
2201
@@ -67,14 +64,17 @@
2202
67
        to an int in the test.
64
        to an int in the test.
2203
68
        """
65
        """
2204
69
        value = 42
66
        value = 42
2209
70
        self.assertFailure(rpc.call_twisted(self.context, 'test',
67
        self.assertRaises(rpc.RemoteError,
2210
71
                                            {"method": "fail",
68
                          rpc.call,
2211
72
                                             "args": {"value": value}}),
69
                          self.context,
2212
73
                           rpc.RemoteError)
70
                          'test',
2213
71
                          {"method": "fail",
2214
72
                           "args": {"value": value}})
2215
74
        try:
73
        try:
2219
75
            yield rpc.call_twisted(self.context,
74
            rpc.call(self.context,
2220
76
                                   'test', {"method": "fail",
75
                     'test',
2221
77
                                            "args": {"value": value}})
76
                     {"method": "fail",
2222
77
                      "args": {"value": value}})
2223
78
            self.fail("should have thrown rpc.RemoteError")
78
            self.fail("should have thrown rpc.RemoteError")
2224
79
        except rpc.RemoteError as exc:
79
        except rpc.RemoteError as exc:
2225
80
            self.assertEqual(int(exc.value), value)
80
            self.assertEqual(int(exc.value), value)
2226
@@ -89,13 +89,13 @@
2227
89
    def echo(context, value):
89
    def echo(context, value):
2228
90
        """Simply returns whatever value is sent in"""
90
        """Simply returns whatever value is sent in"""
2229
91
        logging.debug("Received %s", value)
91
        logging.debug("Received %s", value)
2231
92
        return defer.succeed(value)
92
        return value
2232
93
93
2233
94
    @staticmethod
94
    @staticmethod
2234
95
    def context(context, value):
95
    def context(context, value):
2235
96
        """Returns dictionary version of context"""
96
        """Returns dictionary version of context"""
2236
97
        logging.debug("Received %s", context)
97
        logging.debug("Received %s", context)
2238
98
        return defer.succeed(context.to_dict())
98
        return context.to_dict()
2239
99
99
2240
100
    @staticmethod
100
    @staticmethod
2241
101
    def fail(context, value):
101
    def fail(context, value):
2242
102
102
2243
=== modified file 'nova/tests/scheduler_unittest.py'
2244
--- nova/tests/scheduler_unittest.py	2010-10-26 06:37:51 +0000
2245
+++ nova/tests/scheduler_unittest.py	2010-12-16 20:49:10 +0000
2246
@@ -44,7 +44,7 @@
2247
44
        return 'named_host'
44
        return 'named_host'
2248
45
45
2249
46
46
2251
47
class SchedulerTestCase(test.TrialTestCase):
47
class SchedulerTestCase(test.TestCase):
2252
48
    """Test case for scheduler"""
48
    """Test case for scheduler"""
2253
49
    def setUp(self):
49
    def setUp(self):
2254
50
        super(SchedulerTestCase, self).setUp()
50
        super(SchedulerTestCase, self).setUp()
2255
@@ -73,7 +73,7 @@
2256
73
        scheduler.named_method(ctxt, 'topic', num=7)
73
        scheduler.named_method(ctxt, 'topic', num=7)
2257
74
74
2258
75
75
2260
76
class SimpleDriverTestCase(test.TrialTestCase):
76
class SimpleDriverTestCase(test.TestCase):
2261
77
    """Test case for simple driver"""
77
    """Test case for simple driver"""
2262
78
    def setUp(self):
78
    def setUp(self):
2263
79
        super(SimpleDriverTestCase, self).setUp()
79
        super(SimpleDriverTestCase, self).setUp()
2264
@@ -122,12 +122,12 @@
2265
122
                                   'nova-compute',
122
                                   'nova-compute',
2266
123
                                   'compute',
123
                                   'compute',
2267
124
                                   FLAGS.compute_manager)
124
                                   FLAGS.compute_manager)
2269
125
        compute1.startService()
125
        compute1.start()
2270
126
        compute2 = service.Service('host2',
126
        compute2 = service.Service('host2',
2271
127
                                   'nova-compute',
127
                                   'nova-compute',
2272
128
                                   'compute',
128
                                   'compute',
2273
129
                                   FLAGS.compute_manager)
129
                                   FLAGS.compute_manager)
2275
130
        compute2.startService()
130
        compute2.start()
2276
131
        hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
131
        hosts = self.scheduler.driver.hosts_up(self.context, 'compute')
2277
132
        self.assertEqual(len(hosts), 2)
132
        self.assertEqual(len(hosts), 2)
2278
133
        compute1.kill()
133
        compute1.kill()
2279
@@ -139,12 +139,12 @@
2280
139
                                   'nova-compute',
139
                                   'nova-compute',
2281
140
                                   'compute',
140
                                   'compute',
2282
141
                                   FLAGS.compute_manager)
141
                                   FLAGS.compute_manager)
2284
142
        compute1.startService()
142
        compute1.start()
2285
143
        compute2 = service.Service('host2',
143
        compute2 = service.Service('host2',
2286
144
                                   'nova-compute',
144
                                   'nova-compute',
2287
145
                                   'compute',
145
                                   'compute',
2288
146
                                   FLAGS.compute_manager)
146
                                   FLAGS.compute_manager)
2290
147
        compute2.startService()
147
        compute2.start()
2291
148
        instance_id1 = self._create_instance()
148
        instance_id1 = self._create_instance()
2292
149
        compute1.run_instance(self.context, instance_id1)
149
        compute1.run_instance(self.context, instance_id1)
2293
150
        instance_id2 = self._create_instance()
150
        instance_id2 = self._create_instance()
2294
@@ -162,12 +162,12 @@
2295
162
                                   'nova-compute',
162
                                   'nova-compute',
2296
163
                                   'compute',
163
                                   'compute',
2297
164
                                   FLAGS.compute_manager)
164
                                   FLAGS.compute_manager)
2299
165
        compute1.startService()
165
        compute1.start()
2300
166
        compute2 = service.Service('host2',
166
        compute2 = service.Service('host2',
2301
167
                                   'nova-compute',
167
                                   'nova-compute',
2302
168
                                   'compute',
168
                                   'compute',
2303
169
                                   FLAGS.compute_manager)
169
                                   FLAGS.compute_manager)
2305
170
        compute2.startService()
170
        compute2.start()
2306
171
        instance_ids1 = []
171
        instance_ids1 = []
2307
172
        instance_ids2 = []
172
        instance_ids2 = []
2308
173
        for index in xrange(FLAGS.max_cores):
173
        for index in xrange(FLAGS.max_cores):
2309
@@ -195,12 +195,12 @@
2310
195
                                   'nova-volume',
195
                                   'nova-volume',
2311
196
                                   'volume',
196
                                   'volume',
2312
197
                                   FLAGS.volume_manager)
197
                                   FLAGS.volume_manager)
2314
198
        volume1.startService()
198
        volume1.start()
2315
199
        volume2 = service.Service('host2',
199
        volume2 = service.Service('host2',
2316
200
                                   'nova-volume',
200
                                   'nova-volume',
2317
201
                                   'volume',
201
                                   'volume',
2318
202
                                   FLAGS.volume_manager)
202
                                   FLAGS.volume_manager)
2320
203
        volume2.startService()
203
        volume2.start()
2321
204
        volume_id1 = self._create_volume()
204
        volume_id1 = self._create_volume()
2322
205
        volume1.create_volume(self.context, volume_id1)
205
        volume1.create_volume(self.context, volume_id1)
2323
206
        volume_id2 = self._create_volume()
206
        volume_id2 = self._create_volume()
2324
@@ -218,12 +218,12 @@
2325
218
                                   'nova-volume',
218
                                   'nova-volume',
2326
219
                                   'volume',
219
                                   'volume',
2327
220
                                   FLAGS.volume_manager)
220
                                   FLAGS.volume_manager)
2329
221
        volume1.startService()
221
        volume1.start()
2330
222
        volume2 = service.Service('host2',
222
        volume2 = service.Service('host2',
2331
223
                                   'nova-volume',
223
                                   'nova-volume',
2332
224
                                   'volume',
224
                                   'volume',
2333
225
                                   FLAGS.volume_manager)
225
                                   FLAGS.volume_manager)
2335
226
        volume2.startService()
226
        volume2.start()
2336
227
        volume_ids1 = []
227
        volume_ids1 = []
2337
228
        volume_ids2 = []
228
        volume_ids2 = []
2338
229
        for index in xrange(FLAGS.max_gigabytes):
229
        for index in xrange(FLAGS.max_gigabytes):
2339
230
230
2340
=== modified file 'nova/tests/service_unittest.py'
2341
--- nova/tests/service_unittest.py	2010-10-26 06:08:57 +0000
2342
+++ nova/tests/service_unittest.py	2010-12-16 20:49:10 +0000
2343
@@ -22,9 +22,6 @@
2344
22
22
2345
23
import mox
23
import mox
2346
24
24
2347
25
from twisted.application.app import startApplication
2348
26
from twisted.internet import defer
2349
27
2350
28
from nova import exception
25
from nova import exception
2351
29
from nova import flags
26
from nova import flags
2352
30
from nova import rpc
27
from nova import rpc
2353
@@ -48,7 +45,7 @@
2354
48
        return 'service'
45
        return 'service'
2355
49
46
2356
50
47
2358
51
class ServiceManagerTestCase(test.TrialTestCase):
48
class ServiceManagerTestCase(test.TestCase):
2359
52
    """Test cases for Services"""
49
    """Test cases for Services"""
2360
53
50
2361
54
    def test_attribute_error_for_no_manager(self):
51
    def test_attribute_error_for_no_manager(self):
2362
@@ -63,7 +60,7 @@
2363
63
                               'test',
60
                               'test',
2364
64
                               'test',
61
                               'test',
2365
65
                               'nova.tests.service_unittest.FakeManager')
62
                               'nova.tests.service_unittest.FakeManager')
2367
66
        serv.startService()
63
        serv.start()
2368
67
        self.assertEqual(serv.test_method(), 'manager')
64
        self.assertEqual(serv.test_method(), 'manager')
2369
68
65
2370
69
    def test_override_manager_method(self):
66
    def test_override_manager_method(self):
2371
@@ -71,11 +68,11 @@
2372
71
                               'test',
68
                               'test',
2373
72
                               'test',
69
                               'test',
2374
73
                               'nova.tests.service_unittest.FakeManager')
70
                               'nova.tests.service_unittest.FakeManager')
2376
74
        serv.startService()
71
        serv.start()
2377
75
        self.assertEqual(serv.test_method(), 'service')
72
        self.assertEqual(serv.test_method(), 'service')
2378
76
73
2379
77
74
2381
78
class ServiceTestCase(test.TrialTestCase):
75
class ServiceTestCase(test.TestCase):
2382
79
    """Test cases for Services"""
76
    """Test cases for Services"""
2383
80
77
2384
81
    def setUp(self):
78
    def setUp(self):
2385
@@ -94,8 +91,6 @@
2386
94
        self.mox.StubOutWithMock(rpc,
91
        self.mox.StubOutWithMock(rpc,
2387
95
                                 'AdapterConsumer',
92
                                 'AdapterConsumer',
2388
96
                                 use_mock_anything=True)
93
                                 use_mock_anything=True)
2389
97
        self.mox.StubOutWithMock(
2390
98
                service.task, 'LoopingCall', use_mock_anything=True)
2391
99
        rpc.AdapterConsumer(connection=mox.IgnoreArg(),
94
        rpc.AdapterConsumer(connection=mox.IgnoreArg(),
2392
100
                            topic=topic,
95
                            topic=topic,
2393
101
                            proxy=mox.IsA(service.Service)).AndReturn(
96
                            proxy=mox.IsA(service.Service)).AndReturn(
2394
@@ -106,19 +101,8 @@
2395
106
                            proxy=mox.IsA(service.Service)).AndReturn(
101
                            proxy=mox.IsA(service.Service)).AndReturn(
2396
107
                                    rpc.AdapterConsumer)
102
                                    rpc.AdapterConsumer)
2397
108
103
2411
109
        rpc.AdapterConsumer.attach_to_twisted()
104
        rpc.AdapterConsumer.attach_to_eventlet()
2412
110
        rpc.AdapterConsumer.attach_to_twisted()
105
        rpc.AdapterConsumer.attach_to_eventlet()
2400
111
2401
112
        # Stub out looping call a bit needlessly since we don't have an easy
2402
113
        # way to cancel it (yet) when the tests finishes
2403
114
        service.task.LoopingCall(mox.IgnoreArg()).AndReturn(
2404
115
                        service.task.LoopingCall)
2405
116
        service.task.LoopingCall.start(interval=mox.IgnoreArg(),
2406
117
                                       now=mox.IgnoreArg())
2407
118
        service.task.LoopingCall(mox.IgnoreArg()).AndReturn(
2408
119
                        service.task.LoopingCall)
2409
120
        service.task.LoopingCall.start(interval=mox.IgnoreArg(),
2410
121
                                       now=mox.IgnoreArg())
2413
122
106
2414
123
        service_create = {'host': host,
107
        service_create = {'host': host,
2415
124
                          'binary': binary,
108
                          'binary': binary,
2416
@@ -136,14 +120,14 @@
2417
136
                                  service_create).AndReturn(service_ref)
120
                                  service_create).AndReturn(service_ref)
2418
137
        self.mox.ReplayAll()
121
        self.mox.ReplayAll()
2419
138
122
2421
139
        startApplication(app, False)
123
        app.start()
2422
124
        app.stop()
2423
140
        self.assert_(app)
125
        self.assert_(app)
2424
141
126
2425
142
    # We're testing sort of weird behavior in how report_state decides
127
    # We're testing sort of weird behavior in how report_state decides
2426
143
    # whether it is disconnected, it looks for a variable on itself called
128
    # whether it is disconnected, it looks for a variable on itself called
2427
144
    # 'model_disconnected' and report_state doesn't really do much so this
129
    # 'model_disconnected' and report_state doesn't really do much so this
2428
145
    # these are mostly just for coverage
130
    # these are mostly just for coverage
2429
146
    @defer.inlineCallbacks
2430
147
    def test_report_state_no_service(self):
131
    def test_report_state_no_service(self):
2431
148
        host = 'foo'
132
        host = 'foo'
2432
149
        binary = 'bar'
133
        binary = 'bar'
2433
@@ -173,10 +157,9 @@
2434
173
                               binary,
157
                               binary,
2435
174
                               topic,
158
                               topic,
2436
175
                               'nova.tests.service_unittest.FakeManager')
159
                               'nova.tests.service_unittest.FakeManager')
2439
176
        serv.startService()
160
        serv.start()
2440
177
        yield serv.report_state()
161
        serv.report_state()
2441
178
162
2442
179
    @defer.inlineCallbacks
2443
180
    def test_report_state_newly_disconnected(self):
163
    def test_report_state_newly_disconnected(self):
2444
181
        host = 'foo'
164
        host = 'foo'
2445
182
        binary = 'bar'
165
        binary = 'bar'
2446
@@ -204,11 +187,10 @@
2447
204
                               binary,
187
                               binary,
2448
205
                               topic,
188
                               topic,
2449
206
                               'nova.tests.service_unittest.FakeManager')
189
                               'nova.tests.service_unittest.FakeManager')
2452
207
        serv.startService()
190
        serv.start()
2453
208
        yield serv.report_state()
191
        serv.report_state()
2454
209
        self.assert_(serv.model_disconnected)
192
        self.assert_(serv.model_disconnected)
2455
210
193
2456
211
    @defer.inlineCallbacks
2457
212
    def test_report_state_newly_connected(self):
194
    def test_report_state_newly_connected(self):
2458
213
        host = 'foo'
195
        host = 'foo'
2459
214
        binary = 'bar'
196
        binary = 'bar'
2460
@@ -238,8 +220,8 @@
2461
238
                               binary,
220
                               binary,
2462
239
                               topic,
221
                               topic,
2463
240
                               'nova.tests.service_unittest.FakeManager')
222
                               'nova.tests.service_unittest.FakeManager')
2465
241
        serv.startService()
223
        serv.start()
2466
242
        serv.model_disconnected = True
224
        serv.model_disconnected = True
2468
243
        yield serv.report_state()
225
        serv.report_state()
2469
244
226
2470
245
        self.assert_(not serv.model_disconnected)
227
        self.assert_(not serv.model_disconnected)
2471
246
228
2472
=== removed file 'nova/tests/validator_unittest.py'
2473
--- nova/tests/validator_unittest.py	2010-10-22 07:48:27 +0000
2474
+++ nova/tests/validator_unittest.py	1970-01-01 00:00:00 +0000
2475
@@ -1,42 +0,0 @@
2476
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2477
2
2478
3
# Copyright 2010 United States Government as represented by the
2479
4
# Administrator of the National Aeronautics and Space Administration.
2480
5
# All Rights Reserved.
2481
6
#
2482
7
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
2483
8
#    not use this file except in compliance with the License. You may obtain
2484
9
#    a copy of the License at
2485
10
#
2486
11
#         http://www.apache.org/licenses/LICENSE-2.0
2487
12
#
2488
13
#    Unless required by applicable law or agreed to in writing, software
2489
14
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
2490
15
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
2491
16
#    License for the specific language governing permissions and limitations
2492
17
#    under the License.
2493
18
2494
19
import logging
2495
20
import unittest
2496
21
2497
22
from nova import flags
2498
23
from nova import test
2499
24
from nova import validate
2500
25
2501
26
2502
27
class ValidationTestCase(test.TrialTestCase):
2503
28
    def setUp(self):
2504
29
        super(ValidationTestCase, self).setUp()
2505
30
2506
31
    def tearDown(self):
2507
32
        super(ValidationTestCase, self).tearDown()
2508
33
2509
34
    def test_type_validation(self):
2510
35
        self.assertTrue(type_case("foo", 5, 1))
2511
36
        self.assertRaises(TypeError, type_case, "bar", "5", 1)
2512
37
        self.assertRaises(TypeError, type_case, None, 5, 1)
2513
38
2514
39
2515
40
@validate.typetest(instanceid=str, size=int, number_of_instances=int)
2516
41
def type_case(instanceid, size, number_of_instances):
2517
42
    return True
2518
43
0
2519
=== modified file 'nova/tests/virt_unittest.py'
2520
--- nova/tests/virt_unittest.py	2010-10-24 22:06:42 +0000
2521
+++ nova/tests/virt_unittest.py	2010-12-16 20:49:10 +0000
2522
@@ -30,7 +30,7 @@
2523
30
flags.DECLARE('instances_path', 'nova.compute.manager')
30
flags.DECLARE('instances_path', 'nova.compute.manager')
2524
31
31
2525
32
32
2527
33
class LibvirtConnTestCase(test.TrialTestCase):
33
class LibvirtConnTestCase(test.TestCase):
2528
34
    def setUp(self):
34
    def setUp(self):
2529
35
        super(LibvirtConnTestCase, self).setUp()
35
        super(LibvirtConnTestCase, self).setUp()
2530
36
        self.manager = manager.AuthManager()
36
        self.manager = manager.AuthManager()
2531
@@ -123,7 +123,7 @@
2532
123
        self.manager.delete_user(self.user)
123
        self.manager.delete_user(self.user)
2533
124
124
2534
125
125
2536
126
class NWFilterTestCase(test.TrialTestCase):
126
class NWFilterTestCase(test.TestCase):
2537
127
127
2538
128
    def setUp(self):
128
    def setUp(self):
2539
129
        super(NWFilterTestCase, self).setUp()
129
        super(NWFilterTestCase, self).setUp()
2540
@@ -235,7 +235,7 @@
2541
235
                                          'project_id': 'fake'})
235
                                          'project_id': 'fake'})
2542
236
        inst_id = instance_ref['id']
236
        inst_id = instance_ref['id']
2543
237
237
2545
238
        def _ensure_all_called(_):
238
        def _ensure_all_called():
2546
239
            instance_filter = 'nova-instance-%s' % instance_ref['name']
239
            instance_filter = 'nova-instance-%s' % instance_ref['name']
2547
240
            secgroup_filter = 'nova-secgroup-%s' % self.security_group['id']
240
            secgroup_filter = 'nova-secgroup-%s' % self.security_group['id']
2548
241
            for required in [secgroup_filter, 'allow-dhcp-server',
241
            for required in [secgroup_filter, 'allow-dhcp-server',
2549
@@ -253,7 +253,6 @@
2550
253
        instance = db.instance_get(self.context, inst_id)
253
        instance = db.instance_get(self.context, inst_id)
2551
254
254
2552
255
        d = self.fw.setup_nwfilters_for_instance(instance)
255
        d = self.fw.setup_nwfilters_for_instance(instance)
2556
256
        d.addCallback(_ensure_all_called)
256
        _ensure_all_called()
2557
257
        d.addCallback(lambda _: self.teardown_security_group())
257
        self.teardown_security_group()
2555
258
2558
259
        return d
258
        return d
2559
260
259
2560
=== modified file 'nova/tests/volume_unittest.py'
2561
--- nova/tests/volume_unittest.py	2010-11-03 21:38:14 +0000
2562
+++ nova/tests/volume_unittest.py	2010-12-16 20:49:10 +0000
2563
@@ -21,8 +21,6 @@
2564
21
"""
21
"""
2565
22
import logging
22
import logging
2566
23
23
2567
24
from twisted.internet import defer
2568
25
2569
26
from nova import context
24
from nova import context
2570
27
from nova import exception
25
from nova import exception
2571
28
from nova import db
26
from nova import db
2572
@@ -33,7 +31,7 @@
2573
33
FLAGS = flags.FLAGS
31
FLAGS = flags.FLAGS
2574
34
32
2575
35
33
2577
36
class VolumeTestCase(test.TrialTestCase):
34
class VolumeTestCase(test.TestCase):
2578
37
    """Test Case for volumes."""
35
    """Test Case for volumes."""
2579
38
36
2580
39
    def setUp(self):
37
    def setUp(self):
2581
@@ -56,51 +54,48 @@
2582
56
        vol['attach_status'] = "detached"
54
        vol['attach_status'] = "detached"
2583
57
        return db.volume_create(context.get_admin_context(), vol)['id']
55
        return db.volume_create(context.get_admin_context(), vol)['id']
2584
58
56
2585
59
    @defer.inlineCallbacks
2586
60
    def test_create_delete_volume(self):
57
    def test_create_delete_volume(self):
2587
61
        """Test volume can be created and deleted."""
58
        """Test volume can be created and deleted."""
2588
62
        volume_id = self._create_volume()
59
        volume_id = self._create_volume()
2590
63
        yield self.volume.create_volume(self.context, volume_id)
60
        self.volume.create_volume(self.context, volume_id)
2591
64
        self.assertEqual(volume_id, db.volume_get(context.get_admin_context(),
61
        self.assertEqual(volume_id, db.volume_get(context.get_admin_context(),
2592
65
                         volume_id).id)
62
                         volume_id).id)
2593
66
63
2595
67
        yield self.volume.delete_volume(self.context, volume_id)
64
        self.volume.delete_volume(self.context, volume_id)
2596
68
        self.assertRaises(exception.NotFound,
65
        self.assertRaises(exception.NotFound,
2597
69
                          db.volume_get,
66
                          db.volume_get,
2598
70
                          self.context,
67
                          self.context,
2599
71
                          volume_id)
68
                          volume_id)
2600
72
69
2601
73
    @defer.inlineCallbacks
2602
74
    def test_too_big_volume(self):
70
    def test_too_big_volume(self):
2603
75
        """Ensure failure if a too large of a volume is requested."""
71
        """Ensure failure if a too large of a volume is requested."""
2604
76
        # FIXME(vish): validation needs to move into the data layer in
72
        # FIXME(vish): validation needs to move into the data layer in
2605
77
        #              volume_create
73
        #              volume_create
2607
78
        defer.returnValue(True)
74
        return True
2608
79
        try:
75
        try:
2609
80
            volume_id = self._create_volume('1001')
76
            volume_id = self._create_volume('1001')
2611
81
            yield self.volume.create_volume(self.context, volume_id)
77
            self.volume.create_volume(self.context, volume_id)
2612
82
            self.fail("Should have thrown TypeError")
78
            self.fail("Should have thrown TypeError")
2613
83
        except TypeError:
79
        except TypeError:
2614
84
            pass
80
            pass
2615
85
81
2616
86
    @defer.inlineCallbacks
2617
87
    def test_too_many_volumes(self):
82
    def test_too_many_volumes(self):
2618
88
        """Ensure that NoMoreTargets is raised when we run out of volumes."""
83
        """Ensure that NoMoreTargets is raised when we run out of volumes."""
2619
89
        vols = []
84
        vols = []
2620
90
        total_slots = FLAGS.iscsi_num_targets
85
        total_slots = FLAGS.iscsi_num_targets
2621
91
        for _index in xrange(total_slots):
86
        for _index in xrange(total_slots):
2622
92
            volume_id = self._create_volume()
87
            volume_id = self._create_volume()
2624
93
            yield self.volume.create_volume(self.context, volume_id)
88
            self.volume.create_volume(self.context, volume_id)
2625
94
            vols.append(volume_id)
89
            vols.append(volume_id)
2626
95
        volume_id = self._create_volume()
90
        volume_id = self._create_volume()
2630
96
        self.assertFailure(self.volume.create_volume(self.context,
91
        self.assertRaises(db.NoMoreTargets,
2631
97
                                                     volume_id),
92
                          self.volume.create_volume,
2632
98
                           db.NoMoreTargets)
93
                          self.context,
2633
94
                          volume_id)
2634
99
        db.volume_destroy(context.get_admin_context(), volume_id)
95
        db.volume_destroy(context.get_admin_context(), volume_id)
2635
100
        for volume_id in vols:
96
        for volume_id in vols:
2637
101
            yield self.volume.delete_volume(self.context, volume_id)
97
            self.volume.delete_volume(self.context, volume_id)
2638
102
98
2639
103
    @defer.inlineCallbacks
2640
104
    def test_run_attach_detach_volume(self):
99
    def test_run_attach_detach_volume(self):
2641
105
        """Make sure volume can be attached and detached from instance."""
100
        """Make sure volume can be attached and detached from instance."""
2642
106
        inst = {}
101
        inst = {}
2643
@@ -115,15 +110,15 @@
2644
115
        instance_id = db.instance_create(self.context, inst)['id']
110
        instance_id = db.instance_create(self.context, inst)['id']
2645
116
        mountpoint = "/dev/sdf"
111
        mountpoint = "/dev/sdf"
2646
117
        volume_id = self._create_volume()
112
        volume_id = self._create_volume()
2648
118
        yield self.volume.create_volume(self.context, volume_id)
113
        self.volume.create_volume(self.context, volume_id)
2649
119
        if FLAGS.fake_tests:
114
        if FLAGS.fake_tests:
2650
120
            db.volume_attached(self.context, volume_id, instance_id,
115
            db.volume_attached(self.context, volume_id, instance_id,
2651
121
                               mountpoint)
116
                               mountpoint)
2652
122
        else:
117
        else:
2657
123
            yield self.compute.attach_volume(self.context,
118
            self.compute.attach_volume(self.context,
2658
124
                                             instance_id,
119
                                       instance_id,
2659
125
                                             volume_id,
120
                                       volume_id,
2660
126
                                             mountpoint)
121
                                       mountpoint)
2661
127
        vol = db.volume_get(context.get_admin_context(), volume_id)
122
        vol = db.volume_get(context.get_admin_context(), volume_id)
2662
128
        self.assertEqual(vol['status'], "in-use")
123
        self.assertEqual(vol['status'], "in-use")
2663
129
        self.assertEqual(vol['attach_status'], "attached")
124
        self.assertEqual(vol['attach_status'], "attached")
2664
@@ -131,25 +126,26 @@
2665
131
        instance_ref = db.volume_get_instance(self.context, volume_id)
126
        instance_ref = db.volume_get_instance(self.context, volume_id)
2666
132
        self.assertEqual(instance_ref['id'], instance_id)
127
        self.assertEqual(instance_ref['id'], instance_id)
2667
133
128
2670
134
        self.assertFailure(self.volume.delete_volume(self.context, volume_id),
129
        self.assertRaises(exception.Error,
2671
135
                           exception.Error)
130
                          self.volume.delete_volume,
2672
131
                          self.context,
2673
132
                          volume_id)
2674
136
        if FLAGS.fake_tests:
133
        if FLAGS.fake_tests:
2675
137
            db.volume_detached(self.context, volume_id)
134
            db.volume_detached(self.context, volume_id)
2676
138
        else:
135
        else:
2680
139
            yield self.compute.detach_volume(self.context,
136
            self.compute.detach_volume(self.context,
2681
140
                                             instance_id,
137
                                       instance_id,
2682
141
                                             volume_id)
138
                                       volume_id)
2683
142
        vol = db.volume_get(self.context, volume_id)
139
        vol = db.volume_get(self.context, volume_id)
2684
143
        self.assertEqual(vol['status'], "available")
140
        self.assertEqual(vol['status'], "available")
2685
144
141
2687
145
        yield self.volume.delete_volume(self.context, volume_id)
142
        self.volume.delete_volume(self.context, volume_id)
2688
146
        self.assertRaises(exception.Error,
143
        self.assertRaises(exception.Error,
2689
147
                          db.volume_get,
144
                          db.volume_get,
2690
148
                          self.context,
145
                          self.context,
2691
149
                          volume_id)
146
                          volume_id)
2692
150
        db.instance_destroy(self.context, instance_id)
147
        db.instance_destroy(self.context, instance_id)
2693
151
148
2694
152
    @defer.inlineCallbacks
2695
153
    def test_concurrent_volumes_get_different_targets(self):
149
    def test_concurrent_volumes_get_different_targets(self):
2696
154
        """Ensure multiple concurrent volumes get different targets."""
150
        """Ensure multiple concurrent volumes get different targets."""
2697
155
        volume_ids = []
151
        volume_ids = []
2698
@@ -164,15 +160,11 @@
2699
164
            self.assert_(iscsi_target not in targets)
160
            self.assert_(iscsi_target not in targets)
2700
165
            targets.append(iscsi_target)
161
            targets.append(iscsi_target)
2701
166
            logging.debug("Target %s allocated", iscsi_target)
162
            logging.debug("Target %s allocated", iscsi_target)
2702
167
        deferreds = []
2703
168
        total_slots = FLAGS.iscsi_num_targets
163
        total_slots = FLAGS.iscsi_num_targets
2704
169
        for _index in xrange(total_slots):
164
        for _index in xrange(total_slots):
2705
170
            volume_id = self._create_volume()
165
            volume_id = self._create_volume()
2706
171
            d = self.volume.create_volume(self.context, volume_id)
166
            d = self.volume.create_volume(self.context, volume_id)
2711
172
            d.addCallback(_check)
167
            _check(d)
2708
173
            d.addErrback(self.fail)
2709
174
            deferreds.append(d)
2710
175
        yield defer.DeferredList(deferreds)
2712
176
        for volume_id in volume_ids:
168
        for volume_id in volume_ids:
2713
177
            self.volume.delete_volume(self.context, volume_id)
169
            self.volume.delete_volume(self.context, volume_id)
2714
178
170
2715
179
171
2716
=== modified file 'nova/utils.py'
2717
--- nova/utils.py	2010-11-23 20:58:46 +0000
2718
+++ nova/utils.py	2010-12-16 20:49:10 +0000
2719
@@ -31,7 +31,8 @@
2720
31
import sys
31
import sys
2721
32
from xml.sax import saxutils
32
from xml.sax import saxutils
2722
33
33
2724
34
from twisted.internet.threads import deferToThread
34
from eventlet import event
2725
35
from eventlet import greenthread
2726
35
36
2727
36
from nova import exception
37
from nova import exception
2728
37
from nova import flags
38
from nova import flags
2729
@@ -75,7 +76,7 @@
2730
75
76
2731
76
77
2732
77
def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
78
def execute(cmd, process_input=None, addl_env=None, check_exit_code=True):
2734
78
    logging.debug("Running cmd: %s", cmd)
79
    logging.debug("Running cmd (subprocess): %s", cmd)
2735
79
    env = os.environ.copy()
80
    env = os.environ.copy()
2736
80
    if addl_env:
81
    if addl_env:
2737
81
        env.update(addl_env)
82
        env.update(addl_env)
2738
@@ -95,6 +96,10 @@
2739
95
                                        stdout=stdout,
96
                                        stdout=stdout,
2740
96
                                        stderr=stderr,
97
                                        stderr=stderr,
2741
97
                                        cmd=cmd)
98
                                        cmd=cmd)
2742
99
    # NOTE(termie): this appears to be necessary to let the subprocess call
2743
100
    #               clean something up in between calls, without it two
2744
101
    #               execute calls in a row hangs the second one
2745
102
    greenthread.sleep(0)
2746
98
    return result
103
    return result
2747
99
104
2748
100
105
2749
@@ -123,13 +128,7 @@
2750
123
128
2751
124
def runthis(prompt, cmd, check_exit_code=True):
129
def runthis(prompt, cmd, check_exit_code=True):
2752
125
    logging.debug("Running %s" % (cmd))
130
    logging.debug("Running %s" % (cmd))
2760
126
    exit_code = subprocess.call(cmd.split(" "))
131
    rv, err = execute(cmd, check_exit_code=check_exit_code)
2754
127
    logging.debug(prompt % (exit_code))
2755
128
    if check_exit_code and exit_code != 0:
2756
129
        raise ProcessExecutionError(exit_code=exit_code,
2757
130
                                    stdout=None,
2758
131
                                    stderr=None,
2759
132
                                    cmd=cmd)
2761
133
132
2762
134
133
2763
135
def generate_uid(topic, size=8):
134
def generate_uid(topic, size=8):
2764
@@ -224,10 +223,41 @@
2765
224
        return getattr(backend, key)
223
        return getattr(backend, key)
2766
225
224
2767
226
225
2772
227
def deferredToThread(f):
226
class LoopingCall(object):
2773
228
    def g(*args, **kwargs):
227
    def __init__(self, f=None, *args, **kw):
2774
229
        return deferToThread(f, *args, **kwargs)
228
        self.args = args
2775
230
    return g
229
        self.kw = kw
2776
230
        self.f = f
2777
231
        self._running = False
2778
232
2779
233
    def start(self, interval, now=True):
2780
234
        self._running = True
2781
235
        done = event.Event()
2782
236
2783
237
        def _inner():
2784
238
            if not now:
2785
239
                greenthread.sleep(interval)
2786
240
            try:
2787
241
                while self._running:
2788
242
                    self.f(*self.args, **self.kw)
2789
243
                    greenthread.sleep(interval)
2790
244
            except Exception:
2791
245
                logging.exception('in looping call')
2792
246
                done.send_exception(*sys.exc_info())
2793
247
                return
2794
248
2795
249
            done.send(True)
2796
250
2797
251
        self.done = done
2798
252
2799
253
        greenthread.spawn(_inner)
2800
254
        return self.done
2801
255
2802
256
    def stop(self):
2803
257
        self._running = False
2804
258
2805
259
    def wait(self):
2806
260
        return self.done.wait()
2807
231
261
2808
232
262
2809
233
def xhtml_escape(value):
263
def xhtml_escape(value):
2810
234
264
2811
=== removed file 'nova/validate.py'
2812
--- nova/validate.py	2010-10-21 18:49:51 +0000
2813
+++ nova/validate.py	1970-01-01 00:00:00 +0000
2814
@@ -1,94 +0,0 @@
2815
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
2816
2
2817
3
# Copyright 2010 United States Government as represented by the
2818
4
# Administrator of the National Aeronautics and Space Administration.
2819
5
# All Rights Reserved.
2820
6
#
2821
7
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
2822
8
#    not use this file except in compliance with the License. You may obtain
2823
9
#    a copy of the License at
2824
10
#
2825
11
#         http://www.apache.org/licenses/LICENSE-2.0
2826
12
#
2827
13
#    Unless required by applicable law or agreed to in writing, software
2828
14
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
2829
15
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
2830
16
#    License for the specific language governing permissions and limitations
2831
17
#    under the License.
2832
18
2833
19
"""Decorators for argument validation, courtesy of
2834
20
http://rmi.net/~lutz/rangetest.html"""
2835
21
2836
22
2837
23
def rangetest(**argchecks):
2838
24
    """Validate ranges for both + defaults"""
2839
25
2840
26
    def onDecorator(func):
2841
27
        """onCall remembers func and argchecks"""
2842
28
        import sys
2843
29
        code = func.__code__ if sys.version_info[0] == 3 else func.func_code
2844
30
        allargs = code.co_varnames[:code.co_argcount]
2845
31
        funcname = func.__name__
2846
32
2847
33
        def onCall(*pargs, **kargs):
2848
34
            # all pargs match first N args by position
2849
35
            # the rest must be in kargs or omitted defaults
2850
36
            positionals = list(allargs)
2851
37
            positionals = positionals[:len(pargs)]
2852
38
2853
39
            for (argname, (low, high)) in argchecks.items():
2854
40
                # for all args to be checked
2855
41
                if argname in kargs:
2856
42
                    # was passed by name
2857
43
                    if float(kargs[argname]) < low or \
2858
44
                       float(kargs[argname]) > high:
2859
45
                        errmsg = '{0} argument "{1}" not in {2}..{3}'
2860
46
                        errmsg = errmsg.format(funcname, argname, low, high)
2861
47
                        raise TypeError(errmsg)
2862
48
2863
49
                elif argname in positionals:
2864
50
                    # was passed by position
2865
51
                    position = positionals.index(argname)
2866
52
                    if float(pargs[position]) < low or \
2867
53
                       float(pargs[position]) > high:
2868
54
                        errmsg = '{0} argument "{1}" with value of {4} ' \
2869
55
                                 'not in {2}..{3}'
2870
56
                        errmsg = errmsg.format(funcname, argname, low, high,
2871
57
                                               pargs[position])
2872
58
                        raise TypeError(errmsg)
2873
59
                else:
2874
60
                    pass
2875
61
2876
62
            return func(*pargs, **kargs)    # okay: run original call
2877
63
        return onCall
2878
64
    return onDecorator
2879
65
2880
66
2881
67
def typetest(**argchecks):
2882
68
    def onDecorator(func):
2883
69
        import sys
2884
70
        code = func.__code__ if sys.version_info[0] == 3 else func.func_code
2885
71
        allargs = code.co_varnames[:code.co_argcount]
2886
72
        funcname = func.__name__
2887
73
2888
74
        def onCall(*pargs, **kargs):
2889
75
            positionals = list(allargs)[:len(pargs)]
2890
76
            for (argname, typeof) in argchecks.items():
2891
77
                if argname in kargs:
2892
78
                    if not isinstance(kargs[argname], typeof):
2893
79
                        errmsg = '{0} argument "{1}" not of type {2}'
2894
80
                        errmsg = errmsg.format(funcname, argname, typeof)
2895
81
                        raise TypeError(errmsg)
2896
82
                elif argname in positionals:
2897
83
                    position = positionals.index(argname)
2898
84
                    if not isinstance(pargs[position], typeof):
2899
85
                        errmsg = '{0} argument "{1}" with value of {2} ' \
2900
86
                                 'not of type {3}'
2901
87
                        errmsg = errmsg.format(funcname, argname,
2902
88
                                               pargs[position], typeof)
2903
89
                        raise TypeError(errmsg)
2904
90
                else:
2905
91
                    pass
2906
92
            return func(*pargs, **kargs)
2907
93
        return onCall
2908
94
    return onDecorator
2909
95
0
2910
=== modified file 'nova/virt/fake.py'
2911
--- nova/virt/fake.py	2010-11-01 20:13:18 +0000
2912
+++ nova/virt/fake.py	2010-12-16 20:49:10 +0000
2913
@@ -25,8 +25,6 @@
2914
25
25
2915
26
"""
26
"""
2916
27
27
2917
28
from twisted.internet import defer
2918
29
2919
30
from nova import exception
28
from nova import exception
2920
31
from nova.compute import power_state
29
from nova.compute import power_state
2921
32
30
2922
@@ -107,7 +105,6 @@
2923
107
        fake_instance = FakeInstance()
105
        fake_instance = FakeInstance()
2924
108
        self.instances[instance.name] = fake_instance
106
        self.instances[instance.name] = fake_instance
2925
109
        fake_instance._state = power_state.RUNNING
107
        fake_instance._state = power_state.RUNNING
2926
110
        return defer.succeed(None)
2927
111
108
2928
112
    def reboot(self, instance):
109
    def reboot(self, instance):
2929
113
        """
110
        """
2930
@@ -119,19 +116,19 @@
2931
119
        The work will be done asynchronously.  This function returns a
116
        The work will be done asynchronously.  This function returns a
2932
120
        Deferred that allows the caller to detect when it is complete.
117
        Deferred that allows the caller to detect when it is complete.
2933
121
        """
118
        """
2935
122
        return defer.succeed(None)
119
        pass
2936
123
120
2937
124
    def rescue(self, instance):
121
    def rescue(self, instance):
2938
125
        """
122
        """
2939
126
        Rescue the specified instance.
123
        Rescue the specified instance.
2940
127
        """
124
        """
2942
128
        return defer.succeed(None)
125
        pass
2943
129
126
2944
130
    def unrescue(self, instance):
127
    def unrescue(self, instance):
2945
131
        """
128
        """
2946
132
        Unrescue the specified instance.
129
        Unrescue the specified instance.
2947
133
        """
130
        """
2949
134
        return defer.succeed(None)
131
        pass
2950
135
132
2951
136
    def destroy(self, instance):
133
    def destroy(self, instance):
2952
137
        """
134
        """
2953
@@ -144,7 +141,6 @@
2954
144
        Deferred that allows the caller to detect when it is complete.
141
        Deferred that allows the caller to detect when it is complete.
2955
145
        """
142
        """
2956
146
        del self.instances[instance.name]
143
        del self.instances[instance.name]
2957
147
        return defer.succeed(None)
2958
148
144
2959
149
    def attach_volume(self, instance_name, device_path, mountpoint):
145
    def attach_volume(self, instance_name, device_path, mountpoint):
2960
150
        """Attach the disk at device_path to the instance at mountpoint"""
146
        """Attach the disk at device_path to the instance at mountpoint"""
2961
151
147
2962
=== modified file 'nova/virt/images.py'
2963
--- nova/virt/images.py	2010-10-22 00:15:21 +0000
2964
+++ nova/virt/images.py	2010-12-16 20:49:10 +0000
2965
@@ -26,7 +26,7 @@
2966
26
import urlparse
26
import urlparse
2967
27
27
2968
28
from nova import flags
28
from nova import flags
2970
29
from nova import process
29
from nova import utils
2971
30
from nova.auth import manager
30
from nova.auth import manager
2972
31
from nova.auth import signer
31
from nova.auth import signer
2973
32
from nova.objectstore import image
32
from nova.objectstore import image
2974
@@ -50,7 +50,7 @@
2975
50
50
2976
51
    # This should probably move somewhere else, like e.g. a download_as
51
    # This should probably move somewhere else, like e.g. a download_as
2977
52
    # method on User objects and at the same time get rewritten to use
52
    # method on User objects and at the same time get rewritten to use
2979
53
    # twisted web client.
53
    # a web client.
2980
54
    headers = {}
54
    headers = {}
2981
55
    headers['Date'] = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime())
55
    headers['Date'] = time.strftime("%a, %d %b %Y %H:%M:%S GMT", time.gmtime())
2982
56
56
2983
@@ -63,15 +63,16 @@
2984
63
63
2985
64
    cmd = ['/usr/bin/curl', '--fail', '--silent', url]
64
    cmd = ['/usr/bin/curl', '--fail', '--silent', url]
2986
65
    for (k, v) in headers.iteritems():
65
    for (k, v) in headers.iteritems():
2988
66
        cmd += ['-H', '%s: %s' % (k, v)]
66
        cmd += ['-H', '"%s: %s"' % (k, v)]
2989
67
67
2990
68
    cmd += ['-o', path]
68
    cmd += ['-o', path]
2992
69
    return process.SharedPool().execute(executable=cmd[0], args=cmd[1:])
69
    cmd_out = ' '.join(cmd)
2993
70
    return utils.execute(cmd_out)
2994
70
71
2995
71
72
2996
72
def _fetch_local_image(image, path, user, project):
73
def _fetch_local_image(image, path, user, project):
2997
73
    source = _image_path('%s/image' % image)
74
    source = _image_path('%s/image' % image)
2999
74
    return process.simple_execute('cp %s %s' % (source, path))
75
    return utils.execute('cp %s %s' % (source, path))
3000
75
76
3001
76
77
3002
77
def _image_path(path):
78
def _image_path(path):
3003
78
79
3004
=== modified file 'nova/virt/libvirt_conn.py'
3005
--- nova/virt/libvirt_conn.py	2010-11-17 19:56:42 +0000
3006
+++ nova/virt/libvirt_conn.py	2010-12-16 20:49:10 +0000
3007
@@ -45,16 +45,15 @@
3008
45
import os
45
import os
3009
46
import shutil
46
import shutil
3010
47
47
3011
48
from eventlet import event
3012
49
from eventlet import tpool
3013
50
3014
48
import IPy
51
import IPy
3015
49
from twisted.internet import defer
3016
50
from twisted.internet import task
3017
51
from twisted.internet import threads
3018
52
52
3019
53
from nova import context
53
from nova import context
3020
54
from nova import db
54
from nova import db
3021
55
from nova import exception
55
from nova import exception
3022
56
from nova import flags
56
from nova import flags
3023
57
from nova import process
3024
58
from nova import utils
57
from nova import utils
3025
59
#from nova.api import context
58
#from nova.api import context
3026
60
from nova.auth import manager
59
from nova.auth import manager
3027
@@ -184,14 +183,12 @@
3028
184
        except Exception as _err:
183
        except Exception as _err:
3029
185
            pass
184
            pass
3030
186
            # If the instance is already terminated, we're still happy
185
            # If the instance is already terminated, we're still happy
3037
187
        d = defer.Deferred()
186
3038
188
        if cleanup:
187
        done = event.Event()
3039
189
            d.addCallback(lambda _: self._cleanup(instance))
188
3040
190
        # FIXME: What does this comment mean?
189
        # We'll save this for when we do shutdown,
3035
191
        # TODO(termie): short-circuit me for tests
3036
192
        # WE'LL save this for when we do shutdown,
3041
193
        # instead of destroy - but destroy returns immediately
190
        # instead of destroy - but destroy returns immediately
3043
194
        timer = task.LoopingCall(f=None)
191
        timer = utils.LoopingCall(f=None)
3044
195
192
3045
196
        def _wait_for_shutdown():
193
        def _wait_for_shutdown():
3046
197
            try:
194
            try:
3047
@@ -200,17 +197,26 @@
3048
200
                                      instance['id'], state)
197
                                      instance['id'], state)
3049
201
                if state == power_state.SHUTDOWN:
198
                if state == power_state.SHUTDOWN:
3050
202
                    timer.stop()
199
                    timer.stop()
3051
203
                    d.callback(None)
3052
204
            except Exception:
200
            except Exception:
3053
205
                db.instance_set_state(context.get_admin_context(),
201
                db.instance_set_state(context.get_admin_context(),
3054
206
                                      instance['id'],
202
                                      instance['id'],
3055
207
                                      power_state.SHUTDOWN)
203
                                      power_state.SHUTDOWN)
3056
208
                timer.stop()
204
                timer.stop()
3057
209
                d.callback(None)
3058
210
205
3059
211
        timer.f = _wait_for_shutdown
206
        timer.f = _wait_for_shutdown
3062
212
        timer.start(interval=0.5, now=True)
207
        timer_done = timer.start(interval=0.5, now=True)
3063
213
        return d
208
3064
209
        # NOTE(termie): this is strictly superfluous (we could put the
3065
210
        #               cleanup code in the timer), but this emulates the
3066
211
        #               previous model so I am keeping it around until
3067
212
        #               everything has been vetted a bit
3068
213
        def _wait_for_timer():
3069
214
            timer_done.wait()
3070
215
            self._cleanup(instance)
3071
216
            done.send()
3072
217
3073
218
        greenthread.spawn(_wait_for_timer)
3074
219
        return done
3075
214
220
3076
215
    def _cleanup(self, instance):
221
    def _cleanup(self, instance):
3077
216
        target = os.path.join(FLAGS.instances_path, instance['name'])
222
        target = os.path.join(FLAGS.instances_path, instance['name'])
3078
@@ -219,7 +225,6 @@
3079
219
        if os.path.exists(target):
225
        if os.path.exists(target):
3080
220
            shutil.rmtree(target)
226
            shutil.rmtree(target)
3081
221
227
3082
222
    @defer.inlineCallbacks
3083
223
    @exception.wrap_exception
228
    @exception.wrap_exception
3084
224
    def attach_volume(self, instance_name, device_path, mountpoint):
229
    def attach_volume(self, instance_name, device_path, mountpoint):
3085
225
        virt_dom = self._conn.lookupByName(instance_name)
230
        virt_dom = self._conn.lookupByName(instance_name)
3086
@@ -230,7 +235,6 @@
3087
230
                     <target dev='%s' bus='virtio'/>
235
                     <target dev='%s' bus='virtio'/>
3088
231
                 </disk>""" % (device_path, mount_device)
236
                 </disk>""" % (device_path, mount_device)
3089
232
        virt_dom.attachDevice(xml)
237
        virt_dom.attachDevice(xml)
3090
233
        yield
3091
234
238
3092
235
    def _get_disk_xml(self, xml, device):
239
    def _get_disk_xml(self, xml, device):
3093
236
        """Returns the xml for the disk mounted at device"""
240
        """Returns the xml for the disk mounted at device"""
3094
@@ -252,7 +256,6 @@
3095
252
            if doc != None:
256
            if doc != None:
3096
253
                doc.freeDoc()
257
                doc.freeDoc()
3097
254
258
3098
255
    @defer.inlineCallbacks
3099
256
    @exception.wrap_exception
259
    @exception.wrap_exception
3100
257
    def detach_volume(self, instance_name, mountpoint):
260
    def detach_volume(self, instance_name, mountpoint):
3101
258
        virt_dom = self._conn.lookupByName(instance_name)
261
        virt_dom = self._conn.lookupByName(instance_name)
3102
@@ -261,17 +264,13 @@
3103
261
        if not xml:
264
        if not xml:
3104
262
            raise exception.NotFound("No disk at %s" % mount_device)
265
            raise exception.NotFound("No disk at %s" % mount_device)
3105
263
        virt_dom.detachDevice(xml)
266
        virt_dom.detachDevice(xml)
3106
264
        yield
3107
265
267
3108
266
    @defer.inlineCallbacks
3109
267
    @exception.wrap_exception
268
    @exception.wrap_exception
3110
268
    def reboot(self, instance):
269
    def reboot(self, instance):
3112
269
        yield self.destroy(instance, False)
270
        self.destroy(instance, False)
3113
270
        xml = self.to_xml(instance)
271
        xml = self.to_xml(instance)
3118
271
        yield self._conn.createXML(xml, 0)
272
        self._conn.createXML(xml, 0)
3119
272
273
        timer = utils.LoopingCall(f=None)
3116
273
        d = defer.Deferred()
3117
274
        timer = task.LoopingCall(f=None)
3120
275
274
3121
276
        def _wait_for_reboot():
275
        def _wait_for_reboot():
3122
277
            try:
276
            try:
3123
@@ -281,33 +280,28 @@
3124
281
                if state == power_state.RUNNING:
280
                if state == power_state.RUNNING:
3125
282
                    logging.debug('instance %s: rebooted', instance['name'])
281
                    logging.debug('instance %s: rebooted', instance['name'])
3126
283
                    timer.stop()
282
                    timer.stop()
3127
284
                    d.callback(None)
3128
285
            except Exception, exn:
283
            except Exception, exn:
3129
286
                logging.error('_wait_for_reboot failed: %s', exn)
284
                logging.error('_wait_for_reboot failed: %s', exn)
3130
287
                db.instance_set_state(context.get_admin_context(),
285
                db.instance_set_state(context.get_admin_context(),
3131
288
                                      instance['id'],
286
                                      instance['id'],
3132
289
                                      power_state.SHUTDOWN)
287
                                      power_state.SHUTDOWN)
3133
290
                timer.stop()
288
                timer.stop()
3134
291
                d.callback(None)
3135
292
289
3136
293
        timer.f = _wait_for_reboot
290
        timer.f = _wait_for_reboot
3139
294
        timer.start(interval=0.5, now=True)
291
        return timer.start(interval=0.5, now=True)
3138
295
        yield d
3140
296
292
3141
297
    @defer.inlineCallbacks
3142
298
    @exception.wrap_exception
293
    @exception.wrap_exception
3143
299
    def rescue(self, instance):
294
    def rescue(self, instance):
3145
300
        yield self.destroy(instance, False)
295
        self.destroy(instance, False)
3146
301
296
3147
302
        xml = self.to_xml(instance, rescue=True)
297
        xml = self.to_xml(instance, rescue=True)
3148
303
        rescue_images = {'image_id': FLAGS.rescue_image_id,
298
        rescue_images = {'image_id': FLAGS.rescue_image_id,
3149
304
                         'kernel_id': FLAGS.rescue_kernel_id,
299
                         'kernel_id': FLAGS.rescue_kernel_id,
3150
305
                         'ramdisk_id': FLAGS.rescue_ramdisk_id}
300
                         'ramdisk_id': FLAGS.rescue_ramdisk_id}
3153
306
        yield self._create_image(instance, xml, 'rescue-', rescue_images)
301
        self._create_image(instance, xml, 'rescue-', rescue_images)
3154
307
        yield self._conn.createXML(xml, 0)
302
        self._conn.createXML(xml, 0)
3155
308
303
3158
309
        d = defer.Deferred()
304
        timer = utils.LoopingCall(f=None)
3157
310
        timer = task.LoopingCall(f=None)
3159
311
305
3160
312
        def _wait_for_rescue():
306
        def _wait_for_rescue():
3161
313
            try:
307
            try:
3162
@@ -316,27 +310,22 @@
3163
316
                if state == power_state.RUNNING:
310
                if state == power_state.RUNNING:
3164
317
                    logging.debug('instance %s: rescued', instance['name'])
311
                    logging.debug('instance %s: rescued', instance['name'])
3165
318
                    timer.stop()
312
                    timer.stop()
3166
319
                    d.callback(None)
3167
320
            except Exception, exn:
313
            except Exception, exn:
3168
321
                logging.error('_wait_for_rescue failed: %s', exn)
314
                logging.error('_wait_for_rescue failed: %s', exn)
3169
322
                db.instance_set_state(None,
315
                db.instance_set_state(None,
3170
323
                                      instance['id'],
316
                                      instance['id'],
3171
324
                                      power_state.SHUTDOWN)
317
                                      power_state.SHUTDOWN)
3172
325
                timer.stop()
318
                timer.stop()
3173
326
                d.callback(None)
3174
327
319
3175
328
        timer.f = _wait_for_rescue
320
        timer.f = _wait_for_rescue
3178
329
        timer.start(interval=0.5, now=True)
321
        return timer.start(interval=0.5, now=True)
3177
330
        yield d
3179
331
322
3180
332
    @defer.inlineCallbacks
3181
333
    @exception.wrap_exception
323
    @exception.wrap_exception
3182
334
    def unrescue(self, instance):
324
    def unrescue(self, instance):
3183
335
        # NOTE(vish): Because reboot destroys and recreates an instance using
325
        # NOTE(vish): Because reboot destroys and recreates an instance using
3184
336
        #             the normal xml file, we can just call reboot here
326
        #             the normal xml file, we can just call reboot here
3186
337
        yield self.reboot(instance)
327
        self.reboot(instance)
3187
338
328
3188
339
    @defer.inlineCallbacks
3189
340
    @exception.wrap_exception
329
    @exception.wrap_exception
3190
341
    def spawn(self, instance):
330
    def spawn(self, instance):
3191
342
        xml = self.to_xml(instance)
331
        xml = self.to_xml(instance)
3192
@@ -344,14 +333,12 @@
3193
344
                              instance['id'],
333
                              instance['id'],
3194
345
                              power_state.NOSTATE,
334
                              power_state.NOSTATE,
3195
346
                              'launching')
335
                              'launching')
3200
347
        yield NWFilterFirewall(self._conn).\
336
        NWFilterFirewall(self._conn).setup_nwfilters_for_instance(instance)
3201
348
              setup_nwfilters_for_instance(instance)
337
        self._create_image(instance, xml)
3202
349
        yield self._create_image(instance, xml)
338
        self._conn.createXML(xml, 0)
3199
350
        yield self._conn.createXML(xml, 0)
3203
351
        logging.debug("instance %s: is running", instance['name'])
339
        logging.debug("instance %s: is running", instance['name'])
3204
352
340
3207
353
        local_d = defer.Deferred()
341
        timer = utils.LoopingCall(f=None)
3206
354
        timer = task.LoopingCall(f=None)
3208
355
342
3209
356
        def _wait_for_boot():
343
        def _wait_for_boot():
3210
357
            try:
344
            try:
3211
@@ -361,7 +348,6 @@
3212
361
                if state == power_state.RUNNING:
348
                if state == power_state.RUNNING:
3213
362
                    logging.debug('instance %s: booted', instance['name'])
349
                    logging.debug('instance %s: booted', instance['name'])
3214
363
                    timer.stop()
350
                    timer.stop()
3215
364
                    local_d.callback(None)
3216
365
            except:
351
            except:
3217
366
                logging.exception('instance %s: failed to boot',
352
                logging.exception('instance %s: failed to boot',
3218
367
                                  instance['name'])
353
                                  instance['name'])
3219
@@ -369,10 +355,9 @@
3220
369
                                      instance['id'],
355
                                      instance['id'],
3221
370
                                      power_state.SHUTDOWN)
356
                                      power_state.SHUTDOWN)
3222
371
                timer.stop()
357
                timer.stop()
3224
372
                local_d.callback(None)
358
3225
373
        timer.f = _wait_for_boot
359
        timer.f = _wait_for_boot
3228
374
        timer.start(interval=0.5, now=True)
360
        return timer.start(interval=0.5, now=True)
3227
375
        yield local_d
3229
376
361
3230
377
    def _flush_xen_console(self, virsh_output):
362
    def _flush_xen_console(self, virsh_output):
3231
378
        logging.info('virsh said: %r' % (virsh_output,))
363
        logging.info('virsh said: %r' % (virsh_output,))
3232
@@ -380,10 +365,9 @@
3233
380
365
3234
381
        if virsh_output.startswith('/dev/'):
366
        if virsh_output.startswith('/dev/'):
3235
382
            logging.info('cool, it\'s a device')
367
            logging.info('cool, it\'s a device')
3240
383
            d = process.simple_execute("sudo dd if=%s iflag=nonblock" %
368
            out, err = utils.execute("sudo dd if=%s iflag=nonblock" %
3241
384
                                       virsh_output, check_exit_code=False)
369
                                     virsh_output, check_exit_code=False)
3242
385
            d.addCallback(lambda r: r[0])
370
            return out
3239
386
            return d
3243
387
        else:
371
        else:
3244
388
            return ''
372
            return ''
3245
389
373
3246
@@ -403,21 +387,20 @@
3247
403
    def get_console_output(self, instance):
387
    def get_console_output(self, instance):
3248
404
        console_log = os.path.join(FLAGS.instances_path, instance['name'],
388
        console_log = os.path.join(FLAGS.instances_path, instance['name'],
3249
405
                                   'console.log')
389
                                   'console.log')
3252
406
        d = process.simple_execute('sudo chown %d %s' % (os.getuid(),
390
3253
407
                                   console_log))
391
        utils.execute('sudo chown %d %s' % (os.getuid(), console_log))
3254
392
3255
408
        if FLAGS.libvirt_type == 'xen':
393
        if FLAGS.libvirt_type == 'xen':
3262
409
            # Xen is spethial
394
            # Xen is special
3263
410
            d.addCallback(lambda _:
395
            virsh_output = utils.execute("virsh ttyconsole %s" %
3264
411
                process.simple_execute("virsh ttyconsole %s" %
396
                                         instance['name'])
3265
412
                                       instance['name']))
397
            data = self._flush_xen_console(virsh_output)
3266
413
            d.addCallback(self._flush_xen_console)
398
            fpath = self._append_to_file(data, console_log)
3261
414
            d.addCallback(self._append_to_file, console_log)
3267
415
        else:
399
        else:
3273
416
            d.addCallback(lambda _: defer.succeed(console_log))
400
            fpath = console_log
3274
417
        d.addCallback(self._dump_file)
401
3275
418
        return d
402
        return self._dump_file(fpath)
3276
419
403
3272
420
    @defer.inlineCallbacks
3277
421
    def _create_image(self, inst, libvirt_xml, prefix='', disk_images=None):
404
    def _create_image(self, inst, libvirt_xml, prefix='', disk_images=None):
3278
422
        # syntactic nicety
405
        # syntactic nicety
3279
423
        basepath = lambda fname = '', prefix = prefix: os.path.join(
406
        basepath = lambda fname = '', prefix = prefix: os.path.join(
3280
@@ -426,8 +409,8 @@
3281
426
                                                 prefix + fname)
409
                                                 prefix + fname)
3282
427
410
3283
428
        # ensure directories exist and are writable
411
        # ensure directories exist and are writable
3286
429
        yield process.simple_execute('mkdir -p %s' % basepath(prefix=''))
412
        utils.execute('mkdir -p %s' % basepath(prefix=''))
3287
430
        yield process.simple_execute('chmod 0777 %s' % basepath(prefix=''))
413
        utils.execute('chmod 0777 %s' % basepath(prefix=''))
3288
431
414
3289
432
        # TODO(termie): these are blocking calls, it would be great
415
        # TODO(termie): these are blocking calls, it would be great
3290
433
        #               if they weren't.
416
        #               if they weren't.
3291
@@ -448,19 +431,19 @@
3292
448
                           'kernel_id': inst['kernel_id'],
431
                           'kernel_id': inst['kernel_id'],
3293
449
                           'ramdisk_id': inst['ramdisk_id']}
432
                           'ramdisk_id': inst['ramdisk_id']}
3294
450
        if not os.path.exists(basepath('disk')):
433
        if not os.path.exists(basepath('disk')):
3297
451
            yield images.fetch(inst.image_id, basepath('disk-raw'), user,
434
            images.fetch(inst.image_id, basepath('disk-raw'), user,
3298
452
                               project)
435
                         project)
3299
453
        if not os.path.exists(basepath('kernel')):
436
        if not os.path.exists(basepath('kernel')):
3302
454
            yield images.fetch(inst.kernel_id, basepath('kernel'), user,
437
            images.fetch(inst.kernel_id, basepath('kernel'), user,
3303
455
                               project)
438
                         project)
3304
456
        if not os.path.exists(basepath('ramdisk')):
439
        if not os.path.exists(basepath('ramdisk')):
3307
457
            yield images.fetch(inst.ramdisk_id, basepath('ramdisk'), user,
440
            images.fetch(inst.ramdisk_id, basepath('ramdisk'), user,
3308
458
                               project)
441
                         project)
3309
459
442
3314
460
        execute = lambda cmd, process_input = None, check_exit_code = True: \
443
        def execute(cmd, process_input=None, check_exit_code=True):
3315
461
                  process.simple_execute(cmd=cmd,
444
            return utils.execute(cmd=cmd,
3316
462
                                         process_input=process_input,
445
                                 process_input=process_input,
3317
463
                                         check_exit_code=check_exit_code)
446
                                 check_exit_code=check_exit_code)
3318
464
447
3319
465
        key = str(inst['key_data'])
448
        key = str(inst['key_data'])
3320
466
        net = None
449
        net = None
3321
@@ -482,11 +465,11 @@
3322
482
            if net:
465
            if net:
3323
483
                logging.info('instance %s: injecting net into image %s',
466
                logging.info('instance %s: injecting net into image %s',
3324
484
                    inst['name'], inst.image_id)
467
                    inst['name'], inst.image_id)
3327
485
            yield disk.inject_data(basepath('disk-raw'), key, net,
468
            disk.inject_data(basepath('disk-raw'), key, net,
3328
486
                                   execute=execute)
469
                             execute=execute)
3329
487
470
3330
488
        if os.path.exists(basepath('disk')):
471
        if os.path.exists(basepath('disk')):
3332
489
            yield process.simple_execute('rm -f %s' % basepath('disk'))
472
            utils.execute('rm -f %s' % basepath('disk'))
3333
490
473
3334
491
        local_bytes = (instance_types.INSTANCE_TYPES[inst.instance_type]
474
        local_bytes = (instance_types.INSTANCE_TYPES[inst.instance_type]
3335
492
                                                    ['local_gb']
475
                                                    ['local_gb']
3336
@@ -495,12 +478,11 @@
3337
495
        resize = True
478
        resize = True
3338
496
        if inst['instance_type'] == 'm1.tiny' or prefix == 'rescue-':
479
        if inst['instance_type'] == 'm1.tiny' or prefix == 'rescue-':
3339
497
            resize = False
480
            resize = False
3342
498
        yield disk.partition(basepath('disk-raw'), basepath('disk'),
481
        disk.partition(basepath('disk-raw'), basepath('disk'),
3343
499
                             local_bytes, resize, execute=execute)
482
                       local_bytes, resize, execute=execute)
3344
500
483
3345
501
        if FLAGS.libvirt_type == 'uml':
484
        if FLAGS.libvirt_type == 'uml':
3348
502
            yield process.simple_execute('sudo chown root %s' %
485
            utils.execute('sudo chown root %s' % basepath('disk'))
3347
503
                                         basepath('disk'))
3349
504
486
3350
505
    def to_xml(self, instance, rescue=False):
487
    def to_xml(self, instance, rescue=False):
3351
506
        # TODO(termie): cache?
488
        # TODO(termie): cache?
3352
@@ -758,15 +740,15 @@
3353
758
    def _define_filter(self, xml):
740
    def _define_filter(self, xml):
3354
759
        if callable(xml):
741
        if callable(xml):
3355
760
            xml = xml()
742
            xml = xml()
3358
761
        d = threads.deferToThread(self._conn.nwfilterDefineXML, xml)
743
3359
762
        return d
744
        # execute in a native thread and block current greenthread until done
3360
745
        tpool.execute(self._conn.nwfilterDefineXML, xml)
3361
763
746
3362
764
    @staticmethod
747
    @staticmethod
3363
765
    def _get_net_and_mask(cidr):
748
    def _get_net_and_mask(cidr):
3364
766
        net = IPy.IP(cidr)
749
        net = IPy.IP(cidr)
3365
767
        return str(net.net()), str(net.netmask())
750
        return str(net.net()), str(net.netmask())
3366
768
751
3367
769
    @defer.inlineCallbacks
3368
770
    def setup_nwfilters_for_instance(self, instance):
752
    def setup_nwfilters_for_instance(self, instance):
3369
771
        """
753
        """
3370
772
        Creates an NWFilter for the given instance. In the process,
754
        Creates an NWFilter for the given instance. In the process,
3371
@@ -774,10 +756,10 @@
3372
774
        the base filter are all in place.
756
        the base filter are all in place.
3373
775
        """
757
        """
3374
776
758
3379
777
        yield self._define_filter(self.nova_base_ipv4_filter)
759
        self._define_filter(self.nova_base_ipv4_filter)
3380
778
        yield self._define_filter(self.nova_base_ipv6_filter)
760
        self._define_filter(self.nova_base_ipv6_filter)
3381
779
        yield self._define_filter(self.nova_dhcp_filter)
761
        self._define_filter(self.nova_dhcp_filter)
3382
780
        yield self._define_filter(self.nova_base_filter)
762
        self._define_filter(self.nova_base_filter)
3383
781
763
3384
782
        nwfilter_xml = "<filter name='nova-instance-%s' chain='root'>\n" \
764
        nwfilter_xml = "<filter name='nova-instance-%s' chain='root'>\n" \
3385
783
                       "  <filterref filter='nova-base' />\n" % \
765
                       "  <filterref filter='nova-base' />\n" % \
3386
@@ -789,20 +771,19 @@
3387
789
            net, mask = self._get_net_and_mask(network_ref['cidr'])
771
            net, mask = self._get_net_and_mask(network_ref['cidr'])
3388
790
            project_filter = self.nova_project_filter(instance['project_id'],
772
            project_filter = self.nova_project_filter(instance['project_id'],
3389
791
                                                      net, mask)
773
                                                      net, mask)
3391
792
            yield self._define_filter(project_filter)
774
            self._define_filter(project_filter)
3392
793
775
3393
794
            nwfilter_xml += "  <filterref filter='nova-project-%s' />\n" % \
776
            nwfilter_xml += "  <filterref filter='nova-project-%s' />\n" % \
3394
795
                            instance['project_id']
777
                            instance['project_id']
3395
796
778
3396
797
        for security_group in instance.security_groups:
779
        for security_group in instance.security_groups:
3398
798
            yield self.ensure_security_group_filter(security_group['id'])
780
            self.ensure_security_group_filter(security_group['id'])
3399
799
781
3400
800
            nwfilter_xml += "  <filterref filter='nova-secgroup-%d' />\n" % \
782
            nwfilter_xml += "  <filterref filter='nova-secgroup-%d' />\n" % \
3401
801
                            security_group['id']
783
                            security_group['id']
3402
802
        nwfilter_xml += "</filter>"
784
        nwfilter_xml += "</filter>"
3403
803
785
3406
804
        yield self._define_filter(nwfilter_xml)
786
        self._define_filter(nwfilter_xml)
3405
805
        return
3407
806
787
3408
807
    def ensure_security_group_filter(self, security_group_id):
788
    def ensure_security_group_filter(self, security_group_id):
3409
808
        return self._define_filter(
789
        return self._define_filter(
3410
809
790
3411
=== modified file 'nova/virt/xenapi/network_utils.py'
3412
--- nova/virt/xenapi/network_utils.py	2010-12-06 12:42:34 +0000
3413
+++ nova/virt/xenapi/network_utils.py	2010-12-16 20:49:10 +0000
3414
@@ -20,8 +20,6 @@
3415
20
their lookup functions.
20
their lookup functions.
3416
21
"""
21
"""
3417
22
22
3418
23
from twisted.internet import defer
3419
24
3420
25
23
3421
26
class NetworkHelper():
24
class NetworkHelper():
3422
27
    """
25
    """
3423
@@ -31,14 +29,12 @@
3424
31
        return
29
        return
3425
32
30
3426
33
    @classmethod
31
    @classmethod
3427
34
    @defer.inlineCallbacks
3428
35
    def find_network_with_bridge(cls, session, bridge):
32
    def find_network_with_bridge(cls, session, bridge):
3430
36
        """ Return the network on which the bridge is attached, if found """
33
        """ Return the network on which the bridge is attached, if found."""
3431
37
        expr = 'field "bridge" = "%s"' % bridge
34
        expr = 'field "bridge" = "%s"' % bridge
3434
38
        networks = yield session.call_xenapi('network.get_all_records_where',
35
        networks = session.call_xenapi('network.get_all_records_where', expr)
3433
39
                                           expr)
3435
40
        if len(networks) == 1:
36
        if len(networks) == 1:
3437
41
            defer.returnValue(networks.keys()[0])
37
            return networks.keys()[0]
3438
42
        elif len(networks) > 1:
38
        elif len(networks) > 1:
3439
43
            raise Exception('Found non-unique network for bridge %s' % bridge)
39
            raise Exception('Found non-unique network for bridge %s' % bridge)
3440
44
        else:
40
        else:
3441
45
41
3442
=== modified file 'nova/virt/xenapi/vm_utils.py'
3443
--- nova/virt/xenapi/vm_utils.py	2010-12-09 19:37:30 +0000
3444
+++ nova/virt/xenapi/vm_utils.py	2010-12-16 20:49:10 +0000
3445
@@ -21,19 +21,14 @@
3446
21
21
3447
22
import logging
22
import logging
3448
23
import urllib
23
import urllib
3449
24
3450
25
from twisted.internet import defer
3451
26
from xml.dom import minidom
24
from xml.dom import minidom
3452
27
25
3453
28
from nova import flags
3454
29
from nova import utils
26
from nova import utils
3455
30
3456
31
from nova.auth.manager import AuthManager
27
from nova.auth.manager import AuthManager
3457
32
from nova.compute import instance_types
28
from nova.compute import instance_types
3458
33
from nova.compute import power_state
29
from nova.compute import power_state
3459
34
from nova.virt import images
30
from nova.virt import images
3460
35
31
3461
36
FLAGS = flags.FLAGS
3462
37
32
3463
38
XENAPI_POWER_STATE = {
33
XENAPI_POWER_STATE = {
3464
39
    'Halted': power_state.SHUTDOWN,
34
    'Halted': power_state.SHUTDOWN,
3465
@@ -42,6 +37,7 @@
3466
42
    'Suspended': power_state.SHUTDOWN,  # FIXME
37
    'Suspended': power_state.SHUTDOWN,  # FIXME
3467
43
    'Crashed': power_state.CRASHED}
38
    'Crashed': power_state.CRASHED}
3468
44
39
3469
40
3470
45
XenAPI = None
41
XenAPI = None
3471
46
42
3472
47
43
3473
@@ -64,7 +60,6 @@
3474
64
            XenAPI = __import__('XenAPI')
60
            XenAPI = __import__('XenAPI')
3475
65
61
3476
66
    @classmethod
62
    @classmethod
3477
67
    @defer.inlineCallbacks
3478
68
    def create_vm(cls, session, instance, kernel, ramdisk):
63
    def create_vm(cls, session, instance, kernel, ramdisk):
3479
69
        """Create a VM record.  Returns a Deferred that gives the new
64
        """Create a VM record.  Returns a Deferred that gives the new
3480
70
        VM reference."""
65
        VM reference."""
3481
@@ -102,12 +97,11 @@
3482
102
            'other_config': {},
97
            'other_config': {},
3483
103
            }
98
            }
3484
104
        logging.debug('Created VM %s...', instance.name)
99
        logging.debug('Created VM %s...', instance.name)
3486
105
        vm_ref = yield session.call_xenapi('VM.create', rec)
100
        vm_ref = session.call_xenapi('VM.create', rec)
3487
106
        logging.debug('Created VM %s as %s.', instance.name, vm_ref)
101
        logging.debug('Created VM %s as %s.', instance.name, vm_ref)
3489
107
        defer.returnValue(vm_ref)
102
        return vm_ref
3490
108
103
3491
109
    @classmethod
104
    @classmethod
3492
110
    @defer.inlineCallbacks
3493
111
    def create_vbd(cls, session, vm_ref, vdi_ref, userdevice, bootable):
105
    def create_vbd(cls, session, vm_ref, vdi_ref, userdevice, bootable):
3494
112
        """Create a VBD record.  Returns a Deferred that gives the new
106
        """Create a VBD record.  Returns a Deferred that gives the new
3495
113
        VBD reference."""
107
        VBD reference."""
3496
@@ -126,13 +120,12 @@
3497
126
        vbd_rec['qos_algorithm_params'] = {}
120
        vbd_rec['qos_algorithm_params'] = {}
3498
127
        vbd_rec['qos_supported_algorithms'] = []
121
        vbd_rec['qos_supported_algorithms'] = []
3499
128
        logging.debug('Creating VBD for VM %s, VDI %s ... ', vm_ref, vdi_ref)
122
        logging.debug('Creating VBD for VM %s, VDI %s ... ', vm_ref, vdi_ref)
3501
129
        vbd_ref = yield session.call_xenapi('VBD.create', vbd_rec)
123
        vbd_ref = session.call_xenapi('VBD.create', vbd_rec)
3502
130
        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
124
        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
3503
131
                      vdi_ref)
125
                      vdi_ref)
3505
132
        defer.returnValue(vbd_ref)
126
        return vbd_ref
3506
133
127
3507
134
    @classmethod
128
    @classmethod
3508
135
    @defer.inlineCallbacks
3509
136
    def create_vif(cls, session, vm_ref, network_ref, mac_address):
129
    def create_vif(cls, session, vm_ref, network_ref, mac_address):
3510
137
        """Create a VIF record.  Returns a Deferred that gives the new
130
        """Create a VIF record.  Returns a Deferred that gives the new
3511
138
        VIF reference."""
131
        VIF reference."""
3512
@@ -148,13 +141,12 @@
3513
148
        vif_rec['qos_algorithm_params'] = {}
141
        vif_rec['qos_algorithm_params'] = {}
3514
149
        logging.debug('Creating VIF for VM %s, network %s ... ', vm_ref,
142
        logging.debug('Creating VIF for VM %s, network %s ... ', vm_ref,
3515
150
                      network_ref)
143
                      network_ref)
3517
151
        vif_ref = yield session.call_xenapi('VIF.create', vif_rec)
144
        vif_ref = session.call_xenapi('VIF.create', vif_rec)
3518
152
        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
145
        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
3519
153
                      vm_ref, network_ref)
146
                      vm_ref, network_ref)
3521
154
        defer.returnValue(vif_ref)
147
        return vif_ref
3522
155
148
3523
156
    @classmethod
149
    @classmethod
3524
157
    @defer.inlineCallbacks
3525
158
    def fetch_image(cls, session, image, user, project, use_sr):
150
    def fetch_image(cls, session, image, user, project, use_sr):
3526
159
        """use_sr: True to put the image as a VDI in an SR, False to place
151
        """use_sr: True to put the image as a VDI in an SR, False to place
3527
160
        it on dom0's filesystem.  The former is for VM disks, the latter for
152
        it on dom0's filesystem.  The former is for VM disks, the latter for
3528
@@ -171,12 +163,11 @@
3529
171
        args['password'] = user.secret
163
        args['password'] = user.secret
3530
172
        if use_sr:
164
        if use_sr:
3531
173
            args['add_partition'] = 'true'
165
            args['add_partition'] = 'true'
3535
174
        task = yield session.async_call_plugin('objectstore', fn, args)
166
        task = session.async_call_plugin('objectstore', fn, args)
3536
175
        uuid = yield session.wait_for_task(task)
167
        uuid = session.wait_for_task(task)
3537
176
        defer.returnValue(uuid)
168
        return uuid
3538
177
169
3539
178
    @classmethod
170
    @classmethod
3540
179
    @utils.deferredToThread
3541
180
    def lookup(cls, session, i):
171
    def lookup(cls, session, i):
3542
181
        """ Look the instance i up, and returns it if available """
172
        """ Look the instance i up, and returns it if available """
3543
182
        return VMHelper.lookup_blocking(session, i)
173
        return VMHelper.lookup_blocking(session, i)
3544
@@ -194,7 +185,6 @@
3545
194
            return vms[0]
185
            return vms[0]
3546
195
186
3547
196
    @classmethod
187
    @classmethod
3548
197
    @utils.deferredToThread
3549
198
    def lookup_vm_vdis(cls, session, vm):
188
    def lookup_vm_vdis(cls, session, vm):
3550
199
        """ Look for the VDIs that are attached to the VM """
189
        """ Look for the VDIs that are attached to the VM """
3551
200
        return VMHelper.lookup_vm_vdis_blocking(session, vm)
190
        return VMHelper.lookup_vm_vdis_blocking(session, vm)
3552
201
191
3553
=== modified file 'nova/virt/xenapi/vmops.py'
3554
--- nova/virt/xenapi/vmops.py	2010-12-09 17:08:24 +0000
3555
+++ nova/virt/xenapi/vmops.py	2010-12-16 20:49:10 +0000
3556
@@ -20,8 +20,6 @@
3557
20
20
3558
21
import logging
21
import logging
3559
22
22
3560
23
from twisted.internet import defer
3561
24
3562
25
from nova import db
23
from nova import db
3563
26
from nova import context
24
from nova import context
3564
27
25
3565
@@ -49,10 +47,9 @@
3566
49
        return [self._session.get_xenapi().VM.get_name_label(vm) \
47
        return [self._session.get_xenapi().VM.get_name_label(vm) \
3567
50
                for vm in self._session.get_xenapi().VM.get_all()]
48
                for vm in self._session.get_xenapi().VM.get_all()]
3568
51
49
3569
52
    @defer.inlineCallbacks
3570
53
    def spawn(self, instance):
50
    def spawn(self, instance):
3571
54
        """ Create VM instance """
51
        """ Create VM instance """
3573
55
        vm = yield VMHelper.lookup(self._session, instance.name)
52
        vm = VMHelper.lookup(self._session, instance.name)
3574
56
        if vm is not None:
53
        if vm is not None:
3575
57
            raise Exception('Attempted to create non-unique name %s' %
54
            raise Exception('Attempted to create non-unique name %s' %
3576
58
                            instance.name)
55
                            instance.name)
3577
@@ -60,66 +57,63 @@
3578
60
        bridge = db.project_get_network(context.get_admin_context(),
57
        bridge = db.project_get_network(context.get_admin_context(),
3579
61
                                      instance.project_id).bridge
58
                                      instance.project_id).bridge
3580
62
        network_ref = \
59
        network_ref = \
3582
63
            yield NetworkHelper.find_network_with_bridge(self._session, bridge)
60
            NetworkHelper.find_network_with_bridge(self._session, bridge)
3583
64
61
3584
65
        user = AuthManager().get_user(instance.user_id)
62
        user = AuthManager().get_user(instance.user_id)
3585
66
        project = AuthManager().get_project(instance.project_id)
63
        project = AuthManager().get_project(instance.project_id)
3596
67
        vdi_uuid = yield VMHelper.fetch_image(self._session,
64
        vdi_uuid = VMHelper.fetch_image(
3597
68
            instance.image_id, user, project, True)
65
                self._session, instance.image_id, user, project, True)
3598
69
        kernel = yield VMHelper.fetch_image(self._session,
66
        kernel = VMHelper.fetch_image(
3599
70
            instance.kernel_id, user, project, False)
67
                self._session, instance.kernel_id, user, project, False)
3600
71
        ramdisk = yield VMHelper.fetch_image(self._session,
68
        ramdisk = VMHelper.fetch_image(
3601
72
            instance.ramdisk_id, user, project, False)
69
                self._session, instance.ramdisk_id, user, project, False)
3602
73
        vdi_ref = yield self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
70
        vdi_ref = self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
3603
74
        vm_ref = yield VMHelper.create_vm(self._session,
71
        vm_ref = VMHelper.create_vm(
3604
75
                                          instance, kernel, ramdisk)
72
                self._session, instance, kernel, ramdisk)
3605
76
        yield VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
73
        VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
3606
77
        if network_ref:
74
        if network_ref:
3609
78
            yield VMHelper.create_vif(self._session, vm_ref,
75
            VMHelper.create_vif(self._session, vm_ref,
3610
79
                                      network_ref, instance.mac_address)
76
                                network_ref, instance.mac_address)
3611
80
        logging.debug('Starting VM %s...', vm_ref)
77
        logging.debug('Starting VM %s...', vm_ref)
3613
81
        yield self._session.call_xenapi('VM.start', vm_ref, False, False)
78
        self._session.call_xenapi('VM.start', vm_ref, False, False)
3614
82
        logging.info('Spawning VM %s created %s.', instance.name,
79
        logging.info('Spawning VM %s created %s.', instance.name,
3615
83
                     vm_ref)
80
                     vm_ref)
3616
84
81
3617
85
    @defer.inlineCallbacks
3618
86
    def reboot(self, instance):
82
    def reboot(self, instance):
3619
87
        """ Reboot VM instance """
83
        """ Reboot VM instance """
3620
88
        instance_name = instance.name
84
        instance_name = instance.name
3622
89
        vm = yield VMHelper.lookup(self._session, instance_name)
85
        vm = VMHelper.lookup(self._session, instance_name)
3623
90
        if vm is None:
86
        if vm is None:
3624
91
            raise Exception('instance not present %s' % instance_name)
87
            raise Exception('instance not present %s' % instance_name)
3627
92
        task = yield self._session.call_xenapi('Async.VM.clean_reboot', vm)
88
        task = self._session.call_xenapi('Async.VM.clean_reboot', vm)
3628
93
        yield self._session.wait_for_task(task)
89
        self._session.wait_for_task(task)
3629
94
90
3630
95
    @defer.inlineCallbacks
3631
96
    def destroy(self, instance):
91
    def destroy(self, instance):
3632
97
        """ Destroy VM instance """
92
        """ Destroy VM instance """
3634
98
        vm = yield VMHelper.lookup(self._session, instance.name)
93
        vm = VMHelper.lookup(self._session, instance.name)
3635
99
        if vm is None:
94
        if vm is None:
3636
100
            # Don't complain, just return.  This lets us clean up instances
95
            # Don't complain, just return.  This lets us clean up instances
3637
101
            # that have already disappeared from the underlying platform.
96
            # that have already disappeared from the underlying platform.
3639
102
            defer.returnValue(None)
97
            return
3640
103
        # Get the VDIs related to the VM
98
        # Get the VDIs related to the VM
3642
104
        vdis = yield VMHelper.lookup_vm_vdis(self._session, vm)
99
        vdis = VMHelper.lookup_vm_vdis(self._session, vm)
3643
105
        try:
100
        try:
3645
106
            task = yield self._session.call_xenapi('Async.VM.hard_shutdown',
101
            task = self._session.call_xenapi('Async.VM.hard_shutdown',
3646
107
                                                   vm)
102
                                                   vm)
3648
108
            yield self._session.wait_for_task(task)
103
            self._session.wait_for_task(task)
3649
109
        except XenAPI.Failure, exc:
104
        except XenAPI.Failure, exc:
3650
110
            logging.warn(exc)
105
            logging.warn(exc)
3651
111
        # Disk clean-up
106
        # Disk clean-up
3652
112
        if vdis:
107
        if vdis:
3653
113
            for vdi in vdis:
108
            for vdi in vdis:
3654
114
                try:
109
                try:
3658
115
                    task = yield self._session.call_xenapi('Async.VDI.destroy',
110
                    task = self._session.call_xenapi('Async.VDI.destroy', vdi)
3659
116
                                                           vdi)
111
                    self._session.wait_for_task(task)
3657
117
                    yield self._session.wait_for_task(task)
3660
118
                except XenAPI.Failure, exc:
112
                except XenAPI.Failure, exc:
3661
119
                    logging.warn(exc)
113
                    logging.warn(exc)
3662
120
        try:
114
        try:
3665
121
            task = yield self._session.call_xenapi('Async.VM.destroy', vm)
115
            task = self._session.call_xenapi('Async.VM.destroy', vm)
3666
122
            yield self._session.wait_for_task(task)
116
            self._session.wait_for_task(task)
3667
123
        except XenAPI.Failure, exc:
117
        except XenAPI.Failure, exc:
3668
124
            logging.warn(exc)
118
            logging.warn(exc)
3669
125
119
3670
@@ -131,14 +125,13 @@
3671
131
        rec = self._session.get_xenapi().VM.get_record(vm)
125
        rec = self._session.get_xenapi().VM.get_record(vm)
3672
132
        return VMHelper.compile_info(rec)
126
        return VMHelper.compile_info(rec)
3673
133
127
3674
134
    @defer.inlineCallbacks
3675
135
    def get_diagnostics(self, instance_id):
128
    def get_diagnostics(self, instance_id):
3676
136
        """Return data about VM diagnostics"""
129
        """Return data about VM diagnostics"""
3678
137
        vm = yield VMHelper.lookup(self._session, instance_id)
130
        vm = VMHelper.lookup(self._session, instance_id)
3679
138
        if vm is None:
131
        if vm is None:
3680
139
            raise Exception("instance not present %s" % instance_id)
132
            raise Exception("instance not present %s" % instance_id)
3683
140
        rec = yield self._session.get_xenapi().VM.get_record(vm)
133
        rec = self._session.get_xenapi().VM.get_record(vm)
3684
141
        defer.returnValue(VMHelper.compile_diagnostics(self._session, rec))
134
        return VMHelper.compile_diagnostics(self._session, rec)
3685
142
135
3686
143
    def get_console_output(self, instance):
136
    def get_console_output(self, instance):
3687
144
        """ Return snapshot of console """
137
        """ Return snapshot of console """
3688
145
138
3689
=== modified file 'nova/virt/xenapi_conn.py'
3690
--- nova/virt/xenapi_conn.py	2010-12-08 20:16:49 +0000
3691
+++ nova/virt/xenapi_conn.py	2010-12-16 20:49:10 +0000
3692
@@ -48,10 +48,11 @@
3693
48
"""
48
"""
3694
49
49
3695
50
import logging
50
import logging
3696
51
import sys
3697
51
import xmlrpclib
52
import xmlrpclib
3698
52
53
3701
53
from twisted.internet import defer
54
from eventlet import event
3702
54
from twisted.internet import reactor
55
from eventlet import tpool
3703
55
56
3704
56
from nova import utils
57
from nova import utils
3705
57
from nova import flags
58
from nova import flags
3706
@@ -159,53 +160,51 @@
3707
159
        """ Return the xenapi host """
160
        """ Return the xenapi host """
3708
160
        return self._session.xenapi.session.get_this_host(self._session.handle)
161
        return self._session.xenapi.session.get_this_host(self._session.handle)
3709
161
162
3710
162
    @utils.deferredToThread
3711
163
    def call_xenapi(self, method, *args):
163
    def call_xenapi(self, method, *args):
3714
164
        """Call the specified XenAPI method on a background thread.  Returns
164
        """Call the specified XenAPI method on a background thread."""
3713
165
        a Deferred for the result."""
3715
166
        f = self._session.xenapi
165
        f = self._session.xenapi
3716
167
        for m in method.split('.'):
166
        for m in method.split('.'):
3717
168
            f = f.__getattr__(m)
167
            f = f.__getattr__(m)
3719
169
        return f(*args)
168
        return tpool.execute(f, *args)
3720
170
169
3721
171
    @utils.deferredToThread
3722
172
    def async_call_plugin(self, plugin, fn, args):
170
    def async_call_plugin(self, plugin, fn, args):
3728
173
        """Call Async.host.call_plugin on a background thread.  Returns a
171
        """Call Async.host.call_plugin on a background thread."""
3729
174
        Deferred with the task reference."""
172
        return tpool.execute(_unwrap_plugin_exceptions,
3730
175
        return _unwrap_plugin_exceptions(
173
                             self._session.xenapi.Async.host.call_plugin,
3731
176
            self._session.xenapi.Async.host.call_plugin,
174
                             self.get_xenapi_host(), plugin, fn, args)
3727
177
            self.get_xenapi_host(), plugin, fn, args)
3732
178
175
3733
179
    def wait_for_task(self, task):
176
    def wait_for_task(self, task):
3734
180
        """Return a Deferred that will give the result of the given task.
177
        """Return a Deferred that will give the result of the given task.
3735
181
        The task is polled until it completes."""
178
        The task is polled until it completes."""
3742
182
        d = defer.Deferred()
179
3743
183
        reactor.callLater(0, self._poll_task, task, d)
180
        done = event.Event()
3744
184
        return d
181
        loop = utils.LoopingCall(self._poll_task, task, done)
3745
185
182
        loop.start(FLAGS.xenapi_task_poll_interval, now=True)
3746
186
    @utils.deferredToThread
183
        rv = done.wait()
3747
187
    def _poll_task(self, task, deferred):
184
        loop.stop()
3748
185
        return rv
3749
186
3750
187
    def _poll_task(self, task, done):
3751
188
        """Poll the given XenAPI task, and fire the given Deferred if we
188
        """Poll the given XenAPI task, and fire the given Deferred if we
3752
189
        get a result."""
189
        get a result."""
3753
190
        try:
190
        try:
3754
191
            #logging.debug('Polling task %s...', task)
191
            #logging.debug('Polling task %s...', task)
3755
192
            status = self._session.xenapi.task.get_status(task)
192
            status = self._session.xenapi.task.get_status(task)
3756
193
            if status == 'pending':
193
            if status == 'pending':
3759
194
                reactor.callLater(FLAGS.xenapi_task_poll_interval,
194
                return
3758
195
                                  self._poll_task, task, deferred)
3760
196
            elif status == 'success':
195
            elif status == 'success':
3761
197
                result = self._session.xenapi.task.get_result(task)
196
                result = self._session.xenapi.task.get_result(task)
3762
198
                logging.info('Task %s status: success.  %s', task, result)
197
                logging.info('Task %s status: success.  %s', task, result)
3764
199
                deferred.callback(_parse_xmlrpc_value(result))
198
                done.send(_parse_xmlrpc_value(result))
3765
200
            else:
199
            else:
3766
201
                error_info = self._session.xenapi.task.get_error_info(task)
200
                error_info = self._session.xenapi.task.get_error_info(task)
3767
202
                logging.warn('Task %s status: %s.  %s', task, status,
201
                logging.warn('Task %s status: %s.  %s', task, status,
3768
203
                             error_info)
202
                             error_info)
3771
204
                deferred.errback(XenAPI.Failure(error_info))
203
                done.send_exception(XenAPI.Failure(error_info))
3772
205
            #logging.debug('Polling task %s done.', task)
204
                #logging.debug('Polling task %s done.', task)
3773
206
        except XenAPI.Failure, exc:
205
        except XenAPI.Failure, exc:
3774
207
            logging.warn(exc)
206
            logging.warn(exc)
3776
208
            deferred.errback(exc)
207
            done.send_exception(*sys.exc_info())
3777
209
208
3778
210
209
3779
211
def _unwrap_plugin_exceptions(func, *args, **kwargs):
210
def _unwrap_plugin_exceptions(func, *args, **kwargs):
3780
212
211
3781
=== modified file 'nova/volume/driver.py'
3782
--- nova/volume/driver.py	2010-11-03 22:06:00 +0000
3783
+++ nova/volume/driver.py	2010-12-16 20:49:10 +0000
3784
@@ -22,12 +22,10 @@
3785
22
22
3786
23
import logging
23
import logging
3787
24
import os
24
import os
3790
25
25
import time
3789
26
from twisted.internet import defer
3791
27
26
3792
28
from nova import exception
27
from nova import exception
3793
29
from nova import flags
28
from nova import flags
3794
30
from nova import process
3795
31
from nova import utils
29
from nova import utils
3796
32
30
3797
33
31
3798
@@ -55,14 +53,13 @@
3799
55
53
3800
56
class VolumeDriver(object):
54
class VolumeDriver(object):
3801
57
    """Executes commands relating to Volumes."""
55
    """Executes commands relating to Volumes."""
3803
58
    def __init__(self, execute=process.simple_execute,
56
    def __init__(self, execute=utils.execute,
3804
59
                 sync_exec=utils.execute, *args, **kwargs):
57
                 sync_exec=utils.execute, *args, **kwargs):
3805
60
        # NOTE(vish): db is set by Manager
58
        # NOTE(vish): db is set by Manager
3806
61
        self.db = None
59
        self.db = None
3807
62
        self._execute = execute
60
        self._execute = execute
3808
63
        self._sync_exec = sync_exec
61
        self._sync_exec = sync_exec
3809
64
62
3810
65
    @defer.inlineCallbacks
3811
66
    def _try_execute(self, command):
63
    def _try_execute(self, command):
3812
67
        # NOTE(vish): Volume commands can partially fail due to timing, but
64
        # NOTE(vish): Volume commands can partially fail due to timing, but
3813
68
        #             running them a second time on failure will usually
65
        #             running them a second time on failure will usually
3814
@@ -70,15 +67,15 @@
3815
70
        tries = 0
67
        tries = 0
3816
71
        while True:
68
        while True:
3817
72
            try:
69
            try:
3820
73
                yield self._execute(command)
70
                self._execute(command)
3821
74
                defer.returnValue(True)
71
                return True
3822
75
            except exception.ProcessExecutionError:
72
            except exception.ProcessExecutionError:
3823
76
                tries = tries + 1
73
                tries = tries + 1
3824
77
                if tries >= FLAGS.num_shell_tries:
74
                if tries >= FLAGS.num_shell_tries:
3825
78
                    raise
75
                    raise
3826
79
                logging.exception("Recovering from a failed execute."
76
                logging.exception("Recovering from a failed execute."
3827
80
                                  "Try number %s", tries)
77
                                  "Try number %s", tries)
3829
81
                yield self._execute("sleep %s" % tries ** 2)
78
                time.sleep(tries ** 2)
3830
82
79
3831
83
    def check_for_setup_error(self):
80
    def check_for_setup_error(self):
3832
84
        """Returns an error if prerequisites aren't met"""
81
        """Returns an error if prerequisites aren't met"""
3833
@@ -86,53 +83,45 @@
3834
86
            raise exception.Error("volume group %s doesn't exist"
83
            raise exception.Error("volume group %s doesn't exist"
3835
87
                                  % FLAGS.volume_group)
84
                                  % FLAGS.volume_group)
3836
88
85
3837
89
    @defer.inlineCallbacks
3838
90
    def create_volume(self, volume):
86
    def create_volume(self, volume):
3839
91
        """Creates a logical volume."""
87
        """Creates a logical volume."""
3840
92
        if int(volume['size']) == 0:
88
        if int(volume['size']) == 0:
3841
93
            sizestr = '100M'
89
            sizestr = '100M'
3842
94
        else:
90
        else:
3843
95
            sizestr = '%sG' % volume['size']
91
            sizestr = '%sG' % volume['size']
3848
96
        yield self._try_execute("sudo lvcreate -L %s -n %s %s" %
92
        self._try_execute("sudo lvcreate -L %s -n %s %s" %
3849
97
                            (sizestr,
93
                          (sizestr,
3850
98
                             volume['name'],
94
                           volume['name'],
3851
99
                             FLAGS.volume_group))
95
                           FLAGS.volume_group))
3852
100
96
3853
101
    @defer.inlineCallbacks
3854
102
    def delete_volume(self, volume):
97
    def delete_volume(self, volume):
3855
103
        """Deletes a logical volume."""
98
        """Deletes a logical volume."""
3859
104
        yield self._try_execute("sudo lvremove -f %s/%s" %
99
        self._try_execute("sudo lvremove -f %s/%s" %
3860
105
                                (FLAGS.volume_group,
100
                          (FLAGS.volume_group,
3861
106
                                 volume['name']))
101
                           volume['name']))
3862
107
102
3863
108
    @defer.inlineCallbacks
3864
109
    def local_path(self, volume):
103
    def local_path(self, volume):
3866
110
        yield  # NOTE(vish): stops deprecation warning
104
        # NOTE(vish): stops deprecation warning
3867
111
        escaped_group = FLAGS.volume_group.replace('-', '--')
105
        escaped_group = FLAGS.volume_group.replace('-', '--')
3868
112
        escaped_name = volume['name'].replace('-', '--')
106
        escaped_name = volume['name'].replace('-', '--')
3871
113
        defer.returnValue("/dev/mapper/%s-%s" % (escaped_group,
107
        return "/dev/mapper/%s-%s" % (escaped_group, escaped_name)
3870
114
                                                 escaped_name))
3872
115
108
3873
116
    def ensure_export(self, context, volume):
109
    def ensure_export(self, context, volume):
3874
117
        """Synchronously recreates an export for a logical volume."""
110
        """Synchronously recreates an export for a logical volume."""
3875
118
        raise NotImplementedError()
111
        raise NotImplementedError()
3876
119
112
3877
120
    @defer.inlineCallbacks
3878
121
    def create_export(self, context, volume):
113
    def create_export(self, context, volume):
3879
122
        """Exports the volume."""
114
        """Exports the volume."""
3880
123
        raise NotImplementedError()
115
        raise NotImplementedError()
3881
124
116
3882
125
    @defer.inlineCallbacks
3883
126
    def remove_export(self, context, volume):
117
    def remove_export(self, context, volume):
3884
127
        """Removes an export for a logical volume."""
118
        """Removes an export for a logical volume."""
3885
128
        raise NotImplementedError()
119
        raise NotImplementedError()
3886
129
120
3887
130
    @defer.inlineCallbacks
3888
131
    def discover_volume(self, volume):
121
    def discover_volume(self, volume):
3889
132
        """Discover volume on a remote host."""
122
        """Discover volume on a remote host."""
3890
133
        raise NotImplementedError()
123
        raise NotImplementedError()
3891
134
124
3892
135
    @defer.inlineCallbacks
3893
136
    def undiscover_volume(self, volume):
125
    def undiscover_volume(self, volume):
3894
137
        """Undiscover volume on a remote host."""
126
        """Undiscover volume on a remote host."""
3895
138
        raise NotImplementedError()
127
        raise NotImplementedError()
3896
@@ -155,14 +144,13 @@
3897
155
                dev = {'shelf_id': shelf_id, 'blade_id': blade_id}
144
                dev = {'shelf_id': shelf_id, 'blade_id': blade_id}
3898
156
                self.db.export_device_create_safe(context, dev)
145
                self.db.export_device_create_safe(context, dev)
3899
157
146
3900
158
    @defer.inlineCallbacks
3901
159
    def create_export(self, context, volume):
147
    def create_export(self, context, volume):
3902
160
        """Creates an export for a logical volume."""
148
        """Creates an export for a logical volume."""
3903
161
        self._ensure_blades(context)
149
        self._ensure_blades(context)
3904
162
        (shelf_id,
150
        (shelf_id,
3905
163
         blade_id) = self.db.volume_allocate_shelf_and_blade(context,
151
         blade_id) = self.db.volume_allocate_shelf_and_blade(context,
3906
164
                                                             volume['id'])
152
                                                             volume['id'])
3908
165
        yield self._try_execute(
153
        self._try_execute(
3909
166
                "sudo vblade-persist setup %s %s %s /dev/%s/%s" %
154
                "sudo vblade-persist setup %s %s %s /dev/%s/%s" %
3910
167
                (shelf_id,
155
                (shelf_id,
3911
168
                 blade_id,
156
                 blade_id,
3912
@@ -176,33 +164,30 @@
3913
176
        #             still works for the other volumes, so we
164
        #             still works for the other volumes, so we
3914
177
        #             just wait a bit for the current volume to
165
        #             just wait a bit for the current volume to
3915
178
        #             be ready and ignore any errors.
166
        #             be ready and ignore any errors.
3921
179
        yield self._execute("sleep 2")
167
        time.sleep(2)
3922
180
        yield self._execute("sudo vblade-persist auto all",
168
        self._execute("sudo vblade-persist auto all",
3923
181
                            check_exit_code=False)
169
                      check_exit_code=False)
3924
182
        yield self._execute("sudo vblade-persist start all",
170
        self._execute("sudo vblade-persist start all",
3925
183
                            check_exit_code=False)
171
                      check_exit_code=False)
3926
184
172
3927
185
    @defer.inlineCallbacks
3928
186
    def remove_export(self, context, volume):
173
    def remove_export(self, context, volume):
3929
187
        """Removes an export for a logical volume."""
174
        """Removes an export for a logical volume."""
3930
188
        (shelf_id,
175
        (shelf_id,
3931
189
         blade_id) = self.db.volume_get_shelf_and_blade(context,
176
         blade_id) = self.db.volume_get_shelf_and_blade(context,
3932
190
                                                        volume['id'])
177
                                                        volume['id'])
3937
191
        yield self._try_execute("sudo vblade-persist stop %s %s" %
178
        self._try_execute("sudo vblade-persist stop %s %s" %
3938
192
                                (shelf_id, blade_id))
179
                          (shelf_id, blade_id))
3939
193
        yield self._try_execute("sudo vblade-persist destroy %s %s" %
180
        self._try_execute("sudo vblade-persist destroy %s %s" %
3940
194
                                (shelf_id, blade_id))
181
                          (shelf_id, blade_id))
3941
195
182
3942
196
    @defer.inlineCallbacks
3943
197
    def discover_volume(self, _volume):
183
    def discover_volume(self, _volume):
3944
198
        """Discover volume on a remote host."""
184
        """Discover volume on a remote host."""
3947
199
        yield self._execute("sudo aoe-discover")
185
        self._execute("sudo aoe-discover")
3948
200
        yield self._execute("sudo aoe-stat", check_exit_code=False)
186
        self._execute("sudo aoe-stat", check_exit_code=False)
3949
201
187
3950
202
    @defer.inlineCallbacks
3951
203
    def undiscover_volume(self, _volume):
188
    def undiscover_volume(self, _volume):
3952
204
        """Undiscover volume on a remote host."""
189
        """Undiscover volume on a remote host."""
3954
205
        yield
190
        pass
3955
206
191
3956
207
192
3957
208
class FakeAOEDriver(AOEDriver):
193
class FakeAOEDriver(AOEDriver):
3958
@@ -252,7 +237,6 @@
3959
252
            target = {'host': host, 'target_num': target_num}
237
            target = {'host': host, 'target_num': target_num}
3960
253
            self.db.iscsi_target_create_safe(context, target)
238
            self.db.iscsi_target_create_safe(context, target)
3961
254
239
3962
255
    @defer.inlineCallbacks
3963
256
    def create_export(self, context, volume):
240
    def create_export(self, context, volume):
3964
257
        """Creates an export for a logical volume."""
241
        """Creates an export for a logical volume."""
3965
258
        self._ensure_iscsi_targets(context, volume['host'])
242
        self._ensure_iscsi_targets(context, volume['host'])
3966
@@ -261,61 +245,55 @@
3967
261
                                                      volume['host'])
245
                                                      volume['host'])
3968
262
        iscsi_name = "%s%s" % (FLAGS.iscsi_target_prefix, volume['name'])
246
        iscsi_name = "%s%s" % (FLAGS.iscsi_target_prefix, volume['name'])
3969
263
        volume_path = "/dev/%s/%s" % (FLAGS.volume_group, volume['name'])
247
        volume_path = "/dev/%s/%s" % (FLAGS.volume_group, volume['name'])
3976
264
        yield self._execute("sudo ietadm --op new "
248
        self._execute("sudo ietadm --op new "
3977
265
                            "--tid=%s --params Name=%s" %
249
                      "--tid=%s --params Name=%s" %
3978
266
                            (iscsi_target, iscsi_name))
250
                      (iscsi_target, iscsi_name))
3979
267
        yield self._execute("sudo ietadm --op new --tid=%s "
251
        self._execute("sudo ietadm --op new --tid=%s "
3980
268
                            "--lun=0 --params Path=%s,Type=fileio" %
252
                      "--lun=0 --params Path=%s,Type=fileio" %
3981
269
                            (iscsi_target, volume_path))
253
                      (iscsi_target, volume_path))
3982
270
254
3983
271
    @defer.inlineCallbacks
3984
272
    def remove_export(self, context, volume):
255
    def remove_export(self, context, volume):
3985
273
        """Removes an export for a logical volume."""
256
        """Removes an export for a logical volume."""
3986
274
        iscsi_target = self.db.volume_get_iscsi_target_num(context,
257
        iscsi_target = self.db.volume_get_iscsi_target_num(context,
3987
275
                                                           volume['id'])
258
                                                           volume['id'])
3992
276
        yield self._execute("sudo ietadm --op delete --tid=%s "
259
        self._execute("sudo ietadm --op delete --tid=%s "
3993
277
                            "--lun=0" % iscsi_target)
260
                      "--lun=0" % iscsi_target)
3994
278
        yield self._execute("sudo ietadm --op delete --tid=%s" %
261
        self._execute("sudo ietadm --op delete --tid=%s" %
3995
279
                            iscsi_target)
262
                      iscsi_target)
3996
280
263
3997
281
    @defer.inlineCallbacks
3998
282
    def _get_name_and_portal(self, volume_name, host):
264
    def _get_name_and_portal(self, volume_name, host):
3999
283
        """Gets iscsi name and portal from volume name and host."""
265
        """Gets iscsi name and portal from volume name and host."""
4002
284
        (out, _err) = yield self._execute("sudo iscsiadm -m discovery -t "
266
        (out, _err) = self._execute("sudo iscsiadm -m discovery -t "
4003
285
                                         "sendtargets -p %s" % host)
267
                                    "sendtargets -p %s" % host)
4004
286
        for target in out.splitlines():
268
        for target in out.splitlines():
4005
287
            if FLAGS.iscsi_ip_prefix in target and volume_name in target:
269
            if FLAGS.iscsi_ip_prefix in target and volume_name in target:
4006
288
                (location, _sep, iscsi_name) = target.partition(" ")
270
                (location, _sep, iscsi_name) = target.partition(" ")
4007
289
                break
271
                break
4008
290
        iscsi_portal = location.split(",")[0]
272
        iscsi_portal = location.split(",")[0]
4010
291
        defer.returnValue((iscsi_name, iscsi_portal))
273
        return (iscsi_name, iscsi_portal)
4011
292
274
4012
293
    @defer.inlineCallbacks
4013
294
    def discover_volume(self, volume):
275
    def discover_volume(self, volume):
4014
295
        """Discover volume on a remote host."""
276
        """Discover volume on a remote host."""
4024
296
        (iscsi_name,
277
        iscsi_name, iscsi_portal = self._get_name_and_portal(volume['name'],
4025
297
         iscsi_portal) = yield self._get_name_and_portal(volume['name'],
278
                                                             volume['host'])
4026
298
                                                         volume['host'])
279
        self._execute("sudo iscsiadm -m node -T %s -p %s --login" %
4027
299
        yield self._execute("sudo iscsiadm -m node -T %s -p %s --login" %
280
                      (iscsi_name, iscsi_portal))
4028
300
                            (iscsi_name, iscsi_portal))
281
        self._execute("sudo iscsiadm -m node -T %s -p %s --op update "
4029
301
        yield self._execute("sudo iscsiadm -m node -T %s -p %s --op update "
282
                      "-n node.startup -v automatic" %
4030
302
                            "-n node.startup -v automatic" %
283
                      (iscsi_name, iscsi_portal))
4031
303
                            (iscsi_name, iscsi_portal))
284
        return "/dev/iscsi/%s" % volume['name']
4023
304
        defer.returnValue("/dev/iscsi/%s" % volume['name'])
4032
305
285
4033
306
    @defer.inlineCallbacks
4034
307
    def undiscover_volume(self, volume):
286
    def undiscover_volume(self, volume):
4035
308
        """Undiscover volume on a remote host."""
287
        """Undiscover volume on a remote host."""
4046
309
        (iscsi_name,
288
        iscsi_name, iscsi_portal = self._get_name_and_portal(volume['name'],
4047
310
         iscsi_portal) = yield self._get_name_and_portal(volume['name'],
289
                                                             volume['host'])
4048
311
                                                         volume['host'])
290
        self._execute("sudo iscsiadm -m node -T %s -p %s --op update "
4049
312
        yield self._execute("sudo iscsiadm -m node -T %s -p %s --op update "
291
                      "-n node.startup -v manual" %
4050
313
                            "-n node.startup -v manual" %
292
                      (iscsi_name, iscsi_portal))
4051
314
                            (iscsi_name, iscsi_portal))
293
        self._execute("sudo iscsiadm -m node -T %s -p %s --logout " %
4052
315
        yield self._execute("sudo iscsiadm -m node -T %s -p %s --logout " %
294
                      (iscsi_name, iscsi_portal))
4053
316
                            (iscsi_name, iscsi_portal))
295
        self._execute("sudo iscsiadm -m node --op delete "
4054
317
        yield self._execute("sudo iscsiadm -m node --op delete "
296
                      "--targetname %s" % iscsi_name)
4045
318
                            "--targetname %s" % iscsi_name)
4055
319
297
4056
320
298
4057
321
class FakeISCSIDriver(ISCSIDriver):
299
class FakeISCSIDriver(ISCSIDriver):
4058
322
300
4059
=== modified file 'nova/volume/manager.py'
4060
--- nova/volume/manager.py	2010-11-03 21:38:14 +0000
4061
+++ nova/volume/manager.py	2010-12-16 20:49:10 +0000
4062
@@ -45,7 +45,6 @@
4063
45
import logging
45
import logging
4064
46
import datetime
46
import datetime
4065
47
47
4066
48
from twisted.internet import defer
4067
49
48
4068
50
from nova import context
49
from nova import context
4069
51
from nova import exception
50
from nova import exception
4070
@@ -86,7 +85,6 @@
4071
86
        for volume in volumes:
85
        for volume in volumes:
4072
87
            self.driver.ensure_export(ctxt, volume)
86
            self.driver.ensure_export(ctxt, volume)
4073
88
87
4074
89
    @defer.inlineCallbacks
4075
90
    def create_volume(self, context, volume_id):
88
    def create_volume(self, context, volume_id):
4076
91
        """Creates and exports the volume."""
89
        """Creates and exports the volume."""
4077
92
        context = context.elevated()
90
        context = context.elevated()
4078
@@ -102,19 +100,18 @@
4079
102
100
4080
103
        logging.debug("volume %s: creating lv of size %sG",
101
        logging.debug("volume %s: creating lv of size %sG",
4081
104
                      volume_ref['name'], volume_ref['size'])
102
                      volume_ref['name'], volume_ref['size'])
4083
105
        yield self.driver.create_volume(volume_ref)
103
        self.driver.create_volume(volume_ref)
4084
106
104
4085
107
        logging.debug("volume %s: creating export", volume_ref['name'])
105
        logging.debug("volume %s: creating export", volume_ref['name'])
4087
108
        yield self.driver.create_export(context, volume_ref)
106
        self.driver.create_export(context, volume_ref)
4088
109
107
4089
110
        now = datetime.datetime.utcnow()
108
        now = datetime.datetime.utcnow()
4090
111
        self.db.volume_update(context,
109
        self.db.volume_update(context,
4091
112
                              volume_ref['id'], {'status': 'available',
110
                              volume_ref['id'], {'status': 'available',
4092
113
                                                 'launched_at': now})
111
                                                 'launched_at': now})
4093
114
        logging.debug("volume %s: created successfully", volume_ref['name'])
112
        logging.debug("volume %s: created successfully", volume_ref['name'])
4095
115
        defer.returnValue(volume_id)
113
        return volume_id
4096
116
114
4097
117
    @defer.inlineCallbacks
4098
118
    def delete_volume(self, context, volume_id):
115
    def delete_volume(self, context, volume_id):
4099
119
        """Deletes and unexports volume."""
116
        """Deletes and unexports volume."""
4100
120
        context = context.elevated()
117
        context = context.elevated()
4101
@@ -124,14 +121,13 @@
4102
124
        if volume_ref['host'] != self.host:
121
        if volume_ref['host'] != self.host:
4103
125
            raise exception.Error("Volume is not local to this node")
122
            raise exception.Error("Volume is not local to this node")
4104
126
        logging.debug("volume %s: removing export", volume_ref['name'])
123
        logging.debug("volume %s: removing export", volume_ref['name'])
4106
127
        yield self.driver.remove_export(context, volume_ref)
124
        self.driver.remove_export(context, volume_ref)
4107
128
        logging.debug("volume %s: deleting", volume_ref['name'])
125
        logging.debug("volume %s: deleting", volume_ref['name'])
4109
129
        yield self.driver.delete_volume(volume_ref)
126
        self.driver.delete_volume(volume_ref)
4110
130
        self.db.volume_destroy(context, volume_id)
127
        self.db.volume_destroy(context, volume_id)
4111
131
        logging.debug("volume %s: deleted successfully", volume_ref['name'])
128
        logging.debug("volume %s: deleted successfully", volume_ref['name'])
4113
132
        defer.returnValue(True)
129
        return True
4114
133
130
4115
134
    @defer.inlineCallbacks
4116
135
    def setup_compute_volume(self, context, volume_id):
131
    def setup_compute_volume(self, context, volume_id):
4117
136
        """Setup remote volume on compute host.
132
        """Setup remote volume on compute host.
4118
137
133
4119
@@ -139,17 +135,16 @@
4120
139
        context = context.elevated()
135
        context = context.elevated()
4121
140
        volume_ref = self.db.volume_get(context, volume_id)
136
        volume_ref = self.db.volume_get(context, volume_id)
4122
141
        if volume_ref['host'] == self.host and FLAGS.use_local_volumes:
137
        if volume_ref['host'] == self.host and FLAGS.use_local_volumes:
4124
142
            path = yield self.driver.local_path(volume_ref)
138
            path = self.driver.local_path(volume_ref)
4125
143
        else:
139
        else:
4128
144
            path = yield self.driver.discover_volume(volume_ref)
140
            path = self.driver.discover_volume(volume_ref)
4129
145
        defer.returnValue(path)
141
        return path
4130
146
142
4131
147
    @defer.inlineCallbacks
4132
148
    def remove_compute_volume(self, context, volume_id):
143
    def remove_compute_volume(self, context, volume_id):
4133
149
        """Remove remote volume on compute host."""
144
        """Remove remote volume on compute host."""
4134
150
        context = context.elevated()
145
        context = context.elevated()
4135
151
        volume_ref = self.db.volume_get(context, volume_id)
146
        volume_ref = self.db.volume_get(context, volume_id)
4136
152
        if volume_ref['host'] == self.host and FLAGS.use_local_volumes:
147
        if volume_ref['host'] == self.host and FLAGS.use_local_volumes:
4138
153
            defer.returnValue(True)
148
            return True
4139
154
        else:
149
        else:
4141
155
            yield self.driver.undiscover_volume(volume_ref)
150
            self.driver.undiscover_volume(volume_ref)
4142
156
151
4143
=== modified file 'run_tests.py'
4144
--- run_tests.py	2010-12-11 20:10:24 +0000
4145
+++ run_tests.py	2010-12-16 20:49:10 +0000
4146
@@ -39,6 +39,9 @@
4147
39
39
4148
40
"""
40
"""
4149
41
41
4150
42
import eventlet
4151
43
eventlet.monkey_patch()
4152
44
4153
42
import __main__
45
import __main__
4154
43
import gettext
46
import gettext
4155
44
import os
47
import os
4156
@@ -59,15 +62,12 @@
4157
59
from nova.tests.flags_unittest import *
62
from nova.tests.flags_unittest import *
4158
60
from nova.tests.misc_unittest import *
63
from nova.tests.misc_unittest import *
4159
61
from nova.tests.network_unittest import *
64
from nova.tests.network_unittest import *
4162
62
from nova.tests.objectstore_unittest import *
65
#from nova.tests.objectstore_unittest import *
4161
63
from nova.tests.process_unittest import *
4163
64
from nova.tests.quota_unittest import *
66
from nova.tests.quota_unittest import *
4164
65
from nova.tests.rpc_unittest import *
67
from nova.tests.rpc_unittest import *
4165
66
from nova.tests.scheduler_unittest import *
68
from nova.tests.scheduler_unittest import *
4166
67
from nova.tests.service_unittest import *
69
from nova.tests.service_unittest import *
4167
68
from nova.tests.twistd_unittest import *
70
from nova.tests.twistd_unittest import *
4168
69
from nova.tests.validator_unittest import *
4169
70
from nova.tests.virt_unittest import *
4170
71
from nova.tests.virt_unittest import *
71
from nova.tests.virt_unittest import *
4171
72
from nova.tests.volume_unittest import *
72
from nova.tests.volume_unittest import *
4172
73
73
Status:	Merged
Approved by:	Eric Day on 2010-12-16
Approved revision:	400
Merged at revision:	465
Proposed branch:	lp:~termie/nova/eventlet_merge
Merge into:	lp:~hudson-openstack/nova/trunk
Diff against target:	4171 lines (+651/-1472) 45 files modified bin/nova-api (+8/-12) bin/nova-combined (+65/-0) bin/nova-compute (+6/-9) bin/nova-network (+6/-9) bin/nova-scheduler (+6/-9) bin/nova-volume (+6/-9) nova/compute/disk.py (+39/-45) nova/compute/manager.py (+20/-29) nova/flags.py (+7/-0) nova/manager.py (+1/-3) nova/network/manager.py (+1/-3) nova/objectstore/image.py (+1/-0) nova/process.py (+0/-209) nova/rpc.py (+26/-57) nova/server.py (+0/-151) nova/service.py (+0/-195) nova/test.py (+85/-15) nova/tests/access_unittest.py (+1/-1) nova/tests/auth_unittest.py (+3/-3) nova/tests/cloud_unittest.py (+2/-4) nova/tests/compute_unittest.py (+18/-23) nova/tests/flags_unittest.py (+1/-1) nova/tests/misc_unittest.py (+1/-1) nova/tests/network_unittest.py (+1/-1) nova/tests/objectstore_unittest.py (+2/-2) nova/tests/process_unittest.py (+0/-132) nova/tests/quota_unittest.py (+1/-1) nova/tests/rpc_unittest.py (+18/-18) nova/tests/scheduler_unittest.py (+12/-12) nova/tests/service_unittest.py (+14/-32) nova/tests/validator_unittest.py (+0/-42) nova/tests/virt_unittest.py (+5/-6) nova/tests/volume_unittest.py (+25/-33) nova/utils.py (+43/-13) nova/validate.py (+0/-94) nova/virt/fake.py (+3/-7) nova/virt/images.py (+6/-5) nova/virt/libvirt_conn.py (+80/-99) nova/virt/xenapi/network_utils.py (+3/-7) nova/virt/xenapi/vm_utils.py (+10/-20) nova/virt/xenapi/vmops.py (+30/-37) nova/virt/xenapi_conn.py (+23/-24) nova/volume/driver.py (+57/-79) nova/volume/manager.py (+11/-16) run_tests.py (+4/-4)
To merge this branch:	bzr merge lp:~termie/nova/eventlet_merge
Related bugs:	Link a bug report
Reviewer	Date Requested	Status
Jay Pipes (community)		Approve on 2010-12-15
Eric Day (community)	2010-12-10	Approve on 2010-12-15
Anthony Young (community)		Needs Fixing on 2010-12-11
Review via email: mp+43383@code.launchpad.net