1

#!/usr/bin/env python

     2

     3

"""

     4

    Requirements:

     5

        pydot

     6

"""

     7

     8

import pvl.args

     9

import pvl.hosts

    10

    11

import collections

    12

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

    13

import optparse

    14

    15

COLOR_VLANS = {

    16

    1:      'grey',         # pvl-lan

    17

    2:      'blue',         # pvl-lan2

    18

    3:      'red',          # pvl-san

    19

    4:      'green',        # pvl-veturi

    20

    7:      'orange',       # pvl-ranssi

    21

    8:      'yellow',       # pvl-mgmt

    22

    10:     'brown',        # pvl-public

    23

    100:    'navyblue',     # pvl-test

    24

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

    25

    104:    'red2',         # pvl-ganeti

    26

    192:    'purple',       # paivola-services

    27

    255:    'magenta',      # pvl-sonera

    28

}

    29

    30

class ParseError (Exception) :

    31

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

    32

        self.file = file

    33

        self.line = line

    34

        self.msg = msg

    35

    36

    def __str__ (self) :

    37

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

    38

    49

def _load_snmp_data (options, file) :

    50

    """

    51

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

    52

    53

        Yields (host, attr, value)

    54

    """

    55

    56

    host = None

    57

    attr = None

    58

    value = None

    60

    61

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

    68

        line = line.strip()

    69

    78

        if indent == 0 :

    79

            host = line

    80

            attr = None

    81

            value = None

    83

    84

        elif indent == 1 :

    87

    99

   100

        elif indent == 2 :

   101

            if not attr :

   106

   108

   110

   111

def load_snmp_data (options, file, hosts) :

   112

    """

   113

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

   114

    """

   115

   116

    if file :

   117

        file = open(file)

   118

    else :

   119

        file = sys.stdin

   120

   121

    root = { }

   122

   123

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

   124

        host = hosts[host_name]

   125

   126

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

   127

   128

        item = root.setdefault(host, { })

   130

        for a in attr[:-1] :

   131

            item = item.setdefault(a, {})

   132

   133

        a = attr[-1]

   137

   138

        else :

   141

    return root

   142

   143

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

   144

    import pydot

   145

   146

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

   147

            # XXX: breaks multi-edges?

   148

            #splines     = 'true',

   149

   150

            sep             = '+25,25',

   151

            overlap         = 'scalexy',

   152

   153

            # only applies to loops

   154

            nodesep     = 0.5,

   155

    )

   156

    dot.set_edge_defaults(

   157

            labeldistance   = 3.0,

   158

            penwidth        = 2.0,

   159

    )

   160

   161

    nodes = { }

   162

    edges = { }

   163

    vlan_colors = { } # { vlan: color }

   164

   165

    for host, local, remote, remote_host in items :

   166

        # src

   167

        src_name = str(host)

   168

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

   169

   170

        if src_name in nodes :

   171

            src = nodes[src_name]

   172

        else :

   173

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

   174

                    label       = src_label,

   175

                    fontsize    = 18,

   176

            )

   177

            dot.add_node(src)

   178

   179

        # dst

   180

        if remote_host :

   181

            dst_name = str(remote_host)

   182

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

   183

        else :

   184

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

   185

   186

            # XXX: pydot is not smart enough to quote this

   187

            if remote['sys_name'] :

   188

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

   189

            else :

   190

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

   191

   192

        if dst_name in nodes :

   193

            dst = nodes[dst_name]

   194

        else :

   195

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

   196

                    label       = dst_label,

   197

                    fontsize    = 18,

   198

            )

   199

            dot.add_node(dst)

   200

   201

        # edges

   202

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

   203

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

   204

        fillcolor = 'black'

   205

        color = 'black'

   206

        untag = tagged = None

   207

   208

        # vlans?

   209

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

   210

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

   211

   212

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

   213

   214

            colors = []

   215

            for tag in sorted(tagged) :

   216

                if tag in COLOR_VLANS :

   217

                    colors.append(COLOR_VLANS[tag])

   218

                elif tag in vlan_colors :

   219

                    colors.append(vlan_colors[tag])

   220

                else :

   221

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

   222

   223

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

   224

   225

                    vlan_colors[tag] = color

   226

                    colors.append(color)

   227

   228

            if not untag :

   229

                pass

   230

            elif untag in COLOR_VLANS :

   231

                fillcolor = COLOR_VLANS[untag]

   232

            elif untag in vlan_colors :

   233

                fillcolor = vlan_colors[untag]

   234

            else :

   235

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

   236

   237

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

   238

   239

                fillcolor = vlan_colors[tag] = color

   240

   241

            # first color overrides fillcolor for heads

   242

            if colors and untag :

   243

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

   244

            elif colors :

   245

                color = ':'.join(colors)

   246

            elif fillcolor :

   247

                color = fillcolor

   248

   249

        elif vlans :

   250

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

   251

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

   252

   253

        # edge

   254

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

   255

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

   256

   257

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

   258

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

   259

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

   260

   261

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

   262

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

   263

   264

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

   265

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

   266

   267

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

   268

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

   269

   270

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

   271

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

   272

   273

            # mark as bidirectional

   274

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

   275

   276

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

   277

   278

            # set second color for tail

   279

            if untag :

   280

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

   281

                    headcolor   = edge.get('fillcolor'),

   282

                    tailcolor   = fillcolor,

   283

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

   284

                ))

   285

   286

        else :

   287

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

   288

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

   289

                    headlabel   = headlabel,

   290

                    taillabel   = taillabel,

   291

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

   292

                    fillcolor   = fillcolor,

   293

            )

   294

   295

            dot.add_edge(edge)

   296

   297

    if options.graph_dot :

   298

        dot.write(options.graph_dot)

   299

   300

def main (argv) :

   301

    """

   302

        Graph network

   303

    """

   304

   305

    parser = optparse.OptionParser(main.__doc__)

   306

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

   307

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

   308

   309

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

   310

            help="Load snmp data from FILE")

   311

   312

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

   313

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

   314

   315

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

   316

            help="Graph all VLANs")

   317

   318

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

   319

            help="Do not color VLANs")

   320

   321

    # input

   322

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

   323

    pvl.args.apply(options)

   324

   325

    # load hosts for correlation

   326

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

   327

   328

    # load raw snmp data

   329

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

   330

   331

    import pprint; pprint.pprint(data)

   332

   333

    # TODO: process data into graph

   334

   335

    # TODO: generate graph

   336

    #apply_graph(options, items, vlans if options.vlans else None)

   337

   338

    return 0

   339

   340

if __name__ == '__main__':

   341

    pvl.args.main(main)