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 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, 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 setTrapReceiver(self, host, community):
     config.addV1System(self._snmpEngine, 'nms-area', community)
     config.addVacmUser(self._snmpEngine, 2, 'nms-area', 'noAuthNoPriv',
                        notifySubTree=(1, 3, 6, 1, 4, 1))
     config.addTargetParams(self._snmpEngine,
                            'nms-creds', 'nms-area', 'noAuthNoPriv', 1)
     config.addTargetAddr(self._snmpEngine, 'my-nms', udp.domainName,
                          (host, 162), 'nms-creds',
                          tagList='all-my-managers')
     # set last parameter to 'notification' to have it send
     # informs rather than unacknowledged traps
     config.addNotificationTarget(
                                  self._snmpEngine,
                                  'test-notification', 'my-filter',
                                  'all-my-managers', 'trap')

    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 v3TargetName( 
		self, engine,
		ip, port=161, 
		authKey=None,
		privKey=None,
		authProtocol='MD5',
		privProtocol='DES',
	):
		"""Find/create target name for v1/v2 connection to given agent
		
		authProtocol -- one of None, 'MD5' or 'SHA' determining the hashing
			of the authorisation key (password)
		privProtocol -- one of None or 'DES', determining encryption of the
			messages sent to the agent 
		authKey -- authorisation key (password) for the agent 
		privKey -- key used to obscure requests from eavesdroppers
		"""
		if authKey is None:
			authProtocol = None 
		if privKey is None:
			privProtocol = None 
		authProtocol = self.AUTH_PROTOCOL_REGISTRY[ authProtocol ]
		privProtocol = self.PRIV_PROTOCOL_REGISTRY[ privProtocol ]
		key = ( authProtocol, authKey, privProtocol, privKey )
		paramName = self._v3paramCache.get( key )
		if paramName is None:
			nameID = self._newV3Name()
			name = 'v3user-%s'%(nameID)
			config.addV3User(
				engine, name, 
				authProtocol=authProtocol, authKey=authKey,
				privProtocol=privProtocol, privKey=privKey
			)
			if authProtocol is config.usmNoAuthProtocol:
				paramType = "noAuthNoPriv"
			elif privProtocol is config.usmNoPrivProtocol:
				paramType = "authNoPriv"
			else:
				paramType = "authPriv"
			paramName = 'v3param-%s'%(nameID)
			config.addTargetParams(
				engine, paramName, name, paramType,
				mpModel = 3
			)
			self._v3paramCache[ key ] = paramName
		return self._targetName( engine, ip, port, paramName )

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 main(argv):
    # Create SNMP engine instance
    snmpEngine = engine.SnmpEngine()
    dispatcher = TornadoDispatcher()
    snmpEngine.registerTransportDispatcher(dispatcher)

    # SecurityName <-> CommunityName mapping
    config.addV1System(snmpEngine, 'my-area', 'public')

    # Specify security settings per SecurityName (SNMPv1 - 0, SNMPv2c - 1)
    config.addTargetParams(snmpEngine, 'my-creds', 'my-area', 'noAuthNoPriv', 1)

    # UDP/IPv4
    config.addSocketTransport(
        snmpEngine,
        udp.domainName,
        udp.UdpSocketTransport().openClientMode()
    )
    config.addTargetAddr(
        snmpEngine,
        'my-router',
        udp.domainName,
        (argv[0], 161),
        'my-creds',
        timeout=3.0,
        retryCount=1
    )

    cbCtx = dict(dispatcher=dispatcher)

    cmdGen = cmdgen.GetCommandGenerator()
    cmdGen.sendReq(
        snmpEngine,
        'my-router',
        ( ('1.3.6.1.2.1.1.1.0', None), ),
        cbFun,
        cbCtx
    )

    IOLoop.instance().start()

    def __init__(self, host, port, username, password, snmp_context):
        self.snmp_context = snmp_context

        self.snmp_engine = engine.SnmpEngine()
        # HiT7300 uses the user password for encryption (privacy protocol) pass phrase (PSK?)
        config.addV3User(
            self.snmp_engine, username, config.usmHMACMD5AuthProtocol, password, config.usmAesCfb128Protocol, password
        )

        # pysnmp bug?
        # setting context doesn't affect the getCommandGenerator, so we don't set it
        # FIXME: report upstream and have cmdgen use context of snmpEngine!?
        # config.addContext(self.snmp_engine, 'tnms')
        # snmp_context = context.SnmpContext(self.snmp_engine)

        config.addTargetParams(self.snmp_engine, "myParams", username, "authPriv")
        # config.addTargetParams(self.snmp_engine, 'myParams', username, 'authPriv')

        config.addTargetAddr(self.snmp_engine, "myTarget", config.snmpUDPDomain, (host, int(port)), "myParams")

        config.addSocketTransport(self.snmp_engine, udp.domainName, udp.UdpSocketTransport().openClientMode())

        self.cbCtx = {}

	def v1TargetName( 
		self, engine,
		ip, port=161, 
		community='public', 
		snmpVersion='2',
	):
		"""Find/create target name for v1/v2 connection to given agent"""
		key = (community,snmpVersion=='1')
		paramName = self._v1ParamCache.get( key )
		if paramName is None:
			nameID = self._newV1Name()
			name = 'v1sys-%s'%(nameID)
			config.addV1System(engine, name, community)
			paramName = 'v1param-%s'%(nameID)
			if snmpVersion == '1':
				version = 0
			else:
				version = 1
			config.addTargetParams(
				engine, paramName, name, 'noAuthNoPriv', version
			)
			self._v1ParamCache[ key ] = paramName
		return self._targetName( engine, ip, port, paramName )

    def cfgCmdGen(self, authData, transportTarget, tagList=null):
        if authData not in self.__knownAuths:
            if isinstance(authData, CommunityData):
                config.addV1System(
                    self.snmpEngine,
                    authData.securityName,
                    authData.communityName,
                    authData.contextEngineId,
                    authData.contextName,
                    tagList
                    )
            elif isinstance(authData, UsmUserData):
                config.addV3User(
                    self.snmpEngine,
                    authData.securityName,
                    authData.authProtocol, authData.authKey,
                    authData.privProtocol, authData.privKey,
                    authData.contextEngineId
                    )
            else:
                raise error.PySnmpError('Unsupported authentication object')

            self.__knownAuths[authData] = 1

        k = authData.securityName, authData.securityLevel, authData.mpModel
        if k in self.__knownParams:
            paramsName = self.__knownParams[k]
        else:
            paramsName = 'p%s' % nextID()
            config.addTargetParams(
                self.snmpEngine, paramsName,
                authData.securityName, authData.securityLevel, authData.mpModel
                )
            self.__knownParams[k] = paramsName

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

        k = paramsName, transportTarget, tagList
        if k in self.__knownTransportAddrs:
            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 snmpv3_getbulk(ip='',user='',hash_meth=None,hash_key=None,cry_meth=None,cry_key=None,oid='',num=10):
    #usmHMACMD5AuthProtocol - MD5 hashing
    #usmHMACSHAAuthProtocol - SHA hashing
    #usmNoAuthProtocol - no authentication
    #usmDESPrivProtocol - DES encryption
    #usm3DESEDEPrivProtocol - triple-DES encryption
    #usmAesCfb128Protocol - AES encryption, 128-bit
    #usmAesCfb192Protocol - AES encryption, 192-bit
    #usmAesCfb256Protocol - AES encryption, 256-bit
    #usmNoPrivProtocol - no encryption
    global maxRepetitions
    maxRepetitions = num
    hashval = None
    cryval = None
    model = None

    config.addTargetAddr(#添加目标，'yourDevice'(OID与处理方法），'my-creds'（用户，密码，安全模型），目的IP与端口号
        snmpEngine, 'yourDevice', 
        udp.domainName, (ip, 161),
        'my-creds'
    )
    #========================下面的操作在判断安全模型==========================
    #NoAuthNoPriv
    if hash_meth == None and cry_meth == None:
        hashval = config.usmNoAuthProtocol
        cryval = config.usmNoPrivProtocol
        model = 'noAuthNoPriv'
    #AuthNoPriv
    elif hash_meth != None and cry_meth == None:
        if hash_meth == 'md5':
            hashval = config.usmHMACMD5AuthProtocol
        elif hash_meth == 'sha':
            hashval = config.usmHMACSHAAuthProtocol
        else:
            print('哈希算法必须是md5 or sha!')
            return
        cryval = config.usmNoPrivProtocol
        model = 'authNoPriv'
    #AuthPriv
    elif hash_meth != None and cry_meth != None:
        if hash_meth == 'md5':
            hashval = config.usmHMACMD5AuthProtocol
        elif hash_meth == 'sha':
            hashval = config.usmHMACSHAAuthProtocol
        else:
            print('哈希算法必须是md5 or sha!')
            return
        if cry_meth == '3des':
            cryval = config.usm3DESEDEPrivProtocol
        elif cry_meth == 'des':
            cryval = config.usmDESPrivProtocol
        elif cry_meth == 'aes128':
            cryval = config.usmAesCfb128Protocol
        elif cry_meth == 'aes192':
            cryval = config.usmAesCfb192Protocol
        elif cry_meth == 'aes256':
            cryval = config.usmAesCfb256Protocol
        else:
            print('加密算法必须是3des, des, aes128, aes192 or aes256 !')
            return
        model = 'authPriv'
    #提供的参数不符合标准时给出提示
    else:
        print('三种USM: NoAuthNoPriv, AuthNoPriv, AuthPriv.。请选择其中一种。')
        return
    #========================判断安全模型结束==========================

    config.addV3User(#添加用户与他的密钥
        snmpEngine, user,
        hashval, hash_key,
        cryval, cry_key
    )
    config.addTargetParams(snmpEngine, 'my-creds', user, model)#创建'my-creds',里边有用户和安全模型

    # Prepare initial request to be sent

    cmdgen.BulkCommandGenerator().sendReq(snmpEngine,'yourDevice', 0, 1,((oid, None),),cbFun)#创建'yourDevice'，有OID和处理方法cbFun

    # Run I/O dispatcher which would send pending queries and process responses
    snmpEngine.transportDispatcher.runDispatcher()#运行实例
    
    return oid_list#返回oid_list

