def setup_snmp():
"""Configure SNMP server listener"""
transport_dispatcher = AsynsockDispatcher()
transport_dispatcher.registerRecvCbFun(snmp_trap_receiver)
# UDP/IPv4
transport_dispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(('0.0.0.0', 162)))
# UDP/IPv6
transport_dispatcher.registerTransport(
udp6.domainName,
udp6.Udp6SocketTransport().openServerMode(('::1', 162)))
transport_dispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transport_dispatcher.runDispatcher()
except:
transport_dispatcher.closeDispatcher()
raise
def receive_trap(self):
transportDispatcher = AsynsockDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openServerMode(('192.168.115.187', 162))
)
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName, udp6.Udp6SocketTransport().openServerMode(('::1', 162))
)
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
print('run dispatcher')
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
raise
def add_udp_endpoint(
self,
snmp_engine,
snmp_timeout=SNMP_TIMEOUT,
snmp_retry_count=SNMP_RETRIES_COUNT,
):
if self._snmp_parameters.ip:
try:
agent_udp_endpoint = socket.getaddrinfo(
self._snmp_parameters.ip,
self._snmp_parameters.port,
socket.AF_INET,
socket.SOCK_DGRAM,
socket.IPPROTO_UDP,
)[0][4][:2]
except socket.gaierror:
raise InitializeSNMPException(
"Failed to validate {} hostname".format(
self._snmp_parameters.ip),
self._logger,
)
else:
raise InitializeSNMPException(
"Failed to validate {} hostname".format(
self._snmp_parameters.ip),
self._logger,
)
ip = ip_address(u"{}".format(self._snmp_parameters.ip))
if isinstance(ip, IPv6Address):
config.addSocketTransport(
snmp_engine,
udp6.domainName,
udp6.Udp6SocketTransport().openClientMode(),
)
config.addTargetAddr(
snmp_engine,
"tgt",
udp6.domainName,
agent_udp_endpoint,
"pms",
snmp_timeout,
snmp_retry_count,
)
else:
config.addSocketTransport(
snmp_engine, udp.domainName,
udp.UdpSocketTransport().openClientMode())
config.addTargetAddr(
snmp_engine,
"tgt",
udp.domainName,
agent_udp_endpoint,
"pms",
snmp_timeout,
snmp_retry_count,
)
def run(self):
"""Run the sensor on its own thread"""
# Check for debug mode being activated/deactivated
self._read_my_msgQ_noWait()
try:
self._log_debug("Start processing")
# Create MIB loader to lookup oids sent in traps
self._mib_builder()
# Create an asynchronous dispatcher and register a callback method to handle incoming traps
transportDispatcher = AsynsockDispatcher()
transportDispatcher.registerRecvCbFun(self._trap_catcher)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(
(self._bind_ip, self._bind_port)))
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName,
udp6.Udp6SocketTransport().openServerMode(
('::1', self._bind_port)))
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job #1 never reaches zero
transportDispatcher.runDispatcher()
except Exception as ae:
self._log_debug("Exception: %r" % ae)
transportDispatcher.closeDispatcher()
self._log_debug("Finished processing, restarting SNMP listener")
# Reset debug mode if persistence is not enabled
self._disable_debug_if_persist_false()
# Schedule the next time to run thread
self._scheduler.enter(10, self._priority, self.run, ())
# Could not bind to IP:port, log it and exit out module
except Exception as ae:
self._log_debug(
"Unable to process SNMP traps from this node, closing module.")
self._log_debug(
f"SNMP Traps sensor attempted to bind to {self._bind_ip}:{self._bind_port}"
)
def main():
'main program function'
if os.path.isfile(CONFIG_FILE):
filename = CONFIG_FILE
elif os.path.isfile('/config/{0}'.format(CONFIG_FILE)):
filename = '/config/{0}'.format(CONFIG_FILE)
else:
print 'Error: cannot find configuration file', CONFIG_FILE
return
processConfig(filename)
transportDispatcher = AsynsockDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
if gArgs.virtual_router:
lookupVR(gArgs.virtual_router)
# During startup, the IP address may not be ready yet. So we try a few times
for retry in range(30):
try:
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(
(gArgs.ip_address, 162)))
break
except Exception:
time.sleep(5)
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName,
udp6.Udp6SocketTransport().openServerMode(('::1', 162)))
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except Exception:
transportDispatcher.closeDispatcher()
raise
def start(self):
transportDispatcher = AsynsockDispatcher()
transportDispatcher.registerRecvCbFun(self._event_handle)
if self.ipv4_addr:
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(
(str(self.ipv4_addr), self.port)))
if self.ipv6_addr:
transportDispatcher.registerTransport(
udp6.domainName,
udp6.Udp6SocketTransport().openServerMode(
(str(self.ipv6_addr), self.port)))
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
raise
def getSNMPEngine(address4, address6, snmpv12_agents, SNMPv3_users):
# Create SNMP engine with autogenernated engineID and pre-bound
# to socket transport dispatcher
snmpEngine = engine.SnmpEngine()
# Setup transport endpoint
config.addSocketTransport(
snmpEngine, udp.domainName,
udp.UdpSocketTransport().openServerMode(address4))
config.addSocketTransport(
snmpEngine, udp6.domainName,
udp6.Udp6SocketTransport().openServerMode(address6))
log.info(
"SNMP Trap; listening; msg=SNMP Trap daemon listening on UDP address %s and %s",
address4, address6)
# v1/2 setup
for agent in snmpv12_agents:
agent_val = snmpv12_agents.get(agent)
community_string = agent_val.get("community_string")
if community_string:
config.addV1System(snmpEngine, agent, community_string)
log.info("SNMP Trap; registering; Registered agent %s", agent)
# v3 setup
for user in SNMPv3_users:
user_val = SNMPv3_users.get(user)
user_auth_key = user_val.get("auth-key")
user_priv_key = user_val.get("priv-key")
if user_auth_key and user_priv_key:
config.addV3User(snmpEngine, user, config.usmHMACMD5AuthProtocol,
user_auth_key, config.usmDESPrivProtocol,
user_priv_key)
log.info("SNMP Trap; registering; Registered snmp v3 user %s",
user)
return snmpEngine
def __init__(self, ip, port=161, is_ipv6=False, timeout=2000, retry_count=2, get_bulk_flag=False,
continue_on_errors=0, get_bulk_repetitions=25, v3_context_engine_id=None, v3_context=''):
self.ip = ip
self.continue_on_errors = continue_on_errors
self.get_bulk_repetitions = get_bulk_repetitions
self.timeout = timeout
self.output_file = list()
self.retry_count = retry_count
self.get_bulk_flag = get_bulk_flag
self.v3_context_engine_id = v3_context_engine_id
self.v3_context = v3_context
if self.v3_context_engine_id:
if self.v3_context_engine_id[2:] == '0x':
self.v3_context_engine_id = univ.OctetString(hexValue=self.v3_context_engine_id[2:])
else:
self.v3_context_engine_id = univ.OctetString(self.v3_context_engine_id)
if self.v3_context:
if self.v3_context[:2] == '0x':
self.v3_context = univ.OctetString(hexValue=self.v3_context[2:])
else:
self.v3_context = univ.OctetString(self.v3_context)
if ip:
try:
agent_udp_endpoint = \
socket.getaddrinfo(ip,
port,
socket.AF_INET, socket.SOCK_DGRAM,
socket.IPPROTO_UDP)[0][4][:2]
except socket.gaierror:
sys.stderr.write('ERROR: unknown hostname {}\r\n'.format(ip))
sys.exit(-1)
else:
sys.stderr.write('ERROR: unknown hostname {}\r\n'.format(ip))
sys.exit(-1)
self._snmp_engine = engine.SnmpEngine()
config.addTargetParams(self._snmp_engine, 'pms', self.get_user, self.get_security,
self.get_snmp_version)
if agent_udp_endpoint:
if is_ipv6:
config.addSocketTransport(
self._snmp_engine,
udp6.domainName,
udp6.Udp6SocketTransport().openClientMode()
)
config.addTargetAddr(
self._snmp_engine, 'tgt', udp6.domainName, agent_udp_endpoint, 'pms',
self.timeout, self.retry_count
)
else:
config.addSocketTransport(
self._snmp_engine,
udp.domainName,
udp.UdpSocketTransport().openClientMode()
)
config.addTargetAddr(
self._snmp_engine, 'tgt', udp.domainName, agent_udp_endpoint, 'pms',
self.timeout, self.retry_count
)
else:
sys.stderr.write('ERROR: Failed to communicate with provided IP Address {}\r\n'.format(ip))
sys.exit(-1)
# a target name. Since Notifications could be sent to multiple Managers
# at once, more than one target entry may be configured (and tagged).
#
# UDP/IPv4
config.addSocketTransport(snmpEngine, udp.domainName,
udp.UdpSocketTransport().openClientMode())
config.addTargetAddr(snmpEngine,
'my-nms-1',
udp.domainName, ('127.0.0.1', 162),
'my-creds-1',
tagList='all-my-managers')
## UDP/IPv6
config.addSocketTransport(snmpEngine, udp6.domainName,
udp6.Udp6SocketTransport().openClientMode())
config.addTargetAddr(snmpEngine,
'my-nms-2',
udp6.domainName, ('::1', 162),
'my-creds-3',
tagList='all-my-managers')
## Local domain socket
#config.addSocketTransport(
# snmpEngine,
# unix.domainName,
# unix.UnixSocketTransport().openClientMode()
#)
#config.addTargetAddr(
# snmpEngine, 'my-nms',
# unix.domainName, '/tmp/snmp-manager',
# Build message
trapMsg = pMod.Message()
pMod.apiMessage.setDefaults(trapMsg)
pMod.apiMessage.setCommunity(trapMsg, 'public')
pMod.apiMessage.setPDU(trapMsg, trapPDU)
transportDispatcher = AsynsockDispatcher()
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openClientMode()
)
transportDispatcher.sendMessage(
encoder.encode(trapMsg), udp.domainName, ('localhost', 5003)
)
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName, udp6.Udp6SocketTransport().openClientMode()
)
transportDispatcher.sendMessage(
encoder.encode(trapMsg), udp6.domainName, ('::1', 5003))
# Dispatcher will finish as all scheduled messages are sent
transportDispatcher.runDispatcher()
transportDispatcher.closeDispatcher()
for oid, val in varBinds:
print('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
return wholeMsg
transportDispatcher = AsynsockDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(('192.168.77.22', 162)))
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName,
udp6.Udp6SocketTransport().openServerMode(('::1', 162)))
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
raise
if __name__ == '__main__':
# SNMP_Get()
cbFun()
else:
varBinds = pMod.apiPDU.getVarBindList(reqPDU)
logger.debug('Var-binds:')
for oid, val in varBinds:
logger.debug('%s = %s' % (oid.prettyPrint(), val.prettyPrint()))
return wholeMsg
transportDispatcher = AsynsockDispatcher()
transportDispatcher.registerRecvCbFun(cbFun)
# UDP/IPv4
transportDispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openServerMode(('localhost', 162))
)
# UDP/IPv6
transportDispatcher.registerTransport(
udp6.domainName, udp6.Udp6SocketTransport().openServerMode(('::1', 162))
)
transportDispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportDispatcher.runDispatcher()
except:
transportDispatcher.closeDispatcher()
raise
def openClientMode(self):
self.transport = udp6.Udp6SocketTransport().openClientMode()
return self.transport
def start_trap(self, pattern_end_trap, time_end_trap,
timeout, port, queue):
"""
:param pattern_end_trap
**OPTION** the pattern you are looking for in the trap to
stop trap. If not defined, trap will be stopped after
timeout value
:param time_end_trap
**OPTION** the time for running trap. Default: 30
:param timeout
**OPTION** the timeout for snmp trap. Default: 300.
:param port
**OPTION** the port of snmp trap.
:return:
"""
t.log("DEBUG", "Entering 'start_trap'\n"+__file__)
import warnings
warnings.simplefilter("ignore", ResourceWarning)
startedat = time.time()
#global results
global RESPONSE
RESPONSE = ''
def cbfun(transportdispatcher, transportdomain, transportaddress,
wholemsg):
t.log("DEBUG", "Entering 'cbfun'\n"+__file__)
#global results
global RESPONSE
while wholemsg:
msgver = int(api.decodeMessageVersion(wholemsg))
if msgver in api.protoModules:
pmod = api.protoModules[msgver]
else:
RESPONSE += 'Unsupported SNMP version %s' % msgver
return
reqmsg, wholemsg = decoder.decode(
wholemsg, asn1Spec=pmod.Message(),
)
RESPONSE += 'Notification message from %s:%s: \n' % (
transportdomain, transportaddress
)
reqpdu = pmod.apiMessage.getPDU(reqmsg)
if msgver == api.protoVersion1:
varbinds = pmod.apiTrapPDU.getVarBindList(reqpdu)
RESPONSE += 'Var-binds: \n'
for oid, val in varbinds:
RESPONSE += '%s = %s \n' % (oid.prettyPrint(),
val.prettyPrint())
if pattern_end_trap and re.search(pattern_end_trap,
RESPONSE, re.I):
transportdispatcher.jobFinished(1)
RESPONSE += "Stopped trap \n"
RESPONSE += 'Enterprise: %s \n' % (
pmod.apiTrapPDU.getEnterprise(reqpdu).prettyPrint()
)
RESPONSE += 'Agent Address: %s \n' % (
pmod.apiTrapPDU.getAgentAddr(reqpdu).prettyPrint()
)
RESPONSE += 'Generic Trap: %s \n' % (
pmod.apiTrapPDU.getGenericTrap(
reqpdu).prettyPrint())
RESPONSE += 'Specific Trap: %s \n' % (
pmod.apiTrapPDU.getSpecificTrap(
reqpdu).prettyPrint()
)
RESPONSE += 'Uptime: %s \n' % (
pmod.apiTrapPDU.getTimeStamp(
reqpdu).prettyPrint()
)
else:
varbinds = pmod.apiPDU.getVarBindList(reqpdu)
def cbtimerfun(timenow):
t.log("DEBUG", "Entering 'cbtimerfun'\n"+__file__)
#global results
global RESPONSE
if time_end_trap is not None:
if timenow - startedat >= time_end_trap:
transportdispatcher.jobFinished(1)
RESPONSE += "Stopped trap \n"
if timenow - startedat >= timeout:
t.log(level="DEBUG", message="Request timed out \n")
raise Exception("Request timed out \n")
transportdispatcher = AsynsockDispatcher()
transportdispatcher.registerRecvCbFun(cbfun)
transportdispatcher.registerTimerCbFun(cbtimerfun)
# UDP/IPv4
transportdispatcher.registerTransport(
udp.domainName, udp.UdpSocketTransport().openServerMode(
(self.trap_server_v4, port))
)
# UDP/IPv6
transportdispatcher.registerTransport(
udp6.domainName, udp6.Udp6SocketTransport().openServerMode(
(self.trap_server_v6, port))
)
transportdispatcher.jobStarted(1)
try:
# Dispatcher will never finish as job#1 never reaches zero
transportdispatcher.runDispatcher()
except:
transportdispatcher.closeDispatcher()
queue.put(RESPONSE)
t.log(level="DEBUG", message="Exiting 'start_trap' with return value/code :\n")
return
def main():
parser = argparse.ArgumentParser(description="HEALTH CHECKER.")
parser.add_argument("-c",
"--config",
default="/etc/healthchecker.yaml",
help="Path to config file.")
parser.add_argument("-v",
"--verbose",
action="count",
default=0,
help="Increase logging verbosity.")
parser.add_argument("-q",
"--quiet",
action="count",
default=0,
help="Decrease logging verbosity.")
parser.add_argument("-V",
"--version",
action="version",
version="%%(prog)s %s" % __version__,
help="Display version information.")
args = parser.parse_args()
oid_translate.load_mibs()
config = Config.from_file(args.config)
db_host, db_port, db_name, db_user, db_passwd = config.get_database_config(
)
db_engine = PooledMySQLDatabase(
db_name, **{
'host': db_host,
'port': db_port,
'password': db_passwd,
'user': db_user
})
models = [Target, FPingMessage, Device, EventMessage, Port]
db_engine.bind(models)
community = config["community"]
if not community:
community = None
ipv6_server = config["ipv6"]
if not ipv6_server:
ipv6_server = None
trap_cb = TrapperCallback(db_engine, config, community)
logging.basicConfig(
filename=LOGFILE,
level=10, #get_loglevel(args),
format=LOGFORMAT)
transport_dispatcher = AsynsockDispatcher()
transport_dispatcher.registerRecvCbFun(trap_cb)
if ipv6_server:
transport_dispatcher.registerTransport(
udp6.domainName,
udp6.Udp6SocketTransport().openServerMode(
("::1", int(config["trap_port"]))))
transport_dispatcher.registerTransport(
udp.domainName,
udp.UdpSocketTransport().openServerMode(
("0.0.0.0", int(config["trap_port"]))))
transport_dispatcher.jobStarted(1)
process_count = config['process_count']
if not process_count:
process_count = (
multiprocessing.cpu_count() * 2 +
1) if (multiprocessing.cpu_count() * 2 + 1) < 11 else 10
logging.info("multiprocess count is : %s" % process_count)
fping_count = int(config['fping_count'])
if not fping_count:
fping_count = 5
logging.info("fping count is : %d" % fping_count)
interval_time = int(config['interval_time'])
if not interval_time:
interval_time = 1
fping_cb = FPingCallback(db_engine)
scheduler = BackgroundScheduler()
trigger = IntervalTrigger(minutes=interval_time) # FIX PYINSTALL BUG
scheduler.add_job(fping_cb,
trigger,
args=(process_count, fping_count),
max_instances=10)
#scheduler.add_job(fping_cb, trigger='interval', args=(process_count, fping_count),
# max_instances=10, minutes=interval_time)
## syslog service
host = '127.0.0.1'
port = 8889
syslog_service = SyslogService(db_engine, host, port)
TRAP = False
try:
scheduler.start()
if TRAP: #TODO new thread
transport_dispatcher.runDispatcher()
else:
#redo_start_time = datetime.datetime.now() + datetime.timedelta(seconds=-20)
redo_start_time = config.get("redo_start_time")
if redo_start_time is None:
redo_start_time = False
syslog_service.start(redo_start_time)
except KeyboardInterrupt:
pass
finally:
logging.info("Shutdown Scheduler...")
scheduler.shutdown()
if TRAP:
logging.info("Stopping Transport Dispatcher...")
transport_dispatcher.closeDispatcher()
else:
syslog_service.stop()
logging.info("Bye")
