1
=== modified file 'nova/api/ec2/apirequest.py'
2
--- nova/api/ec2/apirequest.py	2011-04-18 20:53:09 +0000
3
+++ nova/api/ec2/apirequest.py	2011-06-17 23:35:54 +0000
4
@@ -21,22 +21,15 @@
5
21
"""
21
"""
6
22
22
7
23
import datetime
23
import datetime
8
24
import re
9
25
# TODO(termie): replace minidom with etree
24
# TODO(termie): replace minidom with etree
10
26
from xml.dom import minidom
25
from xml.dom import minidom
11
27
26
12
28
from nova import log as logging
27
from nova import log as logging
13
28
from nova.api.ec2 import ec2utils
14
29
29
15
30
LOG = logging.getLogger("nova.api.request")
30
LOG = logging.getLogger("nova.api.request")
16
31
31
17
32
32
18
33
_c2u = re.compile('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))')
19
34
20
35
21
36
def _camelcase_to_underscore(str):
22
37
    return _c2u.sub(r'_\1', str).lower().strip('_')
23
38
24
39
25
40
def _underscore_to_camelcase(str):
33
def _underscore_to_camelcase(str):
26
41
    return ''.join([x[:1].upper() + x[1:] for x in str.split('_')])
34
    return ''.join([x[:1].upper() + x[1:] for x in str.split('_')])
27
42
35
28
@@ -51,59 +44,6 @@
29
51
    return datetimeobj.strftime("%Y-%m-%dT%H:%M:%SZ")
44
    return datetimeobj.strftime("%Y-%m-%dT%H:%M:%SZ")
30
52
45
31
53
46
32
54
def _try_convert(value):
33
55
    """Return a non-string from a string or unicode, if possible.
34
56
35
57
    ============= =====================================================
36
58
    When value is returns
37
59
    ============= =====================================================
38
60
    zero-length   ''
39
61
    'None'        None
40
62
    'True'        True
41
63
    'False'       False
42
64
    '0', '-0'     0
43
65
    0xN, -0xN     int from hex (postitive) (N is any number)
44
66
    0bN, -0bN     int from binary (positive) (N is any number)
45
67
    *             try conversion to int, float, complex, fallback value
46
68
47
69
    """
48
70
    if len(value) == 0:
49
71
        return ''
50
72
    if value == 'None':
51
73
        return None
52
74
    if value == 'True':
53
75
        return True
54
76
    if value == 'False':
55
77
        return False
56
78
    valueneg = value[1:] if value[0] == '-' else value
57
79
    if valueneg == '0':
58
80
        return 0
59
81
    if valueneg == '':
60
82
        return value
61
83
    if valueneg[0] == '0':
62
84
        if valueneg[1] in 'xX':
63
85
            return int(value, 16)
64
86
        elif valueneg[1] in 'bB':
65
87
            return int(value, 2)
66
88
        else:
67
89
            try:
68
90
                return int(value, 8)
69
91
            except ValueError:
70
92
                pass
71
93
    try:
72
94
        return int(value)
73
95
    except ValueError:
74
96
        pass
75
97
    try:
76
98
        return float(value)
77
99
    except ValueError:
78
100
        pass
79
101
    try:
80
102
        return complex(value)
81
103
    except ValueError:
82
104
        return value
83
105
84
106
85
107
class APIRequest(object):
47
class APIRequest(object):
86
108
    def __init__(self, controller, action, version, args):
48
    def __init__(self, controller, action, version, args):
87
109
        self.controller = controller
49
        self.controller = controller
88
@@ -114,7 +54,7 @@
89
114
    def invoke(self, context):
54
    def invoke(self, context):
90
115
        try:
55
        try:
91
116
            method = getattr(self.controller,
56
            method = getattr(self.controller,
93
117
                             _camelcase_to_underscore(self.action))
57
                             ec2utils.camelcase_to_underscore(self.action))
94
118
        except AttributeError:
58
        except AttributeError:
95
119
            controller = self.controller
59
            controller = self.controller
96
120
            action = self.action
60
            action = self.action
97
@@ -125,19 +65,7 @@
98
125
            #       and reraise as 400 error.
65
            #       and reraise as 400 error.
99
126
            raise Exception(_error)
66
            raise Exception(_error)
100
127
67
114
128
        args = {}
68
        args = ec2utils.dict_from_dotted_str(self.args.items())
102
129
        for key, value in self.args.items():
103
130
            parts = key.split(".")
104
131
            key = _camelcase_to_underscore(parts[0])
105
132
            if isinstance(value, str) or isinstance(value, unicode):
106
133
                # NOTE(vish): Automatically convert strings back
107
134
                #             into their respective values
108
135
                value = _try_convert(value)
109
136
            if len(parts) > 1:
110
137
                d = args.get(key, {})
111
138
                d[parts[1]] = value
112
139
                value = d
113
140
            args[key] = value
115
141
69
116
142
        for key in args.keys():
70
        for key in args.keys():
117
143
            # NOTE(vish): Turn numeric dict keys into lists
71
            # NOTE(vish): Turn numeric dict keys into lists
118
144
72
119
=== modified file 'nova/api/ec2/cloud.py'
120
--- nova/api/ec2/cloud.py	2011-06-17 20:47:23 +0000
121
+++ nova/api/ec2/cloud.py	2011-06-17 23:35:54 +0000
122
@@ -909,6 +909,25 @@
123
909
        if kwargs.get('ramdisk_id'):
909
        if kwargs.get('ramdisk_id'):
124
910
            ramdisk = self._get_image(context, kwargs['ramdisk_id'])
910
            ramdisk = self._get_image(context, kwargs['ramdisk_id'])
125
911
            kwargs['ramdisk_id'] = ramdisk['id']
911
            kwargs['ramdisk_id'] = ramdisk['id']
126
912
        for bdm in kwargs.get('block_device_mapping', []):
127
913
            # NOTE(yamahata)
128
914
            # BlockDevicedMapping.<N>.DeviceName
129
915
            # BlockDevicedMapping.<N>.Ebs.SnapshotId
130
916
            # BlockDevicedMapping.<N>.Ebs.VolumeSize
131
917
            # BlockDevicedMapping.<N>.Ebs.DeleteOnTermination
132
918
            # BlockDevicedMapping.<N>.VirtualName
133
919
            # => remove .Ebs and allow volume id in SnapshotId
134
920
            ebs = bdm.pop('ebs', None)
135
921
            if ebs:
136
922
                ec2_id = ebs.pop('snapshot_id')
137
923
                id = ec2utils.ec2_id_to_id(ec2_id)
138
924
                if ec2_id.startswith('snap-'):
139
925
                    bdm['snapshot_id'] = id
140
926
                elif ec2_id.startswith('vol-'):
141
927
                    bdm['volume_id'] = id
142
928
                ebs.setdefault('delete_on_termination', True)
143
929
                bdm.update(ebs)
144
930
145
912
        image = self._get_image(context, kwargs['image_id'])
931
        image = self._get_image(context, kwargs['image_id'])
146
913
932
147
914
        if image:
933
        if image:
148
@@ -933,37 +952,54 @@
149
933
            user_data=kwargs.get('user_data'),
952
            user_data=kwargs.get('user_data'),
150
934
            security_group=kwargs.get('security_group'),
953
            security_group=kwargs.get('security_group'),
151
935
            availability_zone=kwargs.get('placement', {}).get(
954
            availability_zone=kwargs.get('placement', {}).get(
153
936
                                  'AvailabilityZone'))
955
                                  'AvailabilityZone'),
154
956
            block_device_mapping=kwargs.get('block_device_mapping', {}))
155
937
        return self._format_run_instances(context,
957
        return self._format_run_instances(context,
156
938
                                          instances[0]['reservation_id'])
958
                                          instances[0]['reservation_id'])
157
939
959
158
960
    def _do_instance(self, action, context, ec2_id):
159
961
        instance_id = ec2utils.ec2_id_to_id(ec2_id)
160
962
        action(context, instance_id=instance_id)
161
963
162
964
    def _do_instances(self, action, context, instance_id):
163
965
        for ec2_id in instance_id:
164
966
            self._do_instance(action, context, ec2_id)
165
967
166
940
    def terminate_instances(self, context, instance_id, **kwargs):
968
    def terminate_instances(self, context, instance_id, **kwargs):
167
941
        """Terminate each instance in instance_id, which is a list of ec2 ids.
969
        """Terminate each instance in instance_id, which is a list of ec2 ids.
168
942
        instance_id is a kwarg so its name cannot be modified."""
970
        instance_id is a kwarg so its name cannot be modified."""
169
943
        LOG.debug(_("Going to start terminating instances"))
971
        LOG.debug(_("Going to start terminating instances"))
173
944
        for ec2_id in instance_id:
972
        self._do_instances(self.compute_api.delete, context, instance_id)
171
945
            instance_id = ec2utils.ec2_id_to_id(ec2_id)
172
946
            self.compute_api.delete(context, instance_id=instance_id)
174
947
        return True
973
        return True
175
948
974
176
949
    def reboot_instances(self, context, instance_id, **kwargs):
975
    def reboot_instances(self, context, instance_id, **kwargs):
177
950
        """instance_id is a list of instance ids"""
976
        """instance_id is a list of instance ids"""
178
951
        LOG.audit(_("Reboot instance %r"), instance_id, context=context)
977
        LOG.audit(_("Reboot instance %r"), instance_id, context=context)
182
952
        for ec2_id in instance_id:
978
        self._do_instances(self.compute_api.reboot, context, instance_id)
183
953
            instance_id = ec2utils.ec2_id_to_id(ec2_id)
979
        return True
184
954
            self.compute_api.reboot(context, instance_id=instance_id)
980
185
981
    def stop_instances(self, context, instance_id, **kwargs):
186
982
        """Stop each instances in instance_id.
187
983
        Here instance_id is a list of instance ids"""
188
984
        LOG.debug(_("Going to stop instances"))
189
985
        self._do_instances(self.compute_api.stop, context, instance_id)
190
986
        return True
191
987
192
988
    def start_instances(self, context, instance_id, **kwargs):
193
989
        """Start each instances in instance_id.
194
990
        Here instance_id is a list of instance ids"""
195
991
        LOG.debug(_("Going to start instances"))
196
992
        self._do_instances(self.compute_api.start, context, instance_id)
197
955
        return True
993
        return True
198
956
994
199
957
    def rescue_instance(self, context, instance_id, **kwargs):
995
    def rescue_instance(self, context, instance_id, **kwargs):
200
958
        """This is an extension to the normal ec2_api"""
996
        """This is an extension to the normal ec2_api"""
203
959
        instance_id = ec2utils.ec2_id_to_id(instance_id)
997
        self._do_instance(self.compute_api.rescue, contect, instnace_id)
202
960
        self.compute_api.rescue(context, instance_id=instance_id)
204
961
        return True
998
        return True
205
962
999
206
963
    def unrescue_instance(self, context, instance_id, **kwargs):
1000
    def unrescue_instance(self, context, instance_id, **kwargs):
207
964
        """This is an extension to the normal ec2_api"""
1001
        """This is an extension to the normal ec2_api"""
210
965
        instance_id = ec2utils.ec2_id_to_id(instance_id)
1002
        self._do_instance(self.compute_api.unrescue, context, instance_id)
209
966
        self.compute_api.unrescue(context, instance_id=instance_id)
211
967
        return True
1003
        return True
212
968
1004
213
969
    def update_instance(self, context, instance_id, **kwargs):
1005
    def update_instance(self, context, instance_id, **kwargs):
214
970
1006
215
=== modified file 'nova/api/ec2/ec2utils.py'
216
--- nova/api/ec2/ec2utils.py	2011-05-11 18:02:01 +0000
217
+++ nova/api/ec2/ec2utils.py	2011-06-17 23:35:54 +0000
218
@@ -16,6 +16,8 @@
219
16
#    License for the specific language governing permissions and limitations
16
#    License for the specific language governing permissions and limitations
220
17
#    under the License.
17
#    under the License.
221
18
18
222
19
import re
223
20
224
19
from nova import exception
21
from nova import exception
225
20
22
226
21
23
227
@@ -30,3 +32,95 @@
228
30
def id_to_ec2_id(instance_id, template='i-%08x'):
32
def id_to_ec2_id(instance_id, template='i-%08x'):
229
31
    """Convert an instance ID (int) to an ec2 ID (i-[base 16 number])"""
33
    """Convert an instance ID (int) to an ec2 ID (i-[base 16 number])"""
