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

    16

    17

class RRDDatabase (object) :

    18

    """

    19

        A filesystem directory containing .rrd files.

    20

    """

    21

    23

        if not path :

    24

            raise ValueError("RRDDatabase: no path given")

    25

    27

    28

        self._path = path

    30

    31

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

    32

        """

    33

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

    34

    35

            Raises ValueError if invalid path.

    36

        """

    37

    38

        if node :

    39

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

    40

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

    41

        else :

    42

            path = self._path

    43

    44

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

    45

    46

        # check inside base path

    47

        if not path.startswith(self._path) :

    48

            # mask

    49

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

    50

    51

        # ok

    52

        return path

    53

    54

    def tree (self, node=None) :

    55

        """

    56

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

    57

    58

            Raises ValueError if invalid path, or no such tree.

    59

        """

    60

    61

        # lookup fs path

    62

        path = self.path(node)

    63

    64

        # found?

    65

        if not os.path.isdir(path) :

    66

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

    67

    68

        return node

    69

    70

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

    71

        """

    72

            Lookup and return RRD for given node.

    73

        """

    74

    75

        if tree :

    76

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

    77

    79

    80

        if not os.path.isfile(path) :

    81

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

    82

    83

        return node

    84

    85

    def list (self, tree) :

    86

        """

    87

            List (trees, rrds) under given tree.

    88

        """

    89

    90

        dirs = []

    91

        rrds = []

    92

    93

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

    94

            if name.startswith('.') :

    95

                continue

    96

    97

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

    98

    99

            path = self.path(tree, name)

   100

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

   101

   102

            if os.path.isdir(path) :

   103

                dirs.append(name)

   104

   105

            elif extname == '.rrd' :

   106

                # without the .rrd

   107

                rrds.append(basename)

   108

   109

        # return sorted lists

   110

        return sorted(dirs), sorted(rrds)

   111

   161

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

   162

        """

   163

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

   164

        """

   165

   167

   169

   183

   184

        return outfile

   185

   186

    def __str__ (self) :

   187

        return str(self._path)

   188

   189

# View/Controller

   190

class Handler (web.Handler) :

   191

    CSS = (

   192

        "/static/rrd.css", 

   193

    )

   194

   195

    def title (self) :

   196

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

   197

   198

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

   199

        """

   200

            Yield (title, url) navigation breadcrumbs

   201

        """

   202

   203

        yield '/', self.url(Index)

   204

   205

        if _tree :

   206

            tree = ''

   207

   208

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

   209

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

   210

   211

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

   212

   213

        if target :

   214

            # Target

   215

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

   216

   217

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

   218

        """

   219

            Render breadcrumb -> html.div

   220

        """

   221

   222

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

   223

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

   224

        )

   225

   226

class Index (Handler) :

   227

    """

   228

        Browse trees, show overview graphs for targets.

   229

    """

   230

   231

    def _title (self) :

   232

        if self.tree :

   233

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

   234

        else :

   235

            return ""

   236

   237

    def url_tree (self, node) :

   238

        """

   239

            Return url for given sub-node.

   240

        """

   241

   242

        if self.tree :

   243

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

   244

        else :

   245

            path = node

   246

   247

        return self.url(tree=path)

   248

   249

    def process (self, tree=None) :

   250

        """

   251

            Lookup path -> self.tree.

   252

        """

   253

   254

        if tree :

   255

            try :

   256

                # XXX: unicode?

   257

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

   258

            except ValueError as ex :

   259

                # mask

   260

                raise web.NotFound(tree)

   261

        else :

   262

            # root

   263

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

   264

   265

    def render_list (self, items) :

   266

        return (

   267

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

   268

        )

   269

   270

    def render_rrd (self, rrd) :

   271

        """

   272

            Render overview link/image for given rrd.

   273

        """

   274

   275

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

   276

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

   277

   278

        return html.a(href=target_url)(

   279

                html.h3(rrd),

   280

                html.img(src=graph_url),

   281

        )

   282

   283

    def render (self) :

   284

        """

   285

            Render list of trees/rrds.

   286

        """

   287

   288

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

   289

   290

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

   291

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

   292

                    self.render_list(

   293

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

   294

                    for subtree in trees)

   295

                ) if trees else None,

   296

   297

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

   298

   299

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

   300

                    self.render_list(

   301

                        self.render_rrd(rrd)

   302

                    for rrd in rrds)

   303

                ) if rrds else None,

   304

        )

   305

   306

class Target (Handler) :

   307

    """

   308

        Show graphs for RRD file.

   309

    """

   310

   311

    def _title (self) :

   312

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

   313

   314

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

   315

        """

   316

            Lookup tree/target -> self.target

   317

        """

   318

   319

        try :

   320

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

   321

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

   322

            self.target = target

   323

   324

        except ValueError as ex :

   325

            raise web.NotFound(tree, target)

   326

   327

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

   328

        """

   329

            Render detail link/image.

   330

        """

   331

   332

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

   333

   334

        return (

   335

                html.h2(interval.title()),

   336

                html.img(src=graph_url)

   337

        )

   338

   339

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

   340

   341

    def render (self) :

   342

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

   343

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

   344

        )

   345

   346

from pvl.invoke import merge # XXX

   347

import werkzeug # wrap_file

   348

   349

class Graph (Handler) :

   350

    """

   351

        Render graph for RRD.

   352

    """

   353

   354

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

   355

   356

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

   357

        """

   358

            Return Graph for given options.

   359

        """

   360

   361

        try :

   362

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

   363

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

   364

   365

        except ValueError as ex :

   366

            raise web.NotFound(tree, target)

   367

   368

        self.style = style

   369

        self.interval = interval

   370

   371

    def render_png (self) :

   372

        """

   373

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

   374

        """

   375

   376

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

   377

   378

    def respond (self) :

   379

        """

   380

            Return Response for our request.

   381

        """

   382

   383

        # process params+args -> self.graph

   384

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

   385

        response = self.process(**process)

   386

   387

        if response :

   388

            return response

   389

   390

        # PNG output

   391

        render = self.render_png()

   392

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

   393

   394

        # respond with file wrapper

   395

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

   396

   397

# WSGI

   398

class Application (web.Application) :

   399

    urls = urls.Map((

   400

        urls.rule('/',                              Index),

   401

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

   402

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

   403

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

   404

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

   405

    ))

   406

   407

    def __init__ (self, rrd) :

   408

        """

   409

            Initialize app with given RRDDatabase

   410

        """

   411

   412

        self.rrd = rrd

   413