1

import rrdtool

     2

     3

import pvl.invoke

     4

import tempfile

     5

     6

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

     7

     8

"""

     9

    Wrapper around the rrdtool python interface

    10

"""

    11

    12

def timestamp (time=None) :

    13

    """

    14

        Format datetime value for rrdtool.

    15

    """

    16

    17

    if not time :

    18

        return None

    19

    20

    elif isinstance(time, datetime.datetime) :

    21

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

    22

    23

    elif isinstance(time, datetime.timedelta) :

    24

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

    25

    26

    else :

    27

        # dunno

    28

        return str(dt)

    29

    30

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

    31

    """

    32

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

    33

    34

        Returns the return value, which varies...

    35

    """

    36

    37

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

    38

    39

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

    40

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

    41

    42

    # positional arguments

    43

    pre = pvl.invoke.optargs(*pre)

    44

    post = pvl.invoke.optargs(*post)

    45

    46

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

    47

    48

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

    49

    """

    50

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

    51

    52

            out     - None  -> tempfile

    53

                    - False -> stdout

    54

                    - path  -> write to file

    55

    56

        Returns:

    57

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

    58

            report_output           - any PRINT'd output (?)

    59

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

    60

    61

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

    62

    63

        XXX: tempfile suffix as .png?

    64

    """

    65

    66

    if out is None :

    67

        # tempfile

    68

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

    69

        out_path = out_file.name

    70

    71

    elif out is False :

    72

        out_file = None

    73

        out_path = '-'

    74

    75

    else :

    76

        # for reading

    77

        out_path = out

    78

        out_file = True # open later

    79

    80

    log.debug("%s", out_path)

    81

    82

    # XXX: handle tempfile close?

    83

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

    84

    85

    if out_file is True :

    86

        out_file = open(out_path)

    87

    88

    return (width, height), out_lines, out_file

    89

    90

def report (*defs, **opts) :

    91

    """

    92

        Render an output-less graph with only PRINT statements as a textual report.

    93

    94

        Returns output lines.

    95

    """

    96

    97

    # exec

    98

    width, height, out_lines = cmd(rrdtool.graph, ('/dev/null', ), opts, defs)

    99

   100

    return out_lines

   101

   102

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

   103

    """

   104

        Fetch values from RRD.

   105

   106

        Returns

   107

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

   108

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

   109

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

   110

    """

   111

   112

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

   113

   114

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

   115

    """

   116

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

   117

    """

   118

   119

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

   120

        resolution  = resolution,

   121

        start       = timestamp(start),

   122

        end         = timestamp(end),

   123

        **opts

   124

    )

   125

   126

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

   127

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

   128