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

    16

    17

class RRDDatabase (object) :

    18

    """

    19

        A filesystem directory containing .rrd files.

    20

    """

    21

    22

    def __init__ (self, path) :

    26

        log.info("%s", path)

    27

    28

        self._path = path

    29

    30

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

    31

        """

    32

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

    33

    34

            Raises ValueError if invalid path.

    35

        """

    36

    37

        if node :

    38

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

    39

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

    40

        else :

    41

            path = self._path

    42

    43

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

    44

    45

        # check inside base path

    46

        if not path.startswith(self._path) :

    47

            # mask

    48

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

    49

    50

        # ok

    51

        return path

    52

    53

    def tree (self, node=None) :

    54

        """

    55

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

    56

    57

            Raises ValueError if invalid path, or no such tree.

    58

        """

    59

    60

        # lookup fs path

    61

        path = self.path(node)

    62

    63

        # found?

    64

        if not os.path.isdir(path) :

    65

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

    66

    67

        return node

    68

    69

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

    70

        """

    71

            Lookup and return RRD for given node.

    72

        """

    73

    74

        if tree :

    75

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

    76

    77

        node += '.rrd'

    78

    79

        path = self.path(node)

    80

    81

        if not os.path.isfile(path) :

    82

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

    83

    84

        return node

    85

    86

    def list (self, tree) :

    87

        """

    88

            List (trees, rrds) under given tree.

    89

        """

    90

    91

        dirs = []

    92

        rrds = []

    93

    94

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

    95

            if name.startswith('.') :

    96

                continue

    97

    98

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

    99

   100

            path = self.path(tree, name)

   101

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

   102

   103

            if os.path.isdir(path) :

   104

                dirs.append(name)

   105

   106

            elif extname == '.rrd' :

   107

                # without the .rrd

   108

                rrds.append(basename)

   109

   110

        # return sorted lists

   111

        return sorted(dirs), sorted(rrds)

   112

   113

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

   114

        """

   115

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

   116

        """

   117

   118

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

   119

   120

        log.debug("%s: %s: %s/%s", self, rrd, style, interval)

   121

   122

        # XXX: lookup graph style..

   123

        # XXX: collectd

   124

        # XXX: out=None -> tempfile

   125

        dimensions, lines, outfile = pvl.rrd.graph.collectd_ifoctets(style, interval, title, self.path(rrd), None)

   126

   127

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

   128

   129

        return outfile

   130

   131

    def __str__ (self) :

   132

        return str(self._path)

   133

   134

# View/Controller

   135

class Handler (web.Handler) :

   136

    CSS = (

   137

        "/static/rrd.css", 

   138

    )

   139

   140

    def title (self) :

   141

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

   142

   143

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

   144

        """

   145

            Yield (title, url) navigation breadcrumbs

   146

        """

   147

   148

        yield '/', self.url(Index)

   149

   150

        if _tree :

   151

            tree = ''

   152

   153

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

   154

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

   155

   156

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

   157

   158

        if target :

   159

            # Target

   160

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

   161

   162

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

   163

        """

   164

            Render breadcrumb -> html.div

   165

        """

   166

   167

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

   168

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

   169

        )

   170

   171

class Index (Handler) :

   172

    """

   173

        Browse trees, show overview graphs for targets.

   174

    """

   175

   176

    def _title (self) :

   177

        if self.tree :

   178

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

   179

        else :

   180

            return ""

   181

   182

    def url_tree (self, node) :

   183

        """

   184

            Return url for given sub-node.

   185

        """

   186

   187

        if self.tree :

   188

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

   189

        else :

   190

            path = node

   191

   192

        return self.url(tree=path)

   193

   194

    def process (self, tree=None) :

   195

        """

   196

            Lookup path -> self.tree.

   197

        """

   198

   199

        if tree :

   200

            try :

   201

                # XXX: unicode?

   202

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

   203

            except ValueError as ex :

   204

                # mask

   205

                raise web.NotFound(tree)

   206

        else :

   207

            # root

   208

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

   209

   210

    def render_list (self, items) :

   211

        return (

   212

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

   213

        )

   214

   215

    def render_rrd (self, rrd) :

   216

        """

   217

            Render overview link/image for given rrd.

   218

        """

   219

   220

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

   221

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

   222

   223

        return html.a(href=target_url)(

   225

                html.img(src=graph_url),

   226

        )

   227

   228

    def render (self) :

   229

        """

   230

            Render list of trees/rrds.

   231

        """

   232

   233

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

   234

   235

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

   236

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

   237

                    self.render_list(

   238

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

   239

                    for subtree in trees)

   240

                ) if trees else None,

   241

   242

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

   243

   244

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

   245

                    self.render_list(

   246

                        self.render_rrd(rrd)

   247

                    for rrd in rrds)

   248

                ) if rrds else None,

   249

        )

   250

   251

class Target (Handler) :

   252

    """

   253

        Show graphs for RRD file.

   254

    """

   255

   256

    def _title (self) :

   257

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

   258

   259

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

   260

        """

   261

            Lookup tree/target -> self.target

   262

        """

   263

   264

        try :

   265

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

   266

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

   267

            self.target = target

   268

   269

        except ValueError as ex :

   270

            raise web.NotFound(tree, target)

   271

   272

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

   273

        """

   274

            Render detail link/image.

   275

        """

   276

   277

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

   278

   279

        return (

   280

                html.h2(interval.title()),

   281

                html.img(src=graph_url)

   282

        )

   283

   284

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

   285

   286

    def render (self) :

   287

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

   288

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

   289

        )

   290

   291

from pvl.invoke import merge # XXX

   292

import werkzeug # wrap_file

   293

   294

class Graph (Handler) :

   295

    """

   296

        Render graph for RRD.

   297

    """

   298

   299

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

   300

   301

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

   302

        """

   303

            Return Graph for given options.

   304

        """

   305

   306

        try :

   307

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

   308

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

   309

   310

        except ValueError as ex :

   311

            raise web.NotFound(tree, target)

   312

   313

        self.style = style

   314

        self.interval = interval

   315

   316

    def render_png (self) :

   317

        """

   318

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

   319

        """

   320

   321

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

   322

   323

    def respond (self) :

   324

        """

   325

            Return Response for our request.

   326

        """

   327

   328

        # process params+args -> self.graph

   329

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

   330

        response = self.process(**process)

   331

   332

        if response :

   333

            return response

   334

   335

        # PNG output

   336

        render = self.render_png()

   337

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

   338

   339

        # respond with file wrapper

   340

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

   341

   342

# WSGI

   343

class Application (web.Application) :

   344

    urls = urls.Map((

   345

        urls.rule('/',                              Index),

   346

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

   347

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

   348

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

   349

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

   350

    ))

   351

   352

    def __init__ (self, rrd) :

   353

        """

   354

            Initialize app with given RRDDatabase

   355

        """

   356

   357

        self.rrd = rrd

   358