"""#
from pysnmp.entity import engine, config
from pysnmp.carrier.asyncore.dgram import udp
from pysnmp.entity.rfc3413 import ntforg
from pysnmp.proto.api import v2c

# Create SNMP engine instance
snmpEngine = engine.SnmpEngine()

# SNMPv2c:

# SecurityName <-> CommunityName mapping
config.addV1System(snmpEngine, 'my-area', 'public', transportTag='all-my-managers')

# Specify security settings per SecurityName (SNMPv2c -> 1)
config.addTargetParams(snmpEngine, 'my-creds-1', 'my-area', 'noAuthNoPriv', 1)

# SNMPv3:

config.addV3User(
    snmpEngine, 'usr-md5-none',
    config.usmHMACMD5AuthProtocol, 'authkey1'
)
config.addTargetParams(snmpEngine, 'my-creds-2', 'usr-md5-none', 'authNoPriv')

# Setup transport endpoint and bind it with security settings yielding
# a target name
config.addTransport(
    snmpEngine,
    udp.domainName,
    udp.UdpSocketTransport().openClientMode()

            secLevel, v3AuthKey is None and '<NONE>' or v3AuthKey,
            v3AuthProto,
            v3PrivKey is None and '<NONE>' or v3PrivKey, v3PrivProto))

else:

    v3User = 'agt'
    secLevel = 'noAuthNoPriv'

    config.addV1System(snmpEngine, v3User, snmpCommunity)

    log.info(
        'SNMP version %s, Community name: '
        '%s' % (snmpVersion == 0 and '1' or '2c', snmpCommunity))

config.addTargetParams(snmpEngine, 'pms', v3User, secLevel, snmpVersion)

if agentUDPv6Endpoint:
    config.addSocketTransport(
        snmpEngine, udp6.domainName,
        udp6.Udp6SocketTransport().openClientMode())

    config.addTargetAddr(
        snmpEngine, 'tgt', udp6.domainName, agentUDPv6Endpoint, 'pms',
        timeout, retryCount)

    log.info('Querying UDP/IPv6 agent at [%s]:%s' % agentUDPv6Endpoint)

elif agentUNIXEndpoint:
    config.addSocketTransport(
        snmpEngine, unix.domainName,

#
# SNMPv3/USM setup (Manager role)
#

# user: usr-md5-none, auth: MD5, priv NONE
config.addV3User(
    snmpEngine, remoteV3User,
    config.usmHMACMD5AuthProtocol, remoteV3AuthKey
)

#
# Transport target used by Manager
#

config.addTargetParams(
    snmpEngine, 'distant-agent', 'MD5User', 'authNoPriv'
)
config.addTargetAddr(
        snmpEngine, 'net-snmp-agent', 
        remoteTransportDomain, remoteTransportAddress,
        'distant-agent', retryCount=0
)

# Default SNMP context
config.addContext(snmpEngine, '')

class CommandResponder(cmdrsp.CommandResponderBase):
    cmdGenMap = { v2c.GetRequestPDU.tagSet: cmdgen.GetCommandGenerator(),
                  v2c.SetRequestPDU.tagSet: cmdgen.SetCommandGenerator(),
                  v2c.GetNextRequestPDU.tagSet: cmdgen.NextCommandGeneratorSingleRun(),
                  v2c.GetBulkRequestPDU.tagSet: cmdgen.BulkCommandGeneratorSingleRun() }

# Initial OID prefix
initialOID = rfc1902.ObjectName('1.3.6.1.2.1.1')

# Create SNMP engine instance
snmpEngine = engine.SnmpEngine()

#
# SNMPv3/USM setup
#

# user: usr-none-none, auth: none, priv: none
config.addV3User(
    snmpEngine, 'usr-none-none',
)
config.addTargetParams(snmpEngine, 'my-creds', 'usr-none-none', 'noAuthNoPriv')

#
# Setup transport endpoint and bind it with security settings yielding
# a target name
#

# UDP/IPv4
config.addTransport(
    snmpEngine,
    udp.domainName,
    udp.UdpSocketTransport().openClientMode()
)
config.addTargetAddr(
    snmpEngine, 'my-router',
    udp.domainName, ('195.218.195.228', 161),

from pysnmp.carrier.asynsock.dgram import udp
from pysnmp.entity.rfc3413 import cmdgen
from pysnmp.proto import rfc1902

# Create SNMP engine instance
snmpEngine = engine.SnmpEngine()

#
# SNMPv1 setup
#

# SecurityName <-> CommunityName mapping
config.addV1System(snmpEngine, 'my-area', 'private')

# Specify security settings per SecurityName (SNMPv1 - 0, SNMPv2c - 1)
config.addTargetParams(snmpEngine, 'my-creds', 'my-area', 'noAuthNoPriv', 0)

#
# Setup transport endpoint and bind it with security settings yielding
# a target name
#

# UDP/IPv4
config.addTransport(
    snmpEngine,
    udp.domainName,
    udp.UdpSocketTransport().openClientMode()
)
config.addTargetAddr(
    snmpEngine, 'my-router',
    udp.domainName, ('195.218.195.228', 161),

#
# SNMPv3/USM setup (Manager role)
#

# user: usr-md5-none, auth: MD5, priv NONE
config.addV3User(
    snmpEngine, 'usr-md5-none', config.usmHMACMD5AuthProtocol, 'authkey1'
)

#
# Transport target used by Manager
#

config.addTargetParams(
    snmpEngine, 'distant-agent-auth', 'usr-md5-none', 'authNoPriv'
)
config.addTargetAddr(
        snmpEngine, 'distant-agent', 
        udp.domainName + (2,), ('195.218.195.228', 161),
        'distant-agent-auth', retryCount=0
)

# Default SNMP context
config.addContext(snmpEngine, '')

class CommandResponder(cmdrsp.CommandResponderBase):
    cmdGenMap = { 
        v2c.GetRequestPDU.tagSet: cmdgen.GetCommandGenerator(),
        v2c.SetRequestPDU.tagSet: cmdgen.SetCommandGenerator(),
        v2c.GetNextRequestPDU.tagSet: cmdgen.NextCommandGeneratorSingleRun(),