Add prefix and negate_prefix to container

napalm_yang/mappings/eos/translators/openconfig-network-instance/includes/static_routes.yaml

@@ -3,7 +3,19 @@ _process:
     - mode: gate
       when: "{{ protocol_key != 'static static' }}"
 static:
-    _process: unnecessary
+    _process:
+      - mode: container
+        prefix: "ip route {{ static_key }}"
+        negate: "no ip route {{ static_key }}\n"
+        negate_prefix: "no ip route {{ static_key }}"
+        when: "{{ network_instance_key == 'global' }}"
+        in: "network-instances"
+      - mode: container
+        prefix: "ip route vrf {{ network_instance_key }} {{ static_key }}"
+        negate: "no ip route vrf {{ network_instance_key }} {{ static_key }}\n"
+        negate_prefix: "no ip route vrf {{ network_instance_key }} {{ static_key }}"
+        when: "{{ network_instance_key != 'global' }}"
+        in: "network-instances"
     config:
         _process: unnecessary
         prefix:
@@ -15,29 +27,18 @@ static:
         next-hop:
             _process:
               - mode: container
-                key_value: "ip route {{ static_key }} {{ next_hop_key }}\n"
-                negate: "no ip route {{ static_key }} {{ next_hop_key }}\n"
-                when: "{{ network_instance_key == 'global' }}"
-                in: "network-instances"
-              - mode: container
-                key_value: "ip route vrf {{ network_instance_key }} {{ static_key }} {{ next_hop_key }}\n"
-                negate: "no ip route vrf {{ network_instance_key }} {{ static_key }} {{ next_hop_key }}\n"
-                when: "{{ network_instance_key != 'global' }}"
-                in: "network-instances"
+                key_value: "{{ extra_vars.prefix }} {{ next_hop_key }}"
+                negate: "{{ extra_vars.negate_prefix }} {{ next_hop_key }}"
+                end: "\n"
             config:
                 _process: unnecessary
                 index:
                     _process: not_implemented
                 metric:
                     _process:
                       - mode: element
-                        value: "ip route {{ static_key }} {{ next_hop_key }} {{ model }}\n"
-                        negate: "ip route {{ static_key }} {{ next_hop_key }} 1\n"
-                        when: "{{ network_instance_key == 'global' }}"
-                      - mode: element
-                        value: "ip route vrf {{ network_instance_key }} {{ static_key }} {{ next_hop_key }} {{ model }}\n"
-                        negate: "ip route vrf {{ network_instance_key }} {{ static_key }} {{ next_hop_key }} 1\n"
-                        when: "{{ network_instance_key != 'global' }}"
+                        value: " {{ model }}"
+                        negate: " 1"
                 next-hop:
                     _process: unnecessary
                 recurse:

napalm_yang/translator.py

@@ -10,7 +10,7 @@ class Translator(object):
 
     def __init__(self, model, profile,
                  translation=None, keys=None, bookmarks=None,
-                 merge=None, replace=None, other=None):
+                 merge=None, replace=None, other=None, extra_vars=None):
         self.model = model
         self.profile = profile
         self._defining_module = model._defining_module
@@ -19,6 +19,7 @@ def __init__(self, model, profile,
         self.translation = translation
         self.keys = keys or {"parent_key": None}
         self.bookmarks = bookmarks or {self._yang_name: translation, "parent": translation}
+        self.extra_vars = extra_vars or {}
 
         self.merge = merge
         self.replace = replace
@@ -62,15 +63,16 @@ def _translate_container(self, attribute, model, mapping, translation, other):
             self.bookmarks["parent"] = translation
 
             rule = helpers.resolve_rule(mapping["_process"], attribute, self.keys,
-                                        None, model, self.bookmarks)
+                                        self.extra_vars, model, self.bookmarks)
 
-            et = self.translator.translate_container(attribute, model, other, rule,
+            et, extra_vars = self.translator.translate_container(attribute, model, other, rule,
                                                      translation, self.bookmarks)
 
             if et is None:
                 return
 
             self.bookmarks[attribute] = et
+            self.extra_vars.update(extra_vars)
         else:
             et = translation
 
@@ -84,7 +86,7 @@ def _translate_container(self, attribute, model, mapping, translation, other):
             if v._defining_module != self._defining_module and v._defining_module is not None:
                 logger.debug("Skipping attribute: {}:{}".format(v._defining_module, attribute))
                 translator = Translator(v, self.profile, et, self.keys,
-                                        self.bookmarks, self.merge, self.replace, other_attr)
+                                        self.bookmarks, self.merge, self.replace, other_attr, self.extra_vars)
                 translator.translate()
             else:
                 self._translate(k, v, mapping[v._yang_name], et, other_attr)
