1

#!/usr/bin/env python

     2

     3

"""

     4

    Requirements:

     5

        pysnmp

     6

        pysnmp-mibs

     7

        memoized-property

     8

     9

    Setup:

    10

        ./opt/bin/build-pysnmp-mib -o usr/mibs/LLDP-MIB.py etc/mibs/LLDP-MIB

    11

    12

    Run:

    13

        PYSNMP_MIB_DIRS=usr/mibs/ ./opt/bin/python ...

    14

"""

    15

    16

import pvl.args

    17

import pvl.hosts

    18

    19

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

    20

import optparse

    21

    22

from pysnmp.entity.rfc3413.oneliner import cmdgen as pysnmp

    23

import collections

    24

    25

class SNMPError (Exception) :

    26

    pass

    27

    28

class SNMPEngineError (SNMPError) :

    29

    """

    30

        Internal SNMP Engine error (?)

    31

    """

    32

    33

class SNMPAgent (object) :

    34

    """

    35

        GET SNMP shit from a remote host.

    36

    """

    37

    38

    SNMP_PORT = 161

    39

    snmp_cmdgen = pysnmp.CommandGenerator()

    40

    41

    @classmethod

    42

    def apply (cls, options, host) :

    43

        community = options.snmp_community

    44

        port = cls.SNMP_PORT

    45

    46

        if '@' in host :

    47

            community, host = host.split('@', 1)

    48

    49

        if ':' in host :

    50

            host, port = host.rsplit(':', 1)

    51

    52

        return cls(

    53

                pysnmp.CommunityData(community),

    54

                pysnmp.UdpTransportTarget((host, port))

    55

        )

    56

    57

    def __init__ (self, security, transport) :

    58

        self.security = security

    59

        self.transport = transport

    60

    61

    def get (self, *request) :

    62

        """

    63

            request = (

    64

                pysnmp.MibVariable('IF-MIB', 'ifInOctets', 1),

    65

            )

    66

        """

    67

    68

        opts = dict(

    69

                lookupNames     = True,

    70

                lookupValues    = True,

    71

        )

    72

    73

        try :

    74

            error, error_status, error_index, response = self.snmp_cmdgen.getCmd(self.security, self.transport,  *request, **opts)

    75

        except pysnmp.error.PySnmpError as ex :

    76

            raise SNMPEngineError(ex)

    77

    78

        if error :

    79

            raise SNMPEngineError(error)

    80

    81

        if error_status :

    82

            raise SNMPError(errorStatus.prettyPrint())

    83

    84

        return response

    85

        #for name, value in response :

    86

        #    yield name.getMibSymbol(), value.prettyPrint()

    87

    88

    def walk (self, *request) :

    89

        """

    90

            request = (

    91

                    pysnmp.MibVariable('IF-MIB', 'ifInOctets'),

    92

            )

    93

        """

    94

    95

        opts = dict(

    96

                lookupNames     = True,

    97

                lookupValues    = True,

    98

        )

    99

   100

        try :

   101

            error, error_status, error_index, responses = self.snmp_cmdgen.nextCmd(self.security, self.transport, *request, **opts)

   102

        except pysnmp.error.PySnmpError as ex :

   103

            raise SNMPEngineError(ex)

   104

   105

        if error :

   106

            raise SNMPEngineError(error)

   107

   108

        if error_status :

   109

            raise SNMPError(errorStatus.prettyPrint())

   110

   111

        return responses

   112

        #for response in responses:

   113

        #    for name, value in response :

   114

        #        yield name.getMibSymbol(), value.prettyPrint()

   115

   116

    def table (self, table) :

   117

        """

   118

            Load a simple table with a running index.

   119

   120

            Given [(attr, oid, type)] yields { attr: type(value) }

   121

        """

   122

   123

        data = collections.defaultdict(dict)

   124

   125

        for row in self.walk(*[oid for attr, oid, type in table]) :

   126

            log.debug("%s", row)

   127

   128

            for (attr, type), (field, value) in zip([(attr, type) for attr, oid, type in table], row) :

   129

                mib, sym, idx = field.getMibSymbol()

   130

   131

                # convert

   132

                if type :

   133

                    value = type(value)

   134

   135

                log.debug("%s::%s.%s: %s: %s", mib, sym, idx, attr, value)

   136

   137

                data[idx][attr] = value

   138

   139

        return data.items()

   140

   141

from memoized_property import memoized_property

   142

   143

def macaddr (value) :

   144

    """

   145

        Excepts a MAC address from an SNMP OctetString.

   146

    """

   147

   148

    return ':'.join('{octet:02x}'.format(octet=c) for c in value.asNumbers())

   149

   150

class LLDPAgent (SNMPAgent) :

   151

    """

   152

        Query LLDP info from a remote agent.

   153

    """

   154

   155

    LOCAL = (

   156

            ( 'chassis_id',     pysnmp.MibVariable('LLDP-MIB', 'lldpLocChassisId'),     macaddr ),

   157

            ( 'sys_name',       pysnmp.MibVariable('LLDP-MIB', 'lldpLocSysName'),       str     ),

   158

    )

   159

   160

    @memoized_property

   161

    def local (self) :

   162

        """

   163

            Describe the local system.

   164

        """

   165

   166

        for idx, data in self.table(self.LOCAL) :

   167

            return data

   168

   169

    PORTS = (

   170

            ( 'port_id',        pysnmp.MibVariable('LLDP-MIB', 'lldpLocPortId'),      str     ),

   171

    )

   172

   173

    @memoized_property

   174

    def ports (self) :

   175

        """

   176

            Describe the local ports.

   177

        """

   178

   179

        ports = { }

   180

   181

        for idx, data in self.table(self.PORTS) :

   182

            port, = idx

   183

   184

            ports[int(port)] = data

   185

   186

        return ports

   187

   188

    def port (self, port) :

   189

        return self.ports[port]

   190

   191

    REMOTE_DATA = (

   192

            ( 'chassis_id',     pysnmp.MibVariable('LLDP-MIB', 'lldpRemChassisId'),     macaddr ),

   193

            ( 'sys_name',       pysnmp.MibVariable('LLDP-MIB', 'lldpRemSysName'),       str     ),

   194

            ( 'remote_port',    pysnmp.MibVariable('LLDP-MIB', 'lldpRemPortId'),        str     ),

   195

    )

   196

   197

    def remotes (self) :

   198

        """

   199

            Describe remote systems, indexed by local port.

   200

        """

   201

   202

        for idx, data in self.table(self.REMOTE_DATA) :

   203

            time, port, idx = idx

   204

   205

            yield int(port), data

   206

   207

def main (argv) :

   208

    """

   209

        SNMP polling.

   210

    """

   211

   212

    parser = optparse.OptionParser(main.__doc__)

   213

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

   214

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

   215

   216

    parser.add_option('--snmp-community',

   217

            help="SNMPv2 read community")

   218

   219

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

   220

    pvl.args.apply(options)

   221

   222

    # input

   223

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

   224

   225

    for arg in args :

   226

        lldp = LLDPAgent.apply(options, arg)

   227

   228

        print arg, "{chassis_id}({sys_name})".format(**lldp.local)

   229

   230

        for port, remote in lldp.remotes() :

   231

            print '\t', lldp.port(port), remote

   232

   233

if __name__ == '__main__':

   234

    pvl.args.main(main)