1

#!/usr/bin/env python

     2

     3

"""

     4

    Requirements:

     5

        pydot

     6

"""

     7

     8

import pvl.args

     9

import pvl.hosts

    10

    11

import collections

    12

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

    13

import optparse

    14

    15

COLOR_VLANS = {

    16

    1:      'grey',         # pvl-lan

    17

    2:      'blue',         # pvl-lan2

    18

    3:      'red',          # pvl-san

    19

    4:      'green',        # pvl-veturi

    20

    7:      'orange',       # pvl-ranssi

    21

    8:      'yellow',       # pvl-mgmt

    22

    10:     'brown',        # pvl-public

    23

    100:    'navyblue',     # pvl-test

    24

    103:    'red4',         # pvl-test-san

    25

    104:    'red2',         # pvl-ganeti

    26

    192:    'purple',       # paivola-services

    27

    255:    'magenta',      # pvl-sonera

    28

}

    29

    30

class ParseError (Exception) :

    31

    def __init__ (self, file, line, msg) :

    32

        self.file = file

    33

        self.line = line

    34

        self.msg = msg

    35

    36

    def __str__ (self) :

    37

        return "{self.file}:{self.line}: {self.msg}".format(self=self)

    38

    39

def _load_snmp_data (options, file) :

    40

    """

    41

        Load a data dict generated by pvl.hosts-snmp from a file.

    42

    43

        Yields (host, attr, value)

    44

    """

    45

    46

    host = None

    47

    attr = None

    48

    value = None

    49

    50

    for idx, line in enumerate(file, 1) :

    51

        indent = line.count('\t')

    52

        line = line.strip()

    53

    54

        if indent == 0 :

    55

            host = line

    56

            attr = None

    57

            value = None

    58

    59

        elif indent == 1 :

    60

            if attr and not value :

    61

                yield host, attr, None

    62

    63

            attr = tuple((int(a) if a.isdigit() else a) for a in line.split())

    64

            value = None

    65

    66

        elif indent == 2 :

    67

            if not attr :

    68

                raise ParseError(file, line, "value outside of attr")

    69

    70

            value = line

    71

    72

            yield host, attr, value

    73

    74

def load_snmp_data (options, file, hosts) :

    75

    """

    76

        Load snmp data as dict, from given file path, or stdin.

    77

    """

    78

    79

    if file :

    80

        file = open(file)

    81

    else :

    82

        file = sys.stdin

    83

    84

    root = { }

    85

    86

    for host_name, attr, value in _load_snmp_data(options, file) :

    87

        host = hosts[host_name]

    88

    89

        log.info("[%s] %s%s", host, ' '.join(str(a) for a in attr), (': ' + str(value)) if value else '')

    90

    91

        item = root.setdefault(host, { })

    92

    93

        if value :

    94

            end = None

    95

        else :

    96

            end = attr[-1]

    97

            attr = attr[:-1]

    98

    99

        for a in attr[:-1] :

   100

            item = item.setdefault(a, {})

   101

   102

        a = attr[-1]

   103

   104

        if value is None :

   105

            item[a] = end

   106

        else :

   107

            item.setdefault(a, set()).add(value)

   108

   109

    return root

   110

   111