@@ -112,11 +114,11 @@ def _translate_list(self, attribute, model, mapping, translation, other):
             self.keys["parent_key"] = key
 
             translation_rule = helpers.resolve_rule(mapping["_process"], attribute,
-                                                    self.keys, None, element, self.bookmarks)
+                                                    self.keys, self.extra_vars, element, self.bookmarks)
 
             self.translator.default_element(translation_rule, translation, self.bookmarks,
                                             replacing=True)
-            et = self.translator.init_element(attribute, element, other_element, translation_rule,
+            et, extra_vars = self.translator.init_element(attribute, element, other_element, translation_rule,
                                               translation, self.bookmarks)
 
             if et is None:
@@ -125,6 +127,7 @@ def _translate_list(self, attribute, model, mapping, translation, other):
 
             self.bookmarks[attribute][key] = et
             self.bookmarks["parent"] = et
+            self.extra_vars.update(extra_vars)
 
             self._translate(attribute, element, mapping, et, other_element)
 
@@ -149,7 +152,7 @@ def _default_element_list(self, attribute, running, mapping, translation, candid
                 self.keys["parent_key"] = key
 
                 translation_rule = helpers.resolve_rule(mapping["_process"], attribute,
-                                                        self.keys, None, element,
+                                                        self.keys, self.extra_vars, element,
                                                         self.bookmarks)
 
                 self.translator.default_element(translation_rule, translation, self.bookmarks)

napalm_yang/translators/base.py

@@ -18,19 +18,23 @@ def __init__(self, merge, replace):
 
     def init_element(self, attribute, model, other, mapping, translation, bookmarks):
         et = translation
+        extra_vars = {}
         for m in mapping:
             if m["mode"] == "skip":
                 continue
             elif m["mode"] == "gate":
-                return
+                return None, {}
 
             t = _find_translation_point(m, bookmarks, et)
             method_name = "_init_element_{}".format(m["mode"])
             et = getattr(self, method_name)(attribute, model, other, m, t)
+            if isinstance(et, tuple):
+                extra_vars = et[1]
+                et = et[0]
             if et is False:
                 # if it's False we want to return None to signal we want to abort
-                return None
-        return et
+                return None, {}
+        return et, extra_vars
 
     def default_element(self, mapping, translation, bookmarks, replacing=False):
         t = translation
@@ -57,16 +61,17 @@ def translate_leaf(self, attribute, model, other, mapping, translation, bookmark
 
     def translate_container(self, attribute, model, other, mapping, translation, bookmarks):
         et = translation
+        extra_vars = {}
         for m in mapping:
             if m["mode"] == "skip":
                 continue
             elif m["mode"] == "gate":
-                return
+                return None, {}
 
             t = _find_translation_point(m, bookmarks, et)
             method_name = "_translate_container_{}".format(m["mode"])
-            et = getattr(self, method_name)(attribute, model, other, m, t)
+            et, extra_vars = getattr(self, method_name)(attribute, model, other, m, t)
             if et is False:
                 # if it's False we want to return None to signal we want to abort
-                return None
-        return et
+                return None, {}
+        return et, extra_vars

napalm_yang/translators/text.py

@@ -33,28 +33,34 @@ def _translate_leaf_element(self, attribute, model, other, mapping, translation)
         super()._translate_leaf_element(attribute, model, other, mapping, translation, force)
 
     def _init_element_container(self, attribute, model, other, mapping, translation):
+        extra_vars = {}
+
         if other is not None:
             if not napalm_yang.utils.diff(model, other) and not self.replace:
                 # If objects are equal we return None as that aborts translating
                 # the rest of the object
-                return False
+                return False, {}
 
         if not model._changed() and other is not None and not self.replace:
             mapping["key_value"] = mapping["negate"]
         if not model._changed() and other is not None and self.replace:
-            return translation
+            return translation, {}
 
         mapping["key_element"] = "command"
         mapping["container"] = model._yang_name
 
+        for i in ('prefix', 'negate_prefix'):
+            if i in mapping:
+                extra_vars[i] = mapping.pop(i)
+
         t = super()._init_element_container(attribute, model, other, mapping, translation)
 
         end = mapping.get("end", "")
         if end and t is not None:
             e = etree.SubElement(translation, "command")
             e.text = end
 
-        return t
+        return t, extra_vars
 
     #  def _translate_container_container(self, attribute, model, other, mapping, translation):
     #      mapping["key_element"] = "container"
@@ -76,7 +82,7 @@ def _default_element_container(self, mapping, translation, replacing):
 
     def _xml_to_text(self, xml, text=""):
         for element in xml:
-            if element.tag == "command":
+            if element.tag == "command" and element.text is not None:
                 text += element.text
             text += self._xml_to_text(element)
         return text