def put(self, jwt, command_id): if command_id is None: return jsonify(error=True) command = Command.get_by_id(command_id) if command is None: return jsonify(error=True) if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() command_line = post_data.get('command_line') if not command_line: return jsonify(error=True,msg="Command line empty.") command.command_line = command_line writeNagiosCommandsConfigFile(command) if restartNagios() == False: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") db.session.commit() return jsonify(data=command.serialize()) except Exception as e: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) finally: db.session.close() return jsonify(error=True)
def put(self, jwt, contactgroup_id): if contactgroup_id is None: return jsonify(error=True) contactgroup = ContactGroup.get_by_id(contactgroup_id) if contactgroup is None: return jsonify(error=True) if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() contactgroup_name = post_data.get('contactgroup_name') alias = post_data.get('alias') if contactgroup_name is not None: contactgroup.contactgroup_name = contactgroup_name if alias is not None: contactgroup.alias = alias writeNagiosContactGroupsConfigFile(contactgroup) if restartNagios() == False: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") db.session.commit() return jsonify(data=contactgroup.serialize()) except Exception as e: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) finally: db.session.close() return jsonify(error=True)
def delete(self, jwt, service_id): if service_id is None: return jsonify(error=True) service = Service.get_by_id(service_id) if service is None: return jsonify(error=True) else: try: Service.delete_all_hosts_relations(service_id) Service.delete_all_contacts_relations(service_id) Service.delete_all_contactgroups_relations(service_id) Service.delete_all_servicegroups_relations(service_id) Service.delete_all_servicetemplate_relations(service_id) service = Service.get_by_id(service_id) deleteNagiosServicesConfigFile(service) service.delete() if not restartNagios(): syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") return jsonify(error=False) except Exception as e: syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e))
def post(self, jwt): if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() command_name = post_data.get('command_name') command_line = post_data.get('command_line') # check if input data is empty if not command_name: return jsonify(error=True,msg="Command name empty.") if not command_line: return jsonify(error=True,msg="Command line empty.") #Confirm this contact_name doesn't already exist first. if Command.get_by_commandname(command_name): return jsonify(error=True,msg="Command name already exists.") newcommand = Command( command_name = command_name, command_line = command_line ) db.session.add(newcommand) writeNagiosCommandsConfigFile(newcommand) if restartNagios() == False: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") db.session.commit() return jsonify(data=newcommand.serialize()) except Exception as e: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) finally: db.session.close() return jsonify(error=True)
def post(self, jwt): if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() contactgroup_name = post_data.get('contactgroup_name') alias = post_data.get('alias') if contactgroup_name is None: return jsonify(error=True, msg="Missing contactgroup_name required field.") #Confirm this contactgroup_name doesn't already exist first. if ContactGroup.get_by_contactgroupname(contactgroup_name): return jsonify(error=True,msg="Contactgroup name already exists.") newcontactgroup = ContactGroup( contactgroup_name = contactgroup_name, alias = alias, members = None, contactgroup_members = None ) db.session.add(newcontactgroup) db.session.flush() writeNagiosContactGroupsConfigFile(newcontactgroup) if restartNagios() == False: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") db.session.commit() return jsonify(data=newcontactgroup.serialize()) except Exception as e: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) finally: db.session.close() return jsonify(error=True)
def delete(self, jwt, contactgroup_id): if contactgroup_id is None: return jsonify(error=True) contactgroup = ContactGroup.get_by_id(contactgroup_id) if contactgroup is None: return jsonify(error=True) else: try: deleteNagiosContactGroupsConfigFile(contactgroup) db.session.delete(contactgroup) # process contact_contactgroup table relations = Contact2Group.query.filter_by(contactgroup_id=contactgroup_id).all() relation_contact_ids = [] if relations is not None: for relation in relations: relation_contact_ids.append(relation.contact_id) # delete from contact_contactgroup table connection = db.session.connection() connection.execute("DELETE FROM contact_contactgroup WHERE contactgroup_id = '%s'", (contactgroup_id)) # update contact table for relation_contact_id in relation_contact_ids: contact = Contact.get_by_id(relation_contact_id) if contact is None: continue connection = db.session.connection() result = connection.execute( "SELECT GROUP_CONCAT(B.contactgroup_name) contactgroup_names FROM contact_contactgroup A" + " LEFT JOIN contactgroups B ON A.contactgroup_id=B.id" + " WHERE A.contact_id = '%s'" + " GROUP BY A.contact_id" , (contact.id)) if len(result._saved_cursor._result.rows) == 0: contact.contactgroups = '' writeNagiosContactsConfigFile(contact) else: for row in result: contactgroup_names_str = row['contactgroup_names'] contact.contactgroups = contactgroup_names_str writeNagiosContactsConfigFile(contact) break # process contactgroup_service table csrelations = ContactgroupService.query.filter_by(contactgroup_id=contactgroup_id).all() relation_service_ids = [] if csrelations is not None: for csrelation in csrelations: relation_service_ids.append(csrelation.service_id) # delete from contactgroup_service table connection = db.session.connection() connection.execute("DELETE FROM contactgroup_service WHERE contactgroup_id = '%s'", (contactgroup_id)) # update service table for relation_service_id in relation_service_ids: service = Service.get_by_id(relation_service_id) if service is None: continue connection = db.session.connection() result = connection.execute( "SELECT GROUP_CONCAT(B.contactgroup_name) contactgroup_names FROM contactgroup_service A" + " LEFT JOIN contactgroups B ON A.contactgroup_id=B.id" + " WHERE A.service_id = '%s'" + " GROUP BY A.service_id" , (service.id)) if len(result._saved_cursor._result.rows) == 0: service.contact_groups = '' tmp_checkInterval = service.check_interval service.check_interval = round(int(service.check_interval) / 60, 1) writeNagiosServicesConfigFile(service) service.check_interval = tmp_checkInterval else: for row in result: contactgroup_names_str = row['contactgroup_names'] service.contact_groups = contactgroup_names_str tmp_checkInterval = service.check_interval service.check_interval = round(int(service.check_interval) / 60, 1) writeNagiosServicesConfigFile(service) service.check_interval = tmp_checkInterval break if restartNagios() == False: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") db.session.commit() return jsonify(error=False) except Exception as e: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) finally: db.session.close() return jsonify(error=True)
def post(self, jwt): if not 'file' in request.files: return jsonify(error=True, msg="Request contains no files.") file = request.files['file'] if file.filename == '': return jsonify(error=True, msg="No selected file") failed_entries = dict() if file and allowed_file(file.filename, ['cfg']): data = parse_cfg(file.read().decode("utf-8")) if not data: return jsonify(error=True, msg='Failed to parse: {}'.format(file.filename)) for category in data: category_model = get_category_model(category) eval_cols = category_model.eval_columns() if not category_model: return jsonify( error=True, msg='Unsupported category: {}.'.format(category)) cols_default_mapping = category_model.cols_default_mapping() if category == 'host': for index, each in enumerate(cols_default_mapping): if each[0] == 'active_checks_enabled': cols_default_mapping[index][1] = True elif each[0] == 'passive_checks_enabled': cols_default_mapping[index][1] = True elif each[0] == 'check_period': cols_default_mapping[index][1] = "24x7" all_rows = data[category] failed_rows = [] model_objects = [] for row in all_rows: init_args = [] for col_name, default_val in category_model.cols_default_mapping( ): val = row.get(col_name) if val: if col_name in eval_cols: val = literal_eval( val.strip()) if val else default_val else: val = default_val init_args.append(val) model_objects.append(category_model(*init_args)) for model_obj in model_objects: try: model_obj.insert_or_update() except IntegrityError as ie: print(ie) # Todo log warn category_model.rollback() failed_rows.append({ 'reason': 'IntegrityError', 'data': model_obj.serialize() }) except Exception as e: print(e) # Todo log warn category_model.rollback() failed_rows.append({ 'reason': 'Unknown', 'data': model_obj.serialize() }) if failed_rows: failed_entries[category] = failed_rows overwriteAllNagiosConfigFiles() restartNagios() if failed_entries: return jsonify(error=True, msg='Not all config data got insert.', failed_rows=failed_entries) return jsonify(error=False, msg='successful') return jsonify(error=False, msg='File format no supported.')
def post(self, jwt, category): if not 'file' in request.files: return jsonify(error=True, msg="Request contains no files.") file = request.files['file'] if file.filename == '': return jsonify(error=True, msg="No selected file") if file and allowed_file(file.filename, ['csv']): df = pd.read_csv(file) df = df.where((pd.notnull(df)), None) category_model = get_category_model(category) if not category_model: return jsonify( error=True, msg='Unsupported category: {}.'.format(category)) if category == 'hosts': df['active_checks_enabled'] = True df['passive_checks_enabled'] = True df['check_period'] = "24x7" all_rows = df.to_dict(orient='records') failed_rows = [] model_objects = [] for row in all_rows: init_args = [ row.get(col_name, default_val) for col_name, default_val in category_model.cols_default_mapping() ] model_objects.append(category_model(*init_args)) for model_obj in model_objects: try: model_obj.insert_or_update() except IntegrityError as ie: print(ie) #Todo log warn category_model.rollback() failed_rows.append({ 'reason': 'IntegrityError', 'data': model_obj.serialize() }) except Exception as e: print(e) # Todo log warn category_model.rollback() failed_rows.append({ 'reason': 'Unknown', 'data': model_obj.serialize() }) overwriteAllNagiosConfigFiles() restartNagios() if failed_rows: return jsonify(error=True, msg='Not all rows got insert.', failed_rows=failed_rows) return jsonify(error=False, msg='successful') return jsonify(error=False, msg='File format no supported.')
def post(self, jwt): if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() contact_name = post_data.get('contact_name') alias = post_data.get('alias') email = post_data.get('email') text_number = int(post_data.get('_text_number')) if post_data.get('_text_number') else None contactgroups = post_data.get('contactgroups') contacttemplates = post_data.get('use') host_notifications_enabled = 1 if post_data.get('host_notifications_enabled') == True else 0 host_notification_period = post_data.get('host_notification_period') host_notification_options = ','.join(post_data.get('host_notification_options')) host_notification_commands = 'notify-host-by-email' if len(post_data.get('host_notification_commands')) > 0: host_notification_commands = ','.join(post_data.get('host_notification_commands')) service_notifications_enabled = 1 if post_data.get('service_notifications_enabled') == True else 0 service_notification_period = post_data.get('service_notification_period') service_notification_commands = 'notify-service-by-email' if len(post_data.get('service_notification_commands')) > 0: service_notification_commands = ','.join(post_data.get('service_notification_commands')) # service_notification_options = ','.join(post_data.get('service_notification_options')) service_notification_options = 1 contactgroups_str = '' contacttemplates_str = '' #Confirm this contact_name doesn't already exist first. if Contact.get_by_contactname(contact_name): return jsonify(error=True, msg="Contact name already exists.") if contact_name is None: return jsonify(error=True, msg="Missing contact_name required field.") if contactgroups is not None and len(contactgroups) > 0: contactgroups_str = ','.join(contactgroups) if contacttemplates is not None and len(contacttemplates) > 0: contacttemplates_str = ','.join(contacttemplates) newcontact = Contact( contact_name=contact_name, alias=alias, contactgroups=contactgroups_str, minimum_importance=1, host_notifications_enabled=host_notifications_enabled, service_notifications_enabled=service_notifications_enabled, host_notification_period=host_notification_period, service_notification_period=service_notification_period, host_notification_options=host_notification_options, service_notification_options=service_notification_options, host_notification_commands=host_notification_commands, service_notification_commands=service_notification_commands, email=email, pager="", addressx="", can_submit_commands=1, retain_status_information=1, retain_nonstatus_information=1, use=contacttemplates_str, text_number=text_number ) db.session.add(newcontact) db.session.flush() writeNagiosContactsConfigFile(newcontact) for contactgroup_name in contactgroups: contactgroup = ContactGroup.get_by_contactgroupname(contactgroup_name) if contactgroup is None: continue # insert contact_contactgroup table newrelation = Contact2Group( contact_id = newcontact.id, contactgroup_id = contactgroup.id ) db.session.add(newrelation) db.session.flush() # update members field of contactgroups table contact_names_str = "" connection = db.session.connection() result = connection.execute( "SELECT GROUP_CONCAT(B.contact_name) contact_names FROM contact_contactgroup A" + " LEFT JOIN contacts B ON A.contact_id=B.id" + " WHERE A.contactgroup_id = '%s'" + " GROUP BY A.contactgroup_id" , (contactgroup.id)) for row in result: contact_names_str = row['contact_names'] contactgroup.members = contact_names_str writeNagiosContactGroupsConfigFile(contactgroup) break for contacttemplate_name in contacttemplates: contacttemplate = ContactTemplate.get_by_contacttemplatename(contacttemplate_name) if contacttemplate is None: continue # insert contact_contacttemplate table newrelation = Contact2Template( contact_id = newcontact.id, contacttemplate_id = contacttemplate.id ) db.session.add(newrelation) db.session.flush() if restartNagios() == False: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") db.session.commit() return jsonify(data=newcontact.serialize()) except Exception as e: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) finally: db.session.close() return jsonify(error=True)
def put(self, jwt, contact_id): if contact_id is None: return jsonify(error=True) contact = Contact.get_by_id(contact_id) if contact is None: return jsonify(error=True) if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() contact_name = post_data.get('contact_name') alias = post_data.get('alias') email = post_data.get('email') text_number = int(post_data.get('_text_number')) if post_data.get('_text_number') else None contactgroups = post_data.get('contactgroups') contacttemplates = post_data.get('use') host_notifications_enabled = 1 if post_data.get('host_notifications_enabled') == True else 0 host_notification_period = post_data.get('host_notification_period') host_notification_options = ','.join(post_data.get('host_notification_options')) host_notification_commands = 'notify-host-by-email' if len(post_data.get('host_notification_commands')) > 0: host_notification_commands = ','.join(post_data.get('host_notification_commands')) service_notifications_enabled = 1 if post_data.get('service_notifications_enabled') == True else 0 service_notification_period = post_data.get('service_notification_period') service_notification_commands = 'notify-service-by-email' if len(post_data.get('service_notification_commands')) > 0: service_notification_commands = ','.join(post_data.get('service_notification_commands')) # service_notification_options = ','.join(post_data.get('service_notification_options')) service_notification_options = 1 contactgroup_names_to_update = [] if contact.contactgroups: contactgroup_names_to_update = contactgroup_names_to_update + contact.contactgroups.split(',') if contactgroups: contactgroup_names_to_update = contactgroup_names_to_update + contactgroups if contact_name is not None: contact.contact_name = contact_name if alias is not None: contact.alias = alias if email is not None: contact.email = email if text_number is not None: contact.text_number = text_number if contactgroups is not None: contact.contactgroups = ','.join(contactgroups) if contacttemplates is not None: contact.use = ','.join(contacttemplates) if host_notifications_enabled is not None: contact.host_notifications_enabled = host_notifications_enabled if host_notification_options is not None: contact.host_notification_options = host_notification_options if host_notification_commands is not None: contact.host_notification_commands = host_notification_commands if host_notification_period is not None: contact.host_notification_period = host_notification_period if service_notifications_enabled is not None: contact.service_notifications_enabled = service_notifications_enabled if service_notification_period is not None: contact.service_notification_period = service_notification_period if service_notification_commands is not None: contact.service_notification_commands = service_notification_commands if service_notification_options is not None: contact.service_notification_options = service_notification_options writeNagiosContactsConfigFile(contact) # update contact_contactgroup table connection = db.session.connection() connection.execute("DELETE FROM contact_contactgroup WHERE contact_id = '%s'", (contact.id)) for contactgroup_name in contactgroups: contactgroup = ContactGroup.get_by_contactgroupname(contactgroup_name) if contactgroup is None: continue newrelation = Contact2Group( contact_id = contact.id, contactgroup_id = contactgroup.id ) db.session.add(newrelation) db.session.flush() # update contact_contacttemplate table connection = db.session.connection() connection.execute("DELETE FROM contact_contacttemplate WHERE contact_id = '%s'", (contact.id)) for contacttemplate_name in contacttemplates: contacttemplate = ContactTemplate.get_by_contacttemplatename(contacttemplate_name) if contacttemplate is None: continue # insert contact_contacttemplate table newrelation = Contact2Template( contact_id = contact.id, contacttemplate_id = contacttemplate.id ) db.session.add(newrelation) db.session.flush() # update members field of contactgroups table for contactgroup_name in contactgroup_names_to_update: contactgroup = ContactGroup.get_by_contactgroupname(contactgroup_name) if contactgroup is None: continue contact_names_str = "" connection = db.session.connection() result = connection.execute( "SELECT GROUP_CONCAT(B.contact_name) contact_names FROM contact_contactgroup A" + " LEFT JOIN contacts B ON A.contact_id=B.id" + " WHERE A.contactgroup_id = '%s'" + " GROUP BY A.contactgroup_id" , (contactgroup.id)) if len(result._saved_cursor._result.rows) == 0: contactgroup.members = None writeNagiosContactGroupsConfigFile(contactgroup) else: for row in result: contact_names_str = row['contact_names'] contactgroup.members = contact_names_str writeNagiosContactGroupsConfigFile(contactgroup) break if restartNagios() == False: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") db.session.commit() return jsonify(data=contact.serialize()) except Exception as e: db.session.rollback() syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) finally: db.session.close() return jsonify(error=True)
def post(self, jwt): OID_CPU_LOAD_1 = "laLoad.1" OID_CPU_LOAD_5 = "laLoad.2" OID_CPU_LOAD_15 = "laLoad.3" OID_PHYSICAL_MEM = "hrStorageSize.1" OID_VIRTUAL_MEM = "hrStorageSize.3" OID_SWAP_MEM = "hrStorageSize.10" if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() host_names = post_data.get('host_name') service_description = post_data.get('service_description') display_name = post_data.get('display_name') check_command_pre = post_data.get('check_command_pre') check_command_param = post_data.get('check_command_param') snmp_type = post_data.get('snmp_type', '') snmp_option = post_data.get('snmp_option') snmp_check = post_data.get('snmp_check') snmp_ifname = post_data.get('snmp_ifname') max_check_attempts = post_data.get('max_check_attempts') check_interval = post_data.get('check_interval') retry_interval = post_data.get('retry_interval') contacts = post_data.get('contacts') contact_groups = post_data.get('contact_groups') servicegroups = post_data.get('servicegroups') servicetemplates = post_data.get('use') warning_limit = post_data.get('warning_limit') critical_limit = post_data.get('critical_limit') host_name_str = '' service_group_str = '' contacts_str = '' contact_groups_str = '' servicetemplates_str = '' snmp_option_str = '' snmp_check_str = '' command_list = [] if host_names is None: return jsonify(error=True, msg="Missing host_name required field.") if service_description is None: return jsonify( error=True, msg="Missing service_description required field.") if display_name is None: display_name = service_description if check_command_pre is None: return jsonify(error=True, msg="Missing check_command required field.") if max_check_attempts is None or not str( max_check_attempts).isdigit(): max_check_attempts = 5 if check_interval is None or not str(check_interval).isdigit(): check_interval = 60 if retry_interval is None or not str(retry_interval).isdigit(): retry_interval = 1 if warning_limit is None or warning_limit == '': warning_limit = 100 if critical_limit is None or critical_limit == '': critical_limit = 200 if host_names is not None and len(host_names) > 0: temp_data_services = Service.get_by_description( service_description) # Check duplicate host for service_description for tds in temp_data_services: for hname in tds.host_name: for name in host_names: if name == hname: return jsonify( error=True, msg="Service host already exists.") host_name_str = ','.join(host_names) if servicegroups is not None and len(servicegroups) > 0: service_group_str = ','.join(servicegroups) if contacts is not None and len(contacts) > 0: contacts_str = ','.join(contacts) if contact_groups is not None and len(contact_groups) > 0: contact_groups_str = ','.join(contact_groups) if snmp_check is not None and len(snmp_check) > 0: snmp_check_str = ','.join(snmp_check) if servicetemplates is not None and len(servicetemplates) > 0: servicetemplates_str = ','.join(servicetemplates) if check_command_param is not None and len( check_command_param) > 0: check_command_str = check_command_pre + str( check_command_param) command_list.append(check_command_str) else: check_command_str = check_command_pre command = Command.get_by_commandname(check_command_pre) if command is not None and command.command_line.find( 'check_snmp') != -1: # Check existing host's community host = Host.get_by_hostname(host_names) if host is not None and len(host._SNMPCOMMUNITY) == 0: return jsonify( error=True, msg="The community of host not exists.") if snmp_type is not None and check_command_pre: for option in snmp_option: check_command_str = check_command_pre temp = "" if snmp_type == COMMON_SNTP_TRAFFIC: if snmp_check is not None and len( snmp_check) > 0: cnt = 0 for check in snmp_check: cnt += 1 if check == "ifUcastPkts": temp += "!ifHCInUcastPkts." + str( option ) + "!ifHCOutUcastPkts." + str( option) + "!" + str( check_interval ) + "!" + str( warning_limit ) + "!" + str( critical_limit) elif check == "ifMulticastPkts": temp += "!ifHCInMulticastPkts." + str( option ) + "!ifHCOutMulticastPkts." + str( option) + "!" + str( check_interval ) + "!" + str( warning_limit ) + "!" + str( critical_limit) elif check == "ifErrors": temp += "!ifInErrors." + str( option ) + "!ifOutErrors." + str( option) + "!" + str( check_interval ) + "!" + str( warning_limit ) + "!" + str( critical_limit) if cnt == 3: temp = "!ifHCInOctets." + str( option ) + "!ifHCOutOctets." + str( option) + temp else: temp = "!ifHCInOctets." + str( option) + "!ifHCOutOctets." + str( option) + "!" + str( check_interval ) + "!" + str( warning_limit) + "!" + str( critical_limit) check_command_str += temp elif snmp_type == COMMON_SNTP_CPULOAD: temp = "!" + OID_CPU_LOAD_1 + "!" + OID_CPU_LOAD_5 + "!" + OID_CPU_LOAD_15 check_command_str += temp elif snmp_type == COMMON_SNTP_MEMORY: temp = "!" + OID_PHYSICAL_MEM + "!" + OID_VIRTUAL_MEM + "!" + OID_SWAP_MEM check_command_str += temp command_list.append(check_command_str) else: command_list.append(check_command_str) idx = 0 for one_command in command_list: if len(snmp_option) > idx: snmp_option_str = snmp_option[idx] if len(command_list) > 1 and snmp_ifname: service_name = service_description + "-" + snmp_ifname[ idx] display_name = service_name else: service_name = service_description idx += 1 # Create first Ping Service newservice = Service( host_name=host_name_str.strip(), hostgroup_name=None, service_description=service_name.strip(), display_name=display_name.strip(), importance=None, servicegroups=service_group_str.strip(), is_volatile=None, check_command=one_command.strip(), check_command_pre=check_command_pre.strip(), check_command_param=check_command_param, snmp_type=snmp_type.strip(), snmp_option=snmp_option_str, snmp_check=snmp_check_str, max_check_attempts=max_check_attempts, check_interval=str(check_interval), retry_interval=retry_interval, active_checks_enabled=True, passive_checks_enabled=False, check_period="24x7", obsess_over_host=None, check_freshness=None, freshness_threshold=None, event_handler=None, event_handler_enabled=None, low_flap_threshold=None, high_flap_threshold=None, flap_detection_enabled=None, flap_detection_options=None, process_perf_data=True, retain_status_information=True, retain_nonstatus_information=True, contacts=contacts_str, contact_groups=contact_groups_str, notification_interval=60, first_notification_delay=5, notification_period="24x7", notification_options="w,c,r", notifications_enabled=True, use=servicetemplates_str, command=None, retry_check_interval=None, normal_check_interval=None, name=None, warning=warning_limit, critical=str(critical_limit), ) newservice.check_interval = round( int(check_interval) / 60, 1) service_id = newservice.save() writeNagiosServicesConfigFile(newservice) newservice.check_interval = str(check_interval) # Create all relations if host_names: Service.create_hosts_relations(service_id, host_names) if contacts: Service.create_contacts_relations(service_id, contacts) if contact_groups: Service.create_contactgroups_relations( service_id, contact_groups) if servicegroups: Service.create_servicegroups_relations( service_id, servicegroups) if servicetemplates: Service.create_servicetemplate_relations( service_id, servicetemplates) if not restartNagios(): syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") return jsonify(data=newservice.serialize()) except Exception as e: syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) return jsonify(error=True)
def put(self, jwt, service_id): OID_CPU_LOAD_1 = "laLoad.1" OID_CPU_LOAD_5 = "laLoad.2" OID_CPU_LOAD_15 = "laLoad.3" OID_PHYSICAL_MEM = "hrStorageSize.1" OID_VIRTUAL_MEM = "hrStorageSize.3" OID_SWAP_MEM = "hrStorageSize.10" if service_id is None: return jsonify(error=True) service = Service.get_by_id(service_id) if service is None: return jsonify(error=True) if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() host_name = post_data.get('host_name') service_description = post_data.get('service_description') display_name = post_data.get('display_name') check_command_pre = post_data.get('check_command_pre') check_command_param = post_data.get('check_command_param') snmp_type = post_data.get('snmp_type') snmp_option = post_data.get('snmp_option') snmp_check = post_data.get('snmp_check') max_check_attempts = post_data.get('max_check_attempts') check_interval = post_data.get('check_interval') retry_interval = post_data.get('retry_interval') contacts = post_data.get('contacts') contact_groups = post_data.get('contact_groups') servicegroups = post_data.get('servicegroups') servicetemplates = post_data.get('use') warning_limit = post_data.get('warning_limit') critical_limit = post_data.get('critical_limit') servicegroup_names_to_update = [] if service.servicegroups: servicegroup_names_to_update = servicegroup_names_to_update + service.servicegroups.split( ',') if servicegroups: servicegroup_names_to_update = servicegroup_names_to_update + servicegroups if host_name: service.host_name = ','.join(host_name) if service_description is not None: service.service_description = service_description.strip() if check_command_pre is not None: service.check_command_pre = check_command_pre.strip() if service.check_command_param is not None: if snmp_type != COMMON_SNTP_TRAFFIC: service.check_command = check_command_pre + service.check_command_param.strip( ) else: service.check_command = check_command_pre.strip() if check_command_param is not None and len( check_command_param) > 0: service.check_command_param = check_command_param.strip() service.check_command = service.check_command_pre + check_command_param.strip( ) command = Command.get_by_commandname(check_command_pre) if command is not None and command.command_line.find( 'check_snmp') != -1: if snmp_type is not None and len(snmp_type) > 0: temp = "" service.snmp_type = snmp_type.strip() if snmp_type == COMMON_SNTP_TRAFFIC: for option in snmp_option: if snmp_check is not None and len( snmp_check) > 0: for check in snmp_check: if check == "ifUcastPkts": temp += "!ifHCInUcastPkts." + str( option ) + "!ifHCOutUcastPkts." + str( option) + "!" + str( check_interval ) + "!" + str( warning_limit) + "!" + str( critical_limit) elif check == "ifMulticastPkts": temp += "!ifHCInMulticastPkts." + str( option ) + "!ifHCOutMulticastPkts." + str( option) + "!" + str( check_interval ) + "!" + str( warning_limit) + "!" + str( critical_limit) elif check == "ifErrors": temp += "!ifInErrors." + str( option ) + "!ifOutErrors." + str( option) + "!" + str( check_interval ) + "!" + str( warning_limit) + "!" + str( critical_limit) else: temp += "!ifHCInOctets." + str( option) + "!ifHCOutOctets." + str( option) + "!" + str( check_interval) + "!" + str( warning_limit) + "!" + str( critical_limit) break service.check_command = check_command_pre + temp elif snmp_type == COMMON_SNTP_CPULOAD: temp = "!" + OID_CPU_LOAD_1 + "!" + OID_CPU_LOAD_5 + "!" + OID_CPU_LOAD_15 service.check_command = check_command_pre + temp elif snmp_type == COMMON_SNTP_MEMORY: temp = "!" + OID_PHYSICAL_MEM + "!" + OID_VIRTUAL_MEM + "!" + OID_SWAP_MEM service.check_command = check_command_pre + temp if snmp_option is not None and len(snmp_option) > 0: snmp_option_str = ','.join("{0}".format(n) for n in snmp_option) service.snmp_option = snmp_option_str if snmp_check is not None and len(snmp_check) > 0: snmp_check_str = ','.join(snmp_check) service.snmp_check = snmp_check_str if max_check_attempts is not None and str( max_check_attempts).isdigit(): service.max_check_attempts = max_check_attempts if check_interval is not None and str( check_interval).isdigit(): service.check_interval = str( round(int(check_interval) / 60, 1)) if retry_interval is not None and str( retry_interval).isdigit(): service.retry_interval = retry_interval if warning_limit is not None and str(warning_limit).isdigit(): service.warning = warning_limit if critical_limit is not None and str( critical_limit).isdigit(): service.critical = str(critical_limit) if contacts is not None: service.contacts = ','.join(contacts) if contact_groups is not None: service.contact_groups = ','.join(contact_groups) if servicegroups is not None: service.servicegroups = ','.join(servicegroups) if servicetemplates is not None: service.use = ','.join(servicetemplates) writeNagiosServicesConfigFile(service) if check_interval is not None and str( check_interval).isdigit(): service.check_interval = str(check_interval) updated = service.update() if host_name: Service.delete_all_hosts_relations(service_id) Service.create_hosts_relations(service_id, host_name) if contacts: Service.delete_all_contacts_relations(service_id) Service.create_contacts_relations(service_id, contacts) if contact_groups: Service.delete_all_contactgroups_relations(service_id) Service.create_contactgroups_relations( service_id, contact_groups) if servicegroups: Service.delete_all_servicegroups_relations(service_id) Service.create_servicegroups_relations( service_id, servicegroups) if servicetemplates: Service.delete_all_servicetemplate_relations(service_id) Service.create_servicetemplate_relations( service_id, servicetemplates) if not restartNagios(): syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") if updated: service = Service.get_by_id(service_id) return jsonify(data=service.serialize()) except Exception as e: syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) return jsonify(error=True)
def post(self, jwt): if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() host_name = post_data.get('host_name') alias = post_data.get('alias') address = post_data.get('address') contact_groups = post_data.get('contact_groups') contacts = post_data.get('contacts') sms = post_data.get('sms') street_address = post_data.get('street_address', '') notes = post_data.get('notes') notes_url = post_data.get('notes_url') hosttemplates = post_data.get('use') host_templates_str = "" if hosttemplates is not None: host_templates_str = ','.join(hosttemplates) notification_period = post_data.get('notification_period', "24x7") notification_options = "d,u,r" if post_data.get('notification_options') is not None: notification_options = ','.join( post_data.get('notification_options')) notifications_enabled = 1 if post_data.get( 'notifications_enabled') == True else 0 check_interval = post_data.get('check_interval', 5) retry_interval = post_data.get('retry_interval', 1) max_check_attempts = post_data.get('max_check_attempts', 5) notification_interval = post_data.get('notification_interval', 120) check_command = post_data.get('check_command', "check-host-alive") _SNMPVERSION = post_data.get('_SNMPVERSION', "2c") _SNMPCOMMUNITY = post_data.get('_SNMPCOMMUNITY', '') # Confirm this hostname doesn't already exist first. if Host.get_by_hostname(host_name): return jsonify(error=True, msg="Hostname already exists.") if host_name is None: return jsonify(error=True, msg="Missing host_name required field.") if alias is None: return jsonify(error=True, msg="Missing alias required field.") if address is None: return jsonify(error=True, msg="Missing address required field.") contacts_str = '' if contacts is not None and len(contacts) > 0: contacts_str = ','.join(contacts) newhost = Host(host_name=host_name.strip(), alias=alias.strip(), display_name=None, address=address.strip(), importance=None, check_command=check_command.strip(), max_check_attempts=max_check_attempts, check_interval=check_interval, retry_interval=retry_interval, active_checks_enabled=True, passive_checks_enabled=True, check_period="24x7", obsess_over_host=False, check_freshness=True, freshness_threshold=None, event_handler=None, event_handler_enabled=None, low_flap_threshold=None, high_flap_threshold=None, flap_detection_enabled=None, flap_detection_options=None, process_perf_data=True, retain_status_information=True, retain_nonstatus_information=True, contacts=contacts_str, contact_groups="", notification_interval=notification_interval, first_notification_delay=None, notification_period=notification_period.strip(), notification_options=notification_options, notifications_enabled=notifications_enabled, use=host_templates_str, hostgroups="null", street_address=street_address.strip(), sms=sms.strip(), notes=notes.strip(), notes_url=notes_url.strip(), icon_image='', icon_image_alt='', _SNMPVERSION=_SNMPVERSION, _SNMPCOMMUNITY=_SNMPCOMMUNITY) host_id = newhost.save() newservice = Service( host_name=host_name.strip(), hostgroup_name=None, service_description="PING", display_name="PING", importance=None, servicegroups="", is_volatile=None, check_command="PING", check_command_pre=None, check_command_param=None, snmp_type=None, snmp_option=None, snmp_check=None, max_check_attempts=5, check_interval=str(1), retry_interval=1, active_checks_enabled=True, passive_checks_enabled=False, check_period="24x7", obsess_over_host=None, check_freshness=None, freshness_threshold=None, event_handler=None, event_handler_enabled=None, low_flap_threshold=None, high_flap_threshold=None, flap_detection_enabled=None, flap_detection_options=None, process_perf_data=True, retain_status_information=True, retain_nonstatus_information=True, contacts=contacts_str, contact_groups="", notification_interval=60, first_notification_delay=5, notification_period="24x7", notification_options="w,c,r", notifications_enabled=True, use="", command=None, retry_check_interval=None, normal_check_interval=None, name=None, warning=None, critical=None, ) service_id = newservice.save() # create relations if contacts: Host.create_contacts_relations(host_id, contacts) Service.create_contacts_relations(service_id, contacts) if contact_groups: Host.create_contactgroups_relations( host_id, contact_groups) Service.create_contactgroups_relations( service_id, contact_groups) if hosttemplates: Host.create_hosttemplate_relations(host_id, hosttemplates) Service.create_hosts_relations(service_id, [host_name.strip()]) writeNagiosConfigFile(newhost) writeNagiosServicesConfigFile(newservice) if not restartNagios(): syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") return jsonify(data=newhost.serialize()) except Exception as e: syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) return jsonify(error=True)
def delete(self, jwt, host_name, host_id, page_id): # if host_name is None: # return jsonify(error=True) if host_id is not None: host = Host.get_by_id(host_id) elif host_name is not None: host = Host.get_by_hostname(host_name) else: return jsonify(error=True) if host is None: return jsonify(error=True) else: try: host_id = host.id relations = HostService.query.filter_by(host_id=host_id).all() relation_service_ids = [] if relations is not None: for relation in relations: relation_service_ids.append(relation.service_id) relationgroups = HostgroupHost.query.filter_by( host_id=host_id).all() relation_hostgroup_ids = [] if relationgroups is not None: for relationgroup in relationgroups: relation_hostgroup_ids.append( relationgroup.hostgroup_id) # delete all relations Host.delete_all_host_service_relations(host_id) Host.delete_all_contact_relations(host_id) Host.delete_all_contactgroup_relations(host_id) Host.delete_all_host_template_relations(host_id) Host.delete_all_hostgroup_host_relations(host_id) host = Host.get_by_id(host_id) deleteNagiosConfigFile(host) host.delete() for relation in relation_service_ids: service = Service.get_by_id(relation) if not service: continue hosts = HostService.get_all_by_sevice(service.id) if hosts: host_ids = [h.id for h in hosts] host_names_str = ','.join(host_ids) service.host_name = host_names_str tmp_check_interval = service.check_interval service.check_interval = round( int(service.check_interval) / 60, 1) writeNagiosServicesConfigFile(service) service.check_interval = tmp_check_interval service.update() else: deleteNagiosServicesConfigFile(service) service.delete() for relation in relation_hostgroup_ids: host_group = Hostgroup.get_by_id(relation) if not host_group: continue host_group_hosts = HostgroupHost.get_all_by_hostgroup( host_group.id) if host_group_hosts: host_ids = [h.id for h in host_group_hosts] host_names_str = ','.join(host_ids) host_group.members = host_names_str writeNagiosHostgroupsConfigFile(host_group) host_group.update() else: deleteNagiosHostgroupsConfigFile(host_group) host_group.delete() if not restartNagios(): syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") return jsonify(error=False) except Exception as e: syncNagiosAllConfigWithDb() print(e.__dict__) return jsonify(error=True, msg=str(e))
def put(self, jwt, host_id, host_name, page_id): if request.is_json and request.get_json(silent=True) is not None: try: post_data = request.get_json() host = None hostname_org = None index = post_data.get('index') if index is not None: host = Host.get_by_id(index) if host is None: return jsonify(error=True) hostname_org = host.host_name host_name = post_data.get('host_name') alias = post_data.get('alias') address = post_data.get('address') contact_groups = post_data.get('contact_groups') contacts = post_data.get('contacts') sms = post_data.get('sms') street_address = post_data.get('street_address', '') notes = post_data.get('notes') notes_url = post_data.get('notes_url') hosttemplates = post_data.get('use') notification_period = "24x7" if post_data.get('notification_period') is not None and len( post_data.get('notification_period')) > 0: notification_period = post_data.get('notification_period') notification_options = "d,u,r" if post_data.get('notification_options') is not None and len( post_data.get('notification_options')) > 0: notification_options = ','.join( post_data.get('notification_options')) notifications_enabled = 1 if post_data.get('notifications_enabled') is not None and len( str(post_data.get('notifications_enabled'))) > 0: notifications_enabled = 1 if post_data.get( 'notifications_enabled') == True else 0 check_interval = 5 if post_data.get('check_interval') is not None and len( str(post_data.get('check_interval'))) > 0: check_interval = post_data.get('check_interval') retry_interval = 1 if post_data.get('retry_interval') is not None and len( str(post_data.get('retry_interval'))) > 0: retry_interval = post_data.get('retry_interval') max_check_attempts = 5 if post_data.get('max_check_attempts') is not None and len( str(post_data.get('max_check_attempts'))) > 0: max_check_attempts = post_data.get('max_check_attempts') notification_interval = 120 if post_data.get('notification_interval') is not None and len( str(post_data.get('notification_interval'))) > 0: notification_interval = post_data.get( 'notification_interval') check_command = "check-host-alive" if post_data.get('check_command') is not None and len( post_data.get('check_command')) > 0: check_command = post_data.get('check_command') _SNMPVERSION = "2c" if post_data.get('_SNMPVERSION') is not None and len( post_data.get('_SNMPVERSION')) > 0: _SNMPVERSION = post_data.get('_SNMPVERSION') _SNMPCOMMUNITY = "" if post_data.get('_SNMPCOMMUNITY') is not None and len( post_data.get('_SNMPCOMMUNITY')) > 0: _SNMPCOMMUNITY = post_data.get('_SNMPCOMMUNITY') # Confirm this hostname doesn't already exist first. if hostname_org != host_name and Host.get_by_hostname( host_name): return jsonify(error=True, msg="Hostname already exists.") if host_name is None: return jsonify(error=True, msg="Missing host_name required field.") if alias is None: return jsonify(error=True, msg="Missing alias required field.") if address is None: return jsonify(error=True, msg="Missing address required field.") host.host_name = host_name.strip() host.alias = alias.strip() host.address = address.strip() if contact_groups is not None: host.contact_groups = ','.join(contact_groups) if contacts is not None: host.contacts = ','.join(contacts) if sms is not None: host.sms = sms.strip() if street_address is not None: host.street_address = street_address.strip() if notes is not None: host.notes = notes.strip() if notes_url is not None: host.notes_url = notes_url.strip() host_templates_str = host.use if hosttemplates is not None: host_templates_str = ','.join(hosttemplates) host.use = host_templates_str host.notification_period = notification_period.strip() host.notification_options = notification_options host.notifications_enabled = notifications_enabled host.check_interval = check_interval host.retry_interval = retry_interval host.max_check_attempts = max_check_attempts host.notification_interval = notification_interval host.check_command = check_command.strip() host._SNMPVERSION = _SNMPVERSION host._SNMPCOMMUNITY = _SNMPCOMMUNITY writeNagiosConfigFile(host) host_id = host.update() # update host_contact table Host.delete_all_contact_relations(host_id) Host.delete_all_contactgroup_relations(host_id) Host.delete_all_host_template_relations(host_id) Host.create_contacts_relations(host_id, contacts) Host.create_contactgroups_relations(host_id, contact_groups) Host.create_hosttemplate_relations(host_id, hosttemplates) # re-name of host in services table if hostname_org != host_name: services = Service.get_by_hostname_keyword(hostname_org) for service in services: hostnames = service.host_name hostnames = hostnames.replace(hostname_org, host.host_name) service.host_name = hostnames tmp_checkInterval = service.check_interval service.check_interval = round( int(service.check_interval) / 60, 1) writeNagiosServicesConfigFile(service) service.check_interval = tmp_checkInterval service.update() # re-name of host in hostgroups table hostgroups = Hostgroup.get_by_hostname_keyword( hostname_org) for hostgroup in hostgroups: hostnames = hostgroup.members hostnames = hostnames.replace(hostname_org, host.host_name) hostgroup.members = hostnames hostgroup.update() writeNagiosHostgroupsConfigFile(hostgroup) if not restartNagios(): syncNagiosAllConfigWithDb() return jsonify(error=True, msg="Invalid process") if host_id: host = Host.get_by_id(host_id) return jsonify(data=host.serialize()) except Exception as e: syncNagiosAllConfigWithDb() return jsonify(error=True, msg=str(e)) return jsonify(error=True)