Пример #1
0
 def get_object_type(self, snmp_engine):
     mib_view = CommandGeneratorVarBinds().getMibViewController(
         snmpEngine=snmp_engine)
     object_identity = self._create_object_identity()
     object_type = ObjectType(object_identity, self.value)
     object_type.resolveWithMib(mib_view)
     return object_type
Пример #2
0
def snmpRecvCallback(dispatcher, domain, address, msg):
    logger = logging.getLogger("apctrap")
    while msg:
        version = int(api.decodeMessageVersion(msg))
        if version in api.protoModules: module = api.protoModules[version]
        else:
            logger.error("SYSTEM\tERROR | Unsupported SNMP Version")
            return

        req, msg = decoder.decode(msg, asn1Spec=module.Message())
        logger.info("NOTIFICATION\t{} | {}".format(address, domain))

        pdu = module.apiMessage.getPDU(req)
        if not pdu.isSameTypeWith(module.TrapPDU()): continue

        if version == api.protoVersion1:
            varBinds = module.apiTrapPDU.getVarBindList(pdu)
        else:
            varBinds = module.apiPDU.getVarBindList(pdu)

        for v, b in varBinds:
            key = '.'.join([str(i) for i in v._value])
            value = b.getComponent('simple')._value

            parsed = ObjectType(ObjectIdentity(key), value)
            try:
                parsed.resolveWithMib(viewController)
            except Exception as e:
                logger.warning(
                    "TRAP\tERROR | Failed to resolve symbol ({}={})".format(
                        key, value))
                continue
            key, value = parsed.prettyPrint().split(" = ")
            logger.info("TRAP\t{} | {}".format(key, value))

            if key == "PowerNet-MIB::mtrapargsString.0":
                message = value
                for contact in contacts['contacts']:
                    phoneNumber = contact['phoneNumber']
                    _redis.publish(
                        'sms',
                        json.dumps(
                            dict(phoneNumber=phoneNumber, message=message)))

    return msg
Пример #3
0
def snmpRecvCallback(dispatcher, domain, address, msg):
    logger=logging.getLogger("apctrap")
    while msg:
        version=int(api.decodeMessageVersion(msg))
        if version in api.protoModules: module=api.protoModules[version]
        else:
            logger.error("SYSTEM\tERROR | Unsupported SNMP Version")
            return

        req,msg=decoder.decode(msg, asn1Spec=module.Message())
        logger.info("NOTIFICATION\t{} | {}".format(address, domain))

        pdu=module.apiMessage.getPDU(req)
        if not pdu.isSameTypeWith(module.TrapPDU()): continue

        if version==api.protoVersion1:
            varBinds=module.apiTrapPDU.getVarBindList(pdu)
        else: varBinds=module.apiPDU.getVarBindList(pdu)

        for v,b in varBinds:
            key='.'.join([str(i) for i in v._value])
            value=b.getComponent('simple')._value

            parsed=ObjectType(ObjectIdentity(key), value)
            try: parsed.resolveWithMib(viewController)
            except Exception as e: 
                logger.warning("TRAP\tERROR | Failed to resolve symbol ({}={})".format(key,value))
                continue
            key,value=parsed.prettyPrint().split(" = ")
            logger.info("TRAP\t{} | {}".format(key,value))

            if key=="PowerNet-MIB::mtrapargsString.0":
                message=value
                for contact in contacts['contacts']:
                    phoneNumber=contact['phoneNumber']
                    _redis.publish('sms', json.dumps(dict(phoneNumber=phoneNumber, message=message)))

    return msg
Пример #4
0
class SnmpResponse(object):
    def __init__(self, oid, value, snmp_engine, logger):
        self._raw_oid = oid
        self._snmp_mib_translator = CommandGeneratorVarBinds.getMibViewController(
            snmp_engine)
        self._logger = logger
        self._mib_id = None
        self._mib_name = None
        self._index = None
        self._raw_value = value
        self._object_id = ObjectIdentity(self._raw_oid)
        self._object_type = ObjectType(self._object_id, self._raw_value)

    @property
    def _object_identity(self):
        if not self._object_id.isFullyResolved():
            self._object_id.resolveWithMib(self._snmp_mib_translator)
        return self._object_id

    @property
    def object_type(self):
        if not self._object_type.isFullyResolved():
            self._object_type.resolveWithMib(self._snmp_mib_translator)
        return self._object_type

    @property
    def raw_value(self):
        return self._raw_value

    @property
    def oid(self):
        return self._object_identity.getOid()

    @property
    def mib_name(self):
        if not self._mib_name:
            self._get_oid()
        return self._mib_name

    @property
    def mib_id(self):
        if not self._mib_id:
            self._get_oid()
        return self._mib_id

    @property
    def index(self):
        if not self._index:
            self._get_oid()
        return self._index

    @property
    def safe_value(self):
        result = ""
        try:
            result = self.value or ""
        except TranslateSNMPException:
            pass

        return result

    @property
    def value(self):
        try:
            if self._raw_value is None or not self.object_type:
                return
            if hasattr(self.object_type[1], "prettyPrint"):
                value = self.object_type[1].prettyPrint()
            else:
                value = str(self.object_type[1])
            if value.lower().startswith("0x"):
                value = str(self._raw_value)
            return value
        except (PySnmpError, SmiError):
            raise TranslateSNMPException("Error parsing snmp response")

    def _get_oid(self):
        oid = self._object_identity.getMibSymbol()
        self._mib_name = oid[0]
        self._mib_id = oid[1]
        if isinstance(oid[-1], tuple):
            self._index = ".".join(map(lambda x: x.prettyPrint(), oid[-1]))

    def __str__(self):
        return self.safe_value

    def __repr__(self):
        return self.__str__()