Python config.addSocketTransport函数代码示例

    def __init__(self, udpIp, udpPort):
        # Create SNMP engine with autogenernated engineID and pre-bound
        # to socket transport dispatcher
        self.snmpEngine = engine.SnmpEngine()
        self.mibBuilder = self.snmpEngine.msgAndPduDsp.mibInstrumController.mibBuilder

        mibPath = self.mibBuilder.getMibPath() + ('.',)
        self.mibBuilder.setMibPath(*mibPath)

        # Setup UDP over IPv4 transport endpoint
        config.addSocketTransport(
            self.snmpEngine,
            udp.domainName,
            udp.UdpSocketTransport().openServerMode((udpIp, udpPort))
        )

        print 'Publishing readings via SNMP'
        print 'Agent address {}:{}'.format(udpIp, udpPort)
        print 'Community name public'

        # v1/2 setup
        config.addV1System(self.snmpEngine, 'test-agent', 'public')

        # v3 setup
        config.addV3User(
            self.snmpEngine, 'test-user'
        )

        # VACM setup
        config.addContext(self.snmpEngine, '')
        config.addRwUser(self.snmpEngine, 1, 'test-agent', 'noAuthNoPriv', (1,3,6)) # v1
        config.addRwUser(self.snmpEngine, 2, 'test-agent', 'noAuthNoPriv', (1,3,6)) # v2c
        config.addRwUser(self.snmpEngine, 3, 'test-user', 'noAuthNoPriv', (1,3,6)) # v3

        # SNMP context
        snmpContext = context.SnmpContext(self.snmpEngine)

        # Apps registration
        cmdrsp.GetCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.SetCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.NextCommandResponder(self.snmpEngine, snmpContext)
        cmdrsp.BulkCommandResponder(self.snmpEngine, snmpContext)

        MibScalarInstance, = self.mibBuilder.importSymbols('SNMPv2-SMI', 'MibScalarInstance')

        class ScalarFromCallback(MibScalarInstance):
            def __init__(self, sensorId, valueGetter, typeName, instId, syntax):
                MibScalarInstance.__init__(self, typeName, instId, syntax)
                self.valueGetter = valueGetter

            def readTest(self, name, val, idx, (acFun, acCtx)):
                if not self.valueGetter():
                    raise error.NoAccessError(idx=idx, name=name)

            def readGet(self, name, val, idx, (acFun, acCtx)):
                value = self.valueGetter()
                if not value:
                    raise error.NoAccessError(idx=idx, name=name)
                else:
                    return name, self.syntax.clone(value)

     def run(self):
         
        snmpEngine = engine.SnmpEngine()
        
        if self.ipv6:
            domainName = udp6.domainName
            config.addSocketTransport(snmpEngine,domainName,udp6.Udp6Transport().openServerMode((self.host, self.port)))
        else:
            domainName = udp.domainName
            config.addSocketTransport(snmpEngine,domainName,udp.UdpTransport().openServerMode((self.host, self.port))) 
            
        config.addV3User(snmpEngine, self.user,self.auth_proto, self.auth_key,self.priv_proto,self.priv_key)
  
        # Register SNMP Application at the SNMP engine
        ntfrcv.NotificationReceiver(snmpEngine, v3trapCallback)

        snmpEngine.transportDispatcher.jobStarted(1) # this job would never finish

        # Run I/O dispatcher which would receive queries and send confirmations
        try:
            snmpEngine.transportDispatcher.runDispatcher()
        except: # catch *all* exceptions
            e = sys.exc_info()[1]
            snmpEngine.transportDispatcher.closeDispatcher()
            logging.error("Looks like an error: %s" % str(e))
            sys.exit(1)

 def __one_time_init(self):
     self.listen_address = '0.0.0.0' # Set by TrapEngine
     self.listen_port = 162          # Set by TrapEngine
     self.owner = None               # Set by TrapEngine
     self.trap_view = None           # Set by TrapEngine
     self.trap_log = None            # Set by TrapEngine
     self.socket_map = socketmap.SocketMap()
     self.snmpEngine = engine.SnmpEngine()
     transportDispatcher = dispatch.AsynsockDispatcher()
     transportDispatcher.setSocketMap(self.socket_map)
     self.snmpEngine.registerTransportDispatcher(transportDispatcher)
     # @note As of PySNMP 4.1.9a, receipt of a V3 notification with out
     #       any registerred V3 users results in a traceback.
     self.addV3User('\0',
                    config.usmNoAuthProtocol, '\0'*8,
                    config.usmNoPrivProtocol, '\0'*8)
     def cbFun(snmpEngine,
               contextEngineId,
               contextName,
               varBinds,
               trap_thread):
         trap_thread._TrapThread__callback(contextEngineId, contextName,
                                           varBinds)
         return
     self.receiver = ntfrcv.NotificationReceiver(self.snmpEngine,
                                                 cbFun, self)
     # Setup transport endpoint
     config.addSocketTransport(
         self.snmpEngine,
         udp.domainName,
         udp.UdpSocketTransport().openServerMode((self.listen_address,
                                                  self.listen_port))
         )
     return

    def __init__(self, client_config=None):
        if not client_config:
            client_config = conpot_config
        # Create SNMP engine instance
        self.snmpEngine = engine.SnmpEngine()

        # user: usr-sha-aes, auth: SHA, priv AES
        config.addV3User(
            self.snmpEngine, 'usr-sha-aes128',
            config.usmHMACSHAAuthProtocol, 'authkey1',
            config.usmAesCfb128Protocol, 'privkey1'
        )
        config.addTargetParams(self.snmpEngine, 'my-creds', 'usr-sha-aes128', 'authPriv')

        # Setup transport endpoint and bind it with security settings yielding
        # a target name (choose one entry depending of the transport needed).

        # UDP/IPv4
        config.addSocketTransport(
            self.snmpEngine,
            udp.domainName,
            udp.UdpSocketTransport().openClientMode()
        )
        config.addTargetAddr(
            self.snmpEngine, 'my-router',
            udp.domainName, (client_config.snmp_host, client_config.snmp_port),
            'my-creds'
        )

    def __init__(self, objects):

        self._snmpEngine = engine.SnmpEngine()

        config.addSocketTransport( self._snmpEngine, udp.domainName, udp.UdpTransport().openServerMode((_addr, _port)))
        config.addV3User(self._snmpEngine,_account,config.usmHMACMD5AuthProtocol,_auth_key,config.usmDESPrivProtocol,_priv_key)
        config.addVacmUser(self._snmpEngine, 3, _account, "authPriv",(1,3,6,1,4,1), (1,3,6,1,4,1))

        self._snmpContext = context.SnmpContext(self._snmpEngine)


        #builder create
        mibBuilder = self._snmpContext.getMibInstrum().getMibBuilder()
        mibSources = mibBuilder.getMibSources() + (builder.DirMibSource('.'),)+(builder.DirMibSource(filepath),)
        mibBuilder.setMibSources(*mibSources)


        MibScalarInstance, = mibBuilder.importSymbols('SNMPv2-SMI','MibScalarInstance')

        for mibObject in objects:
            nextVar, = mibBuilder.importSymbols(mibObject.mibName,
                                                mibObject.objectType)
            instance = createVariable(MibScalarInstance, mibObject.valueGetFunc, nextVar.name, (0,),  nextVar.syntax)
            #need to export as <var name>Instance
            instanceDict = {str(nextVar.name)+"Instance":instance}
            mibBuilder.exportSymbols(mibObject.mibName, **instanceDict)

        cmdrsp.GetCommandResponder(self._snmpEngine, self._snmpContext)
        cmdrsp.SetCommandResponder(self._snmpEngine, self._snmpContext)
        cmdrsp.NextCommandResponder(self._snmpEngine, self._snmpContext)
        cmdrsp.BulkCommandResponder(self._snmpEngine, self._snmpContext)

    def __init__(self, mibObjects, sqlObject, _rootDir, server_options):
        """
        mibObjects - a list of MibObject tuples that this agent
        will serve
        """
        #each SNMP-based application has an engine
        self._snmpEngine = engine.SnmpEngine()

        #open a UDP socket to listen for snmp requests
        config.addSocketTransport(self._snmpEngine, udp.domainName,
                                  udp.UdpTransport().openServerMode(('', int(server_options['port']))))

        #add a v2 user with the community string public
        config.addV1System(self._snmpEngine, "agent", server_options['community'])
        #let anyone accessing 'public' read anything in the subtree below,
        #which is the enterprises subtree that we defined our MIB to be in
        config.addVacmUser(self._snmpEngine, int(server_options['version']), "agent", "noAuthNoPriv", readSubTree=(1,3,6,1,4,1))

        #each app has one or more contexts
        self._snmpContext = context.SnmpContext(self._snmpEngine)

        #the builder is used to load mibs. tell it to look in the
        #current directory for our new MIB. We'll also use it to
        #export our symbols later
        mibBuilder = self._snmpContext.getMibInstrum().getMibBuilder()
        mibSources = mibBuilder.getMibSources() + (builder.DirMibSource(os.path.join(_rootDir, 'lib_mib_py')),)
        mibBuilder.setMibSources(*mibSources)

        #our variables will subclass this since we only have scalar types
        #can't load this type directly, need to import it
        MibScalarInstance, = mibBuilder.importSymbols('SNMPv2-SMI', 'MibScalarInstance')

        #export our custom mib
        for mibObject in mibObjects:
            nextVar, = mibBuilder.importSymbols(mibObject.mibName, mibObject.objectType)
            if mibObject.objMib.flag:
		#je suis une table

		for client in sqlObject.getClientsId():
		    instance = createVariable(MibScalarInstance, mibObject.objMib, mibObject.valueFunc, nextVar.name,(client['ClientId'],), nextVar.syntax)
		    listName = list(nextVar.name)
		    listName.append(client['ClientId'] )
		    newName = tuple(listName)
	    	    instanceDict = {str(newName)+"Instance":instance}
           	    mibBuilder.exportSymbols(mibObject.mibName, **instanceDict)

	    else :
		instance = createVariable(MibScalarInstance, mibObject.objMib, mibObject.valueFunc, nextVar.name,(0,), nextVar.syntax)
                                             #class         ,class with fonc , nom de la fonction , oid               , type d'oid

            	#need to export as <var name>Instance
	        instanceDict = {str(nextVar.name)+"Instance":instance}
	   	mibBuilder.exportSymbols(mibObject.mibName, **instanceDict)


        # tell pysnmp to respotd to get, getnext, and getbulk
        cmdrsp.GetCommandResponder(self._snmpEngine, self._snmpContext)
        cmdrsp.NextCommandResponder(self._snmpEngine, self._snmpContext)
        cmdrsp.BulkCommandResponder(self._snmpEngine, self._snmpContext)