230
32
    return template % instance_id
34
    return template % instance_id
231
35
232
36
233
37
_c2u = re.compile('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))')
234
38
235
39
236
40
def camelcase_to_underscore(str):
237
41
    return _c2u.sub(r'_\1', str).lower().strip('_')
238
42
239
43
240
44
def _try_convert(value):
241
45
    """Return a non-string from a string or unicode, if possible.
242
46
243
47
    ============= =====================================================
244
48
    When value is returns
245
49
    ============= =====================================================
246
50
    zero-length   ''
247
51
    'None'        None
248
52
    'True'        True case insensitive
249
53
    'False'       False case insensitive
250
54
    '0', '-0'     0
251
55
    0xN, -0xN     int from hex (postitive) (N is any number)
252
56
    0bN, -0bN     int from binary (positive) (N is any number)
253
57
    *             try conversion to int, float, complex, fallback value
254
58
255
59
    """
256
60
    if len(value) == 0:
257
61
        return ''
258
62
    if value == 'None':
259
63
        return None
260
64
    lowered_value = value.lower()
261
65
    if lowered_value == 'true':
262
66
        return True
263
67
    if lowered_value == 'false':
264
68
        return False
265
69
    valueneg = value[1:] if value[0] == '-' else value
266
70
    if valueneg == '0':
267
71
        return 0
268
72
    if valueneg == '':
269
73
        return value
270
74
    if valueneg[0] == '0':
271
75
        if valueneg[1] in 'xX':
272
76
            return int(value, 16)
273
77
        elif valueneg[1] in 'bB':
274
78
            return int(value, 2)
275
79
        else:
276
80
            try:
277
81
                return int(value, 8)
278
82
            except ValueError:
279
83
                pass
280
84
    try:
281
85
        return int(value)
282
86
    except ValueError:
283
87
        pass
284
88
    try:
285
89
        return float(value)
286
90
    except ValueError:
287
91
        pass
288
92
    try:
289
93
        return complex(value)
290
94
    except ValueError:
291
95
        return value
292
96
293
97
294
98
def dict_from_dotted_str(items):
295
99
    """parse multi dot-separated argument into dict.
296
100
    EBS boot uses multi dot-separeted arguments like
297
101
    BlockDeviceMapping.1.DeviceName=snap-id
298
102
    Convert the above into
299
103
    {'block_device_mapping': {'1': {'device_name': snap-id}}}
300
104
    """
301
105
    args = {}
302
106
    for key, value in items:
303
107
        parts = key.split(".")
304
108
        key = camelcase_to_underscore(parts[0])
305
109
        if isinstance(value, str) or isinstance(value, unicode):
306
110
            # NOTE(vish): Automatically convert strings back
307
111
            #             into their respective values
308
112
            value = _try_convert(value)
309
113
310
114
            if len(parts) > 1:
311
115
                d = args.get(key, {})
312
116
                args[key] = d
313
117
                for k in parts[1:-1]:
314
118
                    k = camelcase_to_underscore(k)
315
119
                    v = d.get(k, {})
316
120
                    d[k] = v
317
121
                    d = v
318
122
                d[camelcase_to_underscore(parts[-1])] = value
319
123
            else:
320
124
                args[key] = value
321
125
322
126
    return args
323
33
127
324
=== modified file 'nova/compute/api.py'
325
--- nova/compute/api.py	2011-06-17 15:25:23 +0000
326
+++ nova/compute/api.py	2011-06-17 23:35:54 +0000
327
@@ -34,6 +34,7 @@
328
34
from nova import volume
34
from nova import volume
329
35
from nova.compute import instance_types
35
from nova.compute import instance_types
330
36
from nova.compute import power_state
36
from nova.compute import power_state
331
37
from nova.compute.utils import terminate_volumes
332
37
from nova.scheduler import api as scheduler_api
38
from nova.scheduler import api as scheduler_api
333
38
from nova.db import base
39
from nova.db import base
334
39
40
335
@@ -52,6 +53,18 @@
336
52
    return str(instance_id)
53
    return str(instance_id)
337
53
54
338
54
55
339
56
def _is_able_to_shutdown(instance, instance_id):
340
57
    states = {'terminating': "Instance %s is already being terminated",
341
58
              'migrating': "Instance %s is being migrated",
342
59
              'stopping': "Instance %s is being stopped"}
343
60
    msg = states.get(instance['state_description'])
344
61
    if msg:
345
62
        LOG.warning(_(msg), instance_id)
346
63
        return False
347
64
348
65
    return True
349
66
350
67
351
55
class API(base.Base):
68
class API(base.Base):
352
56
    """API for interacting with the compute manager."""
69
    """API for interacting with the compute manager."""
353
57
70
354
@@ -235,7 +248,7 @@
355
235
        return (num_instances, base_options, security_groups)
248
        return (num_instances, base_options, security_groups)
356
236
249
357
237
    def create_db_entry_for_new_instance(self, context, base_options,
250
    def create_db_entry_for_new_instance(self, context, base_options,
359
238
             security_groups, num=1):
251
             security_groups, block_device_mapping, num=1):
360
239
        """Create an entry in the DB for this new instance,
252
        """Create an entry in the DB for this new instance,
361
240
        including any related table updates (such as security
253
        including any related table updates (such as security
362
241
        groups, MAC address, etc). This will called by create()
254
        groups, MAC address, etc). This will called by create()
363
@@ -255,6 +268,23 @@
364
255
                                                instance_id,
268
                                                instance_id,
365
256
                                                security_group_id)
269
                                                security_group_id)
366
257
270
367
271
        # NOTE(yamahata)
368
272
        # tell vm driver to attach volume at boot time by updating
369
273
        # BlockDeviceMapping
370
274
        for bdm in block_device_mapping:
371
275
            LOG.debug(_('bdm %s'), bdm)
372
276
            assert 'device_name' in bdm
373
277
            values = {
374
278
                'instance_id': instance_id,
375
279
                'device_name': bdm['device_name'],
376
280
                'delete_on_termination': bdm.get('delete_on_termination'),
377
281
                'virtual_name': bdm.get('virtual_name'),
378
282
                'snapshot_id': bdm.get('snapshot_id'),
379
283
                'volume_id': bdm.get('volume_id'),
380
284
                'volume_size': bdm.get('volume_size'),
381
285
                'no_device': bdm.get('no_device')}
382
286
            self.db.block_device_mapping_create(elevated, values)
383
287
384
258
        # Set sane defaults if not specified
288
        # Set sane defaults if not specified
385
259
        updates = dict(hostname=self.hostname_factory(instance_id))
289
        updates = dict(hostname=self.hostname_factory(instance_id))
386
260
        if (not hasattr(instance, 'display_name') or
290
        if (not hasattr(instance, 'display_name') or
387
@@ -339,7 +369,7 @@
388
339
               key_name=None, key_data=None, security_group='default',
369
               key_name=None, key_data=None, security_group='default',
389
340
               availability_zone=None, user_data=None, metadata={},
370
               availability_zone=None, user_data=None, metadata={},
390
341
               injected_files=None, admin_password=None, zone_blob=None,
371
               injected_files=None, admin_password=None, zone_blob=None,
392
342
               reservation_id=None):
372
               reservation_id=None, block_device_mapping=None):
393
343
        """
373
        """
394
344
        Provision the instances by sending off a series of single
374
        Provision the instances by sending off a series of single
395
345
        instance requests to the Schedulers. This is fine for trival
375
        instance requests to the Schedulers. This is fine for trival
396
@@ -360,11 +390,13 @@
397
360
                               injected_files, admin_password, zone_blob,
390
                               injected_files, admin_password, zone_blob,
398
361
                               reservation_id)
391
                               reservation_id)
399
362
392
400
393
        block_device_mapping = block_device_mapping or []
401
363
        instances = []
394
        instances = []
402
364
        LOG.debug(_("Going to run %s instances..."), num_instances)
395
        LOG.debug(_("Going to run %s instances..."), num_instances)
403
365
        for num in range(num_instances):
396
        for num in range(num_instances):
404
366
            instance = self.create_db_entry_for_new_instance(context,
397
            instance = self.create_db_entry_for_new_instance(context,
406
367
                                    base_options, security_groups, num=num)
398
                                    base_options, security_groups,
407
399
                                    block_device_mapping, num=num)
408
368
            instances.append(instance)
400
            instances.append(instance)
409
369
            instance_id = instance['id']
401
            instance_id = instance['id']
410
370
402
411
@@ -474,24 +506,22 @@
412
474
        rv = self.db.instance_update(context, instance_id, kwargs)
506
        rv = self.db.instance_update(context, instance_id, kwargs)
413
475
        return dict(rv.iteritems())
507
        return dict(rv.iteritems())
414
476
508
415
509
    def _get_instance(self, context, instance_id, action_str):
416
510
        try:
417
511
            return self.get(context, instance_id)
418
512
        except exception.NotFound:
419
513
            LOG.warning(_("Instance %(instance_id)s was not found during "
420
514
                          "%(action_str)s") %
421
515
                        {'instance_id': instance_id, 'action_str': action_str})
422
516
            raise
423
517
424
477
    @scheduler_api.reroute_compute("delete")
518
    @scheduler_api.reroute_compute("delete")
425
478
    def delete(self, context, instance_id):
519
    def delete(self, context, instance_id):
426
479
        """Terminate an instance."""
520
        """Terminate an instance."""
427
480
        LOG.debug(_("Going to try to terminate %s"), instance_id)
521
        LOG.debug(_("Going to try to terminate %s"), instance_id)
442
481
        try:
522
        instance = self._get_instance(context, instance_id, 'terminating')
443
482
            instance = self.get(context, instance_id)
523
444
483
        except exception.NotFound:
524
        if not _is_able_to_shutdown(instance, instance_id):
431
484
            LOG.warning(_("Instance %s was not found during terminate"),
432
485
                        instance_id)
433
486
            raise
434
487
435
488
        if instance['state_description'] == 'terminating':
436
489
            LOG.warning(_("Instance %s is already being terminated"),
437
490
                        instance_id)
438
491
            return
439
492
440
493
        if instance['state_description'] == 'migrating':
441
494
            LOG.warning(_("Instance %s is being migrated"), instance_id)
445
495
            return
525
            return
