From 42272241d24e120398f741e9c8fa7d810b921209 Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Fri, 27 May 2011 11:08:02 +0900
Subject: api/ec2: parse ec2 block device mapping and pass it down to compute
 api

teach ec2 api block device mapping.
---
 nova/compute/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index a12f8d515..b809e59e2 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -134,7 +134,7 @@ class API(base.Base):
                display_name='', display_description='',
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata={},
-               injected_files=None):
+               injected_files=None, block_device_mapping=[]):
         """Create the number and type of instances requested.
 
         Verifies that quota and other arguments are valid.
-- 
cgit 


From 945d566c10877aeaf4d75bc26e161ba3a5f9c4b9 Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Fri, 27 May 2011 11:10:03 +0900
Subject: compute, virt: support boot-from-volume without ephemeral device and
 no device

This patch implements basic ebs boot support.
ephemeral device/no device isn't supported yet.
---
 nova/compute/api.py     | 54 +++++++++++++++++++++-------
 nova/compute/manager.py | 96 +++++++++++++++++++++++++++++++++++++++++++++++--
 nova/compute/utils.py   | 34 ++++++++++++++++++
 3 files changed, 168 insertions(+), 16 deletions(-)
 create mode 100644 nova/compute/utils.py

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index b809e59e2..af2f23724 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -34,6 +34,7 @@ from nova import utils
 from nova import volume
 from nova.compute import instance_types
 from nova.compute import power_state
+from nova.compute.utils import terminate_volumes
 from nova.scheduler import api as scheduler_api
 from nova.db import base
 
@@ -52,6 +53,18 @@ def generate_default_hostname(instance_id):
     return str(instance_id)
 
 
+def _is_able_to_shutdown(instance, instance_id):
+    states = {'terminating': "Instance %s is already being terminated",
+              'migrating': "Instance %s is being migrated",
+              'stopping': "Instance %s is being stopped"}
+    msg = states.get(instance['state_description'])
+    if msg:
+        LOG.warning(_(msg), instance_id)
+        return False
+
+    return True
+
+
 class API(base.Base):
     """API for interacting with the compute manager."""
 
@@ -238,6 +251,22 @@ class API(base.Base):
                                                     instance_id,
                                                     security_group_id)
 
+            # tell vm driver to attach volume at boot time by updating
+            # BlockDeviceMapping
+            for bdm in block_device_mapping:
+                LOG.debug(_('bdm %s'), bdm)
+                assert bdm.has_key('device_name')
+                values = {
+                    'instance_id': instance_id,
+                    'device_name': bdm['device_name'],
+                    'delete_on_termination': bdm.get('delete_on_termination'),
+                    'virtual_name': bdm.get('virtual_name'),
+                    'snapshot_id': bdm.get('snapshot_id'),
+                    'volume_id': bdm.get('volume_id'),
+                    'volume_size': bdm.get('volume_size'),
+                    'no_device': bdm.get('no_device')}
+                self.db.block_device_mapping_create(elevated, values)
+
             # Set sane defaults if not specified
             updates = dict(hostname=self.hostname_factory(instance_id))
             if (not hasattr(instance, 'display_name') or
@@ -365,24 +394,22 @@ class API(base.Base):
         rv = self.db.instance_update(context, instance_id, kwargs)
         return dict(rv.iteritems())
 
-    @scheduler_api.reroute_compute("delete")
-    def delete(self, context, instance_id):
-        """Terminate an instance."""
-        LOG.debug(_("Going to try to terminate %s"), instance_id)
+    def _get_instance(self, context, instance_id, action_str):
         try:
-            instance = self.get(context, instance_id)
+            return self.get(context, instance_id)
         except exception.NotFound:
-            LOG.warning(_("Instance %s was not found during terminate"),
-                        instance_id)
+            LOG.warning(_("Instance %(instance_id)s was not found during "
+                          "%(action_str)s") %
+                        {'instance_id': instance_id, 'action_str': action_str})
             raise
 
-        if instance['state_description'] == 'terminating':
-            LOG.warning(_("Instance %s is already being terminated"),
-                        instance_id)
-            return
+    @scheduler_api.reroute_compute("delete")
+    def delete(self, context, instance_id):
+        """Terminate an instance."""
+        LOG.debug(_("Going to try to terminate %s"), instance_id)
+        instance = self._get_instance(context, instance_id, 'terminating')
 
-        if instance['state_description'] == 'migrating':
-            LOG.warning(_("Instance %s is being migrated"), instance_id)
+        if not _is_able_to_shutdown(instance, instance_id):
             return
 
         self.update(context,
@@ -396,6 +423,7 @@ class API(base.Base):
             self._cast_compute_message('terminate_instance', context,
                     instance_id, host)
         else:
+            terminate_volumes(self.db, context, instance_id)
             self.db.instance_destroy(context, instance_id)
 
     def get(self, context, instance_id):
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 11565c25e..86dac0ff2 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -54,6 +54,7 @@ from nova import rpc
 from nova import utils
 from nova import volume
 from nova.compute import power_state
+from nova.compute.utils import terminate_volumes
 from nova.virt import driver
 
 
@@ -215,7 +216,59 @@ class ComputeManager(manager.SchedulerDependentManager):
         """
         return self.driver.refresh_security_group_members(security_group_id)
 
