1

"""

     2

    Friendly wrapper around the rrdtool python interface

     3

"""

     4

     5

import rrdtool

     6

     8

import logging

    10

    11

log = logging.getLogger('rrdweb.rrd')

    12

    13

def normalize_option_key (key) :

    14

    """

    15

        Normalize the given option key.

    16

    17

        A -- is prepended, and _'s are converted to -

    18

    """

    19

    20

    return '--' + str(key).replace('_', '-')

    21

    22

def normalize_option_multi (key, values) :

    23

    """

    24

        Normalize a list of option values, returning a series of --opt, val1, --opt, val2, ...

    25

    """

    26

    27

    for value in values :

    28

        yield key

    29

        yield str(value)

    30

    31

def normalize_option (key, value) :

    32

    """

    33

        Normalize the given option to a series of cmd-args.

    34

    35

        If value is None or False, no cmd-args are emitted. If value is True, only --opt is emitted. If value is a list,

    36

        --opt and value are emitted for each item.

    37

    38

        Otherwise, both --opt and str(value) are emitted.

    39

    """

    40

    41

    key = normalize_option_key(key)

    42

    43

    if value is None or value is False :

    44

        # omit

    45

        return ()

    46

    47

    elif value is True :

    48

        # flag

    49

        return (key, )

    50

    51

    elif isinstance(value, list) :

    52

        # list of option values

    53

        return tuple(normalize_option_multi(key, value))

    54

    55

    else :

    56

        # option value

    57

        return (key, str(value))

    58

    59

def merge_opts (*all_opts) :

    60

    """

    61

        Merge the given series of opt dicts

    62

    """

    63

    64

    out = dict()

    65

    66

    for opts in all_opts :

    67

        # XXX: not strictly true, merge lists

    68

        out.update(opts)

    69

    70

    return out

    71

    72

def run_cmd (func, pre_args, opts, post_args) :

    73

    """

    74

        Run the given rrdtool.* function, formatting the given positional arguments and options.

    75

    """

    76

    77

    # series of (cmd-arg, cmd-arg, ...) tuples, giving all '--opt' and 'value' arguments for each keyword argument

    78

    opt_items = (normalize_option(key, value) for key, value in opts.iteritems())

    79

    80

    # decomposed series of cmd-args for options

    81

    opt_args = [item for items in opt_items for item in items]

    82

    83

    # positional arguments

    84

    pre_args = [str(arg) for arg in pre_args]

    85

    post_args = [str(arg) for arg in post_args]

    86

    87

    # full arguments

    88

    args = pre_args + opt_args + ['--'] + post_args

    89

    90

    log.debug('rrdtool %s %s', func.__name__, args)

    91

    92

    return func(*args)

    93

    95

    """

    97

   100

   106

    """

   112

   146

   147

def create (rrd_path, *args, **opts) :

   148

    """

   149

        Set up a new Round Robin Database (RRD).

   150

    """

   151

   152

    return run_cmd(rrdtool.create, (rrd_path, ), opts, args)

   153

   154

def update (rrd_path, *args, **opts) :

   155

    """

   156

        Store new data values into an RRD.

   157

    """

   158

   159

    return run_cmd(rrdtool.update, (rrd_path, ), opts, args)

   160

   161

   162