446
496
526
447
497
        self.update(context,
527
        self.update(context,
448
@@ -505,8 +535,48 @@
449
505
            self._cast_compute_message('terminate_instance', context,
535
            self._cast_compute_message('terminate_instance', context,
450
506
                    instance_id, host)
536
                    instance_id, host)
451
507
        else:
537
        else:
452
538
            terminate_volumes(self.db, context, instance_id)
453
508
            self.db.instance_destroy(context, instance_id)
539
            self.db.instance_destroy(context, instance_id)
454
509
540
455
541
    @scheduler_api.reroute_compute("stop")
456
542
    def stop(self, context, instance_id):
457
543
        """Stop an instance."""
458
544
        LOG.debug(_("Going to try to stop %s"), instance_id)
459
545
460
546
        instance = self._get_instance(context, instance_id, 'stopping')
461
547
        if not _is_able_to_shutdown(instance, instance_id):
462
548
            return
463
549
464
550
        self.update(context,
465
551
                    instance['id'],
466
552
                    state_description='stopping',
467
553
                    state=power_state.NOSTATE,
468
554
                    terminated_at=utils.utcnow())
469
555
470
556
        host = instance['host']
471
557
        if host:
472
558
            self._cast_compute_message('stop_instance', context,
473
559
                    instance_id, host)
474
560
475
561
    def start(self, context, instance_id):
476
562
        """Start an instance."""
477
563
        LOG.debug(_("Going to try to start %s"), instance_id)
478
564
        instance = self._get_instance(context, instance_id, 'starting')
479
565
        if instance['state_description'] != 'stopped':
480
566
            _state_description = instance['state_description']
481
567
            LOG.warning(_("Instance %(instance_id)s is not "
482
568
                          "stopped(%(_state_description)s)") % locals())
483
569
            return
484
570
485
571
        # TODO(yamahata): injected_files isn't supported right now.
486
572
        #                 It is used only for osapi. not for ec2 api.
487
573
        #                 availability_zone isn't used by run_instance.
488
574
        rpc.cast(context,
489
575
                 FLAGS.scheduler_topic,
490
576
                 {"method": "start_instance",
491
577
                  "args": {"topic": FLAGS.compute_topic,
492
578
                           "instance_id": instance_id}})
493
579
494
510
    def get(self, context, instance_id):
580
    def get(self, context, instance_id):
495
511
        """Get a single instance with the given instance_id."""
581
        """Get a single instance with the given instance_id."""
496
512
        rv = self.db.instance_get(context, instance_id)
582
        rv = self.db.instance_get(context, instance_id)
497
513
583
498
=== modified file 'nova/compute/manager.py'
499
--- nova/compute/manager.py	2011-06-03 15:11:01 +0000
500
+++ nova/compute/manager.py	2011-06-17 23:35:54 +0000
501
@@ -53,6 +53,7 @@
502
53
from nova import utils
53
from nova import utils
503
54
from nova import volume
54
from nova import volume
504
55
from nova.compute import power_state
55
from nova.compute import power_state
505
56
from nova.compute.utils import terminate_volumes
506
56
from nova.virt import driver
57
from nova.virt import driver
507
57
58
508
58
59
509
@@ -214,8 +215,63 @@
510
214
        """
215
        """
511
215
        return self.driver.refresh_security_group_members(security_group_id)
216
        return self.driver.refresh_security_group_members(security_group_id)
512
216
217
515
217
    @exception.wrap_exception
218
    def _setup_block_device_mapping(self, context, instance_id):
516
218
    def run_instance(self, context, instance_id, **kwargs):
219
        """setup volumes for block device mapping"""
517
220
        self.db.instance_set_state(context,
518
221
                                   instance_id,
519
222
                                   power_state.NOSTATE,
520
223
                                   'block_device_mapping')
521
224
522
225
        volume_api = volume.API()
523
226
        block_device_mapping = []
524
227
        for bdm in self.db.block_device_mapping_get_all_by_instance(
525
228
            context, instance_id):
526
229
            LOG.debug(_("setting up bdm %s"), bdm)
527
230
            if ((bdm['snapshot_id'] is not None) and
528
231
                (bdm['volume_id'] is None)):
529
232
                # TODO(yamahata): default name and description
530
233
                vol = volume_api.create(context, bdm['volume_size'],
531
234
                                        bdm['snapshot_id'], '', '')
532
235
                # TODO(yamahata): creating volume simultaneously
533
236
                #                 reduces creation time?
534
237
                volume_api.wait_creation(context, vol['id'])
535
238
                self.db.block_device_mapping_update(
536
239
                    context, bdm['id'], {'volume_id': vol['id']})
537
240
                bdm['volume_id'] = vol['id']
538
241
539
242
            if not ((bdm['snapshot_id'] is None) or
540
243
                    (bdm['volume_id'] is not None)):
541
244
                LOG.error(_('corrupted state of block device mapping '
542
245
                            'id: %(id)s '
543
246
                            'snapshot: %(snapshot_id) volume: %(vollume_id)') %
544
247
                          {'id': bdm['id'],
545
248
                           'snapshot_id': bdm['snapshot'],
546
249
                           'volume_id': bdm['volume_id']})
547
250
                raise exception.ApiError(_('broken block device mapping %d') %
548
251
                                         bdm['id'])
549
252
550
253
            if bdm['volume_id'] is not None:
551
254
                volume_api.check_attach(context,
552
255
                                        volume_id=bdm['volume_id'])
553
256
                dev_path = self._attach_volume_boot(context, instance_id,
554
257
                                                    bdm['volume_id'],
555
258
                                                    bdm['device_name'])
556
259
                block_device_mapping.append({'device_path': dev_path,
557
260
                                             'mount_device':
558
261
                                             bdm['device_name']})
559
262
            elif bdm['virtual_name'] is not None:
560
263
                # TODO(yamahata): ephemeral/swap device support
561
264
                LOG.debug(_('block_device_mapping: '
562
265
                            'ephemeral device is not supported yet'))
563
266
            else:
564
267
                # TODO(yamahata): NoDevice support
565
268
                assert bdm['no_device']
566
269
                LOG.debug(_('block_device_mapping: '
567
270
                            'no device is not supported yet'))
568
271
569
272
        return block_device_mapping
570
273
571
274
    def _run_instance(self, context, instance_id, **kwargs):
572
219
        """Launch a new instance with specified options."""
275
        """Launch a new instance with specified options."""
573
220
        context = context.elevated()
276
        context = context.elevated()
574
221
        instance_ref = self.db.instance_get(context, instance_id)
277
        instance_ref = self.db.instance_get(context, instance_id)
575
@@ -249,11 +305,15 @@
576
249
            self.network_manager.setup_compute_network(context,
305
            self.network_manager.setup_compute_network(context,
577
250
                                                       instance_id)
306
                                                       instance_id)
578
251
307
579
308
        block_device_mapping = self._setup_block_device_mapping(context,
580
309
                                                                instance_id)
581
310
582
252
        # TODO(vish) check to make sure the availability zone matches
311
        # TODO(vish) check to make sure the availability zone matches
583
253
        self._update_state(context, instance_id, power_state.BUILDING)
312
        self._update_state(context, instance_id, power_state.BUILDING)
584
254
313
585
255
        try:
314
        try:
587
256
            self.driver.spawn(instance_ref)
315
            self.driver.spawn(instance_ref,
588
316
                              block_device_mapping=block_device_mapping)
589
257
        except Exception as ex:  # pylint: disable=W0702
317
        except Exception as ex:  # pylint: disable=W0702
590
258
            msg = _("Instance '%(instance_id)s' failed to spawn. Is "
318
            msg = _("Instance '%(instance_id)s' failed to spawn. Is "
591
259
                    "virtualization enabled in the BIOS? Details: "
319
                    "virtualization enabled in the BIOS? Details: "
592
@@ -277,12 +337,24 @@
593
277
        self._update_state(context, instance_id)
337
        self._update_state(context, instance_id)
594
278
338
595
279
    @exception.wrap_exception
339
    @exception.wrap_exception
596
340
    def run_instance(self, context, instance_id, **kwargs):
597
341
        self._run_instance(context, instance_id, **kwargs)
598
342
599
343
    @exception.wrap_exception
600
280
    @checks_instance_lock
344
    @checks_instance_lock
603
281
    def terminate_instance(self, context, instance_id):
345
    def start_instance(self, context, instance_id):
604
282
        """Terminate an instance on this host."""
346
        """Starting an instance on this host."""
605
347
        # TODO(yamahata): injected_files isn't supported.
606
348
        #                 Anyway OSAPI doesn't support stop/start yet
607
349
        self._run_instance(context, instance_id)
608
350
609
351
    def _shutdown_instance(self, context, instance_id, action_str):
610
352
        """Shutdown an instance on this host."""
611
283
        context = context.elevated()
353
        context = context.elevated()
612
284
        instance_ref = self.db.instance_get(context, instance_id)
354
        instance_ref = self.db.instance_get(context, instance_id)
614
285
        LOG.audit(_("Terminating instance %s"), instance_id, context=context)
355
        LOG.audit(_("%(action_str)s instance %(instance_id)s") %
615
356
                  {'action_str': action_str, 'instance_id': instance_id},
616
357
                  context=context)
617
286
358
618
287
        fixed_ip = instance_ref.get('fixed_ip')
359
        fixed_ip = instance_ref.get('fixed_ip')
619
288
        if not FLAGS.stub_network and fixed_ip:
360
        if not FLAGS.stub_network and fixed_ip:
620
@@ -318,18 +390,36 @@
621
318
390
622
319
        volumes = instance_ref.get('volumes') or []
391
        volumes = instance_ref.get('volumes') or []
623
320
        for volume in volumes:
392
        for volume in volumes:
626
321
            self.detach_volume(context, instance_id, volume['id'])
393
            self._detach_volume(context, instance_id, volume['id'], False)
627
322
        if instance_ref['state'] == power_state.SHUTOFF:
394
628
395
        if (instance_ref['state'] == power_state.SHUTOFF and
629
396
            instance_ref['state_description'] != 'stopped'):
630
323
            self.db.instance_destroy(context, instance_id)
397
            self.db.instance_destroy(context, instance_id)
631
324
            raise exception.Error(_('trying to destroy already destroyed'
398
            raise exception.Error(_('trying to destroy already destroyed'
632
325
                                    ' instance: %s') % instance_id)
399
                                    ' instance: %s') % instance_id)
633
326
        self.driver.destroy(instance_ref)
400
        self.driver.destroy(instance_ref)
634
327
401
635
402
        if action_str == 'Terminating':
636
403
            terminate_volumes(self.db, context, instance_id)
637
404
638
405
    @exception.wrap_exception
639
406
    @checks_instance_lock
640
407
    def terminate_instance(self, context, instance_id):
641
408
        """Terminate an instance on this host."""
642
409
        self._shutdown_instance(context, instance_id, 'Terminating')
643
410
644
328
        # TODO(ja): should we keep it in a terminated state for a bit?
411
        # TODO(ja): should we keep it in a terminated state for a bit?
645
329
        self.db.instance_destroy(context, instance_id)
412
        self.db.instance_destroy(context, instance_id)
646
330
413
647
331
    @exception.wrap_exception
414
    @exception.wrap_exception
648
332
    @checks_instance_lock
415
    @checks_instance_lock
649
416
    def stop_instance(self, context, instance_id):
650
417
        """Stopping an instance on this host."""
651
418
        self._shutdown_instance(context, instance_id, 'Stopping')
652
419
        # instance state will be updated to stopped by _poll_instance_states()
653
420
654
421
    @exception.wrap_exception
655
422
    @checks_instance_lock
656
333
    def rebuild_instance(self, context, instance_id, **kwargs):
423
    def rebuild_instance(self, context, instance_id, **kwargs):
657
334
        """Destroy and re-make this instance.
424
        """Destroy and re-make this instance.
658
335
425
659
@@ -800,6 +890,22 @@
660
800
        instance_ref = self.db.instance_get(context, instance_id)
890
        instance_ref = self.db.instance_get(context, instance_id)
661
801
        return self.driver.get_vnc_console(instance_ref)
891
        return self.driver.get_vnc_console(instance_ref)
662
802
892
663
893
    def _attach_volume_boot(self, context, instance_id, volume_id, mountpoint):
664
894
        """Attach a volume to an instance at boot time. So actual attach
665
895
        is done by instance creation"""
666
896
667
897
        # TODO(yamahata):
668
898
        # should move check_attach to volume manager?
669
899
        volume.API().check_attach(context, volume_id)
670
900
671
901
        context = context.elevated()
672
902
        LOG.audit(_("instance %(instance_id)s: booting with "
673
903
                    "volume %(volume_id)s at %(mountpoint)s") %
674
904
                  locals(), context=context)
675
905
        dev_path = self.volume_manager.setup_compute_volume(context, volume_id)
676
906
        self.db.volume_attached(context, volume_id, instance_id, mountpoint)
677
907
        return dev_path
678
908
679
803
    @checks_instance_lock
909
    @checks_instance_lock
680
804
    def attach_volume(self, context, instance_id, volume_id, mountpoint):
910
    def attach_volume(self, context, instance_id, volume_id, mountpoint):
681
805
        """Attach a volume to an instance."""
911
        """Attach a volume to an instance."""
682
@@ -817,6 +923,16 @@
683
817
                                    volume_id,
923
                                    volume_id,
684
818
                                    instance_id,
924
                                    instance_id,
685
819
                                    mountpoint)
925
                                    mountpoint)
686
926
            values = {
687
927
                'instance_id': instance_id,
688
928
                'device_name': mountpoint,
689
929
                'delete_on_termination': False,
690
930
                'virtual_name': None,
691
931
                'snapshot_id': None,
692
932
                'volume_id': volume_id,
693
933
                'volume_size': None,
694
934
                'no_device': None}
695
935
            self.db.block_device_mapping_create(context, values)
696
820
        except Exception as exc:  # pylint: disable=W0702
936
        except Exception as exc:  # pylint: disable=W0702
697
821
            # NOTE(vish): The inline callback eats the exception info so we
937
            # NOTE(vish): The inline callback eats the exception info so we
698
822
            #             log the traceback here and reraise the same
938
            #             log the traceback here and reraise the same
699
@@ -831,7 +947,7 @@
700
831
947
701
832
    @exception.wrap_exception
948
    @exception.wrap_exception
702
833
    @checks_instance_lock
949
    @checks_instance_lock
704
834
    def detach_volume(self, context, instance_id, volume_id):
950
    def _detach_volume(self, context, instance_id, volume_id, destroy_bdm):
705
835
        """Detach a volume from an instance."""
951
        """Detach a volume from an instance."""
706
836
        context = context.elevated()
952
        context = context.elevated()
707
837
        instance_ref = self.db.instance_get(context, instance_id)
953
        instance_ref = self.db.instance_get(context, instance_id)
708
@@ -847,8 +963,15 @@
709
847
                                      volume_ref['mountpoint'])
963
                                      volume_ref['mountpoint'])
