1

# encoding: utf-8

     2

"""

     3

    http://verkko.paivola.fi/rrd

     4

"""

     5

     6

import pvl.web.application as web

     7

from pvl.web import urls

     8

from pvl.web.html import tags as html

     9

    10

import pvl.rrd

    11

    12

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

    13

    14

# Model

    15

import os, os.path, errno

    16

    17

class RRDDatabase (object) :

    18

    """

    19

        A filesystem directory containing .rrd files.

    20

    """

    21

    29

        if not path :

    30

            raise ValueError("RRDDatabase: no path given")

    31

    35

        self._path = path

    36

        self._cache = cache

    37

    38

    def path (self, node=None, *subnodes) :

    39

        """

    40

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

    41

    42

            Raises ValueError if invalid path.

    43

        """

    44

    45

        if node :

    46

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

    47

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

    48

        else :

    49

            path = self._path

    50

    51

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

    52

    53

        # check inside base path

    54

        if not path.startswith(self._path) :

    55

            # mask

    56

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

    57

    58

        # ok

    59

        return path

    60

    61

    def tree (self, node=None) :

    62

        """

    63

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

    64

    65

            Raises ValueError if invalid path, or no such tree.

    66

        """

    67

    68

        # lookup fs path

    69

        path = self.path(node)

    70

    71

        # found?

    72

        if not os.path.isdir(path) :

    73

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

    74

    75

        return node

    76

    77

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

    78

        """

    79

            Lookup and return RRD for given node.

    80

        """

    81

    82

        if tree :

    83

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

    84

    85

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

    86

    87

        if not os.path.isfile(path) :

    88

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

    89

    90

        return node

    91

    92

    def list (self, tree) :

    93

        """

    94

            List (trees, rrds) under given tree.

    95

        """

    96

    97

        dirs = []

    98

        rrds = []

    99

   100

        for name in os.listdir(self.path(tree)) :

   101

            if name.startswith('.') :

   102

                continue

   103

   104

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

   105

   106

            path = self.path(tree, name)

   107

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

   108

   109

            if os.path.isdir(path) :

   110

                dirs.append(name)

   111

   112

            elif extname == '.rrd' :

   113

                # without the .rrd

   114

                rrds.append(basename)

   115

   116

        # return sorted lists

   117

        return sorted(dirs), sorted(rrds)

   118

   119

    def _stat (self, path) :

   120

        """

   121

            os.stat or None.

   122

        """

   123

   124

        try :

   125

            return os.stat(path)

   126

   127

        except OSError as ex :

   128

            if ex.errno == errno.ENOENT :

   129

                return None

   130

            else :

   131

                raise

   132

   133

    def cache (self, source, *key) :

   134

        """

   135

            Lookup given key from cache, returning (hit, file).

   136

        """

   137

   138

        # output

   139

        if not self._cache :

   140

            return None, None

   141

   142

        # cache path

   143

        path = os.path.join(self._cache, *key)

   144

   145

        # create

   146

        dir = os.path.dirname(path)

   147

        if not os.path.isdir(dir) :

   148

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

   149

            os.makedirs(dir)

   150

   151

        # stats's

   152

        src = self._stat(source)

   153

        dst = self._stat(path)

   154

   155

        if not dst:

   156

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

   157

            return None, path

   158

   159

        elif dst and src.st_mtime < dst.st_mtime :

   160

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

   161

   162

            return True, path

   163

   164

        else :

   165

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

   166

            return False, path

   167

   168

    def graph (self, rrd, style, interval) :

   169

        """

   170

            Graph given rrd using given style/interval, returning the opened png data file.

   171

        """

   172

   173

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

   174

   175

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

   176

   177

        cached, out = self.cache(path, style, interval, rrd + '.png')

   178

   179

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

   180

   181

        if cached :

   182

            # from cache

   183

            outfile = open(out)

   184

   185

        else :

   186

            # to cache

   188

   189

        return outfile

   190

   191

    def __str__ (self) :

   192

        return str(self._path)

   193

   194

# View/Controller

   195

class Handler (web.Handler) :

   196

    CSS = (

   197

        "/static/rrd.css", 

   198

    )

   199

   200

    def title (self) :

   201

        return u"Päivölä Network - Network RRD Traffic Graphs"

   202

   203

    def breadcrumb (self, _tree, target=None) :

   204

        """

   205

            Yield (title, url) navigation breadcrumbs

   206

        """

   207

   208

        yield '/', self.url(Index)

   209

   210

        if _tree :

   211

            tree = ''

   212

   213

            for part in _tree.split('/') :

   214

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

   215

   216

                yield part, self.url(Index, tree=tree)

   217

   218

        if target :

   219

            # Target

   220

            yield target, self.url(Target, tree=tree, target=self.target)

   221

   222

    def render_breadcrumb (self, tree, target=None) :

   223

        """

   224

            Render breadcrumb -> html.div

   225

        """

   226

   227

        return html.div(id='breadcrumb')(html(" » ".join(

   228

            str(html.a(href=url)(node)) for node, url in self.breadcrumb(tree, target)))

   229

        )

   230

   231

