From fc82c6dbbd0fa1cdc130cefea534967e273d5570 Mon Sep 17 00:00:00 2001 From: Michael Still Date: Wed, 4 Jul 2012 14:42:08 +1000 Subject: Convert fixed_ips to using instance_uuid. This should be the second last blueprint finish-uuid-conversion change. Change-Id: Idd47c5ed3c30af24d60eb23b8e3881d61b4c7976 --- bin/nova-manage | 17 ++-- nova/api/metadata/base.py | 2 +- nova/api/openstack/compute/contrib/floating_ips.py | 8 +- nova/db/api.py | 17 ++-- nova/db/sqlalchemy/api.py | 60 +++++++----- .../migrate_repo/versions/106_add_foreign_keys.py | 2 +- .../versions/113_fixed_ips_uses_uuid.py | 108 +++++++++++++++++++++ .../migrate_repo/versions/113_sqlite_downgrade.sql | 85 ++++++++++++++++ .../migrate_repo/versions/113_sqlite_upgrade.sql | 85 ++++++++++++++++ nova/db/sqlalchemy/models.py | 2 +- nova/exception.py | 9 +- nova/network/manager.py | 93 +++++++++++------- nova/network/quantum/manager.py | 2 +- nova/network/quantum/nova_ipam_lib.py | 3 +- .../openstack/compute/contrib/test_floating_ips.py | 4 +- nova/tests/compute/test_compute.py | 2 +- nova/tests/network/test_manager.py | 82 ++++++++-------- nova/tests/network/test_quantum.py | 6 +- nova/tests/test_db_api.py | 26 ++--- 19 files changed, 467 insertions(+), 146 deletions(-) create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/113_fixed_ips_uses_uuid.py create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/113_sqlite_downgrade.sql create mode 100644 nova/db/sqlalchemy/migrate_repo/versions/113_sqlite_upgrade.sql diff --git a/bin/nova-manage b/bin/nova-manage index da9d375e4..776dc836b 100755 --- a/bin/nova-manage +++ b/bin/nova-manage @@ -274,9 +274,9 @@ class FixedIpCommands(object): sys.exit(2) instances = db.instance_get_all(context.get_admin_context()) - instances_by_id = {} + instances_by_uuid = {} for instance in instances: - instances_by_id[instance['id']] = instance + instances_by_uuid[instance['uuid']] = instance print "%-18s\t%-15s\t%-15s\t%s" % (_('network'), _('IP address'), @@ -304,8 +304,8 @@ class FixedIpCommands(object): network = all_networks.get(fixed_ip['network_id']) if network: has_ip = True - if fixed_ip.get('instance_id'): - instance = instances_by_id.get(fixed_ip['instance_id']) + if fixed_ip.get('instance_uuid'): + instance = instances_by_uuid.get(fixed_ip['instance_uuid']) if instance: hostname = instance['hostname'] host = instance['host'] @@ -414,16 +414,11 @@ class FloatingIpCommands(object): instance_id = None if floating_ip['fixed_ip_id']: fixed_ip = db.fixed_ip_get(ctxt, floating_ip['fixed_ip_id']) - try: - instance = db.instance_get(ctxt, fixed_ip['instance_id']) - instance_id = instance.get('uuid', "none") - except exception.InstanceNotFound: - msg = _('Missing instance %s') - instance_id = msg % fixed_ip['instance_id'] + instance_uuid = fixed_ip['instance_uuid'] print "%s\t%s\t%s\t%s\t%s" % (floating_ip['project_id'], floating_ip['address'], - instance_id, + instance_uuid, floating_ip['pool'], floating_ip['interface']) diff --git a/nova/api/metadata/base.py b/nova/api/metadata/base.py index 4ecf64649..2964d57f1 100644 --- a/nova/api/metadata/base.py +++ b/nova/api/metadata/base.py @@ -214,7 +214,7 @@ def get_metadata_by_address(address): ctxt = context.get_admin_context() fixed_ip = network.API().get_fixed_ip_by_address(ctxt, address) - instance = db.instance_get(ctxt, fixed_ip['instance_id']) + instance = db.instance_get_by_uuid(ctxt, fixed_ip['instance_uuid']) return InstanceMetadata(instance, address) diff --git a/nova/api/openstack/compute/contrib/floating_ips.py b/nova/api/openstack/compute/contrib/floating_ips.py index 4b290bb4c..6fb9f0cc1 100644 --- a/nova/api/openstack/compute/contrib/floating_ips.py +++ b/nova/api/openstack/compute/contrib/floating_ips.py @@ -120,13 +120,13 @@ class FloatingIPController(object): fixed_ip_id = floating_ip['fixed_ip_id'] floating_ip['fixed_ip'] = self._get_fixed_ip(context, fixed_ip_id) - instance_id = None + instance_uuid = None if floating_ip['fixed_ip']: - instance_id = floating_ip['fixed_ip']['instance_id'] + instance_uuid = floating_ip['fixed_ip']['instance_uuid'] - if instance_id: + if instance_uuid: floating_ip['instance'] = self._get_instance(context, - instance_id) + instance_uuid) else: floating_ip['instance'] = None diff --git a/nova/db/api.py b/nova/db/api.py index 231df02f2..cf87e672c 100644 --- a/nova/db/api.py +++ b/nova/db/api.py @@ -418,25 +418,26 @@ def migration_get_all_unconfirmed(context, confirm_window): #################### -def fixed_ip_associate(context, address, instance_id, network_id=None, +def fixed_ip_associate(context, address, instance_uuid, network_id=None, reserved=False): """Associate fixed ip to instance. Raises if fixed ip is not available. """ - return IMPL.fixed_ip_associate(context, address, instance_id, network_id, + return IMPL.fixed_ip_associate(context, address, instance_uuid, network_id, reserved) -def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None): +def fixed_ip_associate_pool(context, network_id, instance_uuid=None, + host=None): """Find free ip in network and associate it to instance or host. Raises if one is not available. """ return IMPL.fixed_ip_associate_pool(context, network_id, - instance_id, host) + instance_uuid, host) def fixed_ip_create(context, values): @@ -474,14 +475,14 @@ def fixed_ip_get_by_address(context, address): return IMPL.fixed_ip_get_by_address(context, address) -def fixed_ip_get_by_instance(context, instance_id): +def fixed_ip_get_by_instance(context, instance_uuid): """Get fixed ips by instance or raise if none exist.""" - return IMPL.fixed_ip_get_by_instance(context, instance_id) + return IMPL.fixed_ip_get_by_instance(context, instance_uuid) -def fixed_ip_get_by_network_host(context, network_id, host): +def fixed_ip_get_by_network_host(context, network_uuid, host): """Get fixed ip for a host in a network.""" - return IMPL.fixed_ip_get_by_network_host(context, network_id, host) + return IMPL.fixed_ip_get_by_network_host(context, network_uuid, host) def fixed_ips_by_virtual_interface(context, vif_id): diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py index 6d002b5db..ac56e5983 100644 --- a/nova/db/sqlalchemy/api.py +++ b/nova/db/sqlalchemy/api.py @@ -993,12 +993,15 @@ def dnsdomain_list(context): @require_admin_context -def fixed_ip_associate(context, address, instance_id, network_id=None, +def fixed_ip_associate(context, address, instance_uuid, network_id=None, reserved=False): """Keyword arguments: reserved -- should be a boolean value(True or False), exact value will be used to filter on the fixed ip address """ + if not utils.is_uuid_like(instance_uuid): + raise exception.InvalidUUID(uuid=instance_uuid) + session = get_session() with session.begin(): network_or_none = or_(models.FixedIp.network_id == network_id, @@ -1015,18 +1018,22 @@ def fixed_ip_associate(context, address, instance_id, network_id=None, if fixed_ip_ref is None: raise exception.FixedIpNotFoundForNetwork(address=address, network_id=network_id) - if fixed_ip_ref.instance_id: + if fixed_ip_ref.instance_uuid: raise exception.FixedIpAlreadyInUse(address=address) if not fixed_ip_ref.network_id: fixed_ip_ref.network_id = network_id - fixed_ip_ref.instance_id = instance_id + fixed_ip_ref.instance_uuid = instance_uuid session.add(fixed_ip_ref) return fixed_ip_ref['address'] @require_admin_context -def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None): +def fixed_ip_associate_pool(context, network_id, instance_uuid=None, + host=None): + if not utils.is_uuid_like(instance_uuid): + raise exception.InvalidUUID(uuid=instance_uuid) + session = get_session() with session.begin(): network_or_none = or_(models.FixedIp.network_id == network_id, @@ -1035,7 +1042,7 @@ def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None): read_deleted="no").\ filter(network_or_none).\ filter_by(reserved=False).\ - filter_by(instance_id=None).\ + filter_by(instance_uuid=None).\ filter_by(host=None).\ with_lockmode('update').\ first() @@ -1047,8 +1054,8 @@ def fixed_ip_associate_pool(context, network_id, instance_id=None, host=None): if fixed_ip_ref['network_id'] is None: fixed_ip_ref['network'] = network_id - if instance_id: - fixed_ip_ref['instance_id'] = instance_id + if instance_uuid: + fixed_ip_ref['instance_uuid'] = instance_uuid if host: fixed_ip_ref['host'] = host @@ -1081,7 +1088,7 @@ def fixed_ip_disassociate(context, address): fixed_ip_ref = fixed_ip_get_by_address(context, address, session=session) - fixed_ip_ref['instance_id'] = None + fixed_ip_ref['instance_uuid'] = None fixed_ip_ref.save(session=session) @@ -1102,7 +1109,8 @@ def fixed_ip_disassociate_all_by_timeout(context, host, time): join((models.Network, models.Network.id == models.FixedIp.network_id)).\ join((models.Instance, - models.Instance.id == models.FixedIp.instance_id)).\ + models.Instance.uuid == \ + models.FixedIp.instance_uuid)).\ filter(host_filter).\ all() fixed_ip_ids = [fip[0] for fip in result] @@ -1110,7 +1118,7 @@ def fixed_ip_disassociate_all_by_timeout(context, host, time): return 0 result = model_query(context, models.FixedIp, session=session).\ filter(models.FixedIp.id.in_(fixed_ip_ids)).\ - update({'instance_id': None, + update({'instance_uuid': None, 'leased': False, 'updated_at': timeutils.utcnow()}, synchronize_session='fetch') @@ -1127,8 +1135,9 @@ def fixed_ip_get(context, id, session=None): # FIXME(sirp): shouldn't we just use project_only here to restrict the # results? - if is_user_context(context) and result['instance_id'] is not None: - instance = instance_get(context, result['instance_id'], session) + if is_user_context(context) and result['instance_uuid'] is not None: + instance = instance_get_by_uuid(context, result['instance_uuid'], + session) authorize_project_context(context, instance.project_id) return result @@ -1155,21 +1164,25 @@ def fixed_ip_get_by_address(context, address, session=None): # NOTE(sirp): shouldn't we just use project_only here to restrict the # results? - if is_user_context(context) and result['instance_id'] is not None: - instance = instance_get(context, result['instance_id'], session) + if is_user_context(context) and result['instance_uuid'] is not None: + instance = instance_get_by_uuid(context, result['instance_uuid'], + session) authorize_project_context(context, instance.project_id) return result @require_context -def fixed_ip_get_by_instance(context, instance_id): +def fixed_ip_get_by_instance(context, instance_uuid): + if not utils.is_uuid_like(instance_uuid): + raise exception.InvalidUUID(uuid=instance_uuid) + result = model_query(context, models.FixedIp, read_deleted="no").\ - filter_by(instance_id=instance_id).\ + filter_by(instance_uuid=instance_uuid).\ all() if not result: - raise exception.FixedIpNotFoundForInstance(instance_id=instance_id) + raise exception.FixedIpNotFoundForInstance(instance_uuid=instance_uuid) return result @@ -1671,9 +1684,12 @@ def instance_get_all_by_reservation(context, reservation_id): # go away @require_context def instance_get_floating_address(context, instance_id): - fixed_ips = fixed_ip_get_by_instance(context, instance_id) + instance = instance_get(context, instance_id) + fixed_ips = fixed_ip_get_by_instance(context, instance['uuid']) + if not fixed_ips: return None + # NOTE(tr3buchet): this only gets the first fixed_ip # won't find floating ips associated with other fixed_ips floating_ips = floating_ip_get_by_fixed_address(context, @@ -2136,11 +2152,11 @@ def network_get_associated_fixed_ips(context, network_id, host=None): vif_and = and_(models.VirtualInterface.id == models.FixedIp.virtual_interface_id, models.VirtualInterface.deleted == False) - inst_and = and_(models.Instance.id == models.FixedIp.instance_id, + inst_and = and_(models.Instance.uuid == models.FixedIp.instance_uuid, models.Instance.deleted == False) session = get_session() query = session.query(models.FixedIp.address, - models.FixedIp.instance_id, + models.FixedIp.instance_uuid, models.FixedIp.network_id, models.FixedIp.virtual_interface_id, models.VirtualInterface.address, @@ -2152,7 +2168,7 @@ def network_get_associated_fixed_ips(context, network_id, host=None): filter(models.FixedIp.allocated == True).\ join((models.VirtualInterface, vif_and)).\ join((models.Instance, inst_and)).\ - filter(models.FixedIp.instance_id != None).\ + filter(models.FixedIp.instance_uuid != None).\ filter(models.FixedIp.virtual_interface_id != None) if host: query = query.filter(models.Instance.host == host) @@ -2161,7 +2177,7 @@ def network_get_associated_fixed_ips(context, network_id, host=None): for datum in result: cleaned = {} cleaned['address'] = datum[0] - cleaned['instance_id'] = datum[1] + cleaned['instance_uuid'] = datum[1] cleaned['network_id'] = datum[2] cleaned['vif_id'] = datum[3] cleaned['vif_address'] = datum[4] diff --git a/nova/db/sqlalchemy/migrate_repo/versions/106_add_foreign_keys.py b/nova/db/sqlalchemy/migrate_repo/versions/106_add_foreign_keys.py index 8d867609c..2874b4042 100644 --- a/nova/db/sqlalchemy/migrate_repo/versions/106_add_foreign_keys.py +++ b/nova/db/sqlalchemy/migrate_repo/versions/106_add_foreign_keys.py @@ -64,5 +64,5 @@ def downgrade(migrate_engine): columns=[t.c.instance_uuid], refcolumns=[instances.c.uuid]).drop() except Exception: - LOG.error(_("foreign key constraint couldn't be created")) + LOG.error(_("foreign key constraint couldn't be dropped")) raise diff --git a/nova/db/sqlalchemy/migrate_repo/versions/113_fixed_ips_uses_uuid.py b/nova/db/sqlalchemy/migrate_repo/versions/113_fixed_ips_uses_uuid.py new file mode 100644 index 000000000..d51bbb912 --- /dev/null +++ b/nova/db/sqlalchemy/migrate_repo/versions/113_fixed_ips_uses_uuid.py @@ -0,0 +1,108 @@ +# vim: tabstop=4 shiftwidth=4 softtabstop=4 + +# Copyright 2011 OpenStack LLC. +# Copyright 2012 Michael Still and Canonical Inc +# All Rights Reserved. +# +# 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 migrate import ForeignKeyConstraint +from sqlalchemy import MetaData, String, Table +from sqlalchemy import select, Column, ForeignKey, Integer + +from nova.openstack.common import log as logging + + +LOG = logging.getLogger(__name__) + + +def upgrade(migrate_engine): + meta = MetaData() + meta.bind = migrate_engine + fixed_ips = Table('fixed_ips', meta, autoload=True) + instances = Table('instances', meta, autoload=True) + uuid_column = Column('instance_uuid', String(36)) + uuid_column.create(fixed_ips) + + try: + fixed_ips.update().values( + instance_uuid=select( + [instances.c.uuid], + instances.c.id == fixed_ips.c.instance_id) + ).execute() + except Exception: + uuid_column.drop() + raise + + fkeys = list(fixed_ips.c.instance_id.foreign_keys) + if fkeys: + try: + fkey_name = fkeys[0].constraint.name + ForeignKeyConstraint( + columns=[fixed_ips.c.instance_id], + refcolumns=[instances.c.id], + name=fkey_name).drop() + except Exception: + LOG.error(_("foreign key constraint couldn't be removed")) + raise + + fixed_ips.c.instance_id.drop() + + try: + ForeignKeyConstraint( + columns=[fixed_ips.c.instance_uuid], + refcolumns=[instances.c.uuid]).create() + except Exception: + LOG.error(_("foreign key constraint couldn't be created")) + raise + + +def downgrade(migrate_engine): + meta = MetaData() + meta.bind = migrate_engine + fixed_ips = Table('fixed_ips', meta, autoload=True) + instances = Table('instances', meta, autoload=True) + id_column = Column('instance_id', Integer, ForeignKey('instances.id')) + id_column.create(fixed_ips) + + fkeys = list(fixed_ips.c.instance_uuid.foreign_keys) + if fkeys: + try: + fkey_name = fkeys[0].constraint.name + ForeignKeyConstraint( + columns=[fixed_ips.c.instance_uuid], + refcolumns=[instances.c.uuid], + name=fkey_name).drop() + except Exception: + LOG.error(_("foreign key constraint couldn't be removed")) + raise + + try: + fixed_ips.update().values( + instance_id=select( + [instances.c.id], + instances.c.uuid == fixed_ips.c.instance_uuid) + ).execute() + except Exception: + id_column.drop() + raise + + fixed_ips.c.instance_uuid.drop() + + try: + ForeignKeyConstraint( + columns=[fixed_ips.c.instance_id], + refcolumns=[instances.c.id]).create() + except Exception: + LOG.error(_("foreign key constraint couldn't be created")) + raise diff --git a/nova/db/sqlalchemy/migrate_repo/versions/113_sqlite_downgrade.sql b/nova/db/sqlalchemy/migrate_repo/versions/113_sqlite_downgrade.sql new file mode 100644 index 000000000..0a7a7bed9 --- /dev/null +++ b/nova/db/sqlalchemy/migrate_repo/versions/113_sqlite_downgrade.sql @@ -0,0 +1,85 @@ +BEGIN TRANSACTION; + CREATE TEMPORARY TABLE fixed_ips_backup ( + created_at DATETIME, + updated_at DATETIME, + deleted_at DATETIME, + deleted BOOLEAN, + id INTEGER NOT NULL, + address VARCHAR(255), + network_id INTEGER, + instance_id INTEGER NOT NULL, + instance_uuid VARCHAR(36), + allocated BOOLEAN, + leased BOOLEAN, + reserved BOOLEAN, + virtual_interface_id INTEGER, + host VARCHAR(255), + PRIMARY KEY (id) + ); + + INSERT INTO fixed_ips_backup + SELECT created_at, + updated_at, + deleted_at, + deleted, + id, + address, + network_id, + NULL, + instance_uuid, + allocated, + leased, + reserved, + virtual_interface_id, + host + FROM fixed_ips; + + UPDATE fixed_ips_backup + SET instance_id= + (SELECT id + FROM instances + WHERE fixed_ips_backup.instance_uuid = instances.uuid + ); + + DROP TABLE fixed_ips; + + CREATE TABLE fixed_ips ( + created_at DATETIME, + updated_at DATETIME, + deleted_at DATETIME, + deleted BOOLEAN, + id INTEGER NOT NULL, + address VARCHAR(255), + network_id INTEGER, + instance_id INTEGER, + allocated BOOLEAN, + leased BOOLEAN, + reserved BOOLEAN, + virtual_interface_id INTEGER, + host VARCHAR(255), + PRIMARY KEY (id), + FOREIGN KEY(instance_id) REFERENCES instances (id) + ); + + CREATE INDEX fixed_ips_id ON fixed_ips(id); + CREATE INDEX address ON fixed_ips(address); + + INSERT INTO fixed_ips + SELECT created_at, + updated_at, + deleted_at, + deleted, + id, + address, + network_id, + instance_id, + allocated, + leased, + reserved, + virtual_interface_id, + host + FROM fixed_ips_backup; + + DROP TABLE fixed_ips_backup; + +COMMIT; \ No newline at end of file diff --git a/nova/db/sqlalchemy/migrate_repo/versions/113_sqlite_upgrade.sql b/nova/db/sqlalchemy/migrate_repo/versions/113_sqlite_upgrade.sql new file mode 100644 index 000000000..417b5bfe3 --- /dev/null +++ b/nova/db/sqlalchemy/migrate_repo/versions/113_sqlite_upgrade.sql @@ -0,0 +1,85 @@ +BEGIN TRANSACTION; + CREATE TEMPORARY TABLE fixed_ips_backup ( + created_at DATETIME, + updated_at DATETIME, + deleted_at DATETIME, + deleted BOOLEAN, + id INTEGER NOT NULL, + address VARCHAR(255), + network_id INTEGER, + instance_id INTEGER NOT NULL, + instance_uuid VARCHAR(36), + allocated BOOLEAN, + leased BOOLEAN, + reserved BOOLEAN, + virtual_interface_id INTEGER, + host VARCHAR(255), + PRIMARY KEY (id) + ); + + INSERT INTO fixed_ips_backup + SELECT created_at, + updated_at, + deleted_at, + deleted, + id, + address, + network_id, + instance_id, + NULL, + allocated, + leased, + reserved, + virtual_interface_id, + host + FROM fixed_ips; + + UPDATE fixed_ips_backup + SET instance_uuid= + (SELECT uuid + FROM instances + WHERE fixed_ips_backup.instance_id = instances.id + ); + + DROP TABLE fixed_ips; + + CREATE TABLE fixed_ips ( + created_at DATETIME, + updated_at DATETIME, + deleted_at DATETIME, + deleted BOOLEAN, + id INTEGER NOT NULL, + address VARCHAR(255), + network_id INTEGER, + instance_uuid VARCHAR(36), + allocated BOOLEAN, + leased BOOLEAN, + reserved BOOLEAN, + virtual_interface_id INTEGER, + host VARCHAR(255), + PRIMARY KEY (id), + FOREIGN KEY(instance_uuid) REFERENCES instances (uuid) + ); + + CREATE INDEX fixed_ips_id ON fixed_ips(id); + CREATE INDEX address ON fixed_ips(address); + + INSERT INTO fixed_ips + SELECT created_at, + updated_at, + deleted_at, + deleted, + id, + address, + network_id, + instance_uuid, + allocated, + leased, + reserved, + virtual_interface_id, + host + FROM fixed_ips_backup; + + DROP TABLE fixed_ips_backup; + +COMMIT; diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py index 5f7e85511..21644ce18 100644 --- a/nova/db/sqlalchemy/models.py +++ b/nova/db/sqlalchemy/models.py @@ -717,7 +717,7 @@ class FixedIp(BASE, NovaBase): address = Column(String(255)) network_id = Column(Integer, nullable=True) virtual_interface_id = Column(Integer, nullable=True) - instance_id = Column(Integer, nullable=True) + instance_uuid = Column(String(36), nullable=True) # associated means that a fixed_ip has its instance_id column set # allocated means that a fixed_ip has its virtual_interface_id column set allocated = Column(Boolean, default=False) diff --git a/nova/exception.py b/nova/exception.py index b63406427..69c28e59b 100644 --- a/nova/exception.py +++ b/nova/exception.py @@ -423,7 +423,7 @@ class InvalidEc2Id(Invalid): class InvalidUUID(Invalid): - message = _("Expected a uuid but received %(uuid).") + message = _("Expected a uuid but received %(uuid)s.") class ConstraintNotMet(NovaException): @@ -596,7 +596,7 @@ class FixedIpNotFoundForAddress(FixedIpNotFound): class FixedIpNotFoundForInstance(FixedIpNotFound): - message = _("Instance %(instance_id)s has zero fixed ips.") + message = _("Instance %(instance_uuid)s has zero fixed ips.") class FixedIpNotFoundForNetworkHost(FixedIpNotFound): @@ -605,7 +605,7 @@ class FixedIpNotFoundForNetworkHost(FixedIpNotFound): class FixedIpNotFoundForSpecificInstance(FixedIpNotFound): - message = _("Instance %(instance_id)s doesn't have fixed ip '%(ip)s'.") + message = _("Instance %(instance_uuid)s doesn't have fixed ip '%(ip)s'.") class FixedIpNotFoundForHost(FixedIpNotFound): @@ -618,7 +618,8 @@ class FixedIpNotFoundForNetwork(FixedIpNotFound): class FixedIpAlreadyInUse(NovaException): - message = _("Fixed IP address %(address)s is already in use.") + message = _("Fixed IP address %(address)s is already in use on instance " + "%(instance_uuid)s.") class FixedIpInvalid(Invalid): diff --git a/nova/network/manager.py b/nova/network/manager.py index 7c5716ef9..4dd42e153 100644 --- a/nova/network/manager.py +++ b/nova/network/manager.py @@ -353,12 +353,14 @@ class FloatingIP(object): # deleted before the IPs are released, so we need to get deleted # instances too read_deleted_context = context.elevated(read_deleted='yes') - LOG.debug(_("floating IP deallocation for instance |%s|"), instance_id, - context=read_deleted_context) + instance = self.db.instance_get(read_deleted_context, instance_id) + + LOG.debug(_("floating IP deallocation for instance |%s|"), + instance=instance, context=read_deleted_context) try: fixed_ips = self.db.fixed_ip_get_by_instance(read_deleted_context, - instance_id) + instance['uuid']) except exception.FixedIpNotFoundForInstance: fixed_ips = [] # add to kwargs so we can pass to super to save a db lookup there @@ -503,7 +505,8 @@ class FloatingIP(object): network = self._get_network_by_id(context.elevated(), fixed_ip['network_id']) if network['multi_host']: - instance = self.db.instance_get(context, fixed_ip['instance_id']) + instance = self.db.instance_get_by_uuid(context, + fixed_ip['instance_uuid']) host = instance['host'] else: host = network['host'] @@ -574,7 +577,8 @@ class FloatingIP(object): # send to correct host, unless i'm the correct host network = self._get_network_by_id(context, fixed_ip['network_id']) if network['multi_host']: - instance = self.db.instance_get(context, fixed_ip['instance_id']) + instance = self.db.instance_get_by_uuid(context, + fixed_ip['instance_uuid']) host = instance['host'] else: host = network['host'] @@ -846,9 +850,15 @@ class NetworkManager(manager.SchedulerDependentManager): # NOTE(francois.charlier): the instance may have been deleted already # thus enabling `read_deleted` admin_context = context.get_admin_context(read_deleted='yes') - instance_ref = self.db.instance_get(admin_context, instance_id) - group_ids = [group['id'] for group - in instance_ref['security_groups']] + if utils.is_uuid_like(instance_id): + instance_ref = self.db.instance_get_by_uuid(admin_context, + instance_id) + else: + instance_ref = self.db.instance_get(admin_context, instance_id) + + groups = instance_ref['security_groups'] + group_ids = [group['id'] for group in groups] + self.security_group_api.trigger_members_refresh(admin_context, group_ids) self.security_group_api.trigger_handler('security_group_members', @@ -977,14 +987,16 @@ class NetworkManager(manager.SchedulerDependentManager): read_deleted_context = context.elevated(read_deleted='yes') instance_id = kwargs.pop('instance_id') + instance = self.db.instance_get(read_deleted_context, instance_id) + try: fixed_ips = (kwargs.get('fixed_ips') or self.db.fixed_ip_get_by_instance(read_deleted_context, - instance_id)) + instance['uuid'])) except exception.FixedIpNotFoundForInstance: fixed_ips = [] - LOG.debug(_("network deallocation for instance |%s|"), instance_id, - context=read_deleted_context) + LOG.debug(_("network deallocation for instance"), instance=instance, + context=read_deleted_context) # deallocate fixed ips for fixed_ip in fixed_ips: self.deallocate_fixed_ip(context, fixed_ip['address'], **kwargs) @@ -1034,7 +1046,7 @@ class NetworkManager(manager.SchedulerDependentManager): # get network dict for vif from args and build the subnets network = networks[vif['uuid']] subnets = self._get_subnets_from_network(context, network, vif, - instance_host) + instance_host) # if rxtx_cap data are not set everywhere, set to none try: @@ -1048,9 +1060,9 @@ class NetworkManager(manager.SchedulerDependentManager): vif['uuid'], network['project_id']) v6_IPs = self.ipam.get_v6_ips_by_interface(context, - network['uuid'], - vif['uuid'], - network['project_id']) + network['uuid'], + vif['uuid'], + network['project_id']) # create model FixedIPs from these fixed_ips network_IPs = [network_model.FixedIP(address=ip_address) @@ -1195,11 +1207,11 @@ class NetworkManager(manager.SchedulerDependentManager): raise exception.FixedIpNotFoundForSpecificInstance( instance_id=instance_id, ip=address) - def _validate_instance_zone_for_dns_domain(self, context, instance_id): - instance = self.db.instance_get(context, instance_id) + def _validate_instance_zone_for_dns_domain(self, context, instance): instance_zone = instance.get('availability_zone') if not self.instance_dns_domain: return True + instance_domain = self.instance_dns_domain domainref = self.db.dnsdomain_get(context, instance_zone) dns_zone = domainref.availability_zone @@ -1223,16 +1235,19 @@ class NetworkManager(manager.SchedulerDependentManager): # and use that network here with a method like # network_get_by_compute_host address = None + instance_ref = self.db.instance_get(context, instance_id) + if network['cidr']: address = kwargs.get('address', None) if address: address = self.db.fixed_ip_associate(context, - address, instance_id, + address, + instance_ref['uuid'], network['id']) else: address = self.db.fixed_ip_associate_pool(context.elevated(), network['id'], - instance_id) + instance_ref['uuid']) self._do_trigger_security_group_members_refresh_for_instance( instance_id) get_vif = self.db.virtual_interface_get_by_instance_and_network @@ -1241,10 +1256,9 @@ class NetworkManager(manager.SchedulerDependentManager): 'virtual_interface_id': vif['id']} self.db.fixed_ip_update(context, address, values) - instance_ref = self.db.instance_get(context, instance_id) name = instance_ref['display_name'] - if self._validate_instance_zone_for_dns_domain(context, instance_id): + if self._validate_instance_zone_for_dns_domain(context, instance_ref): uuid = instance_ref['uuid'] self.instance_dns_manager.create_entry(name, address, "A", @@ -1262,11 +1276,13 @@ class NetworkManager(manager.SchedulerDependentManager): self.db.fixed_ip_update(context, address, {'allocated': False, 'virtual_interface_id': None}) - instance_id = fixed_ip_ref['instance_id'] + instance = self.db.instance_get_by_uuid(context, + fixed_ip_ref['instance_uuid']) + self._do_trigger_security_group_members_refresh_for_instance( - instance_id) + instance['uuid']) - if self._validate_instance_zone_for_dns_domain(context, instance_id): + if self._validate_instance_zone_for_dns_domain(context, instance): for n in self.instance_dns_manager.get_entries_by_address(address, self.instance_dns_domain): self.instance_dns_manager.delete_entry(n, @@ -1301,7 +1317,7 @@ class NetworkManager(manager.SchedulerDependentManager): LOG.debug(_('Leased IP |%(address)s|'), locals(), context=context) fixed_ip = self.db.fixed_ip_get_by_address(context, address) - if fixed_ip['instance_id'] is None: + if fixed_ip['instance_uuid'] is None: msg = _('IP %s leased that is not associated') % address raise exception.NovaException(msg) now = timeutils.utcnow() @@ -1318,7 +1334,7 @@ class NetworkManager(manager.SchedulerDependentManager): LOG.debug(_('Released IP |%(address)s|'), locals(), context=context) fixed_ip = self.db.fixed_ip_get_by_address(context, address) - if fixed_ip['instance_id'] is None: + if fixed_ip['instance_uuid'] is None: msg = _('IP %s released that is not associated') % address raise exception.NovaException(msg) if not fixed_ip['leased']: @@ -1596,10 +1612,12 @@ class NetworkManager(manager.SchedulerDependentManager): network = self._get_network_by_id(context, fixed_ip_ref['network_id']) if network['uuid'] != network_uuid: - raise exception.FixedIpNotFoundForNetwork(address=address, - network_uuid=network_uuid) - if fixed_ip_ref['instance_id'] is not None: - raise exception.FixedIpAlreadyInUse(address=address) + raise exception.FixedIpNotFoundForNetwork( + address=address, network_uuid=network_uuid) + if fixed_ip_ref['instance_uuid'] is not None: + raise exception.FixedIpAlreadyInUse( + address=address, + instance_uuid=fixed_ip_ref['instance_uuid']) def _get_network_by_id(self, context, network_id): return self.db.network_get(context, network_id) @@ -1622,7 +1640,14 @@ class NetworkManager(manager.SchedulerDependentManager): fixed_ip = self.db.fixed_ip_get(context, floating_ip['fixed_ip_id']) # NOTE(tr3buchet): this can be None - return fixed_ip['instance_id'] + # NOTE(mikal): we need to return the instance id here because its used + # by ec2 (and possibly others) + uuid = fixed_ip['instance_uuid'] + if not uuid: + return uuid + + instance = self.db.instance_get_by_uuid(context, uuid) + return instance['id'] @wrap_check_policy def get_network(self, context, network_uuid): @@ -1852,15 +1877,17 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager): network['id'], reserved=True) else: + instance = self.db.instance_get(context, instance_id) + address = kwargs.get('address', None) if address: address = self.db.fixed_ip_associate(context, address, - instance_id, + instance['uuid'], network['id']) else: address = self.db.fixed_ip_associate_pool(context, network['id'], - instance_id) + instance['uuid']) self._do_trigger_security_group_members_refresh_for_instance( instance_id) vif = self.db.virtual_interface_get_by_instance_and_network(context, diff --git a/nova/network/quantum/manager.py b/nova/network/quantum/manager.py index 9fa852c09..ac3d7d0af 100644 --- a/nova/network/quantum/manager.py +++ b/nova/network/quantum/manager.py @@ -539,7 +539,7 @@ class QuantumManager(manager.FloatingIP, manager.FlatManager): return self.db.virtual_interface_create(context, vif) def get_instance_nw_info(self, context, instance_id, instance_uuid, - rxtx_factor, host, **kwargs): + rxtx_factor, host, **kwargs): """This method is used by compute to fetch all network data that should be used when creating the VM. diff --git a/nova/network/quantum/nova_ipam_lib.py b/nova/network/quantum/nova_ipam_lib.py index 08e19f0a4..1efea398b 100644 --- a/nova/network/quantum/nova_ipam_lib.py +++ b/nova/network/quantum/nova_ipam_lib.py @@ -127,9 +127,10 @@ class QuantumNovaIPAMLib(object): network = db.network_get_by_uuid(admin_context, quantum_net_id) address = None if network['cidr']: + instance = db.instance_get(context, vif_rec['instance_id']) address = db.fixed_ip_associate_pool(admin_context, network['id'], - vif_rec['instance_id']) + instance['uuid']) values = {'allocated': True, 'virtual_interface_id': vif_rec['id']} db.fixed_ip_update(admin_context, address, values) diff --git a/nova/tests/api/openstack/compute/contrib/test_floating_ips.py b/nova/tests/api/openstack/compute/contrib/test_floating_ips.py index 8a3a2ece1..db1364c3b 100644 --- a/nova/tests/api/openstack/compute/contrib/test_floating_ips.py +++ b/nova/tests/api/openstack/compute/contrib/test_floating_ips.py @@ -36,7 +36,7 @@ FAKE_UUID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa' def network_api_get_fixed_ip(self, context, id): if id is None: return None - return {'address': '10.0.0.1', 'id': id, 'instance_id': 1} + return {'address': '10.0.0.1', 'id': id, 'instance_uuid': 1} def network_api_get_floating_ip(self, context, id): @@ -214,7 +214,7 @@ class FloatingIpTest(test.TestCase): 'fixed_ip_id': 11} def get_fixed_ip(self, context, id): - return {'address': '10.0.0.1', 'instance_id': 1} + return {'address': '10.0.0.1', 'instance_uuid': 1} self.stubs.Set(network.api.API, "get_floating_ip", get_floating_ip) self.stubs.Set(network.api.API, "get_fixed_ip", get_fixed_ip) diff --git a/nova/tests/compute/test_compute.py b/nova/tests/compute/test_compute.py index e2c736c54..b6d0803f6 100644 --- a/nova/tests/compute/test_compute.py +++ b/nova/tests/compute/test_compute.py @@ -1647,7 +1647,7 @@ class ComputeTestCase(BaseTestCase): 'power_state': power_state.PAUSED}) v_ref = db.volume_create(c, {'size': 1, 'instance_id': inst_id}) fix_addr = db.fixed_ip_create(c, {'address': '1.1.1.1', - 'instance_id': inst_id}) + 'instance_uuid': inst_ref['uuid']}) fix_ref = db.fixed_ip_get_by_address(c, fix_addr) db.floating_ip_create(c, {'address': flo_addr, 'fixed_ip_id': fix_ref['id']}) diff --git a/nova/tests/network/test_manager.py b/nova/tests/network/test_manager.py index a5a6b9548..a183094af 100644 --- a/nova/tests/network/test_manager.py +++ b/nova/tests/network/test_manager.py @@ -38,10 +38,11 @@ LOG = logging.getLogger(__name__) HOST = "testhost" +FAKEUUID = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa" networks = [{'id': 0, - 'uuid': "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa", + 'uuid': FAKEUUID, 'label': 'test0', 'injected': False, 'multi_host': False, @@ -84,14 +85,14 @@ networks = [{'id': 0, fixed_ips = [{'id': 0, 'network_id': 0, 'address': '192.168.0.100', - 'instance_id': 0, + 'instance_uuid': 0, 'allocated': False, 'virtual_interface_id': 0, 'floating_ips': []}, {'id': 0, 'network_id': 1, 'address': '192.168.1.100', - 'instance_id': 0, + 'instance_uuid': 0, 'allocated': False, 'virtual_interface_id': 0, 'floating_ips': []}] @@ -197,19 +198,19 @@ class FlatNetworkTestCase(test.TestCase): def test_validate_networks(self): self.mox.StubOutWithMock(db, 'network_get') self.mox.StubOutWithMock(db, 'network_get_all_by_uuids') - self.mox.StubOutWithMock(db, "fixed_ip_get_by_address") + self.mox.StubOutWithMock(db, 'fixed_ip_get_by_address') - requested_networks = [("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb", - "192.168.1.100")] + requested_networks = [('bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb', + '192.168.1.100')] db.network_get_all_by_uuids(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(networks) + mox.IgnoreArg()).AndReturn(networks) db.network_get(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(networks[1]) ip = fixed_ips[1].copy() - ip['instance_id'] = None + ip['instance_uuid'] = None db.fixed_ip_get_by_address(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn(ip) + mox.IgnoreArg()).AndReturn(ip) self.mox.ReplayAll() self.network.validate_networks(self.context, requested_networks) @@ -282,14 +283,12 @@ class FlatNetworkTestCase(test.TestCase): db.virtual_interface_get_by_instance_and_network(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'id': 0}) - db.instance_get(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn({'security_groups': - [{'id': 0}]}) db.instance_get(self.context, 1).AndReturn({'display_name': HOST, 'uuid': 'test-00001'}) db.instance_get(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn({'availability_zone': ''}) + mox.IgnoreArg()).AndReturn({'security_groups': + [{'id': 0}]}) db.fixed_ip_associate_pool(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('192.168.0.101') @@ -315,14 +314,12 @@ class FlatNetworkTestCase(test.TestCase): db.virtual_interface_get_by_instance_and_network(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'id': 0}) - db.instance_get(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn({'security_groups': - [{'id': 0}]}) db.instance_get(self.context, 1).AndReturn({'display_name': HOST, 'uuid': 'test-00001'}) db.instance_get(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn({'availability_zone': ''}) + mox.IgnoreArg()).AndReturn({'security_groups': + [{'id': 0}]}) db.fixed_ip_associate_pool(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('192.168.0.101') @@ -372,6 +369,7 @@ class FlatNetworkTestCase(test.TestCase): self.mox.StubOutWithMock(db, 'network_update') self.mox.StubOutWithMock(db, 'fixed_ip_associate_pool') self.mox.StubOutWithMock(db, 'instance_get') + self.mox.StubOutWithMock(db, 'instance_get_by_uuid') self.mox.StubOutWithMock(db, 'virtual_interface_get_by_instance_and_network') self.mox.StubOutWithMock(db, 'fixed_ip_update') @@ -382,15 +380,13 @@ class FlatNetworkTestCase(test.TestCase): db.virtual_interface_get_by_instance_and_network(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'id': 0}) - db.instance_get(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn({'security_groups': - [{'id': 0}]}) - db.instance_get(self.context, 1).AndReturn({'display_name': HOST, 'uuid': 'test-00001'}) db.instance_get(mox.IgnoreArg(), - mox.IgnoreArg()).AndReturn({'availability_zone': ''}) + mox.IgnoreArg()).AndReturn({'security_groups': + [{'id': 0}]}) + db.fixed_ip_associate_pool(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(fixedip) @@ -446,12 +442,13 @@ class VlanNetworkTestCase(test.TestCase): network = dict(networks[0]) network['vpn_private_address'] = '192.168.0.2' network['id'] = None + instance = db.instance_create(self.context, {}) context_admin = context.RequestContext('testuser', 'testproject', is_admin=True) self.assertRaises(exception.FixedIpNotFoundForNetwork, self.network.allocate_fixed_ip, context_admin, - 0, + instance['uuid'], network, vpn=True) @@ -462,6 +459,8 @@ class VlanNetworkTestCase(test.TestCase): 'virtual_interface_get_by_instance_and_network') self.mox.StubOutWithMock(db, 'instance_get') + db.instance_get(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn({'uuid': FAKEUUID}) db.instance_get(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'security_groups': [{'id': 0}]}) @@ -503,7 +502,7 @@ class VlanNetworkTestCase(test.TestCase): mox.IgnoreArg()).AndReturn(networks) fixed_ips[1]['network_id'] = networks[1]['id'] - fixed_ips[1]['instance_id'] = None + fixed_ips[1]['instance_uuid'] = None db.fixed_ip_get_by_address(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn(fixed_ips[1]) @@ -841,6 +840,8 @@ class VlanNetworkTestCase(test.TestCase): 'virtual_interface_get_by_instance_and_network') self.mox.StubOutWithMock(db, 'fixed_ip_update') + db.instance_get(mox.IgnoreArg(), + mox.IgnoreArg()).AndReturn({'uuid': FAKEUUID}) db.fixed_ip_update(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()) @@ -850,7 +851,8 @@ class VlanNetworkTestCase(test.TestCase): db.instance_get(mox.IgnoreArg(), mox.IgnoreArg()).AndReturn({'security_groups': [{'id': 0}], - 'availability_zone': ''}) + 'availability_zone': '', + 'uuid': FAKEUUID}) db.fixed_ip_associate_pool(mox.IgnoreArg(), mox.IgnoreArg(), mox.IgnoreArg()).AndReturn('192.168.0.101') @@ -874,14 +876,14 @@ class VlanNetworkTestCase(test.TestCase): address = '1.2.3.4' float_addr = db.floating_ip_create(context1.elevated(), - {'address': address, - 'project_id': context1.project_id}) + {'address': address, + 'project_id': context1.project_id}) instance = db.instance_create(context1, - {'project_id': 'project1'}) + {'project_id': 'project1'}) fix_addr = db.fixed_ip_associate_pool(context1.elevated(), - 1, instance['id']) + 1, instance['uuid']) # Associate the IP with non-admin user context self.assertRaises(exception.NotAuthorized, @@ -932,7 +934,7 @@ class VlanNetworkTestCase(test.TestCase): {'project_id': 'project1'}) elevated = context1.elevated() - fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['id']) + fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid']) values = {'allocated': True, 'virtual_interface_id': 3} db.fixed_ip_update(elevated, fix_addr, values) @@ -967,13 +969,13 @@ class VlanNetworkTestCase(test.TestCase): {'project_id': 'project1'}) elevated = context1.elevated() - fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['id']) + fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid']) db.fixed_ip_update(elevated, fix_addr, {'deleted': 1}) elevated.read_deleted = 'yes' delfixed = db.fixed_ip_get_by_address(elevated, fix_addr) values = {'address': fix_addr, 'network_id': 0, - 'instance_id': delfixed['instance_id']} + 'instance_uuid': delfixed['instance_uuid']} db.fixed_ip_create(elevated, values) elevated.read_deleted = 'no' newfixed = db.fixed_ip_get_by_address(elevated, fix_addr) @@ -1000,10 +1002,10 @@ class VlanNetworkTestCase(test.TestCase): context1 = context.RequestContext('user', 'project1') instance = db.instance_create(context1, - {'project_id': 'project1'}) + {'project_id': 'project1'}) elevated = context1.elevated() - fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['id']) + fix_addr = db.fixed_ip_associate_pool(elevated, 1, instance['uuid']) values = {'allocated': True, 'virtual_interface_id': 3} db.fixed_ip_update(elevated, fix_addr, values) @@ -1458,12 +1460,12 @@ class AllocateTestCase(test.TestCase): {'host': self.network.host}) project_id = self.context.project_id nw_info = self.network.allocate_for_instance(self.context, - instance_id=inst['id'], - instance_uuid='', - host=inst['host'], - vpn=None, - rxtx_factor=3, - project_id=project_id) + instance_id=inst['id'], + instance_uuid='', + host=inst['host'], + vpn=None, + rxtx_factor=3, + project_id=project_id) self.assertEquals(1, len(nw_info)) fixed_ip = nw_info.fixed_ips()[0]['address'] self.assertTrue(utils.is_valid_ipv4(fixed_ip)) diff --git a/nova/tests/network/test_quantum.py b/nova/tests/network/test_quantum.py index 5299bde93..b126994d0 100644 --- a/nova/tests/network/test_quantum.py +++ b/nova/tests/network/test_quantum.py @@ -542,7 +542,7 @@ class QuantumNovaMACGenerationTestCase(QuantumNovaTestCase): class QuantumNovaPortSecurityTestCase(QuantumNovaTestCase): - def test_port_securty(self): + def test_port_security(self): self.flags(use_melange_mac_generation=True) self.flags(quantum_use_port_security=True) fake_mac = "ab:cd:ef:ab:cd:ef" @@ -578,7 +578,7 @@ class QuantumNovaPortSecurityTestCase(QuantumNovaTestCase): requested_networks=requested_networks) self.assertEqual(nw_info[0]['address'], fake_mac) - def test_port_securty_negative(self): + def test_port_security_negative(self): self.flags(use_melange_mac_generation=True) self.flags(quantum_use_port_security=False) fake_mac = "ab:cd:ef:ab:cd:ef" @@ -593,7 +593,7 @@ class QuantumNovaPortSecurityTestCase(QuantumNovaTestCase): requested_networks = [(n[0], None) for n in all_valid_networks] instance_ref = db.api.instance_create(ctx, - {"project_id": project_id}) + {"project_id": project_id}) oldfunc = self.net_man.q_conn.create_and_attach_port # Make sure no pairs are passed in if port security is turned off diff --git a/nova/tests/test_db_api.py b/nova/tests/test_db_api.py index acf0b1873..44efc0950 100644 --- a/nova/tests/test_db_api.py +++ b/nova/tests/test_db_api.py @@ -334,14 +334,14 @@ class DbApiTestCase(test.TestCase): values = {'address': 'baz', 'network_id': 1, 'allocated': True, - 'instance_id': instance['id'], + 'instance_uuid': instance['uuid'], 'virtual_interface_id': vif['id']} fixed_address = db.fixed_ip_create(ctxt, values) data = db.network_get_associated_fixed_ips(ctxt, 1) self.assertEqual(len(data), 1) record = data[0] self.assertEqual(record['address'], fixed_address) - self.assertEqual(record['instance_id'], instance['id']) + self.assertEqual(record['instance_uuid'], instance['uuid']) self.assertEqual(record['network_id'], 1) self.assertEqual(record['instance_created'], instance['created_at']) self.assertEqual(record['instance_updated'], instance['updated_at']) @@ -360,25 +360,25 @@ class DbApiTestCase(test.TestCase): new = time = timeout + datetime.timedelta(seconds=5) # should deallocate values = {'allocated': False, - 'instance_id': instance['id'], + 'instance_uuid': instance['uuid'], 'network_id': net['id'], 'updated_at': old} db.fixed_ip_create(ctxt, values) # still allocated values = {'allocated': True, - 'instance_id': instance['id'], + 'instance_uuid': instance['uuid'], 'network_id': net['id'], 'updated_at': old} db.fixed_ip_create(ctxt, values) # wrong network values = {'allocated': False, - 'instance_id': instance['id'], + 'instance_uuid': instance['uuid'], 'network_id': None, 'updated_at': old} db.fixed_ip_create(ctxt, values) # too new values = {'allocated': False, - 'instance_id': instance['id'], + 'instance_uuid': instance['uuid'], 'network_id': None, 'updated_at': new} db.fixed_ip_create(ctxt, values) @@ -830,27 +830,27 @@ class TestIpAllocation(test.TestCase): def test_fixed_ip_associate_fails_if_ip_not_in_network(self): self.assertRaises(exception.FixedIpNotFoundForNetwork, db.fixed_ip_associate, - self.ctxt, None, None) + self.ctxt, None, self.instance.uuid) def test_fixed_ip_associate_fails_if_ip_in_use(self): - address = self.create_fixed_ip(instance_id=self.instance.id) + address = self.create_fixed_ip(instance_uuid=self.instance.uuid) self.assertRaises(exception.FixedIpAlreadyInUse, db.fixed_ip_associate, - self.ctxt, address, self.instance.id) + self.ctxt, address, self.instance.uuid) def test_fixed_ip_associate_succeeds(self): address = self.create_fixed_ip(network_id=self.network.id) - db.fixed_ip_associate(self.ctxt, address, self.instance.id, + db.fixed_ip_associate(self.ctxt, address, self.instance.uuid, network_id=self.network.id) fixed_ip = db.fixed_ip_get_by_address(self.ctxt, address) - self.assertEqual(fixed_ip.instance_id, self.instance.id) + self.assertEqual(fixed_ip.instance_uuid, self.instance.uuid) def test_fixed_ip_associate_succeeds_and_sets_network(self): address = self.create_fixed_ip() - db.fixed_ip_associate(self.ctxt, address, self.instance.id, + db.fixed_ip_associate(self.ctxt, address, self.instance.uuid, network_id=self.network.id) fixed_ip = db.fixed_ip_get_by_address(self.ctxt, address) - self.assertEqual(fixed_ip.instance_id, self.instance.id) + self.assertEqual(fixed_ip.instance_uuid, self.instance.uuid) self.assertEqual(fixed_ip.network_id, self.network.id) -- cgit