-    @exception.wrap_exception
+    def _setup_block_device_mapping(self, context, instance_id):
+        """setup volumes for block device mapping"""
+        self.db.instance_set_state(context,
+                                   instance_id,
+                                   power_state.NOSTATE,
+                                   'block_device_mapping')
+
+        block_device_mapping = []
+        try:
+            bdms = self.db.block_device_mapping_get_all_by_instance(
+                context, instance_id)
+        except exception.NotFound:
+            pass
+        else:
+            volume_api = volume.API()
+            for bdm in bdms:
+                LOG.debug(_("setting up bdm %s"), bdm)
+                if ((bdm['snapshot_id'] is not None) and
+                    (bdm['volume_id'] is None)):
+                    # TODO(yamahata): default name and description
+                    vol = volume_api.create(context, bdm['volume_size'],
+                                            bdm['snapshot_id'], '', '')
+                    # TODO(yamahata): creatning volume simulteneously
+                    #                 reduce creation time?
+                    volume_api.wait_creation(context, vol['id'])
+                    self.db.block_device_mapping_update(
+                        context, bdm['id'], {'volume_id': vol['id']})
+                    bdm['volume_id'] = vol['id']
+
+                assert ((bdm['snapshot_id'] is None) or
+                        (bdm['volume_id'] is not None))
+
+                if bdm['volume_id'] is not None:
+                    volume_api.check_attach(context,
+                                            volume_id=bdm['volume_id'])
+                    dev_path = self._attach_volume_boot(context, instance_id,
+                                                        bdm['volume_id'],
+                                                        bdm['device_name'])
+                    block_device_mapping.append({'device_path': dev_path,
+                                                 'mount_device':
+                                                 bdm['device_name']})
+                elif bdm['virtual_name'] is not None:
+                    # TODO(yamahata)
+                    LOG.debug(_('block_device_mapping: '
+                                'ephemeral device is not supported yet'))
+                else:
+                    # TODO(yamahata)
+                    assert bdm['no_device']
+                    LOG.debug(_('block_device_mapping: '
+                                'no device is not supported yet'))
+
+        return block_device_mapping
+
     def run_instance(self, context, instance_id, **kwargs):
         """Launch a new instance with specified options."""
         context = context.elevated()
@@ -249,11 +302,15 @@ class ComputeManager(manager.SchedulerDependentManager):
             self.network_manager.setup_compute_network(context,
                                                        instance_id)
 
+        block_device_mapping = self._setup_block_device_mapping(context,
+                                                                instance_id)
+
         # TODO(vish) check to make sure the availability zone matches
         self._update_state(context, instance_id, power_state.BUILDING)
 
         try:
