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):
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)