Merge branch 'develop'

Author: miott

Makefile

@@ -84,4 +84,22 @@ help:
 				helpMessage = ""; \
 			} \
 		}' \
-		$(MAKEFILE_LIST)
+		$(MAKEFILE_LIST)
+
+## Setup links in virtual env for development
+develop:
+	@echo "--------------------------------------------------------------------"
+	@echo "Setting up development environment"
+	@python setup.py develop -q
+	@echo ""
+	@echo "Done."
+	@echo ""
+
+## Remove development links in virtual env
+undevelop:
+	@echo "--------------------------------------------------------------------"
+	@echo "Removing development environment"
+	@python setup.py develop -q --uninstall
+	@echo ""
+	@echo "Done."
+	@echo ""

src/cisco_gnmi/client.py

@@ -24,7 +24,11 @@
 """Python gNMI wrapper to ease usage of gNMI."""
 
 import logging
+from collections import OrderedDict
 from xml.etree.ElementPath import xpath_tokenizer_re
+import re
+import json
+import os
 from six import string_types
 
 from . import proto
@@ -152,7 +156,9 @@ def get(
             "encoding", encoding, "Encoding", proto.gnmi_pb2.Encoding
         )
         request = proto.gnmi_pb2.GetRequest()
-        if not isinstance(paths, (list, set)):
+        try:
+            iter(paths)
+        except TypeError:
             raise Exception("paths must be an iterable containing Path(s)!")
         request.path.extend(paths)
         request.type = data_type
@@ -334,3 +340,172 @@ def parse_xpath_to_gnmi_path(self, xpath, origin=None):
             raise Exception("Unfinished elements in XPath parsing!")
         path.elem.extend(path_elems)
         return path
+
+    def combine_configs(self, payload, last_xpath, xpath, config):
+        last_set = set(last_xpath.split('/'))
+        curr_diff = set(xpath.split('/')) - last_set
+        if len(curr_diff) > 1:
+            print('combine_configs() error1')
+            return payload
+        index = curr_diff.pop()
+        curr_xpath = xpath[xpath.find(index):]
+        curr_xpath = curr_xpath.split('/')
+        curr_xpath.reverse()
+        for seg in curr_xpath:
+            config = {seg: config}
+
+        last_diff = last_set - set(xpath.split('/'))
+        if len(last_diff) > 1:
+            print('combine_configs() error2')
+            return payload
+        last_xpath = last_xpath[last_xpath.find(last_diff.pop()):]
+        last_xpath = last_xpath.split('/')
+        last_xpath.reverse()
+        for seg in last_xpath:
+            if seg not in payload:
+                payload = {seg: payload}
+        payload.update(config)
+        return payload
+
+    def xpath_to_json(self, configs, last_xpath='', payload={}):
+        for i, cfg in enumerate(configs, 1):
+            xpath, config, is_key = cfg
+            if last_xpath and xpath not in last_xpath:
+                # Branched config here
+                #   |---last xpath config
+                # --|
+                #   |---this xpath config
+                payload = self.combine_configs(payload, last_xpath, xpath, config)
+                return self.xpath_to_json(configs[i:], xpath, payload)
+            xpath_segs = xpath.split('/')
+            xpath_segs.reverse()
+            for seg in xpath_segs:
+                if not seg:
+                    continue
+                if payload:
+                    if is_key:
+                        if seg in payload:
+                            if isinstance(payload[seg], list):
+                                payload[seg].append(config)
+                            elif isinstance(payload[seg], dict):
+                                payload[seg].update(config)
+                        else:
+                            payload.update(config)
+                            payload = {seg: [payload]}
+                    else:
+                        config.update(payload)
+                        payload = {seg: config}
+                    return self.xpath_to_json(configs[i:], xpath, payload)
+                else:
+                    if is_key:
+                        payload = {seg: [config]}
+                    else:
+                        payload = {seg: config}
+                    return self.xpath_to_json(configs[i:], xpath, payload)
+        return payload
+
+    # Pattern to detect keys in an xpath
+    RE_FIND_KEYS = re.compile(r'\[.*?\]')
+
+    def get_payload(self, configs):
+        # Number of updates are limited so try to consolidate into lists.
+        xpaths_cfg = []
+        first_key = set()
+        # Find first common keys for all xpaths_cfg of collection.
+        for config in configs:
+            xpath = next(iter(config.keys()))
+
+            # Change configs to tuples (xpath, config) for easier management
+            xpaths_cfg.append((xpath, config[xpath]))
+
+            xpath_split = xpath.split('/')
+            for seg in xpath_split:
+                if '[' in seg:
+                    first_key.add(seg)
+                    break
+
+        # Common first key/configs represents one GNMI update
+        updates = []
+        for key in first_key:
+            update = []
+            remove_cfg = []
+            for config in xpaths_cfg:
+                xpath, cfg = config
+                if key in xpath:
+                    update.append(config)
+                else:
+                    for k, v in cfg.items():
+                        if '[{0}="{1}"]'.format(k, v) not in key:
+                            break
+                    else:
+                        # This cfg sets the first key so we don't need it
+                        remove_cfg.append((xpath, cfg))
+            if update:
+                for upd in update:
+                    # Remove this config out of main list
+                    xpaths_cfg.remove(upd)
+                for rem_cfg in remove_cfg:
+                    # Sets a key in update path so remove it
+                    xpaths_cfg.remove(rem_cfg)
+                updates.append(update)
+                break
+
+        # Add remaining configs to updates
+        if xpaths_cfg:
+            updates.append(xpaths_cfg)
+
+        # Combine all xpath configs of each update if possible
+        xpaths = []
+        compressed_updates = []
+        for update in updates:
+            xpath_consolidated = {}
+            config_compressed = []
+            for seg in update:
+                xpath, config = seg
+                if xpath in xpath_consolidated:
+                    xpath_consolidated[xpath].update(config)
+                else:
+                    xpath_consolidated[xpath] = config
+                    config_compressed.append((xpath, xpath_consolidated[xpath]))
+                    xpaths.append(xpath)
+
+            # Now get the update path for this batch of configs
+            common_xpath = os.path.commonprefix(xpaths)
+            cfg_compressed = []
+            keys = []
+
+            # Need to reverse the configs to build the dict correctly
+            config_compressed.reverse()
+            for seg in config_compressed:
+                is_key = False
+                prepend_path = ''
+                xpath, config = seg
+                end_path = xpath[len(common_xpath):]
+                if end_path.startswith('['):
+                    # Don't start payload with a list
+                    tmp = common_xpath.split('/')
+                    prepend_path = '/' + tmp.pop()
+                    common_xpath = '/'.join(tmp)
+                end_path = prepend_path + end_path
+
+                # Building json, need to identify configs that set keys
+                for key in keys:
+                    if [k for k in config.keys() if k in key]:
+                        is_key = True
+                keys += re.findall(self.RE_FIND_KEYS, end_path)
+                cfg_compressed.append((end_path, config, is_key))
+
+            update = (common_xpath, cfg_compressed)
+            compressed_updates.append(update)
+
+        updates = []
+        for update in compressed_updates:
+            common_xpath, cfgs = update
+            payload = self.xpath_to_json(cfgs)
+            updates.append(
+                (
+                    common_xpath,
+                    json.dumps(payload).encode('utf-8')
+                )
+            )
+        return updates