EVOLUTION-MANAGER

Edit File: base.py

# -*- coding: utf-8 -*-
# Copyright 2019 Red Hat
# GNU General Public License v3.0+
# (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
"""
The VyOS interfaces fact class
It is in this file the configuration is collected from the device
for a given resource, parsed, and the facts tree is populated
based on the configuration.
"""

from __future__ import absolute_import, division, print_function
__metaclass__ = type
import platform
import re
from ansible.module_utils. \
    network.vyos.vyos import run_commands, get_capabilities

class LegacyFactsBase(object):

COMMANDS = frozenset()

def __init__(self, module):
        self.module = module
        self.facts = dict()
        self.warnings = list()
        self.responses = None

def populate(self):
        self.responses = run_commands(self.module, list(self.COMMANDS))

class Default(LegacyFactsBase):

COMMANDS = [
        'show version',
    ]

def populate(self):
        super(Default, self).populate()
        data = self.responses[0]
        self.facts['serialnum'] = self.parse_serialnum(data)
        self.facts.update(self.platform_facts())

def parse_serialnum(self, data):
        match = re.search(r'HW S/N:\s+(\S+)', data)
        if match:
            return match.group(1)

def platform_facts(self):
        platform_facts = {}

resp = get_capabilities(self.module)
        device_info = resp['device_info']

platform_facts['system'] = device_info['network_os']

for item in ('model', 'image', 'version', 'platform', 'hostname'):
            val = device_info.get('network_os_%s' % item)
            if val:
                platform_facts[item] = val

platform_facts['api'] = resp['network_api']
        platform_facts['python_version'] = platform.python_version()

return platform_facts

class Config(LegacyFactsBase):

COMMANDS = [
        'show configuration commands',
        'show system commit',
    ]

def populate(self):
        super(Config, self).populate()

self.facts['config'] = self.responses

commits = self.responses[1]
        entries = list()
        entry = None

for line in commits.split('\n'):
            match = re.match(r'(\d+)\s+(.+)by(.+)via(.+)', line)
            if match:
                if entry:
                    entries.append(entry)

entry = dict(revision=match.group(1),
                             datetime=match.group(2),
                             by=str(match.group(3)).strip(),
                             via=str(match.group(4)).strip(),
                             comment=None)
            else:
                entry['comment'] = line.strip()

self.facts['commits'] = entries

class Neighbors(LegacyFactsBase):

COMMANDS = [
        'show lldp neighbors',
        'show lldp neighbors detail',
    ]

def populate(self):
        super(Neighbors, self).populate()

all_neighbors = self.responses[0]
        if 'LLDP not configured' not in all_neighbors:
            neighbors = self.parse(
                self.responses[1]
            )
            self.facts['neighbors'] = self.parse_neighbors(neighbors)

def parse(self, data):
        parsed = list()
        values = None
        for line in data.split('\n'):
            if not line:
                continue
            elif line[0] == ' ':
                values += '\n%s' % line
            elif line.startswith('Interface'):
                if values:
                    parsed.append(values)
                values = line
        if values:
            parsed.append(values)
        return parsed

def parse_neighbors(self, data):
        facts = dict()
        for item in data:
            interface = self.parse_interface(item)
            host = self.parse_host(item)
            port = self.parse_port(item)
            if interface not in facts:
                facts[interface] = list()
            facts[interface].append(dict(host=host, port=port))
        return facts

def parse_interface(self, data):
        match = re.search(r'^Interface:\s+(\S+),', data)
        return match.group(1)

def parse_host(self, data):
        match = re.search(r'SysName:\s+(.+)$', data, re.M)
        if match:
            return match.group(1)

def parse_port(self, data):
        match = re.search(r'PortDescr:\s+(.+)$', data, re.M)
        if match:
            return match.group(1)