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 = { }

   115

   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

   171

def build_graph (snmp, hosts) :

   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

   183

   184

    # first scan: lldp hosts

   185

    for host, host_attrs in snmp.iteritems() :

   186

        lldp = host_attrs.get('lldp')

   187

   188

        if lldp :

   189

            lldp_local = lldp['local']

   190

            local = lldp_local['chassis']

   191

   193

            hosts_by_lldp[local] = host

   194

   200

    # second scan: lldp remotes

   201

    for host, host_attrs in snmp.iteritems() :

   202

        lldp = host_attrs.get('lldp')

   203

   204

        if not lldp :

   205

            continue

   206

   207

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

   208

        local_node = host

   209

   210

        if 'vlan' in host_attrs :

   211

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

   212

        else :

   213

            vlans = None

   214

   215

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

   216

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

   217

   218

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

   222

                if remote in hosts_by_lldp :

   233

                else :

   234

                    remote_node = remote

   236

   242

   244

   245

                # local vlans

   246

                if vlans :

   247

                    port_vlans = vlans.get(port)

   248

                else :

   249

                    port_vlans = None

   250

   251

                if port_vlans :

   252

                    local_untag, local_tagged = port_vlans

   253

   254

                # bidirectional mappings

   257

                forward = (local_node, local_port, remote_port, remote_node)

   258

                reverse = (remote_node, remote_port, local_port, local_node)

   259

   260

                if reverse not in links :

   261

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

   262

                else :

   263

                    remote_untag, remote_tagged, _ = links[reverse]

   264

   265

                    # merge

   266

                    if remote_untag != local_untag :

   267

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

   268

                                host, local_port, local_untag,

   269

                                remote_untag, remote_node, remote_port

   270

                        )

   271

   272

                    if remote_tagged != local_tagged :

   273

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

   274

                                host, local_port, ':'.join(str(x) for x in sorted(local_tagged)),

   275

                                ':'.join(str(x) for x in sorted(remote_tagged)), remote_node, remote_port

   276

                        )

   277

   278

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

   279

   280

    return nodes, links

   281

   282

class GraphVlans (object) :

   283

    """

   284

        Maintain vlan -> dot style/color mappings

   285

    """

   286

   287

    SERIES = 'paired12'

   288

    NONE = 'black'

   289

   290

    def __init__ (self, vlans=None) :

   291

        if vlans :

   292

            self.vlans = dict(vlans)

   293

        else :

   294

            self.vlans = { }

   295

   296

    def color (self, vlan) :

   297

        if vlan in self.vlans :

   298

            return self.vlans[vlan]

   299

   300

        # alloc

   301

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

   302

   303

        self.vlans[vlan] = color

   304

   305

        return color

   306

   307

def dot_quote (value) :

   308

    """

   309

        Quote a dot value.

   310

    """

   311

   312

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

   313

   314

def dot (*line, **attrs) :

   315

    """

   316

        Build dot-syntax:

   317

            *line {

   318

                *line [**attrs];

   319

            }

   320

    """

   321

   322

    if line and attrs :

   323

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

   324

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

   325

        ']', ';'))

   326

    elif line :

   327

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

   328

    else :

   329

        return '}'

   330

   331

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

   332

    """

   333

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

   334

    """

   335

   336

    if vlans is True :

   337

        vlans = { }

   338

   339

    yield dot(type, 'verkko')

   340

   341

    # defaults

   342

    yield dot('graph',

   343

            # XXX: breaks multi-edges?

   344

            #splines     = 'true',

   345

   346

            sep             = '+25,25',

   347

            overlap         = 'scalexy',

   348

   349

            # only applies to loops

   350

            nodesep     = 0.5,

   351

    )

   352

    yield dot('edge',

   353

        labeldistance   = 3.0,

   354

        penwidth        = 2.0,

   355

    )

   356

    yield dot('node',

   357

        fontsize        = 18,

   358

    )

   359

   360

    # nodes

   361

    for node, node_label in nodes.iteritems() :

   362

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

   363

   364

    # links

   365

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

   366

        if vlans :

   367

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

   368

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

   369

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

   370

        else :

   371

            head_color = GraphVlans.NONE if local_untag else None

   372

            tail_color = GraphVlans.NONE if remote_untag else None

   373

            line_colors = []

   374

   375

        if head_color and tail_color :

   376

            dir = 'both'

   377

            colors = [head_color, tail_color] + line_colors

   378

        elif head_color :

   379

            dir = 'forward'

   380

            colors = [head_color] + line_colors

   381

        elif tail_color :

   382

            dir = 'back'

   383

            colors = [vlans.NONE, tail_color] + line_colors

   384

        else :

   385

            dir = 'none'

   386

            colors = line_colors

   387

   388

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

   389

            taillabel   = local_port,

   390

            headlabel   = remote_port,

   391

            dir         = dir,

   392

   393

            fillcolor   = 'black',

   394

            color       = ':'.join(colors),

   395

        )

   396

   397

    yield dot()

   398

   399

def apply_dot (options, file, dot) :

   400

    """

   401

        Output dot file for given graphbits

   402

    """

   403

   404

    for line in dot :

   405

        file.write(line + '\n')

   406

   407

def main (argv) :

   408

    """

   409

        Graph network

   410

    """

   411

   412

    parser = optparse.OptionParser(main.__doc__)

   413

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

   414

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

   415

   416

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

   417

            help="Load snmp data from FILE")

   418

   419

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

   420

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

   421

   422

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

   423

            help="Graph all VLANs")

   424

   425

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

   426

            help="Do not color VLANs")

   427

   428

    # input

   429

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

   430

    pvl.args.apply(options)

   431

   434

   435

    # load raw snmp data

   436

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

   437

   438

    # process data into graph

   439

    nodes, links = build_graph(snmp, hosts)

   440

   441

    # process graph into dot

   442

    if options.graph_vlans is False :

   443

        graph_vlans = None

   444

    else :

   445

        graph_vlans = GraphVlans()

   446

   447

    if options.graph_dot :

   448

        # process to dot

   449

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

   450

   451

        # write out

   452

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

   453

   454

    return 0

   455

   456

if __name__ == '__main__':

   457

    pvl.args.main(main)