acex-driver-juniper-junoscli 1.0.0__tar.gz

acex_driver_juniper_junoscli-1.0.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: acex-driver-juniper-junoscli
+Version: 1.0.0
+Summary: ACE-X Driver: Juniper Junos CLI
+License: AGPL-3.0
+Author: Johan Lahti
+Author-email: johan.lahti@acebit.se
+Requires-Python: >=3.13,<4.0
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: acex-devkit (>=1.14.0,<2.0.0)
+Requires-Dist: netmiko (>=4.6.0,<5.0.0)
+Project-URL: Homepage, https://github.com/acex-labs/acex
+Project-URL: Repository, https://github.com/acex-labs/acex

acex_driver_juniper_junoscli-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "acex-driver-juniper-junoscli"
+version = "1.0.0"
+description = "ACE-X Driver: Juniper Junos CLI"
+authors = ["Johan Lahti <johan.lahti@acebit.se>"]
+license = "AGPL-3.0"
+homepage = "https://github.com/acex-labs/acex"
+repository = "https://github.com/acex-labs/acex"
+
+packages = [
+    { include = "acex_driver_juniper_junos_cli", from = "src" }
+]
+
+[tool.poetry.dependencies]
+python = "^3.13"
+netmiko = "^4.6.0"
+acex-devkit = "^1.14.0"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.plugins."acex.neds"]
+juniper_junos_cli = "acex_driver_juniper_junos_cli.junos_cli:JunosCLI"
+
+[dependency-groups]
+dev = [
+    "ipython (>=9.10.0,<10.0.0)"
+]

acex_driver_juniper_junoscli-1.0.0/src/acex_driver_juniper_junos_cli/augment_renderers.py

@@ -0,0 +1,67 @@
+"""
+Per-type rendering of `Augment`-class components into Junos CLI lines.
+
+Mirrors the Cisco driver's dispatch pattern. Augments unknown to this
+driver (no renderer registered for that type) are silently skipped.
+
+Junos-set commands are flat (no indented blocks like Cisco), so renderer
+functions emit fully-formed `set ...` lines. They receive `target_path`
+so they can extract context (e.g. the SNMP community name) from it.
+
+To add a new Juniper augment type:
+  1. Define the augment component + payload model in the backend
+  2. Register a renderer here under its `type` key
+"""
+from collections import defaultdict
+from typing import Callable, Dict, List
+
+
+def _render_snmp_community_clients(aug: dict, target_path: str) -> List[str]:
+    """`set snmp community <name> clients <prefix>` — one line per prefix."""
+    community_name = target_path.rsplit(".", 1)[-1]
+    clients = (aug.get("clients") or {}).get("value") or []
+    return [
+        f"set snmp community {community_name} clients {prefix}"
+        for prefix in clients
+    ]
+
+
+AUGMENT_RENDERERS: Dict[str, Callable[[dict, str], List[str]]] = {
+    "juniper.snmp_community_clients": _render_snmp_community_clients,
+}
+
+
+def resolve_augment_lines(configuration: dict) -> Dict[str, List[str]]:
+    """
+    Walk every targetable tree node, collect its `augments` dict, dispatch each
+    augment to its renderer, and return a {target_path: [cli_line, ...]} dict
+    for use in Jinja.
+
+    Augments unknown to this driver (no renderer registered for that type)
+    are silently skipped — that's the point of augment-on-target dispatch.
+    """
+    by_target: Dict[str, List[str]] = defaultdict(list)
+
+    def _collect(target_path: str, augments: dict):
+        for aug_type, aug in (augments or {}).items():
+            renderer = AUGMENT_RENDERERS.get(aug_type)
+            if renderer is None:
+                continue
+            by_target[target_path].extend(renderer(aug, target_path))
+
+    for name, intf in (configuration.get("interfaces") or {}).items():
+        _collect(f"interfaces.{name}", intf.get("augments"))
+
+    for name, tmpl in (configuration.get("interface_templates") or {}).items():
+        _collect(f"interface_templates.{name}", tmpl.get("augments"))
+
+    # SNMP communities — Junos has per-community augments (e.g. clients list)
+    for name, com in (((configuration.get("system") or {}).get("snmp") or {}).get("communities") or {}).items():
+        _collect(f"system.snmp.communities.{name}", com.get("augments"))
+
+    # Singletons under system.* — extend here as more Augmentable targets land.
+    vtp_cfg = ((configuration.get("system") or {}).get("vtp") or {}).get("config")
+    if vtp_cfg:
+        _collect("system.vtp.config", vtp_cfg.get("augments"))
+
+    return dict(by_target)

