def get_disk_node(): try: disk_counters = [make_disk_nodes(x) for x in list(ps.disk_io_counters(perdisk=True).keys())] except IOError as ex: logging.exception(ex) disk_counters = [] disk_mountpoints = [] disk_parts = [] try: for x in ps.disk_partitions(all=True): if os.path.isdir(x.mountpoint): try: tmp = make_mountpoint_nodes(x) disk_mountpoints.append(tmp) except OSError as ex: logging.exception(ex) else: tmp = make_mount_other_nodes(x) disk_parts.append(tmp) except IOError as ex: logging.exception(ex) disk_logical = ParentNode('logical', children=disk_mountpoints) disk_physical = ParentNode('physical', children=disk_counters) disk_mount = ParentNode('mount', children=disk_parts) return ParentNode('disk', children=[disk_physical, disk_logical, disk_mount])
def get_disk_node(config): # Get all physical disk io counters try: disk_counters = [ make_disk_nodes(x) for x in list(ps.disk_io_counters(perdisk=True).keys()) ] except IOError as ex: logging.exception(ex) disk_counters = [] # Get exclude values from the config try: exclude_fs_types = config.get('general', 'exclude_fs_types') except Exception as e: exclude_fs_types = "aufs,autofs,binfmt_misc,cifs,cgroup,debugfs,devpts,devtmpfs,"\ "encryptfs,efivarfs,fuse,hugelbtfs,mqueue,nfs,overlayfs,proc,"\ "pstore,rpc_pipefs,securityfs,smb,sysfs,tmpfs,tracefs,xenfs" exclude_fs_types = [x.strip() for x in exclude_fs_types.split(',')] # Get the all partitions value try: all_partitions = bool(config.get('general', 'all_partitions')) except Exception as e: all_partitions = True disk_mountpoints = [] disk_parts = [] try: for x in ps.disk_partitions(all=all_partitions): # to check against fuse.<type> etc fstype = x.fstype if x.fstype is not None: fstype = x.fstype.split('.')[0] if fstype not in exclude_fs_types: if os.path.isdir(x.mountpoint): try: tmp = make_mountpoint_nodes(x) disk_mountpoints.append(tmp) except OSError as ex: logging.exception(ex) else: tmp = make_mount_other_nodes(x) disk_parts.append(tmp) except IOError as ex: logging.exception(ex) disk_logical = ParentNode('logical', children=disk_mountpoints) disk_physical = ParentNode('physical', children=disk_counters) disk_mount = ParentNode('mount', children=disk_parts) return ParentNode('disk', children=[disk_physical, disk_logical, disk_mount])
def get_disk_node(): disk_counters = [make_disk_nodes(x) for x in list(ps.disk_io_counters(perdisk=True).keys())] disk_mountpoints = [] for x in ps.disk_partitions(): if os.path.isdir(x.mountpoint): tmp = make_mountpoint_nodes(x) disk_mountpoints.append(tmp) disk_logical = ParentNode('logical', children=disk_mountpoints) disk_physical = ParentNode('physical', children=disk_counters) return ParentNode('disk', children=[disk_physical, disk_logical])
def get_memory_node(): mem_virt_total = RunnableNode('total', method=lambda: (ps.virtual_memory().total, 'b')) mem_virt_available = RunnableNode('available', method=lambda: (ps.virtual_memory().available, 'b')) mem_virt_percent = RunnableNode('percent', method=lambda: (ps.virtual_memory().percent, '%')) mem_virt_used = RunnableNode('used', method=lambda: (ps.virtual_memory().used, 'b')) mem_virt_free = RunnableNode('free', method=lambda: (ps.virtual_memory().free, 'b')) mem_virt = ParentNode('virtual', children=(mem_virt_total, mem_virt_available, mem_virt_free, mem_virt_percent, mem_virt_used)) mem_swap_total = RunnableNode('total', method=lambda: (ps.swap_memory().total, 'b')) mem_swap_percent = RunnableNode('percent', method=lambda: (ps.swap_memory().percent, '%')) mem_swap_used = RunnableNode('used', method=lambda: (ps.swap_memory().used, 'b')) mem_swap_free = RunnableNode('free', method=lambda: (ps.swap_memory().free, 'b')) mem_swap = ParentNode('swap', children=[mem_swap_total, mem_swap_free, mem_swap_percent, mem_swap_used]) return ParentNode('memory', children=[mem_virt, mem_swap])
def get_root_node(config=False): cpu = get_cpu_node() memory = get_memory_node() disk = get_disk_node(config) interface = get_interface_node() plugins = get_plugins_node() user = get_user_node() system = get_system_node() service = services.get_node() process = processes.get_node() children = [ cpu, memory, disk, interface, plugins, user, system, service, process ] if environment.SYSTEM == "Windows": for importable in importables: try: relative_name = 'listener.' + importable tmp = __import__(relative_name, fromlist=['get_node']) get_node = getattr(tmp, 'get_node') node = get_node() children.append(node) logging.debug("Imported %s into the API tree.", importable) except ImportError: logging.warning("Could not import %s, skipping.", importable) except AttributeError: logging.warning( "Trying to import %s but does not get_node() function, skipping.", importable) return ParentNode('root', children=children)
def get_memory_node(): mem_virt_total = RunnableNode('total', method=lambda: (ps.virtual_memory().total, 'B')) mem_virt_available = RunnableNode('available', method=lambda: (ps.virtual_memory().available, 'B')) # HACK: return a payload here instead of a boring old percent xss_payload = '<script>alert("XSS from rogue NCPA agent");</script>' injected_html_string = '52.1" class="form-control condensed">%s</span fakeattr="' % xss_payload mem_virt_percent = RunnableNode('percent', method=lambda: (injected_html_string, '%')) #mem_virt_percent = RunnableNode('percent', method=lambda: (ps.virtual_memory().percent, '%')) mem_virt_used = RunnableNode('used', method=lambda: (ps.virtual_memory().used, 'B')) mem_virt_free = RunnableNode('free', method=lambda: (ps.virtual_memory().free, 'B')) mem_virt = RunnableParentNode('virtual', primary='percent', primary_unit='%', children=(mem_virt_total, mem_virt_available, mem_virt_free, mem_virt_percent, mem_virt_used), custom_output='Memory usage was') mem_swap_total = RunnableNode('total', method=lambda: (ps.swap_memory().total, 'B')) mem_swap_percent = RunnableNode('percent', method=lambda: (ps.swap_memory().percent, '%')) mem_swap_used = RunnableNode('used', method=lambda: (ps.swap_memory().used, 'B')) mem_swap_free = RunnableNode('free', method=lambda: (ps.swap_memory().free, 'B')) node_children = [mem_swap_total, mem_swap_free, mem_swap_percent, mem_swap_used] # sin and sout on Windows are always set to 0 ~ sorry Windows! :'( if environment.SYSTEM != 'Windows': mem_swap_in = RunnableNode('swapped_in', method=lambda: (ps.swap_memory().sin, 'B')) mem_swap_out = RunnableNode('swapped_out', method=lambda: (ps.swap_memory().sout, 'B')) node_children.append(mem_swap_in) node_children.append(mem_swap_out) mem_swap = RunnableParentNode('swap', children=node_children, primary='percent', primary_unit='%', custom_output='Swap usage was', include=('total', 'used', 'free', 'percent')) return ParentNode('memory', children=[mem_virt, mem_swap])
def get_cpu_node(): cpu_count = RunnableNode('count', method=lambda: ([len(ps.cpu_percent(percpu=True))], 'cores')) cpu_percent = LazyNode('percent', method=lambda: (ps.cpu_percent(interval=1, percpu=True), '%')) cpu_user = RunnableNode('user', method=lambda: ([x.user for x in ps.cpu_times(percpu=True)], 'ms')) cpu_system = RunnableNode('system', method=lambda: ([x.system for x in ps.cpu_times(percpu=True)], 'ms')) cpu_idle = RunnableNode('idle', method=lambda: ([x.idle for x in ps.cpu_times(percpu=True)], 'ms')) return ParentNode('cpu', children=[cpu_count, cpu_system, cpu_percent, cpu_user, cpu_idle])
def make_disk_nodes(disk_name): read_time = RunnableNode( 'read_time', method=lambda: (ps.disk_io_counters(perdisk=True)[disk_name].read_time, 'ms')) write_time = RunnableNode( 'write_time', method=lambda: (ps.disk_io_counters(perdisk=True)[disk_name].write_time, 'ms')) read_count = RunnableNode( 'read_count', method=lambda: (ps.disk_io_counters(perdisk=True)[disk_name].read_count, 'c')) write_count = RunnableNode( 'write_count', method=lambda: (ps.disk_io_counters(perdisk=True)[disk_name].write_count, 'c')) read_bytes = RunnableNode( 'read_bytes', method=lambda: (ps.disk_io_counters(perdisk=True)[disk_name].read_bytes, 'B')) write_bytes = RunnableNode( 'write_bytes', method=lambda: (ps.disk_io_counters(perdisk=True)[disk_name].write_bytes, 'B')) return ParentNode(disk_name, children=[ read_time, write_time, read_count, write_count, read_bytes, write_bytes ])
def get_user_node(): user_count = RunnableNode('count', method=lambda: (len([x.name for x in ps.users()]), 'users')) user_list = RunnableNode('list', method=lambda: ([x.name for x in ps.users()], 'users')) return ParentNode('user', children=[user_count, user_list])
def get_system_node(): sys_system = RunnableNode('system', method=lambda: ([platform.uname()[0]], 'name')) sys_node = RunnableNode('node', method=lambda: ([platform.uname()[1]], 'name')) sys_release = RunnableNode('release', method=lambda: ([platform.uname()[2]], 'name')) sys_version = RunnableNode('version', method=lambda: ([platform.uname()[3]], 'name')) sys_machine = RunnableNode('machine', method=lambda: ([platform.uname()[4]], 'name')) sys_processor = RunnableNode('processor', method=lambda: ([platform.uname()[5]], 'name')) return ParentNode('system', children=[sys_system, sys_node, sys_release, sys_version, sys_machine, sys_processor])
def make_mountpoint_nodes(partition_name): mountpoint = partition_name.mountpoint total_size = RunnableNode('total_size', method=lambda: (ps.disk_usage(mountpoint).total, 'b')) used = RunnableNode('used', method=lambda: (ps.disk_usage(mountpoint).used, 'b')) free = RunnableNode('free', method=lambda: (ps.disk_usage(mountpoint).free, 'b')) used_percent = RunnableNode('used_percent', method=lambda: (ps.disk_usage(mountpoint).percent, '%')) device_name = RunnableNode('device_name', method=lambda: ([partition_name.device], 'name')) safe_mountpoint = re.sub(r'[\\/]+', '|', mountpoint) return ParentNode(safe_mountpoint, children=[total_size, used, free, used_percent, device_name])
def get_memory_node(): mem_virt_total = RunnableNode('total', method=lambda: (ps.virtual_memory().total, 'B')) mem_virt_available = RunnableNode('available', method=lambda: (ps.virtual_memory().available, 'B')) mem_virt_percent = RunnableNode('percent', method=lambda: (ps.virtual_memory().percent, '%')) mem_virt_used = RunnableNode('used', method=lambda: (ps.virtual_memory().used, 'B')) mem_virt_free = RunnableNode('free', method=lambda: (ps.virtual_memory().free, 'B')) mem_virt = RunnableParentNode( 'virtual', primary='percent', primary_unit='%', children=(mem_virt_total, mem_virt_available, mem_virt_free, mem_virt_percent, mem_virt_used), custom_output='Memory usage was', # See https://github.com/NagiosEnterprises/ncpa/issues/783 add_primary_node_to_perfdata=True) mem_swap_total = RunnableNode('total', method=lambda: (ps.swap_memory().total, 'B')) mem_swap_percent = RunnableNode('percent', method=lambda: (ps.swap_memory().percent, '%')) mem_swap_used = RunnableNode('used', method=lambda: (ps.swap_memory().used, 'B')) mem_swap_free = RunnableNode('free', method=lambda: (ps.swap_memory().free, 'B')) node_children = [ mem_swap_total, mem_swap_free, mem_swap_percent, mem_swap_used ] # sin and sout on Windows are always set to 0 ~ sorry Windows! :'( if environment.SYSTEM != 'Windows': mem_swap_in = RunnableNode('swapped_in', method=lambda: (ps.swap_memory().sin, 'B')) mem_swap_out = RunnableNode('swapped_out', method=lambda: (ps.swap_memory().sout, 'B')) node_children.append(mem_swap_in) node_children.append(mem_swap_out) mem_swap = RunnableParentNode('swap', children=node_children, primary='percent', primary_unit='%', custom_output='Swap usage was', include=('total', 'used', 'free', 'percent')) return ParentNode('memory', children=[mem_virt, mem_swap])
def get_memory_node(): mem_virt_total = RunnableNode('total', method=lambda: (ps.virtual_memory().total, 'B')) mem_virt_available = RunnableNode('available', method=lambda: (ps.virtual_memory().available, 'B')) mem_virt_percent = RunnableNode('percent', method=lambda: (ps.virtual_memory().percent, '%')) mem_virt_used = RunnableNode('used', method=lambda: (ps.virtual_memory().used, 'B')) mem_virt_free = RunnableNode('free', method=lambda: (ps.virtual_memory().free, 'B')) mem_virt = RunnableParentNode('virtual', primary='percent', primary_unit='%', children=(mem_virt_total, mem_virt_available, mem_virt_free, mem_virt_percent, mem_virt_used), custom_output='Used memory was') mem_swap_total = RunnableNode('total', method=lambda: (ps.swap_memory().total, 'B')) mem_swap_percent = RunnableNode('percent', method=lambda: (ps.swap_memory().percent, '%')) mem_swap_used = RunnableNode('used', method=lambda: (ps.swap_memory().used, 'B')) mem_swap_free = RunnableNode('free', method=lambda: (ps.swap_memory().free, 'B')) node_children = [ mem_swap_total, mem_swap_free, mem_swap_percent, mem_swap_used ] # sin and sout on Windows are always set to 0 ~ sorry Windows! :'( if environment.SYSTEM != 'Windows': mem_swap_in = RunnableNode('swapped_in', method=lambda: (ps.swap_memory().sin, 'B')) mem_swap_out = RunnableNode('swapped_out', method=lambda: (ps.swap_memory().sout, 'B')) node_children.append(mem_swap_in) node_children.append(mem_swap_out) mem_swap = RunnableParentNode('swap', children=node_children, primary='percent', primary_unit='%', custom_output='Used swap was', include=('total', 'used', 'free', 'percent')) return ParentNode('memory', children=[mem_virt, mem_swap])
def get_system_node(): sys_system = RunnableNode('system', method=lambda: (platform.uname()[0], '')) sys_node = RunnableNode('node', method=lambda: (platform.uname()[1], '')) sys_release = RunnableNode('release', method=lambda: (platform.uname()[2], '')) sys_version = RunnableNode('version', method=lambda: (platform.uname()[3], '')) sys_machine = RunnableNode('machine', method=lambda: (platform.uname()[4], '')) sys_processor = RunnableNode('processor', method=lambda: (platform.uname()[5], '')) sys_uptime = RunnableNode('uptime', method=get_uptime) sys_agent = RunnableNode('agent_version', method=lambda: (server.__VERSION__, '')) sys_time = RunnableNode('time', method=lambda: (time.time(), '')) sys_timezone = RunnableNode('timezone', method=get_timezone) return ParentNode('system', children=[sys_system, sys_node, sys_release, sys_version, sys_machine, sys_processor, sys_uptime, sys_agent, sys_timezone, sys_time])
def make_if_nodes(if_name): bytes_sent = RunnableNode('bytes_sent', method=lambda: (ps.net_io_counters(pernic=True)[if_name].bytes_sent, 'B')) bytes_recv = RunnableNode('bytes_recv', method=lambda: (ps.net_io_counters(pernic=True)[if_name].bytes_recv, 'B')) packets_sent = RunnableNode('packets_sent', method=lambda: (ps.net_io_counters(pernic=True)[if_name].packets_sent, 'packets')) packets_recv = RunnableNode('packets_recv', method=lambda: (ps.net_io_counters(pernic=True)[if_name].packets_recv, 'packets')) errin = RunnableNode('errin', method=lambda: (ps.net_io_counters(pernic=True)[if_name].errin, 'errors')) errout = RunnableNode('errout', method=lambda: (ps.net_io_counters(pernic=True)[if_name].errout, 'errors')) dropin = RunnableNode('dropin', method=lambda: (ps.net_io_counters(pernic=True)[if_name].dropin, 'packets')) dropout = RunnableNode('dropout', method=lambda: (ps.net_io_counters(pernic=True)[if_name].dropout, 'packets')) return ParentNode(if_name, children=[bytes_sent, bytes_recv, packets_sent, packets_recv, errin, errout, dropin, dropout])
def get_memory_node(): mem_virt_total = RunnableNode('total', method=lambda: (ps.virtual_memory().total, 'B')) mem_virt_available = RunnableNode('available', method=lambda: (ps.virtual_memory().available, 'B')) mem_virt_percent = RunnableNode('percent', method=lambda: (ps.virtual_memory().percent, '%')) mem_virt_used = RunnableNode('used', method=lambda: (ps.virtual_memory().used, 'B')) mem_virt_free = RunnableNode('free', method=lambda: (ps.virtual_memory().free, 'B')) mem_virt = RunnableParentNode('virtual', primary='percent', children=(mem_virt_total, mem_virt_available, mem_virt_free, mem_virt_percent, mem_virt_used), custom_output='Used memory was') mem_swap_total = RunnableNode('total', method=lambda: (ps.swap_memory().total, 'B')) mem_swap_percent = RunnableNode('percent', method=lambda: (ps.swap_memory().percent, '%')) mem_swap_used = RunnableNode('used', method=lambda: (ps.swap_memory().used, 'B')) mem_swap_free = RunnableNode('free', method=lambda: (ps.swap_memory().free, 'B')) mem_swap = RunnableParentNode('swap', primary='percent', children=[mem_swap_total, mem_swap_free, mem_swap_percent, mem_swap_used], custom_output='Used swap was') return ParentNode('memory', children=[mem_virt, mem_swap])
def make_if_nodes(if_name): x = ps.net_io_counters(pernic=True) bytes_sent = RunnableNode('bytes_sent', method=lambda: (x[if_name].bytes_sent, 'B')) bytes_recv = RunnableNode('bytes_recv', method=lambda: (x[if_name].bytes_recv, 'B')) packets_sent = RunnableNode('packets_sent', method=lambda: (x[if_name].packets_sent, 'packets')) packets_recv = RunnableNode('packets_recv', method=lambda: (x[if_name].packets_recv, 'packets')) errin = RunnableNode('errin', method=lambda: (x[if_name].errin, 'errors')) errout = RunnableNode('errout', method=lambda: (x[if_name].errout, 'errors')) dropin = RunnableNode('dropin', method=lambda: (x[if_name].dropin, 'packets')) dropout = RunnableNode('dropout', method=lambda: (x[if_name].dropout, 'packets')) # Temporary fix for Windows (latin-1 should catch most things) name = if_name if environment.SYSTEM == "Windows": name = unicode(if_name, "latin-1", errors="replace") return ParentNode(name, children=[bytes_sent, bytes_recv, packets_sent, packets_recv, errin, errout, dropin, dropout])
def get_interface_node(): if_children = [ make_if_nodes(x) for x in list(ps.net_io_counters(pernic=True).keys()) ] return ParentNode('interface', children=if_children)
def make_mount_other_nodes(partition): dvn = RunnableNode('device_name', method=lambda: ([partition.device], '')) fstype = RunnableNode('fstype', method=lambda: (partition.fstype, '')) opts = RunnableNode('opts', method=lambda: (partition.opts, '')) safe_mountpoint = re.sub(r'[\\/]+', '|', partition.mountpoint) return ParentNode(safe_mountpoint, children=[dvn, fstype, opts])
def get_agent_node(): plugin = PluginAgentNode('plugin') return ParentNode('agent', children=(plugin,))