def get_config(self) -> str:
config = 'template Host "servertemplate_' + self.__id + '" {\n'
for template in self.__templates:
config += ' import "servertemplate_' + template.get_id() + '"\n'
if None is not self.__ssh_template:
config += ' import "sshtemplate_' + self.__ssh_template.get_id(
) + '"\n'
if None is not self.__os:
config += ' import "os_' + self.__os.get_id() + '"\n'
for manager in self.__package_manager:
config += ' import "packagemanager_' + manager.get_id() + '"\n'
config += Checkable.get_config(self)
config += ValueMapper.parse_var('address', self.__ipv4)
config += ValueMapper.parse_var('address6', self.__ipv6)
config += ValueMapper.parse_var('vars.checks', self.__checks)
config += ValueMapper.parse_var('vars.groups',
self.__groups,
value_prefix='hostgroup_')
config += PluginDirs.get_config(self)
config += ScriptDirs.get_config(self)
config += CustomVars.get_config(self)
config += ' check_command = "hostalive"\n'
config += ' zone = "' + self.__execution_zone.get_id() + '"\n'
config += ValueMapper.parse_var('vars.endpoint_name',
self.__execution_endpoint)
config += '}\n'
return config
def group_config_function(self, group):
if 0 == len(group.get_telegram_id()):
return []
if None is self.__api_token:
raise Exception('Telegram API token not set in ' + self.get_id())
config = [
ValueMapper.parse_var('vars.notification_telegram_groups', group.get_telegram_id()) + '\n' +
ValueMapper.parse_var('vars.notification_telegram_token', self.__api_token) + '\n'
]
return config
def get_custom_config(self) -> str:
config = NmapScanUDP.get_config(self)
config += NmapScanTCP.get_config(self)
config += NmapN.get_config(self)
config += Nmapr.get_config(self)
config += NmapSystemDns.get_config(self)
config += NmapTraceroute.get_config(self)
config += NmapF.get_config(self)
config += NmapR.get_config(self)
config += NmapSV.get_config(self)
config += NmapVersionLight.get_config(self)
config += NmapVersionAll.get_config(self)
config += NmapVersionTrace.get_config(self)
config += NmapSC.get_config(self)
config += NmapScriptTrace.get_config(self)
config += NmapO.get_config(self)
config += NmapOsscanGuess.get_config(self)
config += NmapBadsum.get_config(self)
config += Nmap6.get_config(self)
config += NmapA.get_config(self)
config += NmapSendEth.get_config(self)
config += NmapSendIp.get_config(self)
config += NmapPrivileged.get_config(self)
config += NmapPn.get_config(self)
config += NmapUnprivileged.get_config(self)
config += ValueMapper.parse_var('vars.allowed_ports',
self.__allowed_ports)
config += NmapBase.get_custom_config(self)
return config
def get_config(self) -> str:
self.validate()
config = 'object User "user_' + self.__id + '" {\n'
config += ValueMapper.parse_var('display_name', self.__display_name)
config += Nameable.get_config(self)
config += NotificationFunctions.get_config(self)
config += ValueMapper.parse_var('groups', self.__groups, value_prefix='usergroup_')
config += ValueMapper.parse_var('states', self.__states)
config += ValueMapper.parse_var('types', self.__types)
for var in self.__vars:
config += ' var.' + var[0] + ' = ' + ValueMapper.parse_value_for_var(var[1]) + '\n'
config += '}\n'
return config
def get_config(self) -> str:
NmapR.validate(self)
return ValueMapper.get_property_default_config(self,
NmapR(self)._class_name,
self._command_name,
'command')
def get_config(self) -> str:
config = ''
for custom_var in self.__custom_vars:
if not custom_var['internal_use']:
config += ValueMapper.parse_var('vars.' + custom_var['key'], custom_var['value'])
return config
def get_config(self: T) -> str:
self.validate()
config = Dependency.get_config(self)
config += 'apply Dependency "servicedependency_' + self.get_id() + '" to Service {\n'
config += ' import "dependency_' + self.get_id() + '"\n'
config += ValueMapper.parse_var('parent_service_name', self.__parent_service_name)
config += ' assign where "dependency_' + self.get_id() + '" in service.vars.dependencies\n'
config += '}\n'
return config
def validate_id(id):
prefixes = ValueChecker.get_prefixes()
for prefix in prefixes:
if id.startswith(prefix + '_'):
raise Exception(prefix +
'_ is a reserved Prefix. You can\'t use it!')
if ValueMapper.canonicalize_for_id(id) != id:
raise Exception(
'Id\'s can only contains letters (a-z,A-Z), numbers (0-9) and underscore (_)'
)
def get_assign_config(self,
custom_config,
notification_id,
users=None,
groups=None):
config = ''
for type in ['Host', 'Service']:
config += 'apply Notification "' + type.lower(
) + '_' + notification_id + '" to ' + type + ' {\n'
config += ' import "notification_template_' + type.lower() + '_' \
+ Notification.get_id(self) + '"\n'
config += ValueMapper.parse_var('user_groups',
groups,
value_prefix='usergroup_')
config += ValueMapper.parse_var('users',
users,
value_prefix='user_')
config += custom_config
config += ' assign where "notification_' + self.get_id() + '" in ' \
+ type.lower() + '.vars.notification\n'
config += '}\n'
return config
def get_config(self: T) -> str:
self.validate()
config = ''
for type in ['Host', 'Service']:
config += 'apply ScheduledDowntime "downtime_' + self.__id + '" to ' + type + '{\n'
config += ValueMapper.parse_var('comment', self.__comment)
config += ValueMapper.parse_var('author', self.__author)
config += ValueMapper.parse_var('child_options', self.__child_options)
config += ValueMapper.parse_var('fixed', self.__fixed)
if None is not self.__duration:
config += ' duration = ' + self.__duration + '\n'
if 0 < len(self.__ranges):
config += ' ranges = {\n'
for range in self.__ranges:
config += ' "' + range[0] + '" = "' + range[1] + '"\n'
config += ' }\n'
config += ' assign where "downtime_' + self.__id + '" in ' + type.lower() + '.vars.downtime\n'
config += '}\n'
return config
def get_config(self) -> str:
self.validate()
config = 'template Notification "notification_template_host_' + self.__id + '" {\n'
config += ' interval = ' + self.__interval + '\n'
if None is not self.__escalation:
config += ' times = {\n'
config += ' begin = ' + self.__escalation[0] + '\n'
config += ' end = ' + self.__escalation[1] + '\n'
config += ' }\n'
config += ValueMapper.parse_var('command',
self.__command,
value_prefix='command_host_')
config += ValueMapper.parse_var('period',
self.__time_period,
value_prefix='time_period_')
config += ValueMapper.parse_var('types', self.__host_types)
config += ValueMapper.parse_var('states', self.__host_states)
config += '}\n'
config += 'template Notification "notification_template_service_' + self.__id + '" {\n'
config += ' interval = ' + self.__interval + '\n'
if None is not self.__escalation:
config += ' times = {\n'
config += ' begin = ' + self.__escalation[0] + '\n'
config += ' end = ' + self.__escalation[1] + '\n'
config += ' }\n'
config += ValueMapper.parse_var('command',
self.__command,
value_prefix='command_service_')
config += ValueMapper.parse_var('period',
self.__time_period,
value_prefix='time_period_')
config += ValueMapper.parse_var('types', self.__service_types)
config += ValueMapper.parse_var('states', self.__service_states)
config += '}\n'
config += self.apply_for_all()
return config
def get_config(self: T) -> str:
self.validate()
config = 'template Dependency "dependency_' + self.__id + '" {\n'
config += ValueMapper.parse_var('parent_host_name',
self.__parent_host_name)
config += ValueMapper.parse_var('disable_checks',
self.__disable_checks)
config += ValueMapper.parse_var('disable_notifications',
self.__disable_notifications)
config += ValueMapper.parse_var('ignore_soft_states',
self.__ignore_soft_states)
config += ValueMapper.parse_var('period',
self.__period,
value_prefix='time_period_')
config += ValueMapper.parse_var('states', self.__states)
config += '}\n'
return config
def get_config(self) -> str:
config = ValueMapper.parse_var('vars.icinga_script_dir',
self.__icinga_script_dir)
config += ValueMapper.parse_var('vars.monitoring_script_dir',
self.__monitoring_script_dir)
return config
def user_config_function(self, user):
email_config = []
for email in user.get_email():
email_config.append(
ValueMapper.parse_var('vars.notification_email', email))
return email_config
def apply(self):
if self.__inherit:
DefaultWebserverChecks.apply(self)
for config in DefaultWordpressChecks.get_vhostconfigs(self):
service_baseid = config[0]
domain = config[1]
for server in DefaultWebserverChecks.get_servers(self):
for checkserver in DefaultWebserverChecks.get_checkservers(
self):
server.add_hostgroup(HostGroup.create('wordpress'))
base_id = service_baseid + '_' + server.get_id(
) + '_' + ValueMapper.canonicalize_for_id(
domain) + '_' + checkserver.get_id()
if True is self.__validate_deny_license:
self.create_wp_check('license', service_baseid,
base_id, server, checkserver,
domain, '/license.txt')
if True is self.__validate_deny_readme:
self.create_wp_check('readme', service_baseid, base_id,
server, checkserver, domain,
'/readme.html')
if True is self.__validate_deny_wp_admin:
self.create_wp_check('wp_admin', service_baseid,
base_id, server, checkserver,
domain, '/wp-admin/')
if True is self.__validate_deny_wp_content:
self.create_wp_check('wp_includes', service_baseid,
base_id, server, checkserver,
domain, '/wp-includes/')
if True is self.__validate_deny_wp_content:
self.create_wp_check('wp_content', service_baseid,
base_id, server, checkserver,
domain, '/wp-content/')
if True is self.__validate_deny_wp_login:
self.create_wp_check('wp_login', service_baseid,
base_id, server, checkserver,
domain, '/wp-login.php')
if True is self.__validate_deny_wp_cron:
self.create_wp_check('wp_cron', service_baseid,
base_id, server, checkserver,
domain, '/wp-cron.php')
if True is self.__validate_deny_wp_load:
self.create_wp_check('wp_load', service_baseid,
base_id, server, checkserver,
domain, '/wp-load.php')
if True is self.__validate_deny_wp_mail:
self.create_wp_check('wp_mail', service_baseid,
base_id, server, checkserver,
domain, '/wp-mail.php')
if True is self.__validate_deny_wp_signup:
self.create_wp_check('wp_signup', service_baseid,
base_id, server, checkserver,
domain, '/wp-signup.php')
if True is self.__validate_deny_wp_trackback:
self.create_wp_check('wp_trackback', service_baseid,
base_id, server, checkserver,
domain, '/wp-trackback.php')
if True is self.__validate_deny_wp_xmlrpc:
self.create_wp_check('wp_xmlrpc', service_baseid,
base_id, server, checkserver,
domain, '/xmlrpc.php')
if True is self.__validate_deny_wp_config:
self.create_wp_check('wp_config', service_baseid,
base_id, server, checkserver,
domain, '/wp-config.php')
if True is self.__validate_deny_wp_config_sample:
self.create_wp_check('wp_config_sample',
service_baseid, base_id, server,
checkserver, domain,
'/wp-config-sample.php')
if True is self.__validate_deny_wp_blog_header:
self.create_wp_check('wp_blog_header', service_baseid,
base_id, server, checkserver,
domain, '/wp-blog-header.php')
if True is self.__validate_deny_wp_activate:
self.create_wp_check('wp_activate', service_baseid,
base_id, server, checkserver,
domain, '/wp-activate.php')
if True is self.__validate_deny_wp_links_opml:
self.create_wp_check('wp_links_opml', service_baseid,
base_id, server, checkserver,
domain, '/wp-links-opml.php')
def get_property_default_config(self: T) -> str:
return ValueMapper.get_property_default_config(
self, self.__class_name,
ValueMapper.replace_command_prefixes(self.__command_name),
'command')
def get_group_config(self: T) -> str:
return ValueMapper.parse_var('vars.groups',
self.__service_groups,
value_prefix='servicegroup_')
def get_default_access_check(self, service_baseid, server, domain):
base_id = service_baseid + '_' + server.get_id() + '_' + ValueMapper.canonicalize_for_id(domain)
return {
'ipv4': ConfigBuilder.get_check('web_access_default_ipv4_' + base_id),
'ipv6': ConfigBuilder.get_check('web_access_default_ipv6_' + base_id)
}
def get_config(self) -> str:
return ValueMapper.parse_var('display_name', self.__display_name)
def get_default_check_name(id: str, command_name: str) -> str:
default_names = {
'apt': 'APT',
'breeze': 'Breeze',
'ciphers': 'Ciphers',
'clamd': 'Clamd',
'deny_tls_version': 'Deny TLS version',
'dhcp': 'DHCP',
'dig': 'DIG',
'disk': 'Disk',
'disk_smb': 'Disk SMB',
'dnssec_expiry': 'DNSSEC expire',
'docker_login': '******',
'domain_address_ipv4': 'DNS A',
'domain_address_ipv6': 'DNS AAAA',
'dummy': 'Dummy',
'existing_users': 'Existing users',
'file_age': 'File age',
'flexlm': 'Flexlm',
'ftp': 'FTP',
'group_members': 'Group members',
'hpjd': 'HP JD',
'http': 'Http',
'icmp': 'ICMP',
'ide_smart': 'SMART',
'ifstatus': 'Interface status',
'imap': 'IMAP',
'ircd': 'IRCD',
'jabber': 'Jabber',
'ldap': 'LDAP',
'ldaps': 'LDAPS',
'load': 'Load',
'log': 'Log',
'mailq': 'Mail queue',
'mrt_gtraf': 'MRT gtraf',
'mysql': 'MySQL',
'mysql_query': 'MySQL query',
'nntp': 'NNTP',
'nntps': 'NNTPS',
'nt': 'NT',
'ntp_peer': 'NTP peer',
'ntp_time': 'NTP time',
'open_ports': 'Open ports',
'path_exist': 'Path exist',
'pgsql': 'PostgreSQL',
'ping': 'Ping',
'ping4': 'Ping (ipv4)',
'ping6': 'Ping (ipv6)',
'pop': 'POP',
'procs': 'Processes',
'proxy_requests': 'Open proxy (ProxyRequests)',
'radius': 'RADIUS',
'reboot_required': 'Reboot required',
'rpc': 'RPC',
'running_proc_amavisd': 'Amavisd running',
'running_proc_apache': 'Apache running',
'running_proc_bind': 'Bind running',
'running_proc_clamd': 'Clamd running',
'running_proc_containerd': 'Containerd running',
'running_proc_cron': 'Cron running',
'running_proc_docker': 'Docker running',
'running_proc_dovecot': 'Dovecot running',
'running_proc_freshclam': 'Freshclam running',
'running_proc_httpd': 'Httpd running',
'running_proc_mysql': 'MySQL running',
'running_proc_nginx': 'NGINX running',
'running_proc_opendkim': 'Open DKIM running',
'running_proc_php_fpm': 'PHP FPM running',
'running_proc_postfix': 'Postfix running',
'running_proc_postgres': 'PostgreSQL running',
'running_proc_postgrey': 'Postgrey running',
'running_proc_rsyslogd': 'Rsyslogd running',
'running_proc_sshd': 'SSHD running',
'running_proc_tomcat': 'Apache Tomcat running',
'sensors': 'Sensors',
'simap': 'IMAPS',
'smtp': 'SMTP',
'snmp': 'SNMP',
'spop': 'POPS',
'ssh': 'SSH',
'sshd_security': 'SSHD security',
'ssmtp': 'SMTPS',
'synology_status': 'Synology Status',
'sudoers_group_members': 'Sudoers group members',
'swap': 'SWAP',
'tcp': 'TCP',
'udp': 'UDP',
'ufw_status': 'UFW Status',
'ups': 'UPS',
'uptime': 'Uptime',
'users': 'Users',
'wave': 'Wave',
'web_access_allow_tls1_0': 'Allow insecure TLS 1.0',
'web_access_allow_tls1_1': 'Allow insecure TLS 1.1',
'web_access_allow_tls1_2': 'Allow secure TLS 1.2',
'web_access_allow_tls1_3': 'Allow secure TLS 1.3',
'web_access_certificate': 'Certificate check',
'web_access_default': 'Default web access',
'web_access_deny_gitdir': 'Deny .git',
'web_access_deny_gitignore': 'Deny .gitignore',
'web_access_deny_license': 'Deny License',
'web_access_deny_readme': 'Deny readme',
'web_access_deny_tls1_0': 'Deny insecure TLS 1.0',
'web_access_deny_tls1_1': 'Deny insecure TLS 1.1',
'web_access_deny_tls1_2': 'Deny secure TLS 1.2',
'web_access_deny_tls1_3': 'Deny secure TLS 1.3',
'web_access_deny_wp_admin': 'deny /wp-admin',
'web_access_deny_wp_includes': 'deny /wp-includes',
'web_access_deny_wp_content': 'deny /wp-content',
'web_access_deny_wp_login': '******',
'web_access_deny_wp_cron': 'deny /wp-cron.php',
'web_access_deny_wp_load': 'deny /wp-load.php',
'web_access_deny_wp_mail': 'deny /wp-mail.php',
'web_access_deny_wp_signup': 'deny /wp-signup.php',
'web_access_deny_wp_trackback': 'deny /wp-trackback.php',
'web_access_deny_wp_xmlrpc': 'deny /xmlrpc.php',
'web_access_deny_wp_config': 'deny /wp-config.php',
'web_access_deny_wp_config_sample': 'deny /wp-config-sample.php',
'web_access_deny_wp_blog_header': 'deny /wp-blog-header.php',
'web_access_deny_wp_activate': 'deny /wp-activate.php',
'web_access_deny_wp_links_opml': 'deny /wp-links-opml.php',
'web_access_http_redirect': 'Http to https redirect',
'web_access_missing_http_redirect': 'No http redirect check for',
'wheel_group_members': 'Sudoers (wheel) group members',
'yum': 'YUM',
}
id = ValueMapper.replace_command_prefixes(id)
command_name = ValueMapper.replace_command_prefixes(command_name)
for name in default_names:
if id.startswith(name + '_'):
return default_names[name]
return default_names.get(
id, default_names.get(command_name, command_name.replace('_', ' ')))
def get_custom_config(self: T) -> str:
return ValueMapper.get_property_default_config(self, 'CheckSNMP',
'snmp', 'command')
def get_custom_config(self) -> str:
return ValueMapper.get_property_default_config(self, 'NmapBase',
self._command_name,
'command')
def get_config(self) -> str:
config = ValueMapper.parse_var('vars.email_addresses', self.__email)
config += ValueMapper.parse_var('pager', self.__pager)
config += ValueMapper.parse_var('vars.phone', self.__phone)
return config
def apply(self):
for config in self.__vhostconfigs:
service_baseid = config[0]
domain = config[1]
uri = config[2]
for server in self.get_servers():
for checkserver in self.get_checkservers():
base_id = service_baseid + '_' + server.get_id() + '_' + ValueMapper.canonicalize_for_id(domain)
server_ipv4 = server.get_ipv4()
server_ipv6 = server.get_ipv6()
if None is server_ipv4 and None is server_ipv6:
raise Exception('It is required to set the ipv4 or ipv6 on the server with id "' +
server.get_id() + '", before you can apply this checks!')
server.add_hostgroup(HostGroup.create('Webserver'))
default_ipv4_http_check = None
default_ipv6_http_check = None
if None is not server_ipv4:
default_ipv4_http_check = CheckHttp.create('web_access_default_ipv4_' + base_id)
default_ipv4_http_check.set_ip(server_ipv4) \
.set_vhost(domain) \
.set_uri(uri) \
.set_ssl(True) \
.set_sni(self.__sni) \
.set_display_name(default_ipv4_http_check.get_display_name() + ' ' + domain)
self.apply_check(default_ipv4_http_check, server, checkserver)
if None is not server_ipv6:
default_ipv6_http_check = CheckHttp.create('web_access_default_ipv6_' + base_id)
default_ipv6_http_check.set_ip(server_ipv6) \
.set_ipv6(True) \
.set_vhost(domain) \
.set_uri(uri) \
.set_ssl(True) \
.set_sni(self.__sni) \
.set_display_name(default_ipv6_http_check.get_display_name() + ' ' + domain)
self.apply_check(default_ipv6_http_check, server, checkserver)
if None == default_ipv4_http_check and None == default_ipv6_http_check:
raise Exception('Server "' + server.get_id()
+ '" has no IPv4 and no IPv6 address set. Can\'t go further right now.')
if True is self.__validate_certificate:
if None is not server_ipv4:
certificate_check = CheckHttp.create('web_access_certificate_ipv4_' + base_id)
certificate_check.set_ip(server_ipv4) \
.set_vhost(domain) \
.set_uri(uri) \
.set_ssl(True) \
.set_sni(self.__sni) \
.set_certificate_check(True) \
.set_check_interval('15m') \
.add_service_group(ServiceGroup.create('certificate_check')) \
.set_display_name(certificate_check.get_display_name() + ' ' + domain)
self.apply_check(certificate_check, server, checkserver, default_ipv4_http_check)
if None is not server_ipv6:
certificate_check = CheckHttp.create('web_access_certificate_ipv6_' + base_id)
certificate_check.set_ip(server_ipv6) \
.set_ipv6(True) \
.set_vhost(domain) \
.set_uri(uri) \
.set_ssl(True) \
.set_sni(self.__sni) \
.set_certificate_check(True) \
.set_check_interval('15m') \
.add_service_group(ServiceGroup.create('certificate_check')) \
.set_display_name(certificate_check.get_display_name() + ' ' + domain)
self.apply_check(certificate_check, server, checkserver, default_ipv6_http_check)
else:
server.add_hostgroup(HostGroup.create('no_certificate_check'))
if True is self.__validate_http_redirect:
if None is not server_ipv4:
redirect_check = CheckHttp.create('web_access_http_redirect_ipv4_' + base_id)
redirect_check.set_ip(server_ipv4) \
.set_vhost(domain) \
.set_uri(uri) \
.set_ssl(False) \
.set_sni(self.__sni) \
.set_port(80) \
.set_expect('HTTP/1.1 30') \
.set_check_interval('15m') \
.add_service_group(ServiceGroup.create('http_redirect')) \
.set_display_name(redirect_check.get_display_name() + ' ' + domain)
self.apply_check(redirect_check, server, checkserver, default_ipv4_http_check)
if None is not server_ipv6:
redirect_check = CheckHttp.create('web_access_http_redirect_ipv6_' + base_id)
redirect_check.set_ip(server_ipv6) \
.set_ipv6(True) \
.set_vhost(domain) \
.set_uri(uri) \
.set_ssl(False) \
.set_sni(self.__sni) \
.set_port(80) \
.set_expect('HTTP/1.1 30') \
.set_check_interval('15m') \
.add_service_group(ServiceGroup.create('http_redirect')) \
.set_display_name(redirect_check.get_display_name() + ' ' + domain)
self.apply_check(redirect_check, server, checkserver, default_ipv6_http_check)
server.add_hostgroup(HostGroup.create('http_redirect'))
elif True is self.__warn_no_http_redirect:
redirect_check = CheckDummy.create('web_access_missing_http_redirect_' + base_id)
redirect_check.set_state(1) \
.set_text(redirect_check.get_display_name() + ' ' + domain) \
.set_check_interval('15m') \
.add_service_group(ServiceGroup.create('missing_http_redirect_check')) \
.add_service_group(ServiceGroup.create('Webserver')) \
.set_display_name(redirect_check.get_display_name() + ' ' + domain)
self.apply_check(redirect_check, server, checkserver)
server.add_hostgroup(HostGroup.create('no_http_redirect'))
else:
server.add_hostgroup(HostGroup.create('http_redirect_unchecked'))
self.add_tls_check(base_id, default_ipv4_http_check, default_ipv6_http_check, domain,
server, checkserver, server_ipv4, server_ipv6, uri, '1.0',
self.__validate_allow_tls1, self.__validate_deny_tls1, True)
self.add_tls_check(base_id, default_ipv4_http_check, default_ipv6_http_check, domain,
server, checkserver, server_ipv4, server_ipv6, uri, '1.1',
self.__validate_allow_tls1_1, self.__validate_deny_tls1_1, True)
self.add_tls_check(base_id, default_ipv4_http_check, default_ipv6_http_check, domain,
server, checkserver, server_ipv4, server_ipv6, uri, '1.2',
self.__validate_allow_tls1_2, self.__validate_deny_tls1_2, False)
self.add_tls_check(base_id, default_ipv4_http_check, default_ipv6_http_check, domain,
server, checkserver, server_ipv4, server_ipv6, uri, '1.3',
self.__validate_allow_tls1_3, self.__validate_deny_tls1_3, False)
def get_default_group_name(id: str) -> str:
default_names = {
'amavisd': 'Amavisd',
'antivirus': 'Antivirus',
'apache': 'Apache',
'apt': 'APT',
'bind': 'Bind',
'breeze': 'Breeze',
'certificate_check': 'X.509 certificate',
'ciphers': 'Ciphers',
'clamd': 'Clamd',
'containerd': 'Containerd',
'cron': 'Cron',
'database': 'Database',
'deny_insecure_TLSv1_0_webserver': 'Deny insecure TLS 1.0 webserver',
'deny_insecure_TLSv1_0_unchecked': 'Deny insecure TLS 1.0 unchecked',
'deny_insecure_TLSv1_1_webserver': 'Deny insecure TLS 1.1 webserver',
'deny_insecure_TLSv1_1_unchecked': 'Deny insecure TLS 1.1 unchecked',
'deny_secure_TLSv1_2_webserver': 'Deny secure TLS 1.2 wevserver',
'deny_secure_TLSv1_3_webserver': 'Deny secure TLS 1.3 wevserver',
'dhcp': 'DHCP',
'dig': 'dig',
'disk': 'Disk',
'dns': 'DNS',
'dnssec': 'DNSSEC',
'docker': 'Docker',
'dovecot': 'Dovecot',
'dummy': 'Dummy',
'existing_user': '******',
'file_age': 'File age',
'firewall': 'Firewall',
'flexlm': 'Flexlm',
'freshclam': 'Freshclam',
'ftp': 'FTP',
'group_members': 'Group members',
'hpjd': 'HP JD',
'http_redirect': 'Http to https redirect',
'http_redirect_unchecked': 'Http to https redirect unchecked',
'icmp': 'ICMP',
'ifstatus': 'Interface status',
'imap': 'IMAP',
'insecure_webserver': 'Insecure webserver',
'insecure_TLSv1_0_Webserver': 'Insecure TLS v1.0 webserver',
'insecure_TLSv1_1_Webserver': 'Insecure TLS v1.1 webserver',
'ircd': 'IRCD',
'jabber': 'Jabber',
'ldap': 'LDAP',
'load': 'Load',
'log': 'Log',
'mail': 'Mail',
'mailq': 'Mail queue',
'missing_http_redirect_check': 'Missing http to https redirect check',
'mrt_gtraf': 'MRT graf',
'mysql': 'MySQL',
'network': 'Network',
'nginx': 'NGINX',
'nmap': 'Nmap',
'nntp': 'NNTP',
'no_certificate_check': 'No X.509 Certificate check',
'ntp': 'NTP',
'ns_client': 'NS Client',
'opendkim': 'Open DKIM',
'open_ports': 'Open ports',
'path_exists': 'Path exists',
'php_fpm': 'PHP FPM',
'postfix': 'Postfix',
'postgres': 'PostgreSQL',
'postgrey': 'Postgrey',
'ping': 'Ping',
'pop': 'POP',
'procs': 'Procs',
'radius': 'RADIUS',
'reboot': 'Reboot',
'rpc': 'RPC',
'rsyslogd': 'Rsyslogd',
'secure_webserver': 'Secure Webserver',
'secure_TLSv1_2_unchecked': 'Secure TLS 1.2 unchecked',
'secure_TLSv1_3_unchecked': 'Secure TLS 1.3 unchecked',
'secure_TLSv1_2_webserver': 'Secure TLS 1.2 Webserver',
'secure_TLSv1_3_webserver': 'Secure TLS 1.3 Webserver',
'security': 'Security',
'sensors': 'Sensors',
'smart': 'SMART',
'smtp': 'SMTP',
'snmp': 'SNMP',
'sshd': 'SSHD',
'sshd_security': 'SSHD security',
'sudoers': 'Sudoers',
'swap': 'SWAP',
'synology_status': 'Synology Status',
'system_health': 'System health',
'tcp': 'TCP',
'tls_1_0_check': 'TLS v1.0 Check',
'tls_1_1_check': 'TLS v1.1 Check',
'tls_1_2_check': 'TLS v1.2 Check',
'tls_1_3_check': 'TLS v1.3 Check',
'tls': 'TLS',
'tomcat': 'Apache Tomcat',
'udp': 'UDP',
'ufw': 'UFW',
'ups': 'UPS',
'updates': 'Updates',
'uptime': 'Uptime',
'user': '******',
'yum': 'YUM',
'wave': 'Wave',
'webserver': 'Webserver',
'wordpress': 'Wordpress',
}
id = ValueMapper.replace_command_prefixes(id)
return default_names.get(id, id.replace('_', ' '))
def get_config(self: T) -> str:
config = Nameable.get_config(self)
config += CustomVars.get_config(self)
if not self.__is_check:
config += ValueMapper.parse_var('vars.zone_name', self.__dns_zone)
elif self.__override_zone:
config += ValueMapper.parse_var('zone', self.__dns_zone)
else:
config += ' zone = host.vars.zone_name\n'
if not self.__is_check:
config += ValueMapper.parse_var('vars.endpoint_name', self.__command_endpoint)
elif self.__override_endpoint:
config += ValueMapper.parse_var('command_endpoint', self.__command_endpoint)
else:
config += ' command_endpoint = host.vars.endpoint_name\n'
config += ' check_interval = ' + self.__check_interval + '\n'
config += ' retry_interval = ' + self.__retry_interval + '\n'
config += ValueMapper.parse_var('max_check_attempts', self.__max_check_attempts)
config += ValueMapper.parse_var('enable_perfdata', self.__enable_perfdata)
config += ValueMapper.parse_var('check_timeout', self.__check_timeout)
config += ValueMapper.parse_var('vars.notification', self.__notifications, value_prefix='notification_')
config += ValueMapper.parse_var('vars.downtime', self.__downtimes, value_prefix='downtime_')
config += ValueMapper.parse_var('vars.dependencies', self.__dependencies, value_prefix='dependency_')
if self.__use_negation:
config += ValueMapper.parse_var('vars.negation_ok_status', self.__negation_ok_status)
config += ValueMapper.parse_var('vars.negation_warning_status', self.__negation_warning_status)
config += ValueMapper.parse_var('vars.negation_critical_status', self.__negation_critical_status)
config += ValueMapper.parse_var('vars.negation_unknown_status', self.__negation_unknown_status)
config += ValueMapper.parse_var('vars.negation_substitute', self.__negation_substitute)
config += ValueMapper.parse_var('vars.negation_timeout', self.__negation_timeout)
return config