710
848
        self.volume_manager.remove_compute_volume(context, volume_id)
964
        self.volume_manager.remove_compute_volume(context, volume_id)
711
849
        self.db.volume_detached(context, volume_id)
965
        self.db.volume_detached(context, volume_id)
712
966
        if destroy_bdm:
713
967
            self.db.block_device_mapping_destroy_by_instance_and_volume(
714
968
                context, instance_id, volume_id)
715
850
        return True
969
        return True
716
851
970
717
971
    def detach_volume(self, context, instance_id, volume_id):
718
972
        """Detach a volume from an instance."""
719
973
        return self._detach_volume(context, instance_id, volume_id, True)
720
974
721
852
    def remove_volume(self, context, volume_id):
975
    def remove_volume(self, context, volume_id):
722
853
        """Remove volume on compute host.
976
        """Remove volume on compute host.
723
854
977
724
@@ -1174,11 +1297,14 @@
725
1174
                               "State=%(db_state)s, so setting state to "
1297
                               "State=%(db_state)s, so setting state to "
726
1175
                               "shutoff.") % locals())
1298
                               "shutoff.") % locals())
727
1176
                    vm_state = power_state.SHUTOFF
1299
                    vm_state = power_state.SHUTOFF
728
1300
                    if db_instance['state_description'] == 'stopping':
729
1301
                        self.db.instance_stop(context, db_instance['id'])
730
1302
                        continue
731
1177
            else:
1303
            else:
732
1178
                vm_state = vm_instance.state
1304
                vm_state = vm_instance.state
733
1179
                vms_not_found_in_db.remove(name)
1305
                vms_not_found_in_db.remove(name)
734
1180
1306
736
1181
            if db_instance['state_description'] == 'migrating':
1307
            if (db_instance['state_description'] in ['migrating', 'stopping']):
737
1182
                # A situation which db record exists, but no instance"
1308
                # A situation which db record exists, but no instance"
738
1183
                # sometimes occurs while live-migration at src compute,
1309
                # sometimes occurs while live-migration at src compute,
739
1184
                # this case should be ignored.
1310
                # this case should be ignored.
740
1185
1311
741
=== added file 'nova/compute/utils.py'
742
--- nova/compute/utils.py	1970-01-01 00:00:00 +0000
743
+++ nova/compute/utils.py	2011-06-17 23:35:54 +0000
744
@@ -0,0 +1,29 @@
745
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
746
2
747
3
# Copyright (c) 2011 VA Linux Systems Japan K.K
748
4
# Copyright (c) 2011 Isaku Yamahata
749
5
#
750
6
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
751
7
#    not use this file except in compliance with the License. You may obtain
752
8
#    a copy of the License at
753
9
#
754
10
#         http://www.apache.org/licenses/LICENSE-2.0
755
11
#
756
12
#    Unless required by applicable law or agreed to in writing, software
757
13
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
758
14
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
759
15
#    License for the specific language governing permissions and limitations
760
16
#    under the License.
761
17
762
18
from nova import volume
763
19
764
20
765
21
def terminate_volumes(db, context, instance_id):
766
22
    """delete volumes of delete_on_termination=True in block device mapping"""
767
23
    volume_api = volume.API()
768
24
    for bdm in db.block_device_mapping_get_all_by_instance(context,
769
25
                                                           instance_id):
770
26
        #LOG.debug(_("terminating bdm %s") % bdm)
771
27
        if bdm['volume_id'] and bdm['delete_on_termination']:
772
28
            volume_api.delete(context, bdm['volume_id'])
773
29
        db.block_device_mapping_destroy(context, bdm['id'])
774
0
30
775
=== modified file 'nova/db/api.py'
776
--- nova/db/api.py	2011-05-27 04:50:20 +0000
777
+++ nova/db/api.py	2011-06-17 23:35:54 +0000
778
@@ -414,6 +414,11 @@
779
414
    return IMPL.instance_destroy(context, instance_id)
414
    return IMPL.instance_destroy(context, instance_id)
780
415
415
781
416
416
782
417
def instance_stop(context, instance_id):
783
418
    """Stop the instance or raise if it does not exist."""
784
419
    return IMPL.instance_stop(context, instance_id)
785
420
786
421
787
417
def instance_get(context, instance_id):
422
def instance_get(context, instance_id):
788
418
    """Get an instance or raise if it does not exist."""
423
    """Get an instance or raise if it does not exist."""
789
419
    return IMPL.instance_get(context, instance_id)
424
    return IMPL.instance_get(context, instance_id)
790
@@ -920,6 +925,36 @@
791
920
####################
925
####################
792
921
926
793
922
927
794
928
def block_device_mapping_create(context, values):
795
929
    """Create an entry of block device mapping"""
796
930
    return IMPL.block_device_mapping_create(context, values)
797
931
798
932
799
933
def block_device_mapping_update(context, bdm_id, values):
800
934
    """Create an entry of block device mapping"""
801
935
    return IMPL.block_device_mapping_update(context, bdm_id, values)
802
936
803
937
804
938
def block_device_mapping_get_all_by_instance(context, instance_id):
805
939
    """Get all block device mapping belonging to a instance"""
806
940
    return IMPL.block_device_mapping_get_all_by_instance(context, instance_id)
807
941
808
942
809
943
def block_device_mapping_destroy(context, bdm_id):
810
944
    """Destroy the block device mapping."""
811
945
    return IMPL.block_device_mapping_destroy(context, bdm_id)
812
946
813
947
814
948
def block_device_mapping_destroy_by_instance_and_volume(context, instance_id,
815
949
                                                        volume_id):
816
950
    """Destroy the block device mapping or raise if it does not exist."""
817
951
    return IMPL.block_device_mapping_destroy_by_instance_and_volume(
818
952
        context, instance_id, volume_id)
819
953
820
954
821
955
####################
822
956
823
957
824
923
def security_group_get_all(context):
958
def security_group_get_all(context):
825
924
    """Get all security groups."""
959
    """Get all security groups."""
826
925
    return IMPL.security_group_get_all(context)
960
    return IMPL.security_group_get_all(context)
827
926
961
828
=== modified file 'nova/db/sqlalchemy/api.py'
829
--- nova/db/sqlalchemy/api.py	2011-06-15 21:35:31 +0000
830
+++ nova/db/sqlalchemy/api.py	2011-06-17 23:35:54 +0000
831
@@ -840,6 +840,25 @@
832
840
840
833
841
841
834
842
@require_context
842
@require_context
835
843
def instance_stop(context, instance_id):
836
844
    session = get_session()
837
845
    with session.begin():
838
846
        from nova.compute import power_state
839
847
        session.query(models.Instance).\
840
848
                filter_by(id=instance_id).\
841
849
                update({'host': None,
842
850
                        'state': power_state.SHUTOFF,
843
851
                        'state_description': 'stopped',
844
852
                        'updated_at': literal_column('updated_at')})
845
853
        session.query(models.SecurityGroupInstanceAssociation).\
846
854
                filter_by(instance_id=instance_id).\
847
855
                update({'updated_at': literal_column('updated_at')})
848
856
        session.query(models.InstanceMetadata).\
849
857
                filter_by(instance_id=instance_id).\
850
858
                update({'updated_at': literal_column('updated_at')})
851
859
852
860
853
861
@require_context
854
843
def instance_get(context, instance_id, session=None):
862
def instance_get(context, instance_id, session=None):
855
844
    if not session:
863
    if not session:
856
845
        session = get_session()
864
        session = get_session()
857
@@ -1883,6 +1902,66 @@
858
1883
1902
859
1884
1903
860
1885
@require_context
1904
@require_context
861
1905
def block_device_mapping_create(context, values):
862
1906
    bdm_ref = models.BlockDeviceMapping()
863
1907
    bdm_ref.update(values)
864
1908
865
1909
    session = get_session()
866
1910
    with session.begin():
867
1911
        bdm_ref.save(session=session)
868
1912
869
1913
870
1914
@require_context
871
1915
def block_device_mapping_update(context, bdm_id, values):
872
1916
    session = get_session()
873
1917
    with session.begin():
874
1918
        session.query(models.BlockDeviceMapping).\
875
1919
                filter_by(id=bdm_id).\
876
1920
                filter_by(deleted=False).\
877
1921
                update(values)
878
1922
879
1923
880
1924
@require_context
881
1925
def block_device_mapping_get_all_by_instance(context, instance_id):
882
1926
    session = get_session()
883
1927
    result = session.query(models.BlockDeviceMapping).\
884
1928
             filter_by(instance_id=instance_id).\
885
1929
             filter_by(deleted=False).\
886
1930
             all()
887
1931
    if not result:
888
1932
        return []
889
1933
    return result
890
1934
891
1935
892
1936
@require_context
893
1937
def block_device_mapping_destroy(context, bdm_id):
894
1938
    session = get_session()
895
1939
    with session.begin():
896
1940
        session.query(models.BlockDeviceMapping).\
897
1941
                filter_by(id=bdm_id).\
898
1942
                update({'deleted': True,
899
1943
                        'deleted_at': utils.utcnow(),
900
1944
                        'updated_at': literal_column('updated_at')})
901
1945
902
1946
903
1947
@require_context
904
1948
def block_device_mapping_destroy_by_instance_and_volume(context, instance_id,
905
1949
                                                        volume_id):
906
1950
    session = get_session()
907
1951
    with session.begin():
908
1952
        session.query(models.BlockDeviceMapping).\
909
1953
        filter_by(instance_id=instance_id).\
910
1954
        filter_by(volume_id=volume_id).\
911
1955
        filter_by(deleted=False).\
912
1956
        update({'deleted': True,
913
1957
                'deleted_at': utils.utcnow(),
914
1958
                'updated_at': literal_column('updated_at')})
915
1959
916
1960
917
1961
###################
918
1962
919
1963
920
1964
@require_context
921
1886
def security_group_get_all(context):
1965
def security_group_get_all(context):
922
1887
    session = get_session()
1966
    session = get_session()
923
1888
    return session.query(models.SecurityGroup).\
1967
    return session.query(models.SecurityGroup).\
924
1889
1968
925
=== added file 'nova/db/sqlalchemy/migrate_repo/versions/024_add_block_device_mapping.py'
926
--- nova/db/sqlalchemy/migrate_repo/versions/024_add_block_device_mapping.py	1970-01-01 00:00:00 +0000
927
+++ nova/db/sqlalchemy/migrate_repo/versions/024_add_block_device_mapping.py	2011-06-17 23:35:54 +0000
928
@@ -0,0 +1,87 @@
929
1
# Copyright 2011 OpenStack LLC.
930
2
# Copyright 2011 Isaku Yamahata
931
3
#
932
4
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
933
5
#    not use this file except in compliance with the License. You may obtain
934
6
#    a copy of the License at
935
7
#
936
8
#         http://www.apache.org/licenses/LICENSE-2.0
937
9
#
938
10
#    Unless required by applicable law or agreed to in writing, software
939
11
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
940
12
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
941
13
#    License for the specific language governing permissions and limitations
942
14
#    under the License.
943
15
944
16
from sqlalchemy import MetaData, Table, Column
945
17
from sqlalchemy import DateTime, Boolean, Integer, String
946
18
from sqlalchemy import ForeignKey
947
19
from nova import log as logging
948
20
949
21
meta = MetaData()
950
22
951
23
# Just for the ForeignKey and column creation to succeed, these are not the
952
24
# actual definitions of instances or services.
953
25
instances = Table('instances', meta,
954
26
        Column('id', Integer(), primary_key=True, nullable=False),
955
27
        )
956
28
957
29
volumes = Table('volumes', meta,
958
30
        Column('id', Integer(),  primary_key=True, nullable=False),
959
31
        )
960
32
961
33
snapshots = Table('snapshots', meta,
962
34
        Column('id', Integer(),  primary_key=True, nullable=False),
963
35
        )
