def setUp(self):
super(TestNetworkModel, self).setUp()
model = network_model.NetworkInfo()
self.field = fields.Field(fields.NetworkModel())
self.coerce_good_values = [(model, model), (model.json(), model)]
self.coerce_bad_values = [[], 'foo']
self.to_primitive_values = [(model, model.json())]
self.from_primitive_values = [(model.json(), model)]
def setUp(self):
super(TestSet, self).setUp()
self.field = fields.Field(fields.Set(FakeFieldType()))
self.coerce_good_values = [(set(['foo',
'bar']), set(['*foo*', '*bar*']))]
self.coerce_bad_values = [['foo'], {'foo': 'bar'}]
self.to_primitive_values = [(set(['foo']), tuple(['!foo!']))]
self.from_primitive_values = [(tuple(['!foo!']), set(['foo']))]
def setUp(self):
super(TestDict, self).setUp()
self.field = fields.Field(fields.Dict(FakeFieldType()))
self.coerce_good_values = [({'foo': 'bar'}, {'foo': '*bar*'}),
({'foo': 1}, {'foo': '*1*'})]
self.coerce_bad_values = [{1: 'bar'}, 'foo']
self.to_primitive_values = [({'foo': 'bar'}, {'foo': '!bar!'})]
self.from_primitive_values = [({'foo': '!bar!'}, {'foo': 'bar'})]
def setUp(self):
super(TestNetworkVIFModel, self).setUp()
model = network_model.VIF('6c197bc7-820c-40d5-8aff-7116b993e793')
primitive = jsonutils.dumps(model)
self.field = fields.Field(fields.NetworkVIFModel())
self.coerce_good_values = [(model, model), (primitive, model)]
self.coerce_bad_values = [[], 'foo']
self.to_primitive_values = [(model, primitive)]
self.from_primitive_values = [(primitive, model)]
def setUp(self):
super(TestXenAddress, self).setUp()
self.field = fields.Field(fields.XenAddressField())
self.coerce_good_values = [('000100', '000100'), ('768', '768')]
self.coerce_bad_values = [
'1',
'00100',
]
self.to_primitive_values = self.coerce_good_values
self.from_primitive_values = self.coerce_good_values
def setUp(self):
super(TestIPV6Network, self).setUp()
self.field = fields.Field(fields.IPV6Network())
good = ['::1/128', '::1/64', '::1/0']
self.coerce_good_values = [(x, netaddr.IPNetwork(x)) for x in good]
self.coerce_bad_values = [
'192.168.0.0/f', '192.168.0.0/foo', '::1/129', '192.168.0.0/-1'
]
self.to_primitive_values = [(netaddr.IPNetwork(x), x) for x in good]
self.from_primitive_values = [(x, netaddr.IPNetwork(x)) for x in good]
def setUp(self):
super(TestIDEAddress, self).setUp()
self.field = fields.Field(fields.IDEAddressField())
self.coerce_good_values = [('0:0', '0:0')]
self.coerce_bad_values = [
'0:2',
'00',
'0',
]
self.to_primitive_values = self.coerce_good_values
self.from_primitive_values = self.coerce_good_values
def setUp(self):
super(TestCIDR, self).setUp()
self.field = fields.Field(fields.CIDR())
good = ['192.168.0.1/24', '192.168.0.0/16', '192.168.0.0/8',
'192.168.0.0/0', '1.2.3.4/32', '1.2.3.4/22', '0/0',
'::1/128', '::1/64', '::1/0']
self.coerce_good_values = [(x, x) for x in good]
self.coerce_bad_values = ['192.168.0.0', '192.168.0.0/f',
'192.168.0.0/foo', '192.168.0.0/33',
'::1/129', '192.168.0.0/-1']
self.to_primitive_values = [(x, x) for x in good]
self.from_primitive_values = self.to_primitive_values
def setUp(self):
super(TestSCSIAddress, self).setUp()
self.field = fields.Field(fields.SCSIAddressField())
self.coerce_good_values = [('1:0:2:0', '1:0:2:0')]
self.coerce_bad_values = [
'1:0:2',
'-:0:2:0',
'1:-:2:0',
'1:0:-:0',
'1:0:2:-',
]
self.to_primitive_values = self.coerce_good_values
self.from_primitive_values = self.coerce_good_values
def setUp(self):
super(TestPCIAddress, self).setUp()
self.field = fields.Field(fields.PCIAddressField())
self.coerce_good_values = [('0000:00:02.0', '0000:00:02.0')]
self.coerce_bad_values = [
'000:00:02.0',
'0000:0:02.0',
'0000:00:2.0',
'0000:00:02.',
'-000:00:02.0',
'0000:0-:02.0',
'0000:00:-2.0',
'0000:00:02.-',
'000000:02.0',
'0000:0:02.0',
'0000:00:020',
]
self.to_primitive_values = self.coerce_good_values
self.from_primitive_values = self.coerce_good_values
def setUp(self):
class TestableObject(obj_base.NovaObject):
def __eq__(self, value):
# NOTE(danms): Be rather lax about this equality thing to
# satisfy the assertEqual() in test_from_primitive(). We
# just want to make sure the right type of object is re-created
return value.__class__.__name__ == TestableObject.__name__
class OtherTestableObject(obj_base.NovaObject):
pass
test_inst = TestableObject()
super(TestObject, self).setUp()
self.field = fields.Field(fields.Object('TestableObject'))
self.coerce_good_values = [(test_inst, test_inst)]
self.coerce_bad_values = [OtherTestableObject(), 1, 'foo']
self.to_primitive_values = [(test_inst, test_inst.obj_to_primitive())]
self.from_primitive_values = [(test_inst.obj_to_primitive(), test_inst)
]
class SecurityGroupRule(base.NovaPersistentObject, base.NovaObject):
# Version 1.0: Initial version
VERSION = '1.0'
fields = {
'id': fields.IntegerField(),
'protocol': fields.StringField(nullable=True),
'from_port': fields.IntegerField(nullable=True),
'to_port': fields.IntegerField(nullable=True),
'cidr': fields.Field(fields.CIDR(), nullable=True),
'parent_group': fields.ObjectField('SecurityGroup', nullable=True),
'grantee_group': fields.ObjectField('SecurityGroup', nullable=True),
}
@staticmethod
def _from_db_subgroup(context, db_group):
if db_group is None:
return None
return security_group.SecurityGroup._from_db_object(
context, security_group.SecurityGroup(), db_group)
@staticmethod
def _from_db_object(context, rule, db_rule, expected_attrs=None):
if expected_attrs is None:
expected_attrs = []
for field in rule.fields:
if field in expected_attrs:
rule[field] = rule._from_db_subgroup(context, db_rule[field])
elif field not in OPTIONAL_ATTRS:
rule[field] = db_rule[field]
rule._context = context
rule.obj_reset_changes()
return rule
@base.remotable_classmethod
def get_by_id(cls, context, rule_id):
db_rule = db.security_group_rule_get(context, rule_id)
return cls._from_db_object(context, cls(), db_rule)
class Bar(base.NovaObject):
fields = {'foo': fields.Field(fields.String())}
class TestSubclassedObject(RandomMixInWithNoFields, MyObj):
fields = {'new_field': fields.Field(fields.String())}
class Foo(base.NovaObject):
fields = {'foobar': fields.Field(fields.Integer())}
class VIFMigrateData(obj_base.NovaObject):
# Version 1.0: Initial version
VERSION = '1.0'
# The majority of the fields here represent a port binding on the
# **destination** host during a live migration. The vif_type, among
# other fields, could be different from the existing binding on the
# source host, which is represented by the "source_vif" field.
fields = {
'port_id': fields.StringField(),
'vnic_type': fields.StringField(), # TODO(sean-k-mooney): make enum?
'vif_type': fields.StringField(),
# vif_details is a dict whose contents are dependent on the vif_type
# and can be any number of types for the values, so we just store it
# as a serialized dict
'vif_details_json': fields.StringField(),
# profile is in the same random dict of terrible boat as vif_details
# so it's stored as a serialized json string
'profile_json': fields.StringField(),
'host': fields.StringField(),
# The source_vif attribute is a copy of the VIF network model
# representation of the port on the source host which can be used
# for filling in blanks about the VIF (port) when building a
# configuration reference for the destination host.
# NOTE(mriedem): This might not be sufficient based on how the
# destination host is configured for all vif types. See the note in
# the libvirt driver here: https://review.openstack.org/#/c/551370/
# 29/nova/virt/libvirt/driver.py@7036
'source_vif': fields.Field(fields.NetworkVIFModel()),
}
@property
def vif_details(self):
return jsonutils.loads(self.vif_details_json)
@vif_details.setter
def vif_details(self, vif_details_dict):
self.vif_details_json = jsonutils.dumps(vif_details_dict)
@property
def profile(self):
return jsonutils.loads(self.profile_json)
@profile.setter
def profile(self, profile_dict):
self.profile_json = jsonutils.dumps(profile_dict)
def get_dest_vif(self):
"""Get a destination VIF representation of this object.
This method takes the source_vif and updates it to include the
destination host port binding information using the other fields
on this object.
:return: nova.network.model.VIF object
"""
if 'source_vif' not in self:
raise exception.ObjectActionError(action='get_dest_vif',
reason='source_vif is not set')
vif = copy.deepcopy(self.source_vif)
vif['type'] = self.vif_type
vif['vnic_type'] = self.vnic_type
vif['profile'] = self.profile
vif['details'] = self.vif_details
return vif
class InstanceInfoCache(base.NovaPersistentObject, base.NovaObject,
base.NovaObjectDictCompat):
# Version 1.0: Initial version
# Version 1.1: Converted network_info to store the model.
# Version 1.2: Added new() and update_cells kwarg to save().
# Version 1.3: Added delete()
# Version 1.4: String attributes updated to support unicode
# Version 1.5: Actually set the deleted, created_at, updated_at, and
# deleted_at attributes
VERSION = '1.5'
fields = {
'instance_uuid': fields.UUIDField(),
'network_info': fields.Field(fields.NetworkModel(), nullable=True),
}
@staticmethod
def _from_db_object(context, info_cache, db_obj):
for field in info_cache.fields:
info_cache[field] = db_obj[field]
info_cache.obj_reset_changes()
info_cache._context = context
return info_cache
@classmethod
def new(cls, context, instance_uuid):
"""Create an InfoCache object that can be used to create the DB
entry for the first time.
When save()ing this object, the info_cache_update() DB call
will properly handle creating it if it doesn't exist already.
"""
info_cache = cls()
info_cache.instance_uuid = instance_uuid
info_cache.network_info = None
info_cache._context = context
# Leave the fields dirty
return info_cache
@base.remotable_classmethod
def get_by_instance_uuid(cls, context, instance_uuid):
db_obj = db.instance_info_cache_get(context, instance_uuid)
if not db_obj:
raise exception.InstanceInfoCacheNotFound(
instance_uuid=instance_uuid)
return cls._from_db_object(context, cls(context), db_obj)
@staticmethod
def _info_cache_cells_update(ctxt, info_cache):
cell_type = cells_opts.get_cell_type()
if cell_type != 'compute':
return
cells_api = cells_rpcapi.CellsAPI()
try:
cells_api.instance_info_cache_update_at_top(ctxt, info_cache)
except Exception:
LOG.exception(
_LE("Failed to notify cells of instance info "
"cache update"))
@base.remotable
def save(self, update_cells=True):
if 'network_info' in self.obj_what_changed():
nw_info_json = self.fields['network_info'].to_primitive(
self, 'network_info', self.network_info)
rv = db.instance_info_cache_update(self._context,
self.instance_uuid,
{'network_info': nw_info_json})
self._from_db_object(self._context, self, rv)
if update_cells and rv:
self._info_cache_cells_update(self._context, rv)
self.obj_reset_changes()
@base.remotable
def delete(self):
db.instance_info_cache_delete(self._context, self.instance_uuid)
@base.remotable
def refresh(self):
current = self.__class__.get_by_instance_uuid(self._context,
self.instance_uuid)
current._context = None
for field in self.fields:
if self.obj_attr_is_set(field) and self[field] != current[field]:
self[field] = current[field]
self.obj_reset_changes()
def setUp(self):
super(TestNonNegativeInteger, self).setUp()
self.field = fields.Field(fields.NonNegativeInteger())
self.coerce_bad_values.extend(['-2', '4.2'])
class InstanceInfoCache(base.NovaPersistentObject, base.NovaObject):
# Version 1.0: Initial version
# Version 1.1: Converted network_info to store the model.
# Version 1.2: Added new() and update_cells kwarg to save().
# Version 1.3: Added delete()
# Version 1.4: String attributes updated to support unicode
# Version 1.5: Actually set the deleted, created_at, updated_at, and
# deleted_at attributes
VERSION = '1.5'
fields = {
'instance_uuid': fields.UUIDField(),
'network_info': fields.Field(fields.NetworkModel(), nullable=True),
}
@staticmethod
def _from_db_object(context, info_cache, db_obj):
for field in info_cache.fields:
setattr(info_cache, field, db_obj[field])
info_cache.obj_reset_changes()
info_cache._context = context
return info_cache
@classmethod
def new(cls, context, instance_uuid):
"""Create an InfoCache object that can be used to create the DB
entry for the first time.
When save()ing this object, the info_cache_update() DB call
will properly handle creating it if it doesn't exist already.
"""
info_cache = cls()
info_cache.instance_uuid = instance_uuid
info_cache.network_info = None
info_cache._context = context
# Leave the fields dirty
return info_cache
@base.remotable_classmethod
def get_by_instance_uuid(cls, context, instance_uuid):
db_obj = db.instance_info_cache_get(context, instance_uuid)
if not db_obj:
raise exception.InstanceInfoCacheNotFound(
instance_uuid=instance_uuid)
return cls._from_db_object(context, cls(context), db_obj)
# TODO(stephenfin): Remove 'update_cells' in version 2.0
@base.remotable
def save(self, update_cells=True):
if 'network_info' in self.obj_what_changed():
nw_info_json = self.fields['network_info'].to_primitive(
self, 'network_info', self.network_info)
rv = db.instance_info_cache_update(self._context,
self.instance_uuid,
{'network_info': nw_info_json})
self._from_db_object(self._context, self, rv)
self.obj_reset_changes()
@base.remotable
def delete(self):
db.instance_info_cache_delete(self._context, self.instance_uuid)
@base.remotable
def refresh(self):
current = self.__class__.get_by_instance_uuid(self._context,
self.instance_uuid)
current._context = None
for field in self.fields:
if (self.obj_attr_is_set(field)
and getattr(self, field) != getattr(current, field)):
setattr(self, field, getattr(current, field))
self.obj_reset_changes()
def setUp(self):
super(TestNonNegativeFloat, self).setUp()
self.field = fields.Field(fields.NonNegativeFloat())
self.coerce_bad_values.extend(['-4.2'])
class VIFMigrateData(obj_base.NovaObject):
# Version 1.0: Initial version
VERSION = '1.0'
# The majority of the fields here represent a port binding on the
# **destination** host during a live migration. The vif_type, among
# other fields, could be different from the existing binding on the
# source host, which is represented by the "source_vif" field.
fields = {
'port_id': fields.StringField(),
'vnic_type': fields.StringField(), # TODO(sean-k-mooney): make enum?
'vif_type': fields.StringField(),
# vif_details is a dict whose contents are dependent on the vif_type
# and can be any number of types for the values, so we just store it
# as a serialized dict
'vif_details_json': fields.StringField(),
# profile is in the same random dict of terrible boat as vif_details
# so it's stored as a serialized json string
'profile_json': fields.StringField(),
'host': fields.StringField(),
# The source_vif attribute is a copy of the VIF network model
# representation of the port on the source host which can be used
# for filling in blanks about the VIF (port) when building a
# configuration reference for the destination host.
# NOTE(mriedem): This might not be sufficient based on how the
# destination host is configured for all vif types. See the note in
# the libvirt driver here: https://review.opendev.org/#/c/551370/
# 29/nova/virt/libvirt/driver.py@7036
'source_vif': fields.Field(fields.NetworkVIFModel()),
}
@property
def vif_details(self):
if 'vif_details_json' not in self:
return {}
return jsonutils.loads(self.vif_details_json)
@vif_details.setter
def vif_details(self, vif_details_dict):
self.vif_details_json = jsonutils.dumps(vif_details_dict)
@property
def profile(self):
if 'profile_json' not in self:
return {}
return jsonutils.loads(self.profile_json)
@profile.setter
def profile(self, profile_dict):
self.profile_json = jsonutils.dumps(profile_dict)
@property
def supports_os_vif_delegation(self):
return self.profile.get(OS_VIF_DELEGATION, False)
# TODO(stephenfin): add a proper delegation field instead of storing this
# info in the profile catch-all blob
@supports_os_vif_delegation.setter
def supports_os_vif_delegation(self, supported):
# we can't simply set the attribute using dict notation since the
# getter returns a copy of the data, not the data itself
self.profile = dict(self.profile or {},
**{OS_VIF_DELEGATION: supported})
def get_dest_vif(self):
"""Get a destination VIF representation of this object.
This method takes the source_vif and updates it to include the
destination host port binding information using the other fields
on this object.
:return: nova.network.model.VIF object
"""
if 'source_vif' not in self:
raise exception.ObjectActionError(action='get_dest_vif',
reason='source_vif is not set')
vif = copy.deepcopy(self.source_vif)
vif['type'] = self.vif_type
vif['vnic_type'] = self.vnic_type
vif['profile'] = self.profile
vif['details'] = self.vif_details
vif['delegate_create'] = self.supports_os_vif_delegation
return vif
@classmethod
def create_skeleton_migrate_vifs(cls, vifs):
"""Create migrate vifs for live migration.
:param vifs: a list of VIFs.
:return: list of VIFMigrateData object corresponding to the provided
VIFs.
"""
vif_mig_data = []
for vif in vifs:
mig_vif = cls(port_id=vif['id'], source_vif=vif)
vif_mig_data.append(mig_vif)
return vif_mig_data
class MyObj(base.NovaPersistentObject, base.NovaObject):
VERSION = '1.6'
fields = {
'foo': fields.Field(fields.Integer()),
'bar': fields.Field(fields.String()),
'missing': fields.Field(fields.String()),
'readonly': fields.Field(fields.Integer(), read_only=True),
'rel_object': fields.ObjectField('MyOwnedObject', nullable=True)
}
@staticmethod
def _from_db_object(context, obj, db_obj):
self = MyObj()
self.foo = db_obj['foo']
self.bar = db_obj['bar']
self.missing = db_obj['missing']
self.readonly = 1
return self
def obj_load_attr(self, attrname):
setattr(self, attrname, 'loaded!')
@base.remotable_classmethod
def query(cls, context):
obj = cls(foo=1, bar='bar')
obj.obj_reset_changes()
return obj
@base.remotable
def marco(self, context):
return 'polo'
@base.remotable
def _update_test(self, context):
if context.project_id == 'alternate':
self.bar = 'alternate-context'
else:
self.bar = 'updated'
@base.remotable
def save(self, context):
self.obj_reset_changes()
@base.remotable
def refresh(self, context):
self.foo = 321
self.bar = 'refreshed'
self.obj_reset_changes()
@base.remotable
def modify_save_modify(self, context):
self.bar = 'meow'
self.save()
self.foo = 42
self.rel_object = MyOwnedObject(baz=42)
def obj_make_compatible(self, primitive, target_version):
# NOTE(danms): Simulate an older version that had a different
# format for the 'bar' attribute
if target_version == '1.1' and 'bar' in primitive:
primitive['bar'] = 'old%s' % primitive['bar']
class MyOwnedObject(base.NovaPersistentObject, base.NovaObject):
VERSION = '1.0'
fields = {'baz': fields.Field(fields.Integer())}
class InstanceInfoCache(base.NovaPersistentObject, base.NovaObject):
# Version 1.0: Initial version
# Version 1.1: Converted network_info to store the model.
# Version 1.2: Added new() and update_cells kwarg to save().
# Version 1.3: Added delete()
# Version 1.4: String attributes updated to support unicode
# Version 1.5: Actually set the deleted, created_at, updated_at, and
# deleted_at attributes
VERSION = '1.5'
fields = {
'instance_uuid': fields.UUIDField(),
'network_info': fields.Field(fields.NetworkModel(), nullable=True),
}
@staticmethod
def _from_db_object(context, info_cache, db_obj):
for field in info_cache.fields:
setattr(info_cache, field, db_obj[field])
info_cache.obj_reset_changes()
info_cache._context = context
return info_cache
@classmethod
def new(cls, context, instance_uuid):
"""Create an InfoCache object that can be used to create the DB
entry for the first time.
When save()ing this object, the info_cache_update() DB call
will properly handle creating it if it doesn't exist already.
"""
info_cache = cls()
info_cache.instance_uuid = instance_uuid
info_cache.network_info = None
info_cache._context = context
# Leave the fields dirty
return info_cache
@base.remotable_classmethod
def get_by_instance_uuid(cls, context, instance_uuid):
db_obj = db.instance_info_cache_get(context, instance_uuid)
if not db_obj:
raise exception.InstanceInfoCacheNotFound(
instance_uuid=instance_uuid)
return cls._from_db_object(context, cls(context), db_obj)
# TODO(stephenfin): Remove 'update_cells' in version 2.0
@base.remotable
def save(self, update_cells=True):
if 'network_info' in self.obj_what_changed():
nw_info_json = self.fields['network_info'].to_primitive(
self, 'network_info', self.network_info)
inst_uuid = self.instance_uuid
try:
rv = db.instance_info_cache_update(
self._context, inst_uuid, {'network_info': nw_info_json})
except db_exc.DBReferenceError as exp:
if exp.key != 'instance_uuid':
raise
# NOTE(melwitt): It is possible for us to fail here with a
# foreign key constraint violation on instance_uuid when we
# attempt to save the instance network info cache after
# receiving a network-changed external event from neutron
# during a cross-cell migration. This means the instance record
# is not found in this cell database and we can raise
# InstanceNotFound to signal that in a way that callers know
# how to handle.
raise exception.InstanceNotFound(instance_id=inst_uuid)
self._from_db_object(self._context, self, rv)
self.obj_reset_changes()
@base.remotable
def delete(self):
db.instance_info_cache_delete(self._context, self.instance_uuid)
@base.remotable
def refresh(self):
current = self.__class__.get_by_instance_uuid(self._context,
self.instance_uuid)
current._context = None
for field in self.fields:
if (self.obj_attr_is_set(field)
and getattr(self, field) != getattr(current, field)):
setattr(self, field, getattr(current, field))
self.obj_reset_changes()