-            self.driver.spawn(instance_ref)
+            self.driver.spawn(instance_ref,
+                              block_device_mapping=block_device_mapping)
         except Exception as ex:  # pylint: disable=W0702
             msg = _("Instance '%(instance_id)s' failed to spawn. Is "
                     "virtualization enabled in the BIOS? Details: "
@@ -786,6 +843,22 @@ class ComputeManager(manager.SchedulerDependentManager):
         instance_ref = self.db.instance_get(context, instance_id)
         return self.driver.get_vnc_console(instance_ref)
 
+    def _attach_volume_boot(self, context, instance_id, volume_id, mountpoint):
+        """Attach a volume to an instnace at boot time. So actual attach
+        is done by instance creation"""
+
+        # TODO(yamahata):
+        # should move check_attach to volume manager?
+        volume.API().check_attach(context, volume_id)
+
+        context = context.elevated()
+        LOG.audit(_("instance %(instance_id)s: booting with "
+                    "volume %(volume_id)s at %(mountpoint)s") %
+                  locals(), context=context)
+        dev_path = self.volume_manager.setup_compute_volume(context, volume_id)
+        self.db.volume_attached(context, volume_id, instance_id, mountpoint)
+        return dev_path
+
     @checks_instance_lock
     def attach_volume(self, context, instance_id, volume_id, mountpoint):
         """Attach a volume to an instance."""
@@ -803,6 +876,16 @@ class ComputeManager(manager.SchedulerDependentManager):
                                     volume_id,
                                     instance_id,
                                     mountpoint)
+            values = {
+                'instance_id': instance_id,
+                'device_name': mountpoint,
+                'delete_on_termination': False,
+                'virtual_name': None,
+                'snapshot_id': None,
+                'volume_id': volume_id,
+                'volume_size': None,
+                'no_device': None}
+            self.db.block_device_mapping_create(context, values)
         except Exception as exc:  # pylint: disable=W0702
             # NOTE(vish): The inline callback eats the exception info so we
             #             log the traceback here and reraise the same
@@ -817,7 +900,7 @@ class ComputeManager(manager.SchedulerDependentManager):
 
     @exception.wrap_exception
     @checks_instance_lock
-    def detach_volume(self, context, instance_id, volume_id):
+    def _detach_volume(self, context, instance_id, volume_id, destroy_bdm):
         """Detach a volume from an instance."""
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
@@ -833,8 +916,15 @@ class ComputeManager(manager.SchedulerDependentManager):
                                       volume_ref['mountpoint'])
         self.volume_manager.remove_compute_volume(context, volume_id)
         self.db.volume_detached(context, volume_id)
+        if destroy_bdm:
+            self.db.block_device_mapping_destroy_by_instance_and_volume(
+                context, instance_id, volume_id)
         return True
 
