1

import rrdtool

     2

     3

import pvl.invoke

     4

     5

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

     6

     7

"""

     8

    Wrapper around the rrdtool python interface

     9

"""

    10

    11

def timestamp (time=None) :

    12

    """

    13

        Format datetime value for rrdtool.

    14

    """

    15

    16

    if not time :

    17

        return None

    18

    19

    elif isinstance(time, datetime.datetime) :

    20

        return int(time.mktime(dt.timetuple()))

    21

    22

    elif isinstance(time, datetime.timedelta) :

    23

        raise NotImplementedError("pvl.rrd.api.timestamp: timedelta")

    24

    25

    else :

    26

        # dunno

    27

        return str(dt)

    28

    29

def cmd (func, pre, opts, post) :

    30

    """

    31

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

    32

    33

        Returns the return value, which varies...

    34

    """

    35

    36

    log.debug("%s: %s: %s: %s", func, pre, opts, post)

    37

    38

    # { opt: arg } -> [ '--opt', arg ]

    39

    opts = pvl.invoke.optargs(**opts)

    40

    41

    # positional arguments

    42

    pre = pvl.invoke.optargs(*pre)

    43

    post = pvl.invoke.optargs(*post)

    44

    45

    return func(*(pre + opts + post))

    46

    47

def graph (out=None, *args, **opts) :

    48

    """

    49

        Render a graph image and/or print a report from data stored in one or several RRDs.

    50

    51

            out     - None  -> tempfile

    52

                    - False -> stdout

    53

                    - path  -> write to file

    54

    55

        Returns:

    56

            (width, height)         - pixel dimensions of the resulting graph image

    57

            report_output           - any PRINT'd output (?)

    58

            graph_file              - file-like object containing graph image, unless out=False -> stdout

    59

    60

        With out=None, the returned graph_file is a tempfile which will be cleaned up by Python once close()'d!

    61

    """

    62

    63

    if out is None :

    64

        # tempfile

    65

        out_file = tempfile.NamedTemporaryFile(suffix='.png', delete=True) # python2.6

    66

        out_path = out.name

    67

    68

    elif out is False :

    69

        out_file = None

    70

        out_path = '-'

    71

    72

    else :

    73

        # for reading

    74

        out_path = out

    75

        out_file = True # open later

    76

    77

    # XXX: handle tempfile close?

    78

    width, height, out_lines = cmd(rrdtool.graph, (out_path, ), opts, args)

    79

    80

    if out_file is True :

    81

        out_file = open(out_path)

    82

    83

    return (width, height), out_lines, out_file

    84

    85

def fetch (rrd, cf, **opts) :

    86

    """

    87

        Fetch values from RRD.

    88

    89

        Returns

    90

            (start, end, step)          - xrange(...) for row timestamps

    91

            (ds, ...)                   - columns (ds name)

    92

            ((value, ...), ...)         - rows (data by ds)

    93

    """

    94

    95

    return cmd(rrdtool.fetch, (rrd, cf), opts, ())

    96

    97

def _fetch (rrd, cf='AVERAGE', resolution=None, start=None, end=None, **opts) :

    98

    """

    99

        Yields (timestamp, { ds: value }) for given ds-values, or all.

   100

    """

   101

   102

    steps, sources, rows = fetch(rrd, cf,

   103

        resolution  = resolution,

   104

        start       = timestamp(start),

   105

        end         = timestamp(end),

   106

        **opts

   107

    )

   108

   109

    for ts, row in zip(xrange(*steps), rows) :

   110

        yield datetime.fromtimestamp(ts), dict(zip(sources, row))

   111