Example #1
0
    def __init__(self, args):
        configDict = loadConfig(args.config)

        self.moduleLogger = set_logging(configDict, __class__.__name__)

        self.moduleLogger.debug('configDict:{}'.format(configDict))

        mibBuilder = builder.MibBuilder()
        self._mibViewController = view.MibViewController(mibBuilder)

        compiler.addMibCompiler(
            mibBuilder, sources=configDict['snmp'].get('mibs', ()))

        # this dict holds all OID items indexed by MIB symbols
        self._mibObjects = collections.defaultdict(dict)

        # this dict holds only recently updated OIDs (indexed by
        # MIB name and object)
        self._candidateMibObjects = collections.defaultdict(dict)

        # this dict holds all OID items populated from `mibObjects`
        self._oids = {}

        self._expireBy = time.time() + self.EXPIRE_PERIOD

        self._dirty = True  # OIDs need sorting
Example #2
0
    def __init__(self, args, queue):

        configDict = loadConfig(args.config)

        self.moduleLogger = set_logging(configDict, __class__.__name__)

        self.listeningIP = configDict['notificator']['listeningIP']
        self.listeningPort = configDict['notificator']['listeningPort']

        self.requestCounter = 0

        self.queue = queue
Example #3
0
    def setOidDbAndLogger(self, oidDb, args):
        """Attach OID DB and logging objects

        Args:
            oidDb (OidDb): OID DB object to operate on
            args (object): argparse namespace object holding
                command-line options
        """
        self._oidDb = oidDb

        configDict = loadConfig(args.config)

        self.moduleLogger = set_logging(configDict, __class__.__name__)

        return self
Example #4
0
    def __init__(self, args):

        configDict = loadConfig(args.config)

        self._moduleLogger = set_logging(configDict, __class__.__name__)

        self._moduleLogger.debug(f'configDict:{configDict}')
        self._restHost = configDict['access']['rtbrickHost']
        self._restPorts = (configDict['access']['rtbrickPorts'])

        self._staticOidDict = configDict['responder']['staticOidContent']

        self._oidDb = OidDb(args)

        # keeps track of changes to the BDS data
        self._bdsIds = collections.defaultdict(list)
    def __init__(self, args, queue):
        configDict = loadConfig(args.config)

        self.moduleLogger = set_logging(configDict, __class__.__name__)

        self.moduleLogger.info(f'original configDict: {configDict}')

        self._queue = queue

        # temp lines for graylog client end #
        # configDict['usmUserDataMatrix'] = [ usmUserTuple.strip().split(',')
        # for usmUserTuple in configDict['usmUserTuples'].split(';') if len(usmUserTuple) > 0 ]
        # self.moduleLogger.debug('configDict['usmUserDataMatrix']: {}'.format(configDict['usmUserDataMatrix']))
        # configDict['usmUsers'] = []
        self.moduleLogger.info(f'modified configDict: {configDict}')

        self._snmpEngine = snmp_config.getSnmpEngine(
            engineId=configDict['snmp'].get('engineId'))

        engineBoots = snmp_config.setSnmpEngineBoots(
            self._snmpEngine, configDict.get('stateDir', '.'))

        self._targets = snmp_config.setTrapTypeForTag(self._snmpEngine, self.TARGETS_TAG)

        authEntries = {}

        for snmpVersion, snmpConfigEntries in configDict['snmp'].get(
                'versions', {}).items():

            snmpVersion = str(snmpVersion)

            if snmpVersion in ('1', '2c'):

                for security, snmpConfig in snmpConfigEntries.items():

                    community = snmpConfig['community']

                    authLevel = snmp_config.setCommunity(
                        self._snmpEngine, security, community, version=snmpVersion, tag=self.TARGETS_TAG)

                    self.moduleLogger.info(
                        f'Configuring SNMPv{snmpVersion} security name '
                        f'{security}, community name {community}')

                    authEntries[security] = snmpVersion, authLevel

            elif snmpVersion == '3':

                for security, usmCreds in snmpConfigEntries.get('usmUsers', {}).items():

                    authLevel = snmp_config.setUsmUser(
                        self._snmpEngine, security,
                        usmCreds.get('user'),
                        usmCreds.get('authKey'), usmCreds.get('authProtocol'),
                        usmCreds.get('privKey'), usmCreds.get('privProtocol'))

                    self.moduleLogger.info(
                        f'Configuring SNMPv3 USM security {security}, user '
                        f'{usmCreds.get("user")}, '
                        f'auth {usmCreds.get("authKey")}/{usmCreds.get("authProtocol")}, '
                        f'priv {usmCreds.get("privKey")}/{usmCreds.get("privProtocol")}')

                    authEntries[security] = snmpVersion, authLevel

            else:
                raise error.BdsError(f'Unknown SNMP version {snmpVersion}')

            self._birthday = time.time()

        snmpTrapTargets = configDict['notificator'].get('snmpTrapTargets', {}).items()

        for targetId, (targetName, targetConfig) in enumerate(snmpTrapTargets):

            bind_address = targetConfig.get('bind-address', '0.0.0.0'), 0

            security = targetConfig['security-name']

            transportDomain = snmp_config.setSnmpTransport(
                self._snmpEngine, iface=bind_address, iface_num=targetId)

            transportAddress = (targetConfig['address'],
                                int(targetConfig.get('port', 162)))

            snmp_config.setTrapTargetAddress(
                self._snmpEngine, security, transportDomain, transportAddress,
                tag=self.TARGETS_TAG)

            snmpVersion, authLevel = authEntries[security]

            snmp_config.setTrapVersion(
                self._snmpEngine, security, authLevel, snmpVersion)

            self.moduleLogger.info(
                f'Configuring target #{targetId}, transport domain '
                f'{transportDomain}, destination {transportAddress}, '
                f'bind address {bind_address} using security name {security}')

        self._configureMibObjects(configDict)

        self._ntfOrg = ntforg.NotificationOriginator()

        self._trapCounter = 0

        self.moduleLogger.info(
            f'Running SNMP engine ID {self._snmpEngine}, boots {engineBoots}')