def test2():
    from pysnmp.v4.proto.rfc1902 import ObjectName
    from pysnmp.entity import engine, config
    from pysnmp.carrier.asynsock.dgram import udp
    from pysnmp.entity.rfc3413 import cmdgen
    
    sysName = ObjectName("1.3.6.1.2.1.1.5.0")
    ip = "192.168.1.9"
    snmp_engine = engine.SnmpEngine()
    config.addV1System(snmp_engine, 'test-agent', "public")
    config.addTargetParams(snmp_engine, 'myParams', 'test-agent', 'noAuthNoPriv', 0)
    config.addTargetAddr(
        snmp_engine, 'myRouter', config.snmpUDPDomain,
        (ip, 161), 'myParams'
        )
    config.addSocketTransport(
        snmp_engine,
        udp.domainName,
        udp.UdpSocketTransport().openClientMode()
        )

    cb = {}
    
    def cbFun(sendRequestHandle, errorIndication, errorStatus, errorIndex,
              varBinds, cbCtx):
        cbCtx['errorIndication'] = errorIndication
        cbCtx['errorStatus'] = errorStatus
        cbCtx['errorIndex'] = errorIndex
        cbCtx['varBinds'] = varBinds
        

    cmdgen.GetCommandGenerator().sendReq(snmp_engine, 'myRouter', ((sysName, None),), cbFun, cb)
        
        
    lastmemusage = 0
    lastrefs = None
    errors = 0
    while (errors < 2):
        snmp_engine.transportDispatcher.runDispatcher()
        print cb['varBinds'][0][1]
        snmp_engine.transportDispatcher.closeDispatcher()
        #asynCommandGenerator.flushConfig()
        newmemusage = resource.getrusage(resource.RUSAGE_SELF)[2]
        memdiff = (newmemusage - lastmemusage)
        newrefs = get_refcounts()
        if memdiff > 0:
            print "Leaked %d Kb... printing refcount diff" % memdiff
            if lastrefs == None:
                print "No previous refcount, skipping"
            else:
                print_ref_diffs(lastrefs, newrefs)
                errors = errors + 1
        gc.collect()
        lastrefs = newrefs
        lastmemusage = newmemusage
        #print resource.getrusage(resource.RUSAGE_SELF)[3]
        time.sleep(1)

    def cfgCmdGen(self, authData, transportTarget, tagList=''):
        if self.__knownAuths.has_key(authData):
            paramsName = self.__knownAuths[authData]
        else:
            paramsName = 'p%s' % nextID()
            if isinstance(authData, CommunityData):
                config.addV1System(
                    self.snmpEngine,
                    authData.securityName,
                    authData.communityName
                    )
                config.addTargetParams(
                    self.snmpEngine, paramsName,
                    authData.securityName, authData.securityLevel,
                    authData.mpModel
                    )
            elif isinstance(authData, UsmUserData):
                config.addV3User(
                    self.snmpEngine,
                    authData.securityName,
                    authData.authProtocol, authData.authKey,
                    authData.privProtocol, authData.privKey
                    )
                config.addTargetParams(
                    self.snmpEngine, paramsName,
                    authData.securityName, authData.securityLevel
                    )
            else:
                raise error.PySnmpError('Unsupported SNMP version')
            self.__knownAuths[authData] = paramsName

        if not self.__knownTransports.has_key(transportTarget.transportDomain):
            transport = transportTarget.openClientMode()
            config.addSocketTransport(
                self.snmpEngine,
                transportTarget.transportDomain,
                transport
                )
            self.__knownTransports[transportTarget.transportDomain] = transport

        k = transportTarget, tagList
        if self.__knownTransportAddrs.has_key(k):
            addrName = self.__knownTransportAddrs[k]
        else:
            addrName = 'a%s' % nextID()
            config.addTargetAddr(
                self.snmpEngine, addrName,
                transportTarget.transportDomain,
                transportTarget.transportAddr,
                paramsName,
                transportTarget.timeout * 100,
                transportTarget.retries,
                tagList                
                )
            self.__knownTransportAddrs[k] = addrName

        return addrName, paramsName

 def __init__(self, host, port, rcommunity):
     self.snmpEngine = engine.SnmpEngine()
     config.addSocketTransport(self.snmpEngine, udp.domainName, udp.UdpTransport().openServerMode((host, port)))
     config.addV1System(self.snmpEngine, 'my-area', rcommunity)
     config.addVacmUser(self.snmpEngine, 2, 'my-area', 'noAuthNoPriv', (1, 3, 6))
     self.snmpContext = context.SnmpContext(self.snmpEngine)
     self.mibBuilder = self.snmpContext.getMibInstrum().getMibBuilder()
     self.MibScalar, self.MibScalarInstance = self.mibBuilder.importSymbols('SNMPv2-SMI', 'MibScalar', 'MibScalarInstance')
     cmdrsp.GetCommandResponder(self.snmpEngine, self.snmpContext)
     cmdrsp.NextCommandResponder(self.snmpEngine, self.snmpContext)
     cmdrsp.BulkCommandResponder(self.snmpEngine, self.snmpContext)

    def __init__(self, host, port, community):
        self.snmp = engine.SnmpEngine()
        self.snmp.registerTransportDispatcher(dispatch.TwistedDispatcher())

        config.addV1System(self.snmp, 'my-area', community)
        config.addTargetParams(self.snmp,
            'my-creds', 'my-area', 'noAuthNoPriv', 0)
        config.addSocketTransport(self.snmp,
            udp.domainName, udp.UdpTwistedTransport().openClientMode()
        )
        config.addTargetAddr(self.snmp, 'my-router', udp.domainName,
            (host, port), 'my-creds')

    def __init__(self, host, port, users, naming_scheme):
        """
        host = public ip to listen on
        port = port to listen on (usually 161)
        users = list of ('username', 'password', 'privatekey', 'authPriv') #authentication method for snmp v3
        if users is None, authentication will be snmp v1 public community string, read only
        """
        self.naming_scheme = naming_scheme

        self.run = True
        self.users = users
        # Create SNMP engine
        self.snmpEngine = engine.SnmpEngine()
        # Get default SNMP context this SNMP engine serves
        self.snmpContext = context.SnmpContext(self.snmpEngine)
        # MIB builder
        self.mibBuilder = self.snmpContext.getMibInstrum().getMibBuilder()
        self.MibScalar, self.MibScalarInstance = self.mibBuilder.importSymbols('SNMPv2-SMI', 'MibScalar', 'MibScalarInstance')

        # Transport setup
        # UDP over IPv4
        try:
            config.addSocketTransport(self.snmpEngine,
                                      udp.domainName,
                                      udp.UdpTransport().openServerMode((host, port)))
            print('Serving on port %s' % port)
        except error.CarrierError as carrier_error :
            if "[Errno 98]" in carrier_error.message:
                raise RuntimeError('Port %s is in use' % port)

        # SNMPv3/USM setup
        # user: usr-md5-des, auth: MD5, priv DES
        if users:
            for user in users:
                self._add_v3_md5_des_user(user)
                # Allow full MIB access for each user at VACM
        else:
            # SNMPv1 public community string setup
            config.addV1System(self.snmpEngine, 'my-read-area', 'public')

        self._add_user_permission("1.3.6.1.2.1") #full walk permission, without this snmpwalk returns None

        # Overwrite default strings with custom name
        sysDescr, = self.snmpEngine.msgAndPduDsp.mibInstrumController.mibBuilder.importSymbols('SNMPv2-MIB', 'sysDescr')
        sysDescr = self.MibScalarInstance(sysDescr.name,
                                          (0,),
                                          sysDescr.syntax.clone("PySNMP engine - OVS 1.2.0 SNMP Agent")) # Get from config?
        self.snmpEngine.msgAndPduDsp.mibInstrumController.mibBuilder.exportSymbols('SNMPv2-MIB', sysDescr)
        self._add_user_permission(self.naming_scheme.replace('.%s', ''))

    def __init__(self, community, ip, version=1):
        self.__community = community
        self.__ip = ip
        self.__version = version
        self.__errorIndication = None
        self.__errorStatus = None
        self.__errorIndex = None
        self.__varBinds = None
        # self.__lock = threading.Lock()

        self.__snmp_engine = engine.SnmpEngine()
        config.addV1System(self.__snmp_engine, "test-agent", self.__community)
        config.addTargetParams(self.__snmp_engine, "myParams", "test-agent", "noAuthNoPriv", self.__version)
        config.addTargetAddr(self.__snmp_engine, "myRouter", config.snmpUDPDomain, (self.__ip, 161), "myParams")
        config.addSocketTransport(self.__snmp_engine, udp.domainName, udp.UdpSocketTransport().openClientMode())