acex_driver_juniper_junoscli-1.0.0/src/acex_driver_juniper_junos_cli/junos_cli.py

@@ -0,0 +1,139 @@
+
+from contextlib import contextmanager
+from typing import Optional
+from acex_devkit.models.composed_configuration import ComposedConfiguration
+from acex_devkit.models.node_response import NodeListItem
+from acex_devkit.models.management_connection import ManagementConnection
+from netmiko import ConnectHandler
+
+from acex_devkit.drivers import NetworkElementDriver, TransportBase
+from acex_devkit.configdiffer import Diff
+
+from .renderer import JunosCLIRenderer
+from .parser import JunosCLIParser
+
+
+class JunosCLITransport(TransportBase):
+
+    def __init__(self):
+        self._session_conn: Optional[ConnectHandler] = None
+
+    def _open_connection(self, connection: ManagementConnection, **kwargs) -> ConnectHandler:
+        username = kwargs.get("username")
+        password = kwargs.get("password")
+        if not username or not password:
+            raise ValueError("Credentials required: username and password must be provided")
+        device = {
+            "device_type": "juniper_junos",
+            "host": connection.target_ip,
+            "username": username,
+            "password": password,
+            "port": 22,
+            "conn_timeout": 30,
+        }
+        return ConnectHandler(**device)
+
+    @contextmanager
+    def session(self, connection: ManagementConnection, **kwargs):
+        """Hold one SSH session open for the duration of the block."""
+        conn = self._open_connection(connection, **kwargs)
+        self._session_conn = conn
+        try:
+            yield self
+        finally:
+            self._session_conn = None
+            try:
+                conn.disconnect()
+            except Exception:
+                pass
+
+    @contextmanager
+    def _conn(self, connection: ManagementConnection, **kwargs):
+        """Yield active session conn or open a one-shot, closing what we own."""
+        if self._session_conn is not None:
+            yield self._session_conn
+            return
+        conn = self._open_connection(connection, **kwargs)
+        try:
+            yield conn
+        finally:
+            try:
+                conn.disconnect()
+            except Exception:
+                pass
+
+    def get_config(self, node: NodeListItem, connection: ManagementConnection, **kwargs) -> str:
+        with self._conn(connection, **kwargs) as conn:
+            # `display set` flattens hierarchical config into reproducible
+            # `set` lines; `no-more` disables paging.
+            return conn.send_command(
+                "show configuration | display set | no-more",
+                read_timeout=120,
+            )
+
+    def send_config(self, node: NodeListItem, connection: ManagementConnection, commands: list[str], **kwargs) -> str:
+        # netmiko's juniper_junos handler enters configure mode, sends the
+        # commands, commits, and exits — driven by send_config_set.
+        with self._conn(connection, **kwargs) as conn:
+            return conn.send_config_set(commands)
+
+    def execute(self, node: NodeListItem, connection: ManagementConnection, commands: list[str], **kwargs) -> list[str]:
+        with self._conn(connection, **kwargs) as conn:
+            return [conn.send_command(cmd, read_timeout=120) for cmd in commands]
+
+    def get_lldp_neighbors(self, node: NodeListItem, connection: ManagementConnection, **kwargs) -> list[dict]:
+        with self._conn(connection, **kwargs) as conn:
+            try:
+                raw = conn.send_command("show lldp neighbors", read_timeout=60)
+            except Exception:
+                return []
+            return self._parse_lldp_table(raw)
+
+    @staticmethod
+    def _parse_lldp_table(raw: str) -> list[dict]:
+        # `show lldp neighbors` returns a fixed-width table:
+        # Local Interface  Parent Interface  Chassis Id         Port info  System Name
+        # ge-0/0/0         -                 00:11:22:33:44:55  ge-0/0/1   peer-switch
+        neighbors = []
+        lines = [ln.rstrip() for ln in raw.splitlines() if ln.strip()]
+        # Skip header line if present
+        for line in lines:
+            if line.lower().startswith("local interface"):
+                continue
+            parts = line.split()
+            # Expected at minimum: local, parent, chassis_id, port_id, sysname
+            if len(parts) < 5:
+                continue
+            local_iface = parts[0]
+            remote_port = parts[-2]
+            remote_dev = parts[-1]
+            neighbors.append({
+                "local_interface": local_iface,
+                "remote_device": remote_dev,
+                "remote_interface": remote_port,
+                "discovery_protocol": "lldp",
+            })
+        return neighbors
+
+
+class JunosCLI(NetworkElementDriver):
+    """Juniper Junos CLI driver."""
+
+    version = "1.0.0"
+    renderer_class = JunosCLIRenderer
+    transport_class = JunosCLITransport
+    parser_class = JunosCLIParser
+
+    def render(self, configuration: ComposedConfiguration, asset):
+        return self.renderer.render(configuration, asset)
+
+    def parse(self, configuration: str) -> ComposedConfiguration:
+        return self.parser.parse(configuration)
+
+    def render_patch(self, diff: Diff, node_instance: "NodeInstance"):
+        return self.renderer.render_patch(diff, node_instance)
+
+    def apply_patch(self, diff: Diff, node_instance, node: NodeListItem, connection: ManagementConnection, **kwargs):
+        rendered = self.render_patch(diff, node_instance=node_instance)
+        commands = [c.strip() for c in rendered.splitlines() if c.strip()]
+        return self.transport.send_config(node, connection, commands, **kwargs)

