ariatosca-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mxm...@apache.org
Subject [1/2] incubator-ariatosca git commit: wip
Date Thu, 18 May 2017 17:06:50 GMT
Repository: incubator-ariatosca
Updated Branches:
  refs/heads/ARIA-258-Convert-runtime-properties-to-attributes 5e5a25389 -> e2f5e25a8


wip


Project: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/commit/b8b7c704
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/tree/b8b7c704
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/diff/b8b7c704

Branch: refs/heads/ARIA-258-Convert-runtime-properties-to-attributes
Commit: b8b7c704d23577d517bde1f2b03d797c85e7a803
Parents: 5e5a253
Author: max-orlov <maxim@gigaspaces.com>
Authored: Thu May 18 16:31:24 2017 +0300
Committer: max-orlov <maxim@gigaspaces.com>
Committed: Thu May 18 16:31:24 2017 +0300

----------------------------------------------------------------------
 aria/orchestrator/context/common.py          | 157 +++++++---------------
 tests/orchestrator/context/test_operation.py |  31 +++--
 2 files changed, 61 insertions(+), 127 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/b8b7c704/aria/orchestrator/context/common.py
----------------------------------------------------------------------
diff --git a/aria/orchestrator/context/common.py b/aria/orchestrator/context/common.py
index d41566b..9f41071 100644
--- a/aria/orchestrator/context/common.py
+++ b/aria/orchestrator/context/common.py
@@ -203,147 +203,82 @@ class BaseContext(object):
 
 
 class _InstrumentedCollection(object):
-    def __init__(self, actor, attributes, model, nested=None):
+    def __init__(self, parent, model, nested=None):
         super(_InstrumentedCollection, self).__init__()
-        self._actor = actor
-        self._attributes = attributes
+        self._parent = parent
         self._model = model
         self._attr_cls = self._model.parameter.model_cls
-        self._nested = nested or []
+        self._nested = nested or None
 
-    @property
-    def _nested_value(self):
-        current = self._attributes
-        for k in self._nested:
-            current = current[k]
-        return current.value if isinstance(current, self._attr_cls) else current
-
-    def __getitem__(self, index):
-        value = self._nested_value[index] if self._nested else self._attributes[index].value
+    def __getitem__(self, key):
+        if isinstance(self._parent.get(key), self._attr_cls):
+            value = self._parent[key].value
+        else:
+            value = self._parent[key]
 
         if isinstance(value, list):
-            return _List(self._actor,
-                         self._attributes,
-                         self._model,
-                         nested=self._nested + [index])
+            return _InstrumentedList(self, self._model, key, _dict=value)
         elif isinstance(value, dict):
-            return _Dict(self._actor,
-                         self._attributes,
-                         self._model,
-                         nested=self._nested + [index])
-        elif isinstance(value, self._attr_cls):
-            return value.value
-
-        return value
-
-    def __delitem__(self, key):
-        del self._nested_value[key]
+            return _InstrumentedDict(self, self._model, key, _dict=value)
+        else:
+            return value
 
-    def __len__(self):
-        return len(self._nested_value)
 
-    def __nonzero__(self):
-        return bool(self._nested_value)
+class _InstrumentedDict(_InstrumentedCollection, dict):
 
+    def __init__(self, *args, **kwargs):
+        dict_ = kwargs.pop('_dict', False)
+        super(_InstrumentedDict, self).__init__(*args, **kwargs)
+        if dict_:
+            dict.__init__(self, dict_ or {})
 
-class _Dict(_InstrumentedCollection, collections.MutableMapping):
+    def _set(self, key, value):
+        dict.__setitem__(self, key, value.value if isinstance(value, self._attr_cls) else
value)
 
     def __setitem__(self, key, value):
-        if self._nested or key in self._attributes:
-            attribute = self._update_attr(key, value)
-            self._model.parameter.update(attribute)
+        self._set(key, value)
+        if self._nested is not None:
+            self._update_parent(self._nested, key, value)
         else:
-            attr = value if isinstance(value, self._attr_cls) else self._attr_cls.wrap(key,
value)
-            self._attributes[key] = attr
+            if isinstance(value, self._attr_cls):
+                attr = value
+            else:
+                attr = self._attr_cls.wrap(key, value)
+            self._update_parent(key, key, attr)
             self._model.parameter.put(attr)
 
