1. Automatic update of interface descriptions using the event handler#

#!/usr/bin/env python3
#
# Example implementation of an event handler script to set interface descriptions according to information learnt over LLDP.
#
# Paths:
#   system lldp interface neighbor system-name - e.g. system lldp interface * neighbor * system-name
#   system lldp interface neighbor port-id - e.g. system lldp interface * neighbor * port-id
# Options:
#   interfaces: <array> - list of interfaces to enable auto-configuration of descriptions, e.g. [ ethernet-1/{10,11}, ethernet-2/5 ]
#   debug: <value>[default false] - optional debug prints - will be visible in 'last-stdout-stderr' leaf
#
# Example config:
#   system {
#        event-handler {
#            instance lldp {
#                admin-state enable
#                upython-script auto-ifdesc.py
#                paths [
#                    "system lldp interface * neighbor * port-id"
#                    "system lldp interface * neighbor * system-name"
#                ]
#                options {
#                    object interfaces {
#                        values [
#                            ethernet-1/12
#                            ethernet-1/{2..10}
#                            ethernet-1/{21..24}
#                            ethernet-1/{25,27..30}
#                        ]
#                    }
#                }
#            }
#        }
#    }

import sys
import json

_MAX_PATH_RANGE_EXPANSION = 4096

class PathRangeExpansionError(Exception):
    pass

def _expand_ranges(path):
    result = {}
    start = path.find('{') + 1
    end = path.find('}')
    if start < 1 or end < 0 or start == end:
        result[path] = None
        return result

    range_block = path[start:end]
    numbers = set()
    splits = range_block.split(',')
    # For each range
    for split in splits:
        pos = split.find('..')
        try:
            if pos >= 0:
                low = int(split[:pos])
                high = int(split[pos+2:])
                if high - low + 1 > _MAX_PATH_RANGE_EXPANSION:
                    raise PathRangeExpansionError(
                        f'Cannot expand path to more than {_MAX_PATH_RANGE_EXPANSION} paths')

                for i in range(low, high+1):
                    numbers.add(i)
            else:
                numbers.add(int(split))
        except (TypeError, ValueError) as e:
            raise PathRangeExpansionError(f"Invalid range expansion in '{path}': {type(e)}: {e}")

    if len(result) + len(numbers) > _MAX_PATH_RANGE_EXPANSION:
        raise PathRangeExpansionError(f'Cannot expand path to more than {_MAX_PATH_RANGE_EXPANSION} paths')

    sorted_list = sorted(numbers)
    if not sorted_list:
        raise PathRangeExpansionError(
            f"Invalid range expansion in '{path}': Must expand to at least one number")
    if sorted_list[0] < 0:
        raise PathRangeExpansionError(
            f"Invalid range expansion in '{path}': Negative numbers are not supported")

    for number in sorted_list:
        new_value = path[:start-1] + str(number) + path[end+1:]
        result[new_value] = None

    # found and expanded range
    return result

def process_options(options):
    parsed_interfaces = {}
    for interface_range in enabled_interfaces(options):
        interface_list = _expand_ranges(interface_range)
        parsed_interfaces.update(interface_list)
    return parsed_interfaces

def create_actions(parsed_interfaces, interfaces, cache):
    """cache save interfaces state from previous run
        {
        'ethernet-x/y':{
            'description':'node1|1/1/1'
            'stale':False
            }
        }
    """
    actions = []
    cached_interfaces_pending_check = list(cache.keys())

    #process active lldp neighbors
    for interface, lldp_info in interfaces.items():
        if interface in parsed_interfaces:
            description = f'{lldp_info.get("system-name", "unknown")}|{lldp_info.get("port-id","unknown")}'
            actions.append({
                'set-cfg-path':{'path':f'interface {interface} description',
                'value':description,
                'always-execute':False}
            })
            if interface in cache:
                old_description = cache[interface]['description']
                cached_interfaces_pending_check.remove(interface)
                if description != old_description:
                    logmessage = f"'activity-12: auto-updating {interface} description: {old_description} -> {description}'"
                    actions.append({
                        'run-script': {"cmdline": f"logger -t sr_event_mgr -p local6.info {logmessage}"}
                    })
                cache[interface]['stale'] = False
                cache[interface]['description'] = description
            else:
                cache[interface] = {
                    'stale': False,
                    'description': description
                }

    #process expired lldp neighbors
    while cached_interfaces_pending_check:
        interface = cached_interfaces_pending_check.pop()
        if cache[interface]['stale'] == False:
            old_description = cache[interface]['description']
            description = old_description + " [STALE]"
            logmessage = f"'activity-12: auto-updating {interface} description: {old_description} -> {description}'"
            actions.append({
                'set-cfg-path':{'path':f'interface {interface} description',
                'value':description,
                'always-execute':False}
            })
            actions.append({
                'run-script': {"cmdline": f"logger -t sr_event_mgr -p local6.info {logmessage}"}
            })
            cache[interface]['description'] = description
            cache[interface]['stale'] = True

    return actions

def enabled_interfaces(options):
    return options.get('interfaces', [])

def process_paths(paths):
    interfaces = {}
    for update in paths:
        path = update.get('path','')
        value = update.get('value','')
        interface_name = path.split(' ')[3]
        if interface_name not in interfaces:
            interfaces[interface_name] = {}
        if path.endswith('system-name'):
            interfaces[interface_name]['system-name'] = value
        elif path.endswith('port-id'):
            interfaces[interface_name]['port-id'] = value
    return interfaces