def apply_graph (options, items, vlans={}) :

   112

    import pydot

   113

   114

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

   115

            # XXX: breaks multi-edges?

   116

            #splines     = 'true',

   117

   118

            sep             = '+25,25',

   119

            overlap         = 'scalexy',

   120

   121

            # only applies to loops

   122

            nodesep     = 0.5,

   123

    )

   124

    dot.set_edge_defaults(

   125

            labeldistance   = 3.0,

   126

            penwidth        = 2.0,

   127

    )

   128

   129

    nodes = { }

   130

    edges = { }

   131

    vlan_colors = { } # { vlan: color }

   132

   133

    for host, local, remote, remote_host in items :

   134

        # src

   135

        src_name = str(host)

   136

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

   137

   138

        if src_name in nodes :

   139

            src = nodes[src_name]

   140

        else :

   141

            src = nodes[src_name] = pydot.Node(src_name,

   142

                    label       = src_label,

   143

                    fontsize    = 18,

   144

            )

   145

            dot.add_node(src)

   146

   147

        # dst

   148

        if remote_host :

   149

            dst_name = str(remote_host)

   150

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

   151

        else :

   152

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

   153

   154

            # XXX: pydot is not smart enough to quote this

   155

            if remote['sys_name'] :

   156

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

   157

            else :

   158

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

   159

   160

        if dst_name in nodes :

   161

            dst = nodes[dst_name]

   162

        else :

   163

            dst = nodes[dst_name] = pydot.Node(dst_name,

   164

                    label       = dst_label,

   165

                    fontsize    = 18,

   166

            )

   167

            dot.add_node(dst)

   168

   169

        # edges

   170

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

   171

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

   172

        fillcolor = 'black'

   173

        color = 'black'

   174

        untag = tagged = None

   175

   176

        # vlans?

   177

        if vlans and host in vlans and local['port_id'] in vlans[host] :

   178

            untag, tagged = vlans[host][local['port_id']]

   179

   180

            log.debug("%s#%s: %s+%s", host, local['port_id'], untag, tagged)

   181

   182

            colors = []

   183

            for tag in sorted(tagged) :

   184

                if tag in COLOR_VLANS :

   185

                    colors.append(COLOR_VLANS[tag])

   186

                elif tag in vlan_colors :

   187

                    colors.append(vlan_colors[tag])

   188

                else :

   189

                    color = '/paired12/{count}'.format(count=1+len(vlan_colors))

   190

   191

                    log.info("%s#%s: chosing new vlan %s color %s", host, local['port_id'], tag, color)

   192

   193

                    vlan_colors[tag] = color

   194

                    colors.append(color)

   195

   196

            if not untag :

   197

                pass

   198

            elif untag in COLOR_VLANS :

   199

                fillcolor = COLOR_VLANS[untag]

   200

            elif untag in vlan_colors :

   201

                fillcolor = vlan_colors[untag]

   202

            else :

   203

                color = '/paired12/{count}'.format(count=1+len(vlan_colors))

   204

   205

                log.warn("%s#%s: chosing new vlan %s color %s", host, local['port_id'], untag, color)

   206

   207

                fillcolor = vlan_colors[tag] = color

   208

   209

            # first color overrides fillcolor for heads

   210

            if colors and untag :

   211

                color = ':'.join([fillcolor] + colors)

   212

            elif colors :

   213

                color = ':'.join(colors)

   214

            elif fillcolor :

   215

                color = fillcolor

   216

   217

        elif vlans :

   218

            # XXX: this happens when LLDP gives us the LACP ports but the VLANS are on the TRK port

   219

            log.warn("%s#%s: unknown port for vlans: %s", host, local['port_id'], vlans.get(host))

   220

   221

        # edge

   222

        if (src_name, local['port'], dst_name, remote['port']) in edges :

   223

            log.warning("%s:%s <- %s:%s: duplicate", src_name, local['port'], dst_name, remote['port'])

   224

   225

        elif (dst_name, remote['port'], src_name, local['port']) in edges :

   226

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

   227

            edge = edges[(dst_name, remote['port'], src_name, local['port'])]

   228

   229

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

   230

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

   231

   232

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

   233

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

   234

   235

            if edge.get('fillcolor') != fillcolor :

   236

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

   237

   238

            if edge.get('color') != '"' + color + '"' :

   239

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

   240

   241

            # mark as bidirectional

   242

            edges[(src_name, local['port'], dst_name, remote['port'])] = edge

   243

   244

            edge.set('dir', 'both' if untag else 'none')

   245

   246

            # set second color for tail

   247

            if untag :

   248

                edge.set('color', '"{headcolor}:{tailcolor}{tagcolors}"'.format(

   249

                    headcolor   = edge.get('fillcolor'),

   250

                    tailcolor   = fillcolor,

   251

                    tagcolors   = ':' + ':'.join(colors) if colors else '',

   252

                ))

   253

   254

        else :

   255

            edge = edges[(src_name, local['port'], dst_name, remote['port'])] = pydot.Edge(src, dst,

   256

                    dir         = 'forward' if untag else 'none',

   257

                    headlabel   = headlabel,

   258

                    taillabel   = taillabel,

   259

                    color       = '"{color}"'.format(color=color),

   260

                    fillcolor   = fillcolor,

   261

            )

   262

   263

            dot.add_edge(edge)

   264

   265

    if options.graph_dot :

   266

        dot.write(options.graph_dot)

   267

   268

def main (argv) :

   269

    """

   270

        Graph network

   271

    """

   272

   273

    parser = optparse.OptionParser(main.__doc__)

   274

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

   275

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

   276

   277

    parser.add_option('--snmp-data', metavar='FILE', default=None,

   278

            help="Load snmp data from FILE")

   279

   280

    parser.add_option('--graph-dot', metavar='FILE',

   281

            help="Output .dot graph data to file")

   282

   283

    parser.add_option('--graph-vlans', action='store_true', dest='vlans', 

   284

            help="Graph all VLANs")

   285

   286

    parser.add_option('--no-vlans', action='store_false', dest='vlans',

   287

            help="Do not color VLANs")

   288

   289

    # input

   290

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

   291

    pvl.args.apply(options)

   292

   293

    # load hosts for correlation

   294

    hosts = dict((str(host), host) for host in pvl.hosts.apply(options, args))

   295

   296

    # load raw snmp data

   297

    data = load_snmp_data(options, options.snmp_data, hosts)

   298

   299

    import pprint; pprint.pprint(data)

   300

   301

    # TODO: process data into graph

   302

   303

    # TODO: generate graph

   304

    #apply_graph(options, items, vlans if options.vlans else None)

   305

   306

    return 0

   307

   308

if __name__ == '__main__':

   309

    pvl.args.main(main)