1

#!/usr/bin/python

     2

     3

"""

     4

    Setup symlinks for pvl.verkko-rrd -> collectd based on define host/interface names

     5

"""

     6

     7

__version__ = '0.1'

     8

     9

import shlex

    10

import os

    11

    12

import pvl.args

    13

    14

import optparse

    15

import logging; log = logging.getLogger('main')

    16

    17

def hostjoin (*hosts) :

    18

    """

    19

        DNS hostname join.

    20

    """

    21

    22

    return '.'.join(hosts)

    23

    24

def hostreverse (host) :

    25

    """

    26

        Reverse hostname.

    27

    """

    28

    29

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

    30

    31

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

    32

    """

    33

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

    34

    35

            file                - read host/ports from file

    36

            collectd_domain     - append given domain to collectd hostname

    37

            collectd_plugin     - use given collectd plugin's type-instances

    38

    """

    39

    40

    host = None

    41

    42

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

    43

    44

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

    45

        line = line.rstrip()

    46

    47

        if not line :

    48

            continue

    49

    50

        # comment?

    51

        if line.startswith('#') :

    52

            continue

    53

    54

        # line

    55

        parts = shlex.split(line)

    56

    57

        if not line[0].isspace() :

    58

            host = parts.pop(0)

    59

    60

        # host-spec?

    61

        if '=' in host :

    62

            collectd_host, interface_host = host.split('=')

    63

        else :

    64

            collectd_host = interface_host = host

    65

    66

        # flip from DNS-ordering -> path-ordering

    67

        if options.reverse_host :

    68

            interface_host = hostreverse(interface_host)

    69

    70

        # host has domain in collectd?

    71

        if collectd_domain :

    72

            collectd_host = hostjoin(collectd_host, collectd_domain)

    73

    74

        if not parts :

    75

            # keep host for following lines

    76

            continue

    77

    78

        port = parts.pop(0)

    79

    80

        # possibly multiple tags..

    81

        for tag in parts :

    82

            collectd_type = options.collectd_type + '-' + port

    83

            collectd_rrd = os.path.join(options.collectd_rrd, collectd_host, collectd_plugin, collectd_type) + '.rrd'

    84

    85

            if not os.path.exists(collectd_rrd) :

    86

                log.warn("%s: missing collectd rrd: %s", idx, collectd_rrd)

    87

                continue

    88

    89

            # out

    90

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

    91

    92

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

    93

    94

            yield collectd_rrd, interface_rrd

    95

    96

def sync_links (options, links, dir) :

    97

    """

    98

        Sync given (collectd, name) symlinks in given dir.

    99

    """

   100

   101

    log.info("%s", dir)

   102

   103

    for path, name in links :

   104

        link = os.path.join(dir, name)

   105

   106

        # sync

   107

        if os.path.exists(link) :

   108

            continue

   109

   110

        log.info("%s: %s: %s", dir, name, path)

   111

   112

        yield link, path

   113

   114

def apply_links (options, links) :

   115

    """

   116

        Apply given symlinks

   117

    """

   118

   119

    for link, path in links :

   120

        linkdir = os.path.dirname(link)

   121

   122

        # do

   123

        if not os.path.exists(linkdir) :

   124

            log.warn("mkdir: %s", linkdir)

   125

            os.mkdir(linkdir)

   126

   127

        print path

   128

   129

        os.symlink(path, link)

   130

   131

COLLECTD_RRD = '/var/lib/collectd/rrd'

   132

COLLECTD_PLUGIN = 'interfaces'

   133

COLLECTD_TYPE = 'if_octets'

   134

   135

def parse_argv (argv, doc = __doc__) :

   136

    """

   137

        Parse command-line argv, returning (options, args).

   138

    """

   139

   140

    prog = argv.pop(0)

   141

    args = argv

   142

   143

    # optparse

   144

    parser = optparse.OptionParser(

   145

        prog        = prog,

   146

        usage       = '%prog: [options] [<input.txt> [...]]',

   147

        version     = __version__,

   148

        description = doc,

   149

    )

   150

   151

    # common

   152

    parser.add_option_group(pvl.args.parser(parser))

   153

   154

    # options

   155

    parser.add_option('--collectd-rrd',     metavar='PATH',     default=COLLECTD_RRD,

   156

            help="Path to collectd rrd: %default")

   157

    parser.add_option('--collectd-plugin',  metavar='PLUGIN',   default=None,

   158

            help="Collectd plugin to use: <input>-<plugin>.txt")

   159

    parser.add_option('--collectd-type',    metavar='TYPE',     default=COLLECTD_TYPE,

   160

            help="Collectd type to use: %default")

   161

   162

    # hostnames

   163

    parser.add_option('--reverse-host',     action='store_true',

   164

            help="Flip host.domain -> domain.host (default)")

   165

    parser.add_option('--no-reverse-host',  action='store_false', dest='reverse_host',

   166

            help="Keep host.domain as host.domain")

   167

    parser.add_option('--domain',           metavar='DOMAIN',  

   168

            help="Append domain to collectd hostnames: <input>.txt -> <input>")

   169

   170

    # output

   171

    parser.add_option('--rrd',              metavar='PATH',

   172

            help="Output directory for .rrd symlinks: <input>.txt -> <input>/")

   173

    parser.add_option('--noop',             action='store_true',

   174

            help="Scan symlinks, but do not update")

   175

   176

    parser.set_defaults(

   177

            reverse_host    = True,

   178

    )

   179

   180

    # parse

   181

    options, args = parser.parse_args(args)

   182

   183

    # apply

   184

    pvl.args.apply(options)

   185

   186

    return options, args

   187

   188

def main (argv) :

   189

    options, args = parse_argv(argv)

   190

   191

    for txt in args :

   192

        # <path>/<domain>-<plugin>.txt -> <path>/<domain>-<plugin>

   193

        basepath, _ = os.path.splitext(txt)

   194

   195

        # <path>/<domain>-<plugin> -> <path>/<domain>, <plugin>

   196

        if '-' in basepath :

   197

            basepath, collectd_plugin = basepath.rsplit('-', 1)

   198

        else :

   199

            collectd_plugin = None

   200

   201

        # <path>/<domain> -> <domain>

   202

        _, basename = os.path.split(basepath)

   203

   204

        # domain?

   205

        if options.domain is None :

   206

            # reverse-order hostname

   207

            domain = hostreverse(basename)

   208

        else :

   209

            # may be ''

   210

            domain = options.domain

   211

   212

        # output dir?

   213

        if options.rrd :

   214

            rrd_domain = hostreverse(domain) if options.reverse_host else domain

   215

            rrd = os.path.join(options.rrd, rrd_domain)

   216

        else :

   217

            rrd = basepath

   218

   219

        # generate links from spec

   220

        links = list(collectd_interfaces(options, open(txt),

   221

            collectd_domain     = domain,

   222

            collectd_plugin     = options.collectd_plugin or collectd_plugin or COLLECTD_PLUGIN,

   223

        ))

   224

   225

        if not os.path.exists(rrd) :

   226

            log.warn("mkdir: %s", rrd)

   227

   228

            if not options.noop :

   229

                os.mkdir(rrd)

   230

   231

        # sync missing links

   232

        links = list(sync_links(options, links,

   233

            dir     = rrd,

   234

        ))

   235

   236

        # verbose

   237

        if not options.quiet :

   238

            for link, path in links :

   239

                print link, '->', path

   240

   241

        # apply

   242

        if not options.noop :

   243

            apply_links(options, links)

   244

   245

    return 0

   246

   247

if __name__ == '__main__':

   248

    import sys

   249

   250

    sys.exit(main(sys.argv))