def __init__(self, pid_directory, id, module_name, table_name, logger):
self.pid_directory = pid_directory
self.id = id
self.module_name = module_name.replace(' ', '_').lower()
self.table_name = table_name
self.logger = logger
self.conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"), self.logger)
def get(self, id=None, show=None, status=None):
args = self.api_utils.optional_parameters()
try:
poller_session = self.db_utils.model_session(self.main_model)
if id is not None:
poller_session = poller_session.filter(
self.main_model.id == id)
poller_session = poller_session.order_by(
self.main_model.id.desc()).all()
schema_option = self.api_utils.schema_options(
self.main_schema, args['columns'])
poller_result = self.main_schema(
**schema_option).dump(poller_session)
poller_result = self.api_utils.get_paginated_list(
poller_result, args['start'], args['limit'])
for poller_element in poller_result:
if 'blacklist' in args['include']:
blacklist = self.db_utils.select_with_filter(
Blacklist, BlacklistSchema,
{'snmp_poller_id': poller_element['id']})
poller_element['blacklist'] = blacklist
if 'selected_oid' in args['include']:
selected_oid = self.db_utils.select_with_filter(
SelectedOid, SelectedOidSchema,
{'snmp_poller_id': poller_element['id']})
poller_element['selected_oid'] = selected_oid
if 'selected_ips' in args['include']:
conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
query_string = "Select {0}_id,ip_address,system_description,system_name,brand from {0}".format(
poller_element["table_name"])
result = conn.select_query(query_string)
poller_element['selected_ip'] = result
return {'data': poller_result}, 200
except Exception as err:
logger.log("Error encountered on Poller : %s" % str(err),
log_type='ERROR')
return eval(str(err)), 422
finally:
db.session.close()
db.engine.dispose()
def __init__(self, poller_id=0):
self.poller_id = poller_id
# self.conn = DatabaseUtil(os.environ.get("DB_CONN"), os.environ.get("DB_USER"), os.environ.get("DB_PASSWORD"), os.environ.get("DB_NAME"))
try:
self.conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
conn = self.conn.get_connection(interval=60)
conn.close()
except Exception as err:
print(err)
sys.exit()
self.logger = None
self.pid_util = None
atexit.register(self.exit_handler)
def __init__(self, table_name=None,orig_table_name=None,fields=[], default=[]):
self.orig_table_name = orig_table_name
self.table = table_name
self.fields = fields
self.default = default
self.db_util = DatabaseUtil(os.environ.get("DB_CONN"), os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"), os.environ.get("DB_NAME"))
def __init__(self,
logs_directory=None,
module_id=None,
module_name=None,
table_name=None,
use_db=True):
self.logs_directory = logs_directory
self.module_name = module_name
self.table_name = table_name
self.module_id = module_id
self.use_db = use_db
try:
self.conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
except Exception as err:
print(err)
exit(0)
def authentication(self):
try:
if self.args['type'] == "API":
if self.auth['authentication_type'] == 'token':
url = "{0}{1}".format(self.auth['host'],
self.auth['token_url'])
auth = requests.post(url,
auth=HTTPBasicAuth(
username=self.auth['username'],
password=self.auth['password']),
verify=False)
return auth.json()
else:
return None
elif self.args['type'] == "Database":
conn = DatabaseUtil(self.auth['host'], self.auth['username'],
self.auth['password'],
self.auth['db_name'])
test_conn = conn.get_connection(api=True)
return conn
except Exception as err:
raise ValueError('Cannot connect to source {0} - {1}'.format(
self.args['type'], self.auth['host']))
class PollPreview:
def __init__(self,prev_config):
self.ip_list = prev_config['ip_list']
self.community_string = prev_config['community_string']
self.oid_list = prev_config['oid_list']
self.conn = DatabaseUtil(os.environ.get("DB_CONN"), os.environ.get("DB_USER"), os.environ.get("DB_PASSWORD"), os.environ.get("DB_NAME"))
def get_oid_prev(self,brand):
oid_list = {"oid_list" :[]}
oid_inner = dict()
for oid_key in self.oid_list:
sql_query = sql_utils.sql_templates["oid_prev"].value
oid_raw = self.conn.jinja_select_query(sql_query, {'oid_key': oid_key,'brand': brand})[0]
oid_inner[oid_raw['oid_key']] = oid_raw['oid']
oid_list['oid_list'] = [oid_inner]
return oid_list
def run(self):
main_data =list()
try:
for prev_info in self.ip_list:
ip_address = prev_info['ip_address']
brand = prev_info['brand']
for_mdd = self.get_oid_prev(brand)
mdd_runner = main_device_details(ip_address , for_mdd , self.community_string)
mdd_output = mdd_runner.run()
mdd_output["ip_address"] = ip_address
main_data.append(mdd_output)
return main_data
except Exception as err:
print('-----------------------')
print(err)
raise ValueError(err)
# prev_config = {
# 'ip_list' : [{'ip_address' : '192.168.1.1' , 'brand' : 'cisco'}],
# 'community_string' : 'trends-ro',
# 'oid_list' : ['cpu' , 'memory']
# }
# sample = PollPreview(prev_config)
# abcd = sample.run()
# print(abcd)
def __init__(self,prev_config):
self.ip_list = prev_config['ip_list']
self.community_string = prev_config['community_string']
self.oid_list = prev_config['oid_list']
self.conn = DatabaseUtil(os.environ.get("DB_CONN"), os.environ.get("DB_USER"), os.environ.get("DB_PASSWORD"), os.environ.get("DB_NAME"))
class start_polling:
def __init__(self, poller_id=0):
self.poller_id = poller_id
# self.conn = DatabaseUtil(os.environ.get("DB_CONN"), os.environ.get("DB_USER"), os.environ.get("DB_PASSWORD"), os.environ.get("DB_NAME"))
try:
self.conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
conn = self.conn.get_connection(interval=60)
conn.close()
except Exception as err:
print(err)
sys.exit()
self.logger = None
self.pid_util = None
atexit.register(self.exit_handler)
def poller_event(self, status):
status = int(status)
try:
self.conn.jinja_update_query(
sql_utils.sql_templates["update_event"].value, {
"status": status,
"id": self.poller_id
})
if status is not 1:
os.kill(os.getpid(), signal.SIGINT)
except Exception as err:
self.logger.log(
'An error has occured while updating poller status: {0}'.
format(err), 'critical')
sys.exit(1)
def get_poller_config(self):
sql_query = sql_utils.sql_templates["poller_config"].value
return self.conn.jinja_select_query(sql_query,
{'poll_id': self.poller_id})
def get_selected_oid(self, id, brand):
oid_list = {"oid_list": []}
oid_inner = dict()
sql_query = sql_utils.sql_templates["oid_config"].value
oid_raw = self.conn.jinja_select_query(sql_query, {
'poll_id': id,
'brand': brand
})
for key, value in enumerate(oid_raw):
oid_inner[value['oid_key']] = value['oid']
oid_list['oid_list'] = [oid_inner]
return oid_list
def get_ip_address(self, table):
ip_list = list()
raw_list = self.conn.select_query(
"""SELECT ip_address from {0}""".format(table))
for key, items in enumerate(raw_list):
ip_list.append(items["ip_address"])
return ip_list
def insert_update(self, device_detail, table_name):
ip_address = device_detail['ip_address']
del device_detail['ip_address']
placeholder = ', '.join('?' * len(device_detail))
update_util = sql_utils.sql_templates["poll_update_up"].value
update_query = update_util.format(
table_name,
', '.join("{0}='{1}'".format(value, device_detail[value])
for key, value in enumerate(device_detail)), ip_address,
self.poller_id)
self.conn.update_query(update_query)
def exit_handler(self):
if self.pid_util:
if str(self.pid_util.read_pid()) == str(os.getpid()):
try:
self.pid_util.delete_pid()
except Exception as err:
self.logger.log(err, 'critical')
def signal_handler(self, signum, frame):
self.exit_handler()
if self.logger:
self.logger.log('Service stopped.')
sys.exit(1)
def create_directory(self, directory):
if not os.path.exists(os.path.join(os.getcwd(), directory)):
os.mkdir(os.path.join(os.getcwd(), directory))
print(directory, 'Directory created.')
def run(self):
self.create_directory(logs_directory)
self.create_directory(pid_directory)
poller_config = self.get_poller_config()
if poller_config:
poller_config = poller_config[0]
subnet = poller_config["subnet"]
community_string = poller_config["community_string"]
interval = poller_config["interval"]
table_name = poller_config["table_name"]
poll_name = poller_config["poll_name"]
self.logger = Logger(logs_directory, self.poller_id, table_name,
'snmp_poller_logs')
self.pid_util = ProcessIdUtil(pid_directory, self.poller_id,
table_name, 'snmp_poller', None)
self.logger.config_logging()
if self.pid_util.is_process_running():
self.logger.log('Already running.')
sys.exit(1)
else:
self.logger.log("[{0}] : Poller running...".format(poll_name))
self.poller_event(1)
ip_list = self.get_ip_address(table_name)
try:
self.pid_util.create_pid()
self.pid_util.save_pid()
except Exception as err:
self.logger.log(err, 'critical')
sys.exit(1)
runner = True
while runner:
# start
for ip_address in ip_list:
mdi_runner = main_device_info(ip_address,
community_string)
mdi_output = mdi_runner.run()
if mdi_output["is_valid"]:
try:
mdi_data = mdi_output["main_info"]
for_mdd = self.get_selected_oid(
self.poller_id, mdi_data['brand'])
mdd_runner = main_device_details(
mdi_data["ip_address"], for_mdd,
community_string)
mdd_output = mdd_runner.run()
mdd_output["ip_address"] = mdi_data[
"ip_address"]
self.insert_update(mdd_output, table_name)
except Exception as err:
self.logger.log(
"[{0}] : Stopped due to an error : {1}".
format(poll_name, err))
self.poller_event('-1')
else:
update_util = sql_utils.sql_templates[
"poll_update_down"].value
update_query = update_util.format(
table_name, ip_address)
self.conn.update_query(update_query)
self.logger.log(
"[{0}] : No SNMP response for {1}".format(
poll_name, ip_address))
time.sleep(2)
#end
time.sleep(interval)
else:
print('Poller does not exist.')
class Logger():
def __init__(self,
logs_directory=None,
module_id=None,
module_name=None,
table_name=None,
use_db=True):
self.logs_directory = logs_directory
self.module_name = module_name
self.table_name = table_name
self.module_id = module_id
self.use_db = use_db
try:
self.conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
except Exception as err:
print(err)
exit(0)
def create_directory(self):
if not os.path.exists(os.path.join(os.getcwd(), self.logs_directory)):
os.mkdir(os.path.join(os.getcwd(), self.logs_directory))
def config_logging(self, use_datetime=False):
module_name = self.module_name.replace(' ', '_').lower()
now = datetime.datetime.now()
if use_datetime:
module_name = module_name + '_' + now.strftime("%Y%m%d")
log_handler = TimedRotatingFileHandler(os.path.join(
os.getcwd(), self.logs_directory, module_name + '.log'),
when='midnight')
log_formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(message)s', '%Y-%m-%d %H:%M:%S')
log_handler.setFormatter(log_formatter)
log_handler.suffix = '%Y%m%d'
self.logger = logging.getLogger('logger')
self.logger.addHandler(log_handler)
self.logger.setLevel(logging.INFO)
def log(self, description, log_type='INFO'):
log = ""
if self.use_db:
log = '{0} ({1}) : {2}'.format(self.module_name, self.module_id,
description)
print(log)
else:
log = '{0} : {1}'.format(self.module_name, description)
log_type = str(log_type).upper()
if log_type == 'CRITICAL':
self.logger.critical(log)
elif log_type == 'WARNING':
self.logger.warning(log)
elif log_type == 'ERROR':
self.logger.error(log)
elif log_type == 'DEBUG':
self.logger.debug(log)
else:
self.logger.info(log)
log = log.replace('\'', '\"')
if self.use_db:
query_string = 'INSERT INTO {0} values ({1}, \'{2}\', \'{3}\', DEFAULT)'.format(
self.table_name, self.module_id, log_type, log)
try:
self.conn.insert_query(query_string)
except Exception as err:
log = '{0} ({1}) : {2}'.format(self.module_name,
self.module_id, err)
print(log)
class ProcessIdUtil():
def __init__(self, pid_directory, id, module_name, table_name, logger):
self.pid_directory = pid_directory
self.id = id
self.module_name = module_name.replace(' ', '_').lower()
self.table_name = table_name
self.logger = logger
self.conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"), self.logger)
def create_directory(self):
if not os.path.exists(os.path.join(os.getcwd(), self.pid_directory)):
os.mkdir(os.path.join(os.getcwd(), self.pid_directory))
print(self.pid_directory, 'created.')
def create_pid(self):
try:
with open(
os.path.join(os.getcwd(), self.pid_directory,
str(self.module_name) + '.pid'), 'w') as file:
file.write(str(os.getpid()))
except Exception as err:
raise ValueError("Error encountered in creating PID: %s" % (err))
def read_pid(self):
try:
f = open(
os.path.join(os.getcwd(), self.pid_directory,
str(self.module_name) + '.pid'), 'r')
contents = f.read()
f.close()
return contents
except FileNotFoundError:
return False
def delete_pid(self):
try:
os.remove(
os.path.join(os.getcwd(), self.pid_directory,
str(self.module_name) + '.pid'))
except Exception as err:
raise ValueError("Error encountered in deleting PID: %s" % (err))
def save_pid(self, pid=None):
try:
if pid:
query_string = 'UPDATE {0} SET pid = {1} WHERE id = {2}'.format(
self.table_name, pid, self.id)
else:
query_string = 'UPDATE {0} SET pid = {1} WHERE id = {2}'.format(
self.table_name, os.getpid(), self.id)
self.conn.insert_query(query_string)
except Exception as err:
raise ValueError("Error encountered in creating PID: %s" % (err))
def get_pid(self):
try:
query_string = 'SELECT pid FROM {0} WHERE id = {1}'.format(
self.table_name, self.id)
pid = self.conn.select_query(query_string)
return pid[0]['pid']
except Exception as err:
raise ValueError("Error encountered in getting PID: %s" % (err))
def is_pid_running(self, pid):
# services = ['worker.exe', 'aggregate.exe','visionapi.exe']
services = ['worker.py', 'aggregate.py', 'VisionAPI.py', 'poller.py']
# check if pid exists
if psutil.pid_exists(pid):
process = psutil.Process(pid)
if process.name() == 'python.exe' and (
process.cmdline()[1] and process.cmdline()[1] in services):
return True
# if pid does not exist, check if command exists
for process in psutil.process_iter():
try:
if len(process.cmdline()) == 3:
if process.name() == 'python.exe' and (
process.cmdline()[1] and process.cmdline()[1]
in services) and process.cmdline()[2] == self.id:
if process.pid != os.getpid():
self.save_pid(process.pid)
return True
except (psutil.NoSuchProcess, psutil.AccessDenied,
psutil.ZombieProcess):
pass
return False
def is_process_running(self):
db_pid = self.get_pid()
db_pid_running = self.is_pid_running(db_pid)
if self.read_pid():
file_pid = int(self.read_pid())
file_pid_running = self.is_pid_running(file_pid)
if file_pid_running and db_pid_running:
return True
else:
if db_pid_running:
return True
return False
def is_process_running_without_db(self):
if self.read_pid():
file_pid = int(self.read_pid())
file_pid_running = self.is_pid_running(file_pid)
if file_pid_running:
return True
return False
def post(self):
conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
args = self.api_utils.parameters(self.main_model(),
blacklist="append",
selected_oid="append",
ip_list="append")
list_of_ids = {}
try:
blacklist = list(eval(items) for items in list(args['blacklist']))
selected_oid = list(filter(None, args['selected_oid']))
ip_list = list(eval(items) for items in list(args['ip_list']))
del args['ip_list']
del args['blacklist']
del args['selected_oid']
SnmpPollerSchema().load(args)
if (selected_oid and ip_list) and self.api_utils.ip_validator(
ip_list) and self.api_utils.ip_validator(
blacklist) and self.api_utils.oid_validator(
conn, selected_oid):
poller_data = self.main_schema().load(args)
poller_result = self.db_utils.insert_data(self.module_name,
self.main_model,
poller_data,
commit=True)
list_of_ids['snmp_poller'] = poller_result
if blacklist is not None:
for blacklist_element in blacklist:
blacklist_obj = {}
blacklist_obj['ip_address'] = blacklist_element[
'ip_address']
blacklist_obj['snmp_poller_id'] = poller_result
blacklist_obj[
'system_description'] = blacklist_element[
'system_description']
blacklist_obj['system_name'] = blacklist_element[
'system_name']
blacklist_obj['brand'] = blacklist_element['brand']
blacklist_data = BlacklistSchema().load(blacklist_obj)
blacklist_result = self.db_utils.insert_data(
self.module_name,
Blacklist,
blacklist_data,
commit=True)
list_of_ids['blacklist'] = blacklist_result
if selected_oid is not None:
for selected_oid_element in selected_oid:
selected_oid_obj = {}
selected_oid_obj['oid_key'] = selected_oid_element
selected_oid_obj['snmp_poller_id'] = poller_result
selected_oid_data = SelectedOidSchema().load(
selected_oid_obj)
selected_oid_result = self.db_utils.insert_data(
self.module_name,
SelectedOid,
selected_oid_data,
commit=True)
list_of_ids['selected_oid'] = selected_oid_result
oid_raw = conn.select_query('Select oid_key from oid_list')
oid_main = [oid['oid_key'] for oid in oid_raw]
oid_main.extend([
'ip_address', 'status', 'brand', 'system_description',
'system_name'
])
SchemaBuilder(args['table_name'],
fields=oid_main).create_table(default_date=True)
SchemaBuilder().create_data_retention(args['table_name'])
conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
query_string = 'INSERT INTO {0} (ip_address,system_description,brand,system_name) values ({1})'.format(
args['table_name'],
'%(ip_address)s,%(system_description)s,%(brand)s ,%(system_name)s'
)
conn.insert_many_query(query_string, ip_list)
args['snmp_poller_id'] = poller_result
logger.log("Inserted data to SNMP Poller. Status CREATED 201")
return {
'message': 'Successfully added.',
'snmp_poller_payload': args
}, 201
else:
return {
'message': 'Payload verification failed.',
'snmp_poller_payload': args
}, 422
except ValidationError as value_error:
logger.log("Validation encountered on SNMP poller table: %s" %
(str(value_error)),
log_type='ERROR')
self.db_utils.data_rollback(list_of_ids)
return {
'lists': value_error.messages,
'type': 'ValidationError',
'message': 'Validation errors in your request'
}, 422
except Exception as err:
logger.log("Error encountered on SNMP poller : %s" % str(err),
log_type='ERROR')
self.db_utils.data_rollback(list_of_ids)
return eval(str(err)), 422
class SnmpPollerApi(Resource):
api_utils = ApiUtils()
db_utils = DatabaseUtils()
db_util_raw = DatabaseUtil()
main_model = SnmpPoller
main_schema = SnmpPollerSchema
service = ServiceManager(module_name='poller')
module_name = 'SNMP Poller'
def get(self, id=None, show=None, status=None):
args = self.api_utils.optional_parameters()
try:
poller_session = self.db_utils.model_session(self.main_model)
if id is not None:
poller_session = poller_session.filter(
self.main_model.id == id)
poller_session = poller_session.order_by(
self.main_model.id.desc()).all()
schema_option = self.api_utils.schema_options(
self.main_schema, args['columns'])
poller_result = self.main_schema(
**schema_option).dump(poller_session)
poller_result = self.api_utils.get_paginated_list(
poller_result, args['start'], args['limit'])
for poller_element in poller_result:
if 'blacklist' in args['include']:
blacklist = self.db_utils.select_with_filter(
Blacklist, BlacklistSchema,
{'snmp_poller_id': poller_element['id']})
poller_element['blacklist'] = blacklist
if 'selected_oid' in args['include']:
selected_oid = self.db_utils.select_with_filter(
SelectedOid, SelectedOidSchema,
{'snmp_poller_id': poller_element['id']})
poller_element['selected_oid'] = selected_oid
if 'selected_ips' in args['include']:
conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
query_string = "Select {0}_id,ip_address,system_description,system_name,brand from {0}".format(
poller_element["table_name"])
result = conn.select_query(query_string)
poller_element['selected_ip'] = result
return {'data': poller_result}, 200
except Exception as err:
logger.log("Error encountered on Poller : %s" % str(err),
log_type='ERROR')
return eval(str(err)), 422
finally:
db.session.close()
db.engine.dispose()
def post(self):
conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
args = self.api_utils.parameters(self.main_model(),
blacklist="append",
selected_oid="append",
ip_list="append")
list_of_ids = {}
try:
blacklist = list(eval(items) for items in list(args['blacklist']))
selected_oid = list(filter(None, args['selected_oid']))
ip_list = list(eval(items) for items in list(args['ip_list']))
del args['ip_list']
del args['blacklist']
del args['selected_oid']
SnmpPollerSchema().load(args)
if (selected_oid and ip_list) and self.api_utils.ip_validator(
ip_list) and self.api_utils.ip_validator(
blacklist) and self.api_utils.oid_validator(
conn, selected_oid):
poller_data = self.main_schema().load(args)
poller_result = self.db_utils.insert_data(self.module_name,
self.main_model,
poller_data,
commit=True)
list_of_ids['snmp_poller'] = poller_result
if blacklist is not None:
for blacklist_element in blacklist:
blacklist_obj = {}
blacklist_obj['ip_address'] = blacklist_element[
'ip_address']
blacklist_obj['snmp_poller_id'] = poller_result
blacklist_obj[
'system_description'] = blacklist_element[
'system_description']
blacklist_obj['system_name'] = blacklist_element[
'system_name']
blacklist_obj['brand'] = blacklist_element['brand']
blacklist_data = BlacklistSchema().load(blacklist_obj)
blacklist_result = self.db_utils.insert_data(
self.module_name,
Blacklist,
blacklist_data,
commit=True)
list_of_ids['blacklist'] = blacklist_result
if selected_oid is not None:
for selected_oid_element in selected_oid:
selected_oid_obj = {}
selected_oid_obj['oid_key'] = selected_oid_element
selected_oid_obj['snmp_poller_id'] = poller_result
selected_oid_data = SelectedOidSchema().load(
selected_oid_obj)
selected_oid_result = self.db_utils.insert_data(
self.module_name,
SelectedOid,
selected_oid_data,
commit=True)
list_of_ids['selected_oid'] = selected_oid_result
oid_raw = conn.select_query('Select oid_key from oid_list')
oid_main = [oid['oid_key'] for oid in oid_raw]
oid_main.extend([
'ip_address', 'status', 'brand', 'system_description',
'system_name'
])
SchemaBuilder(args['table_name'],
fields=oid_main).create_table(default_date=True)
SchemaBuilder().create_data_retention(args['table_name'])
conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
query_string = 'INSERT INTO {0} (ip_address,system_description,brand,system_name) values ({1})'.format(
args['table_name'],
'%(ip_address)s,%(system_description)s,%(brand)s ,%(system_name)s'
)
conn.insert_many_query(query_string, ip_list)
args['snmp_poller_id'] = poller_result
logger.log("Inserted data to SNMP Poller. Status CREATED 201")
return {
'message': 'Successfully added.',
'snmp_poller_payload': args
}, 201
else:
return {
'message': 'Payload verification failed.',
'snmp_poller_payload': args
}, 422
except ValidationError as value_error:
logger.log("Validation encountered on SNMP poller table: %s" %
(str(value_error)),
log_type='ERROR')
self.db_utils.data_rollback(list_of_ids)
return {
'lists': value_error.messages,
'type': 'ValidationError',
'message': 'Validation errors in your request'
}, 422
except Exception as err:
logger.log("Error encountered on SNMP poller : %s" % str(err),
log_type='ERROR')
self.db_utils.data_rollback(list_of_ids)
return eval(str(err)), 422
# edit
def put(self, id=None):
args = self.api_utils.parameters(self.main_model(),
blacklist="append",
selected_oid="append",
ip_list="append")
poller_id = id
conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
poll_data = conn.select_query(
'Select status from snmp_poller where id = {0}'.format(poller_id))
if not poll_data:
return {
'message': "ID doesn't exist",
"type": "ReferenceError"
}, 422
poll_status = poll_data[0]['status']
list_of_ids = {}
if poll_status != 1:
try:
blacklist = list(
eval(items) for items in list(args['blacklist']))
selected_oid = list(filter(None, args['selected_oid']))
ip_list = list(eval(items) for items in list(args['ip_list']))
del args['ip_list']
del args['blacklist']
del args['selected_oid']
SnmpPollerSchema().load(args)
if (selected_oid and ip_list) and self.api_utils.ip_validator(
ip_list) and self.api_utils.ip_validator(
blacklist) and self.api_utils.oid_validator(
conn, selected_oid):
if blacklist is not None:
self.db_utils.delete_data_using_id(
Blacklist, {'snmp_poller_id': poller_id})
for blacklist_element in blacklist:
blacklist_obj = {}
blacklist_obj['ip_address'] = blacklist_element[
'ip_address']
blacklist_obj[
'system_description'] = blacklist_element[
'system_description']
blacklist_obj['system_name'] = blacklist_element[
'system_name']
blacklist_obj['brand'] = blacklist_element['brand']
blacklist_obj['snmp_poller_id'] = poller_id
blacklist_data = BlacklistSchema().load(
blacklist_obj)
blacklist_result = self.db_utils.insert_data(
self.module_name,
Blacklist,
blacklist_data,
commit=True)
list_of_ids['blacklist'] = blacklist_result
if selected_oid is not None:
self.db_utils.delete_data_using_id(
SelectedOid, {'snmp_poller_id': poller_id})
for selected_oid_element in selected_oid:
selected_oid_obj = {}
selected_oid_obj['oid_key'] = selected_oid_element
selected_oid_obj['snmp_poller_id'] = poller_id
selected_oid_data = SelectedOidSchema().load(
selected_oid_obj)
selected_oid_result = self.db_utils.insert_data(
self.module_name,
SelectedOid,
selected_oid_data,
commit=True)
list_of_ids['selected_oid'] = selected_oid_result
if ip_list is not None:
table_name = conn.select_query(
'Select table_name from snmp_poller where id = %s '
% (poller_id))[0]
new_table_name = table_name["table_name"]
conn.truncate_table('Truncate table %s ' %
(new_table_name))
query_string = 'INSERT INTO {0} (ip_address,system_description,brand,system_name) values ({1})'.format(
new_table_name,
'%(ip_address)s,%(system_description)s,%(brand)s ,%(system_name)s'
)
conn.insert_many_query(query_string, ip_list)
del args['table_name']
args['status'] = 0
args['pid'] = 0
self.db_utils.update_data(self.main_model,
{'id': poller_id},
args,
commit=True)
args['snmp_poller_id'] = poller_id
logger.log("Update SNMP Poller. Status Succesful 200")
return {
'message': 'Update Successful.',
'snmp_poller_payload': args
}, 200
else:
return {
'message': 'Payload verification failed.',
'snmp_poller_payload': args
}, 422
except ValidationError as value_error:
logger.log("Validation encountered on SNMP poller table: %s" %
(str(value_error)),
log_type='ERROR')
self.db_utils.data_rollback(list_of_ids)
return {
'lists': value_error.messages,
'type': 'ValidationError',
'message': 'Validation errors in your request'
}, 422
except Exception as err:
logger.log("Error encountered on SNMP poller : %s" % str(err),
log_type='ERROR')
self.db_utils.data_rollback(list_of_ids)
return eval(str(err)), 422
else:
return {'message': "Update unsuccessfull. Poller is running."}, 422
def delete(self, id=None):
try:
get_table_name = None
poller = self.db_utils.select_with_filter(self.main_model,
self.main_schema,
{'id': id})
if poller:
# poller_tasklist = self.service.check_service(poller[0]['pid'], 'poller.exe')
poller_tasklist = self.service.check_service(
poller[0]['pid'], 'poller.py')
if 'image name' in str(
poller_tasklist.decode("utf-8")).lower():
raise ValueError(
ErrorObject(type="ServiceError",
message="Poller is running.").to_json())
delete_status = self.db_utils.delete_data_using_id(
SnmpPoller, {'id': id})
get_table_name = poller[0]['table_name']
self.db_utils.drop_table(get_table_name)
logger.log("Deleting the data on SNMP Poller, id : %s" % (id))
return {'message': "Successfully deleted."}, 200
else:
logger.log("Encountered error on poller: ID doesn't exist",
log_type='ERROR')
return {
'message': "ID doesn't exist",
"type": "ReferenceError"
}, 422
except Exception as err:
logger.log("Error encountered on SNMP Poller : %s" % str(err),
log_type='ERROR')
return eval(str(err)), 422
def put(self, id=None):
args = self.api_utils.parameters(self.main_model(),
blacklist="append",
selected_oid="append",
ip_list="append")
poller_id = id
conn = DatabaseUtil(os.environ.get("DB_CONN"),
os.environ.get("DB_USER"),
os.environ.get("DB_PASSWORD"),
os.environ.get("DB_NAME"))
poll_data = conn.select_query(
'Select status from snmp_poller where id = {0}'.format(poller_id))
if not poll_data:
return {
'message': "ID doesn't exist",
"type": "ReferenceError"
}, 422
poll_status = poll_data[0]['status']
list_of_ids = {}
if poll_status != 1:
try:
blacklist = list(
eval(items) for items in list(args['blacklist']))
selected_oid = list(filter(None, args['selected_oid']))
ip_list = list(eval(items) for items in list(args['ip_list']))
del args['ip_list']
del args['blacklist']
del args['selected_oid']
SnmpPollerSchema().load(args)
if (selected_oid and ip_list) and self.api_utils.ip_validator(
ip_list) and self.api_utils.ip_validator(
blacklist) and self.api_utils.oid_validator(
conn, selected_oid):
if blacklist is not None:
self.db_utils.delete_data_using_id(
Blacklist, {'snmp_poller_id': poller_id})
for blacklist_element in blacklist:
blacklist_obj = {}
blacklist_obj['ip_address'] = blacklist_element[
'ip_address']
blacklist_obj[
'system_description'] = blacklist_element[
'system_description']
blacklist_obj['system_name'] = blacklist_element[
'system_name']
blacklist_obj['brand'] = blacklist_element['brand']
blacklist_obj['snmp_poller_id'] = poller_id
blacklist_data = BlacklistSchema().load(
blacklist_obj)
blacklist_result = self.db_utils.insert_data(
self.module_name,
Blacklist,
blacklist_data,
commit=True)
list_of_ids['blacklist'] = blacklist_result
if selected_oid is not None:
self.db_utils.delete_data_using_id(
SelectedOid, {'snmp_poller_id': poller_id})
for selected_oid_element in selected_oid:
selected_oid_obj = {}
selected_oid_obj['oid_key'] = selected_oid_element
selected_oid_obj['snmp_poller_id'] = poller_id
selected_oid_data = SelectedOidSchema().load(
selected_oid_obj)
selected_oid_result = self.db_utils.insert_data(
self.module_name,
SelectedOid,
selected_oid_data,
commit=True)
list_of_ids['selected_oid'] = selected_oid_result
if ip_list is not None:
table_name = conn.select_query(
'Select table_name from snmp_poller where id = %s '
% (poller_id))[0]
new_table_name = table_name["table_name"]
conn.truncate_table('Truncate table %s ' %
(new_table_name))
query_string = 'INSERT INTO {0} (ip_address,system_description,brand,system_name) values ({1})'.format(
new_table_name,
'%(ip_address)s,%(system_description)s,%(brand)s ,%(system_name)s'
)
conn.insert_many_query(query_string, ip_list)
del args['table_name']
args['status'] = 0
args['pid'] = 0
self.db_utils.update_data(self.main_model,
{'id': poller_id},
args,
commit=True)
args['snmp_poller_id'] = poller_id
logger.log("Update SNMP Poller. Status Succesful 200")
return {
'message': 'Update Successful.',
'snmp_poller_payload': args
}, 200
else:
return {
'message': 'Payload verification failed.',
'snmp_poller_payload': args
}, 422
except ValidationError as value_error:
logger.log("Validation encountered on SNMP poller table: %s" %
(str(value_error)),
log_type='ERROR')
self.db_utils.data_rollback(list_of_ids)
return {
'lists': value_error.messages,
'type': 'ValidationError',
'message': 'Validation errors in your request'
}, 422
except Exception as err:
logger.log("Error encountered on SNMP poller : %s" % str(err),
log_type='ERROR')
self.db_utils.data_rollback(list_of_ids)
return eval(str(err)), 422
else:
return {'message': "Update unsuccessfull. Poller is running."}, 422