1

"""

     2

    RRD file on filesystem.

     3

"""

     4

     5

import os, os.path, errno

     6

     7

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

     8

     9

class RRDDatabase (object) :

    10

    """

    11

        A filesystem directory containing .rrd files.

    12

    """

    13

    14

    def __init__ (self, path, graph_type, cache=None) :

    15

        """

    16

            path        - path to rrd dirs

    17

            graph_type  - pvl.rrd.graph.InterfaceGraph type

    18

            cache       - optional RRDCache

    19

        """

    20

    21

        if not path :

    22

            raise ValueError("RRDDatabase: no path given")

    23

    24

        log.info("%s: graph_type=%s, cache=%s", path, graph_type, cache)

    25

    26

        self.graph_type = graph_type

    27

        self._path = path

    28

        self.cache = cache

    29

    30

    def path (self, *nodes) :

    31

        """

    32

            Lookup and full filesystem path to the given relative RRD/dir path.

    33

    34

            Raises ValueError if invalid path.

    35

        """

    36

    37

        # relative dir (no leading slash) -> absolute path

    38

        path = os.path.normpath(os.path.join(self._path, *nodes))

    39

    40

        log.debug("%s: %s -> %s", self, nodes, path)

    41

    42

        # check inside base path

    43

        if not path.startswith(self._path.rstrip('/')) :

    44

            # mask

    45

            raise ValueError("%s: Invalid path: %s" % (self, nodes))

    46

    47

        # ok

    48

        return path

    49

    50

    def tree (self, node=None) :

    51

        """

    52

            Lookup and return XXX:RRDTree for given node, or root tree.

    53

    54

            Raises ValueError if invalid path, or no such tree.

    55

        """

    56

    57

        # lookup fs path

    58

        if node :

    59

            path = self.path(node)

    60

        else :

    61

            path = self.path()

    62

    63

        # found?

    64

        if not os.path.isdir(path) :

    65

            raise ValueError("%s: Invalid tree: %s: %s" % (self, node, path))

    66

    67

        if node :

    68

            return node

    69

        else :

    70

            return '' # equivalent

    71

    72

    def rrd (self, node, tree=None) :

    73

        """

    74

            Lookup and return RRD for given node.

    75

        """

    76

    77

        if tree :

    78

            node = os.path.join(tree, node)

    79

    80

        path = self.path(node) + '.rrd'

    81

    82

        if not os.path.isfile(path) :

    83

            raise ValueError("%: Invalid rrd: %s: %s" % (self, node, path))

    84

    85

        return RRD(self, node, self.graph_type)

    86

    87

    def list (self, tree=None) :

    88

        """

    89

            List (trees, rrds) under given tree.

    90

        """

    91

    92

        dirs = []

    93

        rrds = []

    94

    95

        path = self.path(tree)

    96

    97

        for name in os.listdir(path) :

    98

            if name.startswith('.') :

    99

                continue

   100

   101

            path = self.path(tree, name)

   102

   103

            basename, extname = os.path.splitext(name)

   104

   105

            log.debug("%s: %s: %s: %s", self, tree, name, path)

   106

   107

            if os.path.isdir(path) :

   108

                dirs.append(name)

   109

   110

            elif extname == '.rrd' :

   111

                # without the .rrd

   112

                rrds.append(basename)

   113

   114

        # return sorted lists

   115

        return sorted(dirs), sorted(rrds)

   116

   117

    def graph (self, rrd, style, interval, cache=True) :

   118

        """

   119

            Cached RRD.graph(), returning outfile.

   120

   121

            Uses self.cache if cache, otherwise graphs to tempfile.

   122

        """

   123

   124

        path = rrd.path()

   125

   126

        if self.cache and cache :

   127

            # path in cache

   128

            out = self.cache.path(style, interval, str(rrd))

   129

   130

            # hit/miss?

   131

            cache = self.cache.lookup(path, out)

   132

   133

        else :

   134

            # tempfile

   135

            out = None

   136

            cache = None

   137

   138

        log.debug("%s: %s: %s", self, rrd, out)

   139

   140

        if cache :

   141

            # from cache

   142

            outfile = open(out)

   143

   144

        else :

   145

            # to cache/tempfile

   146

            dimensions, lines, outfile = rrd.graph(style, interval).graph(out)

   147

   148

        return outfile

   149

   150

    def __str__ (self) :

   151

        return self._path

   152

   153

class RRD (object) :

   154

    """

   155

        An .rrd file on the filesystem, graphed using pvl.rrd.graph.Interface.

   156

    """

   157

   158

    def __init__ (self, db, rrd, graph_type) :

   159

        self.db = db

   160

        self.rrd = rrd

   161

        self.graph_type = graph_type

   162

   163

    def path (self) :

   164

        return self.db.path(self.rrd) + '.rrd'

   165

   166

    def graph (self, style, interval) :

   167

        """

   168

            Build Graph given rrd using given style/interval.

   169

        """

   170

   171

        path = self.path()

   172

   173

        title = str(self) # " / ".join(rrd.split('/'))

   174

        return self.graph_type.build(title, path, style, interval)

   175

   176

    def __str__ (self) :

   177

        return self.rrd

   178

   179

class RRDCache (object) :

   180

    """

   181

        Cache graph output in the filesystem.

   182

    """

   183

   184

    def __init__ (self, path) :

   185

        log.info("%s", path)

   186

   187

        self._path = path

   188

   189

    def path (self, *key) :

   190

        """

   191

            Return cache path for key.

   192

        """

   193

   194

        return os.path.join(self._path, *key) + '.png'

   195

   196

    def _stat (self, path) :

   197

        """

   198

            os.stat or None.

   199

        """

   200

   201

        try :

   202

            return os.stat(path)

   203

   204

        except OSError as ex :

   205

            if ex.errno == errno.ENOENT :

   206

                return None

   207

            else :

   208

                raise

   209

   210

    def lookup (self, source, path) :

   211

        """

   212

            Return hit from cache.

   213

        """

   214

   215

        # create

   216

        dir = os.path.dirname(path)

   217

        if not os.path.isdir(dir) :

   218

            log.warn("makedirs %s", dir)

   219

            os.makedirs(dir)

   220

   221

        # stats's

   222

        src = self._stat(source)

   223

        dst = self._stat(path)

   224

   225

        if dst and src.st_mtime < dst.st_mtime :

   226

            log.debug("%s: %s: %s: hit", self, source, path)

   227

   228

            return True

   229

   230

        elif not dst:

   231

            log.debug("%s: %s: %s: miss", self, source, path)

   232

            return False

   233

   234

        else :

   235

            log.debug("%s: %s: %s: update", self, source, path)

   236

            return None

   237

   238

    def __str__ (self) :

   239

        return self._path