1

#!/usr/bin/env python

     2

     3

"""

     4

    Requirements:

     5

        pydot

     6

"""

     7

     8

import pvl.args

     9

import pvl.hosts

    11

    12

import collections

    13

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

    14

import optparse

    15

    16

COLOR_VLANS = {

    17

    1:      'grey',         # pvl-lan

    18

    2:      'blue',         # pvl-lan2

    19

    3:      'red',          # pvl-san

    20

    4:      'green',        # pvl-veturi

    21

    7:      'orange',       # pvl-ranssi

    22

    8:      'yellow',       # pvl-mgmt

    23

    10:     'brown',        # pvl-public

    24

    100:    'navyblue',     # pvl-test

    25

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

    26

    104:    'red2',         # pvl-ganeti

    27

    192:    'purple',       # paivola-services

    28

    255:    'magenta',      # pvl-sonera

    29

}

    30

    31

class ParseError (Exception) :

    32

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

    33

        self.file = file

    34

        self.line = line

    35

        self.msg = msg

    36

    37

    def __str__ (self) :

    38

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

    39

    40

def _parse_snmp_part (part) :

    41

    if part.isdigit() :

    42

        return int(part)

    43

    else :

    44

        return part

    45

    46

def _parse_snmp_line (line) :

    47

    for part in line.split() :

    48

        yield _parse_snmp_part(part)

    49

    66

def _load_snmp_data (options, file) :

    67

    """

    68

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

    69

    70

        Yields (host, attr, value)

    71

    """

    72

    73

    host = None

    74

    attr = None

    75

    value = None

    76

    values = None

    77

    78

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

    79

        indent = 0

    80

    81

        while line.startswith('\t') :

    82

            indent += 1

    83

            line = line[1:]

    84

    85

        line = line.strip()

    86

    87

        if '\t' in line :

    89

    90

            line = args.pop(0)

    91

            args = tuple(args)

    92

        else :

    93

            args = None

    94

    95

        if indent == 0 :

    96

            host = line

    97

            attr = None

    98

            value = None

    99

            values = None

   100

   101

        elif indent == 1 :

   102

            if attr and not value and not values :

   103

                raise ParseError(file, line, "[%s] %s: no value" % (host, attr))

   104

   105

            attr = tuple(_parse_snmp_line(line))

   106

   107

            if args :

   109

            else :

   110

                value = None

   111

   112

            values = None

   113

   114

            if value :

   115

                yield host, attr, value

   116

   117

        elif indent == 2 :

   118

            if not attr :

   119

                raise ParseError(file, line, "[%s] %s: value outside of attr" % (host, attr))

   120

   121

            if value :

   122

                raise ParseError(file, line, "[%s] %s: values with value" % (host, attr))

   123

   124

            values = _parse_snmp_part(line)

   125

   126

            yield host, attr, set((values, ))

   127

   128

