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

    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_attr (line) :

    47

    for part in line.split() :

    48

        yield _parse_snmp_part(part)

    49

    50

def _parse_snmp_value (line) :

    51

    if '\t' in line :

    52

        key, value = line.split('\t', 1)

    53

    54

        return { _parse_snmp_part(key): _parse_snmp_part(value) }

    55

    56

    else :

    57

        return set((_parse_snmp_part(line), ))

    58

    59

def _load_snmp_data (options, file) :

    60

    """

    61

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

    62

    63

        Yields (host, attr, value)

    64

    """

    65

    66

    host = None

    67

    attr = None

    68

    value = None

    69

    70

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

    71

        indent = 0

    72

    73

        while line.startswith('\t') :

    74

            indent += 1

    75

            line = line[1:]

    76

    77

        line = line.lstrip('\t').rstrip('\n')

    78

    79

        if indent == 0 :

    80

            host = line

    81

            attr = None

    82

            value = None

    83

    84

        elif indent == 1 :

    85

            attr = tuple(_parse_snmp_attr(line))

    86

            value = None

    87

    88

            yield host, attr, None

    89

    90

        elif indent == 2 :

    91

            if not attr :

    92

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

    93

    94

            value = _parse_snmp_value(line)

    95

    96

            yield host, attr, value

    97

    98

def load_snmp_data (options, file, hosts) :

    99

    """

   100

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

   101

    """

   102

   103

    if file :

   104

        file = open(file)

   105

    else :

   106

        file = sys.stdin

   107

   108

    root = { }

   109

   110

    hosts_by_namedomain = dict(

   111

        (

   112

            '{host}@{domain}'.format(host=host, domain=host.domain), host

   113

        ) for host in hosts

   114

    )

   115

   116

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

   117

        host = hosts_by_namedomain.get(host_domain)

   118

   119

        if value :

   120

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

   121

        else :

   122

            log.debug("[%s] %s", host, ' '.join(str(a) for a in attr),)

   123

   124

        item = root.setdefault(host, { })

   125

   126

        for a in attr[:-1] :

   127

            item = item.setdefault(a, {})

   128

   129

        a = attr[-1]

   130

   131

        if value is None :

   132

            pass

   133

   134

        elif isinstance(value, set) :

   135

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

   136

   137

        elif isinstance(value, dict) :

   138

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

   139

   140

        else :

   141

            item[a] = value

   142

   143

    return root

   144

   145

def host_vlans (host, host_vlans) :

   146

    """

   147

        {vlan: { tagged/untagged: [port] } } -> (port, (untag, [tag])).

   148

    """

   149

   150

    ports = set()

   151

    vlans_untagged = { }

   152

    vlans_tagged = collections.defaultdict(set)

   153

   154

    for vlan, vlan_attrs in host_vlans.iteritems() :

   155

        for port in vlan_attrs.get('tagged', ()) :

   156

            ports.add(port)

   157

            vlans_tagged[port].add(vlan)

   158

   159

        for port in vlan_attrs.get('untagged', ()) :

   160

            ports.add(port)

   161

            vlans_untagged[port] = vlan

   162

   163

    for port in ports :

   164

        untag = vlans_untagged.get(port)

   165

        tagged = vlans_tagged.get(port, ())

   166

   167

        log.debug("%s: %s: untag=%s tag=%s", host, port, untag, tagged)

   168

   169

        yield port, (untag, tagged)

   170

   172

    """

   173

        Combine given snmp data and { host: Host } into

   174

            { node: label }

   175

            { (remote, remote_port, local_port, local): (local_untag, tagged, remote_untag) }

   176

    """

   177

   178

    nodes = { } # host: label

   179

    links = { }

   180

   181

    hosts_by_lldp = { } # chassis: host

   182

    hosts_by_ethernet = { } # ethernet: host

   183

   184

    # first scan: lldp hosts

   185

    for host, host_attrs in snmp.iteritems() :

   187

   192

   193

    # second scan: nodes by ethernet

   194

    for host in hosts :

   195

        for ethernet in host.ethernet.itervalues() :

   196

            hosts_by_ethernet[ethernet] = host

   197

   199

    for host, host_attrs in snmp.iteritems() :

   200

        local_node = host

   201

   202

        if 'vlan' in host_attrs :

   203

            vlans = dict(host_vlans(host, host_attrs['vlan']))

   204

        else :

   205

            vlans = None

   206

   209

   214

   296

                else :

   298

   299

                if remote_node not in nodes :

   300

                    log.info("%s:%s: lazy-add remote %s (%s)", host, port, remote_node, remote_label)

   301

   302

                    nodes[remote_node] = remote_label

   303

   305

   310

   311

    return nodes, links

   312

   313