964
36
965
37
966
38
block_device_mapping = Table('block_device_mapping', meta,
967
39
        Column('created_at', DateTime(timezone=False)),
968
40
        Column('updated_at', DateTime(timezone=False)),
969
41
        Column('deleted_at', DateTime(timezone=False)),
970
42
        Column('deleted', Boolean(create_constraint=True, name=None)),
971
43
        Column('id', Integer(), primary_key=True, autoincrement=True),
972
44
        Column('instance_id',
973
45
               Integer(),
974
46
               ForeignKey('instances.id'),
975
47
               nullable=False),
976
48
        Column('device_name',
977
49
               String(length=255, convert_unicode=False, assert_unicode=None,
978
50
                      unicode_error=None, _warn_on_bytestring=False),
979
51
               nullable=False),
980
52
        Column('delete_on_termination',
981
53
               Boolean(create_constraint=True, name=None),
982
54
               default=False),
983
55
        Column('virtual_name',
984
56
               String(length=255, convert_unicode=False, assert_unicode=None,
985
57
                      unicode_error=None, _warn_on_bytestring=False),
986
58
               nullable=True),
987
59
        Column('snapshot_id',
988
60
               Integer(),
989
61
               ForeignKey('snapshots.id'),
990
62
               nullable=True),
991
63
        Column('volume_id', Integer(), ForeignKey('volumes.id'),
992
64
               nullable=True),
993
65
        Column('volume_size', Integer(), nullable=True),
994
66
        Column('no_device',
995
67
               Boolean(create_constraint=True, name=None),
996
68
               nullable=True),
997
69
        )
998
70
999
71
1000
72
def upgrade(migrate_engine):
1001
73
    # Upgrade operations go here. Don't create your own engine;
1002
74
    # bind migrate_engine to your metadata
1003
75
    meta.bind = migrate_engine
1004
76
    try:
1005
77
        block_device_mapping.create()
1006
78
    except Exception:
1007
79
        logging.info(repr(block_device_mapping))
1008
80
        logging.exception('Exception while creating table')
1009
81
        meta.drop_all(tables=[block_device_mapping])
1010
82
        raise
1011
83
1012
84
1013
85
def downgrade(migrate_engine):
1014
86
    # Operations to reverse the above upgrade go here.
1015
87
    block_device_mapping.drop()
1016
0
88
1017
=== modified file 'nova/db/sqlalchemy/models.py'
1018
--- nova/db/sqlalchemy/models.py	2011-06-08 15:45:23 +0000
1019
+++ nova/db/sqlalchemy/models.py	2011-06-17 23:35:54 +0000
1020
@@ -357,6 +357,45 @@
1021
357
    display_description = Column(String(255))
357
    display_description = Column(String(255))
1022
358
358
1023
359
359
1024
360
class BlockDeviceMapping(BASE, NovaBase):
1025
361
    """Represents block device mapping that is defined by EC2"""
1026
362
    __tablename__ = "block_device_mapping"
1027
363
    id = Column(Integer, primary_key=True, autoincrement=True)
1028
364
1029
365
    instance_id = Column(Integer, ForeignKey('instances.id'), nullable=False)
1030
366
    instance = relationship(Instance,
1031
367
                            backref=backref('balock_device_mapping'),
1032
368
                            foreign_keys=instance_id,
1033
369
                            primaryjoin='and_(BlockDeviceMapping.instance_id=='
1034
370
                                              'Instance.id,'
1035
371
                                              'BlockDeviceMapping.deleted=='
1036
372
                                              'False)')
1037
373
    device_name = Column(String(255), nullable=False)
1038
374
1039
375
    # default=False for compatibility of the existing code.
1040
376
    # With EC2 API,
1041
377
    # default True for ami specified device.
1042
378
    # default False for created with other timing.
1043
379
    delete_on_termination = Column(Boolean, default=False)
1044
380
1045
381
    # for ephemeral device
1046
382
    virtual_name = Column(String(255), nullable=True)
1047
383
1048
384
    # for snapshot or volume
1049
385
    snapshot_id = Column(Integer, ForeignKey('snapshots.id'), nullable=True)
1050
386
    # outer join
1051
387
    snapshot = relationship(Snapshot,
1052
388
                            foreign_keys=snapshot_id)
1053
389
1054
390
    volume_id = Column(Integer, ForeignKey('volumes.id'), nullable=True)
1055
391
    volume = relationship(Volume,
1056
392
                          foreign_keys=volume_id)
1057
393
    volume_size = Column(Integer, nullable=True)
1058
394
1059
395
    # for no device to suppress devices.
1060
396
    no_device = Column(Boolean, nullable=True)
1061
397
1062
398
1063
360
class ExportDevice(BASE, NovaBase):
399
class ExportDevice(BASE, NovaBase):
1064
361
    """Represates a shelf and blade that a volume can be exported on."""
400
    """Represates a shelf and blade that a volume can be exported on."""
1065
362
    __tablename__ = 'export_devices'
401
    __tablename__ = 'export_devices'
1066
363
402
1067
=== modified file 'nova/scheduler/simple.py'
1068
--- nova/scheduler/simple.py	2011-06-02 21:23:05 +0000
1069
+++ nova/scheduler/simple.py	2011-06-17 23:35:54 +0000
1070
@@ -39,7 +39,7 @@
1071
39
class SimpleScheduler(chance.ChanceScheduler):
39
class SimpleScheduler(chance.ChanceScheduler):
1072
40
    """Implements Naive Scheduler that tries to find least loaded host."""
40
    """Implements Naive Scheduler that tries to find least loaded host."""
1073
41
41
1075
42
    def schedule_run_instance(self, context, instance_id, *_args, **_kwargs):
42
    def _schedule_instance(self, context, instance_id, *_args, **_kwargs):
1076
43
        """Picks a host that is up and has the fewest running instances."""
43
        """Picks a host that is up and has the fewest running instances."""
1077
44
        instance_ref = db.instance_get(context, instance_id)
44
        instance_ref = db.instance_get(context, instance_id)
1078
45
        if (instance_ref['availability_zone']
45
        if (instance_ref['availability_zone']
1079
@@ -75,6 +75,12 @@
1080
75
                                   " for this request. Is the appropriate"
75
                                   " for this request. Is the appropriate"
1081
76
                                   " service running?"))
76
                                   " service running?"))
1082
77
77
1083
78
    def schedule_run_instance(self, context, instance_id, *_args, **_kwargs):
1084
79
        return self._schedule_instance(context, instance_id, *_args, **_kwargs)
1085
80
1086
81
    def schedule_start_instance(self, context, instance_id, *_args, **_kwargs):
1087
82
        return self._schedule_instance(context, instance_id, *_args, **_kwargs)
1088
83
1089
78
    def schedule_create_volume(self, context, volume_id, *_args, **_kwargs):
84
    def schedule_create_volume(self, context, volume_id, *_args, **_kwargs):
1090
79
        """Picks a host that is up and has the fewest volumes."""
85
        """Picks a host that is up and has the fewest volumes."""
1091
80
        volume_ref = db.volume_get(context, volume_id)
86
        volume_ref = db.volume_get(context, volume_id)
1092
81
87
1093
=== modified file 'nova/tests/test_api.py'
1094
--- nova/tests/test_api.py	2011-05-23 21:15:10 +0000
1095
+++ nova/tests/test_api.py	2011-06-17 23:35:54 +0000
1096
@@ -89,7 +89,7 @@
1097
89
class XmlConversionTestCase(test.TestCase):
89
class XmlConversionTestCase(test.TestCase):
1098
90
    """Unit test api xml conversion"""
90
    """Unit test api xml conversion"""
1099
91
    def test_number_conversion(self):
91
    def test_number_conversion(self):
1101
92
        conv = apirequest._try_convert
92
        conv = ec2utils._try_convert
1102
93
        self.assertEqual(conv('None'), None)
93
        self.assertEqual(conv('None'), None)
1103
94
        self.assertEqual(conv('True'), True)
94
        self.assertEqual(conv('True'), True)
1104
95
        self.assertEqual(conv('False'), False)
95
        self.assertEqual(conv('False'), False)
1105
96
96
1106
=== modified file 'nova/tests/test_cloud.py'
1107
--- nova/tests/test_cloud.py	2011-06-17 20:47:23 +0000
1108
+++ nova/tests/test_cloud.py	2011-06-17 23:35:54 +0000
1109
@@ -56,6 +56,7 @@
1110
56
        self.compute = self.start_service('compute')
56
        self.compute = self.start_service('compute')
1111
57
        self.scheduter = self.start_service('scheduler')
57
        self.scheduter = self.start_service('scheduler')
1112
58
        self.network = self.start_service('network')
58
        self.network = self.start_service('network')
1113
59
        self.volume = self.start_service('volume')
1114
59
        self.image_service = utils.import_object(FLAGS.image_service)
60
        self.image_service = utils.import_object(FLAGS.image_service)
1115
60
61
1116
61
        self.manager = manager.AuthManager()
62
        self.manager = manager.AuthManager()
1117
@@ -373,14 +374,21 @@
1118
373
        self.assertRaises(exception.ImageNotFound, deregister_image,
374
        self.assertRaises(exception.ImageNotFound, deregister_image,
1119
374
                          self.context, 'ami-bad001')
375
                          self.context, 'ami-bad001')
1120
375
376
1121
377
    def _run_instance(self, **kwargs):
1122
378
        rv = self.cloud.run_instances(self.context, **kwargs)
1123
379
        instance_id = rv['instancesSet'][0]['instanceId']
1124
380
        return instance_id
1125
381
1126
382
    def _run_instance_wait(self, **kwargs):
1127
383
        ec2_instance_id = self._run_instance(**kwargs)
1128
384
        self._wait_for_running(ec2_instance_id)
1129
385
        return ec2_instance_id
1130
386
1131
376
    def test_console_output(self):
387
    def test_console_output(self):
1139
377
        instance_type = FLAGS.default_instance_type
388
        instance_id = self._run_instance(
1140
378
        max_count = 1
389
            image_id='ami-1',
1141
379
        kwargs = {'image_id': 'ami-1',
390
            instance_type=FLAGS.default_instance_type,
1142
380
                  'instance_type': instance_type,
391
            max_count=1)
1136
381
                  'max_count': max_count}
1137
382
        rv = self.cloud.run_instances(self.context, **kwargs)
1138
383
        instance_id = rv['instancesSet'][0]['instanceId']
1143
384
        output = self.cloud.get_console_output(context=self.context,
392
        output = self.cloud.get_console_output(context=self.context,
1144
385
                                               instance_id=[instance_id])
393
                                               instance_id=[instance_id])
1145
386
        self.assertEquals(b64decode(output['output']), 'FAKE CONSOLE?OUTPUT')
394
        self.assertEquals(b64decode(output['output']), 'FAKE CONSOLE?OUTPUT')
1146
@@ -389,9 +397,7 @@
1147
389
        rv = self.cloud.terminate_instances(self.context, [instance_id])
397
        rv = self.cloud.terminate_instances(self.context, [instance_id])
1148
390
398
1149
391
    def test_ajax_console(self):
399
    def test_ajax_console(self):
1153
392
        kwargs = {'image_id': 'ami-1'}
400
        instance_id = self._run_instance(image_id='ami-1')
1151
393
        rv = self.cloud.run_instances(self.context, **kwargs)
1152
394
        instance_id = rv['instancesSet'][0]['instanceId']
1154
395
        output = self.cloud.get_ajax_console(context=self.context,
401
        output = self.cloud.get_ajax_console(context=self.context,
1155
396
                                             instance_id=[instance_id])
402
                                             instance_id=[instance_id])
