def init(**context):
if context['options']:
for k, v in [split(x, ':') for x in split(context['options'], ',')]:
if k == 'addon':
if k in moduleContext:
moduleContext[k].append(v)
else:
moduleContext[k] = [v]
else:
moduleContext[k] = v
if context['mode'] == 'variating':
moduleContext['booted'] = time.time()
elif context['mode'] == 'recording':
if 'dir' not in moduleContext:
raise error.SnmpsimError('SNMP snapshots directory not specified')
if not os.path.exists(moduleContext['dir']):
log.msg('multiplex: creating %s...' % moduleContext['dir'])
os.makedirs(moduleContext['dir'])
if 'iterations' in moduleContext:
moduleContext['iterations'] = max(
0,
int(moduleContext['iterations']) - 1)
if 'period' in moduleContext:
moduleContext['period'] = float(moduleContext['period'])
else:
moduleContext['period'] = 10.0
moduleContext['ready'] = True
def init(**context):
if context['mode'] == 'variating':
random.seed()
if context['mode'] == 'recording':
moduleContext['settings'] = {}
if context['options']:
for k, v in [
split(x, ':') for x in split(context['options'], ',')
]:
if k == 'addon':
if k in moduleContext['settings']:
moduleContext['settings'][k].append(v)
else:
moduleContext['settings'][k] = [v]
else:
moduleContext['settings'][k] = v
if 'iterations' in moduleContext['settings']:
moduleContext['settings']['iterations'] = int(
moduleContext['settings']['iterations'])
if moduleContext['settings']['iterations']:
moduleContext['settings'][
'iterations'] = 1 # no reason for more
if 'period' in moduleContext['settings']:
moduleContext['settings']['period'] = float(
moduleContext['settings']['period'])
else:
moduleContext['settings']['period'] = 10.0
if 'taglist' not in moduleContext['settings']:
moduleContext['settings']['taglist'] = '2-65-66-67-70'
def init(**context):
if context['options']:
for k,v in [split(x, ':') for x in split(context['options'], ',')]:
if k == 'addon':
if k in moduleContext:
moduleContext[k].append(v)
else:
moduleContext[k] = [v]
else:
moduleContext[k] = v
if context['mode'] == 'variating':
moduleContext['booted'] = time.time()
elif context['mode'] == 'recording':
if 'dir' not in moduleContext:
raise error.SnmpsimError('SNMP snapshots directory not specified')
if not os.path.exists(moduleContext['dir']):
log.msg('multiplex: creating %s...' % moduleContext['dir'])
os.makedirs(moduleContext['dir'])
if 'iterations' in moduleContext:
moduleContext['iterations'] = max(0, int(moduleContext['iterations'])-1)
if 'period' in moduleContext:
moduleContext['period'] = float(moduleContext['period'])
else:
moduleContext['period'] = 10.0
moduleContext['ready'] = True
def init(**context):
moduleContext['settings'] = {}
if context['options']:
moduleContext['settings'].update(
dict([split(x, ':') for x in split(context['options'], ',')]))
if 'file' in moduleContext['settings']:
moduleContext['cache'] = shelve.open(moduleContext['settings']['file'])
else:
moduleContext['cache'] = {}
def init(**context):
moduleContext['settings'] = {}
if context['options']:
moduleContext['settings'].update(
dict([split(x, ':') for x in split(context['options'], ',')]))
if 'shell' not in moduleContext['settings']:
moduleContext['settings']['shell'] = sys.platform[:3] == 'win'
else:
moduleContext['settings']['shell'] = int(
moduleContext['settings']['shell'])
def init(**context):
moduleContext['settings'] = {}
if context['options']:
moduleContext['settings'].update(
dict([split(x, ':') for x in split(context['options'], ',')])
)
if 'shell' not in moduleContext['settings']:
moduleContext['settings']['shell'] = sys.platform[:3] == 'win'
else:
moduleContext['settings']['shell'] = int(moduleContext['settings']['shell'])
def init(**context):
moduleContext['settings'] = {}
if context['options']:
moduleContext['settings'].update(
dict([split(x, ':') for x in split(context['options'], ',')])
)
if 'file' in moduleContext['settings']:
moduleContext['cache'] = shelve.open(moduleContext['settings']['file'])
else:
moduleContext['cache'] = {}
def init(**context):
options = {}
if context['options']:
options.update(
dict([split(x, ':') for x in split(context['options'], ',')])
)
if 'dbtype' not in options:
raise error.SnmpsimError('database type not specified')
db = __import__(
options['dbtype'],
globals(), locals(),
options['dbtype'].split('.')[:-1]
)
if 'dboptions' in options: # legacy
connectParams = {'database': options['dboptions']}
else:
connectParams = dict(
[(k, options[k]) for k in options if
k in ('host', 'port', 'user', 'passwd', 'password', 'db', 'database', 'unix_socket', 'named_pipe')]
)
for k in 'port', 'connect_timeout':
if k in connectParams:
connectParams[k] = int(connectParams[k])
if not connectParams:
raise error.SnmpsimError('database connect parameters not specified')
moduleContext['dbConn'] = dbConn = db.connect(**connectParams)
moduleContext['dbTable'] = dbTable = options.get('dbtable', 'snmprec')
moduleContext['isolationLevel'] = options.get('isolationlevel', '1')
if moduleContext['isolationLevel'] not in isolationLevels:
raise error.SnmpsimError('unknown SQL transaction isolation level %s' % moduleContext['isolationLevel'])
if 'mode' in context and context['mode'] == 'recording':
cursor = dbConn.cursor()
try:
cursor.execute(
'select * from information_schema.tables where table_name=\'%s\' limit 1' % dbTable
)
except: # non-ANSI database
try:
cursor.execute('select * from %s limit 1' % dbTable)
except:
createTable = True
else:
createTable = False
else:
createTable = not cursor.fetchone()
if createTable:
cursor.execute('CREATE TABLE %s (oid text, tag text, value text, maxaccess text)' % dbTable)
cursor.close()
def init(**context):
options = {}
if context['options']:
options.update(
dict([split(x, ':') for x in split(context['options'], ',')]))
connectOpts = 'host', 'port', 'password', 'db', 'unix_socket'
connectParams = dict([(k, options[k]) for k in options
if k in connectOpts])
for k in 'port', 'db':
if k in connectParams:
connectParams[k] = int(connectParams[k])
if not connectParams:
raise error.SnmpsimError('Redis connect parameters not specified')
if StrictRedis is None:
raise error.SnmpsimError('redis-py Python package must be installed!')
moduleContext['dbConn'] = StrictRedis(**connectParams)
if context['mode'] == 'recording':
if 'key-spaces-id' in options:
moduleContext['key-spaces-id'] = int(options['key-spaces-id'])
else:
moduleContext['key-spaces-id'] = random.randrange(0, 0xffffffff)
log.msg('redis: using key-spaces-id %s' %
moduleContext['key-spaces-id'])
if 'iterations' in options:
moduleContext['iterations'] = max(0,
int(options['iterations']) - 1)
if 'period' in options:
moduleContext['period'] = float(options['period'])
else:
moduleContext['period'] = 60.0
redisScript = options.get('evalsha')
if redisScript:
log.msg('redis: using server-side script %s' % redisScript)
elif context['mode'] == 'variating':
moduleContext['booted'] = time.time()
moduleContext['ready'] = True
def init(**context):
options = {}
if context['options']:
options.update(
dict([split(x, ':')
for x in split(context['options'], ',')]))
connectOpts = 'host', 'port', 'password', 'db', 'unix_socket'
connectParams = dict(
[(k, options[k]) for k in options if k in connectOpts])
for k in 'port', 'db':
if k in connectParams:
connectParams[k] = int(connectParams[k])
if not connectParams:
raise error.SnmpsimError('Redis connect parameters not specified')
if StrictRedis is None:
raise error.SnmpsimError('redis-py Python package must be installed!')
moduleContext['dbConn'] = StrictRedis(**connectParams)
if context['mode'] == 'recording':
if 'key-spaces-id' in options:
moduleContext['key-spaces-id'] = int(options['key-spaces-id'])
else:
moduleContext['key-spaces-id'] = random.randrange(0, 0xffffffff)
log.msg('redis: using key-spaces-id %s' % moduleContext['key-spaces-id'])
if 'iterations' in options:
moduleContext['iterations'] = max(0, int(options['iterations']) - 1)
if 'period' in options:
moduleContext['period'] = float(options['period'])
else:
moduleContext['period'] = 60.0
redisScript = options.get('evalsha')
if redisScript:
log.msg('redis: using server-side script %s' % redisScript)
elif context['mode'] == 'variating':
moduleContext['booted'] = time.time()
moduleContext['ready'] = True
def init(**context):
options = {}
if context['options']:
options.update(
dict([split(x, ':') for x in split(context['options'], ',')])
)
if 'dbtype' not in options:
raise error.SnmpsimError('database type not specified')
db = __import__(
options['dbtype'],
globals(), locals(),
options['dbtype'].split('.')[:-1]
)
if 'dboptions' in options: # legacy
connectParams = { 'database': options['dboptions'] }
else:
connectParams = dict(
[ (k,options[k]) for k in options if k in ('host', 'port', 'user', 'passwd', 'password', 'db', 'database', 'unix_socket', 'named_pipe') ]
)
for k in 'port', 'connect_timeout':
if k in connectParams:
connectParams[k] = int(connectParams[k])
if not connectParams:
raise error.SnmpsimError('database connect parameters not specified')
moduleContext['dbConn'] = dbConn = db.connect(**connectParams)
moduleContext['dbTable'] = dbTable = options.get('dbtable', 'snmprec')
moduleContext['isolationLevel'] = options.get('isolationlevel', '1')
if moduleContext['isolationLevel'] not in isolationLevels:
raise error.SnmpsimError('unknown SQL transaction isolation level %s' % moduleContext['isolationLevel'])
if 'mode' in context and context['mode'] == 'recording':
cursor = dbConn.cursor()
try:
cursor.execute(
'select * from information_schema.tables where table_name=\'%s\' limit 1' % dbTable
)
except: # non-ANSI database
try:
cursor.execute('select * from %s limit 1' % dbTable)
except:
createTable = True
else:
createTable = False
else:
createTable = not cursor.fetchone()
if createTable:
cursor.execute('CREATE TABLE %s (oid text, tag text, value text, maxaccess text)' % dbTable)
cursor.close()
def record(oid, tag, value, **context):
if 'ready' not in moduleContext:
raise error.SnmpsimError('module not initialized')
if 'dbConn' in moduleContext:
dbConn = moduleContext['dbConn']
else:
raise error.SnmpsimError('variation module not initialized')
if 'started' not in moduleContext:
moduleContext['started'] = time.time()
redisScript = moduleContext.get('evalsha')
keySpace = '%.10d' % (moduleContext['key-spaces-id'] + moduleContext.get('iterations', 0))
if context['stopFlag']:
dbConn.sort(keySpace + '-' + 'temp_oids_ordering', store=keySpace + '-' + 'oids_ordering', alpha=True)
dbConn.delete(keySpace + '-' + 'temp_oids_ordering')
dbConn.rpush(moduleContext['key-spaces-id'], keySpace)
log.msg('redis: done with key-space %s' % keySpace)
if 'iterations' in moduleContext and moduleContext['iterations']:
log.msg('redis: %s iterations remaining' % moduleContext['iterations'])
moduleContext['started'] = time.time()
moduleContext['iterations'] -= 1
wait = max(0, moduleContext['period'] - (time.time() - moduleContext['started']))
raise error.MoreDataNotification(period=wait)
else:
raise error.NoDataNotification()
dbOid = '.'.join(['%10s' % x for x in oid.split('.')])
if 'hexvalue' in context:
textTag = context['hextag']
textValue = context['hexvalue']
else:
textTag = SnmprecGrammar().getTagByType(context['origValue'])
textValue = str(context['origValue'])
dbConn.lpush(keySpace + '-temp_oids_ordering', keySpace + '-' + dbOid)
if redisScript:
dbConn.evalsha(redisScript, 1, keySpace + '-' + dbOid, textTag + '|' + textValue)
else:
dbConn.set(keySpace + '-' + dbOid, textTag + '|' + textValue)
if not context['count']:
settings = {
'key-spaces-id': moduleContext['key-spaces-id']
}
if 'period' in moduleContext:
settings['period'] = '%.2f' % float(moduleContext['period'])
if 'addon' in moduleContext:
settings.update(
dict([split(x, '=') for x in moduleContext['addon']])
)
value = ','.join([ '%s=%s' % (k,v) for k,v in settings.items() ])
return str(context['startOID']), ':redis', value
else:
raise error.NoDataNotification()
def variate(oid, tag, value, **context):
# in --v2c-arch some of the items are not defined
transportDomain = transportAddress = securityModel = securityName = \
securityLevel = contextName = '<undefined>'
if 'transportDomain' in context:
transportDomain = rfc1902.ObjectName(
context['transportDomain']).prettyPrint()
if 'transportAddress' in context:
transportAddress = ':'.join(
[str(x) for x in context['transportAddress']])
if 'securityModel' in context:
securityModel = str(context['securityModel'])
if 'securityName' in context:
securityName = str(context['securityName'])
if 'securityLevel' in context:
securityLevel = str(context['securityLevel'])
if 'contextName' in context:
contextName = str(context['contextName'])
args = [(x.replace('@TRANSPORTDOMAIN@', transportDomain).replace(
'@TRANSPORTADDRESS@', transportAddress).replace(
'@SECURITYMODEL@',
securityModel).replace('@SECURITYNAME@', securityName).replace(
'@SECURITYLEVEL@',
securityLevel).replace('@CONTEXTNAME@', contextName).replace(
'@DATAFILE@',
context['dataFile']).replace('@OID@', str(oid)).replace(
'@TAG@', tag).replace('@ORIGOID@',
str(context['origOid'])).
replace('@ORIGTAG@',
str(sum(
[x
for x in context['origValue'].tagSet[0]]))).replace(
'@ORIGVALUE@',
str(context['origValue'])).replace(
'@SETFLAG@',
str(int(context['setFlag']))).replace(
'@NEXTFLAG@',
str(int(context['nextFlag']))).replace(
'@SUBTREEFLAG@',
str(int(context['subtreeFlag']))))
for x in split(value, ' ')]
log.msg('subprocess: executing external process "%s"' % ' '.join(args))
call = (hasattr(subprocess, 'check_output') and subprocess.check_output
or hasattr(subprocess, 'check_call') and subprocess.check_call
or subprocess.call)
if not hasattr(subprocess, 'check_output'):
log.msg('subprocess: old Python, expect no output!')
try:
return oid, tag, call(args, shell=moduleContext['settings']['shell'])
except (hasattr(subprocess, 'CalledProcessError')
and subprocess.CalledProcessError or Exception):
log.msg('subprocess: external program execution failed')
return context['origOid'], tag, context['errorStatus']
def init(**context):
options = {}
if context['options']:
options.update(
dict([split(x, ':') for x in split(context['options'], ',')])
)
if 'dbtype' not in options:
raise error.SnmpsimError('database type not specified')
db = __import__(
options['dbtype'],
globals(), locals(),
options['dbtype'].split('.')[:-1]
)
if 'dboptions' in options:
connectParams = {'database': options['dboptions']}
else:
connectParams = dict(
[(k, options[k]) for k in options if k in ('host', 'port', 'user',
'passwd', 'password',
'db', 'database',
'unix_socket',
'named_pipe')]
)
for k in 'port', 'connect_timeout':
if k in connectParams:
connectParams[k] = int(connectParams[k])
if not connectParams:
raise error.SnmpsimError('database connect parameters not specified')
moduleContext['dbConn'] = dbConn = db.connect(**connectParams)
moduleContext['dbTable'] = dbTable = options.get('dbtable', 'snmprec')
moduleContext['isolationLevel'] = options.get('isolationlevel', '1')
if moduleContext['isolationLevel'] not in isolationLevels:
raise error.SnmpsimError('unknown SQL transaction isolation level %s' %
moduleContext['isolationLevel'])
if not os.path.exists("/tmp/inform"):
os.mkfifo('/tmp/inform')
try:
moduleContext['inform'] = inform = os.open("/tmp/inform",
os.O_WRONLY | os.O_NONBLOCK)
except Exception, ex:
raise error.SnmpsimError('---> Infrasim: {0}: {1}'.format(Exception, ex))
def init(**context):
options = {}
if context['options']:
options.update(
dict([split(x, ':') for x in split(context['options'], ',')]))
if 'dbtype' not in options:
raise error.SnmpsimError('database type not specified')
db = __import__(options['dbtype'], globals(), locals(),
options['dbtype'].split('.')[:-1])
if 'dboptions' in options:
connectParams = {'database': options['dboptions']}
else:
connectParams = dict([
(k, options[k]) for k in options
if k in ('host', 'port', 'user', 'passwd', 'password', 'db',
'database', 'unix_socket', 'named_pipe')
])
for k in 'port', 'connect_timeout':
if k in connectParams:
connectParams[k] = int(connectParams[k])
if not connectParams:
raise error.SnmpsimError('database connect parameters not specified')
moduleContext['dbConn'] = dbConn = db.connect(**connectParams)
moduleContext['dbTable'] = dbTable = options.get('dbtable', 'snmprec')
moduleContext['isolationLevel'] = options.get('isolationlevel', '1')
if moduleContext['isolationLevel'] not in isolationLevels:
raise error.SnmpsimError('unknown SQL transaction isolation level %s' %
moduleContext['isolationLevel'])
if not os.path.exists("/tmp/inform"):
os.mkfifo('/tmp/inform')
try:
moduleContext['inform'] = inform = os.open("/tmp/inform",
os.O_WRONLY | os.O_NONBLOCK)
except Exception, ex:
raise error.SnmpsimError('---> Infrasim: {0}: {1}'.format(
Exception, ex))
def variate(oid, tag, value, **context):
# in --v2c-arch some of the items are not defined
transportDomain = transportAddress = securityModel = securityName = \
securityLevel = contextName = '<undefined>'
if 'transportDomain' in context:
transportDomain = rfc1902.ObjectName(context['transportDomain']).prettyPrint()
if 'transportAddress' in context:
transportAddress = ':'.join([str(x) for x in context['transportAddress']])
if 'securityModel' in context:
securityModel = str(context['securityModel'])
if 'securityName' in context:
securityName = str(context['securityName'])
if 'securityLevel' in context:
securityLevel = str(context['securityLevel'])
if 'contextName' in context:
contextName = str(context['contextName'])
args = [ x\
.replace('@TRANSPORTDOMAIN@', transportDomain)\
.replace('@TRANSPORTADDRESS@', transportAddress)\
.replace('@SECURITYMODEL@', securityModel)\
.replace('@SECURITYNAME@', securityName)\
.replace('@SECURITYLEVEL@', securityLevel)\
.replace('@CONTEXTNAME@', contextName)\
.replace('@DATAFILE@', context['dataFile'])\
.replace('@OID@', str(oid))\
.replace('@TAG@', tag)\
.replace('@ORIGOID@', str(context['origOid']))\
.replace('@ORIGTAG@', str(sum([ x for x in context['origValue'].tagSet[0]])))\
.replace('@ORIGVALUE@', str(context['origValue']))\
.replace('@SETFLAG@', str(int(context['setFlag'])))\
.replace('@NEXTFLAG@', str(int(context['nextFlag'])))\
.replace('@SUBTREEFLAG@', str(int(context['subtreeFlag'])))\
for x in split(value, ' ') ]
log.msg('subprocess: executing external process "%s"' % ' '.join(args))
call = hasattr(subprocess, 'check_output') and subprocess.check_output or \
hasattr(subprocess, 'check_call') and subprocess.check_call or \
subprocess.call
if not hasattr(subprocess, 'check_output'):
log.msg('subprocess: old Python, expect no output!')
try:
return oid, tag, call(
args, shell=moduleContext['settings']['shell']
)
except hasattr(subprocess, 'CalledProcessError') and \
subprocess.CalledProcessError or Exception:
log.msg('subprocess: external program execution failed')
return context['origOid'], tag, context['errorStatus']
def init(**context):
if context['mode'] == 'variating':
random.seed()
if context['mode'] == 'recording':
moduleContext['settings'] = {}
if context['options']:
for x in split(context['options'], ','):
for k, v in split(x, ':'):
if k == 'addon':
if k in moduleContext['settings']:
moduleContext['settings'][k].append(v)
else:
moduleContext['settings'][k] = [v]
else:
moduleContext['settings'][k] = v
if 'iterations' in moduleContext['settings']:
moduleContext['settings']['iterations'] = int(
moduleContext['settings']['iterations'])
if moduleContext['settings']['iterations']:
# no reason for more
moduleContext['settings']['iterations'] = 1
if 'period' in moduleContext['settings']:
moduleContext['settings']['period'] = float(
moduleContext['settings']['period'])
else:
moduleContext['settings']['period'] = 10.0
if 'taglist' not in moduleContext['settings']:
moduleContext['settings']['taglist'] = '2-65-66-67-70'
def record(oid, tag, value, **context):
if 'ready' not in moduleContext:
raise error.SnmpsimError('module not initialized')
if 'started' not in moduleContext:
moduleContext['started'] = time.time()
if context['stopFlag']:
if 'file' in moduleContext:
moduleContext['file'].close()
del moduleContext['file']
else:
moduleContext['filenum'] = 0
if 'iterations' in moduleContext and moduleContext['iterations']:
log.msg('multiplex: %s iterations remaining' % moduleContext['iterations'])
moduleContext['started'] = time.time()
moduleContext['iterations'] -= 1
moduleContext['filenum'] += 1
wait = max(0, moduleContext['period'] - (time.time() - moduleContext['started']))
raise error.MoreDataNotification(period=wait)
else:
raise error.NoDataNotification()
if 'file' not in moduleContext:
if 'filenum' not in moduleContext:
moduleContext['filenum'] = 0
snmprecfile = os.path.join(moduleContext['dir'],
'%.5d%ssnmprec' % (moduleContext['filenum'],
os.path.extsep))
moduleContext['file'] = open(snmprecfile, 'wb')
log.msg('multiplex: writing into %s file...' % snmprecfile)
moduleContext['file'].write(
SnmprecRecord().format(context['origOid'], context['origValue'])
)
if not context['total']:
settings = {
'dir': moduleContext['dir'].replace(os.path.sep, '/')
}
if 'period' in moduleContext:
settings['period'] = '%.2f' % float(moduleContext['period'])
if 'addon' in moduleContext:
settings.update(
dict([split(x, '=') for x in moduleContext['addon']])
)
value = ','.join(['%s=%s' % (k, v) for k, v in settings.items()])
return str(context['startOID']), ':multiplex', value
else:
raise error.NoDataNotification()
def record(oid, tag, value, **context):
if 'ready' not in moduleContext:
raise error.SnmpsimError('module not initialized')
if 'started' not in moduleContext:
moduleContext['started'] = time.time()
if context['stopFlag']:
if 'file' in moduleContext:
moduleContext['file'].close()
del moduleContext['file']
else:
moduleContext['filenum'] = 0
if 'iterations' in moduleContext and moduleContext['iterations']:
log.msg('multiplex: %s iterations remaining' % moduleContext['iterations'])
moduleContext['started'] = time.time()
moduleContext['iterations'] -= 1
moduleContext['filenum'] += 1
wait = max(0, moduleContext['period'] - (time.time() - moduleContext['started']))
raise error.MoreDataNotification(period=wait)
else:
raise error.NoDataNotification()
if 'file' not in moduleContext:
if 'filenum' not in moduleContext:
moduleContext['filenum'] = 0
snmprecfile = os.path.join(moduleContext['dir'],
'%.5d%ssnmprec' % (moduleContext['filenum'],
os.path.extsep))
moduleContext['file'] = open(snmprecfile, 'wb')
log.msg('multiplex: writing into %s file...' % snmprecfile)
moduleContext['file'].write(
SnmprecRecord().format(context['origOid'], context['origValue'])
)
if not context['total']:
settings = {
'dir': moduleContext['dir'].replace(os.path.sep, '/')
}
if 'period' in moduleContext:
settings['period'] = '%.2f' % float(moduleContext['period'])
if 'addon' in moduleContext:
settings.update(
dict([split(x, '=') for x in moduleContext['addon']])
)
value = ','.join([ '%s=%s' % (k,v) for k,v in settings.items() ])
return str(context['startOID']), ':multiplex', value
else:
raise error.NoDataNotification()
def variate(oid, tag, value, **context):
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict([split(x, '=') for x in split(value, ',')])
if 'hexvalue' in recordContext['settings']:
recordContext['settings']['value'] = [int(recordContext['settings']['hexvalue'][x:x + 2], 16) for x in
range(0, len(recordContext['settings']['hexvalue']), 2)]
if 'wait' in recordContext['settings']:
recordContext['settings']['wait'] = float(recordContext['settings']['wait'])
else:
recordContext['settings']['wait'] = 500.0
if 'deviation' in recordContext['settings']:
recordContext['settings']['deviation'] = float(recordContext['settings']['deviation'])
else:
recordContext['settings']['deviation'] = 0.0
if 'vlist' in recordContext['settings']:
vlist = {}
recordContext['settings']['vlist'] = split(recordContext['settings']['vlist'], ':')
while recordContext['settings']['vlist']:
o, v, d = recordContext['settings']['vlist'][:3]
recordContext['settings']['vlist'] = recordContext['settings']['vlist'][3:]
d = int(d)
v = SnmprecGrammar.tagMap[tag](v)
if o not in vlist:
vlist[o] = {}
if o == 'eq':
vlist[o][v] = d
elif o in ('lt', 'gt'):
vlist[o] = v, d
else:
log.msg('delay: bad vlist syntax: %s' % recordContext['settings']['vlist'])
recordContext['settings']['vlist'] = vlist
if 'tlist' in recordContext['settings']:
tlist = {}
recordContext['settings']['tlist'] = split(recordContext['settings']['tlist'], ':')
while recordContext['settings']['tlist']:
o, v, d = recordContext['settings']['tlist'][:3]
recordContext['settings']['tlist'] = recordContext['settings']['tlist'][3:]
v = int(v)
d = int(d)
if o not in tlist:
tlist[o] = {}
if o == 'eq':
tlist[o][v] = d
elif o in ('lt', 'gt'):
tlist[o] = v, d
else:
log.msg('delay: bad tlist syntax: %s' % recordContext['settings']['tlist'])
recordContext['settings']['tlist'] = tlist
if context['setFlag'] and 'vlist' in recordContext['settings']:
if ('eq' in recordContext['settings']['vlist'] and
context['origValue'] in recordContext['settings']['vlist']['eq']):
delay = recordContext['settings']['vlist']['eq'][context['origValue']]
elif ('lt' in recordContext['settings']['vlist'] and
context['origValue'] < recordContext['settings']['vlist']['lt'][0]):
delay = recordContext['settings']['vlist']['lt'][1]
elif ('gt' in recordContext['settings']['vlist'] and
context['origValue'] > recordContext['settings']['vlist']['gt'][0]):
delay = recordContext['settings']['vlist']['gt'][1]
else:
delay = recordContext['settings']['wait']
elif 'tlist' in recordContext['settings']:
now = int(time.time())
if ('eq' in recordContext['settings']['tlist'] and
now == recordContext['settings']['tlist']['eq']):
delay = recordContext['settings']['tlist']['eq'][now]
elif ('lt' in recordContext['settings']['tlist'] and
now < recordContext['settings']['tlist']['lt'][0]):
delay = recordContext['settings']['tlist']['lt'][1]
elif ('gt' in recordContext['settings']['tlist'] and
now > recordContext['settings']['tlist']['gt'][0]):
delay = recordContext['settings']['tlist']['gt'][1]
else:
delay = recordContext['settings']['wait']
else:
delay = recordContext['settings']['wait']
if recordContext['settings']['deviation']:
delay += random.randrange(
-recordContext['settings']['deviation'], recordContext['settings']['deviation']
)
if delay < 0:
delay = 0
elif delay > 99999:
log.msg('delay: dropping response for %s' % oid)
raise error.NoDataNotification()
log.msg('delay: waiting %d milliseconds for %s' % (delay, oid))
time.sleep(delay / 1000) # ms
if context['setFlag'] or 'value' not in recordContext['settings']:
return oid, tag, context['origValue']
else:
return oid, tag, recordContext['settings']['value']
def variate(oid, tag, value, **context):
if 'snmpEngine' in context and context['snmpEngine']:
snmpEngine = context['snmpEngine']
if snmpEngine not in moduleContext:
moduleContext[snmpEngine] = {}
if context['transportDomain'] not in moduleContext[snmpEngine]:
# register this SNMP Engine to handle our transports'
# receiver IDs (which we build by outbound and simulator
# transportDomains concatenation)
snmpEngine.registerTransportDispatcher(
snmpEngine.transportDispatcher,
UdpTransportTarget.transportDomain + \
context['transportDomain']
)
snmpEngine.registerTransportDispatcher(
snmpEngine.transportDispatcher,
Udp6TransportTarget.transportDomain + \
context['transportDomain']
)
moduleContext[snmpEngine][context['transportDomain']] = 1
else:
raise error.SnmpsimError('variation module not given snmpEngine')
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict([split(x, '=') for x in split(value, ',')])
for k, v in (('op', 'set'),
('community', 'public'),
('authkey', None),
('authproto', 'md5'),
('privkey', None),
('privproto', 'des'),
('proto', 'udp'),
('port', '162'),
('ntftype', 'trap'),
('trapoid', '1.3.6.1.6.3.1.1.5.1')):
recordContext['settings'].setdefault(k, v)
if 'hexvalue' in recordContext['settings']:
recordContext['settings']['value'] = [int(recordContext['settings']['hexvalue'][x:x + 2], 16) for x in
range(0, len(recordContext['settings']['hexvalue']), 2)]
if 'vlist' in recordContext['settings']:
vlist = {}
recordContext['settings']['vlist'] = split(recordContext['settings']['vlist'], ':')
while recordContext['settings']['vlist']:
o, v = recordContext['settings']['vlist'][:2]
recordContext['settings']['vlist'] = recordContext['settings']['vlist'][2:]
v = SnmprecGrammar.tagMap[tag](v)
if o not in vlist:
vlist[o] = set()
if o == 'eq':
vlist[o].add(v)
elif o in ('lt', 'gt'):
vlist[o] = v
else:
log.msg('notification: bad vlist syntax: %s' % recordContext['settings']['vlist'])
recordContext['settings']['vlist'] = vlist
args = recordContext['settings']
if context['setFlag'] and 'vlist' in args:
if 'eq' in args['vlist'] and \
context['origValue'] in args['vlist']['eq']:
pass
elif 'lt' in args['vlist'] and \
context['origValue'] < args['vlist']['lt']:
pass
elif 'gt' in args['vlist'] and \
context['origValue'] > args['vlist']['gt']:
pass
else:
return oid, tag, context['origValue']
if args['op'] not in ('get', 'set', 'any', '*'):
log.msg('notification: unknown SNMP request type configured: %s' % args['op'])
return context['origOid'], tag, context['errorStatus']
if args['op'] == 'get' and not context['setFlag'] or \
args['op'] == 'set' and context['setFlag'] or \
args['op'] in ('any', '*'):
if args['version'] in ('1', '2c'):
authData = CommunityData(args['community'], mpModel=args['version'] == '2c' and 1 or 0)
elif args['version'] == '3':
if args['authproto'] == 'md5':
authProtocol = usmHMACMD5AuthProtocol
elif args['authproto'] == 'sha':
authProtocol = usmHMACSHAAuthProtocol
elif args['authproto'] == 'none':
authProtocol = usmNoAuthProtocol
else:
log.msg('notification: unknown auth proto %s' % args['authproto'])
return context['origOid'], tag, context['errorStatus']
if args['privproto'] == 'des':
privProtocol = usmDESPrivProtocol
elif args['privproto'] == 'aes':
privProtocol = usmAesCfb128Protocol
elif args['privproto'] == 'none':
privProtocol = usmNoPrivProtocol
else:
log.msg('notification: unknown privacy proto %s' % args['privproto'])
return context['origOid'], tag, context['errorStatus']
authData = UsmUserData(args['user'], args['authkey'], args['privkey'], authProtocol=authProtocol,
privProtocol=privProtocol)
else:
log.msg('notification: unknown SNMP version %s' % args['version'])
return context['origOid'], tag, context['errorStatus']
if 'host' not in args:
log.msg('notification: target hostname not configured for OID %s' % (oid,))
return context['origOid'], tag, context['errorStatus']
if args['proto'] == 'udp':
target = UdpTransportTarget((args['host'], int(args['port'])))
elif args['proto'] == 'udp6':
target = Udp6TransportTarget((args['host'], int(args['port'])))
else:
log.msg('notification: unknown transport %s' % args['proto'])
return context['origOid'], tag, context['errorStatus']
localAddress = None
if 'bindaddr' in args:
localAddress = args['bindaddr']
else:
if context['transportDomain'][:len(target.transportDomain)] == \
target.transportDomain:
localAddress = \
snmpEngine.transportDispatcher.getTransport(context['transportDomain']).getLocalAddress()[0]
else:
log.msg(
'notification: incompatible network transport types used by CommandResponder vs NotificationOriginator')
if 'bindaddr' in args:
localAddress = args['bindaddr']
if localAddress:
log.msg('notification: binding to local address %s' % localAddress)
target.setLocalAddress((localAddress, 0))
# this will make target objects different based on their bind address
target.transportDomain = target.transportDomain + \
context['transportDomain']
varBinds = []
if 'uptime' in args:
varBinds.append(
(ObjectIdentifier('1.3.6.1.2.1.1.3.0'),
TimeTicks(args['uptime']))
)
if args['version'] == '1':
if 'agentaddress' in args:
varBinds.append(
(ObjectIdentifier('1.3.6.1.6.3.18.1.3.0'),
IpAddress(args['agentaddress']))
)
if 'enterprise' in args:
varBinds.append(
(ObjectIdentifier('1.3.6.1.6.3.1.1.4.3.0'),
ObjectIdentifier(args['enterprise']))
)
if 'varbinds' in args:
vbs = split(args['varbinds'], ':')
while vbs:
varBinds.append(
(ObjectIdentifier(vbs[0]), typeMap[vbs[1]](vbs[2]))
)
vbs = vbs[3:]
sendNotification(
snmpEngine, authData, target, ContextData(), args['ntftype'],
NotificationType(ObjectIdentity(args['trapoid'])).addVarBinds(*varBinds),
cbFun=_cbFun, cbCtx=(oid, value)
)
log.msg('notification: sending Notification to %s with credentials %s' % (authData, target))
if context['setFlag'] or 'value' not in args:
return oid, tag, context['origValue']
else:
return oid, tag, args['value']
def variate(oid, tag, value, **context):
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict(
[split(x, '=') for x in split(value, ',')])
if 'vlist' in recordContext['settings']:
vlist = {}
recordContext['settings']['vlist'] = split(
recordContext['settings']['vlist'], ':')
while recordContext['settings']['vlist']:
o, v, e = recordContext['settings']['vlist'][:3]
vl = recordContext['settings']['vlist'][3:]
recordContext['settings']['vlist'] = vl
typeTag, _ = SnmprecRecord.unpackTag(tag)
v = SnmprecGrammar.TAG_MAP[typeTag](v)
if o not in vlist:
vlist[o] = {}
if o == 'eq':
vlist[o][v] = e
elif o in ('lt', 'gt'):
vlist[o] = v, e
else:
log.msg('writecache: bad vlist syntax: '
'%s' % recordContext['settings']['vlist'])
recordContext['settings']['vlist'] = vlist
if 'status' in recordContext['settings']:
st = recordContext['settings']['status'].lower()
recordContext['settings']['status'] = st
if oid not in moduleContext:
moduleContext[oid] = {}
typeTag, _ = SnmprecRecord.unpackTag(tag)
moduleContext[oid]['type'] = SnmprecGrammar.TAG_MAP[typeTag]()
textOid = str(oid)
if context['setFlag']:
if 'vlist' in recordContext['settings']:
if ('eq' in recordContext['settings']['vlist']
and context['origValue']
in recordContext['settings']['vlist']['eq']):
e = recordContext['settings']['vlist']['eq'][
context['origValue']]
elif ('lt' in recordContext['settings']['vlist']
and context['origValue'] <
recordContext['settings']['vlist']['lt'][0]):
e = recordContext['settings']['vlist']['lt'][1]
elif ('gt' in recordContext['settings']['vlist']
and context['origValue'] >
recordContext['settings']['vlist']['gt'][0]):
e = recordContext['settings']['vlist']['gt'][1]
else:
e = None
if e in ERROR_TYPES:
idx = max(0,
context['varsTotal'] - context['varsRemaining'] - 1)
raise ERROR_TYPES[e](name=oid, idx=idx)
if moduleContext[oid]['type'].isSameTypeWith(context['origValue']):
moduleContext['cache'][textOid] = context['origValue']
else:
return context['origOid'], tag, context['errorStatus']
if 'status' in recordContext['settings']:
if ('op' not in recordContext['settings']
or recordContext['settings']['op'] == 'any' or
recordContext['settings']['op'] == 'set' and context['setFlag']
or recordContext['settings']['op'] == 'get'
and not context['setFlag']):
e = recordContext['settings']['status']
if e in ERROR_TYPES:
idx = max(0,
context['varsTotal'] - context['varsRemaining'] - 1)
raise ERROR_TYPES[e](name=oid, idx=idx)
if textOid in moduleContext['cache']:
return oid, tag, moduleContext['cache'][textOid]
elif 'hexvalue' in recordContext['settings']:
return oid, tag, moduleContext[oid]['type'].clone(
hexValue=recordContext['settings']['hexvalue'])
elif 'value' in recordContext['settings']:
return oid, tag, moduleContext[oid]['type'].clone(
recordContext['settings']['value'])
else:
return oid, tag, context['errorStatus']
def variate(oid, tag, value, **context):
if 'snmpEngine' in context and context['snmpEngine']:
snmpEngine = context['snmpEngine']
if snmpEngine not in moduleContext:
moduleContext[snmpEngine] = {}
if context['transportDomain'] not in moduleContext[snmpEngine]:
# register this SNMP Engine to handle our transports'
# receiver IDs (which we build by outbound and simulator
# transportDomains concatenation)
snmpEngine.registerTransportDispatcher(
snmpEngine.transportDispatcher,
UdpTransportTarget.transportDomain + \
context['transportDomain']
)
snmpEngine.registerTransportDispatcher(
snmpEngine.transportDispatcher,
Udp6TransportTarget.transportDomain + \
context['transportDomain']
)
moduleContext[snmpEngine][context['transportDomain']] = 1
else:
raise error.SnmpsimError('variation module not given snmpEngine')
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict([split(x, '=') for x in split(value, ',')])
for k,v in ( ('op', 'set'),
('community', 'public'),
('authkey', None),
('authproto', 'md5'),
('privkey', None),
('privproto', 'des'),
('proto', 'udp'),
('port', '162'),
('ntftype', 'trap'),
('trapoid', '1.3.6.1.6.3.1.1.5.1') ):
recordContext['settings'].setdefault(k, v)
if 'hexvalue' in recordContext['settings']:
recordContext['settings']['value'] = [int(recordContext['settings']['hexvalue'][x:x+2], 16) for x in range(0, len(recordContext['settings']['hexvalue']), 2)]
if 'vlist' in recordContext['settings']:
vlist = {}
recordContext['settings']['vlist'] = split(recordContext['settings']['vlist'], ':')
while recordContext['settings']['vlist']:
o,v = recordContext['settings']['vlist'][:2]
recordContext['settings']['vlist'] = recordContext['settings']['vlist'][2:]
v = SnmprecGrammar.tagMap[tag](v)
if o not in vlist:
vlist[o] = set()
if o == 'eq':
vlist[o].add(v)
elif o in ('lt', 'gt'):
vlist[o] = v
else:
log.msg('notification: bad vlist syntax: %s' % recordContext['settings']['vlist'])
recordContext['settings']['vlist'] = vlist
args = recordContext['settings']
if context['setFlag'] and 'vlist' in args:
if 'eq' in args['vlist'] and \
context['origValue'] in args['vlist']['eq']:
pass
elif 'lt' in args['vlist'] and \
context['origValue'] < args['vlist']['lt']:
pass
elif 'gt' in args['vlist'] and \
context['origValue'] > args['vlist']['gt']:
pass
else:
return oid, tag, context['origValue']
if args['op'] not in ('get', 'set', 'any', '*'):
log.msg('notification: unknown SNMP request type configured: %s' % args['op'])
return context['origOid'], tag, context['errorStatus']
if args['op'] == 'get' and not context['setFlag'] or \
args['op'] == 'set' and context['setFlag'] or \
args['op'] in ('any', '*'):
if args['version'] in ('1', '2c'):
authData = CommunityData(args['community'], mpModel=args['version'] == '2c' and 1 or 0)
elif args['version'] == '3':
if args['authproto'] == 'md5':
authProtocol = usmHMACMD5AuthProtocol
elif args['authproto'] == 'sha':
authProtocol = usmHMACSHAAuthProtocol
elif args['authproto'] == 'none':
authProtocol = usmNoAuthProtocol
else:
log.msg('notification: unknown auth proto %s' % args['authproto'])
return context['origOid'], tag, context['errorStatus']
if args['privproto'] == 'des':
privProtocol = usmDESPrivProtocol
elif args['privproto'] == 'aes':
privProtocol = usmAesCfb128Protocol
elif args['privproto'] == 'none':
privProtocol = usmNoPrivProtocol
else:
log.msg('notification: unknown privacy proto %s' % args['privproto'])
return context['origOid'], tag, context['errorStatus']
authData = UsmUserData(args['user'], args['authkey'], args['privkey'], authProtocol=authProtocol, privProtocol=privProtocol)
else:
log.msg('notification: unknown SNMP version %s' % args['version'])
return context['origOid'], tag, context['errorStatus']
if 'host' not in args:
log.msg('notification: target hostname not configured for OID' % (oid,))
return context['origOid'], tag, context['errorStatus']
if args['proto'] == 'udp':
target = UdpTransportTarget((args['host'], int(args['port'])))
elif args['proto'] == 'udp6':
target = Udp6TransportTarget((args['host'], int(args['port'])))
else:
log.msg('notification: unknown transport %s' % args['proto'])
return context['origOid'], tag, context['errorStatus']
localAddress = None
if 'bindaddr' in args:
localAddress = args['bindaddr']
else:
if context['transportDomain'][:len(target.transportDomain)] == \
target.transportDomain:
localAddress = snmpEngine.transportDispatcher.getTransport(context['transportDomain']).getLocalAddress()[0]
else:
log.msg('notification: incompatible network transport types used by CommandResponder vs NotificationOriginator')
if 'bindaddr' in args:
localAddress = args['bindaddr']
if localAddress:
log.msg('notification: binding to local address %s' % localAddress)
target.setLocalAddress((localAddress, 0))
# this will make target objects different based on their bind address
target.transportDomain = target.transportDomain + \
context['transportDomain']
varBinds = []
if 'uptime' in args:
varBinds.append(
( ObjectIdentifier('1.3.6.1.2.1.1.3.0'),
TimeTicks(args['uptime']) )
)
if args['version'] == '1':
if 'agentaddress' in args:
varBinds.append(
( ObjectIdentifier('1.3.6.1.6.3.18.1.3.0'),
IpAddress(args['agentaddress']) )
)
if 'enterprise' in args:
varBinds.append(
( ObjectIdentifier('1.3.6.1.6.3.1.1.4.3.0'),
ObjectIdentifier(args['enterprise']) )
)
if 'varbinds' in args:
vbs = split(args['varbinds'], ':')
while vbs:
varBinds.append(
(ObjectIdentifier(vbs[0]), typeMap[vbs[1]](vbs[2]))
)
vbs = vbs[3:]
sendNotification(
snmpEngine, authData, target, ContextData(), args['ntftype'],
NotificationType(ObjectIdentity(args['trapoid'])).addVarBinds(*varBinds),
cbFun=_cbFun, cbCtx=(oid, value)
)
log.msg('notification: sending Notification to %s with credentials %s' % (authData, target))
if context['setFlag'] or 'value' not in args:
return oid, tag, context['origValue']
else:
return oid, tag, args['value']
def variate(oid, tag, value, **context):
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict([split(x, '=') for x in split(value, ',')])
if 'hexvalue' in recordContext['settings']:
recordContext['settings']['value'] = [int(recordContext['settings']['hexvalue'][x:x+2], 16) for x in range(0, len(recordContext['settings']['hexvalue']), 2)]
if 'status' in recordContext['settings']:
recordContext['settings']['status'] = recordContext['settings']['status'].lower()
if 'op' not in recordContext['settings']:
recordContext['settings']['op'] = 'any'
if 'vlist' in recordContext['settings']:
vlist = {}
recordContext['settings']['vlist'] = split(recordContext['settings']['vlist'], ':')
while recordContext['settings']['vlist']:
o,v,e = recordContext['settings']['vlist'][:3]
recordContext['settings']['vlist'] = recordContext['settings']['vlist'][3:]
v = SnmprecGrammar.tagMap[tag](v)
if o not in vlist:
vlist[o] = {}
if o == 'eq':
vlist[o][v] = e
elif o in ('lt', 'gt'):
vlist[o] = v, e
else:
log.msg('error: bad vlist syntax: %s' % recordContext['settings']['vlist'])
recordContext['settings']['vlist'] = vlist
e = None
if context['setFlag']:
if 'vlist' in recordContext['settings']:
if 'eq' in recordContext['settings']['vlist'] and \
context['origValue'] in recordContext['settings']['vlist']['eq']:
e = recordContext['settings']['vlist']['eq'][context['origValue']]
elif 'lt' in recordContext['settings']['vlist'] and \
context['origValue'] < recordContext['settings']['vlist']['lt'][0]:
e = recordContext['settings']['vlist']['lt'][1]
elif 'gt' in recordContext['settings']['vlist'] and \
context['origValue'] > recordContext['settings']['vlist']['gt'][0]:
e = recordContext['settings']['vlist']['gt'][1]
elif recordContext['settings']['op'] in ('set', 'any'):
if 'status' in recordContext['settings']:
e = recordContext['settings']['status']
else:
if recordContext['settings']['op'] in ('get', 'any'):
if 'status' in recordContext['settings']:
e = recordContext['settings']['status']
if e and e in errorTypes:
log.msg('error: reporting %s for %s' % (e, oid))
raise errorTypes[e](
name=oid, idx=max(0, context['varsTotal']-context['varsRemaining']-1)
)
if context['setFlag']:
recordContext['settings']['value'] = context['origValue']
return oid, tag, recordContext['settings'].get('value', context['errorStatus'])
def variate(oid, tag, value, **context):
if 'settings' not in recordContext:
recordContext['settings'] = dict(
[split(x, '=') for x in split(value, ',')])
if 'dir' not in recordContext['settings']:
log.msg('multiplex: snapshot directory not specified')
return context['origOid'], tag, context['errorStatus']
recordContext['settings']['dir'] = recordContext[
'settings']['dir'].replace('/', os.path.sep)
if recordContext['settings']['dir'][0] != os.path.sep:
for x in confdir.data:
d = os.path.join(x, recordContext['settings']['dir'])
if os.path.exists(d):
break
else:
log.msg('multiplex: directory %s not '
'found' % recordContext['settings']['dir'])
return context['origOid'], tag, context['errorStatus']
else:
d = recordContext['settings']['dir']
recordContext['dirmap'] = dict(
[(int(os.path.basename(x).split(os.path.extsep)[0]),
os.path.join(d, x))
for x in os.listdir(d)
if x[-7:] == 'snmprec']
)
recordContext['keys'] = list(recordContext['dirmap'])
recordContext['bounds'] = (
min(recordContext['keys']), max(recordContext['keys']))
if 'period' in recordContext['settings']:
recordContext['settings']['period'] = float(
recordContext['settings']['period'])
else:
recordContext['settings']['period'] = 60.0
if 'wrap' in recordContext['settings']:
recordContext['settings']['wrap'] = bool(
recordContext['settings']['wrap'])
else:
recordContext['settings']['wrap'] = False
if 'control' in recordContext['settings']:
recordContext['settings']['control'] = rfc1902.ObjectName(
recordContext['settings']['control'])
log.msg(
'multiplex: using control OID %s for subtree %s, '
'time-based multiplexing '
'disabled' % (recordContext['settings']['control'], oid))
recordContext['ready'] = True
if 'ready' not in recordContext:
return context['origOid'], tag, context['errorStatus']
if oid not in moduleContext:
moduleContext[oid] = {}
if context['setFlag']:
if 'control' in (
recordContext['settings'] and
recordContext['settings']['control'] == context['origOid']):
fileno = int(context['origValue'])
if fileno >= len(recordContext['keys']):
log.msg('multiplex: .snmprec file number %s over limit of'
' %s' % (fileno, len(recordContext['keys'])))
return context['origOid'], tag, context['errorStatus']
moduleContext[oid]['fileno'] = fileno
log.msg(
'multiplex: switched to file #%s '
'(%s)' % (recordContext['keys'][fileno],
recordContext['dirmap'][recordContext['keys'][fileno]]))
return context['origOid'], tag, context['origValue']
else:
return context['origOid'], tag, context['errorStatus']
if 'control' in recordContext['settings']:
if 'fileno' not in moduleContext[oid]:
moduleContext[oid]['fileno'] = 0
if (not context['nextFlag'] and
recordContext['settings']['control'] == context['origOid']):
val = rfc1902.Integer32(moduleContext[oid]['fileno'])
return context['origOid'], tag, val
else:
period = recordContext['settings']['period']
uptime = time.time() - moduleContext['booted']
timeslot = uptime % (period * len(recordContext['dirmap']))
fileslot = int(timeslot / period) + recordContext['bounds'][0]
fileno = bisect.bisect(recordContext['keys'], fileslot) - 1
if ('fileno' not in moduleContext[oid] or
moduleContext[oid]['fileno'] < fileno or
recordContext['settings']['wrap']):
moduleContext[oid]['fileno'] = fileno
datafile = recordContext['dirmap'][
recordContext['keys'][moduleContext[oid]['fileno']]]
if ('datafile' not in moduleContext[oid] or
moduleContext[oid]['datafile'] != datafile):
if 'datafileobj' in moduleContext[oid]:
moduleContext[oid]['datafileobj'].close()
recordIndex = RecordIndex(datafile, SnmprecRecord()).create()
moduleContext[oid]['datafileobj'] = recordIndex
moduleContext[oid]['datafile'] = datafile
log.msg(
'multiplex: switching to data file %s for '
'%s' % (datafile, context['origOid']))
text, db = moduleContext[oid]['datafileobj'].getHandles()
textOid = str(rfc1902.OctetString(
'.'.join(['%s' % x for x in context['origOid']])))
try:
line = moduleContext[oid]['datafileobj'].lookup(textOid)
except KeyError:
offset = searchRecordByOid(context['origOid'], text, SnmprecRecord())
exactMatch = False
else:
offset, subtreeFlag, prevOffset = line.split(str2octs(','))
exactMatch = True
text.seek(int(offset))
line, _, _ = getRecord(text) # matched line
if context['nextFlag']:
if exactMatch:
line, _, _ = getRecord(text)
else:
if not exactMatch:
return context['origOid'], tag, context['errorStatus']
if not line:
return context['origOid'], tag, context['errorStatus']
try:
oid, value = SnmprecRecord().evaluate(line)
except error.SnmpsimError:
oid, value = context['origOid'], context['errorStatus']
return oid, tag, value
'.'.join([x.strip() for x in str(resultset[0]).split('.')])
)
sqlOid = '.'.join(['%10s' % x for x in str(origOid).split('.')])
else:
cursor.close()
return origOid, tag, context['errorStatus']
cursor.execute('select tag, value from %s where oid=\'%s\' limit 1' % (dbTable, sqlOid))
resultset = cursor.fetchone()
cursor.close()
if resultset:
try:
value_settings = {}
value_settings = \
dict([split(x, '=') for x in split(resultset[1], ',')])
print value_settings
if 'mode' in value_settings:
return origOid, str(resultset[0]), str(value_settings['value'])
except:
pass
return origOid, str(resultset[0]), str(resultset[1])
else:
return origOid, tag, context['errorStatus']
def shutdown(**context):
dbConn = moduleContext.get('dbConn')
if dbConn:
if 'mode' in context and context['mode'] == 'recording':
dbConn.commit()
dbConn.close()
def variate(oid, tag, value, **context):
if 'dbConn' in moduleContext:
dbConn = moduleContext['dbConn']
else:
raise error.SnmpsimError('variation module not initialized')
cursor = dbConn.cursor()
try:
cursor.execute('set session transaction isolation level %s' %
moduleContext['isolationLevel'])
cursor.fetchall()
except: # non-MySQL/Postgres
pass
if value:
dbTable = value.split(',').pop(0)
elif 'dbTable' in moduleContext:
dbTable = moduleContext['dbTable']
else:
log.msg('SQL table not specified for OID %s' % (context['origOid'], ))
return context['origOid'], tag, context['errorStatus']
origOid = context['origOid']
sqlOid = '.'.join(['%10s' % x for x in str(origOid).split('.')])
if context['setFlag']:
if 'hexvalue' in context:
textTag = context['hextag']
textValue = context['hexvalue']
else:
textTag = SnmprecGrammar().getTagByType(context['origValue'])
textValue = str(context['origValue'])
cursor.execute(
'select maxaccess,tag,value from %s where oid=\'%s\' limit 1' %
(dbTable, sqlOid))
resultset = cursor.fetchone()
if resultset:
maxaccess = resultset[0]
if maxaccess != 'read-write':
return origOid, tag, context['errorStatus']
value_written = textValue
try:
value_settings = {}
value_settings = dict(
[split(x, '=') for x in split(resultset[2], ',')])
print value_settings
# if detected error mode, raise an error
if 'mode' in value_settings and \
value_settings['mode'] == 'error':
raise Error.WrongValueError(
name=origOid,
idx=max(
0, context['varsTotal'] -
context['varsRemaining'] - 1))
elif 'mode' in value_settings and \
value_settings['mode'] == 'normal':
value_written = "mode=" + value_settings['mode'] + \
",value=" + textValue
else:
return origOid, tag, context['errorStatus']
except Error.WrongValueError:
cursor.close()
raise Error.WrongValueError(name=origOid,
idx=max(
0, context['varsTotal'] -
context['varsRemaining'] - 1))
except:
pass
cursor.execute(
'update %s set tag=\'%s\',value=\'%s\' where oid=\'%s\'' %
(dbTable, textTag, value_written, sqlOid))
inform = moduleContext.get('inform')
try:
value = str(origOid) + " " + textValue
written_len = os.write(inform, value)
if written_len != len(value):
log.msg(
"--->Infrasim: Expected length %d, actual length %d\n"
% (len(str(origOid)), written_len))
cursor.close()
return origOid, tag, context['errorStatus']
except Exception, ex:
log.msg("--->Infrasim: {0}".format(ex))
cursor.close()
return origOid, tag, context['errorStatus']
else:
cursor.close()
raise Error.NoSuchInstanceError(
name=origOid,
idx=max(0,
context['varsTotal'] - context['varsRemaining'] - 1))
if context['varsRemaining'] == 0: # last OID in PDU
dbConn.commit()
cursor.close()
return origOid, textTag, context['origValue']
def variate(oid, tag, value, **context):
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if context['setFlag']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict(
[split(x, '=') for x in split(value, ',')])
for k in recordContext['settings']:
if k != 'function':
recordContext['settings'][k] = float(
recordContext['settings'][k])
if 'min' not in recordContext['settings']:
recordContext['settings']['min'] = 0
if 'max' not in recordContext['settings']:
if tag == '70':
recordContext['settings']['max'] = 0xffffffffffffffff
else:
recordContext['settings']['max'] = 0xffffffff
if 'rate' not in recordContext['settings']:
recordContext['settings']['rate'] = 1
if 'function' in recordContext['settings']:
f = split(recordContext['settings']['function'], '%')
recordContext['settings']['function'] = getattr(math, f[0]), f[1:]
else:
recordContext['settings']['function'] = lambda x: x, ()
vold, told = recordContext['settings'].get(
'initial', recordContext['settings']['min']), tboot
if 'cumulative' in recordContext['settings']:
if 'value' not in recordContext:
recordContext['value'] = vold, told
vold, told = recordContext['value']
tnow = time.time()
if 'atime' in recordContext['settings']:
t = tnow
else:
t = tnow - tboot
f, args = recordContext['settings']['function']
_args = []
if args:
for x in args:
if x == '<time>':
_args.append(t * recordContext['settings']['rate'])
else:
_args.append(float(x))
else:
_args.append(t * recordContext['settings']['rate'])
v = f(*_args)
if 'scale' in recordContext['settings']:
v *= recordContext['settings']['scale']
if 'offset' in recordContext['settings']:
if 'cumulative' in recordContext['settings']:
v += recordContext['settings']['offset'] * (
tnow - told) * recordContext['settings']['rate']
else:
v += recordContext['settings']['offset']
if 'deviation' in recordContext['settings'] and recordContext['settings'][
'deviation']:
v += random.randrange(-recordContext['settings']['deviation'],
recordContext['settings']['deviation'])
if 'cumulative' in recordContext['settings']:
v = max(v, 0)
v += vold
if v < recordContext['settings']['min']:
v = recordContext['settings']['min']
elif v > recordContext['settings']['max']:
if 'wrap' in recordContext['settings']:
v %= recordContext['settings']['max']
v += recordContext['settings']['min']
else:
v = recordContext['settings']['max']
if 'cumulative' in recordContext['settings']:
recordContext['value'] = v, tnow
return oid, tag, v
def record(oid, tag, value, **context):
if 'started' not in moduleContext:
moduleContext['started'] = time.time()
if 'iterations' not in moduleContext:
moduleContext['iterations'] = min(
1, moduleContext['settings'].get('iterations', 0))
# single-run recording
iterations = moduleContext['settings'].get('iterations')
if not iterations:
if context['origValue'].tagSet not in INTEGER_TYPES:
if 'hextag' in context:
tag = context['hextag']
if 'hexvalue' in context:
value = context['hexvalue']
return oid, tag, value
if ('taglist' not in moduleContext['settings'] or
tag not in moduleContext['settings']['taglist']):
return oid, tag, value
value = 'initial=%s' % value
if context['origValue'].tagSet == rfc1902.TimeTicks.tagSet:
value += ',rate=100'
elif context['origValue'].tagSet == rfc1902.Integer.tagSet:
value += ',rate=0'
return oid, tag + ':numeric', value
# multiple-iteration recording
if oid not in moduleContext:
settings = {
'initial': value
}
if context['origValue'].tagSet == rfc1902.TimeTicks.tagSet:
settings['rate'] = 100
elif context['origValue'].tagSet == rfc1902.Integer.tagSet:
settings['rate'] = 0 # may be constants
if 'addon' in moduleContext['settings']:
settings.update(
dict([split(x, '=')
for x in moduleContext['settings']['addon']]))
moduleContext[oid] = {}
moduleContext[oid]['settings'] = settings
if moduleContext['iterations']:
if context['stopFlag']: # switching to final iteration
log.msg('numeric: %s iterations '
'remaining' % moduleContext['iterations'])
moduleContext['iterations'] -= 1
moduleContext['started'] = time.time()
running = time.time() - moduleContext['started']
wait = max(0, float(moduleContext['settings']['period']) - running)
raise error.MoreDataNotification(period=wait)
else: # storing values on first iteration
moduleContext[oid]['time'] = time.time()
moduleContext[oid]['value'] = context['origValue']
if 'hexvalue' in moduleContext[oid]:
moduleContext[oid]['hexvalue'] = context['hexvalue']
if 'hextag' in moduleContext[oid]:
moduleContext[oid]['hextag'] = context['hextag']
raise error.NoDataNotification()
else:
if context['stopFlag']:
raise error.NoDataNotification()
if 'value' in moduleContext[oid]:
if context['origValue'].tagSet not in INTEGER_TYPES:
if 'hextag' in moduleContext[oid]:
tag = moduleContext[oid]['hextag']
if 'hexvalue' in moduleContext[oid]:
value = moduleContext[oid]['hexvalue']
return oid, tag, value
if tag not in moduleContext['settings']['taglist']:
return oid, tag, moduleContext[oid]['value']
diff = int(context['origValue']) - int(moduleContext[oid]['value'])
runtime = time.time() - moduleContext[oid]['time']
moduleContext[oid]['settings']['rate'] = diff / runtime
tag += ':numeric'
value = ','.join(
['%s=%s' % (k, v)
for k, v in moduleContext[oid]['settings'].items()])
return oid, tag, value
else:
raise error.NoDataNotification()
def variate(oid, tag, value, **context):
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict(
[split(x, '=') for x in split(value, ',')])
if 'hexvalue' in recordContext['settings']:
recordContext['settings']['value'] = [
int(recordContext['settings']['hexvalue'][x:x + 2], 16)
for x in range(0, len(recordContext['settings']['hexvalue']), 2)]
if 'wait' in recordContext['settings']:
recordContext['settings']['wait'] = float(
recordContext['settings']['wait'])
else:
recordContext['settings']['wait'] = 500.0
if 'deviation' in recordContext['settings']:
recordContext['settings']['deviation'] = float(
recordContext['settings']['deviation'])
else:
recordContext['settings']['deviation'] = 0.0
if 'vlist' in recordContext['settings']:
vlist = {}
recordContext['settings']['vlist'] = split(
recordContext['settings']['vlist'], ':')
while recordContext['settings']['vlist']:
o, v, d = recordContext['settings']['vlist'][:3]
recordContext['settings']['vlist'] = recordContext['settings']['vlist'][3:]
d = int(d)
typeTag, _ = SnmprecRecord.unpackTag(tag)
v = SnmprecGrammar.TAG_MAP[typeTag](v)
if o not in vlist:
vlist[o] = {}
if o == 'eq':
vlist[o][v] = d
elif o in ('lt', 'gt'):
vlist[o] = v, d
else:
log.msg('delay: bad vlist syntax: '
'%s' % recordContext['settings']['vlist'])
recordContext['settings']['vlist'] = vlist
if 'tlist' in recordContext['settings']:
tlist = {}
recordContext['settings']['tlist'] = split(
recordContext['settings']['tlist'], ':')
while recordContext['settings']['tlist']:
o, v, d = recordContext['settings']['tlist'][:3]
recordContext['settings']['tlist'] = recordContext['settings']['tlist'][3:]
v = int(v)
d = int(d)
if o not in tlist:
tlist[o] = {}
if o == 'eq':
tlist[o][v] = d
elif o in ('lt', 'gt'):
tlist[o] = v, d
else:
log.msg('delay: bad tlist syntax: '
'%s' % recordContext['settings']['tlist'])
recordContext['settings']['tlist'] = tlist
if context['setFlag'] and 'vlist' in recordContext['settings']:
if ('eq' in recordContext['settings']['vlist'] and
context['origValue'] in recordContext['settings']['vlist']['eq']):
delay = recordContext['settings']['vlist']['eq'][context['origValue']]
elif ('lt' in recordContext['settings']['vlist'] and
context['origValue'] < recordContext['settings']['vlist']['lt'][0]):
delay = recordContext['settings']['vlist']['lt'][1]
elif ('gt' in recordContext['settings']['vlist'] and
context['origValue'] > recordContext['settings']['vlist']['gt'][0]):
delay = recordContext['settings']['vlist']['gt'][1]
else:
delay = recordContext['settings']['wait']
elif 'tlist' in recordContext['settings']:
now = int(time.time())
if ('eq' in recordContext['settings']['tlist'] and
now == recordContext['settings']['tlist']['eq']):
delay = recordContext['settings']['tlist']['eq'][now]
elif ('lt' in recordContext['settings']['tlist'] and
now < recordContext['settings']['tlist']['lt'][0]):
delay = recordContext['settings']['tlist']['lt'][1]
elif ('gt' in recordContext['settings']['tlist'] and
now > recordContext['settings']['tlist']['gt'][0]):
delay = recordContext['settings']['tlist']['gt'][1]
else:
delay = recordContext['settings']['wait']
else:
delay = recordContext['settings']['wait']
if recordContext['settings']['deviation']:
delay += random.randrange(
-recordContext['settings']['deviation'],
recordContext['settings']['deviation'])
if delay < 0:
delay = 0
elif delay > 99999:
log.msg('delay: dropping response for %s' % oid)
raise error.NoDataNotification()
log.msg('delay: waiting %d milliseconds for %s' % (delay, oid))
time.sleep(delay / 1000) # ms
if context['setFlag'] or 'value' not in recordContext['settings']:
return oid, tag, context['origValue']
else:
return oid, tag, recordContext['settings']['value']
def variate(oid, tag, value, **context):
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict([split(x, '=') for x in split(value, ',')])
if 'vlist' in recordContext['settings']:
vlist = {}
recordContext['settings']['vlist'] = split(recordContext['settings']['vlist'], ':')
while recordContext['settings']['vlist']:
o,v,e = recordContext['settings']['vlist'][:3]
recordContext['settings']['vlist'] = recordContext['settings']['vlist'][3:]
v = SnmprecGrammar.tagMap[tag](v)
if o not in vlist:
vlist[o] = {}
if o == 'eq':
vlist[o][v] = e
elif o in ('lt', 'gt'):
vlist[o] = v, e
else:
log.msg('writecache: bad vlist syntax: %s' % recordContext['settings']['vlist'])
recordContext['settings']['vlist'] = vlist
if oid not in moduleContext:
moduleContext[oid] = {}
moduleContext[oid]['type'] = SnmprecGrammar().tagMap[tag]()
textOid = str(oid)
if context['setFlag']:
if 'vlist' in recordContext['settings']:
if 'eq' in recordContext['settings']['vlist'] and \
context['origValue'] in recordContext['settings']['vlist']['eq']:
e = recordContext['settings']['vlist']['eq'][context['origValue']]
elif 'lt' in recordContext['settings']['vlist'] and \
context['origValue']<recordContext['settings']['vlist']['lt'][0]:
e = recordContext['settings']['vlist']['lt'][1]
elif 'gt' in recordContext['settings']['vlist'] and \
context['origValue']>recordContext['settings']['vlist']['gt'][0]:
e = recordContext['settings']['vlist']['gt'][1]
else:
e = None
if e in errorTypes:
raise errorTypes[e](
name=oid, idx=max(0, context['varsTotal']-context['varsRemaining']-1)
)
if moduleContext[oid]['type'].isSameTypeWith(context['origValue']):
moduleContext['cache'][textOid] = context['origValue']
else:
return context['origOid'], tag, context['errorStatus']
if textOid in moduleContext['cache']:
return oid, tag, moduleContext['cache'][textOid]
elif 'hexvalue' in recordContext['settings']:
return oid, tag, moduleContext[oid]['type'].clone(hexValue=recordContext['settings']['hexvalue'])
elif 'value' in recordContext['settings']:
return oid, tag, moduleContext[oid]['type'].clone(recordContext['settings']['value'])
else:
return oid, tag, context['errorStatus']
sqlOid = '.'.join(
['%10s' % x for x in str(origOid).split('.')])
else:
cursor.close()
return origOid, tag, context['errorStatus']
cursor.execute('select tag, value from %s where oid=\'%s\' limit 1' %
(dbTable, sqlOid))
resultset = cursor.fetchone()
cursor.close()
if resultset:
try:
value_settings = {}
value_settings = \
dict([split(x, '=') for x in split(resultset[1], ',')])
print value_settings
if 'mode' in value_settings:
return origOid, str(resultset[0]), str(
value_settings['value'])
except:
pass
return origOid, str(resultset[0]), str(resultset[1])
else:
return origOid, tag, context['errorStatus']
def shutdown(**context):
dbConn = moduleContext.get('dbConn')
if dbConn:
if 'mode' in context and context['mode'] == 'recording':
def variate(oid, tag, value, **context):
if 'dbConn' in moduleContext:
dbConn = moduleContext['dbConn']
else:
raise error.SnmpsimError('variation module not initialized')
cursor = dbConn.cursor()
try:
cursor.execute(
'set session transaction isolation level %s' % moduleContext['isolationLevel']
)
cursor.fetchall()
except: # non-MySQL/Postgres
pass
if value:
dbTable = value.split(',').pop(0)
elif 'dbTable' in moduleContext:
dbTable = moduleContext['dbTable']
else:
log.msg('SQL table not specified for OID %s' % (context['origOid'],))
return context['origOid'], tag, context['errorStatus']
origOid = context['origOid']
sqlOid = '.'.join(['%10s' % x for x in str(origOid).split('.')])
if context['setFlag']:
if 'hexvalue' in context:
textTag = context['hextag']
textValue = context['hexvalue']
else:
textTag = SnmprecGrammar().getTagByType(context['origValue'])
textValue = str(context['origValue'])
cursor.execute(
'select maxaccess,tag,value from %s where oid=\'%s\' limit 1' % (dbTable, sqlOid)
)
resultset = cursor.fetchone()
if resultset:
maxaccess = resultset[0]
if maxaccess != 'read-write':
return origOid, tag, context['errorStatus']
value_written = textValue
try:
value_settings = {}
value_settings = dict([split(x, '=') for x in split(resultset[2], ',')])
print value_settings
# if detected error mode, raise an error
if 'mode' in value_settings and \
value_settings['mode'] == 'error':
raise Error.WrongValueError(name=origOid,
idx=max(0,
context['varsTotal'] - context['varsRemaining'] - 1))
elif 'mode' in value_settings and \
value_settings['mode'] == 'normal':
value_written = "mode=" + value_settings['mode'] + \
",value=" + textValue
else:
return origOid, tag, context['errorStatus']
except Error.WrongValueError:
cursor.close()
raise Error.WrongValueError(name=origOid,
idx=max(0, context['varsTotal'] - context['varsRemaining'] - 1))
except:
pass
cursor.execute(
'update %s set tag=\'%s\',value=\'%s\' where oid=\'%s\'' %
(dbTable, textTag, value_written, sqlOid)
)
inform = moduleContext.get('inform')
try:
value = str(origOid) + " " + textValue
written_len = os.write(inform, value)
if written_len != len(value):
log.msg("--->Infrasim: Expected length %d, actual length %d\n" % (len(str(origOid)), written_len))
cursor.close()
return origOid, tag, context['errorStatus']
except Exception, ex:
log.msg("--->Infrasim: {0}".format(ex))
cursor.close()
return origOid, tag, context['errorStatus']
else:
cursor.close()
raise Error.NoSuchInstanceError(name=origOid,
idx=max(0, context['varsTotal'] - context['varsRemaining'] - 1))
if context['varsRemaining'] == 0: # last OID in PDU
dbConn.commit()
cursor.close()
return origOid, textTag, context['origValue']
def record(oid, tag, value, **context):
if 'started' not in moduleContext:
moduleContext['started'] = time.time()
if 'iterations' not in moduleContext:
moduleContext['iterations'] = min(
1, moduleContext['settings'].get('iterations', 0))
# single-run recording
if 'iterations' not in moduleContext[
'settings'] or not moduleContext['settings']['iterations']:
if context['origValue'].tagSet not in (rfc1902.Counter32.tagSet,
rfc1902.Counter64.tagSet,
rfc1902.TimeTicks.tagSet,
rfc1902.Gauge32.tagSet,
rfc1902.Integer.tagSet):
if 'hextag' in context:
tag = context['hextag']
if 'hexvalue' in context:
value = context['hexvalue']
return oid, tag, value
if 'taglist' not in moduleContext['settings'] or \
tag not in moduleContext['settings']['taglist']:
return oid, tag, value
value = 'initial=%s' % value
if context['origValue'].tagSet == rfc1902.TimeTicks.tagSet:
value += ',rate=100'
elif context['origValue'].tagSet == rfc1902.Integer.tagSet:
value += ',rate=0'
return oid, tag + ':numeric', value
# multiple-iteration recording
if oid not in moduleContext:
settings = {'initial': value}
if context['origValue'].tagSet == rfc1902.TimeTicks.tagSet:
settings['rate'] = 100
elif context['origValue'].tagSet == rfc1902.Integer.tagSet:
settings['rate'] = 0 # may be constants
if 'addon' in moduleContext['settings']:
settings.update(
dict([
split(x, '=') for x in moduleContext['settings']['addon']
]))
moduleContext[oid] = {}
moduleContext[oid]['settings'] = settings
if moduleContext['iterations']:
if context['stopFlag']: # switching to final iteration
log.msg('numeric: %s iterations remaining' %
moduleContext['settings']['iterations'])
moduleContext['iterations'] -= 1
moduleContext['started'] = time.time()
wait = max(
0,
float(moduleContext['settings']['period']) -
(time.time() - moduleContext['started']))
raise error.MoreDataNotification(period=wait)
else: # storing values on first iteration
moduleContext[oid]['time'] = time.time()
moduleContext[oid]['value'] = context['origValue']
if 'hexvalue' in moduleContext[oid]:
moduleContext[oid]['hexvalue'] = context['hexvalue']
if 'hextag' in moduleContext[oid]:
moduleContext[oid]['hextag'] = context['hextag']
raise error.NoDataNotification()
else:
if context['stopFlag']:
raise error.NoDataNotification()
if 'value' in moduleContext[oid]:
if context['origValue'].tagSet not in (rfc1902.Counter32.tagSet,
rfc1902.Counter64.tagSet,
rfc1902.TimeTicks.tagSet,
rfc1902.Gauge32.tagSet,
rfc1902.Integer.tagSet):
if 'hextag' in moduleContext[oid]:
tag = moduleContext[oid]['hextag']
if 'hexvalue' in moduleContext[oid]:
value = moduleContext[oid]['hexvalue']
return oid, tag, value
if tag not in moduleContext['settings']['taglist']:
return oid, tag, moduleContext[oid]['value']
moduleContext[oid]['settings']['rate'] = (int(
context['origValue']) - int(moduleContext[oid]['value'])) / (
time.time() - moduleContext[oid]['time'])
tag += ':numeric'
value = ','.join([
'%s=%s' % (k, v)
for k, v in moduleContext[oid]['settings'].items()
])
return oid, tag, value
else:
raise error.NoDataNotification()
def variate(oid, tag, value, **context):
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict([split(x, '=') for x in split(value, ',')])
if 'vlist' in recordContext['settings']:
vlist = {}
recordContext['settings']['vlist'] = split(
recordContext['settings']['vlist'], ':')
while recordContext['settings']['vlist']:
o, v, e = recordContext['settings']['vlist'][:3]
vl = recordContext['settings']['vlist'][3:]
recordContext['settings']['vlist'] = vl
typeTag, _ = SnmprecRecord.unpackTag(tag)
v = SnmprecGrammar.TAG_MAP[typeTag](v)
if o not in vlist:
vlist[o] = {}
if o == 'eq':
vlist[o][v] = e
elif o in ('lt', 'gt'):
vlist[o] = v, e
else:
log.msg('writecache: bad vlist syntax: '
'%s' % recordContext['settings']['vlist'])
recordContext['settings']['vlist'] = vlist
if 'status' in recordContext['settings']:
st = recordContext['settings']['status'].lower()
recordContext['settings']['status'] = st
if oid not in moduleContext:
moduleContext[oid] = {}
typeTag, _ = SnmprecRecord.unpackTag(tag)
moduleContext[oid]['type'] = SnmprecGrammar.TAG_MAP[typeTag]()
textOid = str(oid)
if context['setFlag']:
if 'vlist' in recordContext['settings']:
if ('eq' in recordContext['settings']['vlist'] and
context['origValue'] in recordContext['settings']['vlist']['eq']):
e = recordContext['settings']['vlist']['eq'][context['origValue']]
elif ('lt' in recordContext['settings']['vlist'] and
context['origValue'] < recordContext['settings']['vlist']['lt'][0]):
e = recordContext['settings']['vlist']['lt'][1]
elif ('gt' in recordContext['settings']['vlist'] and
context['origValue'] > recordContext['settings']['vlist']['gt'][0]):
e = recordContext['settings']['vlist']['gt'][1]
else:
e = None
if e in ERROR_TYPES:
idx = max(0, context['varsTotal'] - context['varsRemaining'] - 1)
raise ERROR_TYPES[e](name=oid, idx=idx)
if moduleContext[oid]['type'].isSameTypeWith(context['origValue']):
moduleContext['cache'][textOid] = context['origValue']
else:
return context['origOid'], tag, context['errorStatus']
if 'status' in recordContext['settings']:
if ('op' not in recordContext['settings'] or
recordContext['settings']['op'] == 'any' or
recordContext['settings']['op'] == 'set' and context['setFlag'] or
recordContext['settings']['op'] == 'get' and not context['setFlag']):
e = recordContext['settings']['status']
if e in ERROR_TYPES:
idx = max(0, context['varsTotal'] - context['varsRemaining'] - 1)
raise ERROR_TYPES[e](name=oid, idx=idx)
if textOid in moduleContext['cache']:
return oid, tag, moduleContext['cache'][textOid]
elif 'hexvalue' in recordContext['settings']:
return oid, tag, moduleContext[oid]['type'].clone(
hexValue=recordContext['settings']['hexvalue'])
elif 'value' in recordContext['settings']:
return oid, tag, moduleContext[oid]['type'].clone(
recordContext['settings']['value'])
else:
return oid, tag, context['errorStatus']
def record(oid, tag, value, **context):
if 'ready' not in moduleContext:
raise error.SnmpsimError('module not initialized')
if 'dbConn' in moduleContext:
dbConn = moduleContext['dbConn']
else:
raise error.SnmpsimError('variation module not initialized')
if 'started' not in moduleContext:
moduleContext['started'] = time.time()
redisScript = moduleContext.get('evalsha')
keySpace = '%.10d' % (moduleContext['key-spaces-id'] +
moduleContext.get('iterations', 0))
if context['stopFlag']:
dbConn.sort(keySpace + '-' + 'temp_oids_ordering',
store=keySpace + '-' + 'oids_ordering',
alpha=True)
dbConn.delete(keySpace + '-' + 'temp_oids_ordering')
dbConn.rpush(moduleContext['key-spaces-id'], keySpace)
log.msg('redis: done with key-space %s' % keySpace)
if 'iterations' in moduleContext and moduleContext['iterations']:
log.msg('redis: %s iterations remaining' %
moduleContext['iterations'])
moduleContext['started'] = time.time()
moduleContext['iterations'] -= 1
runtime = time.time() - moduleContext['started']
wait = max(0, moduleContext['period'] - runtime)
raise error.MoreDataNotification(period=wait)
else:
raise error.NoDataNotification()
dbOid = '.'.join(['%10s' % x for x in oid.split('.')])
if 'hexvalue' in context:
textTag = context['hextag']
textValue = context['hexvalue']
else:
textTag = SnmprecGrammar().getTagByType(context['origValue'])
textValue = str(context['origValue'])
dbConn.lpush(keySpace + '-temp_oids_ordering', keySpace + '-' + dbOid)
if redisScript:
dbConn.evalsha(redisScript, 1, keySpace + '-' + dbOid,
textTag + '|' + textValue)
else:
dbConn.set(keySpace + '-' + dbOid, textTag + '|' + textValue)
if not context['count']:
settings = {'key-spaces-id': moduleContext['key-spaces-id']}
if 'period' in moduleContext:
settings['period'] = '%.2f' % float(moduleContext['period'])
if 'addon' in moduleContext:
settings.update(
dict([split(x, '=') for x in moduleContext['addon']]))
value = ','.join(['%s=%s' % (k, v) for k, v in settings.items()])
return str(context['startOID']), ':redis', value
else:
raise error.NoDataNotification()
def variate(oid, tag, value, **context):
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if context['setFlag']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict(
[split(x, '=') for x in split(value, ',')])
for k in recordContext['settings']:
if k != 'function':
recordContext['settings'][k] = float(recordContext['settings'][k])
if 'min' not in recordContext['settings']:
recordContext['settings']['min'] = 0
if 'max' not in recordContext['settings']:
if tag == '70':
recordContext['settings']['max'] = 0xffffffffffffffff
else:
recordContext['settings']['max'] = 0xffffffff
if 'rate' not in recordContext['settings']:
recordContext['settings']['rate'] = 1
if 'function' in recordContext['settings']:
f = split(recordContext['settings']['function'], '%')
recordContext['settings']['function'] = getattr(math, f[0]), f[1:]
else:
recordContext['settings']['function'] = lambda x: x, ()
vold, told = recordContext['settings'].get(
'initial', recordContext['settings']['min']), BOOTED
if 'cumulative' in recordContext['settings']:
if 'value' not in recordContext:
recordContext['value'] = vold, told
vold, told = recordContext['value']
tnow = time.time()
if 'atime' in recordContext['settings']:
t = tnow
else:
t = tnow - BOOTED
f, args = recordContext['settings']['function']
_args = []
if args:
for x in args:
if x == '<time>':
_args.append(t * recordContext['settings']['rate'])
else:
_args.append(float(x))
else:
_args.append(t * recordContext['settings']['rate'])
v = f(*_args)
if 'scale' in recordContext['settings']:
v *= recordContext['settings']['scale']
if 'offset' in recordContext['settings']:
if 'cumulative' in recordContext['settings']:
rate = recordContext['settings']['rate']
v += recordContext['settings']['offset'] * (tnow - told) * rate
else:
v += recordContext['settings']['offset']
deviation = recordContext['settings'].get('deviation')
if deviation:
v += random.randrange(-deviation, deviation)
if 'cumulative' in recordContext['settings']:
v = max(v, 0)
v += vold
if v < recordContext['settings']['min']:
v = recordContext['settings']['min']
elif v > recordContext['settings']['max']:
if 'wrap' in recordContext['settings']:
v %= recordContext['settings']['max']
v += recordContext['settings']['min']
else:
v = recordContext['settings']['max']
if 'cumulative' in recordContext['settings']:
recordContext['value'] = v, tnow
return oid, tag, v
def variate(oid, tag, value, **context):
if 'dbConn' in moduleContext:
dbConn = moduleContext['dbConn']
else:
raise error.SnmpsimError('variation module not initialized')
if 'settings' not in recordContext:
settings = recordContext['settings'] = dict(
[split(x, '=') for x in split(value, ',')])
if 'key-spaces-id' not in settings:
log.msg('redis:mandatory key-spaces-id option is missing')
return context['origOid'], tag, context['errorStatus']
settings['period'] = float(settings.get('period', 60))
if 'evalsha' in settings:
if not dbConn.script_exists(settings['evalsha']):
log.msg('redis: lua script %s does not exist '
'at Redis' % settings['evalsha'])
return context['origOid'], tag, context['errorStatus']
recordContext['ready'] = True
if 'ready' not in recordContext:
return context['origOid'], tag, context['errorStatus']
redisScript = recordContext['settings'].get('evalsha')
keySpacesId = recordContext['settings']['key-spaces-id']
if recordContext['settings']['period']:
booted = time.time() - moduleContext['booted']
slot = int(
dbConn.llen(keySpacesId)) // recordContext['settings']['period']
keySpaceIdx = int(booted) % (recordContext['settings']['period'] *
slot)
else:
keySpaceIdx = 0
keySpace = dbConn.lindex(keySpacesId, keySpaceIdx)
if ('current-keyspace' not in recordContext
or recordContext['current-keyspace'] != keySpace):
log.msg(
'redis: now using keyspace %s (cycling period'
' %s)' %
(keySpace, recordCoentext['settings']['period'] or '<disabled>'))
recordContext['current-keyspace'] = keySpace
if keySpace is None:
return origOid, tag, context['errorStatus']
origOid = context['origOid']
dbOid = '.'.join(['%10s' % x for x in str(origOid).split('.')])
if context['setFlag']:
if 'hexvalue' in context:
textTag = context['hextag']
textValue = context['hexvalue']
else:
textTag = SnmprecGrammar().getTagByType(context['origValue'])
textValue = str(context['origValue'])
if redisScript:
prevTagAndValue = dbConn.evalsha(redisScript, 1,
keySpace + '-' + dbOid)
else:
prevTagAndValue = dbConn.get(keySpace + '-' + dbOid)
if prevTagAndValue:
prevTag, prevValue = prevTagAndValue.split('|')
if unpackTag(prevTag)[0] != unpackTag(textTag)[0]:
idx = max(0,
context['varsTotal'] - context['varsRemaining'] - 1)
raise WrongValueError(name=origOid, idx=idx)
else:
dbConn.linsert(keySpace + '-oids_ordering', 'after',
getNextOid(dbConn, keySpace, dbOid), dbOid)
if redisScript:
dbConn.evalsha(redisScript, 1, keySpace + '-' + dbOid,
textTag + '|' + textValue)
else:
dbConn.set(keySpace + '-' + dbOid, textTag + '|' + textValue)
return origOid, textTag, context['origValue']
else:
if context['nextFlag']:
textOid = dbConn.lindex(
keySpace + '-oids_ordering',
getNextOid(dbConn, keySpace, dbOid, index=True))
else:
textOid = keySpace + '-' + dbOid
if redisScript:
tagAndValue = dbConn.evalsha(redisScript, 1, textOid)
else:
tagAndValue = dbConn.get(textOid)
if not tagAndValue:
return origOid, tag, context['errorStatus']
textOid = '.'.join(
[x.strip() for x in textOid.split('-', 1)[1].split('.')])
textTag, textValue = tagAndValue.split('|', 1)
return textOid, textTag, textValue
def variate(oid, tag, value, **context):
if not context['nextFlag'] and not context['exactMatch']:
return context['origOid'], tag, context['errorStatus']
if 'settings' not in recordContext:
recordContext['settings'] = dict(
[split(x, '=') for x in split(value, ',')])
if 'hexvalue' in recordContext['settings']:
recordContext['settings']['value'] = [
int(recordContext['settings']['hexvalue'][x:x + 2],
16) for x in range(
0, len(recordContext['settings']['hexvalue']), 2)
]
if 'status' in recordContext['settings']:
recordContext['settings']['status'] = recordContext['settings'][
'status'].lower()
if 'op' not in recordContext['settings']:
recordContext['settings']['op'] = 'any'
if 'vlist' in recordContext['settings']:
vlist = {}
recordContext['settings']['vlist'] = split(
recordContext['settings']['vlist'], ':')
while recordContext['settings']['vlist']:
o, v, e = recordContext['settings']['vlist'][:3]
recordContext['settings']['vlist'] = recordContext['settings'][
'vlist'][3:]
typeTag, _ = SnmprecRecord.unpackTag(tag)
v = SnmprecGrammar.tagMap[typeTag](v)
if o not in vlist:
vlist[o] = {}
if o == 'eq':
vlist[o][v] = e
elif o in ('lt', 'gt'):
vlist[o] = v, e
else:
log.msg('error: bad vlist syntax: %s' %
recordContext['settings']['vlist'])
recordContext['settings']['vlist'] = vlist
e = None
if context['setFlag']:
if 'vlist' in recordContext['settings']:
if ('eq' in recordContext['settings']['vlist']
and context['origValue']
in recordContext['settings']['vlist']['eq']):
e = recordContext['settings']['vlist']['eq'][
context['origValue']]
elif ('lt' in recordContext['settings']['vlist']
and context['origValue'] <
recordContext['settings']['vlist']['lt'][0]):
e = recordContext['settings']['vlist']['lt'][1]
elif ('gt' in recordContext['settings']['vlist']
and context['origValue'] >
recordContext['settings']['vlist']['gt'][0]):
e = recordContext['settings']['vlist']['gt'][1]
elif recordContext['settings']['op'] in ('set', 'any'):
if 'status' in recordContext['settings']:
e = recordContext['settings']['status']
else:
if recordContext['settings']['op'] in ('get', 'any'):
if 'status' in recordContext['settings']:
e = recordContext['settings']['status']
if e and e in errorTypes:
log.msg('error: reporting %s for %s' % (e, oid))
raise errorTypes[e](
name=oid,
idx=max(0, context['varsTotal'] - context['varsRemaining'] - 1))
if context['setFlag']:
recordContext['settings']['value'] = context['origValue']
return oid, tag, recordContext['settings'].get('value',
context['errorStatus'])
def variate(oid, tag, value, **context):
if 'settings' not in recordContext:
recordContext['settings'] = dict(
[split(x, '=') for x in split(value, ',')])
if 'dir' not in recordContext['settings']:
log.msg('multiplex: snapshot directory not specified')
return context['origOid'], tag, context['errorStatus']
recordContext['settings']['dir'] = recordContext['settings'][
'dir'].replace('/', os.path.sep)
if recordContext['settings']['dir'][0] != os.path.sep:
for x in confdir.data:
d = os.path.join(x, recordContext['settings']['dir'])
if os.path.exists(d):
break
else:
log.msg('multiplex: directory %s not found' %
recordContext['settings']['dir'])
return context['origOid'], tag, context['errorStatus']
else:
d = recordContext['settings']['dir']
recordContext['dirmap'] = dict([
(int(os.path.basename(x).split(os.path.extsep)[0]),
os.path.join(d, x)) for x in os.listdir(d) if x[-7:] == 'snmprec'
])
recordContext['keys'] = list(recordContext['dirmap'].keys())
recordContext['bounds'] = (min(recordContext['keys']),
max(recordContext['keys']))
if 'period' in recordContext['settings']:
recordContext['settings']['period'] = float(
recordContext['settings']['period'])
else:
recordContext['settings']['period'] = 60.0
if 'wrap' in recordContext['settings']:
recordContext['settings']['wrap'] = bool(
recordContext['settings']['wrap'])
else:
recordContext['settings']['wrap'] = False
if 'control' in recordContext['settings']:
recordContext['settings']['control'] = rfc1902.ObjectName(
recordContext['settings']['control'])
log.msg(
'multiplex: using control OID %s for subtree %s, time-based multiplexing disabled'
% (recordContext['settings']['control'], oid))
recordContext['ready'] = True
if 'ready' not in recordContext:
return context['origOid'], tag, context['errorStatus']
if oid not in moduleContext:
moduleContext[oid] = {}
if context['setFlag']:
if 'control' in recordContext['settings'] and \
recordContext['settings']['control'] == context['origOid']:
fileno = int(context['origValue'])
if fileno >= len(recordContext['keys']):
log.msg('multiplex: .snmprec file number %s over limit of %s' %
(fileno, len(recordContext['keys'])))
return context['origOid'], tag, context['errorStatus']
moduleContext[oid]['fileno'] = fileno
log.msg('multiplex: switched to file #%s (%s)' %
(recordContext['keys'][fileno],
recordContext['dirmap'][recordContext['keys'][fileno]]))
return context['origOid'], tag, context['origValue']
else:
return context['origOid'], tag, context['errorStatus']
if 'control' in recordContext['settings']:
if 'fileno' not in moduleContext[oid]:
moduleContext[oid]['fileno'] = 0
if (not context['nextFlag'] and recordContext['settings']['control']
== context['origOid']):
return context['origOid'], tag, rfc1902.Integer32(
moduleContext[oid]['fileno'])
else:
timeslot = (time.time() - moduleContext['booted']) % (
recordContext['settings']['period'] * len(recordContext['dirmap']))
fileslot = int(
timeslot /
recordContext['settings']['period']) + recordContext['bounds'][0]
fileno = bisect.bisect(recordContext['keys'], fileslot) - 1
if ('fileno' not in moduleContext[oid]
or moduleContext[oid]['fileno'] < fileno
or recordContext['settings']['wrap']):
moduleContext[oid]['fileno'] = fileno
datafile = recordContext['dirmap'][recordContext['keys'][moduleContext[oid]
['fileno']]]
if ('datafile' not in moduleContext[oid]
or moduleContext[oid]['datafile'] != datafile):
if 'datafileobj' in moduleContext[oid]:
moduleContext[oid]['datafileobj'].close()
moduleContext[oid]['datafileobj'] = RecordIndex(
datafile, SnmprecRecord()).create()
moduleContext[oid]['datafile'] = datafile
log.msg('multiplex: switching to data file %s for %s' %
(datafile, context['origOid']))
text, db = moduleContext[oid]['datafileobj'].getHandles()
textOid = str(
rfc1902.OctetString('.'.join(['%s' % x for x in context['origOid']])))
try:
line = moduleContext[oid]['datafileobj'].lookup(textOid)
except KeyError:
offset = searchRecordByOid(context['origOid'], text, SnmprecRecord())
exactMatch = False
else:
offset, subtreeFlag, prevOffset = line.split(str2octs(','))
exactMatch = True
text.seek(int(offset))
line, _, _ = getRecord(text) # matched line
if context['nextFlag']:
if exactMatch:
line, _, _ = getRecord(text)
else:
if not exactMatch:
return context['origOid'], tag, context['errorStatus']
if not line:
return context['origOid'], tag, context['errorStatus']
try:
oid, value = SnmprecRecord().evaluate(line)
except error.SnmpsimError:
oid, value = context['origOid'], context['errorStatus']
return oid, tag, value
def variate(oid, tag, value, **context):
if 'dbConn' in moduleContext:
dbConn = moduleContext['dbConn']
else:
raise error.SnmpsimError('variation module not initialized')
if 'settings' not in recordContext:
settings = recordContext['settings'] = dict(
[split(x, '=') for x in split(value, ',')])
if 'key-spaces-id' not in settings:
log.msg('redis:mandatory key-spaces-id option is missing')
return context['origOid'], tag, context['errorStatus']
settings['period'] = float(settings.get('period', 60))
if 'evalsha' in settings:
if not dbConn.script_exists(settings['evalsha']):
log.msg('redis: lua script %s does not exist '
'at Redis' % settings['evalsha'])
return context['origOid'], tag, context['errorStatus']
recordContext['ready'] = True
if 'ready' not in recordContext:
return context['origOid'], tag, context['errorStatus']
redisScript = recordContext['settings'].get('evalsha')
keySpacesId = recordContext['settings']['key-spaces-id']
if recordContext['settings']['period']:
booted = time.time() - moduleContext['booted']
slot = int(dbConn.llen(keySpacesId)) // recordContext['settings']['period']
keySpaceIdx = int(booted) % (recordContext['settings']['period'] * slot)
else:
keySpaceIdx = 0
keySpace = dbConn.lindex(keySpacesId, keySpaceIdx)
if ('current-keyspace' not in recordContext or
recordContext['current-keyspace'] != keySpace):
log.msg('redis: now using keyspace %s (cycling period'
' %s)' % (
keySpace, recordCoentext['settings']['period'] or '<disabled>'))
recordContext['current-keyspace'] = keySpace
if keySpace is None:
return origOid, tag, context['errorStatus']
origOid = context['origOid']
dbOid = '.'.join(['%10s' % x for x in str(origOid).split('.')])
if context['setFlag']:
if 'hexvalue' in context:
textTag = context['hextag']
textValue = context['hexvalue']
else:
textTag = SnmprecGrammar().getTagByType(context['origValue'])
textValue = str(context['origValue'])
if redisScript:
prevTagAndValue = dbConn.evalsha(redisScript, 1, keySpace + '-' + dbOid)
else:
prevTagAndValue = dbConn.get(keySpace + '-' + dbOid)
if prevTagAndValue:
prevTag, prevValue = prevTagAndValue.split('|')
if unpackTag(prevTag)[0] != unpackTag(textTag)[0]:
idx = max(0, context['varsTotal'] - context['varsRemaining'] - 1)
raise WrongValueError(name=origOid, idx=idx)
else:
dbConn.linsert(
keySpace + '-oids_ordering', 'after',
getNextOid(dbConn, keySpace, dbOid), dbOid)
if redisScript:
dbConn.evalsha(redisScript, 1, keySpace + '-' + dbOid,
textTag + '|' + textValue)
else:
dbConn.set(keySpace + '-' + dbOid, textTag + '|' + textValue)
return origOid, textTag, context['origValue']
else:
if context['nextFlag']:
textOid = dbConn.lindex(
keySpace + '-oids_ordering',
getNextOid(dbConn, keySpace, dbOid, index=True))
else:
textOid = keySpace + '-' + dbOid
if redisScript:
tagAndValue = dbConn.evalsha(redisScript, 1, textOid)
else:
tagAndValue = dbConn.get(textOid)
if not tagAndValue:
return origOid, tag, context['errorStatus']
textOid = '.'.join(
[x.strip() for x in textOid.split('-', 1)[1].split('.')])
textTag, textValue = tagAndValue.split('|', 1)
return textOid, textTag, textValue