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

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

   111

        host = hosts.get(host_name)

   112

   113

        if value :

   114

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

   115

        else :

   116

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

   117

   118

        item = root.setdefault(host, { })

   119

   120

        for a in attr[:-1] :

   121

            item = item.setdefault(a, {})

   122

   123

        a = attr[-1]

   124

   125

        if value is None :

   126

            pass

   127

   128

        elif isinstance(value, set) :

   129

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

   130

   131

        elif isinstance(value, dict) :

   132

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

   133

   134

        else :

   135

            item[a] = value

   136

   137

    return root

   138

   139

def host_vlans (host, host_vlans) :

   140

    """

   141

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

   142

    """

   143

   144

    ports = set()

   145

    vlans_untagged = { }

   146

    vlans_tagged = collections.defaultdict(set)

   147

   148

    for vlan, vlan_attrs in host_vlans.iteritems() :

   149

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

   150

            ports.add(port)

   151

            vlans_tagged[port].add(vlan)

   152

   153

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

   154

            ports.add(port)

   155

            vlans_untagged[port] = vlan

   156

   157

    for port in ports :

   158

        untag = vlans_untagged.get(port)

   159

        tagged = vlans_tagged.get(port, ())

   160

   161

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

   162

   163

        yield port, (untag, tagged)

   164

   165

def build_graph (snmp, hosts) :

   166

    """

   167

        Combine given snmp data and { host: Host } into

   168

            { node: label }

   169

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

   170

    """

   171

   173

    links = { }

   176

   177

    # first scan: lldp hosts

   178

    for host, host_attrs in snmp.iteritems() :

   179

        lldp = host_attrs.get('lldp')

   180

   181

        if lldp :

   182

            lldp_local = lldp['local']

   184

   187

   188

    # second scan: lldp remotes

   189

    for host, host_attrs in snmp.iteritems() :

   190

        lldp = host_attrs.get('lldp')

   191

   192

        if not lldp :

   193

            continue

   194

   195

        local = lldp['local']['chassis']

   197

   198

        if 'vlan' in host_attrs :

   199

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

   200

        else :

   201

            vlans = None

   202

   203

        for port, port_attrs in lldp.get('port', { }).iteritems() :

   204

            local_port = port_attrs['local']['port']

   205

   206

            for remote, remote_attrs in port_attrs['remote'].iteritems() :

   214

   215

                remote_port = remote_attrs['port']

   216

   217

                # local vlans

   218

                if vlans :

   219

                    port_vlans = vlans.get(port)

   220

                else :

   221

                    port_vlans = None

   222

   223

                if port_vlans :

   224

                    local_untag, local_tagged = port_vlans

   225

   226

                # bidirectional mappings

   229

   230

                if reverse not in links :

   231

                    links[forward] = (local_untag, local_tagged, None)

   232

                else :

   233

                    remote_untag, remote_tagged, _ = links[reverse]

   234

   235

                    # merge

   236

                    if remote_untag != local_untag :

   237

                        log.warning("%s:%s untag %s <=> %s untag %s:%s",

   240

                        )

   241

   242

                    if remote_tagged != local_tagged :

   243

                        log.warning("%s:%s tagged %s <-> %s tagged %s:%s",

   246

                        )

   247

   248

                    links[reverse] = (remote_untag, remote_tagged, local_untag)

   249

   250

    return nodes, links

   251

   252

class GraphVlans (object) :

   253

    """

   254

        Maintain vlan -> dot style/color mappings

   255

    """

   256

   257

    SERIES = 'paired12'

   258

    NONE = 'black'

   259

   260

    def __init__ (self, vlans=None) :

   261

        if vlans :

   262

            self.vlans = dict(vlans)

   263

        else :

   264

            self.vlans = { }

   265

   266

    def color (self, vlan) :

   267

        if vlan in self.vlans :

   268

            return self.vlans[vlan]

   269

   270

        # alloc

   271

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

   272

   273

        self.vlans[vlan] = color

   274

   275

        return color

   276

   277