1156
397
        self.assertEquals(output['url'],
403
        self.assertEquals(output['url'],
1157
@@ -569,3 +575,299 @@
1158
569
        vol = db.volume_get(self.context, vol['id'])
575
        vol = db.volume_get(self.context, vol['id'])
1159
570
        self.assertEqual(None, vol['mountpoint'])
576
        self.assertEqual(None, vol['mountpoint'])
1160
571
        db.volume_destroy(self.context, vol['id'])
577
        db.volume_destroy(self.context, vol['id'])
1161
578
1162
579
    def _restart_compute_service(self, periodic_interval=None):
1163
580
        """restart compute service. NOTE: fake driver forgets all instances."""
1164
581
        self.compute.kill()
1165
582
        if periodic_interval:
1166
583
            self.compute = self.start_service(
1167
584
                'compute', periodic_interval=periodic_interval)
1168
585
        else:
1169
586
            self.compute = self.start_service('compute')
1170
587
1171
588
    def _wait_for_state(self, ctxt, instance_id, predicate):
1172
589
        """Wait for an stopping instance to be a given state"""
1173
590
        id = ec2utils.ec2_id_to_id(instance_id)
1174
591
        while True:
1175
592
            info = self.cloud.compute_api.get(context=ctxt, instance_id=id)
1176
593
            LOG.debug(info)
1177
594
            if predicate(info):
1178
595
                break
1179
596
            greenthread.sleep(1)
1180
597
1181
598
    def _wait_for_running(self, instance_id):
1182
599
        def is_running(info):
1183
600
            return info['state_description'] == 'running'
1184
601
        self._wait_for_state(self.context, instance_id, is_running)
1185
602
1186
603
    def _wait_for_stopped(self, instance_id):
1187
604
        def is_stopped(info):
1188
605
            return info['state_description'] == 'stopped'
1189
606
        self._wait_for_state(self.context, instance_id, is_stopped)
1190
607
1191
608
    def _wait_for_terminate(self, instance_id):
1192
609
        def is_deleted(info):
1193
610
            return info['deleted']
1194
611
        elevated = self.context.elevated(read_deleted=True)
1195
612
        self._wait_for_state(elevated, instance_id, is_deleted)
1196
613
1197
614
    def test_stop_start_instance(self):
1198
615
        """Makes sure stop/start instance works"""
1199
616
        # enforce periodic tasks run in short time to avoid wait for 60s.
1200
617
        self._restart_compute_service(periodic_interval=0.3)
1201
618
1202
619
        kwargs = {'image_id': 'ami-1',
1203
620
                  'instance_type': FLAGS.default_instance_type,
1204
621
                  'max_count': 1, }
1205
622
        instance_id = self._run_instance_wait(**kwargs)
1206
623
1207
624
        # a running instance can't be started. It is just ignored.
1208
625
        result = self.cloud.start_instances(self.context, [instance_id])
1209
626
        greenthread.sleep(0.3)
1210
627
        self.assertTrue(result)
1211
628
1212
629
        result = self.cloud.stop_instances(self.context, [instance_id])
1213
630
        greenthread.sleep(0.3)
1214
631
        self.assertTrue(result)
1215
632
        self._wait_for_stopped(instance_id)
1216
633
1217
634
        result = self.cloud.start_instances(self.context, [instance_id])
1218
635
        greenthread.sleep(0.3)
1219
636
        self.assertTrue(result)
1220
637
        self._wait_for_running(instance_id)
1221
638
1222
639
        result = self.cloud.stop_instances(self.context, [instance_id])
1223
640
        greenthread.sleep(0.3)
1224
641
        self.assertTrue(result)
1225
642
        self._wait_for_stopped(instance_id)
1226
643
1227
644
        result = self.cloud.terminate_instances(self.context, [instance_id])
1228
645
        greenthread.sleep(0.3)
1229
646
        self.assertTrue(result)
1230
647
1231
648
        self._restart_compute_service()
1232
649
1233
650
    def _volume_create(self):
1234
651
        kwargs = {'status': 'available',
1235
652
                  'host': self.volume.host,
1236
653
                  'size': 1,
1237
654
                  'attach_status': 'detached', }
1238
655
        return db.volume_create(self.context, kwargs)
1239
656
1240
657
    def _assert_volume_attached(self, vol, instance_id, mountpoint):
1241
658
        self.assertEqual(vol['instance_id'], instance_id)
1242
659
        self.assertEqual(vol['mountpoint'], mountpoint)
1243
660
        self.assertEqual(vol['status'], "in-use")
1244
661
        self.assertEqual(vol['attach_status'], "attached")
1245
662
1246
663
    def _assert_volume_detached(self, vol):
1247
664
        self.assertEqual(vol['instance_id'], None)
1248
665
        self.assertEqual(vol['mountpoint'], None)
1249
666
        self.assertEqual(vol['status'], "available")
1250
667
        self.assertEqual(vol['attach_status'], "detached")
1251
668
1252
669
    def test_stop_start_with_volume(self):
1253
670
        """Make sure run instance with block device mapping works"""
1254
671
1255
672
        # enforce periodic tasks run in short time to avoid wait for 60s.
1256
673
        self._restart_compute_service(periodic_interval=0.3)
1257
674
1258
675
        vol1 = self._volume_create()
1259
676
        vol2 = self._volume_create()
1260
677
        kwargs = {'image_id': 'ami-1',
1261
678
                  'instance_type': FLAGS.default_instance_type,
1262
679
                  'max_count': 1,
1263
680
                  'block_device_mapping': [{'device_name': '/dev/vdb',
1264
681
                                            'volume_id': vol1['id'],
1265
682
                                            'delete_on_termination': False, },
1266
683
                                           {'device_name': '/dev/vdc',
1267
684
                                            'volume_id': vol2['id'],
1268
685
                                            'delete_on_termination': True, },
1269
686
                                           ]}
1270
687
        ec2_instance_id = self._run_instance_wait(**kwargs)
1271
688
        instance_id = ec2utils.ec2_id_to_id(ec2_instance_id)
1272
689
1273
690
        vols = db.volume_get_all_by_instance(self.context, instance_id)
1274
691
        self.assertEqual(len(vols), 2)
1275
692
        for vol in vols:
1276
693
            self.assertTrue(vol['id'] == vol1['id'] or vol['id'] == vol2['id'])
1277
694
1278
695
        vol = db.volume_get(self.context, vol1['id'])
1279
696
        self._assert_volume_attached(vol, instance_id, '/dev/vdb')
1280
697
1281
698
        vol = db.volume_get(self.context, vol2['id'])
1282
699
        self._assert_volume_attached(vol, instance_id, '/dev/vdc')
1283
700
1284
701
        result = self.cloud.stop_instances(self.context, [ec2_instance_id])
1285
702
        self.assertTrue(result)
1286
703
        self._wait_for_stopped(ec2_instance_id)
1287
704
1288
705
        vol = db.volume_get(self.context, vol1['id'])
1289
706
        self._assert_volume_detached(vol)
1290
707
        vol = db.volume_get(self.context, vol2['id'])
1291
708
        self._assert_volume_detached(vol)
1292
709
1293
710
        self.cloud.start_instances(self.context, [ec2_instance_id])
1294
711
        self._wait_for_running(ec2_instance_id)
1295
712
        vols = db.volume_get_all_by_instance(self.context, instance_id)
1296
713
        self.assertEqual(len(vols), 2)
1297
714
        for vol in vols:
1298
715
            self.assertTrue(vol['id'] == vol1['id'] or vol['id'] == vol2['id'])
1299
716
            self.assertTrue(vol['mountpoint'] == '/dev/vdb' or
1300
717
                            vol['mountpoint'] == '/dev/vdc')
1301
718
            self.assertEqual(vol['instance_id'], instance_id)
1302
719
            self.assertEqual(vol['status'], "in-use")
1303
720
            self.assertEqual(vol['attach_status'], "attached")
1304
721
1305
722
        self.cloud.terminate_instances(self.context, [ec2_instance_id])
1306
723
        greenthread.sleep(0.3)
1307
724
1308
725
        admin_ctxt = context.get_admin_context(read_deleted=False)
1309
726
        vol = db.volume_get(admin_ctxt, vol1['id'])
1310
727
        self.assertFalse(vol['deleted'])
1311
728
        db.volume_destroy(self.context, vol1['id'])
1312
729
1313
730
        greenthread.sleep(0.3)
1314
731
        admin_ctxt = context.get_admin_context(read_deleted=True)
1315
732
        vol = db.volume_get(admin_ctxt, vol2['id'])
1316
733
        self.assertTrue(vol['deleted'])
1317
734
1318
735
        self._restart_compute_service()
1319
736
1320
737
    def test_stop_with_attached_volume(self):
1321
738
        """Make sure attach info is reflected to block device mapping"""
1322
739
        # enforce periodic tasks run in short time to avoid wait for 60s.
1323
740
        self._restart_compute_service(periodic_interval=0.3)
1324
741
1325
742
        vol1 = self._volume_create()
1326
743
        vol2 = self._volume_create()
1327
744
        kwargs = {'image_id': 'ami-1',
1328
745
                  'instance_type': FLAGS.default_instance_type,
1329
746
                  'max_count': 1,
1330
747
                  'block_device_mapping': [{'device_name': '/dev/vdb',
1331
748
                                            'volume_id': vol1['id'],
1332
749
                                            'delete_on_termination': True}]}
1333
750
        ec2_instance_id = self._run_instance_wait(**kwargs)
1334
751
        instance_id = ec2utils.ec2_id_to_id(ec2_instance_id)
1335
752
1336
753
        vols = db.volume_get_all_by_instance(self.context, instance_id)
1337
754
        self.assertEqual(len(vols), 1)
1338
755
        for vol in vols:
1339
756
            self.assertEqual(vol['id'], vol1['id'])
1340
757
            self._assert_volume_attached(vol, instance_id, '/dev/vdb')
1341
758
1342
759
        vol = db.volume_get(self.context, vol2['id'])
1343
760
        self._assert_volume_detached(vol)
1344
761
1345
762
        self.cloud.compute_api.attach_volume(self.context,
1346
763
                                             instance_id=instance_id,
1347
764
                                             volume_id=vol2['id'],
1348
765
                                             device='/dev/vdc')
1349
766
        greenthread.sleep(0.3)
1350
767
        vol = db.volume_get(self.context, vol2['id'])
1351
768
        self._assert_volume_attached(vol, instance_id, '/dev/vdc')
1352
769
1353
770
        self.cloud.compute_api.detach_volume(self.context,
1354
771
                                             volume_id=vol1['id'])
1355
772
        greenthread.sleep(0.3)
1356
773
        vol = db.volume_get(self.context, vol1['id'])
1357
774
        self._assert_volume_detached(vol)
1358
775
1359
776
        result = self.cloud.stop_instances(self.context, [ec2_instance_id])
1360
777
        self.assertTrue(result)
1361
778
        self._wait_for_stopped(ec2_instance_id)
1362
779
1363
780
        for vol_id in (vol1['id'], vol2['id']):
1364
781
            vol = db.volume_get(self.context, vol_id)
1365
782
            self._assert_volume_detached(vol)
1366
783
1367
784
        self.cloud.start_instances(self.context, [ec2_instance_id])
1368
785
        self._wait_for_running(ec2_instance_id)
1369
786
        vols = db.volume_get_all_by_instance(self.context, instance_id)
1370
787
        self.assertEqual(len(vols), 1)
1371
788
        for vol in vols:
1372
789
            self.assertEqual(vol['id'], vol2['id'])
1373
790
            self._assert_volume_attached(vol, instance_id, '/dev/vdc')
1374
791
1375
792
        vol = db.volume_get(self.context, vol1['id'])
1376
793
        self._assert_volume_detached(vol)
1377
794
1378
795
        self.cloud.terminate_instances(self.context, [ec2_instance_id])
1379
796
        greenthread.sleep(0.3)
1380
797
1381
798
        for vol_id in (vol1['id'], vol2['id']):
1382
799
            vol = db.volume_get(self.context, vol_id)
1383
800
            self.assertEqual(vol['id'], vol_id)
1384
801
            self._assert_volume_detached(vol)
1385
802
            db.volume_destroy(self.context, vol_id)
1386
803
1387
804
        self._restart_compute_service()
1388
805
1389
806
    def _create_snapshot(self, ec2_volume_id):
1390
807
        result = self.cloud.create_snapshot(self.context,
1391
808
                                            volume_id=ec2_volume_id)
1392
809
        greenthread.sleep(0.3)
1393
810
        return result['snapshotId']
1394
811
1395
812
    def test_run_with_snapshot(self):
1396
813
        """Makes sure run/stop/start instance with snapshot works."""
1397
814
        vol = self._volume_create()
1398
815
        ec2_volume_id = ec2utils.id_to_ec2_id(vol['id'], 'vol-%08x')
1399
816
1400
817
        ec2_snapshot1_id = self._create_snapshot(ec2_volume_id)
1401
818
        snapshot1_id = ec2utils.ec2_id_to_id(ec2_snapshot1_id)
1402
819
        ec2_snapshot2_id = self._create_snapshot(ec2_volume_id)
1403
820
        snapshot2_id = ec2utils.ec2_id_to_id(ec2_snapshot2_id)
1404
821
1405
822
        kwargs = {'image_id': 'ami-1',
1406
823
                  'instance_type': FLAGS.default_instance_type,
1407
824
                  'max_count': 1,
1408
825
                  'block_device_mapping': [{'device_name': '/dev/vdb',
1409
826
                                            'snapshot_id': snapshot1_id,
1410
827
                                            'delete_on_termination': False, },
1411
828
                                           {'device_name': '/dev/vdc',
1412
829
                                            'snapshot_id': snapshot2_id,
1413
830
                                            'delete_on_termination': True}]}
1414
831
        ec2_instance_id = self._run_instance_wait(**kwargs)
1415
832
        instance_id = ec2utils.ec2_id_to_id(ec2_instance_id)
1416
833
1417
834
        vols = db.volume_get_all_by_instance(self.context, instance_id)
1418
835
        self.assertEqual(len(vols), 2)
1419
836
        vol1_id = None
1420
837
        vol2_id = None
1421
838
        for vol in vols:
1422
839
            snapshot_id = vol['snapshot_id']
1423
840
            if snapshot_id == snapshot1_id:
1424
841
                vol1_id = vol['id']
1425
842
                mountpoint = '/dev/vdb'
1426
843
            elif snapshot_id == snapshot2_id:
1427
844
                vol2_id = vol['id']
1428
845
                mountpoint = '/dev/vdc'
1429
846
            else:
1430
847
                self.fail()
1431
848
1432
849
            self._assert_volume_attached(vol, instance_id, mountpoint)
1433
850
1434
851
        self.assertTrue(vol1_id)
1435
852
        self.assertTrue(vol2_id)
1436
853
1437
854
        self.cloud.terminate_instances(self.context, [ec2_instance_id])
1438
855
        greenthread.sleep(0.3)
1439
856
        self._wait_for_terminate(ec2_instance_id)
1440
857
1441
858
        greenthread.sleep(0.3)
1442
859
        admin_ctxt = context.get_admin_context(read_deleted=False)
1443
860
        vol = db.volume_get(admin_ctxt, vol1_id)
1444
861
        self._assert_volume_detached(vol)
1445
862
        self.assertFalse(vol['deleted'])
1446
863
        db.volume_destroy(self.context, vol1_id)
1447
864
1448
865
        greenthread.sleep(0.3)
1449
866
        admin_ctxt = context.get_admin_context(read_deleted=True)
1450
867
        vol = db.volume_get(admin_ctxt, vol2_id)
1451
868
        self.assertTrue(vol['deleted'])
1452
869
1453
870
        for snapshot_id in (ec2_snapshot1_id, ec2_snapshot2_id):
1454
871
            self.cloud.delete_snapshot(self.context, snapshot_id)
1455
872
            greenthread.sleep(0.3)
1456
873
        db.volume_destroy(self.context, vol['id'])
1457
572
874
1458
=== modified file 'nova/tests/test_compute.py'
1459
--- nova/tests/test_compute.py	2011-06-07 17:32:06 +0000
1460
+++ nova/tests/test_compute.py	2011-06-17 23:35:54 +0000
1461
@@ -228,6 +228,21 @@
1462
228
        self.assert_(instance_ref['launched_at'] < terminate)
228
        self.assert_(instance_ref['launched_at'] < terminate)
1463
229
        self.assert_(instance_ref['deleted_at'] > terminate)
229
        self.assert_(instance_ref['deleted_at'] > terminate)
1464
230
230
1465
231
    def test_stop(self):
1466
232
        """Ensure instance can be stopped"""
1467
233
        instance_id = self._create_instance()
1468
234
        self.compute.run_instance(self.context, instance_id)
1469
235
        self.compute.stop_instance(self.context, instance_id)
1470
236
        self.compute.terminate_instance(self.context, instance_id)
1471
237
1472
238
    def test_start(self):
1473
239
        """Ensure instance can be started"""
1474
240
        instance_id = self._create_instance()
1475
241
        self.compute.run_instance(self.context, instance_id)
1476
242
        self.compute.stop_instance(self.context, instance_id)
1477
243
        self.compute.start_instance(self.context, instance_id)
1478
244
        self.compute.terminate_instance(self.context, instance_id)
1479
245
1480
231
    def test_pause(self):
246
    def test_pause(self):
1481
232
        """Ensure instance can be paused"""
247
        """Ensure instance can be paused"""
1482
233
        instance_id = self._create_instance()
248
        instance_id = self._create_instance()
1483
234
249
1484
=== modified file 'nova/virt/driver.py'
1485
--- nova/virt/driver.py	2011-03-30 00:35:24 +0000
1486
+++ nova/virt/driver.py	2011-06-17 23:35:54 +0000
1487
@@ -61,7 +61,7 @@
1488
61
        """Return a list of InstanceInfo for all registered VMs"""
61
        """Return a list of InstanceInfo for all registered VMs"""
1489
62
        raise NotImplementedError()
62
        raise NotImplementedError()
1490
63
63
1492
64
    def spawn(self, instance, network_info=None):
64
    def spawn(self, instance, network_info=None, block_device_mapping=None):
1493
65
        """Launch a VM for the specified instance"""
65
        """Launch a VM for the specified instance"""
1494
66
        raise NotImplementedError()
66
        raise NotImplementedError()
1495
67
67
1496
68
68
1497
=== modified file 'nova/virt/fake.py'
1498
--- nova/virt/fake.py	2011-05-17 14:49:12 +0000
1499
+++ nova/virt/fake.py	2011-06-17 23:35:54 +0000
1500
@@ -129,7 +129,7 @@
1501
129
            info_list.append(self._map_to_instance_info(instance))
129
            info_list.append(self._map_to_instance_info(instance))
1502
130
        return info_list
130
        return info_list
1503
131
131
1505
132
    def spawn(self, instance):
132
    def spawn(self, instance, network_info=None, block_device_mapping=None):
1506
133
        """
133
        """
1507
134
        Create a new instance/VM/domain on the virtualization platform.
134
        Create a new instance/VM/domain on the virtualization platform.
1508
135
135
1509
@@ -237,6 +237,10 @@
1510
237
        """
237
        """
1511
238
        pass
238
        pass
1512
239
239
1513
240
    def poll_rescued_instances(self, timeout):
1514
241
        """Poll for rescued instances"""
1515
242
        pass
1516
243
1517
240
    def migrate_disk_and_power_off(self, instance, dest):
244
    def migrate_disk_and_power_off(self, instance, dest):
1518
241
        """
245
        """
1519
242
        Transfers the disk of a running instance in multiple phases, turning
246
        Transfers the disk of a running instance in multiple phases, turning
1520
243
247
1521
=== modified file 'nova/virt/hyperv.py'
1522
--- nova/virt/hyperv.py	2011-05-28 11:49:31 +0000
1523
+++ nova/virt/hyperv.py	2011-06-17 23:35:54 +0000
1524
@@ -139,7 +139,7 @@
1525
139
139
1526
140
        return instance_infos
140
        return instance_infos
1527
141
141
1529
142
    def spawn(self, instance):
142
    def spawn(self, instance, network_info=None, block_device_mapping=None):
1530
143
        """ Create a new VM and start it."""
143
        """ Create a new VM and start it."""
1531
144
        vm = self._lookup(instance.name)
144
        vm = self._lookup(instance.name)
1532
145
        if vm is not None:
145
        if vm is not None:
1533
146
146
1534
=== modified file 'nova/virt/libvirt.xml.template'
1535
--- nova/virt/libvirt.xml.template	2011-05-31 17:45:26 +0000
1536
+++ nova/virt/libvirt.xml.template	2011-06-17 23:35:54 +0000
1537
@@ -67,11 +67,13 @@
1538
67
            <target dev='${disk_prefix}b' bus='${disk_bus}'/>
67
            <target dev='${disk_prefix}b' bus='${disk_bus}'/>
1539
68
        </disk>
68
        </disk>
1540
69
    #else
69
    #else
1541
70
        #if not ($getVar('ebs_root', False))
1542
70
        <disk type='file'>
71
        <disk type='file'>
1543
71
            <driver type='${driver_type}'/>
72
            <driver type='${driver_type}'/>
1544
72
            <source file='${basepath}/disk'/>
73
            <source file='${basepath}/disk'/>
1545
73
            <target dev='${disk_prefix}a' bus='${disk_bus}'/>
74
            <target dev='${disk_prefix}a' bus='${disk_bus}'/>
1546
74
        </disk>
75
        </disk>
1547
76
        #end if
1548
75
        #if $getVar('local', False)
77
        #if $getVar('local', False)
1549
76
            <disk type='file'>
78
            <disk type='file'>
1550
77
                <driver type='${driver_type}'/>
79
                <driver type='${driver_type}'/>
1551
@@ -79,6 +81,13 @@
1552
79
                <target dev='${disk_prefix}b' bus='${disk_bus}'/>
81
                <target dev='${disk_prefix}b' bus='${disk_bus}'/>
1553
80
            </disk>
82
            </disk>
1554
81
        #end if
83
        #end if
1555
84
        #for $vol in $volumes
1556
85
            <disk type='block'>
1557
86
                <driver type='raw'/>
1558
87
                <source dev='${vol.device_path}'/>
1559
88
                <target dev='${vol.mount_device}' bus='${disk_bus}'/>
1560
89
            </disk>
1561
90
        #end for
1562
82
    #end if
91
    #end if
1563
83
#end if
92
#end if
1564
84
93
1565
85
94
1566
=== modified file 'nova/virt/libvirt/connection.py'
1567
--- nova/virt/libvirt/connection.py	2011-06-06 15:54:11 +0000
1568
+++ nova/virt/libvirt/connection.py	2011-06-17 23:35:54 +0000
1569
@@ -40,6 +40,7 @@
1570
40
import multiprocessing
40
import multiprocessing
1571
41
import os
41
import os
1572
42
import random
42
import random
1573
43
import re
1574
43
import shutil
44
import shutil
1575
44
import subprocess
45
import subprocess
1576
45
import sys
46
import sys
1577
@@ -148,6 +149,10 @@
1578
148
        Template = t.Template
149
        Template = t.Template
1579
149
150
1580
150
151
1581
152
def _strip_dev(mount_path):
1582
153
        return re.sub(r'^/dev/', '', mount_path)
1583
154
1584
155
1585
151
class LibvirtConnection(driver.ComputeDriver):
156
class LibvirtConnection(driver.ComputeDriver):
1586
152
157
1587
153
    def __init__(self, read_only):
158
    def __init__(self, read_only):
1588
@@ -575,11 +580,14 @@
1589
575
    # NOTE(ilyaalekseyev): Implementation like in multinics
580
    # NOTE(ilyaalekseyev): Implementation like in multinics
1590
576
    # for xenapi(tr3buchet)
581
    # for xenapi(tr3buchet)
1591
577
    @exception.wrap_exception
582
    @exception.wrap_exception
1594
578
    def spawn(self, instance, network_info=None):
583
    def spawn(self, instance, network_info=None, block_device_mapping=None):
1595
579
        xml = self.to_xml(instance, False, network_info)
584
        xml = self.to_xml(instance, False, network_info=network_info,
1596
585
                          block_device_mapping=block_device_mapping)
1597
586
        block_device_mapping = block_device_mapping or []
1598
580
        self.firewall_driver.setup_basic_filtering(instance, network_info)
587
        self.firewall_driver.setup_basic_filtering(instance, network_info)
1599
581
        self.firewall_driver.prepare_instance_filter(instance, network_info)
588
        self.firewall_driver.prepare_instance_filter(instance, network_info)
1601
582
        self._create_image(instance, xml, network_info=network_info)
589
        self._create_image(instance, xml, network_info=network_info,
1602
590
                           block_device_mapping=block_device_mapping)
1603
583
        domain = self._create_new_domain(xml)
591
        domain = self._create_new_domain(xml)
1604
584
        LOG.debug(_("instance %s: is running"), instance['name'])
592
        LOG.debug(_("instance %s: is running"), instance['name'])
1605
585
        self.firewall_driver.apply_instance_filter(instance)
593
        self.firewall_driver.apply_instance_filter(instance)
1606
@@ -761,7 +769,8 @@
1607
761
        # TODO(vish): should we format disk by default?
769
        # TODO(vish): should we format disk by default?
1608
762
770
1609
763
    def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None,
771
    def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None,
1611
764
                        network_info=None):
772
                        network_info=None, block_device_mapping=None):