+    def detach_volume(self, context, instance_id, volume_id):
+        """Detach a volume from an instance."""
+        return self._detach_volume(context, instance_id, volume_id, True)
+
     def remove_volume(self, context, volume_id):
         """Remove volume on compute host.
 
diff --git a/nova/compute/utils.py b/nova/compute/utils.py
new file mode 100644
index 000000000..f0a3ab59b
--- /dev/null
+++ b/nova/compute/utils.py
@@ -0,0 +1,34 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 VA Linux Systems Japan K.K
+# Copyright (c) 2011 Isaku Yamahata
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from nova import exception
+from nova import volume
+
+def terminate_volumes(db, context, instance_id):
+    """delete volumes of delete_on_termination=True in block device mapping"""
+    try:
+        bdms = db.block_device_mapping_get_all_by_instance(
+            context, instance_id)
+    except exception.NotFound:
+        pass
+    else:
+        volume_api = volume.API()
+        for bdm in bdms:
+            #LOG.debug(_("terminating bdm %s") % bdm)
+            if bdm['volume_id'] and bdm['delete_on_termination']:
+                volume_api.delete(context, bdm['volume_id'])
+            db.block_device_mapping_destroy(context, bdm['id'])
-- 
cgit 


From ab938bf376efe7a93b54e4ca595d3102d04b0080 Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Fri, 27 May 2011 11:10:24 +0900
Subject: compute: implement ec2 stop/start instances

This patch implements ec2 stop/start instances with block device mapping
support.
---
 nova/compute/api.py     | 39 +++++++++++++++++++++++++++++++++++++++
 nova/compute/manager.py | 48 +++++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 80 insertions(+), 7 deletions(-)

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index af2f23724..6b38e4eb5 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -426,6 +426,45 @@ class API(base.Base):
             terminate_volumes(self.db, context, instance_id)
             self.db.instance_destroy(context, instance_id)
 
+    @scheduler_api.reroute_compute("stop")
+    def stop(self, context, instance_id):
+        """Stop an instnace."""
+        LOG.debug(_("Going to try to stop %s"), instance_id)
+
+        instance = self._get_instance(context, instance_id, 'stopping')
+        if not _is_able_to_shutdown(instance, instance_id):
+            return
+        
+        self.update(context,
+                    instance['id'],
+                    state_description='stopping',
+                    state=power_state.NOSTATE,
+                    terminated_at=datetime.datetime.utcnow())
+
+        host = instance['host']
+        if host:
+            self._cast_compute_message('stop_instance', context,
+                    instance_id, host)
+
+    def start(self, context, instance_id):
+        """Start an instnace."""
+        LOG.debug(_("Going to try to start %s"), instance_id)
+        instance = self._get_instance(context, instance_id, 'starting')
+        if instance['state_description'] != 'stopped':
+            _state_description = instance['state_description']
+            LOG.warning(_("Instance %(instance_id)s is not "
+                          "stopped(%(_state_description)s)") % locals())
+            return
+
+        # TODO(yamahata): injected_files isn't supported right now.
+        #                 It is used only for osapi. not for ec2 api.
+        #                 availability_zone isn't used by run_instance.
+        rpc.cast(context,
+                 FLAGS.scheduler_topic,
+                 {"method": "start_instance",
+                  "args": {"topic": FLAGS.compute_topic,
+                           "instance_id": instance_id}})
+
     def get(self, context, instance_id):
         """Get a single instance with the given instance_id."""
         rv = self.db.instance_get(context, instance_id)
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 86dac0ff2..5e8429e88 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -269,7 +269,7 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         return block_device_mapping
 
-    def run_instance(self, context, instance_id, **kwargs):
+    def _run_instance(self, context, instance_id, **kwargs):
         """Launch a new instance with specified options."""
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
@@ -333,13 +333,25 @@ class ComputeManager(manager.SchedulerDependentManager):
         self._update_launched_at(context, instance_id)
         self._update_state(context, instance_id)
 
+    @exception.wrap_exception
+    def run_instance(self, context, instance_id, **kwargs):
+        self._run_instance(context, instance_id, **kwargs)
+
     @exception.wrap_exception
     @checks_instance_lock
-    def terminate_instance(self, context, instance_id):
-        """Terminate an instance on this host."""
+    def start_instance(self, context, instance_id):
+        """Starting an instance on this host."""
+        # TODO(yamahata): injected_files isn't supported.
+        #                 Anyway OSAPI doesn't support stop/start yet
+        self._run_instance(context, instance_id)
+
+    def _shutdown_instance(self, context, instance_id, action_str):
+        """Shutdown an instance on this host."""
         context = context.elevated()
         instance_ref = self.db.instance_get(context, instance_id)
-        LOG.audit(_("Terminating instance %s"), instance_id, context=context)
+        LOG.audit(_("%(action_str)s instance %(instance_id)s") %
+                  {'action_str': action_str, 'instance_id': instance_id},
+                  context=context)
 
         fixed_ip = instance_ref.get('fixed_ip')
         if not FLAGS.stub_network and fixed_ip:
@@ -375,16 +387,34 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         volumes = instance_ref.get('volumes') or []
         for volume in volumes:
-            self.detach_volume(context, instance_id, volume['id'])
-        if instance_ref['state'] == power_state.SHUTOFF:
+            self._detach_volume(context, instance_id, volume['id'], False)
+
+        if (instance_ref['state'] == power_state.SHUTOFF and
+            instance_ref['state_description'] != 'stopped'):
             self.db.instance_destroy(context, instance_id)
             raise exception.Error(_('trying to destroy already destroyed'
                                     ' instance: %s') % instance_id)
         self.driver.destroy(instance_ref)
 
+        if action_str == 'Terminating':
+            terminate_volumes(self.db, context, instance_id)
+
+    @exception.wrap_exception
+    @checks_instance_lock
+    def terminate_instance(self, context, instance_id):
+        """Terminate an instance on this host."""
+        self._shutdown_instance(context, instance_id, 'Terminating')
+
         # TODO(ja): should we keep it in a terminated state for a bit?
         self.db.instance_destroy(context, instance_id)
 
+    @exception.wrap_exception
+    @checks_instance_lock
+    def stop_instance(self, context, instance_id):
+        """Stopping an instance on this host."""
+        self._shutdown_instance(context, instance_id, 'Stopping')
+        # instance state will be updated to stopped by _poll_istance_states()
+
     @exception.wrap_exception
     @checks_instance_lock
     def rebuild_instance(self, context, instance_id, image_id):
@@ -1250,11 +1280,15 @@ class ComputeManager(manager.SchedulerDependentManager):
                                "State=%(db_state)s, so setting state to "
                                "shutoff.") % locals())
                     vm_state = power_state.SHUTOFF
+                    if db_instance['state_description'] == 'stopping':
+                        self.db.instance_stop(context, db_instance['id'])
+                        continue
             else:
                 vm_state = vm_instance.state
                 vms_not_found_in_db.remove(name)
 
-            if db_instance['state_description'] == 'migrating':
+                
+            if (db_instance['state_description'] in ['migrating', 'stopping']):
                 # A situation which db record exists, but no instance"
                 # sometimes occurs while live-migration at src compute,
                 # this case should be ignored.
-- 
cgit 


From 4171160aa24d2e055da8b33c90c77c5b75c26fd9 Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Sun, 29 May 2011 22:45:58 +0900
Subject: boot-from-volume: some comments and NOTE(user name)

---
 nova/compute/api.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 455d6d3ba..a211bd4bb 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -258,6 +258,7 @@ class API(base.Base):
                                                     instance_id,
                                                     security_group_id)
 
+            # NOTE(yamahata)
             # tell vm driver to attach volume at boot time by updating
             # BlockDeviceMapping
             for bdm in block_device_mapping:
-- 
cgit 


From c7e8f9ff46758ddbeecd049083bece013301bb59 Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Wed, 15 Jun 2011 14:47:18 +0900
Subject: block_device_mapping: don't use [] as default argument

---
 nova/compute/api.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index a211bd4bb..3b3bea41b 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -150,12 +150,13 @@ class API(base.Base):
                availability_zone=None, user_data=None, metadata={},
                injected_files=None,
                admin_password=None,
-               block_device_mapping=[]):
+               block_device_mapping=None):
         """Create the number and type of instances requested.
 
         Verifies that quota and other arguments are valid.
 
         """
+        block_device_mapping = block_device_mapping or []
         if not instance_type:
             instance_type = instance_types.get_default_instance_type()
 
-- 
cgit 


From b0fdb4a2326f6e7c92bba80e6b80857ba2a61612 Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Wed, 15 Jun 2011 22:58:22 +0900
Subject: typo

---
 nova/compute/api.py     |  4 ++--
 nova/compute/manager.py | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 3b3bea41b..66edf9faa 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -445,7 +445,7 @@ class API(base.Base):
 
     @scheduler_api.reroute_compute("stop")
     def stop(self, context, instance_id):
-        """Stop an instnace."""
+        """Stop an instance."""
         LOG.debug(_("Going to try to stop %s"), instance_id)
 
         instance = self._get_instance(context, instance_id, 'stopping')
@@ -464,7 +464,7 @@ class API(base.Base):
                     instance_id, host)
 
     def start(self, context, instance_id):
-        """Start an instnace."""
+        """Start an instance."""
         LOG.debug(_("Going to try to start %s"), instance_id)
         instance = self._get_instance(context, instance_id, 'starting')
         if instance['state_description'] != 'stopped':
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 128144942..2e130110a 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -238,8 +238,8 @@ class ComputeManager(manager.SchedulerDependentManager):
                     # TODO(yamahata): default name and description
                     vol = volume_api.create(context, bdm['volume_size'],
                                             bdm['snapshot_id'], '', '')
-                    # TODO(yamahata): creatning volume simulteneously
-                    #                 reduce creation time?
+                    # TODO(yamahata): creating volume simultaneously
+                    #                 reduces creation time?
                     volume_api.wait_creation(context, vol['id'])
                     self.db.block_device_mapping_update(
                         context, bdm['id'], {'volume_id': vol['id']})
@@ -258,11 +258,11 @@ class ComputeManager(manager.SchedulerDependentManager):
                                                  'mount_device':
                                                  bdm['device_name']})
                 elif bdm['virtual_name'] is not None:
-                    # TODO(yamahata)
+                    # TODO(yamahata): ephemeral/swap device support
                     LOG.debug(_('block_device_mapping: '
                                 'ephemeral device is not supported yet'))
                 else:
-                    # TODO(yamahata)
+                    # TODO(yamahata): NoDevice support
                     assert bdm['no_device']
                     LOG.debug(_('block_device_mapping: '
                                 'no device is not supported yet'))
@@ -414,7 +414,7 @@ class ComputeManager(manager.SchedulerDependentManager):
     def stop_instance(self, context, instance_id):
         """Stopping an instance on this host."""
         self._shutdown_instance(context, instance_id, 'Stopping')
-        # instance state will be updated to stopped by _poll_istance_states()
+        # instance state will be updated to stopped by _poll_instance_states()
 
     @exception.wrap_exception
     @checks_instance_lock
@@ -887,7 +887,7 @@ class ComputeManager(manager.SchedulerDependentManager):
         return self.driver.get_vnc_console(instance_ref)
 
     def _attach_volume_boot(self, context, instance_id, volume_id, mountpoint):
-        """Attach a volume to an instnace at boot time. So actual attach
+        """Attach a volume to an instance at boot time. So actual attach
         is done by instance creation"""
 
         # TODO(yamahata):