class GraphVlans (object) :

   314

    """

   315

        Maintain vlan -> dot style/color mappings

   316

    """

   317

   318

    SERIES = 'paired12'

   319

    NONE = 'black'

   320

   321

    def __init__ (self, vlans=None) :

   322

        if vlans :

   323

            self.vlans = dict(vlans)

   324

        else :

   325

            self.vlans = { }

   326

   327

    def color (self, vlan) :

   328

        if vlan in self.vlans :

   329

            return self.vlans[vlan]

   330

   331

        # alloc

   332

        color = '/{series}/{index}'.format(series=self.SERIES, index=len(self.vlans) + 1)

   333

   334

        self.vlans[vlan] = color

   335

   336

        return color

   337

   338

def dot_quote (value) :

   339

    """

   340

        Quote a dot value.

   341

    """

   342

   343

    return '"{value}"'.format(value=value)

   344

   345

def dot (*line, **attrs) :

   346

    """

   347

        Build dot-syntax:

   348

            *line {

   349

                *line [**attrs];

   350

            }

   351

    """

   352

   353

    if line and attrs :

   354

        return ''.join(('\t', ' '.join(str(x) for x in line), ' [',

   356

        ']', ';'))

   357

    elif line :

   358

        return ' '.join(line) + ' {'

   359

    else :

   360

        return '}'

   361

   362

def build_dot (options, nodes, links, type='digraph', vlans=None) :

   363

    """

   364

        Construct a dot description of the given node/links graph.

   365

    """

   366

   367

    if vlans is True :

   368

        vlans = { }

   369

   370

    yield dot(type, 'verkko')

   371

   372

    # defaults

   373

    yield dot('graph',

   374

            # XXX: breaks multi-edges?

   375

            #splines     = 'true',

   376

   377

            sep             = '+25,25',

   378

            overlap         = 'scalexy',

   379

   380

            # only applies to loops

   381

            nodesep     = 0.5,

   382

    )

   383

    yield dot('edge',

   384

        labeldistance   = 3.0,

   385

        penwidth        = 2.0,

   386

    )

   387

    yield dot('node',

   388

        fontsize        = 18,

   389

    )

   390

   391

    # nodes

   392

    for node, node_label in nodes.iteritems() :

   393

        yield dot(dot_quote(node), label=node_label)

   394

   395

    # links

   408

        else :

   411

            line_colors = []

   412

   413

        if head_color and tail_color :

   414

            dir = 'both'

   415

            colors = [head_color, tail_color] + line_colors

   416

        elif head_color :

   417

            dir = 'forward'

   418

            colors = [head_color] + line_colors

   419

        elif tail_color :

   420

            dir = 'back'

   421

            colors = [vlans.NONE, tail_color] + line_colors

   422

        else :

   423

            dir = 'none'

   424

            colors = line_colors

   425

   426

        yield dot(dot_quote(local), '->', dot_quote(remote),

   427

            taillabel   = local_port,

   428

            headlabel   = remote_port,

   429

            dir         = dir,

   430

   431

            fillcolor   = 'black',

   433

        )

   434

   435

    yield dot()

   436

   437

def apply_dot (options, file, dot) :

   438

    """

   439

        Output dot file for given graphbits

   440

    """

   441

   442

    for line in dot :

   443

        file.write(line + '\n')

   444

   445

def main (argv) :

   446

    """

   447

        Graph network

   448

    """

   449

   450

    parser = optparse.OptionParser(main.__doc__)

   451

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

   452

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

   453

   454

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

   455

            help="Load snmp data from FILE")

   456

   457

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

   458

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

   459

   461

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

   463

   464

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

   465

            help="Do not color VLANs")

   466

   471

    # input

   472

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

   473

    pvl.args.apply(options)

   474

   475

    # load hosts

   476

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

   477

   478

    # load raw snmp data

   479

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

   480

   481

    # process data into graph

   483

   484

    # process graph into dot

   485

    if options.graph_vlans is False :

   486

        graph_vlans = None

   487

    else :

   488

        graph_vlans = GraphVlans()

   489

   490

    if options.graph_dot :

   491

        # process to dot

   492

        dot = build_dot(options, nodes, links, vlans=graph_vlans)

   493

   494

        # write out

   495

        apply_dot(options, open(options.graph_dot, 'w'), dot)

   496

   497