acex_driver_juniper_junoscli-1.0.0/src/acex_driver_juniper_junos_cli/parser.py

@@ -0,0 +1,17 @@
+"""Junos CLI configuration parser.
+
+Parsing a real Junos `show configuration` (hierarchical or set-format) into
+the device-agnostic model is a significant undertaking. This stub keeps the
+driver instantiable so deployment-side flows (render/render_patch/apply_patch)
+work; calling parse() raises until a real implementation lands.
+"""
+
+from acex.plugins.neds.core import ParserBase
+
+
+class JunosCLIParser(ParserBase):
+    def parse(self, configuration: str):
+        raise NotImplementedError(
+            "JunosCLIParser.parse is not yet implemented. "
+            "Implement parsing of `show configuration | display set` output here."
+        )

acex_driver_juniper_junoscli-1.0.0/src/acex_driver_juniper_junos_cli/renderer.py

@@ -0,0 +1,191 @@
+from collections import defaultdict
+from typing import Any, Callable, Dict, List, Optional
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+from acex.plugins.neds.core import RendererBase
+from acex_devkit.configdiffer import Diff
+from acex_devkit.configdiffer.command import Command, Context
+from acex_devkit.models.composed_configuration import ComposedConfiguration
+
+from .augment_renderers import resolve_augment_lines
+
+
+class GeneratorRegistry:
+    def __init__(self):
+        self._patterns: list[tuple[tuple, Callable]] = []
+
+    def register(self, pattern: tuple, generator: Callable):
+        self._patterns.append((pattern, generator))
+
+    def resolve(self, path: tuple):
+        for pattern, generator in self._patterns:
+            if self._match(path, pattern):
+                return generator
+        return None
+
+    def _match(self, path, pattern):
+        if len(path) < len(pattern):
+            return False
+        for p, pat in zip(path, pattern):
+            if pat != "*" and p != pat:
+                return False
+        return True
+
+
+# Junos uses different interface name prefixes per port speed.
+# Speeds are in kbps to match the AttributeValue[int] convention used elsewhere.
+PORT_PREFIX_BY_SPEED = {
+    1_000_000: "ge",         # 1 Gbps
+    10_000_000: "xe",        # 10 Gbps
+    25_000_000: "et",        # 25 Gbps (some platforms)
+    40_000_000: "et",        # 40 Gbps
+    100_000_000: "et",       # 100 Gbps
+}
+
+
+class JunosCLIRenderer(RendererBase):
+
+    def _load_template_file(self) -> str:
+        path = Path(__file__).parent
+        env = Environment(loader=FileSystemLoader(path), undefined=StrictUndefined)
+        return env.get_template("template.j2")
+
+    def render(self, configuration: ComposedConfiguration, asset) -> Any:
+        """Render the configuration model for Junos CLI devices."""
+        if isinstance(configuration, ComposedConfiguration):
+            configuration = configuration.model_dump(mode="json")
+        else:
+            raise ValueError(
+                f"Configuration must be a ComposedConfiguration instance. Not {type(configuration)}"
+            )
+
+        processed_config = self.pre_process(configuration, asset)
+        template = self._load_template_file()
+        return template.render(configuration=processed_config)
+
+    # ── Patch rendering ─────────────────────────────────────────
+    # Junos `set` / `delete` lines are fully qualified per command, so
+    # there's no enter/exit context to track — generators emit complete
+    # lines and rendering is just a join.
+
+    def _register(self):
+        self.registry.register(('system', 'config'), self._generate_system_config_commands)
+        self.registry.register(('interfaces', '*'), self._generate_interface_config_commands)
+
+    def render_patch(self, diff: Diff, node_instance: "NodeInstance"):
+        """Render device commands for a Diff using registered generators."""
+        self.registry = GeneratorRegistry()
+        self._register()
+
+        commands: List[Command] = []
+        for change in diff.get_all_changes():
+            generator = self.registry.resolve(tuple(change.path))
+            if generator is None:
+                continue
+            commands.extend(generator(change, node_instance))
+
+        return "\n".join(c.command for c in commands)
+
+    def _generate_system_config_commands(self, component_change, node_instance) -> List[Command]:
+        ctx = Context(path=[])
+        commands: List[Command] = []
+        for attr in component_change.changed_attributes:
+            if attr.attribute_name == "hostname":
+                if component_change.op in ("add", "change"):
+                    commands.append(Command(context=ctx, command=f"set system host-name {attr.after.value}"))
+                elif component_change.op == "remove":
+                    commands.append(Command(context=ctx, command="delete system host-name"))
+        return commands
+
+    def _generate_interface_config_commands(self, component_change, node_instance) -> List[Command]:
+        # Stub mirroring the Cisco renderer's placeholder — real attribute
+        # mapping per change.op / attr.attribute_name lands here.
+        ctx = Context(path=component_change.path)
+        return [Command(context=ctx, command="set interfaces TODO description \"TODO\"")]
+
+    def pre_process(self, configuration: dict, asset) -> Dict[str, Any]:
+        """Pre-process the configuration model before rendering j2."""
+        configuration = self._physical_interface_names(configuration, asset)
+        self._resolve_lag_lacp(configuration)
+        configuration["augment_lines"] = resolve_augment_lines(configuration)
+        return configuration
+
+    def _resolve_lag_lacp(self, config: dict) -> None:
+        """
+        Bubble per-member LACP settings up to the LAG itself, plus count LAGs
+        for chassis-level `aggregated-devices` config. The model keeps LACP
+        timing/mode on member ports (Cisco-flavored convention); Junos needs
+        them on the LAG.
+
+        Sets on each LAG: `_lacp_enabled`, `_lacp_mode`, `_lacp_interval`.
+        Sets on config root: `_lag_count`.
+        """
+        interfaces = config.get("interfaces") or {}
+
+        members_by_lag: Dict[int, list] = defaultdict(list)
+        for intf in interfaces.values():
+            if intf.get("type") != "ethernetCsmacd":
+                continue
+            agg = (intf.get("aggregate_id") or {}).get("value")
+            if agg is None:
+                continue
+            members_by_lag[agg].append(intf)
+
+        for intf in interfaces.values():
+            if intf.get("type") != "ieee8023adLag":
+                continue
+            agg_id = (intf.get("aggregate_id") or {}).get("value")
+            if agg_id is None:
+                continue
+            for member in members_by_lag.get(agg_id, []):
+                if (member.get("lacp_enabled") or {}).get("value"):
+                    intf["_lacp_enabled"] = True
+                    mode = (member.get("lacp_mode") or {}).get("value")
+                    intf["_lacp_mode"] = mode if mode in ("active", "passive") else "active"
+                    interval = (member.get("lacp_interval") or {}).get("value")
+                    if interval:
+                        intf["_lacp_interval"] = interval
+                    break
+
+        lag_count = sum(1 for i in interfaces.values() if i.get("type") == "ieee8023adLag")
+        if lag_count > 0:
+            config["_lag_count"] = lag_count
+
+    def _physical_interface_names(self, config: dict, asset) -> dict:
+        """
+        Resolve physical/management interface names per Junos conventions.
+
+        - ethernetCsmacd: ge-/xe-/et- prefix per speed, suffix `<stack>/<module>/<port>`
+          using the asset's stack_index/module_index/index from the model.
+        - managementInterface: hardcoded to `me0` (switch-style); routers use
+          `fxp0` — extend if/when we model that.
+        - softwareLoopback: `lo0` with the index becoming the unit number, set
+          on the model so the template can use it.
+        """
+        for _, intf in (config.get("interfaces") or {}).items():
+            t = intf.get("type")
+
+            if t == "ethernetCsmacd":
+                speed = (intf.get("speed") or {}).get("value") or 1_000_000
+                prefix = PORT_PREFIX_BY_SPEED.get(speed, "ge")
+                stack_index = (intf.get("stack_index") or {}).get("value") or 0
+                module_index = (intf.get("module_index") or {}).get("value") or 0
+                port_index = intf["index"]["value"]
+                intf["name"] = f"{prefix}-{stack_index}/{module_index}/{port_index}"
+
+            elif t == "managementInterface":
+                # Junos out-of-band mgmt; default to me0 for switches.
+                intf["name"] = "me0"
+
+            elif t == "softwareLoopback":
+                # Junos models loopback as lo0 unit N — name doesn't appear
+                # standalone, but having it deterministic helps templates.
+                intf["name"] = "lo0"
+
+            elif t == "ieee8023adLag":
+                # Junos uses ae<N> for aggregated Ethernet.
+                intf["name"] = f"ae{intf['index']['value']}"
+
+        return config