-- 
cgit 


From f48f35183f6bc30c0e053ea9569f5348799ed451 Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Wed, 15 Jun 2011 23:11:03 +0900
Subject: pep8

---
 nova/compute/api.py     | 4 ++--
 nova/compute/manager.py | 1 -
 nova/compute/utils.py   | 1 +
 3 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 66edf9faa..40ad8cd9c 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -264,7 +264,7 @@ class API(base.Base):
             # BlockDeviceMapping
             for bdm in block_device_mapping:
                 LOG.debug(_('bdm %s'), bdm)
-                assert bdm.has_key('device_name')
+                assert 'device_name' in bdm
                 values = {
                     'instance_id': instance_id,
                     'device_name': bdm['device_name'],
@@ -451,7 +451,7 @@ class API(base.Base):
         instance = self._get_instance(context, instance_id, 'stopping')
         if not _is_able_to_shutdown(instance, instance_id):
             return
-        
+
         self.update(context,
                     instance['id'],
                     state_description='stopping',
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 2e130110a..62e5ce243 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -1300,7 +1300,6 @@ class ComputeManager(manager.SchedulerDependentManager):
                 vm_state = vm_instance.state
                 vms_not_found_in_db.remove(name)
 
-                
             if (db_instance['state_description'] in ['migrating', 'stopping']):
                 # A situation which db record exists, but no instance"
                 # sometimes occurs while live-migration at src compute,
diff --git a/nova/compute/utils.py b/nova/compute/utils.py
index f0a3ab59b..b99ef1357 100644
--- a/nova/compute/utils.py
+++ b/nova/compute/utils.py
@@ -18,6 +18,7 @@
 from nova import exception
 from nova import volume
 
+
 def terminate_volumes(db, context, instance_id):
     """delete volumes of delete_on_termination=True in block device mapping"""
     try:
-- 
cgit 


From a9800765f7eb8430c67d15953bed202752c2e199 Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Thu, 16 Jun 2011 00:32:03 +0900
Subject: db/block_device_mapping_get_all_by_instance: don't raise.

Make db.block_device_mapping_get_all_by_instance() not raise,
but returns empty list when no column found as all users catch notfound
exception and ignore it.
Thus ugly 'catch NotFound: pass' is eliminated.
---
 nova/compute/manager.py | 79 +++++++++++++++++++++++--------------------------
 nova/compute/utils.py   | 20 +++++--------
 2 files changed, 44 insertions(+), 55 deletions(-)

(limited to 'nova/compute')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 62e5ce243..7f7f0fa65 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -223,49 +223,44 @@ class ComputeManager(manager.SchedulerDependentManager):
                                    power_state.NOSTATE,
                                    'block_device_mapping')
 
+        volume_api = volume.API()
         block_device_mapping = []
-        try:
-            bdms = self.db.block_device_mapping_get_all_by_instance(
-                context, instance_id)
-        except exception.NotFound:
-            pass
-        else:
-            volume_api = volume.API()
-            for bdm in bdms:
-                LOG.debug(_("setting up bdm %s"), bdm)
-                if ((bdm['snapshot_id'] is not None) and
-                    (bdm['volume_id'] is None)):
-                    # TODO(yamahata): default name and description
-                    vol = volume_api.create(context, bdm['volume_size'],
-                                            bdm['snapshot_id'], '', '')
-                    # TODO(yamahata): creating volume simultaneously
-                    #                 reduces creation time?
-                    volume_api.wait_creation(context, vol['id'])
-                    self.db.block_device_mapping_update(
-                        context, bdm['id'], {'volume_id': vol['id']})
-                    bdm['volume_id'] = vol['id']
-
-                assert ((bdm['snapshot_id'] is None) or
-                        (bdm['volume_id'] is not None))
-
-                if bdm['volume_id'] is not None:
-                    volume_api.check_attach(context,
-                                            volume_id=bdm['volume_id'])
-                    dev_path = self._attach_volume_boot(context, instance_id,
-                                                        bdm['volume_id'],
-                                                        bdm['device_name'])
-                    block_device_mapping.append({'device_path': dev_path,
-                                                 'mount_device':
-                                                 bdm['device_name']})
-                elif bdm['virtual_name'] is not None:
-                    # TODO(yamahata): ephemeral/swap device support
-                    LOG.debug(_('block_device_mapping: '
-                                'ephemeral device is not supported yet'))
-                else:
-                    # TODO(yamahata): NoDevice support
-                    assert bdm['no_device']
-                    LOG.debug(_('block_device_mapping: '
-                                'no device is not supported yet'))
+        for bdm in self.db.block_device_mapping_get_all_by_instance(
+            context, instance_id):
+            LOG.debug(_("setting up bdm %s"), bdm)
+            if ((bdm['snapshot_id'] is not None) and
+                (bdm['volume_id'] is None)):
+                # TODO(yamahata): default name and description
+                vol = volume_api.create(context, bdm['volume_size'],
+                                        bdm['snapshot_id'], '', '')
+                # TODO(yamahata): creating volume simultaneously
+                #                 reduces creation time?
+                volume_api.wait_creation(context, vol['id'])
+                self.db.block_device_mapping_update(
+                    context, bdm['id'], {'volume_id': vol['id']})
+                bdm['volume_id'] = vol['id']
+
+            assert ((bdm['snapshot_id'] is None) or
+                    (bdm['volume_id'] is not None))
+
+            if bdm['volume_id'] is not None:
+                volume_api.check_attach(context,
+                                        volume_id=bdm['volume_id'])
+                dev_path = self._attach_volume_boot(context, instance_id,
+                                                    bdm['volume_id'],
+                                                    bdm['device_name'])
+                block_device_mapping.append({'device_path': dev_path,
+                                             'mount_device':
+                                             bdm['device_name']})
+            elif bdm['virtual_name'] is not None:
+                # TODO(yamahata): ephemeral/swap device support
+                LOG.debug(_('block_device_mapping: '
+                            'ephemeral device is not supported yet'))
+            else:
+                # TODO(yamahata): NoDevice support
+                assert bdm['no_device']
+                LOG.debug(_('block_device_mapping: '
+                            'no device is not supported yet'))
 
         return block_device_mapping
 
diff --git a/nova/compute/utils.py b/nova/compute/utils.py
index b99ef1357..c8cb9bab8 100644
--- a/nova/compute/utils.py
+++ b/nova/compute/utils.py
@@ -15,21 +15,15 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from nova import exception
 from nova import volume
 
 
 def terminate_volumes(db, context, instance_id):
     """delete volumes of delete_on_termination=True in block device mapping"""
-    try:
-        bdms = db.block_device_mapping_get_all_by_instance(
-            context, instance_id)
-    except exception.NotFound:
-        pass
-    else:
-        volume_api = volume.API()
-        for bdm in bdms:
-            #LOG.debug(_("terminating bdm %s") % bdm)
-            if bdm['volume_id'] and bdm['delete_on_termination']:
-                volume_api.delete(context, bdm['volume_id'])
-            db.block_device_mapping_destroy(context, bdm['id'])
+    volume_api = volume.API()
+    for bdm in db.block_device_mapping_get_all_by_instance(context,
+                                                           instance_id):
+        #LOG.debug(_("terminating bdm %s") % bdm)
+        if bdm['volume_id'] and bdm['delete_on_termination']:
+            volume_api.delete(context, bdm['volume_id'])
+        db.block_device_mapping_destroy(context, bdm['id'])
-- 
cgit 


From 31ae0515fbf2dd8f931fb53ef08b40fe0206fc92 Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Thu, 16 Jun 2011 00:48:25 +0900
Subject: _setup_block_device_mapping: raise ApiError when db inconsistency
 found

Instead of assert, log it and raise ApiError if db inconsistency in
block_device_mapping table is found.
---
 nova/compute/manager.py | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

(limited to 'nova/compute')

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 7f7f0fa65..1c5d2c858 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -240,8 +240,16 @@ class ComputeManager(manager.SchedulerDependentManager):
                     context, bdm['id'], {'volume_id': vol['id']})
                 bdm['volume_id'] = vol['id']
 
