def outlet_state(self, set_state=None):
'''The current state of the outlet. Setting this value to turnOff(1)
will turn off the outlet. Setting this value to turnOn(2) will turn on
the outlet. Setting this value to cycle(3) will turn the outlet off,
then turn it back on:
0 = idle or unknown
1 = off
2 = on
3 = cycle (turn off, then turn on
'''
if set_state is None:
# Get current outlet state
obj_id = rfc1902.ObjectIdentity(self.mib, 'tlpPduOutletState',
self.device_id, self.outlet_id)
g = getCmd(SnmpEngine(), self.community, self.transport_target,
ContextData(), rfc1902.ObjectType(obj_id))
errorIndication, errorStatus, errorIndex, varBinds = next(g)
oid, value = varBinds[0]
return int(value)
else:
# Send outlet state
obj_id = rfc1902.ObjectIdentity(self.mib, 'tlpPduOutletCommand',
self.device_id, self.outlet_id)
g = setCmd(SnmpEngine(), self.community, self.transport_target,
ContextData(),
rfc1902.ObjectType(obj_id, int(set_state)))
errorIndication, errorStatus, errorIndex, varBinds = next(g)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the SNMP sensor."""
from pysnmp.hlapi import (
getCmd, CommunityData, SnmpEngine, UdpTransportTarget, ContextData,
ObjectType, ObjectIdentity)
name = config.get(CONF_NAME)
host = config.get(CONF_HOST)
port = config.get(CONF_PORT)
community = config.get(CONF_COMMUNITY)
baseoid = config.get(CONF_BASEOID)
unit = config.get(CONF_UNIT_OF_MEASUREMENT)
version = config.get(CONF_VERSION)
errindication, _, _, _ = next(
getCmd(SnmpEngine(),
CommunityData(community, mpModel=SNMP_VERSIONS[version]),
UdpTransportTarget((host, port)),
ContextData(),
ObjectType(ObjectIdentity(baseoid))))
if errindication:
_LOGGER.error("Please check the details in the configuration file")
return False
else:
data = SnmpData(host, port, community, baseoid, version)
add_devices([SnmpSensor(data, name, unit)])
def update(self):
"""Get the latest data from the remote SNMP capable host."""
from pysnmp.hlapi import (nextCmd, CommunityData, SnmpEngine,
UdpTransportTarget, ContextData, ObjectType,
ObjectIdentity)
for errindication, errstatus, errindex, restable in nextCmd(
SnmpEngine(),
CommunityData(self._community, mpModel=self._version),
UdpTransportTarget((self._host, self._port)), ContextData(),
ObjectType(ObjectIdentity(self._baseoid))):
if errindication and not self._accept_errors:
_LOGGER.error("SNMP error: %s", errindication)
elif errstatus and not self._accept_errors:
_LOGGER.error(
"SNMP error: %s at %s", errstatus.prettyPrint(),
errindex and restable[-1][int(errindex) - 1] or '?')
elif (errindication or errstatus) and self._accept_errors:
self.value = self._default_value
else:
for resrow in restable:
self.attributes[str(resrow[0])] = resrow
self.value = self._default_value
errors = self.attributes.get('1.3.6.1.2.1.25.3.5.1.2.1')
if errors:
code = errors[1].asNumbers()[0]
if code != 0:
_LOGGER.info('Error code: %s', errors[1].asNumbers())
self.value = ERRORS.get(int(math.log(code, 2)))
return
status = self.attributes.get('1.3.6.1.2.1.25.3.5.1.1.1')
if status:
self.value = STATUS.get(status[-1])
def _create_cmd_generator(self, object_identity, cmd_command):
"""
Generates the getCmd (see pySNMP doc) required to retrieve information from the agent.
:raises: SnmpVersionException: if the SNMP version specified is not valid.
:param object_identity: pySNMP object identity corresponding to the information we are looking for
:return: cmd_command result
"""
if self.snmp_version == 1 or self.snmp_version == 2:
data = CommunityData(self.community_index,
mpModel=self.snmp_version - 1)
return cmd_command(
SnmpEngine(),
data,
UdpTransportTarget((self.server_address, self.snmp_port)),
ContextData(),
ObjectType(object_identity),
lexicographicMode=False
) # STOPS WALKS WITHOUT CROSSING BOUNDARIES # EXAMPLE: IF WE GIVE OID 1.3.6.1.2.1.25.4.2.1.2, WE WILL ONLY WALK 1.3.6.1.2.1.25.4.2.1.2.X VALUES. IF THIS IS TRUE, WE WALK THE WHOLE TREE AFTER 1.3.6.1.2.1.25.4.2.1.2
SNMP_LOGGER.error(
"SNMPv%d does not currently exist or isn't supported by this query",
self.snmp_version)
raise SnmpVersionException(
"SNMPv%d does not currently exist or isn't supported by this query"
% self.snmp_version)
def __init__(self,
server_address,
get_values_dict,
walk_values_dict,
max_nb_tries=4,
sleep_between_tries=5,
snmp_port=161,
version=2,
community_index='public'):
"""
:param str server_address: IP address (IPv4 format) of the agent to be monitored
:param dict get_values_dict: Dict containing all the OIDS where a SNMP GET will be performed
:param walk_values_dict: Dict containing all the OIDS where a SNMP GET will be performed
:param int max_nb_tries: Number of tries before the query time out and raises and error
:param int sleep_between_tries: Time in seconds to wait between queries if the first one fails
:param int snmp_port: Agent's port used to connect to the agent
:param int version: SNMP version to be used (it can either be 1, 2, or 3)
"""
self.server_address = server_address
self.snmp_version = version
self.max_nb_tries = max_nb_tries
self.sleep_between_tries = sleep_between_tries
self.snmp_port = snmp_port
self.community_index = community_index
self.snmp_engine = SnmpEngine()
self.oid_get = {}
self.var_name_get = {}
self.oid_walk = {}
self.var_name_walk = {}
self.parse_oid_dict(get_values_dict, walk_values_dict)
def __init__(self, kwargs):
snmp_channel_id = kwargs.get('channel_id', \
str(os.getpid()) + \
str(time.time()).split('.')[0] + \
str(random.randint(0, 9)) \
)
self.snmpchannel = SnmpEngine(snmpEngineID=snmp_channel_id)
self.timeout = kwargs.get('timeout', 60)
self.mibs_dir = kwargs.get('MIBDIRS', DEFAULT_MIBDIR)
self.mibs_custom_dir = kwargs.get('mibs_custom_dir', None)
if self.mibs_custom_dir:
t.log('mibs_custom_dir: '+self.mibs_custom_dir)
self.community = kwargs.get('community', 'public')
self.version = kwargs.get('version', 2)
self.host = kwargs.get('host')
# SNMP V3 settings
self.group = kwargs.get('group')
self.user = kwargs.get('user', 'test1')
self.auth_type = kwargs.get('auth_type', 'usmHMACSHAAuthProtocol')
self.auth_pass = kwargs.get('auth_pass', 'test1234')
self.priv_type = kwargs.get('priv_type', 'usmAesCfb128Protocol')
self.priv_pass = kwargs.get('priv_pass', 'test1234')
self.context_engine = kwargs.get('context_engine', None)
self.context_name = kwargs.get('context_name', '')
self.port = kwargs.get('port', 161)
self.transport = UdpTransportTarget((self.host, self.port))
self.aindex = 1
self.eindex = 8
self.trap_port = kwargs.get('trap_port', self.get_free_port())
self.trap_server_v4 = kwargs.get('trap_server_v4', 'localhost')
self.trap_server_v6 = kwargs.get('trap_server_v6', '::1')
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Setup the SNMP sensor."""
from pysnmp.hlapi import (getCmd, CommunityData, SnmpEngine,
UdpTransportTarget, ContextData, ObjectType,
ObjectIdentity)
host = config.get(CONF_HOST)
port = config.get(CONF_PORT, DEFAULT_PORT)
community = config.get(CONF_COMMUNITY, DEFAULT_COMMUNITY)
baseoid = config.get(CONF_BASEOID)
errindication, _, _, _ = next(
getCmd(SnmpEngine(), CommunityData(community, mpModel=0),
UdpTransportTarget((host, port)), ContextData(),
ObjectType(ObjectIdentity(baseoid))))
if errindication:
_LOGGER.error('Please check the details in the configuration file')
return False
else:
data = SnmpData(host, port, community, baseoid)
add_devices([
SnmpSensor(data, config.get('name', DEFAULT_NAME),
config.get('unit_of_measurement'))
])
def get_snmp_with_auth(template_oids, ip, port, user_name, authen_protocol,
authen_password, priv_protocol, priv_password, timeout,
retries):
"""
:param template_oids:
:param ip:
:param port:
:param user_name:
:param authen_protocol:
:param authen_password:
:param priv_protocol:
:param priv_password:
:param timeout:
:param retries:
:return:
errorIndication, errorStatus, errorIndex, varBinds
"""
return next(
getCmd(
SnmpEngine(),
UsmUserData(
user_name,
authKey=process_password.decrypt_password(
empty_to_none(authen_password)),
privKey=process_password.decrypt_password(
empty_to_none(priv_password)),
authProtocol=AUTH_PROTOCOL[empty_to_none(authen_protocol)],
privProtocol=PRIV_PROTOCOL[empty_to_none(priv_protocol)]),
UdpTransportTarget((ip, port), timeout=timeout, retries=retries),
ContextData(), *template_oids))
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Set up the SNMP sensor."""
from pysnmp.hlapi import (getCmd, CommunityData, SnmpEngine,
UdpTransportTarget, ContextData, ObjectType,
ObjectIdentity)
name = config.get(CONF_NAME)
host = config.get(CONF_HOST)
port = config.get(CONF_PORT)
community = config.get(CONF_COMMUNITY)
baseoid = config.get(CONF_BASEOID)
unit = config.get(CONF_UNIT_OF_MEASUREMENT)
version = config.get(CONF_VERSION)
accept_errors = config.get(CONF_ACCEPT_ERRORS)
default_value = config.get(CONF_DEFAULT_VALUE)
value_template = config.get(CONF_VALUE_TEMPLATE)
if value_template is not None:
value_template.hass = hass
errindication, _, _, _ = next(
getCmd(SnmpEngine(),
CommunityData(community, mpModel=SNMP_VERSIONS[version]),
UdpTransportTarget((host, port)), ContextData(),
ObjectType(ObjectIdentity(baseoid))))
if errindication and not accept_errors:
_LOGGER.error("Please check the details in the configuration file")
return False
else:
data = SnmpData(host, port, community, baseoid, version, accept_errors,
default_value)
add_devices([SnmpSensor(data, name, unit, value_template)], True)
def update(self):
"""Get the latest data from the remote SNMP capable host."""
from pysnmp.hlapi import (getCmd, CommunityData, SnmpEngine,
UdpTransportTarget, ContextData, ObjectType,
ObjectIdentity)
from brother_ql.reader import interpret_response
errindication, errstatus, errindex, restable = next(
getCmd(SnmpEngine(), CommunityData(self._community, mpModel=0),
UdpTransportTarget((self._host, self._port)), ContextData(),
ObjectType(ObjectIdentity(self._baseoid))))
if errindication:
_LOGGER.error("SNMP error: %s", errindication)
elif errstatus:
_LOGGER.error("SNMP error: %s at %s", errstatus.prettyPrint(),
errindex and restable[-1][int(errindex) - 1] or '?')
else:
assert len(restable) == 1
status = interpret_response(bytes(restable[0][1]))
self.media_type = status['media_type']
self.media_width = '{} mm'.format(status['media_width'])
self.media_length = status['media_length'] or 'endless'
self.phase = status['phase_type']
self.errors = ', '.join(status['errors']) or '-none-'
if status['errors']:
self.state = 'error'
elif 'waiting' in status['phase_type'].lower():
self.state = 'idle'
elif 'printing' in status['phase_type'].lower():
self.state = 'printing'
else:
self.state = STATE_UNKNOWN
def get_snmp_table_data(config,
*args,
snmp_engine=SnmpEngine(),
snmpversion="2c"):
"""Retrieve necessary data via SNMP"""
authdata = prepare_authdata(config, snmpversion)
target = UdpTransportTarget((config["host"], config["port"]))
snmp_data = []
for (error_indication, error_status, error_index, var_binds) in nextCmd(
snmp_engine,
authdata,
target,
ContextData(),
*args,
lexicographicMode=False,
):
if error_indication:
raise ValueError(error_indication)
elif error_status:
status = error_status.prettyPrint()
index = error_index and var_binds[int(error_index) - 1][0] or "?"
raise ValueError(f"{status} at {index}")
else:
snmp_data.append(var_binds)
return snmp_data
def probe_oper_status(player):
switch = current_app.config['SWITCHES'][player]
address = switch['address']
port = switch['port']
logger.info("Probing status for player %d on switch %s:%d", player,
address)
engine = SnmpEngine()
auth_data = CommunityData(switch['community'], mpModel=1)
transport = UdpTransportTarget((address, port))
interfaces = switch['interfaces']
oper_states = []
for chunk in chunked(
(ObjectType(ObjectIdentity(ifOperStatus.oid + (index, )), Null())
for index in interfaces), 24):
cmd = getCmd(engine, auth_data, transport, ContextData(), *chunk)
errorIndication, errorStatus, errorIndex, varBinds = next(cmd)
if errorIndication is not None:
raise Exception("SNMP error returned")
oper_states.extend(
ifOperStatus(int(value)) for identity, value in varBinds)
with StateLock:
for cell_state, (index,
oper_state) in zip(current_app.cell_state[player],
enumerate(oper_states)):
if oper_state == ifOperStatus.down and cell_state != CellState.EMPTY:
current_app.cell_state[player][index] = CellState.PRESENT
if oper_state == ifOperStatus.up and cell_state != CellState.EMPTY:
current_app.cell_state[player][index] = CellState.HIT
if not any(cell_state == CellState.PRESENT
for cell_state in current_app.cell_state[player]):
current_app.game_state = GameState.OVER
return True
return False
def trap_v3(self, endpoint, message):
# Send trap to one endpoint
error_indication, error_status, error_index, var_binds = next(
sendNotification(
SnmpEngine(snmpEngineID=OctetString(
hexValue=endpoint.engineid)),
endpoint.usm_user,
UdpTransportTarget((endpoint.host, endpoint.port)),
ContextData(),
'trap',
# sequence of custom OID-value pairs
self.get_pdu(message)))
if error_indication:
log(
"error",
"notifier",
{
"message": 'Unable to send snmp message to %s err:%s %s %s'
% (endpoint.host,
error_indication,
error_status,
error_index)
}
)
else:
log(
"info",
"notifier",
{
"message": 'Sent snmp message to %s to alert about %s'
% (endpoint.host,
message)
}
)
def set_outlet_on(self, outlet, on):
"""
Set an outlet on or off
:param outlet: Which outlet to set the power for (for my model this is
in the range 1 through 8)
:param on: INVALID ATM True means turn it on, False means turn it off
"""
oid = ObjectIdentity(
"1.3.6.1.4.1.3808.1.1.3.3.3.1.1.4.{}".format(outlet))
if isinstance(on, bool):
target_state = "immediateOn" if on else "immediateOff"
else:
target_state = on
errorIndication, errorStatus, errorIndex, varBinds = next(
setCmd(
SnmpEngine(),
CommunityData("private"),
UdpTransportTarget((self.host, 161)),
ContextData(),
ObjectType(oid,
Integer32(self.outlet_state_oids[target_state])),
))
if errorIndication:
raise CyberPowerPduException(errorIndication)
elif errorStatus:
raise CyberPowerPduException("%s at %s" % (
errorStatus.prettyPrint(),
errorIndex and varBinds[int(errorIndex) - 1][0] or "?",
))
def test_snmp(target, port=161, community='public'):
try:
errorIndication, errorStatus, errorIndex, varBinds = next(
getCmd(SnmpEngine(),
# mpModel -> 0:v1,1:v2c
CommunityData(community, mpModel=1),
UdpTransportTarget(
(target, int(port)), timeout=1, retries=1),
ContextData(),
ObjectType(ObjectIdentity(
'SNMPv2-MIB', 'sysDescr', 0)),
ObjectType(ObjectIdentity('SNMPv2-MIB', 'sysName', 0)))
)
if errorIndication:
return (False, errorIndication)
elif errorStatus:
msg = '%s at %s' % (errorStatus.prettyPrint(
), errorIndex and varBinds[int(errorIndex) - 1][0] or '?')
return (False, msg)
else:
result = []
for varBind in varBinds:
result.append(' = '.join(
[x.prettyPrint() for x in varBind]))
return (True, result)
except Exception as e:
# raise
return (False, str(e))
def snmp_harvester(ip: str, port: int, community: str,
parameters: typing.Iterable[str]) -> t_snmp_samples_chunk:
"""
Fires SNMP GET query at endpoint defined by ip and port. The query
consists all of OIDs defined in parameters argument.
:param ip: host IP address
:param port: SNMP port number
:param community: community name
:param parameters: list of OIDs
:returns: samples as list of pairs: OID and its collected value
"""
if ipaddress.ip_address(ip).version == 4:
transport = UdpTransportTarget
else:
transport = Udp6TransportTarget
result = getCmd(SnmpEngine(), CommunityData(community, mpModel=1),
transport((ip, port)), ContextData(),
*[ObjectType(ObjectIdentity(oid)) for oid in parameters])
_error_indication, _error_status, _error_index, var_binds = next(result)
return [(str(name), value._value) for name, value in var_binds
if not isinstance(value, Null)]
def update(self):
"""Update the state."""
from pysnmp.hlapi import (getCmd, CommunityData, SnmpEngine,
UdpTransportTarget, ContextData, ObjectType,
ObjectIdentity)
from pyasn1.type.univ import (Integer)
request = getCmd(SnmpEngine(),
CommunityData(self._community, mpModel=self._version),
UdpTransportTarget((self._host, self._port)),
ContextData(),
ObjectType(ObjectIdentity(self._baseoid)))
errindication, errstatus, errindex, restable = next(request)
if errindication:
_LOGGER.error("SNMP error: %s", errindication)
elif errstatus:
_LOGGER.error("SNMP error: %s at %s", errstatus.prettyPrint(),
errindex and restable[-1][int(errindex) - 1] or '?')
else:
for resrow in restable:
if resrow[-1] == Integer(self._payload_on):
self._state = True
elif resrow[-1] == Integer(self._payload_off):
self._state = False
else:
self._state = None
def get_cmd(self, oid):
"""
SNMP get
"""
snmp_ret = getCmd(SnmpEngine(), self.get_auth(),
UdpTransportTarget((self.hostname, self.snmp_port)),
ContextData(), ObjectType(ObjectIdentity(oid)))
return self._to_list(snmp_ret=snmp_ret)
def walk(self, oid):
snmp_ret = nextCmd(SnmpEngine(),
CommunityData(self.community),
UdpTransportTarget((self.hostname, self.snmp_port)),
ContextData(),
ObjectType(ObjectIdentity(oid)),
lexicographicMode=False)
return self._to_list(snmp_ret=snmp_ret)
def set_outlet_on(self, outlet, on):
"""
Set an outlet on or off
:param outlet: Which outlet to set the power for (for my model this is
in the range 1 through 8)
:param on: True means turn it on, False means turn it off
"""
# OK, sorry for this insane code - the pysnmp docs explicitly say you
# should just copy paste their examples.
# This is based on the code from here:
# http://snmplabs.com/pysnmp/examples/hlapi/asyncore/sync/manager/cmdgen/modifying-variables.html
# The command we would run to power on outlet 1 on the PDU, if we were
# not masochists is this:
#
# snmpset -v 1 -c private $IPADDR CPS-MIB::ePDUOutletControlOutletCommand.1 i immediateOn
#
# However to get those human-readable names to work we'd need to
# download MIBs and tell pysnmp about them. pysnmp + pysmi apparently
# know how to do this but I tried to point it at the CyberPower MIB file
# and it failed silently so huffed and gave up.
#
# So instead, we're going to do something more akin to this command,
# which is exactly the same thing but without the human-readable names:
#
# snmpset -v 1 -c private $IPADDR .1.3.6.1.4.1.3808.1.1.3.3.3.1.1.4.2 i 1
#
# In that command ".1.3.6.1.4.1.3808.1.1.3.3.3.1.1.4.2" is the
# masochistic name for "CPS-MIB::ePDUOutletControlOutletCommand.2" and
# "1" is the masochistic name for "immediateOn"
#
# I figured out what that command would be by running this:
# snmptranslate -On CPS-MIB::ePDUOutletControlOutletCommand
#
# SnmpEngine and ContextData are just pointless boilerplate required by
# pysnmp. Hopefully you can sort of see how the other bits map to the
# code below (the "i" becaomse "Integer32").
oid = ObjectIdentity(
'1.3.6.1.4.1.3808.1.1.3.3.3.1.1.4.{}'.format(outlet))
target_state = 'immediateOn' if on else 'immediateOff'
errorIndication, errorStatus, errorIndex, varBinds = next(
setCmd(
SnmpEngine(), CommunityData('private'),
UdpTransportTarget((self.host, 161)), ContextData(),
ObjectType(oid,
Integer32(self.outlet_state_oids[target_state]))))
if errorIndication:
raise CyberPowerPduException(errorIndication)
elif errorStatus:
raise CyberPowerPduException(
'%s at %s' %
(errorStatus.prettyPrint(),
errorIndex and varBinds[int(errorIndex) - 1][0] or '?'))
def get_cmd(self, oid):
'''
get oid mib info
'''
self.snmp_ret = getCmd(SnmpEngine(),
self.get_auth(),
UdpTransportTarget(
(self.router_ip, self.snmp_port)),
ContextData(),
ObjectType(ObjectIdentity(oid)))
return self._to_list()
def __init__(self, **kwargs):
self.standard_mibs = []
self.mongo_client = pymongo.MongoClient(MONGO_URI)
if kwargs.get("no_mongo"):
self.session = Session()
else:
self.session = CachedLimiterSession(
per_second=120,
cache_name="cache_http",
backend=MongoCache(connection=self.mongo_client,
db_name=MONGO_DB),
expire_after=1800,
match_headers=False,
stale_if_error=True,
allowable_codes=[200],
)
self.profiles = load_profiles()
self.last_modified = time.time()
self.snmpEngine = SnmpEngine()
self.builder = self.snmpEngine.getMibBuilder()
self.mib_view_controller = view.MibViewController(self.builder)
compiler.addMibCompiler(self.builder, sources=[MIB_SOURCES])
# mib_standard_response = self.session.get(f"{MIB_STANDARD}", stream=True)
# if mib_standard_response.status_code == 200:
# for line in mib_standard_response.iter_lines():
# if line:
# mib = line.decode("utf-8")
# logger.info(f"MIB: {mib}")
# try:
# self.builder.loadModules(mib)
# self.standard_mibs.append(mib)
# except Exception as e:
# logger.warning(f"An error occurred during loading MIB module: {mib}: {e}")
# else:
for mib in DEFAULT_STANDARD_MIBS:
self.standard_mibs.append(mib)
self.builder.loadModules(mib)
mib_response = self.session.get(f"{MIB_INDEX}")
self.mib_map = {}
if mib_response.status_code == 200:
with StringIO(mib_response.text) as index_csv:
reader = csv.reader(index_csv)
for each_row in reader:
if len(each_row) == 2:
self.mib_map[each_row[1]] = each_row[0]
logger.debug(f"Loaded {len(self.mib_map.keys())} mib map entries")
else:
logger.error(
f"Unable to load mib map from index http error {self.mib_response.status_code}"
)
def next_cmd(self, oid, max_rows=25, max_calls=0):
'''
get next oid mib info
'''
self.snmp_ret = nextCmd(SnmpEngine(),
CommunityData(self.community),
UdpTransportTarget(
(self.router_ip, self.snmp_port)),
ContextData(),
ObjectType(ObjectIdentity(oid)),
maxRows=max_rows, maxCalls=max_calls)
return self._to_list()
def _set(self, value):
from pysnmp.hlapi import (setCmd, CommunityData, SnmpEngine,
UdpTransportTarget, ContextData, ObjectType,
ObjectIdentity)
request = setCmd(SnmpEngine(),
CommunityData(self._community, mpModel=self._version),
UdpTransportTarget((self._host, self._port)),
ContextData(),
ObjectType(ObjectIdentity(self._baseoid), value))
next(request)
def outlet_ramp_delay(self, set_delay=None):
'''The number of seconds to delay before powering on the given outlet:
integer values only
'''
if set_delay is None:
# Get current outlet state
obj_id = rfc1902.ObjectIdentity(self.mib, 'tlpPduOutletRampDelay',
self.device_id, self.outlet_id)
g = getCmd(SnmpEngine(), self.community, self.transport_target,
ContextData(), rfc1902.ObjectType(obj_id))
errorIndication, errorStatus, errorIndex, varBinds = next(g)
oid, value = varBinds[0]
return int(value)
else:
# Send outlet state
obj_id = rfc1902.ObjectIdentity(self.mib, 'tlpPduOutletRampDelay',
self.device_id, self.outlet_id)
g = setCmd(SnmpEngine(), self.community, self.transport_target,
ContextData(), rfc1902.ObjectType(obj_id),
int(set_delay))
errorIndication, errorStatus, errorIndex, varBinds = next(g)
def port_interaction(self, command, port_number):
if command == "on":
set_bit = self.onsetting
elif command == "off":
set_bit = self.offsetting
else:
raise UnknownCommandException("Unknown command %s." % (command))
transport = UdpTransportTarget((self.hostname, 161))
objecttype = ObjectType(
ObjectIdentity(self.mib, self.controlpoint,
port_number).addAsn1MibSource(
'http://mibs.snmplabs.com/asn1/@mib@'),
int(set_bit))
if self.version == 'snmpv3':
if not self.username:
raise FailedRequestException("No username set for snmpv3")
userdata = UsmUserData(self.username, self.authpass, self.privpass)
errorIndication, errorStatus, errorIndex, varBinds = next(
setCmd(SnmpEngine(), userdata, transport, ContextData(),
objecttype))
elif self.version == 'snmpv1':
if not self.community:
raise FailedRequestException("No community set for snmpv1")
errorIndication, errorStatus, errorIndex, varBinds = next(
setCmd(SnmpEngine(), CommunityData(self.community), transport,
ContextData(), objecttype))
else:
raise FailedRequestException("Unknown snmp version")
if errorIndication:
raise FailedRequestException(errorIndication)
elif errorStatus:
raise FailedRequestException(errorStatus)
else:
for varBind in varBinds:
log.debug(' = '.join([x.prettyPrint() for x in varBind]))
return True
def bulk_cmd(self, oid, non_repeaters=0, max_repeaters=1):
'''
bulk get router info by oid
'''
self.snmp_ret = bulkCmd(SnmpEngine(),
CommunityData(self.community),
UdpTransportTarget(
(self.router_ip, self.snmp_port)),
ContextData(),
non_repeaters, max_repeaters,
ObjectType(ObjectIdentity(oid)),
maxCalls=10)
return self._to_list(oid)
def outlet_ramp_action(self, set_action=None):
'''The ramp action to take on a given outlet when powering on the
device:
0 = remain off
1 = turn on after delay
'''
if set_action is None:
# Get current outlet state
obj_id = rfc1902.ObjectIdentity(self.mib, 'tlpPduOutletRampAction',
self.device_id, self.outlet_id)
g = getCmd(SnmpEngine(), self.community, self.transport_target,
ContextData(), rfc1902.ObjectType(obj_id))
errorIndication, errorStatus, errorIndex, varBinds = next(g)
oid, value = varBinds[0]
return int(value)
else:
# Send outlet state
obj_id = rfc1902.ObjectIdentity(self.mib, 'tlpPduOutletRampAction',
self.device_id, self.outlet_id)
g = setCmd(SnmpEngine(), self.community, self.transport_target,
ContextData(),
rfc1902.ObjectType(obj_id, int(set_action)))
errorIndication, errorStatus, errorIndex, varBinds = next(g)
def get_name(ip):
errorIndication, errorStatus, errorIndex, varBinds = next(
getCmd(SnmpEngine(), CommunityData(community, mpModel=0),
UdpTransportTarget((ip, 161)), ContextData(),
ObjectType(ObjectIdentity('1.3.6.1.2.1.1.5.0'))))
if errorIndication:
print(errorIndication)
elif errorStatus:
print('%s at %s' %
(errorStatus.prettyPrint(),
errorIndex and varBinds[int(errorIndex) - 1][0] or '?'))
else:
for oid, value in varBinds:
return value
def test_snmp_works(self):
for series in ['xenial', 'bionic', 'cosmic', 'disco']:
status = zaza.model.get_status() \
.applications['ubuntu-{}'.format(series)]
for unit in status["units"]:
details = status['units'][unit]
address = details['public-address']
errorIndication, errorStatus, errorIndex, varBinds = next(
getCmd(SnmpEngine(),
CommunityData('public'),
UdpTransportTarget((address, 161)),
ContextData(),
ObjectType(ObjectIdentity('1.3.6.1.2.1.1.1.0')),
ObjectType(ObjectIdentity('1.3.6.1.2.1.1.6.0')))
)
self.assertIsNone(errorIndication)
