def setUp(self):
super(TestObject, self).setUp()
class TestableObject(obj_base.NovaObject):
fields = {
'uuid': fields.StringField(),
}
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()
self._test_cls = TestableObject
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), (test_inst, test_inst)]
def setUp(self):
super(TestField, self).setUp()
self.field = fields.Field(FakeFieldType())
self.coerce_good_values = [('foo', '*foo*')]
self.coerce_bad_values = []
self.to_primitive_values = [('foo', '!foo!')]
self.from_primitive_values = [('!foo!', 'foo')]
def setUp(self):
super(TestList, self).setUp()
self.field = fields.Field(fields.List(FakeFieldType()))
self.coerce_good_values = [(['foo', 'bar'], ['*foo*', '*bar*'])]
self.coerce_bad_values = ['foo']
self.to_primitive_values = [(['foo'], ['!foo!'])]
self.from_primitive_values = [(['!foo!'], ['foo'])]
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(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(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'})]
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})
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()