-    def _update_attr(self, key, value):
-        current = self._attributes
-
-        # If this is nested, lets extract the Parameter itself
-        if self._nested:
-            attribute = current = current[self._nested[0]]
-            for k in self._nested[1:]:
-                current = current[k]
-            if isinstance(current, self._attr_cls):
-                current.value[key] = value
-            else:
-                current[key] = value
-        elif isinstance(current[key], self._attr_cls):
-            attribute = current[key]
-            attribute.value = value
+    def _update_parent(self, nested_key, key, value):
+        if isinstance(self._parent.get(self._nested), self._attr_cls):
+            self._parent[nested_key].value[key] = value
         else:
-            raise BaseException()
-
-        # Since this a user defined parameter, this doesn't track changes. So we override
the entire
-        # thing.
-        if isinstance(attribute.value, (dict, list)):
-            value = attribute.value.copy()
-            attribute.value.clear()
-        attribute.value = value
-        return attribute
-
-    def keys(self):
-        dict_ = (self._nested_value.value
-                 if isinstance(self._nested_value, self._attr_cls)
-                 else self._nested_value)
-        for key in dict_.keys():
-            yield key
-
-    def values(self):
-        for val in self._nested_value.values():
-            if isinstance(val, self._attr_cls):
-                yield val.value
-            else:
-                yield val
-
-    def items(self):
-        for key in self._nested_value:
-            val = self._nested_value[key]
-            if isinstance(val, self._attr_cls):
-                yield key, val.value
+            if nested_key == key:
+                self._parent[nested_key] = value
             else:
-                yield key, val
-
-    def __dict__(self):
-        return dict(item for item in self.items())
-
-    def __iter__(self):
-        for key in self._nested_value.keys():
-            yield key
-
-    def __copy__(self):
-        return dict((k, v) for k, v in self.items())
-
-    def __deepcopy__(self, *args, **kwargs):
-        return self.__copy__()
-
-    def copy(self):
-        return self.__copy__()
+                self._parent[nested_key] = {key: value}
 
     def clear(self):
-        self._nested_value.clear()
+        self._parent.clear()
 
 
-class _List(_InstrumentedCollection, collections.MutableSequence):
+class _InstrumentedList(_InstrumentedCollection, collections.MutableSequence):
 
     def insert(self, index, value):
-        if self._nested:
+        if self._nested is not None:
             attribute = self._update_attr(index, value)
             self._model.parameter.update(attribute)
-        elif len(self._attributes) > index:
-            self._attributes[index].value = value
-            self._model.parameter.update(self._attributes[index])
+        elif len(self._parent) > index:
+            self._parent[index].value = value
+            self._model.parameter.update(self._parent[index])
         else:
             attr = value if isinstance(value, self._attr_cls) else self._attr_cls.wrap(index,
value)
-            self._attributes.insert(index, attr)
-            self._model.parameter.put(self._attributes)
+            self._parent.insert(index, attr)
+            self._model.parameter.put(self._parent)
 
     def __setitem__(self, index, value):
         return self.insert(index, value)
 
     def _update_attr(self, index, value):
-        attribute = current = self._attributes[self._nested[0]]
+        attribute = current = self._parent[self._nested[0]]
         for i in self._nested[1:]:
             current = current[i]
         if isinstance(current, self._attr_cls):
@@ -364,7 +299,7 @@ class _List(_InstrumentedCollection, collections.MutableSequence):
         return attribute
 
     def __eq__(self, other):
-        return self._nested_value.__eq__(other)
+        return self._parent.__eq__(other)
 
 
 class InstrumentCollection(object):
@@ -389,8 +324,8 @@ class InstrumentCollection(object):
             self._actor = func(func_self, *args, **kwargs)
             field = getattr(self._actor, self._field_name)
             if isinstance(field, dict):
-                setattr(self, self._field_name, _Dict(self._actor, field, func_self.model))
+                setattr(self, self._field_name, _InstrumentedDict(self._actor, field, func_self.model))
             elif isinstance(field, list):
