#!/usr/bin/env python3 """ =head1 NAME kvm_net - Munin plugin to show the network I/O per VM =head1 APPLICABLE SYSTEMS Virtualization server with VMs based on KVM may be able to track the network traffic of their VMs, if the KVM processes are started in a specific way. Probably proxmox-based virtualization hosts fit into this category. You can easily check if your KVM processes are started in the expected way, by running the following command: ps -ef | grep "netdev.*ifname=" The plugin can be used, if the above command outputs one line for every currently running VM. In all other cases you need to use other munin plugins instead, e.g. "libvirt". =head1 CONFIGURATION parsed environment variables: * vmsuffix: part of vm name to be removed =head1 AUTHOR Copyright (C) 2012 - Igor Borodikhin Copyright (C) 2018 - Lars Kruse =head1 LICENSE GPLv3 =head1 MAGIC MARKERS #%# capabilities=autoconf #%# family=contrib =cut """ import os import re from subprocess import Popen, PIPE import sys VM_NAME_REGEX = re.compile("^.*\x00-{arg_name}\x00(.+)\x00.*$") KVM_INTERFACE_NAME_REGEX = re.compile("(?:^|,)ifname=([^,]+)(?:,|$)") def config(vm_names): """ Print the plugin's config @param vm_names : a list of "cleaned" vms' name """ print("graph_title KVM Network I/O") print("graph_vlabel Bytes rx(-)/tx(+) per second") print("graph_category virtualization") print("graph_args --base 1024") print("graph_info This graph shows the network I/O of the virtual " "machines. It is only usable for VMs that were started in a very " "specific way. If you see no values in the diagrams, then you " "should check, if the command \"ps -ef | grep 'netdev.*ifname='\" " "returns one line of output for every running VM. If there is no " "output, then you need to change the setup of your VMs or you need " "to use a different munin plugin for monitoring the network traffic " "(e.g. 'libvirt').") print() for vm in vm_names: print("%s_in.label %s" % (vm, vm)) print("%s_in.type COUNTER" % vm) print("%s_in.min 0" % vm) print("%s_in.graph no" % vm) print("%s_out.negative %s_in" % (vm, vm)) print("%s_out.label %s" % (vm, vm)) print("%s_out.type COUNTER" % vm) print("%s_out.min 0" % vm) def clean_vm_name(vm_name): """ Replace all special chars @param vm_name : a vm's name @return cleaned vm's name """ # suffix part defined in conf suffix = os.getenv("vmsuffix") if suffix: vm_name = re.sub(suffix, "", vm_name) # proxmox uses kvm with -name parameter parts = vm_name.split('\x00') if (parts[0].endswith('kvm')): try: return parts[parts.index('-name')+1] except ValueError: pass return re.sub(r"(^[^A-Za-z_]|[^A-Za-z0-9_])", "_", vm_name) def fetch(vms): """ Fetch values for a list of pids @param dictionary {kvm_pid: cleaned vm name} """ for pid, vm_data in vms.items(): vm_interface_names = get_vm_network_interface_names(pid) sum_incoming = 0 sum_outgoing = 0 interface_found = False with open("/proc/net/dev", "r") as net_file: for line in net_file.readlines(): tokens = line.split() current_interface_name = tokens[0].rstrip(":").strip() if current_interface_name in vm_interface_names: sum_incoming += int(tokens[1]) sum_outgoing += int(tokens[9]) interface_found = True if not interface_found: # we want to distinguish "no traffic" from "not found" sum_incoming = "U" sum_outgoing = "U" print("%s_in.value %s" % (vm_data, sum_incoming)) print("%s_out.value %s" % (vm_data, sum_outgoing)) def get_vm_network_interface_names(pid): """ return the MAC addresses configured for network interfacs of a PID """ result = set() for netdev_description in _get_kvm_process_arguments(pid, "netdev"): match = KVM_INTERFACE_NAME_REGEX.search(netdev_description) if match: result.add(match.groups()[0]) return result def detect_kvm(): """ Check if kvm is installed """ kvm = Popen(["which", "kvm"], stdout=PIPE) kvm.communicate() return kvm.returncode == 0 def find_vm_names(pids): """Find and clean vm names from pids @return a dictionary of {pids : cleaned vm name} """ result = {} for pid in pids: name = None name_arg_values = _get_kvm_process_arguments(pid, "name") if name_arg_values: name_arg_value = name_arg_values[0] if "," in name_arg_value: # the modern parameter format may look like this: # guest=foo,debug-threads=on for index, token in enumerate(name_arg_value.split(",")): if (index == 0) and ("=" not in token): # the first item may the plain name name = value elif "=" in token: key, value = token.split("=", 1) if key == "guest": name = value else: # unknown format (no "mapping") pass else: name = name_arg_value if name is None: print("Failed to parse VM name from commandline of process: {}" .format(name_arg_values), file=sys.stderr) else: result[pid] = clean_vm_name(name) return result def _get_kvm_process_arguments(pid, arg_name): """ parse all value with the given name from the process identified by PID The result is a list of tokens, that follow this argument name. The result is empty in case of problems. """ # the "cmdline" (e.g. /proc/self/cmdline) is a null-separated token list try: with open("/proc/%s/cmdline" % pid, "r") as cmdline_file: cmdline = cmdline_file.read() except IOError: # the process seems to have died meanwhile return [] is_value = False result = [] for arg_token in cmdline.split("\0"): if is_value: # the previous token was our argument name result.append(arg_token) is_value = False elif arg_token == "-{}".format(arg_name): # this is our argument name - we want to store the next value is_value = True else: # any other irrelevant value pass return result def list_pids(): """ Find the pid of kvm processes @return a list of pids from running kvm """ pid = Popen(["pidof", "qemu-kvm", "qemu-system-x86_64", "kvm"], stdout=PIPE) return pid.communicate()[0].decode().split() if __name__ == "__main__": action = sys.argv[1] if len(sys.argv) > 1 else None if action == "autoconf": if detect_kvm(): print("yes") else: print("no") elif action == "config": vm_data = find_vm_names(list_pids()) config(vm_data.values()) else: vm_data = find_vm_names(list_pids()) fetch(vm_data)