1612
773
        block_device_mapping = block_device_mapping or []
1613
765
        if not network_info:
774
        if not network_info:
1614
766
            network_info = netutils.get_network_info(inst)
775
            network_info = netutils.get_network_info(inst)
1615
767
776
1616
@@ -824,16 +833,19 @@
1617
824
            size = None
833
            size = None
1618
825
            root_fname += "_sm"
834
            root_fname += "_sm"
1619
826
835
1628
827
        self._cache_image(fn=self._fetch_image,
836
        if not self._volume_in_mapping(self.root_mount_device,
1629
828
                          target=basepath('disk'),
837
                                       block_device_mapping):
1630
829
                          fname=root_fname,
838
            self._cache_image(fn=self._fetch_image,
1631
830
                          cow=FLAGS.use_cow_images,
839
                              target=basepath('disk'),
1632
831
                          image_id=disk_images['image_id'],
840
                              fname=root_fname,
1633
832
                          user=user,
841
                              cow=FLAGS.use_cow_images,
1634
833
                          project=project,
842
                              image_id=disk_images['image_id'],
1635
834
                          size=size)
843
                              user=user,
1636
844
                              project=project,
1637
845
                              size=size)
1638
835
846
1640
836
        if inst_type['local_gb']:
847
        if inst_type['local_gb'] and not self._volume_in_mapping(
1641
848
            self.local_mount_device, block_device_mapping):
