Merged with trunk

2 files changed, 167 insertions, 66 deletions

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 4f91b60b0..410a48613 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -19,9 +19,11 @@
 """Handles all requests relating to instances (guest vms)."""
 
 import eventlet
+import novaclient
 import re
 import time
 
+from nova import block_device
 from nova import db
 from nova import exception
 from nova import flags
@@ -32,7 +34,6 @@ from nova import quota
 from nova import rpc
 from nova import utils
 from nova import volume
-from nova.api.ec2 import ec2utils
 from nova.compute import instance_types
 from nova.compute import power_state
 from nova.compute.utils import terminate_volumes
@@ -229,7 +230,7 @@ class API(base.Base):
         if reservation_id is None:
             reservation_id = utils.generate_uid('r')
 
-        root_device_name = ec2utils.properties_root_device_name(
+        root_device_name = block_device.properties_root_device_name(
             image['properties'])
 
         base_options = {
@@ -261,34 +262,64 @@ class API(base.Base):
 
         return (num_instances, base_options, image)
 
-    def _update_image_block_device_mapping(self, elevated_context, instance_id,
+    @staticmethod
+    def _ephemeral_size(instance_type, ephemeral_name):
+        num = block_device.ephemeral_num(ephemeral_name)
+
+        # TODO(yamahata): ephemeralN where N > 0
+        # Only ephemeral0 is allowed for now because InstanceTypes
+        # table only allows single local disk, local_gb.
+        # In order to enhance it, we need to add a new columns to
+        # instance_types table.
+        if num > 0:
+            return 0
+
+        return instance_type.get('local_gb')
+
+    def _update_image_block_device_mapping(self, elevated_context,
+                                           instance_type, instance_id,
                                            mappings):
         """tell vm driver to create ephemeral/swap device at boot time by
         updating BlockDeviceMapping
         """
-        for bdm in ec2utils.mappings_prepend_dev(mappings):
+        instance_type = (instance_type or
+                         instance_types.get_default_instance_type())
+
+        for bdm in block_device.mappings_prepend_dev(mappings):
             LOG.debug(_("bdm %s"), bdm)
 
             virtual_name = bdm['virtual']
             if virtual_name == 'ami' or virtual_name == 'root':
                 continue
 
-            assert (virtual_name == 'swap' or
-                    virtual_name.startswith('ephemeral'))
+            if not block_device.is_swap_or_ephemeral(virtual_name):
+                continue
+
+            size = 0
+            if virtual_name == 'swap':
+                size = instance_type.get('swap', 0)
+            elif block_device.is_ephemeral(virtual_name):
+                size = self._ephemeral_size(instance_type, virtual_name)
+
+            if size == 0:
+                continue
+
             values = {
                 'instance_id': instance_id,
                 'device_name': bdm['device'],
-                'virtual_name': virtual_name, }
+                'virtual_name': virtual_name,
+                'volume_size': size}
             self.db.block_device_mapping_update_or_create(elevated_context,
                                                           values)
 
-    def _update_block_device_mapping(self, elevated_context, instance_id,
+    def _update_block_device_mapping(self, elevated_context,
+                                     instance_type, instance_id,
                                      block_device_mapping):
         """tell vm driver to attach volume at boot time by updating
         BlockDeviceMapping
         """
+        LOG.debug(_("block_device_mapping %s"), block_device_mapping)
         for bdm in block_device_mapping:
-            LOG.debug(_('bdm %s'), bdm)
             assert 'device_name' in bdm
 
             values = {'instance_id': instance_id}
@@ -297,10 +328,18 @@ class API(base.Base):
                         'no_device'):
                 values[key] = bdm.get(key)
 
+            virtual_name = bdm.get('virtual_name')
+            if (virtual_name is not None and
+                block_device.is_ephemeral(virtual_name)):
+                size = self._ephemeral_size(instance_type, virtual_name)
+                if size == 0:
+                    continue
+                values['volume_size'] = size
+
             # NOTE(yamahata): NoDevice eliminates devices defined in image
             #                 files by command line option.
             #                 (--block-device-mapping)
-            if bdm.get('virtual_name') == 'NoDevice':
+            if virtual_name == 'NoDevice':
                 values['no_device'] = True
                 for k in ('delete_on_termination', 'volume_id',
                           'snapshot_id', 'volume_id', 'volume_size',
@@ -310,8 +349,8 @@ class API(base.Base):
             self.db.block_device_mapping_update_or_create(elevated_context,
                                                           values)
 
-    def create_db_entry_for_new_instance(self, context, image, base_options,
-             security_group, block_device_mapping, num=1):
+    def create_db_entry_for_new_instance(self, context, instance_type, image,
+            base_options, security_group, block_device_mapping, num=1):
         """Create an entry in the DB for this new instance,
         including any related table updates (such as security group,
         etc).
@@ -344,12 +383,12 @@ class API(base.Base):
                                                 security_group_id)
 
         # BlockDeviceMapping table
-        self._update_image_block_device_mapping(elevated, instance_id,
-            image['properties'].get('mappings', []))
-        self._update_block_device_mapping(elevated, instance_id,
+        self._update_image_block_device_mapping(elevated, instance_type,
+            instance_id, image['properties'].get('mappings', []))
+        self._update_block_device_mapping(elevated, instance_type, instance_id,
             image['properties'].get('block_device_mapping', []))
         # override via command line option
-        self._update_block_device_mapping(elevated, instance_id,
+        self._update_block_device_mapping(elevated, instance_type, instance_id,
                                           block_device_mapping)
 
         # Set sane defaults if not specified
@@ -470,7 +509,8 @@ class API(base.Base):
         instances = []
         LOG.debug(_("Going to run %s instances..."), num_instances)
         for num in range(num_instances):
-            instance = self.create_db_entry_for_new_instance(context, image,
+            instance = self.create_db_entry_for_new_instance(context,
+                                    instance_type, image,
                                     base_options, security_group,
                                     block_device_mapping, num=num)
             instances.append(instance)
@@ -687,59 +727,84 @@ class API(base.Base):
         """
         return self.get(context, instance_id)
 
-    def get_all(self, context, project_id=None, reservation_id=None,
-                fixed_ip=None, recurse_zones=False):
+    def get_all(self, context, search_opts=None):
         """Get all instances filtered by one of the given parameters.
 
         If there is no filter and the context is an admin, it will retreive
         all instances in the system.
         """
 
-        if reservation_id is not None:
-            recurse_zones = True
-            instances = self.db.instance_get_all_by_reservation(
-                                    context, reservation_id)
-        elif fixed_ip is not None:
+        if search_opts is None:
+            search_opts = {}
+
+        LOG.debug(_("Searching by: %s") % str(search_opts))
+
+        # Fixups for the DB call
+        filters = {}
+
+        def _remap_flavor_filter(flavor_id):
+            instance_type = self.db.instance_type_get_by_flavor_id(
+                    context, flavor_id)
+            filters['instance_type_id'] = instance_type['id']
+
+        def _remap_fixed_ip_filter(fixed_ip):
+            # Turn fixed_ip into a regexp match. Since '.' matches
+            # any character, we need to use regexp escaping for it.
+            filters['ip'] = '^%s$' % fixed_ip.replace('.', '\\.')
+
+        # search_option to filter_name mapping.
+        filter_mapping = {
+                'image': 'image_ref',
+                'name': 'display_name',
+                'instance_name': 'name',
+                'recurse_zones': None,
+                'flavor': _remap_flavor_filter,
+                'fixed_ip': _remap_fixed_ip_filter}
+
+        # copy from search_opts, doing various remappings as necessary
+        for opt, value in search_opts.iteritems():
+            # Do remappings.
+            # Values not in the filter_mapping table are copied as-is.
+            # If remapping is None, option is not copied
+            # If the remapping is a string, it is the filter_name to use
             try:
-                instances = self.db.fixed_ip_get_instance(context, fixed_ip)
-            except exception.FloatingIpNotFound, e:
-                if not recurse_zones:
-                    raise
-                instances = None
-        elif project_id or not context.is_admin:
-            if not context.project_id:
-                instances = self.db.instance_get_all_by_user(
-                    context, context.user_id)
+                remap_object = filter_mapping[opt]
+            except KeyError:
+                filters[opt] = value
             else:
-                if project_id is None:
-                    project_id = context.project_id
-                instances = self.db.instance_get_all_by_project(
-                    context, project_id)
-        else:
-            instances = self.db.instance_get_all(context)
+                if remap_object:
+                    if isinstance(remap_object, basestring):
+                        filters[remap_object] = value
+                    else:
+                        remap_object(value)
+
+        recurse_zones = search_opts.get('recurse_zones', False)
+        if 'reservation_id' in filters:
+            recurse_zones = True
 
-        if instances is None:
-            instances = []
-        elif not isinstance(instances, list):
-            instances = [instances]
+        instances = self.db.instance_get_all_by_filters(context, filters)
 
         if not recurse_zones:
             return instances
 
+        # Recurse zones.  Need admin context for this.  Send along
+        # the un-modified search options we received..
         admin_context = context.elevated()
         children = scheduler_api.call_zone_method(admin_context,
                 "list",
+                errors_to_ignore=[novaclient.exceptions.NotFound],
                 novaclient_collection_name="servers",
-                reservation_id=reservation_id,
-                project_id=project_id,
-                fixed_ip=fixed_ip,
-                recurse_zones=True)
+                search_opts=search_opts)
 
         for zone, servers in children:
+            # 'servers' can be None if a 404 was returned by a zone
+            if servers is None:
+                continue
             for server in servers:
                 # Results are ready to send to user. No need to scrub.
                 server._info['_is_precooked'] = True
                 instances.append(server._info)
+
         return instances
 
     def _cast_compute_message(self, method, context, instance_id, host=None,
@@ -1011,7 +1076,12 @@ class API(base.Base):
     def set_host_enabled(self, context, host, enabled):
         """Sets the specified host's ability to accept new instances."""
         return self._call_compute_message("set_host_enabled", context,
-                instance_id=None, host=host, params={"enabled": enabled})
+                host=host, params={"enabled": enabled})
+
+    def host_power_action(self, context, host, action):
+        """Reboots, shuts down or powers up the host."""
+        return self._call_compute_message("host_power_action", context,
+                host=host, params={"action": action})
 
     @scheduler_api.reroute_compute("diagnostics")
     def get_diagnostics(self, context, instance_id):
@@ -1184,11 +1254,20 @@ class API(base.Base):
         """Delete the given metadata item from an instance."""
         self.db.instance_metadata_delete(context, instance_id, key)
 
-    def update_or_create_instance_metadata(self, context, instance_id,
-                                            metadata):
-        """Updates or creates instance metadata."""
-        combined_metadata = self.get_instance_metadata(context, instance_id)
-        combined_metadata.update(metadata)
-        self._check_metadata_properties_quota(context, combined_metadata)
-        self.db.instance_metadata_update_or_create(context, instance_id,
-                                                    metadata)
+    def update_instance_metadata(self, context, instance_id,
+                                 metadata, delete=False):
+        """Updates or creates instance metadata.
+
+        If delete is True, metadata items that are not specified in the
+        `metadata` argument will be deleted.
+
+        """
+        if delete:
+            _metadata = metadata
+        else:
+            _metadata = self.get_instance_metadata(context, instance_id)
+            _metadata.update(metadata)
+
+        self._check_metadata_properties_quota(context, _metadata)
+        self.db.instance_metadata_update(context, instance_id, _metadata, True)
+        return _metadata
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 41de1657e..c8a328325 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -45,6 +45,7 @@ import functools
 from eventlet import greenthread
 
 import nova.context
+from nova import block_device
 from nova import exception
 from nova import flags
 import nova.image
@@ -260,6 +261,8 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         volume_api = volume.API()
         block_device_mapping = []
+        swap = None
+        ephemerals = []
         for bdm in self.db.block_device_mapping_get_all_by_instance(
             context, instance_id):
             LOG.debug(_("setting up bdm %s"), bdm)
@@ -267,11 +270,18 @@ class ComputeManager(manager.SchedulerDependentManager):
             if bdm['no_device']:
                 continue
             if bdm['virtual_name']:
-                # TODO(yamahata):
-                # block devices for swap and ephemeralN will be
-                # created by virt driver locally in compute node.
-                assert (bdm['virtual_name'] == 'swap' or
-                        bdm['virtual_name'].startswith('ephemeral'))
+                virtual_name = bdm['virtual_name']
+                device_name = bdm['device_name']
+                assert block_device.is_swap_or_ephemeral(virtual_name)
+                if virtual_name == 'swap':
+                    swap = {'device_name': device_name,
+                            'swap_size': bdm['volume_size']}
+                elif block_device.is_ephemeral(virtual_name):
+                    eph = {'num': block_device.ephemeral_num(virtual_name),
+                           'virtual_name': virtual_name,
+                           'device_name': device_name,
+                           'size': bdm['volume_size']}
+                    ephemerals.append(eph)
                 continue
 
             if ((bdm['snapshot_id'] is not None) and
@@ -307,7 +317,7 @@ class ComputeManager(manager.SchedulerDependentManager):
                                              'mount_device':
                                              bdm['device_name']})
 
-        return block_device_mapping
+        return (swap, ephemerals, block_device_mapping)
 
     def _run_instance(self, context, instance_id, **kwargs):
         """Launch a new instance with specified options."""
@@ -350,13 +360,21 @@ class ComputeManager(manager.SchedulerDependentManager):
                 # all vif creation and network injection, maybe this is correct
                 network_info = []
 
-            bd_mapping = self._setup_block_device_mapping(context, instance_id)
+            (swap, ephemerals,
+             block_device_mapping) = self._setup_block_device_mapping(
+                context, instance_id)
+            block_device_info = {
+                'root_device_name': instance['root_device_name'],
+                'swap': swap,
+                'ephemerals': ephemerals,
+                'block_device_mapping': block_device_mapping}
 
             # TODO(vish) check to make sure the availability zone matches
             self._update_state(context, instance_id, power_state.BUILDING)
 
             try:
-                self.driver.spawn(context, instance, network_info, bd_mapping)
+                self.driver.spawn(context, instance,
+                                  network_info, block_device_info)
             except Exception as ex:  # pylint: disable=W0702
                 msg = _("Instance '%(instance_id)s' failed to spawn. Is "
                         "virtualization enabled in the BIOS? Details: "
@@ -960,8 +978,12 @@ class ComputeManager(manager.SchedulerDependentManager):
                                                        result))
 
     @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
-    def set_host_enabled(self, context, instance_id=None, host=None,
-            enabled=None):
+    def host_power_action(self, context, host=None, action=None):
+        """Reboots, shuts down or powers up the host."""
+        return self.driver.host_power_action(host, action)
+
+    @exception.wrap_exception(notifier=notifier, publisher_id=publisher_id())
+    def set_host_enabled(self, context, host=None, enabled=None):
         """Sets the specified host's ability to accept new instances."""
         return self.driver.set_host_enabled(host, enabled)