def event_handler_main(in_json_str):
    in_json = json.loads(in_json_str)
    paths = in_json['paths']
    options = in_json['options']
    cache = in_json.get('persistent-data', dict())
    parsed_interfaces = process_options(options)
    lldp_interfaces = process_paths(paths)
    if options.get('debug', '') == 'true':
        print(
            f'enabled interfaces = {enabled_interfaces(options)}\n\
parsed interfaces = {parsed_interfaces}\n'
        )
    actions = create_actions(parsed_interfaces, lldp_interfaces, cache)
    response = { 'actions':actions, 'persistent-data':cache }
    json_response = json.dumps(response)
    return json_response

#
# This code is only if you want to test it from bash - this isn't used when invoked from SRL
#
def main():
    example_in_json_str = """
{
    "paths": [
        {
            "path":"system lldp interface ethernet-1/2 neighbor 11:22:33:44:55:66 system-name",
            "value":"node1"
        },
        {
            "path":"system lldp interface ethernet-1/2 neighbor 11:22:33:44:55:66 port-id",
            "value":"1/1/1"
        }
    ],
    "persistent-data":{
        "ethernet-1/2":{
            "description":"node1|1/1/1",
            "stale":"true"
        }
    },
    "options": {"interfaces":["ethernet-1/{2..6}", "ethernet-1/{10,11,14..20}"],"debug":"true"}
}
"""
    json_response = event_handler_main(example_in_json_str)
    print(json_response)

if __name__ == "__main__":
    sys.exit(main())

#!/usr/bin/env python3
#
# Example implementation of an event handler to auto-provision spine-leaf ISLs. Assumes:
# IPv6 link-local addresses
# Untagged subinterface 0
# BGP IPv6 dynamic-neighbors
#
# Example config:
#   system {
#        event-handler {
#            instance auto-isl {
#                admin-state enable
#                upython-script auto-isl.py
#                paths [
#                    "interface * subinterface 0 oper-state"
#                    "system lldp interface * neighbor * system-name"
#                ]
#                options {
#                    object allowed-peer-as {
#                        values [
#                            4200001000..4200001999
#                        ]
#                    }
#                    object peer-group {
#                        value bgpgroup-ebgp-srexperts-fabric
#                   }
#                }
#            }
#        }
#    }

import sys
import json

def create_actions(interfaces, peergroup, as_list):
    actions = []

    for interface in interfaces:
        actions.append({
            'set-cfg-path':{'path':f'interface {interface} subinterface 0 ip-mtu',
            'value':9198,
            'always-execute':True}
        })
        actions.append({
            'set-cfg-path':{'path':f'interface {interface} subinterface 0 admin-state',
            'value':'enable',
            'always-execute':True}
        })
        actions.append({
            'set-cfg-path':{'path':f'interface {interface} subinterface 0 ipv6 admin-state',
            'value':'enable',
            'always-execute':True}
        })
        actions.append({
            'set-cfg-path':{'path':f'interface {interface} subinterface 0 ipv6 router-advertisement router-role admin-state',
            'value':'enable',
            'always-execute':True}
        })
        actions.append({
            'set-cfg-path':{'path':f'network-instance default interface {interface}.0 interface-ref interface',
            'value':interface,
            'always-execute':True}
        })
        actions.append({
            'set-cfg-path':{'path':f'network-instance default interface {interface}.0 interface-ref subinterface',
            'value':0,
            'always-execute':True}
        })
        actions.append({
            'run-script': {
                "cmdline": f"sr_cli -ec -- 'network-instance default protocols bgp dynamic-neighbors interface {interface}.0 allowed-peer-as [ {' '.join(as_list)} ] peer-group {peergroup}'"}
        })
        actions.append({
            'run-script': {
                "cmdline": f"logger -t sr_event_mgr -p local6.info auto-provisioned leaf ISL interface {interface}"}
        })
    return actions

def process_paths(paths):
    already_provisioned_interfaces = set()
    leaf_interfaces = set()
    for update in paths:
        path = update.get('path','')
        value = update.get('value','')

        #collect LLDP neighbor system-name
        if path.startswith('system'):
            splitted_path = path.split(' ')
            interface_name = splitted_path[3]
            if 'leaf' in value:
                leaf_interfaces.add(interface_name)

        #collect subinterfaces with index 0 already existing in config
        elif path.startswith('interface'):
            splitted_path = path.split(' ')
            interface_name = splitted_path[1]
            already_provisioned_interfaces.add(interface_name)

    #return leaf interfaces that are not yet configured.
    return (leaf_interfaces - already_provisioned_interfaces)

def event_handler_main(in_json_str):
    in_json = json.loads(in_json_str)
    paths = in_json['paths']
    options = in_json['options']

    allowed_peer_as_list = options['allowed-peer-as']
    peer_group = options['peer-group']
    interfaces_to_provision = process_paths(paths)
    actions = create_actions(interfaces_to_provision,peergroup=peer_group,as_list=allowed_peer_as_list)
    response = { 'actions':actions }
    json_response = json.dumps(response)
    return json_response

#
# This code is only if you want to test it from bash - this isn't used when invoked from SRL
#
def main():
    example_in_json_str = """
{
    "paths": [
        {
            "path":"system lldp interface ethernet-1/2 neighbor 11:22:33:44:55:66 system-name",
            "value":"leaf1"
        },
        {
            "path":"system lldp interface ethernet-1/3 neighbor 11:22:33:44:55:67 system-name",
            "value":"leaf2"
        },
        {
            "path":"interface ethernet-1/3 oper-state",
            "value":"down"
        }
    ],
    "options": {"allowed-peer-as":["1","2"], "peer-group":"leaf"}
}
"""
    json_response = event_handler_main(example_in_json_str)
    print(json_response)

if __name__ == "__main__":
    sys.exit(main())