def initTarget(host='127.0.0.1', port=162, community='LIC_OSS'):
    #global snmpEngine, snmpContext, ntfOrg
    # Create SNMP engine instance
    snmpEngine = engine.SnmpEngine()
    
    # SecurityName <-> CommunityName mapping
    config.addV1System(snmpEngine, 'my-area', community)
    
    # Specify security settings per SecurityName (SNMPv2c -> 1)
    config.addTargetParams(snmpEngine, 'my-creds', 'my-area', 'noAuthNoPriv', 1)
    
    # Setup transport endpoint and bind it with security settings yielding
    # a target name
    config.addSocketTransport(
        snmpEngine,
        udp.domainName,
        udp.UdpSocketTransport().openClientMode()
    )
    config.addTargetAddr(
        snmpEngine, 'my-nms',
        udp.domainName, (host, port),
        'my-creds',
        tagList='all-my-managers'
    )
    
    # Specify what kind of notification should be sent (TRAP or INFORM),
    # to what targets (chosen by tag) and what filter should apply to
    # the set of targets (selected by tag)
    config.addNotificationTarget(
        snmpEngine, 'my-notification', 'my-filter', 'all-my-managers', 'trap'
    )
    
    # Allow NOTIFY access to Agent's MIB by this SNMP model (2), securityLevel
    # and SecurityName
    config.addContext(snmpEngine, '')
    config.addVacmUser(snmpEngine, 2, 'my-area', 'noAuthNoPriv', (), (), (1,3,6))
    
    # *** SNMP engine configuration is complete by this line ***
    
    # Create default SNMP context where contextEngineId == SnmpEngineId
    snmpContext = context.SnmpContext(snmpEngine)
    
    # Create Notification Originator App instance. 
    ntfOrg = ntforg.NotificationOriginator(snmpContext)
    return snmpEngine, ntfOrg

	def __init__(self):
		self.unReadyNodes = list()
		self.identifiers  = dict()
		self.snmpEngine   = engine.SnmpEngine()
		self.bcmdgen      = cmdgen.BulkCommandGenerator()

		self.snmpEngine.registerTransportDispatcher(dispatch.TwistedDispatcher())
		config.addV1System(self.snmpEngine, 'test-agent', SNMP_COMMUNITY)
		config.addTargetParams(self.snmpEngine, 'myParams', 'test-agent', 'noAuthNoPriv', 1)

		config.addSocketTransport(
	        self.snmpEngine,
	        udp.domainName,
	        udp.UdpTwistedTransport().openClientMode()
	        )

		self.carbonFact = CarbonFactory(self)
		reactor.connectTCP(GRAPHITE_HOST, 2003, self.carbonFact)

 def __init__(self):
     self.snmpEngine = engine.SnmpEngine()
     
     config.addSocketTransport(
         self.snmpEngine,
         udp.domainName,
         udp.UdpSocketTransport().openServerMode(('0.0.0.0', 162))
         )
         
     config.addV1System(self.snmpEngine, 'test-agent', 'public')
     
     config.addV3User(
         self.snmpEngine, 'test-user',
         config.usmHMACMD5AuthProtocol, 'authkey1',
         config.usmDESPrivProtocol, 'privkey1'
         #    '80004fb81c3dafe69'   # ContextEngineID of Notification Originator
         )
     # Apps registration
     ntfrcv.NotificationReceiver(self.snmpEngine, self.recvcallback)
     self.snmpEngine.transportDispatcher.jobStarted(1) # this job would never finish
     self.snmpEngine.transportDispatcher.runDispatcher()