def load_snmp_data (options, file, hosts) :

   129

    """

   130

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

   131

    """

   132

   133

    if file :

   134

        file = open(file)

   135

    else :

   136

        file = sys.stdin

   137

   138

    root = { }

   139

   140

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

   142

   143

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

   144

   145

        item = root.setdefault(host, { })

   146

   147

        for a in attr[:-1] :

   148

            item = item.setdefault(a, {})

   149

   150

        a = attr[-1]

   151

   152

        if isinstance(value, set) :

   153

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

   154

   155

        else :

   157

   158

    return root

   159

   227

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

   228

    import pydot

   229

   230

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

   231

            # XXX: breaks multi-edges?

   232

            #splines     = 'true',

   233

   234

            sep             = '+25,25',

   235

            overlap         = 'scalexy',

   236

   237

            # only applies to loops

   238

            nodesep     = 0.5,

   239

    )

   240

    dot.set_edge_defaults(

   241

            labeldistance   = 3.0,

   242

            penwidth        = 2.0,

   243

    )

   244

   245

    nodes = { }

   246

    edges = { }

   247

    vlan_colors = { } # { vlan: color }

   248

   249

    for host, local, remote, remote_host in items :

   250

        # src

   251

        src_name = str(host)

   252

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

   253

   254

        if src_name in nodes :

   255

            src = nodes[src_name]

   256

        else :

   257

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

   258

                    label       = src_label,

   259

                    fontsize    = 18,

   260

            )

   261

            dot.add_node(src)

   262

   263

        # dst

   264

        if remote_host :

   265

            dst_name = str(remote_host)

   266

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

   267

        else :

   268

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

   269

   270

            # XXX: pydot is not smart enough to quote this

   271

            if remote['sys_name'] :

   272

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

   273

            else :

   274

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

   275

   276

        if dst_name in nodes :

   277

            dst = nodes[dst_name]

   278

        else :

   279

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

   280

                    label       = dst_label,

   281

                    fontsize    = 18,

   282

            )

   283

            dot.add_node(dst)

   284

   285

        # edges

   286

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

   287

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

   288

        fillcolor = 'black'

   289

        color = 'black'

   290

        untag = tagged = None

   291

   292

        # vlans?

   293

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

   294

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

   295

   296

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

   297

   298

            colors = []

   299

            for tag in sorted(tagged) :

   300

                if tag in COLOR_VLANS :

   301

                    colors.append(COLOR_VLANS[tag])

   302

                elif tag in vlan_colors :

   303

                    colors.append(vlan_colors[tag])

   304

                else :

   305

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

   306

   307

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

   308

   309

                    vlan_colors[tag] = color

   310

                    colors.append(color)

   311

   312

            if not untag :

   313

                pass

   314

            elif untag in COLOR_VLANS :

   315

                fillcolor = COLOR_VLANS[untag]

   316

            elif untag in vlan_colors :

   317

                fillcolor = vlan_colors[untag]

   318

            else :

   319

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

   320

   321

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

   322

   323

                fillcolor = vlan_colors[tag] = color

   324

   325

            # first color overrides fillcolor for heads

   326

            if colors and untag :

   327

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

   328

            elif colors :

   329

                color = ':'.join(colors)

   330

            elif fillcolor :

   331

                color = fillcolor

   332

   333

        elif vlans :

   334

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

   335

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

   336

   337

        # edge

   338

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

   339

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

   340

   341

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

   342

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

   343

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

   344

   345

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

   346

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

   347

   348

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

   349

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

   350

   351

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

   352

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

   353

   354

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

   355

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

   356

   357

            # mark as bidirectional

   358

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

   359

   360

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

   361

   362

            # set second color for tail

   363

            if untag :

   364

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

   365

                    headcolor   = edge.get('fillcolor'),

   366

                    tailcolor   = fillcolor,

   367

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

   368

                ))

   369

   370

        else :

   371

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

   372

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

   373

                    headlabel   = headlabel,

   374

                    taillabel   = taillabel,

   375

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

   376

                    fillcolor   = fillcolor,

   377

            )

   378

   379

            dot.add_edge(edge)

   380

   381

    if options.graph_dot :

   382

        dot.write(options.graph_dot)

   383

   384

def main (argv) :

   385

    """

   386

        Graph network

   387

    """

   388

   389

    parser = optparse.OptionParser(main.__doc__)

   390

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

   391

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

   392

   393

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

   394

            help="Load snmp data from FILE")

   395

   396

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

   397

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

   398

   399

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

   400

            help="Graph all VLANs")

   401

   402

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

   403

            help="Do not color VLANs")

   404

   405

    # input

   406

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

   407

    pvl.args.apply(options)

   408

   409

    # load hosts for correlation

   410

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

   411

   412

    # load raw snmp data

   414

   415

    # TODO: process data into graph

   420

   423

   424

    return 0

   425

   426

if __name__ == '__main__':

   427

    pvl.args.main(main)