1

#!/usr/bin/env python

     2

     3

"""

     4

    Requirements:

     5

        pydot

     6

"""

     7

     8

import pvl.args

     9

import pvl.hosts

    10

from pvl.invoke import merge

    11

from pvl.snmp import snmp, lldp

    12

    13

import logging; log = logging.getLogger('pvl.hosts-lldp')

    14

import optparse

    15

    16

def hosts_lldp (options, hosts) :

    17

    """

    18

        Discover LLDP-supporting hosts.

    19

    20

        Yields Host, LLDPAgent

    21

    """

    22

    23

    for host in hosts :

    24

        host_snmp = host.extensions.get('snmp')

    25

    26

    27

        if not host_snmp :

    28

            log.debug("%s: skip non-snmp host", host)

    29

            continue

    30

    31

        elif host.down :

    32

            log.debug("%s: skip down host", host)

    33

            continue

    34

    35

        else :

    36

            log.debug("%s: %s", host, host_snmp)

    37

    38

        agent = lldp.LLDPAgent.apply(options, host.fqdn(), community=host_snmp.get('community'))

    39

    40

        try :

    41

            local = agent.local

    42

        except snmp.SNMPError as ex :

    43

            log.warning("%s: %s", host, ex)

    44

            continue

    45

    46

        log.info("%s: %s", host, local)

    47

    48

        if local['sys_name'] != host.host :

    49

            log.warning("%s: SNMP sys_name mismatch: %s", host, local['sys_name'])

    50

    51

        yield host, agent

    52

    53

def apply_hosts_lldp (options, hosts) :

    54

    """

    55

        Query host LLDP info.

    56

    """

    57

    58

    _hosts_lldp = list(hosts_lldp(options, hosts))

    59

    hosts_by_chassis = { }

    60

    61

    # first pass to discover hosts

    62

    for host, agent in _hosts_lldp :

    63

        chassis = agent.local['chassis']

    64

        log.info("%s: %s", host, chassis)

    65

    66

        hosts_by_chassis[chassis] = host

    67

    68

    # second pass to discver links

    69

    for host, agent in _hosts_lldp :

    70

        for port, remote in agent.remotes() :

    71

            port = agent.port(port)

    72

    73

            remote_chassis = remote['chassis']

    74

            remote_host = hosts_by_chassis.get(remote_chassis)

    75

    76

            log.info("%s: %s: %s (%s)", host, port, remote, remote_host)

    77

    78

            yield host, merge(agent.local, port), remote, remote_host

    79

    80

def apply_graph (options, items) :

    81

    import pydot

    82

    83

    dot = pydot.Dot(graph_name='lldp_hosts', graph_type='digraph',

    86

    87

            sep             = '+25,25',

    88

            overlap         = 'scalexy',

    89

    90

            # only applies to loops

    92

    )

    93

    dot.set_edge_defaults(

    94

            labeldistance   = 3.0,

    95

    )

    96

    97

    nodes = { }

    98

    edges = { }

    99

   100

    for host, local, remote, remote_host in items :

   101

        # src

   102

        src_name = str(host)

   103

        src_label = '"{host.location}"'.format(host=host)

   104

   105

        if src_name in nodes :

   106

            src = nodes[src_name]

   107

        else :

   108

            src = nodes[src_name] = pydot.Node(src_name, label=src_label)

   109

            dot.add_node(src)

   110

   111

        # dst

   112

        if remote_host :

   113

            dst_name = str(remote_host)

   114

            dst_label = '"{host.location}"'.format(host=remote_host)

   115

        else :

   116

            dst_name = remote['chassis'].replace(':', '-')

   117

   118

            # XXX: pydot is not smart enough to quote this

   119

            if remote['sys_name'] :

   120

                dst_label = '"{remote[chassis]} ({remote[sys_name]})"'.format(remote=remote)

   121

            else :

   122

                dst_label = '"{remote[chassis]}"'.format(remote=remote)

   123

   124

   125

        if dst_name in nodes :

   126

            dst = nodes[dst_name]

   127

        else :

   128

            dst = nodes[dst_name] = pydot.Node(dst_name, label=dst_label)

   129

            dot.add_node(dst)

   130

   131

        # edge

   132

        headlabel = '"{remote[port]}"'.format(remote=remote)

   133

        taillabel = '"{local[port]}"'.format(local=local)

   134

   137

   139

            log.info("%s <-> %s", src_name, dst_name)

   141

   142

            if edge.get('headlabel') != taillabel :

   143

                log.warn("%s -> %s: local port mismatch: %s vs %s", src_name, dst_name, local['port'], edge.get('headlabel'))

   144

   145

            if edge.get('taillabel') != headlabel :

   146

                log.warn("%s -> %s: remote port mismatch: %s vs %s", src_name, dst_name, remote['port'], edge.get('taillabel'))

   147

   148

            # mark as bidirectional

   150

   151

            edge.set('dir', 'both')

   152

   153

        else :

   155

                    dir         = 'back',

   156

                    headlabel   = headlabel,

   157

                    taillabel   = taillabel,

   158

            )

   159

   160

            dot.add_edge(edge)

   161

   162

    if options.graph_dot :

   163

        dot.write(options.graph_dot)

   164

   165

def main (argv) :

   166

    """

   167

        SNMP polling.

   168

    """

   169

   170

    parser = optparse.OptionParser(main.__doc__)

   171

    parser.add_option_group(pvl.args.parser(parser))

   172

    parser.add_option_group(pvl.hosts.optparser(parser))

   173

    parser.add_option_group(pvl.snmp.snmp.options(parser))

   174

   175

    parser.add_option('--graph-dot',

   176

            help="Output .dot graph data")

   177

   178

    options, args = parser.parse_args(argv[1:])

   179

    pvl.args.apply(options)

   180

   181

    # input

   182

    hosts = pvl.hosts.apply(options, args)

   183

   184

    # apply

   185

    items = apply_hosts_lldp(options, hosts)

   186

   187

    # print

   188

    if options.graph_dot :

   189

        apply_graph(options, items)

   190

    else :

   191

        for host, local, remote, remote_host in items :

   192

            if remote_host :

   193

                print "{host:30} {host.location:>30} {local[port]:>25} <-> {remote[port]:<25} {remote_host.location:>30} # {remote[chassis]} ({remote_host})".format(host=host, local=local, remote=remote, remote_host=remote_host)

   194

            else :

   195

                print "{host:30} {host.location:>30} {local[port]:>25} <-- {remote[port]:<25} {empty:30} # {remote[chassis]} ({remote[sys_name]})".format(host=host, local=local, remote=remote, empty='')

   196

   197

if __name__ == '__main__':

   198

    pvl.args.main(main)