1642
837
            self._cache_image(fn=self._create_local,
849
            self._cache_image(fn=self._create_local,
1643
838
                              target=basepath('disk.local'),
850
                              target=basepath('disk.local'),
1644
839
                              fname="local_%s" % inst_type['local_gb'],
851
                              fname="local_%s" % inst_type['local_gb'],
1645
@@ -948,7 +960,20 @@
1646
948
960
1647
949
        return result
961
        return result
1648
950
962
1650
951
    def _prepare_xml_info(self, instance, rescue=False, network_info=None):
963
    root_mount_device = 'vda'  # FIXME for now. it's hard coded.
1651
964
    local_mount_device = 'vdb'  # FIXME for now. it's hard coded.
1652
965
1653
966
    def _volume_in_mapping(self, mount_device, block_device_mapping):
1654
967
        mount_device_ = _strip_dev(mount_device)
1655
968
        for vol in block_device_mapping:
1656
969
            vol_mount_device = _strip_dev(vol['mount_device'])
1657
970
            if vol_mount_device == mount_device_:
1658
971
                return True
1659
972
        return False
1660
973
1661
974
    def _prepare_xml_info(self, instance, rescue=False, network_info=None,
1662
975
                          block_device_mapping=None):
1663
976
        block_device_mapping = block_device_mapping or []
1664
952
        # TODO(adiantum) remove network_info creation code
977
        # TODO(adiantum) remove network_info creation code
1665
953
        # when multinics will be completed
978
        # when multinics will be completed
1666
954
        if not network_info:
979
        if not network_info:
1667
@@ -966,6 +991,16 @@
1668
966
        else:
991
        else:
1669
967
            driver_type = 'raw'
992
            driver_type = 'raw'
1670
968
993
1671
994
        for vol in block_device_mapping:
1672
995
            vol['mount_device'] = _strip_dev(vol['mount_device'])
1673
996
        ebs_root = self._volume_in_mapping(self.root_mount_device,
1674
997
                                           block_device_mapping)
1675
998
        if self._volume_in_mapping(self.local_mount_device,
1676
999
                                   block_device_mapping):
1677
1000
            local_gb = False
1678
1001
        else:
1679
1002
            local_gb = inst_type['local_gb']
1680
1003
1681
969
        xml_info = {'type': FLAGS.libvirt_type,
1004
        xml_info = {'type': FLAGS.libvirt_type,
1682
970
                    'name': instance['name'],
1005
                    'name': instance['name'],
1683
971
                    'basepath': os.path.join(FLAGS.instances_path,
1006
                    'basepath': os.path.join(FLAGS.instances_path,
1684
@@ -973,9 +1008,11 @@
1685
973
                    'memory_kb': inst_type['memory_mb'] * 1024,
1008
                    'memory_kb': inst_type['memory_mb'] * 1024,
1686
974
                    'vcpus': inst_type['vcpus'],
1009
                    'vcpus': inst_type['vcpus'],
1687
975
                    'rescue': rescue,
1010
                    'rescue': rescue,
1689
976
                    'local': inst_type['local_gb'],
1011
                    'local': local_gb,
1690
977
                    'driver_type': driver_type,
1012
                    'driver_type': driver_type,
1692
978
                    'nics': nics}
1013
                    'nics': nics,
1693
1014
                    'ebs_root': ebs_root,
1694
1015
                    'volumes': block_device_mapping}
1695
979
1016
1696
980
        if FLAGS.vnc_enabled:
1017
        if FLAGS.vnc_enabled:
1697
981
            if FLAGS.libvirt_type != 'lxc':
1018
            if FLAGS.libvirt_type != 'lxc':
1698
@@ -991,10 +1028,13 @@
1699
991
            xml_info['disk'] = xml_info['basepath'] + "/disk"
1028
            xml_info['disk'] = xml_info['basepath'] + "/disk"
1700
992
        return xml_info
1029
        return xml_info
1701
993
1030
1703
994
    def to_xml(self, instance, rescue=False, network_info=None):
1031
    def to_xml(self, instance, rescue=False, network_info=None,
1704
1032
               block_device_mapping=None):
1705
1033
        block_device_mapping = block_device_mapping or []
1706
995
        # TODO(termie): cache?
1034
        # TODO(termie): cache?
1707
996
        LOG.debug(_('instance %s: starting toXML method'), instance['name'])
1035
        LOG.debug(_('instance %s: starting toXML method'), instance['name'])
1709
997
        xml_info = self._prepare_xml_info(instance, rescue, network_info)
1036
        xml_info = self._prepare_xml_info(instance, rescue, network_info,
1710
1037
                                          block_device_mapping)
1711
998
        xml = str(Template(self.libvirt_xml, searchList=[xml_info]))
1038
        xml = str(Template(self.libvirt_xml, searchList=[xml_info]))
1712
999
        LOG.debug(_('instance %s: finished toXML method'), instance['name'])
1039
        LOG.debug(_('instance %s: finished toXML method'), instance['name'])
1713
1000
        return xml
1040
        return xml
1714
1001
1041
1715
=== modified file 'nova/virt/vmwareapi_conn.py'
1716
--- nova/virt/vmwareapi_conn.py	2011-04-12 21:43:07 +0000
1717
+++ nova/virt/vmwareapi_conn.py	2011-06-17 23:35:54 +0000
1718
@@ -124,7 +124,7 @@
1719
124
        """List VM instances."""
124
        """List VM instances."""
1720
125
        return self._vmops.list_instances()
125
        return self._vmops.list_instances()
1721
126
126
1723
127
    def spawn(self, instance):
127
    def spawn(self, instance, network_info=None, block_device_mapping=None):
1724
128
        """Create VM instance."""
128
        """Create VM instance."""
1725
129
        self._vmops.spawn(instance)
129
        self._vmops.spawn(instance)
1726
130
130
1727
131
131
1728
=== modified file 'nova/virt/xenapi_conn.py'
1729
--- nova/virt/xenapi_conn.py	2011-05-18 16:27:39 +0000
1730
+++ nova/virt/xenapi_conn.py	2011-06-17 23:35:54 +0000
1731
@@ -194,7 +194,7 @@
1732
194
    def list_instances_detail(self):
194
    def list_instances_detail(self):
1733
195
        return self._vmops.list_instances_detail()
195
        return self._vmops.list_instances_detail()
1734
196
196
1736
197
    def spawn(self, instance):
197
    def spawn(self, instance, network_info=None, block_device_mapping=None):
1737
198
        """Create VM instance"""
198
        """Create VM instance"""
1738
199
        self._vmops.spawn(instance)
199
        self._vmops.spawn(instance)
1739
200
200
1740
201
201
1741
=== modified file 'nova/volume/api.py'
1742
--- nova/volume/api.py	2011-06-02 21:23:05 +0000
1743
+++ nova/volume/api.py	2011-06-17 23:35:54 +0000
1744
@@ -21,6 +21,9 @@
1745
21
"""
21
"""
1746
22
22
1747
23
23
1748
24
from eventlet import greenthread
1749
25
1750
26
from nova import db
1751
24
from nova import exception
27
from nova import exception
1752
25
from nova import flags
28
from nova import flags
1753
26
from nova import log as logging
29
from nova import log as logging
1754
@@ -44,7 +47,8 @@
1755
44
            if snapshot['status'] != "available":
47
            if snapshot['status'] != "available":
1756
45
                raise exception.ApiError(
48
                raise exception.ApiError(
1757
46
                    _("Snapshot status must be available"))
49
                    _("Snapshot status must be available"))
1759
47
            size = snapshot['volume_size']
50
            if not size:
1760
51
                size = snapshot['volume_size']
1761
48
52
1762
49
        if quota.allowed_volumes(context, 1, size) < 1:
53
        if quota.allowed_volumes(context, 1, size) < 1:
1763
50
            pid = context.project_id
54
            pid = context.project_id
1764
@@ -73,6 +77,14 @@
1765
73
                           "snapshot_id": snapshot_id}})
77
                           "snapshot_id": snapshot_id}})
1766
74
        return volume
78
        return volume
1767
75
79
1768
80
    # TODO(yamahata): eliminate dumb polling
1769
81
    def wait_creation(self, context, volume_id):
1770
82
        while True:
1771
83
            volume = self.get(context, volume_id)
1772
84
            if volume['status'] != 'creating':
1773
85
                return
1774
86
            greenthread.sleep(1)
1775
87
1776
76
    def delete(self, context, volume_id):
88
    def delete(self, context, volume_id):
1777
77
        volume = self.get(context, volume_id)
89
        volume = self.get(context, volume_id)
1778
78
        if volume['status'] != "available":
90
        if volume['status'] != "available":
1779
79
91
1780
=== modified file 'nova/volume/driver.py'
1781
--- nova/volume/driver.py	2011-05-27 05:13:17 +0000
1782
+++ nova/volume/driver.py	2011-06-17 23:35:54 +0000
1783
@@ -582,6 +582,14 @@
1784
582
        """No setup necessary in fake mode."""
582
        """No setup necessary in fake mode."""
1785
583
        pass
583
        pass
1786
584
584
1787
585
    def discover_volume(self, context, volume):
1788
586
        """Discover volume on a remote host."""
1789
587
        return "/dev/disk/by-path/volume-id-%d" % volume['id']
1790
588
1791
589
    def undiscover_volume(self, volume):
1792
590
        """Undiscover volume on a remote host."""
1793
591
        pass
1794
592
1795
585
    @staticmethod
593
    @staticmethod
1796
586
    def fake_execute(cmd, *_args, **_kwargs):
594
    def fake_execute(cmd, *_args, **_kwargs):
1797
587
        """Execute that simply logs the command."""
595
        """Execute that simply logs the command."""
Status:	Merged
Merged at revision:	1198
Proposed branch:	lp:~yamahata/nova/boot-from-volume-0
Merge into:	lp:~hudson-openstack/nova/trunk
Prerequisite:	lp:~morita-kazutaka/nova/clone-volume
Diff against target:	1797 lines (+1068/-149) 23 files modified nova/api/ec2/apirequest.py (+3/-75) nova/api/ec2/cloud.py (+47/-11) nova/api/ec2/ec2utils.py (+94/-0) nova/compute/api.py (+87/-17) nova/compute/manager.py (+136/-10) nova/compute/utils.py (+29/-0) nova/db/api.py (+35/-0) nova/db/sqlalchemy/api.py (+79/-0) nova/db/sqlalchemy/migrate_repo/versions/024_add_block_device_mapping.py (+87/-0) nova/db/sqlalchemy/models.py (+39/-0) nova/scheduler/simple.py (+7/-1) nova/tests/test_api.py (+1/-1) nova/tests/test_cloud.py (+312/-10) nova/tests/test_compute.py (+15/-0) nova/virt/driver.py (+1/-1) nova/virt/fake.py (+5/-1) nova/virt/hyperv.py (+1/-1) nova/virt/libvirt.xml.template (+9/-0) nova/virt/libvirt/connection.py (+58/-18) nova/virt/vmwareapi_conn.py (+1/-1) nova/virt/xenapi_conn.py (+1/-1) nova/volume/api.py (+13/-1) nova/volume/driver.py (+8/-0)
To merge this branch:	bzr merge lp:~yamahata/nova/boot-from-volume-0
Related bugs:	Link a bug report
Related blueprints:	Boot From Volume (High)
Reviewer	Date Requested	Status
Rick Harris (community)		Approve on 2011-06-17
Matt Dietz (community)		Approve on 2011-06-15
Devin Carlen (community)	2011-05-26	Needs Information on 2011-05-27
Review via email: mp+62419@code.launchpad.net