class Index (Handler) :

   232

    """

   233

        Browse trees, show overview graphs for targets.

   234

    """

   235

   236

    def _title (self) :

   237

        if self.tree :

   238

            return html(" » ".join(self.tree.split('/')))

   239

        else :

   240

            return ""

   241

   242

    def url_tree (self, node) :

   243

        """

   244

            Return url for given sub-node.

   245

        """

   246

   247

        if self.tree :

   248

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

   249

        else :

   250

            path = node

   251

   252

        return self.url(tree=path)

   253

   254

    def process (self, tree=None) :

   255

        """

   256

            Lookup path -> self.tree.

   257

        """

   258

   259

        if tree :

   260

            try :

   261

                # XXX: unicode?

   262

                self.tree = self.app.rrd.tree(tree)

   263

            except ValueError as ex :

   264

                # mask

   265

                raise web.NotFound(tree)

   266

        else :

   267

            # root

   268

            self.tree = self.app.rrd.tree()

   269

   270

    def render_list (self, items) :

   271

        return (

   272

            html.li(class_=('odd' if idx % 2 else 'even'))(item) for idx, item in enumerate(items)

   273

        )

   274

   275

    def render_rrd (self, rrd) :

   276

        """

   277

            Render overview link/image for given rrd.

   278

        """

   279

   280

        target_url = self.url(Target, tree=self.tree, target=rrd)

   281

        graph_url = self.url(Graph, tree=self.tree, target=rrd)

   282

   283

        return html.a(href=target_url)(

   284

                html.h3(rrd),

   285

                html.img(src=graph_url),

   286

        )

   287

   288

    def render (self) :

   289

        """

   290

            Render list of trees/rrds.

   291

        """

   292

   293

        trees, rrds = self.app.rrd.list(self.tree)

   294

   295

        return self.render_breadcrumb(self.tree), html.div(id='overview')(

   296

                html.ul(id='tree-list')(

   297

                    self.render_list(

   298

                        html.a(href=self.url_tree(subtree))(subtree)

   299

                    for subtree in trees)

   300

                ) if trees else None,

   301

   302

                html.hr() if trees and rrds else None,

   303

   304

                html.ul(id='rrd-list')(

   305

                    self.render_list(

   306

                        self.render_rrd(rrd)

   307

                    for rrd in rrds)

   308

                ) if rrds else None,

   309

        )

   310

   311

class Target (Handler) :

   312

    """

   313

        Show graphs for RRD file.

   314

    """

   315

   316

    def _title (self) :

   317

        return html(" » ".join(self.rrd.split('/')))

   318

   319

    def process (self, target, tree=None) :

   320

        """

   321

            Lookup tree/target -> self.target

   322

        """

   323

   324

        try :

   325

            self.tree = self.app.rrd.tree(tree)

   326

            self.rrd = self.app.rrd.rrd(target, self.tree)

   327

            self.target = target

   328

   329

        except ValueError as ex :

   330

            raise web.NotFound(tree, target)

   331

   332

    def render_interval (self, interval, style='detail') :

   333

        """

   334

            Render detail link/image.

   335

        """

   336

   337

        graph_url = self.url(Graph, tree=self.tree, target=self.target, style=style, interval=interval)

   338

   339

        return (

   340

                html.h2(interval.title()),

   341

                html.img(src=graph_url)

   342

        )

   343

   344

    INTERVALS = ('daily', 'weekly', 'yearly')

   345

   346

    def render (self) :

   347

        return self.render_breadcrumb(self.tree, self.target), html.div(id='detail')(

   348

                self.render_interval(interval) for interval in self.INTERVALS

   349

        )

   350

   351

from pvl.invoke import merge # XXX

   352

import werkzeug # wrap_file

   353

   354

class Graph (Handler) :

   355

    """

   356

        Render graph for RRD.

   357

    """

   358

   359

    ARGS = { 'interval': 'daily', 'style': 'overview' }

   360

   361

    def process (self, tree, target, style, interval) :

   362

        """

   363

            Return Graph for given options.

   364

        """

   365

   366

        try :

   367

            self.tree = self.app.rrd.tree(tree)

   368

            self.rrd = self.app.rrd.rrd(target, self.tree)

   369

   370

        except ValueError as ex :

   371

            raise web.NotFound(tree, target)

   372

   373

        self.style = style

   374

        self.interval = interval

   375

   376

    def render_png (self) :

   377

        """

   378

            Return PNG data as a file-like object for our graph.

   379

        """

   380

   381

        return self.app.rrd.graph(self.rrd, self.style, self.interval)

   382

   383

    def respond (self) :

   384

        """

   385

            Return Response for our request.

   386

        """

   387

   388

        # process params+args -> self.graph

   389

        process = merge(self.params, dict((arg, self.request.args.get(arg, default)) for arg, default in self.ARGS.iteritems()))

   390

        response = self.process(**process)

   391

   392

        if response :

   393

            return response

   394

   395

        # PNG output

   396

        render = self.render_png()

   397

        file = werkzeug.wrap_file(self.request.environ, render)

   398

   399

        # respond with file wrapper

   400

        return web.Response(file, mimetype='image/png', direct_passthrough=True)        

   401

   402

# WSGI

   403

class Application (web.Application) :

   404

    urls = urls.Map((

   405

        urls.rule('/',                              Index),

   406

        urls.rule('/<target>',                      Target),

   407

        urls.rule('/<path:tree>/',                  Index),

   408

        urls.rule('/<path:tree>/<target>',          Target),

   409

        urls.rule('/<path:tree>/<target>.png',      Graph),

   410

    ))

   411

   412

    def __init__ (self, rrd) :

   413

        """

   414

            Initialize app with given RRDDatabase

   415

        """

   416

   417

        self.rrd = rrd

   418