-                setattr(self, self._field_name, _List(self._actor, field, func_self.model))
+                setattr(self, self._field_name, _InstrumentedList(self._actor, field, func_self.model))
             return self
         return _wrapper

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/b8b7c704/tests/orchestrator/context/test_operation.py
----------------------------------------------------------------------
diff --git a/tests/orchestrator/context/test_operation.py b/tests/orchestrator/context/test_operation.py
index 44823d1..a7656e5 100644
--- a/tests/orchestrator/context/test_operation.py
+++ b/tests/orchestrator/context/test_operation.py
@@ -525,7 +525,7 @@ class TestDict(object):
         return MockModel()
 
     def test_keys(self, model, actor):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor, actor.attributes_dict, model)
         actor.attributes_dict.update(
             {
                 'key1': Parameter.wrap('key1', 'value1'),
@@ -535,7 +535,7 @@ class TestDict(object):
         assert sorted(dict_.keys()) == sorted(['key1', 'key2'])
 
     def test_values(self, model, actor):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor, actor.attributes_dict, model)
         actor.attributes_dict.update({
             'key1': Parameter.wrap('key1', 'value1'),
             'key2': Parameter.wrap('key1', 'value2')
@@ -543,7 +543,7 @@ class TestDict(object):
         assert sorted(dict_.values()) == sorted(['value1', 'value2'])
 
     def test_items(self, actor, model):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor, actor.attributes_dict, model)
         actor.attributes_dict.update({
             'key1': Parameter.wrap('key1', 'value1'),
             'key2': Parameter.wrap('key1', 'value2')
@@ -551,7 +551,7 @@ class TestDict(object):
         assert sorted(dict_.items()) == sorted([('key1', 'value1'), ('key2', 'value2')])
 
     def test_iter(self, actor, model):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor, actor.attributes_dict, model)
         actor.attributes_dict.update({
             'key1': Parameter.wrap('key1', 'value1'),
             'key2': Parameter.wrap('key1', 'value2')
@@ -559,7 +559,7 @@ class TestDict(object):
         assert sorted(list(dict_)) == sorted(['key1', 'key2'])
 
     def test_bool(self, actor, model):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor, actor.attributes_dict, model)
         assert not dict_
         actor.attributes_dict.update({
             'key1': Parameter.wrap('key1', 'value1'),
@@ -568,29 +568,28 @@ class TestDict(object):
         assert dict_
 
     def test_set_item(self, actor, model):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor.attributes_dict, model)
         dict_['key1'] = Parameter.wrap('key1', 'value1')
-        assert 'key1' in dict_
-        assert isinstance(dict_._attributes['key1'], Parameter)
         assert dict_['key1'] == 'value1'
+        assert isinstance(dict_._parent['key1'], Parameter)
 
         dict_['key1'] = {}
         dict_['key1']['inner_key'] = 'value2'
 
-        assert isinstance(dict_._attributes['key1'], Parameter)
+        assert isinstance(dict_._parent['key1'], Parameter)
         assert len(dict_) == 1
         assert 'inner_key' in dict_['key1']
-        assert isinstance(dict_['key1'], common._Dict)
+        assert isinstance(dict_['key1'], common._InstrumentedDict)
         assert dict_['key1']['inner_key'] == 'value2'
 
     def test_get_item(self, actor, model):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor, actor.attributes_dict, model)
         dict_['key1'] = Parameter.wrap('key1', 'value1')
 
         assert isinstance(dict_._attributes['key1'], Parameter)
 
     def test_update(self, actor, model):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor, actor.attributes_dict, model)
         dict_['key1'] = 'value1'
 
         new_dict = {'key2': 'value2'}
@@ -604,7 +603,7 @@ class TestDict(object):
         assert new_dict['key1'] == dict_['key1']
 
     def test_copy(self, actor, model):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor, actor.attributes_dict, model)
         dict_['key1'] = 'value1'
 
         new_dict = dict_.copy()
@@ -616,7 +615,7 @@ class TestDict(object):
         assert dict_['key1'] == 'value2'
 
     def test_clear(self, actor, model):
-        dict_ = common._Dict(actor, actor.attributes_dict, model)
+        dict_ = common._InstrumentedDict(actor, actor.attributes_dict, model)
         dict_['key1'] = 'value1'
         dict_.clear()
 
@@ -633,7 +632,7 @@ class TestList(object):
         return MockModel()
 
     def test_insert(self, model, actor):
-        list_ = common._List(actor, actor.attributes_list, model)
+        list_ = common._InstrumentedList(actor, actor.attributes_list, model)
         list_.append(Parameter.wrap('name', 'value1'))
         list_.append('value2')
 
@@ -652,7 +651,7 @@ class TestList(object):
         assert list_[1] == 'new_value2'
 
     def test_insert_into_nested(self, model, actor):
-        list_ = common._List(actor, actor.attributes_list, model)
+        list_ = common._InstrumentedList(actor, actor.attributes_list, model)
         list_.append([])
 
         list_[0].append('inner_item')


Mime
View raw message