-            assert ((bdm['snapshot_id'] is None) or
-                    (bdm['volume_id'] is not None))
+            if not ((bdm['snapshot_id'] is None) or
+                    (bdm['volume_id'] is not None)):
+                LOG.error(_('corrupted state of block device mapping '
+                            'id: %(id)s '
+                            'snapshot: %(snapshot_id) volume: %(vollume_id)') %
+                          {'id': bdm['id'],
+                           'snapshot_id': bdm['snapshot'],
+                           'volume_id': bdm['volume_id']})
+                raise exception.ApiError(_('broken block device mapping %d') %
+                                         bdm['id'])
 
             if bdm['volume_id'] is not None:
                 volume_api.check_attach(context,
-- 
cgit 


From ab7c45a9be39def2d6cbb74084abc6fa42f593dd Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Thu, 16 Jun 2011 02:10:28 +0900
Subject: fix mismerge.

---
 nova/compute/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 6f7192ae7..18363ace0 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -553,7 +553,7 @@ class API(base.Base):
                     instance['id'],
                     state_description='stopping',
                     state=power_state.NOSTATE,
-                    terminated_at=datetime.datetime.utcnow())
+                    terminated_at=utils.utcnow())
 
         host = instance['host']
         if host:
-- 
cgit 


From 81dd4f2b4ff6cbdc596b878946a6ee00c31a2599 Mon Sep 17 00:00:00 2001
From: Kevin Bringard <kbringard@attinteractive.com>
Date: Fri, 17 Jun 2011 09:25:23 -0600
Subject: Added context = context.elevated() to get_all_across_zones

---
 nova/compute/api.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index e2c4cf8d7..f1c31a092 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -526,6 +526,7 @@ class API(base.Base):
         """Get all instances with this reservation_id, across
         all available Zones (if any).
         """
+        context = context.elevated()
         instances = self.db.instance_get_all_by_reservation(
                                     context, reservation_id)
 
-- 
cgit 


From 74be8d2791a5579725fa07c8403545ede3354b2e Mon Sep 17 00:00:00 2001
From: Isaku Yamahata <yamahata@valinux.co.jp>
Date: Sat, 18 Jun 2011 08:34:20 +0900
Subject: pep8: white space/blank lines

---
 nova/compute/api.py | 2 --
 1 file changed, 2 deletions(-)

(limited to 'nova/compute')

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 18363ace0..979a29de6 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -298,8 +298,6 @@ class API(base.Base):
 
         return instance
 
-
-
     def _ask_scheduler_to_create_instance(self, context, base_options,
                                           instance_type, zone_blob,
                                           availability_zone, injected_files,
-- 
cgit