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

    47

    for part in line.split() :

    48

        yield _parse_snmp_part(part)

    49

    53

    55

    56

    else :

    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

    78

    79

        if indent == 0 :

    80

            host = line

    81

            attr = None

    82

            value = None

    83

    84

        elif indent == 1 :

    87

    89

    90

        elif indent == 2 :

    91

            if not attr :

    92

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

    93

    95

    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)

   117

   118

        item = root.setdefault(host, { })

   119

   120

        for a in attr[:-1] :

   121

            item = item.setdefault(a, {})

   122

   123

        a = attr[-1]

   124

   129

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

   130

   134

        else :

   135

            item[a] = value

   136

   137

    return root

   138

   139

def search_vlans (snmp) :

   140

    for host in snmp :

   141

        ports = set()

   142

        vlans_untagged = { }

   143

        vlans_tagged = collections.defaultdict(set)

   144

   145

        if 'vlan' not in snmp[host] :

   146

            continue

   147

   148

        for vlan in snmp[host]['vlan'] :

   149

            for port in snmp[host]['vlan'][vlan].get('tagged', ()) :

   150

                ports.add(port)

   151

                vlans_tagged[port].add(vlan)

   152

   153

            for port in snmp[host]['vlan'][vlan].get('untagged', ()) :

   155

                vlans_untagged[port] = vlan

   156

   157

        out = { }

   158

        for port in ports :

   159

            untag = vlans_untagged.get(port)

   161

   162

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

   163

   164

            out[port] = (untag, tagged)

   165

   166

        yield host, out

   167

   168

def search_lldp (snmp) :

   169

    lldp_hosts = {} 

   170

   171

    # first pass to resolve chassis ID's

   172

    for host, host_attrs in snmp.iteritems() :

   173

        lldp = host_attrs.get('lldp')

   174

   175

        if not lldp :

   176

            continue

   177

   178

        lldp_local = lldp.get('local')

   179

   180

        if not lldp_local :

   181

            continue

   182

   183

        lldp_hosts[lldp_local['chassis']] = host

   184

   185

    # second pass to resolve remote

   186

    for host, host_attrs in snmp.iteritems() :

   187

        lldp = host_attrs.get('lldp')

   188

   189

        if not lldp :

   190

            continue

   191

   192

        local_attrs = lldp.get('local')

   193

   194

        for port, port_attrs in snmp[host]['lldp']['port'].iteritems() :

   195

            port_local_attrs = port_attrs['local']

   196

   197

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

   198

                remote_host = lldp_hosts.get(chassis)

   199

   200

                local = merge(local_attrs, port_local_attrs, port_id=port)

   201

                remote = merge(remote_attrs, chassis=chassis)

   202

   203

                log.info("%s @ %s %s : %s %s @ %s", host, host.location, local, remote, remote_host.location if remote_host else '', remote_host)

   204

   205

                yield host, local, remote, remote_host

   206

   207

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

   208

    import pydot

   209

   210

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

   211

            # XXX: breaks multi-edges?

   212

            #splines     = 'true',

   213

   214

            sep             = '+25,25',

   215

            overlap         = 'scalexy',

   216

   217

            # only applies to loops

   218

            nodesep     = 0.5,

   219

    )

   220

    dot.set_edge_defaults(

   221

            labeldistance   = 3.0,

   222

            penwidth        = 2.0,

   223

    )

   224

   225

    nodes = { }

   226

    edges = { }

   227

    vlan_colors = { } # { vlan: color }

   228

   229

    for host, local, remote, remote_host in items :

   230

        # src

   231

        src_name = str(host)

   232

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

   233

   234

        if src_name in nodes :

   235

            src = nodes[src_name]

   236

        else :

   237

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

   238

                    label       = src_label,

   239

                    fontsize    = 18,

   240

            )

   241

            dot.add_node(src)

   242

   243

        # dst

   244

        if remote_host :

   245

            dst_name = str(remote_host)

   246

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

   247

        else :

   248

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

   249

   250

            # XXX: pydot is not smart enough to quote this

   251

            if remote['sys_name'] :

   252

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

   253

            else :

   254

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

   255

   256

        if dst_name in nodes :

   257

            dst = nodes[dst_name]

   258

        else :

   259

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

   260

                    label       = dst_label,

   261

                    fontsize    = 18,

   262

            )

   263

            dot.add_node(dst)

   264

   265

        # edges

   266

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

   267

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

   268

        fillcolor = 'black'

   269

        color = 'black'

   270

        untag = tagged = None

   271

   272

        # vlans?

   273

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

   274

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

   275

   276

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

   277

   278

            colors = []

   279

            for tag in sorted(tagged) :

   280

                if tag in COLOR_VLANS :

   281

                    colors.append(COLOR_VLANS[tag])

   282

                elif tag in vlan_colors :

   283

                    colors.append(vlan_colors[tag])

   284

                else :

   285

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

   286

   287

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

   288

   289

                    vlan_colors[tag] = color

   290

                    colors.append(color)

   291

   292

            if not untag :

   293

                pass

   294

            elif untag in COLOR_VLANS :

   295

                fillcolor = COLOR_VLANS[untag]

   296

            elif untag in vlan_colors :

   297

                fillcolor = vlan_colors[untag]

   298

            else :

   299

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

   300

   301

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

   302

   303

                fillcolor = vlan_colors[tag] = color

   304

   305

            # first color overrides fillcolor for heads

   306

            if colors and untag :

   307

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

   308

            elif colors :

   309

                color = ':'.join(colors)

   310

            elif fillcolor :

   311

                color = fillcolor

   312

   313

        elif vlans :

   314

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

   315

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

   316

   317

        # edge

   318

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

   319

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

   320

   321

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

   322

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

   323

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

   324

   325

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

   326

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

   327

   328

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

   329

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

   330

   331

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

   332

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

   333

   334

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

   335

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

   336

   337

            # mark as bidirectional

   338

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

   339

   340

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

   341

   342

            # set second color for tail

   343

            if untag :

   344

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

   345

                    headcolor   = edge.get('fillcolor'),

   346

                    tailcolor   = fillcolor,

   347

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

   348

                ))

   349

   350

        else :

   351

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

   352

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

   353

                    headlabel   = headlabel,

   354

                    taillabel   = taillabel,

   355

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

   356

                    fillcolor   = fillcolor,

   357

            )

   358

   359

            dot.add_edge(edge)

   360

   361

    if options.graph_dot :

   362

        dot.write(options.graph_dot)

   363

   364

def main (argv) :

   365

    """

   366

        Graph network

   367

    """

   368

   369

    parser = optparse.OptionParser(main.__doc__)

   370

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

   371

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

   372

   373

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

   374

            help="Load snmp data from FILE")

   375

   376

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

   377

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

   378

   379

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

   380

            help="Graph all VLANs")

   381

   382

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

   383

            help="Do not color VLANs")

   384

   385

    # input

   386

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

   387

    pvl.args.apply(options)

   388

   389

    # load hosts for correlation

   390

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

   391

   392

    # load raw snmp data

   393

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

   394

   395

    # TODO: process data into graph

   396

   397

    # XXX: compat

   398

    vlans = dict(search_vlans(snmp))

   399

    lldp = list(search_lldp(snmp))

   400

   401

    # generate graph

   402

    apply_graph(options, lldp, vlans if options.vlans else None)

   403

   404

    return 0

   405

   406

if __name__ == '__main__':

   407

    pvl.args.main(main)