Example #6
0
    def __init__(self, args, mibController):
        self.mibController = mibController

        configDict = loadConfig(args.config)

        self.moduleLogger = set_logging(configDict, __class__.__name__)

        self.moduleLogger.debug(f'configDict:{configDict}')

        self.snmpEngine = snmp_config.getSnmpEngine(
            engineId=configDict['snmp'].get('engineId'))

        engineBoots = snmp_config.setSnmpEngineBoots(
            self.snmpEngine, configDict.get('stateDir', '.'))

        self.listeningAddress = configDict['responder']['listeningIP']
        self.listeningPort = configDict['responder']['listeningPort']
        self.birthday = time.time()

        self.moduleLogger.info(
            f'Running SNMP engine ID {self.snmpEngine.snmpEngineID.prettyPrint()}, '
            f'boots {engineBoots}')

        # UDP over IPv4
        try:
            snmp_config.setSnmpTransport(
                self.snmpEngine, (self.listeningAddress, self.listeningPort))

        except Exception as exc:
            self.moduleLogger.error(f'SNMP transport error: {exc}')
            raise

        self.moduleLogger.info(
            f'SnmpEngine UDPv4 listening on {self.listeningAddress} '
            f'{self.listeningPort}')

        for snmpVersion, snmpConfigEntries in configDict['snmp'].get(
                'versions', {}).items():

            snmpVersion = str(snmpVersion)

            if snmpVersion in ('1', '2c'):

                for security, snmpConfig in snmpConfigEntries.items():
                    community = snmpConfig['community']

                    snmp_config.setCommunity(
                        self.snmpEngine, security, community, version=snmpVersion)

                    self.moduleLogger.info(
                        f'Configuring SNMPv{snmpVersion} security name '
                        f'{security}, community name {community}')

            elif snmpVersion == '3':

                for security, usmCreds in snmpConfigEntries.get('usmUsers', {}).items():
                    snmp_config.setUsmUser(
                        self.snmpEngine, security,
                        usmCreds.get('user'),
                        usmCreds.get('authKey'), usmCreds.get('authProtocol'),
                        usmCreds.get('privKey'), usmCreds.get('privProtocol'))

                    self.moduleLogger.info(
                        f'Configuring SNMPv3 USM security {security}, user '
                        f'{usmCreds.get("user")}, '
                        f'auth {usmCreds.get("authKey")}/{usmCreds.get("authProtocol")}, '
                        f'priv {usmCreds.get("privKey")}/{usmCreds.get("privProtocol")}')

            else:
                raise error.BdsError('Unknown SNMP version {snmpVersion}')

        snmpContext = snmp_config.setMibController(
            self.snmpEngine, mibController)

        self.moduleLogger.info(
            f'Configuring SNMP context name "{snmpContext}"')

        cmdrsp.GetCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.NextCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.BulkCommandResponder(self.snmpEngine, snmpContext)

        self.snmpEngine.transportDispatcher.jobStarted(1)