acex_driver_juniper_junoscli-1.0.0/src/acex_driver_juniper_junos_cli/template.j2

@@ -0,0 +1,176 @@
+{#- Junos CLI day-0 template — renders against the current ComposedConfiguration shape.
+    Scope: hostname, domain, DNS, SSH, NTP, interfaces (mgmt/loopback/ethernet),
+    SNMP communities (with per-community augments), VLANs, static routes.
+    Out of scope: AAA, logging beyond defaults, ACLs, complex routing, sFlow. -#}
+{%- if configuration._lag_count %}
+set chassis aggregated-devices ethernet device-count {{ configuration._lag_count }}
+{%- endif %}
+{%- if configuration.system.config.hostname %}
+set system host-name {{ configuration.system.config.hostname.value }}
+{%- endif %}
+{%- if configuration.system.config.domain_name %}
+set system domain-name {{ configuration.system.config.domain_name.value }}
+{%- endif %}
+{%- if configuration.system.config.location %}
+set system location "{{ configuration.system.config.location.value }}"
+{%- endif %}
+{%- if configuration.system.config.contact %}
+set system contact "{{ configuration.system.config.contact.value }}"
+{%- endif %}
+{#- DNS -#}
+{%- if configuration.system.dns and configuration.system.dns.dns_servers %}
+{%-   for _, dns in configuration.system.dns.dns_servers.items() %}
+{%-     if dns.address %}
+set system name-server {{ dns.address.value }}
+{%-     endif %}
+{%-   endfor %}
+{%- endif %}
+{#- NTP -#}
+{%- if configuration.system.ntp and configuration.system.ntp.servers %}
+{%-   for _, ntp in configuration.system.ntp.servers.items() %}
+set system ntp server {{ ntp.address.value }}{% if ntp.prefer and ntp.prefer.value %} prefer{% endif %}
+{%-   endfor %}
+{%- endif %}
+{#- SSH / NETCONF -#}
+{%- set ssh = configuration.system.ssh.config if configuration.system.ssh else None %}
+{%- if ssh and ssh.enable and ssh.enable.value %}
+set system services ssh
+{%-   if ssh.timeout %}
+set system services ssh idle-timeout {{ ssh.timeout.value }}
+{%-   endif %}
+{%- endif %}
+set system services netconf ssh
+{#- Management interface -#}
+{%- for _, intf in configuration.interfaces.items() %}
+{%-   if intf.type == "managementInterface" %}
+{%-     if intf.description %}
+set interfaces {{ intf.name }} description "{{ intf.description.value }}"
+{%-     endif %}
+{%-     if intf.ipv4 %}
+set interfaces {{ intf.name }} unit 0 family inet address {{ intf.ipv4.value }}
+{%-     endif %}
+{%-     if intf.enabled and not intf.enabled.value %}
+set interfaces {{ intf.name }} disable
+{%-     endif %}
+{%-   endif %}
+{%- endfor %}
+{#- Loopback interfaces (lo0 with multiple units) -#}
+{%- for _, intf in configuration.interfaces.items() %}
+{%-   if intf.type == "softwareLoopback" %}
+{%-     if intf.ipv4 %}
+set interfaces {{ intf.name }} unit {{ intf.index.value }} family inet address {{ intf.ipv4.value }}
+{%-     endif %}
+{%-     if intf.description %}
+set interfaces {{ intf.name }} unit {{ intf.index.value }} description "{{ intf.description.value }}"
+{%-     endif %}
+{%-   endif %}
+{%- endfor %}
+{#- Physical Ethernet interfaces -#}
+{%- for _, intf in configuration.interfaces.items() %}
+{%-   if intf.type == "ethernetCsmacd" %}
+{%-     if intf.description %}
+set interfaces {{ intf.name }} description "{{ intf.description.value }}"
+{%-     endif %}
+{%-     if intf.mtu %}
+set interfaces {{ intf.name }} mtu {{ intf.mtu.value }}
+{%-     endif %}
+{%-     if intf.ipv4 %}
+set interfaces {{ intf.name }} unit 0 family inet address {{ intf.ipv4.value }}
+{%-     endif %}
+{%-     if intf.switchport and intf.switchport.value %}
+{%-       if intf.switchport_mode and intf.switchport_mode.value == "access" %}
+set interfaces {{ intf.name }} unit 0 family ethernet-switching interface-mode access
+{%-         if intf.access_vlan %}
+set interfaces {{ intf.name }} unit 0 family ethernet-switching vlan members {{ intf.access_vlan.value }}
+{%-         endif %}
+{%-       endif %}
+{%-       if intf.switchport_mode and intf.switchport_mode.value == "trunk" %}
+set interfaces {{ intf.name }} unit 0 family ethernet-switching interface-mode trunk
+{%-         if intf.trunk_allowed_vlans %}
+{%-           for vlan in intf.trunk_allowed_vlans.value %}
+set interfaces {{ intf.name }} unit 0 family ethernet-switching vlan members {{ vlan }}
+{%-           endfor %}
+{%-         endif %}
+{%-         if intf.native_vlan %}
+set interfaces {{ intf.name }} native-vlan-id {{ intf.native_vlan.value }}
+{%-         endif %}
+{%-       endif %}
+{%-     endif %}
+{%-     if intf.aggregate_id %}
+set interfaces {{ intf.name }} ether-options 802.3ad ae{{ intf.aggregate_id.value }}
+{%-     endif %}
+{%-     if intf.enabled and not intf.enabled.value %}
+set interfaces {{ intf.name }} disable
+{%-     endif %}
+{%-   endif %}
+{%- endfor %}
+{#- LAG interfaces (ae<N>) -#}
+{%- for _, intf in configuration.interfaces.items() %}
+{%-   if intf.type == "ieee8023adLag" %}
+{%-     if intf.description %}
+set interfaces {{ intf.name }} description "{{ intf.description.value }}"
+{%-     endif %}
+{%-     if intf.mtu %}
+set interfaces {{ intf.name }} mtu {{ intf.mtu.value }}
+{%-     endif %}
+{%-     if intf._lacp_enabled %}
+set interfaces {{ intf.name }} aggregated-ether-options lacp {{ intf._lacp_mode }}
+{%-       if intf._lacp_interval %}
+set interfaces {{ intf.name }} aggregated-ether-options lacp periodic {{ intf._lacp_interval }}
+{%-       endif %}
+{%-     endif %}
+{%-     if intf.switchport and intf.switchport.value %}
+{%-       if intf.switchport_mode and intf.switchport_mode.value == "access" %}
+set interfaces {{ intf.name }} unit 0 family ethernet-switching interface-mode access
+{%-       endif %}
+{%-       if intf.switchport_mode and intf.switchport_mode.value == "trunk" %}
+set interfaces {{ intf.name }} unit 0 family ethernet-switching interface-mode trunk
+{%-         if intf.trunk_allowed_vlans %}
+{%-           for vlan in intf.trunk_allowed_vlans.value %}
+set interfaces {{ intf.name }} unit 0 family ethernet-switching vlan members {{ vlan }}
+{%-           endfor %}
+{%-         endif %}
+{%-         if intf.native_vlan %}
+set interfaces {{ intf.name }} native-vlan-id {{ intf.native_vlan.value }}
+{%-         endif %}
+{%-       endif %}
+{%-     endif %}
+{%-     if intf.enabled and not intf.enabled.value %}
+set interfaces {{ intf.name }} disable
+{%-     endif %}
+{%-   endif %}
+{%- endfor %}
+{#- VLANs (defined under network_instances.<ni>.vlans) -#}
+{%- for _, ni in configuration.network_instances.items() %}
+{%-   if ni.vlans %}
+{%-     for _, vlan in ni.vlans.items() %}
+{%-       set vname = vlan.vlan_name.value if vlan.vlan_name else vlan.name.value %}
+set vlans {{ vname }} vlan-id {{ vlan.vlan_id.value }}
+{%-     endfor %}
+{%-   endif %}
+{%- endfor %}
+{#- SNMP communities (with per-community augments such as juniper.snmp_community_clients) -#}
+{%- if configuration.system.snmp and configuration.system.snmp.communities %}
+{%-   for name, com in configuration.system.snmp.communities.items() %}
+set snmp community {{ name }} authorization {% if com.access and com.access.value == "READ_WRITE" %}read-write{% else %}read-only{% endif %}
+{%-     for line in configuration.augment_lines.get("system.snmp.communities." ~ name, []) %}
+{{ line }}
+{%-     endfor %}
+{%-   endfor %}
+{%- endif %}
+{#- Static routes (per network_instance) -#}
+{%- for ni_name, ni in configuration.network_instances.items() %}
+{%-   if ni.protocols and ni.protocols.static_routes %}
+{%-     for _, route in ni.protocols.static_routes.items() %}
+{%-       if route.next_hops %}
+{%-         for _, hop in route.next_hops.items() %}
+{%-           if ni_name == "global" %}
+set routing-options static route {{ route.prefix.value }} next-hop {{ hop.next_hop.value }}
+{%-           else %}
+set routing-instances {{ ni_name }} routing-options static route {{ route.prefix.value }} next-hop {{ hop.next_hop.value }}
+{%-           endif %}
+{%-         endfor %}
+{%-       endif %}
+{%-     endfor %}
+{%-   endif %}
+{%- endfor %}