1

"""

     2

    Handle host-interface mappings for stats.

     3

"""

     4

     5

import shlex

     6

import os.path

     7

     8

import logging; log = logging.getLogger('pvl.rrd.hosts')

     9

    10

def hostjoin (*hosts) :

    11

    """

    12

        DNS hostname join.

    13

    """

    14

    15

    return '.'.join(hosts)

    16

    17

def hostreverse (host) :

    18

    """

    19

        Reverse hostname.

    20

    """

    21

    22

    return '.'.join(reversed(host.split('.')))

    23

    24

def load (file, domain=None) :

    25

    """

    26

        Parse hosts from file, yielding

    27

            (host, node, iface, tag)

    28

    29

            file            - read host/ifaces from file

    30

            domain          - append given domain to hostname

    31

    """

    32

    33

    host = None

    34

    35

    for idx, line in enumerate(file, 1) :

    36

        line = line.rstrip()

    37

    38

        if not line :

    39

            continue

    40

    41

        # comment?

    42

        if line.startswith('#') :

    43

            continue

    44

    45

        # line

    46

        parts = shlex.split(line)

    47

    48

        if not line[0].isspace() :

    49

            host = parts.pop(0)

    50

    51

            # host-spec?

    52

            if '=' in host :

    53

                host, node = host.split('=')

    54

            else :

    55

                node = host

    56

    57

            # host has domain in collectd?

    58

            if domain :

    59

                host = hostjoin(host, domain)

    60

    61

        if not parts :

    62

            # keep host for following lines

    63

            continue

    64

    65

        iface = parts.pop(0)

    66

    67

        # possibly multiple tags..

    68

        for tag in parts :

    69

            yield host, node, iface, tag

    70

    71

def map_interfaces (options, file):

    72

    """

    73

        Read (hostname, interface}: (nodename, tag) pairs from file.

    74

    """

    75

    76

    for host, node, iface, tag in load(file) :

    77

        log.debug("%s/%s -> %s/%s", host, iface, node, tag)

    78

        yield (host, iface), (node, tag)

    79

    80

def collectd_interfaces (options, file, collectd_domain, collectd_plugin) :

    81

    """

    82

        Read collectd (host, type-instance, name) items, and yield (collectd-rrd, out-rrd) tuples.

    83

    84

            file                - read host/ports from file

    85

            collectd_domain     - append given domain to collectd hostname

    86

            collectd_plugin     - use given collectd plugin's type-instances

    87

    """

    88

    89

    log.info("scanning %s/<host>.%s/%s/%s-<port>.rrd", options.collectd_rrd, collectd_domain, collectd_plugin, options.collectd_type)

    90

    91

    for collectd_host, interface_host, port, tag in load(file, domain=collectd_domain) :

    92

        # flip from DNS-ordering -> path-ordering

    93

        if options.reverse_host :

    94

            interface_host = hostreverse(interface_host)

    95

    96

        if options.collectd_instance == 'type' :

    97

            type = options.collectd_type + '-' + port

    98

        else :

    99

            type = options.collectd_type

   100

   101

        if options.collectd_instance == 'plugin' :

   102

            plugin = collectd_plugin + '-' + port

   103

        else :

   104

            plugin = collectd_plugin

   105

   106

        collectd_rrd = os.path.join(options.collectd_rrd, collectd_host, plugin, type) + '.rrd'

   107

   108

        if not os.path.exists(collectd_rrd) :

   109

            log.warn("%s/%s: missing collectd rrd: %s", collectd_host, port, collectd_rrd)

   110

            continue

   111

   112

        # out

   113

        interface_rrd = os.path.join(interface_host, tag + '.rrd')

   114

   115

        log.debug("%s: %s", interface_rrd, collectd_rrd)

   116

   117

        yield collectd_rrd, interface_rrd