--- /dev/null
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You 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.
+
+"""
+Utilities for instrumenting collections of models in storage.
+"""
+
+from . import exceptions
+
+
+class _InstrumentedCollection(object):
+
+ def __init__(self,
+ mapi,
+ parent,
+ field_name,
+ field_cls,
+ seq=None,
+ is_top_level=True,
+ **kwargs):
+ self._mapi = mapi
+ self._parent = parent
+ self._field_name = field_name
+ self._is_top_level = is_top_level
+ self._field_cls = field_cls
+ self._load(seq, **kwargs)
+
+ @property
+ def _raw(self):
+ raise NotImplementedError
+
+ def _load(self, seq, **kwargs):
+ """
+ Instantiates the object from existing seq.
+
+ :param seq: the original sequence to load from
+ """
+ raise NotImplementedError
+
+ def _set(self, key, value):
+ """
+ Sets the changes for the current object (not in the database).
+
+ :param key:
+ :param value:
+ """
+ raise NotImplementedError
+
+ def _del(self, collection, key):
+ raise NotImplementedError
+
+ def _instrument(self, key, value):
+ """
+ Instruments any collection to track changes (and ease of access).
+
+ :param key:
+ :param value:
+ """
+ if isinstance(value, _InstrumentedCollection):
+ return value
+ elif isinstance(value, dict):
+ instrumentation_cls = _InstrumentedDict
+ elif isinstance(value, list):
+ instrumentation_cls = _InstrumentedList
+ else:
+ return value
+
+ return instrumentation_cls(self._mapi, self, key, self._field_cls, value, False)
+
+ def _raw_value(self, value):
+ """
+ Gets the raw value.
+
+ :param value:
+ """
+ if isinstance(value, self._field_cls):
+ return value.value
+ return value
+
+ def _encapsulate_value(self, key, value):
+ """
+ Creates a new item class if needed.
+
+ :param key:
+ :param value:
+ """
+ if isinstance(value, self._field_cls):
+ return value
+ # If it is not wrapped
+ return self._field_cls.wrap(key, value)
+
+ def __setitem__(self, key, value):
+ """
+ Updates the values in both the local and the database locations.
+
+ :param key:
+ :param value:
+ """
+ self._set(key, value)
+ if self._is_top_level:
+ # We are at the top level
+ field = getattr(self._parent, self._field_name)
+ self._set_field(
+ field, key, value if key in field else self._encapsulate_value(key, value))
+ self._mapi.update(self._parent)
+ else:
+ # We are not at the top level
+ self._set_field(self._parent, self._field_name, self)
+
+ def _set_field(self, collection, key, value):
+ """
+ Enables updating the current change in the ancestors.
+
+ :param collection: collection to change
+ :param key: key for the specific field
+ :param value: new value
+ """
+ if isinstance(value, _InstrumentedCollection):
+ value = value._raw
+ if key in collection and isinstance(collection[key], self._field_cls):
+ if isinstance(collection[key], _InstrumentedCollection):
+ self._del(collection, key)
+ collection[key].value = value
+ else:
+ collection[key] = value
+ return collection[key]
+
+ def __deepcopy__(self, *args, **kwargs):
+ return self._raw
+
+
+class _InstrumentedDict(_InstrumentedCollection, dict):
+
+ def _load(self, dict_=None, **kwargs):
+ dict.__init__(
+ self,
+ tuple((key, self._raw_value(value)) for key, value in (dict_ or {}).iteritems()),
+ **kwargs)
+
+ def update(self, dict_=None, **kwargs):
+ dict_ = dict_ or {}
+ for key, value in dict_.iteritems():
+ self[key] = value
+ for key, value in kwargs.iteritems():
+ self[key] = value
+
+ def __getitem__(self, key):
+ return self._instrument(key, dict.__getitem__(self, key))
+
+ def _set(self, key, value):
+ dict.__setitem__(self, key, self._raw_value(value))
+
+ @property
+ def _raw(self):
+ return dict(self)
+
+ def _del(self, collection, key):
+ del collection[key]
+
+
+class _InstrumentedList(_InstrumentedCollection, list):
+
+ def _load(self, list_=None, **kwargs):
+ list.__init__(self, list(item for item in list_ or []))
+
+ def append(self, value):
+ self.insert(len(self), value)
+
+ def insert(self, index, value):
+ list.insert(self, index, self._raw_value(value))
+ if self._is_top_level:
+ field = getattr(self._parent, self._field_name)
+ field.insert(index, self._encapsulate_value(index, value))
+ else:
+ self._parent[self._field_name] = self
+
+ def __getitem__(self, key):
+ return self._instrument(key, list.__getitem__(self, key))
+
+ def _set(self, key, value):
+ list.__setitem__(self, key, value)
+
+ def _del(self, collection, key):
+ del collection[key]
+
+ @property
+ def _raw(self):
+ return list(self)
+
+
+class _WrappedBase(object):
+
+ def __init__(self, wrapped, instrumentation, instrumentation_kwargs=None):
+ """
+ :param wrapped: model to be instrumented
+ :param instrumentation: instrumentation dict
+ :param instrumentation_kwargs: arguments for instrumentation class
+ """
+ self._wrapped = wrapped
+ self._instrumentation = instrumentation
+ self._instrumentation_kwargs = instrumentation_kwargs or {}
+
+ def _wrap(self, value):
+ if value.__class__ in set(class_.class_ for class_ in self._instrumentation):
+ return _create_instrumented_model(
+ value, instrumentation=self._instrumentation, **self._instrumentation_kwargs)
+ # Check that the value is a SQLAlchemy model (it should have metadata) or a collection
+ elif hasattr(value, 'metadata') or isinstance(value, (dict, list)):
+ return _create_wrapped_model(
+ value, instrumentation=self._instrumentation, **self._instrumentation_kwargs)
+ return value
+
+ def __getattr__(self, item):
+ if hasattr(self, '_wrapped'):
+ return self._wrap(getattr(self._wrapped, item))
+ else:
+ super(_WrappedBase, self).__getattribute__(item)
+
+
+class _InstrumentedModel(_WrappedBase):
+
+ def __init__(self, mapi, *args, **kwargs):
+ """
+ The original model.
+
+ :param mapi: MAPI for the wrapped model
+ :param wrapped: model to be instrumented
+ :param instrumentation: instrumentation dict
+ :param instrumentation_kwargs: arguments for instrumentation class
+ """
+ super(_InstrumentedModel, self).__init__(instrumentation_kwargs=dict(mapi=mapi),
+ *args, **kwargs)
+ self._mapi = mapi
+ self._apply_instrumentation()
+
+ def _apply_instrumentation(self):
+ for field in self._instrumentation:
+ if not issubclass(type(self._wrapped), field.parent.class_):
+ # Do not apply if this field is not for our class
+ continue
+
+ field_name = field.key
+ field_cls = field.mapper.class_
+
+ field = getattr(self._wrapped, field_name)
+
+ # Preserve the original field, e.g. original "attributes" would be located under
+ # "_attributes"
+ setattr(self, '_{0}'.format(field_name), field)
+
+ # Set instrumented value
+ if isinstance(field, dict):
+ instrumentation_cls = _InstrumentedDict
+ elif isinstance(field, list):
+ instrumentation_cls = _InstrumentedList
+ else:
+ # TODO: raise proper error
+ raise exceptions.StorageError(
+ "ARIA supports instrumentation for dict and list. Field {field} of the "
+ "class `{model}` is of type `{type}`.".format(
+ field=field,
+ model=self._wrapped,
+ type=type(field)))
+
+ instrumented_class = instrumentation_cls(seq=field,
+ parent=self._wrapped,
+ mapi=self._mapi,
+ field_name=field_name,
+ field_cls=field_cls)
+ setattr(self, field_name, instrumented_class)
+
+
+class _WrappedModel(_WrappedBase):
+
+ def __getitem__(self, item):
+ return self._wrap(self._wrapped[item])
+
+ def __iter__(self):
+ for item in self._wrapped.__iter__():
+ yield self._wrap(item)
+
+
+def _create_instrumented_model(original_model, mapi, instrumentation):
+ return type('Instrumented{0}'.format(original_model.__class__.__name__),
+ (_InstrumentedModel,),
+ {})(wrapped=original_model, instrumentation=instrumentation, mapi=mapi)
+
+
+def _create_wrapped_model(original_model, mapi, instrumentation):
+ return type('Wrapped{0}'.format(original_model.__class__.__name__),
+ (_WrappedModel, ),
+ {})(wrapped=original_model,
+ instrumentation=instrumentation,
+ instrumentation_kwargs=dict(mapi=mapi))
+
+
+def instrument(instrumentation, original_model, mapi):
+ for instrumented_field in instrumentation:
+ if isinstance(original_model, instrumented_field.class_):
+ return _create_instrumented_model(original_model, mapi, instrumentation)
+
+ return _create_wrapped_model(original_model, mapi, instrumentation)
Code Review / multicloud / azure.git / blobdiff