def dot_quote (value) :

   278

    """

   279

        Quote a dot value.

   280

    """

   281

   282

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

   283

   284

def dot (*line, **attrs) :

   285

    """

   286

        Build dot-syntax:

   287

            *line {

   288

                *line [**attrs];

   289

            }

   290

    """

   291

   292

    if line and attrs :

   293

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

   294

            ', '.join('{name}="{value}"'.format(name=name, value=value) for name, value in attrs.iteritems()),

   295

        ']', ';'))

   296

    elif line :

   297

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

   298

    else :

   299

        return '}'

   300

   301

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

   302

    """

   303

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

   304

    """

   305

   306

    if vlans is True :

   307

        vlans = { }

   308

   309

    yield dot(type, 'verkko')

   310

   311

    # defaults

   312

    yield dot('graph',

   313

            # XXX: breaks multi-edges?

   314

            #splines     = 'true',

   315

   316

            sep             = '+25,25',

   317

            overlap         = 'scalexy',

   318

   319

            # only applies to loops

   320

            nodesep     = 0.5,

   321

    )

   322

    yield dot('edge',

   323

        labeldistance   = 3.0,

   324

        penwidth        = 2.0,

   325

    )

   326

    yield dot('node',

   327

        fontsize        = 18,

   328

    )

   329

   330

    # nodes

   331

    for node, node_label in nodes.iteritems() :

   332

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

   333

   334

    # links

   335

    for (local, local_port, remote_port, remote), (local_untag, tagged, remote_untag) in links.iteritems() :

   336

        if vlans :

   337

            head_color = vlans.color(local_untag) if local_untag else None

   338

            tail_color = vlans.color(remote_untag) if remote_untag else None

   339

            line_colors = [vlans.color(tag) for tag in sorted(tagged)]

   340

        else :

   341

            head_color = GraphVlans.NONE if local_untag else None

   342

            tail_color = GraphVlans.NONE if remote_untag else None

   343

            line_colors = []

   344

   345

        if head_color and tail_color :

   346

            dir = 'both'

   347

            colors = [head_color, tail_color] + line_colors

   348

        elif head_color :

   349

            dir = 'forward'

   350

            colors = [head_color] + line_colors

   351

        elif tail_color :

   352

            dir = 'back'

   353

            colors = [vlans.NONE, tail_color] + line_colors

   354

        else :

   355

            dir = 'none'

   356

            colors = line_colors

   357

   358

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

   359

            taillabel   = local_port,

   360

            headlabel   = remote_port,

   361

            dir         = dir,

   362

   363

            fillcolor   = 'black',

   364

            color       = ':'.join(colors),

   365

        )

   366

   367

    yield dot()

   368

   369

def apply_dot (options, file, dot) :

   370

    """

   371

        Output dot file for given graphbits

   372

    """

   373

   374

    for line in dot :

   375

        file.write(line + '\n')

   376

   377

def main (argv) :

   378

    """

   379

        Graph network

   380

    """

   381

   382

    parser = optparse.OptionParser(main.__doc__)

   383

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

   384

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

   385

   386

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

   387

            help="Load snmp data from FILE")

   388

   389

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

   390

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

   391

   392

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

   393

            help="Graph all VLANs")

   394

   395

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

   396

            help="Do not color VLANs")

   397

   398

    # input

   399

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

   400

    pvl.args.apply(options)

   401

   402

    # load hosts for correlation

   403

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

   404

   405

    # load raw snmp data

   406

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

   407

   408

    # process data into graph

   409

    nodes, links = build_graph(snmp, hosts)

   410

   411

    # process graph into dot

   412

    if options.graph_vlans is False :

   413

        graph_vlans = None

   414

    else :

   415

        graph_vlans = GraphVlans()

   416

   417

    if options.graph_dot :

   418

        # process to dot

   419

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

   420

   421

        # write out

   422

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

   423

   424

    return 0

   425

   426

if __name__ == '__main__':

   427

    pvl.args.main(main)