Remove instance_mapping_uuid_patch
Because of the change in mapping relationship between cascading and cascaded, the instance_mapping_uuid_patch is no need exists. Change-Id: I72606bb8f1d7238a53e0e5caae0671fa4ed105fa
This commit is contained in:
parent
2005d39ccf
commit
4aaef726dc
|
@ -1,63 +0,0 @@
|
|||
Nova instance mapping_uuid patch
|
||||
===============================
|
||||
add instance mapping_uuid attribute patch,it will be patched in cascading level's control node
|
||||
|
||||
How can we manage the servers in cascading level? To solve this problem,nova proxy must can get relation of cascading and cascaded server.So we can do this through adding instance attribute mapping_uuid
|
||||
|
||||
Key modules
|
||||
-----------
|
||||
|
||||
* adding mapping_uuid column in nova instance table,when nova synchronizes db:
|
||||
|
||||
nova\db\sqlalchemy\migrate_repo\versions\234_add_mapping_uuid_column_to_instance.py
|
||||
nova\db\sqlalchemy\models.py
|
||||
nova-2014.1\nova\objects\instance.py
|
||||
nova\network\neutronv2\api.py
|
||||
|
||||
* allowing nova proxy update instance mapping_uuid through conductor
|
||||
nova\conductor\manager.py
|
||||
|
||||
Requirements
|
||||
------------
|
||||
* openstack of juno-version has been installed
|
||||
|
||||
Installation
|
||||
------------
|
||||
|
||||
We provide two ways to install the instance_mapping_uuid patch code. In this section, we will guide you through installing the instance_mapping_uuid patch.
|
||||
|
||||
* **Note:**
|
||||
|
||||
- Make sure you have an existing installation of **Openstack Juno**.
|
||||
- We recommend that you Do backup at least the following files before installation, because they are to be overwritten or modified:
|
||||
|
||||
* **Manual Installation**
|
||||
|
||||
- Make sure you have performed backups properly.
|
||||
|
||||
- Navigate to the local repository and copy the contents in 'nova' sub-directory to the corresponding places in existing nova, e.g.
|
||||
```cp -r $LOCAL_REPOSITORY_DIR/nova $NOVA_PARENT_DIR```
|
||||
(replace the $... with actual directory name.)
|
||||
|
||||
- synchronize the nova db.
|
||||
```
|
||||
mysql -u root -p$MYSQL_PASS -e "DROP DATABASE if exists nova;
|
||||
CREATE DATABASE nova;
|
||||
GRANT ALL PRIVILEGES ON nova.* TO 'nova'@'%' IDENTIFIED BY '$NOVA_PASSWORD';
|
||||
GRANT ALL PRIVILEGES ON *.* TO 'nova'@'%'IDENTIFIED BY '$NOVA_PASSWORD';
|
||||
nova-manage db sync
|
||||
```
|
||||
|
||||
- Done. The nova proxy should be working with a demo configuration.
|
||||
|
||||
* **Automatic Installation**
|
||||
|
||||
- Make sure you have performed backups properly.
|
||||
|
||||
- Navigate to the installation directory and run installation script.
|
||||
```
|
||||
cd $LOCAL_REPOSITORY_DIR/installation
|
||||
sudo bash ./install.sh
|
||||
```
|
||||
(replace the $... with actual directory name.)
|
||||
|
|
@ -1,91 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
# 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.
|
||||
# Copyright (c) 2014 Huawei Technologies.
|
||||
|
||||
_MYSQL_PASS="1234"
|
||||
_NOVA_INSTALL="/usr/lib64/python2.6/site-packages"
|
||||
_NOVA_DIR="${_NOVA_INSTALL}/nova"
|
||||
# if you did not make changes to the installation files,
|
||||
# please do not edit the following directories.
|
||||
_CODE_DIR="../nova"
|
||||
_BACKUP_DIR="${_NOVA_INSTALL}/.instance_mapping_uuid_patch-installation-backup"
|
||||
|
||||
_SCRIPT_LOGFILE="/var/log/instance_mapping_uuid_patch/installation/install.log"
|
||||
|
||||
function log()
|
||||
{
|
||||
log_path=`dirname ${_SCRIPT_LOGFILE}`
|
||||
if [ ! -d $log_path ] ; then
|
||||
mkdir -p $log_path
|
||||
fi
|
||||
echo "$@"
|
||||
echo "`date -u +'%Y-%m-%d %T.%N'`: $@" >> $_SCRIPT_LOGFILE
|
||||
}
|
||||
|
||||
if [[ ${EUID} -ne 0 ]]; then
|
||||
log "Please run as root."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
|
||||
cd `dirname $0`
|
||||
|
||||
log "checking installation directories..."
|
||||
if [ ! -d "${_NOVA_DIR}" ] ; then
|
||||
log "Could not find the nova installation. Please check the variables in the beginning of the script."
|
||||
log "aborted."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log "checking previous installation..."
|
||||
if [ -d "${_BACKUP_DIR}/nova" ] ; then
|
||||
log "It seems nova-proxy has already been installed!"
|
||||
log "Please check README for solution if this is not true."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log "backing up current files that might be overwritten..."
|
||||
cp -r "${_NOVA_DIR}/" "${_BACKUP_DIR}/"
|
||||
if [ $? -ne 0 ] ; then
|
||||
rm -r "${_BACKUP_DIR}/nova"
|
||||
echo "Error in code backup, aborted."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log "copying in new files..."
|
||||
cp -r "${_CODE_DIR}" `dirname ${_NOVA_DIR}`
|
||||
if [ $? -ne 0 ] ; then
|
||||
log "Error in copying, aborted."
|
||||
log "Recovering original files..."
|
||||
cp -r "${_BACKUP_DIR}/nova" `dirname ${_NOVA_DIR}` && rm -r "${_BACKUP_DIR}/nova"
|
||||
if [ $? -ne 0 ] ; then
|
||||
log "Recovering failed! Please install manually."
|
||||
fi
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log "syc nova db..."
|
||||
mysql -u root -p$_MYSQL_PASS -e "DROP DATABASE if exists nova;CREATE DATABASE nova;GRANT ALL PRIVILEGES ON nova.* TO 'nova'@'%' IDENTIFIED BY 'Galax8800';GRANT ALL PRIVILEGES ON *.* TO 'nova'@'%'IDENTIFIED BY 'Galax8800';"
|
||||
|
||||
nova-manage db sync
|
||||
|
||||
if [ $? -ne 0 ] ; then
|
||||
log "There was an error in restarting the service, please restart nova scheduler manually."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
log "Completed."
|
||||
log "See README to get started."
|
||||
exit 0
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
# 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.
|
||||
# Copyright (c) 2014 Huawei Technologies.
|
||||
|
||||
|
||||
# The uninstallation script don't had been realization,
|
||||
# it will be supplied if needed.
|
||||
exit 1
|
|
@ -1,759 +0,0 @@
|
|||
# Copyright 2013 IBM Corp.
|
||||
#
|
||||
# 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.
|
||||
|
||||
"""Handles database requests from other nova services."""
|
||||
|
||||
import copy
|
||||
import itertools
|
||||
|
||||
from oslo import messaging
|
||||
import six
|
||||
|
||||
from nova.api.ec2 import ec2utils
|
||||
from nova import block_device
|
||||
from nova.cells import rpcapi as cells_rpcapi
|
||||
from nova.compute import api as compute_api
|
||||
from nova.compute import rpcapi as compute_rpcapi
|
||||
from nova.compute import task_states
|
||||
from nova.compute import utils as compute_utils
|
||||
from nova.compute import vm_states
|
||||
from nova.conductor.tasks import live_migrate
|
||||
from nova.db import base
|
||||
from nova import exception
|
||||
from nova.i18n import _
|
||||
from nova import image
|
||||
from nova import manager
|
||||
from nova import network
|
||||
from nova.network.security_group import openstack_driver
|
||||
from nova import notifications
|
||||
from nova import objects
|
||||
from nova.objects import base as nova_object
|
||||
from nova.openstack.common import excutils
|
||||
from nova.openstack.common import jsonutils
|
||||
from nova.openstack.common import log as logging
|
||||
from nova.openstack.common import timeutils
|
||||
from nova import quota
|
||||
from nova.scheduler import client as scheduler_client
|
||||
from nova.scheduler import driver as scheduler_driver
|
||||
from nova.scheduler import utils as scheduler_utils
|
||||
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
# Instead of having a huge list of arguments to instance_update(), we just
|
||||
# accept a dict of fields to update and use this whitelist to validate it.
|
||||
allowed_updates = ['task_state', 'vm_state', 'expected_task_state',
|
||||
'power_state', 'access_ip_v4', 'access_ip_v6',
|
||||
'launched_at', 'terminated_at', 'host', 'node',
|
||||
'memory_mb', 'vcpus', 'root_gb', 'ephemeral_gb',
|
||||
'instance_type_id', 'root_device_name', 'launched_on',
|
||||
'progress', 'vm_mode', 'default_ephemeral_device',
|
||||
'default_swap_device', 'root_device_name',
|
||||
'system_metadata', 'updated_at', 'mapping_uuid'
|
||||
]
|
||||
|
||||
# Fields that we want to convert back into a datetime object.
|
||||
datetime_fields = ['launched_at', 'terminated_at', 'updated_at']
|
||||
|
||||
|
||||
class ConductorManager(manager.Manager):
|
||||
"""Mission: Conduct things.
|
||||
|
||||
The methods in the base API for nova-conductor are various proxy operations
|
||||
performed on behalf of the nova-compute service running on compute nodes.
|
||||
Compute nodes are not allowed to directly access the database, so this set
|
||||
of methods allows them to get specific work done without locally accessing
|
||||
the database.
|
||||
|
||||
The nova-conductor service also exposes an API in the 'compute_task'
|
||||
namespace. See the ComputeTaskManager class for details.
|
||||
"""
|
||||
|
||||
target = messaging.Target(version='2.0')
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
super(ConductorManager, self).__init__(service_name='conductor',
|
||||
*args, **kwargs)
|
||||
self.security_group_api = (
|
||||
openstack_driver.get_openstack_security_group_driver())
|
||||
self._network_api = None
|
||||
self._compute_api = None
|
||||
self.compute_task_mgr = ComputeTaskManager()
|
||||
self.cells_rpcapi = cells_rpcapi.CellsAPI()
|
||||
self.additional_endpoints.append(self.compute_task_mgr)
|
||||
|
||||
@property
|
||||
def network_api(self):
|
||||
# NOTE(danms): We need to instantiate our network_api on first use
|
||||
# to avoid the circular dependency that exists between our init
|
||||
# and network_api's
|
||||
if self._network_api is None:
|
||||
self._network_api = network.API()
|
||||
return self._network_api
|
||||
|
||||
@property
|
||||
def compute_api(self):
|
||||
if self._compute_api is None:
|
||||
self._compute_api = compute_api.API()
|
||||
return self._compute_api
|
||||
|
||||
def ping(self, context, arg):
|
||||
# NOTE(russellb) This method can be removed in 2.0 of this API. It is
|
||||
# now a part of the base rpc API.
|
||||
return jsonutils.to_primitive({'service': 'conductor', 'arg': arg})
|
||||
|
||||
@messaging.expected_exceptions(KeyError, ValueError,
|
||||
exception.InvalidUUID,
|
||||
exception.InstanceNotFound,
|
||||
exception.UnexpectedTaskStateError)
|
||||
def instance_update(self, context, instance_uuid,
|
||||
updates, service):
|
||||
for key, value in updates.iteritems():
|
||||
if key not in allowed_updates:
|
||||
LOG.error(_("Instance update attempted for "
|
||||
"'%(key)s' on %(instance_uuid)s"),
|
||||
{'key': key, 'instance_uuid': instance_uuid})
|
||||
raise KeyError("unexpected update keyword '%s'" % key)
|
||||
if key in datetime_fields and isinstance(value, six.string_types):
|
||||
updates[key] = timeutils.parse_strtime(value)
|
||||
|
||||
old_ref, instance_ref = self.db.instance_update_and_get_original(
|
||||
context, instance_uuid, updates)
|
||||
notifications.send_update(context, old_ref, instance_ref, service)
|
||||
return jsonutils.to_primitive(instance_ref)
|
||||
|
||||
@messaging.expected_exceptions(exception.InstanceNotFound)
|
||||
def instance_get_by_uuid(self, context, instance_uuid,
|
||||
columns_to_join):
|
||||
return jsonutils.to_primitive(
|
||||
self.db.instance_get_by_uuid(context, instance_uuid,
|
||||
columns_to_join))
|
||||
|
||||
def instance_get_all_by_host(self, context, host, node,
|
||||
columns_to_join):
|
||||
if node is not None:
|
||||
result = self.db.instance_get_all_by_host_and_node(
|
||||
context.elevated(), host, node)
|
||||
else:
|
||||
result = self.db.instance_get_all_by_host(context.elevated(), host,
|
||||
columns_to_join)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def migration_get_in_progress_by_host_and_node(self, context,
|
||||
host, node):
|
||||
migrations = self.db.migration_get_in_progress_by_host_and_node(
|
||||
context, host, node)
|
||||
return jsonutils.to_primitive(migrations)
|
||||
|
||||
@messaging.expected_exceptions(exception.AggregateHostExists)
|
||||
def aggregate_host_add(self, context, aggregate, host):
|
||||
host_ref = self.db.aggregate_host_add(context.elevated(),
|
||||
aggregate['id'], host)
|
||||
|
||||
return jsonutils.to_primitive(host_ref)
|
||||
|
||||
@messaging.expected_exceptions(exception.AggregateHostNotFound)
|
||||
def aggregate_host_delete(self, context, aggregate, host):
|
||||
self.db.aggregate_host_delete(context.elevated(),
|
||||
aggregate['id'], host)
|
||||
|
||||
def aggregate_metadata_get_by_host(self, context, host,
|
||||
key='availability_zone'):
|
||||
result = self.db.aggregate_metadata_get_by_host(context, host, key)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def bw_usage_update(self, context, uuid, mac, start_period,
|
||||
bw_in, bw_out, last_ctr_in, last_ctr_out,
|
||||
last_refreshed, update_cells):
|
||||
if [bw_in, bw_out, last_ctr_in, last_ctr_out].count(None) != 4:
|
||||
self.db.bw_usage_update(context, uuid, mac, start_period,
|
||||
bw_in, bw_out, last_ctr_in, last_ctr_out,
|
||||
last_refreshed,
|
||||
update_cells=update_cells)
|
||||
usage = self.db.bw_usage_get(context, uuid, start_period, mac)
|
||||
return jsonutils.to_primitive(usage)
|
||||
|
||||
def provider_fw_rule_get_all(self, context):
|
||||
rules = self.db.provider_fw_rule_get_all(context)
|
||||
return jsonutils.to_primitive(rules)
|
||||
|
||||
# NOTE(danms): This can be removed in version 3.0 of the RPC API
|
||||
def agent_build_get_by_triple(self, context, hypervisor, os, architecture):
|
||||
info = self.db.agent_build_get_by_triple(context, hypervisor, os,
|
||||
architecture)
|
||||
return jsonutils.to_primitive(info)
|
||||
|
||||
def block_device_mapping_update_or_create(self, context, values, create):
|
||||
if create is None:
|
||||
bdm = self.db.block_device_mapping_update_or_create(context,
|
||||
values)
|
||||
elif create is True:
|
||||
bdm = self.db.block_device_mapping_create(context, values)
|
||||
else:
|
||||
bdm = self.db.block_device_mapping_update(context,
|
||||
values['id'],
|
||||
values)
|
||||
bdm_obj = objects.BlockDeviceMapping._from_db_object(
|
||||
context, objects.BlockDeviceMapping(), bdm)
|
||||
self.cells_rpcapi.bdm_update_or_create_at_top(context, bdm_obj,
|
||||
create=create)
|
||||
|
||||
def block_device_mapping_get_all_by_instance(self, context, instance,
|
||||
legacy):
|
||||
bdms = self.db.block_device_mapping_get_all_by_instance(
|
||||
context, instance['uuid'])
|
||||
if legacy:
|
||||
bdms = block_device.legacy_mapping(bdms)
|
||||
return jsonutils.to_primitive(bdms)
|
||||
|
||||
def instance_get_all_by_filters(self, context, filters, sort_key,
|
||||
sort_dir, columns_to_join,
|
||||
use_slave):
|
||||
result = self.db.instance_get_all_by_filters(
|
||||
context, filters, sort_key, sort_dir,
|
||||
columns_to_join=columns_to_join, use_slave=use_slave)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def instance_get_active_by_window(self, context, begin, end,
|
||||
project_id, host):
|
||||
# Unused, but cannot remove until major RPC version bump
|
||||
result = self.db.instance_get_active_by_window(context, begin, end,
|
||||
project_id, host)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def instance_get_active_by_window_joined(self, context, begin, end,
|
||||
project_id, host):
|
||||
result = self.db.instance_get_active_by_window_joined(
|
||||
context, begin, end, project_id, host)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def instance_destroy(self, context, instance):
|
||||
result = self.db.instance_destroy(context, instance['uuid'])
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def instance_fault_create(self, context, values):
|
||||
result = self.db.instance_fault_create(context, values)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
# NOTE(kerrin): The last_refreshed argument is unused by this method
|
||||
# and can be removed in v3.0 of the RPC API.
|
||||
def vol_usage_update(self, context, vol_id, rd_req, rd_bytes, wr_req,
|
||||
wr_bytes, instance, last_refreshed, update_totals):
|
||||
vol_usage = self.db.vol_usage_update(context, vol_id,
|
||||
rd_req, rd_bytes,
|
||||
wr_req, wr_bytes,
|
||||
instance['uuid'],
|
||||
instance['project_id'],
|
||||
instance['user_id'],
|
||||
instance['availability_zone'],
|
||||
update_totals)
|
||||
|
||||
# We have just updated the database, so send the notification now
|
||||
self.notifier.info(context, 'volume.usage',
|
||||
compute_utils.usage_volume_info(vol_usage))
|
||||
|
||||
@messaging.expected_exceptions(exception.ComputeHostNotFound,
|
||||
exception.HostBinaryNotFound)
|
||||
def service_get_all_by(self, context, topic, host, binary):
|
||||
if not any((topic, host, binary)):
|
||||
result = self.db.service_get_all(context)
|
||||
elif all((topic, host)):
|
||||
if topic == 'compute':
|
||||
result = self.db.service_get_by_compute_host(context, host)
|
||||
# FIXME(comstud) Potentially remove this on bump to v3.0
|
||||
result = [result]
|
||||
else:
|
||||
result = self.db.service_get_by_host_and_topic(context,
|
||||
host, topic)
|
||||
elif all((host, binary)):
|
||||
result = self.db.service_get_by_args(context, host, binary)
|
||||
elif topic:
|
||||
result = self.db.service_get_all_by_topic(context, topic)
|
||||
elif host:
|
||||
result = self.db.service_get_all_by_host(context, host)
|
||||
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
@messaging.expected_exceptions(exception.InstanceActionNotFound)
|
||||
def action_event_start(self, context, values):
|
||||
evt = self.db.action_event_start(context, values)
|
||||
return jsonutils.to_primitive(evt)
|
||||
|
||||
@messaging.expected_exceptions(exception.InstanceActionNotFound,
|
||||
exception.InstanceActionEventNotFound)
|
||||
def action_event_finish(self, context, values):
|
||||
evt = self.db.action_event_finish(context, values)
|
||||
return jsonutils.to_primitive(evt)
|
||||
|
||||
def service_create(self, context, values):
|
||||
svc = self.db.service_create(context, values)
|
||||
return jsonutils.to_primitive(svc)
|
||||
|
||||
@messaging.expected_exceptions(exception.ServiceNotFound)
|
||||
def service_destroy(self, context, service_id):
|
||||
self.db.service_destroy(context, service_id)
|
||||
|
||||
def compute_node_create(self, context, values):
|
||||
result = self.db.compute_node_create(context, values)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def compute_node_update(self, context, node, values):
|
||||
result = self.db.compute_node_update(context, node['id'], values)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def compute_node_delete(self, context, node):
|
||||
result = self.db.compute_node_delete(context, node['id'])
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
@messaging.expected_exceptions(exception.ServiceNotFound)
|
||||
def service_update(self, context, service, values):
|
||||
svc = self.db.service_update(context, service['id'], values)
|
||||
return jsonutils.to_primitive(svc)
|
||||
|
||||
def task_log_get(self, context, task_name, begin, end, host, state):
|
||||
result = self.db.task_log_get(context, task_name, begin, end, host,
|
||||
state)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def task_log_begin_task(self, context, task_name, begin, end, host,
|
||||
task_items, message):
|
||||
result = self.db.task_log_begin_task(context.elevated(), task_name,
|
||||
begin, end, host, task_items,
|
||||
message)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def task_log_end_task(self, context, task_name, begin, end, host,
|
||||
errors, message):
|
||||
result = self.db.task_log_end_task(context.elevated(), task_name,
|
||||
begin, end, host, errors, message)
|
||||
return jsonutils.to_primitive(result)
|
||||
|
||||
def notify_usage_exists(self, context, instance, current_period,
|
||||
ignore_missing_network_data,
|
||||
system_metadata, extra_usage_info):
|
||||
compute_utils.notify_usage_exists(self.notifier, context, instance,
|
||||
current_period,
|
||||
ignore_missing_network_data,
|
||||
system_metadata, extra_usage_info)
|
||||
|
||||
def security_groups_trigger_handler(self, context, event, args):
|
||||
self.security_group_api.trigger_handler(event, context, *args)
|
||||
|
||||
def security_groups_trigger_members_refresh(self, context, group_ids):
|
||||
self.security_group_api.trigger_members_refresh(context, group_ids)
|
||||
|
||||
def network_migrate_instance_start(self, context, instance, migration):
|
||||
self.network_api.migrate_instance_start(context, instance, migration)
|
||||
|
||||
def network_migrate_instance_finish(self, context, instance, migration):
|
||||
self.network_api.migrate_instance_finish(context, instance, migration)
|
||||
|
||||
def quota_commit(self, context, reservations, project_id=None,
|
||||
user_id=None):
|
||||
quota.QUOTAS.commit(context, reservations, project_id=project_id,
|
||||
user_id=user_id)
|
||||
|
||||
def quota_rollback(self, context, reservations, project_id=None,
|
||||
user_id=None):
|
||||
quota.QUOTAS.rollback(context, reservations, project_id=project_id,
|
||||
user_id=user_id)
|
||||
|
||||
def get_ec2_ids(self, context, instance):
|
||||
ec2_ids = {}
|
||||
|
||||
ec2_ids['instance-id'] = ec2utils.id_to_ec2_inst_id(instance['uuid'])
|
||||
ec2_ids['ami-id'] = ec2utils.glance_id_to_ec2_id(context,
|
||||
instance['image_ref'])
|
||||
for image_type in ['kernel', 'ramdisk']:
|
||||
image_id = instance.get('%s_id' % image_type)
|
||||
if image_id is not None:
|
||||
ec2_image_type = ec2utils.image_type(image_type)
|
||||
ec2_id = ec2utils.glance_id_to_ec2_id(context, image_id,
|
||||
ec2_image_type)
|
||||
ec2_ids['%s-id' % image_type] = ec2_id
|
||||
|
||||
return ec2_ids
|
||||
|
||||
def compute_unrescue(self, context, instance):
|
||||
self.compute_api.unrescue(context, instance)
|
||||
|
||||
def _object_dispatch(self, target, method, context, args, kwargs):
|
||||
"""Dispatch a call to an object method.
|
||||
|
||||
This ensures that object methods get called and any exception
|
||||
that is raised gets wrapped in an ExpectedException for forwarding
|
||||
back to the caller (without spamming the conductor logs).
|
||||
"""
|
||||
try:
|
||||
# NOTE(danms): Keep the getattr inside the try block since
|
||||
# a missing method is really a client problem
|
||||
return getattr(target, method)(context, *args, **kwargs)
|
||||
except Exception:
|
||||
raise messaging.ExpectedException()
|
||||
|
||||
def object_class_action(self, context, objname, objmethod,
|
||||
objver, args, kwargs):
|
||||
"""Perform a classmethod action on an object."""
|
||||
objclass = nova_object.NovaObject.obj_class_from_name(objname,
|
||||
objver)
|
||||
result = self._object_dispatch(objclass, objmethod, context,
|
||||
args, kwargs)
|
||||
# NOTE(danms): The RPC layer will convert to primitives for us,
|
||||
# but in this case, we need to honor the version the client is
|
||||
# asking for, so we do it before returning here.
|
||||
return (result.obj_to_primitive(target_version=objver)
|
||||
if isinstance(result, nova_object.NovaObject) else result)
|
||||
|
||||
def object_action(self, context, objinst, objmethod, args, kwargs):
|
||||
"""Perform an action on an object."""
|
||||
oldobj = objinst.obj_clone()
|
||||
result = self._object_dispatch(objinst, objmethod, context,
|
||||
args, kwargs)
|
||||
updates = dict()
|
||||
# NOTE(danms): Diff the object with the one passed to us and
|
||||
# generate a list of changes to forward back
|
||||
for name, field in objinst.fields.items():
|
||||
if not objinst.obj_attr_is_set(name):
|
||||
# Avoid demand-loading anything
|
||||
continue
|
||||
if (not oldobj.obj_attr_is_set(name) or
|
||||
oldobj[name] != objinst[name]):
|
||||
updates[name] = field.to_primitive(objinst, name,
|
||||
objinst[name])
|
||||
# This is safe since a field named this would conflict with the
|
||||
# method anyway
|
||||
updates['obj_what_changed'] = objinst.obj_what_changed()
|
||||
return updates, result
|
||||
|
||||
def object_backport(self, context, objinst, target_version):
|
||||
return objinst.obj_to_primitive(target_version=target_version)
|
||||
|
||||
|
||||
class ComputeTaskManager(base.Base):
|
||||
"""Namespace for compute methods.
|
||||
|
||||
This class presents an rpc API for nova-conductor under the 'compute_task'
|
||||
namespace. The methods here are compute operations that are invoked
|
||||
by the API service. These methods see the operation to completion, which
|
||||
may involve coordinating activities on multiple compute nodes.
|
||||
"""
|
||||
|
||||
target = messaging.Target(namespace='compute_task', version='1.9')
|
||||
|
||||
def __init__(self):
|
||||
super(ComputeTaskManager, self).__init__()
|
||||
self.compute_rpcapi = compute_rpcapi.ComputeAPI()
|
||||
self.image_api = image.API()
|
||||
self.scheduler_client = scheduler_client.SchedulerClient()
|
||||
|
||||
@messaging.expected_exceptions(exception.NoValidHost,
|
||||
exception.ComputeServiceUnavailable,
|
||||
exception.InvalidHypervisorType,
|
||||
exception.InvalidCPUInfo,
|
||||
exception.UnableToMigrateToSelf,
|
||||
exception.DestinationHypervisorTooOld,
|
||||
exception.InvalidLocalStorage,
|
||||
exception.InvalidSharedStorage,
|
||||
exception.HypervisorUnavailable,
|
||||
exception.InstanceNotRunning,
|
||||
exception.MigrationPreCheckError)
|
||||
def migrate_server(self, context, instance, scheduler_hint, live, rebuild,
|
||||
flavor, block_migration, disk_over_commit, reservations=None):
|
||||
if instance and not isinstance(instance, nova_object.NovaObject):
|
||||
# NOTE(danms): Until v2 of the RPC API, we need to tolerate
|
||||
# old-world instance objects here
|
||||
attrs = ['metadata', 'system_metadata', 'info_cache',
|
||||
'security_groups']
|
||||
instance = objects.Instance._from_db_object(
|
||||
context, objects.Instance(), instance,
|
||||
expected_attrs=attrs)
|
||||
if live and not rebuild and not flavor:
|
||||
self._live_migrate(context, instance, scheduler_hint,
|
||||
block_migration, disk_over_commit)
|
||||
elif not live and not rebuild and flavor:
|
||||
instance_uuid = instance['uuid']
|
||||
with compute_utils.EventReporter(context, 'cold_migrate',
|
||||
instance_uuid):
|
||||
self._cold_migrate(context, instance, flavor,
|
||||
scheduler_hint['filter_properties'],
|
||||
reservations)
|
||||
else:
|
||||
raise NotImplementedError()
|
||||
|
||||
def _cold_migrate(self, context, instance, flavor, filter_properties,
|
||||
reservations):
|
||||
image_ref = instance.image_ref
|
||||
image = compute_utils.get_image_metadata(
|
||||
context, self.image_api, image_ref, instance)
|
||||
|
||||
request_spec = scheduler_utils.build_request_spec(
|
||||
context, image, [instance], instance_type=flavor)
|
||||
|
||||
quotas = objects.Quotas.from_reservations(context,
|
||||
reservations,
|
||||
instance=instance)
|
||||
try:
|
||||
scheduler_utils.populate_retry(filter_properties, instance['uuid'])
|
||||
hosts = self.scheduler_client.select_destinations(
|
||||
context, request_spec, filter_properties)
|
||||
host_state = hosts[0]
|
||||
except exception.NoValidHost as ex:
|
||||
vm_state = instance['vm_state']
|
||||
if not vm_state:
|
||||
vm_state = vm_states.ACTIVE
|
||||
updates = {'vm_state': vm_state, 'task_state': None}
|
||||
self._set_vm_state_and_notify(context, 'migrate_server',
|
||||
updates, ex, request_spec)
|
||||
quotas.rollback()
|
||||
|
||||
# if the flavor IDs match, it's migrate; otherwise resize
|
||||
if flavor['id'] == instance['instance_type_id']:
|
||||
msg = _("No valid host found for cold migrate")
|
||||
else:
|
||||
msg = _("No valid host found for resize")
|
||||
raise exception.NoValidHost(reason=msg)
|
||||
|
||||
try:
|
||||
scheduler_utils.populate_filter_properties(filter_properties,
|
||||
host_state)
|
||||
# context is not serializable
|
||||
filter_properties.pop('context', None)
|
||||
|
||||
# TODO(timello): originally, instance_type in request_spec
|
||||
# on compute.api.resize does not have 'extra_specs', so we
|
||||
# remove it for now to keep tests backward compatibility.
|
||||
request_spec['instance_type'].pop('extra_specs')
|
||||
|
||||
(host, node) = (host_state['host'], host_state['nodename'])
|
||||
self.compute_rpcapi.prep_resize(
|
||||
context, image, instance,
|
||||
flavor, host,
|
||||
reservations, request_spec=request_spec,
|
||||
filter_properties=filter_properties, node=node)
|
||||
except Exception as ex:
|
||||
with excutils.save_and_reraise_exception():
|
||||
updates = {'vm_state': instance['vm_state'],
|
||||
'task_state': None}
|
||||
self._set_vm_state_and_notify(context, 'migrate_server',
|
||||
updates, ex, request_spec)
|
||||
quotas.rollback()
|
||||
|
||||
def _set_vm_state_and_notify(self, context, method, updates, ex,
|
||||
request_spec):
|
||||
scheduler_utils.set_vm_state_and_notify(
|
||||
context, 'compute_task', method, updates,
|
||||
ex, request_spec, self.db)
|
||||
|
||||
def _live_migrate(self, context, instance, scheduler_hint,
|
||||
block_migration, disk_over_commit):
|
||||
destination = scheduler_hint.get("host")
|
||||
try:
|
||||
live_migrate.execute(context, instance, destination,
|
||||
block_migration, disk_over_commit)
|
||||
except (exception.NoValidHost,
|
||||
exception.ComputeServiceUnavailable,
|
||||
exception.InvalidHypervisorType,
|
||||
exception.InvalidCPUInfo,
|
||||
exception.UnableToMigrateToSelf,
|
||||
exception.DestinationHypervisorTooOld,
|
||||
exception.InvalidLocalStorage,
|
||||
exception.InvalidSharedStorage,
|
||||
exception.HypervisorUnavailable,
|
||||
exception.InstanceNotRunning,
|
||||
exception.MigrationPreCheckError) as ex:
|
||||
with excutils.save_and_reraise_exception():
|
||||
# TODO(johngarbutt) - eventually need instance actions here
|
||||
request_spec = {'instance_properties': {
|
||||
'uuid': instance['uuid'], },
|
||||
}
|
||||
scheduler_utils.set_vm_state_and_notify(context,
|
||||
'compute_task', 'migrate_server',
|
||||
dict(vm_state=instance['vm_state'],
|
||||
task_state=None,
|
||||
expected_task_state=task_states.MIGRATING,),
|
||||
ex, request_spec, self.db)
|
||||
except Exception as ex:
|
||||
LOG.error(_('Migration of instance %(instance_id)s to host'
|
||||
' %(dest)s unexpectedly failed.'),
|
||||
{'instance_id': instance['uuid'], 'dest': destination},
|
||||
exc_info=True)
|
||||
raise exception.MigrationError(reason=ex)
|
||||
|
||||
def build_instances(self, context, instances, image, filter_properties,
|
||||
admin_password, injected_files, requested_networks,
|
||||
security_groups, block_device_mapping=None, legacy_bdm=True):
|
||||
# TODO(ndipanov): Remove block_device_mapping and legacy_bdm in version
|
||||
# 2.0 of the RPC API.
|
||||
request_spec = scheduler_utils.build_request_spec(context, image,
|
||||
instances)
|
||||
# TODO(danms): Remove this in version 2.0 of the RPC API
|
||||
if (requested_networks and
|
||||
not isinstance(requested_networks,
|
||||
objects.NetworkRequestList)):
|
||||
requested_networks = objects.NetworkRequestList(
|
||||
objects=[objects.NetworkRequest.from_tuple(t)
|
||||
for t in requested_networks])
|
||||
|
||||
try:
|
||||
# check retry policy. Rather ugly use of instances[0]...
|
||||
# but if we've exceeded max retries... then we really only
|
||||
# have a single instance.
|
||||
scheduler_utils.populate_retry(filter_properties,
|
||||
instances[0].uuid)
|
||||
hosts = self.scheduler_client.select_destinations(context,
|
||||
request_spec, filter_properties)
|
||||
except Exception as exc:
|
||||
for instance in instances:
|
||||
scheduler_driver.handle_schedule_error(context, exc,
|
||||
instance.uuid, request_spec)
|
||||
return
|
||||
|
||||
for (instance, host) in itertools.izip(instances, hosts):
|
||||
try:
|
||||
instance.refresh()
|
||||
except (exception.InstanceNotFound,
|
||||
exception.InstanceInfoCacheNotFound):
|
||||
LOG.debug('Instance deleted during build', instance=instance)
|
||||
continue
|
||||
local_filter_props = copy.deepcopy(filter_properties)
|
||||
scheduler_utils.populate_filter_properties(local_filter_props,
|
||||
host)
|
||||
# The block_device_mapping passed from the api doesn't contain
|
||||
# instance specific information
|
||||
bdms = objects.BlockDeviceMappingList.get_by_instance_uuid(
|
||||
context, instance.uuid)
|
||||
|
||||
self.compute_rpcapi.build_and_run_instance(context,
|
||||
instance=instance, host=host['host'], image=image,
|
||||
request_spec=request_spec,
|
||||
filter_properties=local_filter_props,
|
||||
admin_password=admin_password,
|
||||
injected_files=injected_files,
|
||||
requested_networks=requested_networks,
|
||||
security_groups=security_groups,
|
||||
block_device_mapping=bdms, node=host['nodename'],
|
||||
limits=host['limits'])
|
||||
|
||||
def _delete_image(self, context, image_id):
|
||||
return self.image_api.delete(context, image_id)
|
||||
|
||||
def _schedule_instances(self, context, image, filter_properties,
|
||||
*instances):
|
||||
request_spec = scheduler_utils.build_request_spec(context, image,
|
||||
instances)
|
||||
hosts = self.scheduler_client.select_destinations(context,
|
||||
request_spec, filter_properties)
|
||||
return hosts
|
||||
|
||||
def unshelve_instance(self, context, instance):
|
||||
sys_meta = instance.system_metadata
|
||||
|
||||
def safe_image_show(ctx, image_id):
|
||||
if image_id:
|
||||
return self.image_api.get(ctx, image_id)
|
||||
|
||||
if instance.vm_state == vm_states.SHELVED:
|
||||
instance.task_state = task_states.POWERING_ON
|
||||
instance.save(expected_task_state=task_states.UNSHELVING)
|
||||
self.compute_rpcapi.start_instance(context, instance)
|
||||
snapshot_id = sys_meta.get('shelved_image_id')
|
||||
if snapshot_id:
|
||||
self._delete_image(context, snapshot_id)
|
||||
elif instance.vm_state == vm_states.SHELVED_OFFLOADED:
|
||||
image_id = sys_meta.get('shelved_image_id')
|
||||
with compute_utils.EventReporter(
|
||||
context, 'get_image_info', instance.uuid):
|
||||
try:
|
||||
image = safe_image_show(context, image_id)
|
||||
except exception.ImageNotFound:
|
||||
instance.vm_state = vm_states.ERROR
|
||||
instance.save()
|
||||
reason = _('Unshelve attempted but the image %s '
|
||||
'cannot be found.') % image_id
|
||||
LOG.error(reason, instance=instance)
|
||||
raise exception.UnshelveException(
|
||||
instance_id=instance.uuid, reason=reason)
|
||||
|
||||
try:
|
||||
with compute_utils.EventReporter(context, 'schedule_instances',
|
||||
instance.uuid):
|
||||
filter_properties = {}
|
||||
hosts = self._schedule_instances(context, image,
|
||||
filter_properties,
|
||||
instance)
|
||||
host_state = hosts[0]
|
||||
scheduler_utils.populate_filter_properties(
|
||||
filter_properties, host_state)
|
||||
(host, node) = (host_state['host'], host_state['nodename'])
|
||||
self.compute_rpcapi.unshelve_instance(
|
||||
context, instance, host, image=image,
|
||||
filter_properties=filter_properties, node=node)
|
||||
except exception.NoValidHost:
|
||||
instance.task_state = None
|
||||
instance.save()
|
||||
LOG.warning(_("No valid host found for unshelve instance"),
|
||||
instance=instance)
|
||||
return
|
||||
else:
|
||||
LOG.error(_('Unshelve attempted but vm_state not SHELVED or '
|
||||
'SHELVED_OFFLOADED'), instance=instance)
|
||||
instance.vm_state = vm_states.ERROR
|
||||
instance.save()
|
||||
return
|
||||
|
||||
for key in ['shelved_at', 'shelved_image_id', 'shelved_host']:
|
||||
if key in sys_meta:
|
||||
del(sys_meta[key])
|
||||
instance.system_metadata = sys_meta
|
||||
instance.save()
|
||||
|
||||
def rebuild_instance(self, context, instance, orig_image_ref, image_ref,
|
||||
injected_files, new_pass, orig_sys_metadata,
|
||||
bdms, recreate, on_shared_storage,
|
||||
preserve_ephemeral=False, host=None):
|
||||
|
||||
with compute_utils.EventReporter(context, 'rebuild_server',
|
||||
instance.uuid):
|
||||
if not host:
|
||||
# NOTE(lcostantino): Retrieve scheduler filters for the
|
||||
# instance when the feature is available
|
||||
filter_properties = {'ignore_hosts': [instance.host]}
|
||||
request_spec = scheduler_utils.build_request_spec(context,
|
||||
image_ref,
|
||||
[instance])
|
||||
try:
|
||||
hosts = self.scheduler_client.select_destinations(context,
|
||||
request_spec,
|
||||
filter_properties)
|
||||
host = hosts.pop(0)['host']
|
||||
except exception.NoValidHost as ex:
|
||||
with excutils.save_and_reraise_exception():
|
||||
self._set_vm_state_and_notify(context,
|
||||
'rebuild_server',
|
||||
{'vm_state': instance.vm_state,
|
||||
'task_state': None}, ex, request_spec)
|
||||
LOG.warning(_("No valid host found for rebuild"),
|
||||
instance=instance)
|
||||
|
||||
self.compute_rpcapi.rebuild_instance(context,
|
||||
instance=instance,
|
||||
new_pass=new_pass,
|
||||
injected_files=injected_files,
|
||||
image_ref=image_ref,
|
||||
orig_image_ref=orig_image_ref,
|
||||
orig_sys_metadata=orig_sys_metadata,
|
||||
bdms=bdms,
|
||||
recreate=recreate,
|
||||
on_shared_storage=on_shared_storage,
|
||||
preserve_ephemeral=preserve_ephemeral,
|
||||
host=host)
|
|
@ -1,20 +0,0 @@
|
|||
from sqlalchemy import Column, String, MetaData, Table
|
||||
|
||||
|
||||
def upgrade(migrate_engine):
|
||||
meta = MetaData()
|
||||
meta.bind = migrate_engine
|
||||
|
||||
instances = Table('instances', meta, autoload=True)
|
||||
mapping_uuid = Column('mapping_uuid',
|
||||
String(length=36))
|
||||
instances.create_column(mapping_uuid)
|
||||
|
||||
|
||||
def downgrade(migrate_engine):
|
||||
meta = MetaData()
|
||||
meta.bind = migrate_engine
|
||||
|
||||
instances = Table('instances', meta, autoload=True)
|
||||
mapping_uuid = instances.columns.mapping_uuid
|
||||
mapping_uuid.drop()
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
@ -1,802 +0,0 @@
|
|||
# Copyright 2013 IBM Corp.
|
||||
#
|
||||
# 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.cells import opts as cells_opts
|
||||
from nova.cells import rpcapi as cells_rpcapi
|
||||
from nova.compute import flavors
|
||||
from nova import db
|
||||
from nova import exception
|
||||
from nova.i18n import _LE
|
||||
from nova import notifications
|
||||
from nova import objects
|
||||
from nova.objects import base
|
||||
from nova.objects import fields
|
||||
from nova.openstack.common import log as logging
|
||||
from nova.openstack.common import timeutils
|
||||
from nova import utils
|
||||
|
||||
from oslo.config import cfg
|
||||
|
||||
|
||||
CONF = cfg.CONF
|
||||
LOG = logging.getLogger(__name__)
|
||||
|
||||
|
||||
# List of fields that can be joined in DB layer.
|
||||
_INSTANCE_OPTIONAL_JOINED_FIELDS = ['metadata', 'system_metadata',
|
||||
'info_cache', 'security_groups',
|
||||
'pci_devices']
|
||||
# These are fields that are optional but don't translate to db columns
|
||||
_INSTANCE_OPTIONAL_NON_COLUMN_FIELDS = ['fault', 'numa_topology']
|
||||
|
||||
# These are fields that can be specified as expected_attrs
|
||||
INSTANCE_OPTIONAL_ATTRS = (_INSTANCE_OPTIONAL_JOINED_FIELDS +
|
||||
_INSTANCE_OPTIONAL_NON_COLUMN_FIELDS)
|
||||
# These are fields that most query calls load by default
|
||||
INSTANCE_DEFAULT_FIELDS = ['metadata', 'system_metadata',
|
||||
'info_cache', 'security_groups']
|
||||
|
||||
|
||||
def _expected_cols(expected_attrs):
|
||||
"""Return expected_attrs that are columns needing joining."""
|
||||
if not expected_attrs:
|
||||
return expected_attrs
|
||||
return [attr for attr in expected_attrs
|
||||
if attr in _INSTANCE_OPTIONAL_JOINED_FIELDS]
|
||||
|
||||
|
||||
class Instance(base.NovaPersistentObject, base.NovaObject):
|
||||
# Version 1.0: Initial version
|
||||
# Version 1.1: Added info_cache
|
||||
# Version 1.2: Added security_groups
|
||||
# Version 1.3: Added expected_vm_state and admin_state_reset to
|
||||
# save()
|
||||
# Version 1.4: Added locked_by and deprecated locked
|
||||
# Version 1.5: Added cleaned
|
||||
# Version 1.6: Added pci_devices
|
||||
# Version 1.7: String attributes updated to support unicode
|
||||
# Version 1.8: 'security_groups' and 'pci_devices' cannot be None
|
||||
# Version 1.9: Make uuid a non-None real string
|
||||
# Version 1.10: Added use_slave to refresh and get_by_uuid
|
||||
# Version 1.11: Update instance from database during destroy
|
||||
# Version 1.12: Added ephemeral_key_uuid
|
||||
# Version 1.13: Added delete_metadata_key()
|
||||
# Version 1.14: Added numa_topology
|
||||
# Version 1.15: PciDeviceList 1.1
|
||||
VERSION = '1.15'
|
||||
|
||||
fields = {
|
||||
'id': fields.IntegerField(),
|
||||
|
||||
'user_id': fields.StringField(nullable=True),
|
||||
'project_id': fields.StringField(nullable=True),
|
||||
|
||||
'image_ref': fields.StringField(nullable=True),
|
||||
'kernel_id': fields.StringField(nullable=True),
|
||||
'ramdisk_id': fields.StringField(nullable=True),
|
||||
'hostname': fields.StringField(nullable=True),
|
||||
|
||||
'launch_index': fields.IntegerField(nullable=True),
|
||||
'key_name': fields.StringField(nullable=True),
|
||||
'key_data': fields.StringField(nullable=True),
|
||||
|
||||
'power_state': fields.IntegerField(nullable=True),
|
||||
'vm_state': fields.StringField(nullable=True),
|
||||
'task_state': fields.StringField(nullable=True),
|
||||
|
||||
'memory_mb': fields.IntegerField(nullable=True),
|
||||
'vcpus': fields.IntegerField(nullable=True),
|
||||
'root_gb': fields.IntegerField(nullable=True),
|
||||
'ephemeral_gb': fields.IntegerField(nullable=True),
|
||||
'ephemeral_key_uuid': fields.UUIDField(nullable=True),
|
||||
|
||||
'host': fields.StringField(nullable=True),
|
||||
'node': fields.StringField(nullable=True),
|
||||
|
||||
'instance_type_id': fields.IntegerField(nullable=True),
|
||||
|
||||
'user_data': fields.StringField(nullable=True),
|
||||
|
||||
'reservation_id': fields.StringField(nullable=True),
|
||||
|
||||
'scheduled_at': fields.DateTimeField(nullable=True),
|
||||
'launched_at': fields.DateTimeField(nullable=True),
|
||||
'terminated_at': fields.DateTimeField(nullable=True),
|
||||
|
||||
'availability_zone': fields.StringField(nullable=True),
|
||||
|
||||
'display_name': fields.StringField(nullable=True),
|
||||
'display_description': fields.StringField(nullable=True),
|
||||
|
||||
'launched_on': fields.StringField(nullable=True),
|
||||
|
||||
# NOTE(jdillaman): locked deprecated in favor of locked_by,
|
||||
# to be removed in Icehouse
|
||||
'locked': fields.BooleanField(default=False),
|
||||
'locked_by': fields.StringField(nullable=True),
|
||||
|
||||
'os_type': fields.StringField(nullable=True),
|
||||
'architecture': fields.StringField(nullable=True),
|
||||
'vm_mode': fields.StringField(nullable=True),
|
||||
'uuid': fields.UUIDField(),
|
||||
'mapping_uuid': fields.UUIDField(nullable=True),
|
||||
|
||||
'root_device_name': fields.StringField(nullable=True),
|
||||
'default_ephemeral_device': fields.StringField(nullable=True),
|
||||
'default_swap_device': fields.StringField(nullable=True),
|
||||
'config_drive': fields.StringField(nullable=True),
|
||||
|
||||
'access_ip_v4': fields.IPV4AddressField(nullable=True),
|
||||
'access_ip_v6': fields.IPV6AddressField(nullable=True),
|
||||
|
||||
'auto_disk_config': fields.BooleanField(default=False),
|
||||
'progress': fields.IntegerField(nullable=True),
|
||||
|
||||
'shutdown_terminate': fields.BooleanField(default=False),
|
||||
'disable_terminate': fields.BooleanField(default=False),
|
||||
|
||||
'cell_name': fields.StringField(nullable=True),
|
||||
|
||||
'metadata': fields.DictOfStringsField(),
|
||||
'system_metadata': fields.DictOfNullableStringsField(),
|
||||
|
||||
'info_cache': fields.ObjectField('InstanceInfoCache',
|
||||
nullable=True),
|
||||
|
||||
'security_groups': fields.ObjectField('SecurityGroupList'),
|
||||
|
||||
'fault': fields.ObjectField('InstanceFault', nullable=True),
|
||||
|
||||
'cleaned': fields.BooleanField(default=False),
|
||||
|
||||
'pci_devices': fields.ObjectField('PciDeviceList', nullable=True),
|
||||
'numa_topology': fields.ObjectField('InstanceNUMATopology',
|
||||
nullable=True)
|
||||
}
|
||||
|
||||
obj_extra_fields = ['name']
|
||||
|
||||
def __init__(self, *args, **kwargs):
|
||||
super(Instance, self).__init__(*args, **kwargs)
|
||||
self._reset_metadata_tracking()
|
||||
|
||||
def _reset_metadata_tracking(self, fields=None):
|
||||
if fields is None or 'system_metadata' in fields:
|
||||
self._orig_system_metadata = (dict(self.system_metadata) if
|
||||
'system_metadata' in self else {})
|
||||
if fields is None or 'metadata' in fields:
|
||||
self._orig_metadata = (dict(self.metadata) if
|
||||
'metadata' in self else {})
|
||||
|
||||
def obj_reset_changes(self, fields=None):
|
||||
super(Instance, self).obj_reset_changes(fields)
|
||||
self._reset_metadata_tracking(fields=fields)
|
||||
|
||||
def obj_what_changed(self):
|
||||
changes = super(Instance, self).obj_what_changed()
|
||||
if 'metadata' in self and self.metadata != self._orig_metadata:
|
||||
changes.add('metadata')
|
||||
if 'system_metadata' in self and (self.system_metadata !=
|
||||
self._orig_system_metadata):
|
||||
changes.add('system_metadata')
|
||||
return changes
|
||||
|
||||
@classmethod
|
||||
def _obj_from_primitive(cls, context, objver, primitive):
|
||||
self = super(Instance, cls)._obj_from_primitive(context, objver,
|
||||
primitive)
|
||||
self._reset_metadata_tracking()
|
||||
return self
|
||||
|
||||
def obj_make_compatible(self, primitive, target_version):
|
||||
target_version = utils.convert_version_to_tuple(target_version)
|
||||
unicode_attributes = ['user_id', 'project_id', 'image_ref',
|
||||
'kernel_id', 'ramdisk_id', 'hostname',
|
||||
'key_name', 'key_data', 'host', 'node',
|
||||
'user_data', 'availability_zone',
|
||||
'display_name', 'display_description',
|
||||
'launched_on', 'locked_by', 'os_type',
|
||||
'architecture', 'vm_mode', 'root_device_name',
|
||||
'default_ephemeral_device',
|
||||
'default_swap_device', 'config_drive',
|
||||
'cell_name']
|
||||
if target_version < (1, 14) and 'numa_topology' in primitive:
|
||||
del primitive['numa_topology']
|
||||
if target_version < (1, 10) and 'info_cache' in primitive:
|
||||
# NOTE(danms): Instance <= 1.9 (havana) had info_cache 1.4
|
||||
self.info_cache.obj_make_compatible(
|
||||
primitive['info_cache']['nova_object.data'], '1.4')
|
||||
primitive['info_cache']['nova_object.version'] = '1.4'
|
||||
if target_version < (1, 7):
|
||||
# NOTE(danms): Before 1.7, we couldn't handle unicode in
|
||||
# string fields, so squash it here
|
||||
for field in [x for x in unicode_attributes if x in primitive
|
||||
and primitive[x] is not None]:
|
||||
primitive[field] = primitive[field].encode('ascii', 'replace')
|
||||
if target_version < (1, 15) and 'pci_devices' in primitive:
|
||||
# NOTE(baoli): Instance <= 1.14 (icehouse) had PciDeviceList 1.0
|
||||
self.pci_devices.obj_make_compatible(
|
||||
primitive['pci_devices']['nova_object.data'], '1.0')
|
||||
primitive['pci_devices']['nova_object.version'] = '1.0'
|
||||
if target_version < (1, 6):
|
||||
# NOTE(danms): Before 1.6 there was no pci_devices list
|
||||
if 'pci_devices' in primitive:
|
||||
del primitive['pci_devices']
|
||||
|
||||
@property
|
||||
def name(self):
|
||||
try:
|
||||
base_name = CONF.instance_name_template % self.id
|
||||
except TypeError:
|
||||
# Support templates like "uuid-%(uuid)s", etc.
|
||||
info = {}
|
||||
# NOTE(russellb): Don't use self.iteritems() here, as it will
|
||||
# result in infinite recursion on the name property.
|
||||
for key in self.fields:
|
||||
if key == 'name':
|
||||
# NOTE(danms): prevent recursion
|
||||
continue
|
||||
elif not self.obj_attr_is_set(key):
|
||||
# NOTE(danms): Don't trigger lazy-loads
|
||||
continue
|
||||
info[key] = self[key]
|
||||
try:
|
||||
base_name = CONF.instance_name_template % info
|
||||
except KeyError:
|
||||
base_name = self.uuid
|
||||
return base_name
|
||||
|
||||
@staticmethod
|
||||
def _from_db_object(context, instance, db_inst, expected_attrs=None):
|
||||
"""Method to help with migration to objects.
|
||||
|
||||
Converts a database entity to a formal object.
|
||||
"""
|
||||
instance._context = context
|
||||
if expected_attrs is None:
|
||||
expected_attrs = []
|
||||
# Most of the field names match right now, so be quick
|
||||
for field in instance.fields:
|
||||
if field in INSTANCE_OPTIONAL_ATTRS:
|
||||
continue
|
||||
elif field == 'deleted':
|
||||
instance.deleted = db_inst['deleted'] == db_inst['id']
|
||||
elif field == 'cleaned':
|
||||
instance.cleaned = db_inst['cleaned'] == 1
|
||||
else:
|
||||
instance[field] = db_inst[field]
|
||||
|
||||
if 'metadata' in expected_attrs:
|
||||
instance['metadata'] = utils.instance_meta(db_inst)
|
||||
if 'system_metadata' in expected_attrs:
|
||||
instance['system_metadata'] = utils.instance_sys_meta(db_inst)
|
||||
if 'fault' in expected_attrs:
|
||||
instance['fault'] = (
|
||||
objects.InstanceFault.get_latest_for_instance(
|
||||
context, instance.uuid))
|
||||
if 'numa_topology' in expected_attrs:
|
||||
instance._load_numa_topology()
|
||||
|
||||
if 'info_cache' in expected_attrs:
|
||||
if db_inst['info_cache'] is None:
|
||||
instance.info_cache = None
|
||||
elif not instance.obj_attr_is_set('info_cache'):
|
||||
# TODO(danms): If this ever happens on a backlevel instance
|
||||
# passed to us by a backlevel service, things will break
|
||||
instance.info_cache = objects.InstanceInfoCache(context)
|
||||
if instance.info_cache is not None:
|
||||
instance.info_cache._from_db_object(context,
|
||||
instance.info_cache,
|
||||
db_inst['info_cache'])
|
||||
|
||||
# TODO(danms): If we are updating these on a backlevel instance,
|
||||
# we'll end up sending back new versions of these objects (see
|
||||
# above note for new info_caches
|
||||
if 'pci_devices' in expected_attrs:
|
||||
pci_devices = base.obj_make_list(
|
||||
context, objects.PciDeviceList(context),
|
||||
objects.PciDevice, db_inst['pci_devices'])
|
||||
instance['pci_devices'] = pci_devices
|
||||
if 'security_groups' in expected_attrs:
|
||||
sec_groups = base.obj_make_list(
|
||||
context, objects.SecurityGroupList(context),
|
||||
objects.SecurityGroup, db_inst['security_groups'])
|
||||
instance['security_groups'] = sec_groups
|
||||
|
||||
instance.obj_reset_changes()
|
||||
return instance
|
||||
|
||||
@base.remotable_classmethod
|
||||
def get_by_uuid(cls, context, uuid, expected_attrs=None, use_slave=False):
|
||||
if expected_attrs is None:
|
||||
expected_attrs = ['info_cache', 'security_groups']
|
||||
columns_to_join = _expected_cols(expected_attrs)
|
||||
db_inst = db.instance_get_by_uuid(context, uuid,
|
||||
columns_to_join=columns_to_join,
|
||||
use_slave=use_slave)
|
||||
return cls._from_db_object(context, cls(), db_inst,
|
||||
expected_attrs)
|
||||
|
||||
@base.remotable_classmethod
|
||||
def get_by_id(cls, context, inst_id, expected_attrs=None):
|
||||
if expected_attrs is None:
|
||||
expected_attrs = ['info_cache', 'security_groups']
|
||||
columns_to_join = _expected_cols(expected_attrs)
|
||||
db_inst = db.instance_get(context, inst_id,
|
||||
columns_to_join=columns_to_join)
|
||||
return cls._from_db_object(context, cls(), db_inst,
|
||||
expected_attrs)
|
||||
|
||||
@base.remotable
|
||||
def create(self, context):
|
||||
if self.obj_attr_is_set('id'):
|
||||
raise exception.ObjectActionError(action='create',
|
||||
reason='already created')
|
||||
updates = self.obj_get_changes()
|
||||
expected_attrs = [attr for attr in INSTANCE_DEFAULT_FIELDS
|
||||
if attr in updates]
|
||||
if 'security_groups' in updates:
|
||||
updates['security_groups'] = [x.name for x in
|
||||
updates['security_groups']]
|
||||
if 'info_cache' in updates:
|
||||
updates['info_cache'] = {
|
||||
'network_info': updates['info_cache'].network_info.json()
|
||||
}
|
||||
numa_topology = updates.pop('numa_topology', None)
|
||||
db_inst = db.instance_create(context, updates)
|
||||
if numa_topology:
|
||||
expected_attrs.append('numa_topology')
|
||||
numa_topology.instance_uuid = db_inst['uuid']
|
||||
numa_topology.create(context)
|
||||
self._from_db_object(context, self, db_inst, expected_attrs)
|
||||
|
||||
@base.remotable
|
||||
def destroy(self, context):
|
||||
if not self.obj_attr_is_set('id'):
|
||||
raise exception.ObjectActionError(action='destroy',
|
||||
reason='already destroyed')
|
||||
if not self.obj_attr_is_set('uuid'):
|
||||
raise exception.ObjectActionError(action='destroy',
|
||||
reason='no uuid')
|
||||
if not self.obj_attr_is_set('host') or not self.host:
|
||||
# NOTE(danms): If our host is not set, avoid a race
|
||||
constraint = db.constraint(host=db.equal_any(None))
|
||||
else:
|
||||
constraint = None
|
||||
|
||||
try:
|
||||
db_inst = db.instance_destroy(context, self.uuid,
|
||||
constraint=constraint)
|
||||
self._from_db_object(context, self, db_inst)
|
||||
except exception.ConstraintNotMet:
|
||||
raise exception.ObjectActionError(action='destroy',
|
||||
reason='host changed')
|
||||
delattr(self, base.get_attrname('id'))
|
||||
|
||||
def _save_info_cache(self, context):
|
||||
self.info_cache.save(context)
|
||||
|
||||
def _save_security_groups(self, context):
|
||||
for secgroup in self.security_groups:
|
||||
secgroup.save(context)
|
||||
self.security_groups.obj_reset_changes()
|
||||
|
||||
def _save_fault(self, context):
|
||||
# NOTE(danms): I don't think we need to worry about this, do we?
|
||||
pass
|
||||
|
||||
def _save_numa_topology(self, context):
|
||||
# NOTE(ndipanov): No need for this yet.
|
||||
pass
|
||||
|
||||
def _save_pci_devices(self, context):
|
||||
# NOTE(yjiang5): All devices held by PCI tracker, only PCI tracker
|
||||
# permitted to update the DB. all change to devices from here will
|
||||
# be dropped.
|
||||
pass
|
||||
|
||||
@base.remotable
|
||||
def save(self, context, expected_vm_state=None,
|
||||
expected_task_state=None, admin_state_reset=False):
|
||||
"""Save updates to this instance
|
||||
|
||||
Column-wise updates will be made based on the result of
|
||||
self.what_changed(). If expected_task_state is provided,
|
||||
it will be checked against the in-database copy of the
|
||||
instance before updates are made.
|
||||
|
||||
:param:context: Security context
|
||||
:param:expected_task_state: Optional tuple of valid task states
|
||||
for the instance to be in
|
||||
:param:expected_vm_state: Optional tuple of valid vm states
|
||||
for the instance to be in
|
||||
:param admin_state_reset: True if admin API is forcing setting
|
||||
of task_state/vm_state
|
||||
|
||||
"""
|
||||
|
||||
cell_type = cells_opts.get_cell_type()
|
||||
if cell_type == 'api' and self.cell_name:
|
||||
# NOTE(comstud): We need to stash a copy of ourselves
|
||||
# before any updates are applied. When we call the save
|
||||
# methods on nested objects, we will lose any changes to
|
||||
# them. But we need to make sure child cells can tell
|
||||
# what is changed.
|
||||
#
|
||||
# We also need to nuke any updates to vm_state and task_state
|
||||
# unless admin_state_reset is True. compute cells are
|
||||
# authoritative for their view of vm_state and task_state.
|
||||
stale_instance = self.obj_clone()
|
||||
|
||||
def _handle_cell_update_from_api():
|
||||
cells_api = cells_rpcapi.CellsAPI()
|
||||
cells_api.instance_update_from_api(context, stale_instance,
|
||||
expected_vm_state,
|
||||
expected_task_state,
|
||||
admin_state_reset)
|
||||
else:
|
||||
stale_instance = None
|
||||
|
||||
updates = {}
|
||||
changes = self.obj_what_changed()
|
||||
for field in self.fields:
|
||||
if (self.obj_attr_is_set(field) and
|
||||
isinstance(self[field], base.NovaObject)):
|
||||
try:
|
||||
getattr(self, '_save_%s' % field)(context)
|
||||
except AttributeError:
|
||||
LOG.exception(_LE('No save handler for %s'), field,
|
||||
instance=self)
|
||||
elif field in changes:
|
||||
updates[field] = self[field]
|
||||
|
||||
if not updates:
|
||||
if stale_instance:
|
||||
_handle_cell_update_from_api()
|
||||
return
|
||||
|
||||
# Cleaned needs to be turned back into an int here
|
||||
if 'cleaned' in updates:
|
||||
if updates['cleaned']:
|
||||
updates['cleaned'] = 1
|
||||
else:
|
||||
updates['cleaned'] = 0
|
||||
|
||||
if expected_task_state is not None:
|
||||
if (self.VERSION == '1.9' and
|
||||
expected_task_state == 'image_snapshot'):
|
||||
# NOTE(danms): Icehouse introduced a pending state which
|
||||
# Havana doesn't know about. If we're an old instance,
|
||||
# tolerate the pending state as well
|
||||
expected_task_state = [
|
||||
expected_task_state, 'image_snapshot_pending']
|
||||
updates['expected_task_state'] = expected_task_state
|
||||
if expected_vm_state is not None:
|
||||
updates['expected_vm_state'] = expected_vm_state
|
||||
|
||||
expected_attrs = [attr for attr in _INSTANCE_OPTIONAL_JOINED_FIELDS
|
||||
if self.obj_attr_is_set(attr)]
|
||||
if 'pci_devices' in expected_attrs:
|
||||
# NOTE(danms): We don't refresh pci_devices on save right now
|
||||
expected_attrs.remove('pci_devices')
|
||||
|
||||
# NOTE(alaski): We need to pull system_metadata for the
|
||||
# notification.send_update() below. If we don't there's a KeyError
|
||||
# when it tries to extract the flavor.
|
||||
if 'system_metadata' not in expected_attrs:
|
||||
expected_attrs.append('system_metadata')
|
||||
old_ref, inst_ref = db.instance_update_and_get_original(
|
||||
context, self.uuid, updates, update_cells=False,
|
||||
columns_to_join=_expected_cols(expected_attrs))
|
||||
|
||||
if stale_instance:
|
||||
_handle_cell_update_from_api()
|
||||
elif cell_type == 'compute':
|
||||
cells_api = cells_rpcapi.CellsAPI()
|
||||
cells_api.instance_update_at_top(context, inst_ref)
|
||||
|
||||
self._from_db_object(context, self, inst_ref,
|
||||
expected_attrs=expected_attrs)
|
||||
notifications.send_update(context, old_ref, inst_ref)
|
||||
self.obj_reset_changes()
|
||||
|
||||
@base.remotable
|
||||
def refresh(self, context, use_slave=False):
|
||||
extra = [field for field in INSTANCE_OPTIONAL_ATTRS
|
||||
if self.obj_attr_is_set(field)]
|
||||
current = self.__class__.get_by_uuid(context, uuid=self.uuid,
|
||||
expected_attrs=extra,
|
||||
use_slave=use_slave)
|
||||
# NOTE(danms): We orphan the instance copy so we do not unexpectedly
|
||||
# trigger a lazy-load (which would mean we failed to calculate the
|
||||
# expected_attrs properly)
|
||||
current._context = None
|
||||
|
||||
for field in self.fields:
|
||||
if self.obj_attr_is_set(field):
|
||||
if field == 'info_cache':
|
||||
self.info_cache.refresh()
|
||||
# NOTE(danms): Make sure this shows up as touched
|
||||
self.info_cache = self.info_cache
|
||||
elif self[field] != current[field]:
|
||||
self[field] = current[field]
|
||||
self.obj_reset_changes()
|
||||
|
||||
def _load_generic(self, attrname):
|
||||
instance = self.__class__.get_by_uuid(self._context,
|
||||
uuid=self.uuid,
|
||||
expected_attrs=[attrname])
|
||||
|
||||
# NOTE(danms): Never allow us to recursively-load
|
||||
if instance.obj_attr_is_set(attrname):
|
||||
self[attrname] = instance[attrname]
|
||||
else:
|
||||
raise exception.ObjectActionError(
|
||||
action='obj_load_attr',
|
||||
reason='loading %s requires recursion' % attrname)
|
||||
|
||||
def _load_fault(self):
|
||||
self.fault = objects.InstanceFault.get_latest_for_instance(
|
||||
self._context, self.uuid)
|
||||
|
||||
def _load_numa_topology(self):
|
||||
try:
|
||||
self.numa_topology = \
|
||||
objects.InstanceNUMATopology.get_by_instance_uuid(
|
||||
self._context, self.uuid)
|
||||
except exception.NumaTopologyNotFound:
|
||||
self.numa_topology = None
|
||||
|
||||
def obj_load_attr(self, attrname):
|
||||
if attrname not in INSTANCE_OPTIONAL_ATTRS:
|
||||
raise exception.ObjectActionError(
|
||||
action='obj_load_attr',
|
||||
reason='attribute %s not lazy-loadable' % attrname)
|
||||
if not self._context:
|
||||
raise exception.OrphanedObjectError(method='obj_load_attr',
|
||||
objtype=self.obj_name())
|
||||
|
||||
LOG.debug("Lazy-loading `%(attr)s' on %(name)s uuid %(uuid)s",
|
||||
{'attr': attrname,
|
||||
'name': self.obj_name(),
|
||||
'uuid': self.uuid,
|
||||
})
|
||||
# FIXME(comstud): This should be optimized to only load the attr.
|
||||
if attrname == 'fault':
|
||||
# NOTE(danms): We handle fault differently here so that we
|
||||
# can be more efficient
|
||||
self._load_fault()
|
||||
elif attrname == 'numa_topology':
|
||||
self._load_numa_topology()
|
||||
else:
|
||||
self._load_generic(attrname)
|
||||
self.obj_reset_changes([attrname])
|
||||
|
||||
def get_flavor(self, namespace=None):
|
||||
prefix = ('%s_' % namespace) if namespace is not None else ''
|
||||
|
||||
db_flavor = flavors.extract_flavor(self, prefix)
|
||||
flavor = objects.Flavor(self._context)
|
||||
for key in flavors.system_metadata_flavor_props:
|
||||
flavor[key] = db_flavor[key]
|
||||
return flavor
|
||||
|
||||
def set_flavor(self, flavor, namespace=None):
|
||||
prefix = ('%s_' % namespace) if namespace is not None else ''
|
||||
|
||||
self.system_metadata = flavors.save_flavor_info(
|
||||
self.system_metadata, flavor, prefix)
|
||||
self.save()
|
||||
|
||||
def delete_flavor(self, namespace):
|
||||
self.system_metadata = flavors.delete_flavor_info(
|
||||
self.system_metadata, "%s_" % namespace)
|
||||
self.save()
|
||||
|
||||
@base.remotable
|
||||
def delete_metadata_key(self, context, key):
|
||||
"""Optimized metadata delete method.
|
||||
|
||||
This provides a more efficient way to delete a single metadata
|
||||
key, instead of just calling instance.save(). This should be called
|
||||
with the key still present in self.metadata, which it will update
|
||||
after completion.
|
||||
"""
|
||||
db.instance_metadata_delete(context, self.uuid, key)
|
||||
md_was_changed = 'metadata' in self.obj_what_changed()
|
||||
del self.metadata[key]
|
||||
self._orig_metadata.pop(key, None)
|
||||
instance_dict = base.obj_to_primitive(self)
|
||||
notifications.send_update(context, instance_dict, instance_dict)
|
||||
if not md_was_changed:
|
||||
self.obj_reset_changes(['metadata'])
|
||||
|
||||
|
||||
def _make_instance_list(context, inst_list, db_inst_list, expected_attrs):
|
||||
get_fault = expected_attrs and 'fault' in expected_attrs
|
||||
inst_faults = {}
|
||||
if get_fault:
|
||||
# Build an instance_uuid:latest-fault mapping
|
||||
expected_attrs.remove('fault')
|
||||
instance_uuids = [inst['uuid'] for inst in db_inst_list]
|
||||
faults = objects.InstanceFaultList.get_by_instance_uuids(
|
||||
context, instance_uuids)
|
||||
for fault in faults:
|
||||
if fault.instance_uuid not in inst_faults:
|
||||
inst_faults[fault.instance_uuid] = fault
|
||||
|
||||
inst_list.objects = []
|
||||
for db_inst in db_inst_list:
|
||||
inst_obj = objects.Instance._from_db_object(
|
||||
context, objects.Instance(context), db_inst,
|
||||
expected_attrs=expected_attrs)
|
||||
if get_fault:
|
||||
inst_obj.fault = inst_faults.get(inst_obj.uuid, None)
|
||||
inst_list.objects.append(inst_obj)
|
||||
inst_list.obj_reset_changes()
|
||||
return inst_list
|
||||
|
||||
|
||||
class InstanceList(base.ObjectListBase, base.NovaObject):
|
||||
# Version 1.0: Initial version
|
||||
# Version 1.1: Added use_slave to get_by_host
|
||||
# Instance <= version 1.9
|
||||
# Version 1.2: Instance <= version 1.11
|
||||
# Version 1.3: Added use_slave to get_by_filters
|
||||
# Version 1.4: Instance <= version 1.12
|
||||
# Version 1.5: Added method get_active_by_window_joined.
|
||||
# Version 1.6: Instance <= version 1.13
|
||||
# Version 1.7: Added use_slave to get_active_by_window_joined
|
||||
# Version 1.8: Instance <= version 1.14
|
||||
# Version 1.9: Instance <= version 1.15
|
||||
VERSION = '1.9'
|
||||
|
||||
fields = {
|
||||
'objects': fields.ListOfObjectsField('Instance'),
|
||||
}
|
||||
child_versions = {
|
||||
'1.1': '1.9',
|
||||
# NOTE(danms): Instance was at 1.9 before we added this
|
||||
'1.2': '1.11',
|
||||
'1.3': '1.11',
|
||||
'1.4': '1.12',
|
||||
'1.5': '1.12',
|
||||
'1.6': '1.13',
|
||||
'1.7': '1.13',
|
||||
'1.8': '1.14',
|
||||
'1.9': '1.15',
|
||||
}
|
||||
|
||||
@base.remotable_classmethod
|
||||
def get_by_filters(cls, context, filters,
|
||||
sort_key='created_at', sort_dir='desc', limit=None,
|
||||
marker=None, expected_attrs=None, use_slave=False):
|
||||
db_inst_list = db.instance_get_all_by_filters(
|
||||
context, filters, sort_key, sort_dir, limit=limit, marker=marker,
|
||||
columns_to_join=_expected_cols(expected_attrs),
|
||||
use_slave=use_slave)
|
||||
return _make_instance_list(context, cls(), db_inst_list,
|
||||
expected_attrs)
|
||||
|
||||
@base.remotable_classmethod
|
||||
def get_by_host(cls, context, host, expected_attrs=None, use_slave=False):
|
||||
db_inst_list = db.instance_get_all_by_host(
|
||||
context, host, columns_to_join=_expected_cols(expected_attrs),
|
||||
use_slave=use_slave)
|
||||
return _make_instance_list(context, cls(), db_inst_list,
|
||||
expected_attrs)
|
||||
|
||||
@base.remotable_classmethod
|
||||
def get_by_host_and_node(cls, context, host, node, expected_attrs=None):
|
||||
db_inst_list = db.instance_get_all_by_host_and_node(
|
||||
context, host, node)
|
||||
return _make_instance_list(context, cls(), db_inst_list,
|
||||
expected_attrs)
|
||||
|
||||
@base.remotable_classmethod
|
||||
def get_by_host_and_not_type(cls, context, host, type_id=None,
|
||||
expected_attrs=None):
|
||||
db_inst_list = db.instance_get_all_by_host_and_not_type(
|
||||
context, host, type_id=type_id)
|
||||
return _make_instance_list(context, cls(), db_inst_list,
|
||||
expected_attrs)
|
||||
|
||||
@base.remotable_classmethod
|
||||
def get_hung_in_rebooting(cls, context, reboot_window,
|
||||
expected_attrs=None):
|
||||
db_inst_list = db.instance_get_all_hung_in_rebooting(context,
|
||||
reboot_window)
|
||||
return _make_instance_list(context, cls(), db_inst_list,
|
||||
expected_attrs)
|
||||
|
||||
@base.remotable_classmethod
|
||||
def _get_active_by_window_joined(cls, context, begin, end=None,
|
||||
project_id=None, host=None,
|
||||
expected_attrs=None,
|
||||
use_slave=False):
|
||||
# NOTE(mriedem): We need to convert the begin/end timestamp strings
|
||||
# to timezone-aware datetime objects for the DB API call.
|
||||
begin = timeutils.parse_isotime(begin)
|
||||
end = timeutils.parse_isotime(end) if end else None
|
||||
db_inst_list = db.instance_get_active_by_window_joined(context,
|
||||
begin,
|
||||
end,
|
||||
project_id,
|
||||
host)
|
||||
return _make_instance_list(context, cls(), db_inst_list,
|
||||
expected_attrs)
|
||||
|
||||
@classmethod
|
||||
def get_active_by_window_joined(cls, context, begin, end=None,
|
||||
project_id=None, host=None,
|
||||
expected_attrs=None,
|
||||
use_slave=False):
|
||||
"""Get instances and joins active during a certain time window.
|
||||
|
||||
:param:context: nova request context
|
||||
:param:begin: datetime for the start of the time window
|
||||
:param:end: datetime for the end of the time window
|
||||
:param:project_id: used to filter instances by project
|
||||
:param:host: used to filter instances on a given compute host
|
||||
:param:expected_attrs: list of related fields that can be joined
|
||||
in the database layer when querying for instances
|
||||
:param use_slave if True, ship this query off to a DB slave
|
||||
:returns: InstanceList
|
||||
|
||||
"""
|
||||
# NOTE(mriedem): We have to convert the datetime objects to string
|
||||
# primitives for the remote call.
|
||||
begin = timeutils.isotime(begin)
|
||||
end = timeutils.isotime(end) if end else None
|
||||
return cls._get_active_by_window_joined(context, begin, end,
|
||||
project_id, host,
|
||||
expected_attrs,
|
||||
use_slave=use_slave)
|
||||
|
||||
@base.remotable_classmethod
|
||||
def get_by_security_group_id(cls, context, security_group_id):
|
||||
db_secgroup = db.security_group_get(
|
||||
context, security_group_id,
|
||||
columns_to_join=['instances.info_cache',
|
||||
'instances.system_metadata'])
|
||||
return _make_instance_list(context, cls(), db_secgroup['instances'],
|
||||
['info_cache', 'system_metadata'])
|
||||
|
||||
@classmethod
|
||||
def get_by_security_group(cls, context, security_group):
|
||||
return cls.get_by_security_group_id(context, security_group.id)
|
||||
|
||||
def fill_faults(self):
|
||||
"""Batch query the database for our instances' faults.
|
||||
|
||||
:returns: A list of instance uuids for which faults were found.
|
||||
"""
|
||||
uuids = [inst.uuid for inst in self]
|
||||
faults = objects.InstanceFaultList.get_by_instance_uuids(
|
||||
self._context, uuids)
|
||||
faults_by_uuid = {}
|
||||
for fault in faults:
|
||||
if fault.instance_uuid not in faults_by_uuid:
|
||||
faults_by_uuid[fault.instance_uuid] = fault
|
||||
|
||||
for instance in self:
|
||||
if instance.uuid in faults_by_uuid:
|
||||
instance.fault = faults_by_uuid[instance.uuid]
|
||||
else:
|
||||
# NOTE(danms): Otherwise the caller will cause a lazy-load
|
||||
# when checking it, and we know there are none
|
||||
instance.fault = None
|
||||
instance.obj_reset_changes(['fault'])
|
||||
|
||||
return faults_by_uuid.keys()
|
Loading…
Reference in New Issue