NetDev

Complexity

Total Complexity

14

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	15	1
A	poll()	0	6	1
B	get_columns()	0	36	6
B	check()	0	36	6

# -*- coding: utf-8 -*-
"""Network interface metrics reader for /proc on Linux."""
import re
import time
from collections import deque

import plumd
from plumd.util import Differential
from plumd.util import get_file

__author__ = 'Kenny Freeman'
__email__ = 'kenny.freeman@gmail.com'
__license__ = "ISCL"
__docformat__ = 'reStructuredText'


class NetDev(plumd.Reader):
    """Plugin to measure various kernel metrics from /proc."""

    rename = {
        'packets': 'pkt',
        'compressed': 'compr',
        'multicast': 'mcast',
    }

    defaults = {
        'poll.interval': 10,
        'proc_path': '/proc',
        'proc_netdev_re': "(virbr\d+)|(vnet\d+)"

A suspicious escape sequence \d was found. Did you maybe forget to add an r prefix?

    }

    def __init__(self, log, config):
        """Plugin to measure network interface metrics from proc file net/dev.

        :param log: A logger
        :type log: logging.RootLogger
        :param config: a plumd.config.Conf configuration helper instance.
        :type config: plumd.config.Conf
        """
        super(NetDev, self).__init__(log, config)
        config.defaults(NetDev.defaults)
        self.proc_file = "{0}/net/dev".format(config.get('proc_path'))
        self.dev_re = re.compile(config.get('proc_netdev_re'))
        self.calc = Differential()
        self.enabled = True
        self.dev_cols = self.get_columns()

    def get_columns(self):
        """Return the /proc file column names.

        :rtype: list
        """
        cols = []
        dat = get_file(self.proc_file)
        lines = deque(dat.split("\n"))
        nlines = len(lines)
        # expect at least one network interface + 2 header lines
        if nlines < 2:
            msg = "NetDev: cannot parse {0}"
            self.log.error(msg.format(self.proc_file))
            self.enabled = False
            return cols

        # skip first line eg. Inter-|   Receive
        lines.popleft()
        # next line has the header values
        hdr_vals = deque(lines.popleft().split("|"))
        # remove eg.  face
        hdr_vals.popleft()
        if len(hdr_vals) != 2:
            msg = "NetDev: cannot parse {0}"
            self.log.error(msg.format(self.proc_file))
            self.enabled = False
            return cols

        # values are receive then transmit
        hdrs = dict(zip(["rx", "tx"], hdr_vals))
        for pfx, metrics in hdrs.items():
            for metric in metrics.split():
                if metric in NetDev.rename:
                    metric = NetDev.rename[metric]
                cols.append("{0}_{1}".format(pfx, metric))
        return cols

    def poll(self):
        """Return network interface metrics from proc file net/dev.

        :rtype: ResultSet
        """
        return plumd.ResultSet(self.check())

    def check(self):
        """Return network interface metrics from proc file net/dev.

        :rtype: list
        """
        result = plumd.Result("netdev")
        if not self.enabled:
            return [result]

        dat = {}
        cols = self.dev_cols
        regexp = self.dev_re

        # read and process /proc/net/dev
        with open(self.proc_file, 'r') as pfd:
            lines = deque(pfd.read().strip().split("\n"))
            # remove the two header lines - format fail :|
            lines.popleft()
            lines.popleft()

        # for Differential
        times = time.time()

        # now it's dev, metrics
        for line in lines:
            dat = line.split()
            dev = dat[0].split(":")[0]
            vals = dat[1:]
            if regexp.match(dev):
                continue
            for key, val in dict(zip(cols, vals)).items():
                mstr = "{0}.{1}".format(dev, key)
                dval = self.calc.per_second(mstr, int(val), times)
                result.add(plumd.Float(mstr, dval))

        return [result]