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) :

    23

        log.info("%s", path)

    24

    25

        self._path = path

    26

    27

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

    28

        """

    29

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

    30

    31

            Raises ValueError if invalid path.

    32

        """

    33

    34

        if node :

    35

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

    36

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

    37

        else :

    38

            path = self._path

    39

    40

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

    41

    42

        # check inside base path

    43

        if not path.startswith(self._path) :

    44

            # mask

    45

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

    46

    47

        # ok

    48

        return path

    49

    50

    def tree (self, node=None) :

    51

        """

    52

            Lookup and return 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

        path = self.path(node)

    59

    60

        # found?

    61

        if not os.path.isdir(path) :

    62

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

    63

    64

        return node

    65

    66

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

    67

        """

    68

            Lookup and return RRD for given node.

    69

        """

    70

    71

        if tree :

    72

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

    73

    74

        node += '.rrd'

    75

    76

        path = self.path(node)

    77

    78

        if not os.path.isfile(path) :

    79

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

    80

    81

        return node

    82

    83

    def list (self, tree) :

    84

        """

    85

            List (trees, rrds) under given tree.

    86

        """

    87

    88

        dirs = []

    89

        rrds = []

    90

    91

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

    92

            if name.startswith('.') :

    93

                continue

    94

    95

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

    96

    97

            path = self.path(tree, name)

    98

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

    99

   100

            if os.path.isdir(path) :

   101

                dirs.append(name)

   102

   103

            elif extname == '.rrd' :

   104

                # without the .rrd

   105

                rrds.append(basename)

   106

   107

        # return sorted lists

   108

        return sorted(dirs), sorted(rrds)

   109

   110

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

   111

        """

   112

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

   113

        """

   114

   115

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

   116

   117

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

   118

   119

        # XXX: lookup graph style..

   120

        # XXX: collectd

   121

        # XXX: out=None -> tempfile

   122

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

   123

   124

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

   125

   126

        return outfile

   127

   128

    def __str__ (self) :

   129

        return str(self._path)

   130

   131

# View/Controller

   132

class Handler (web.Handler) :

   133

    CSS = (

   134

        "/static/rrd.css", 

   135

    )

   136

   137

    def title (self) :

   138

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

   139

   140

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

   141

        """

   142

            Yield (title, url) navigation breadcrumbs

   143

        """

   144

   145

        yield '/', self.url(Index)

   146

   147

        if _tree :

   148

            tree = ''

   149

   150

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

   151

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

   152

   153

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

   154

   155

        if target :

   156

            # Target

   157

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

   158

   159

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

   160

        """

   161

            Render breadcrumb -> html.div

   162

        """

   163

   164

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

   165

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

   166

        )

   167

   168

class Index (Handler) :

   169

    """

   170

        Browse trees, show overview graphs for targets.

   171

    """

   172

   173

    def _title (self) :

   174

        if self.tree :

   175

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

   176

        else :

   177

            return ""

   178

   179

    def url_tree (self, node) :

   180

        """

   181

            Return url for given sub-node.

   182

        """

   183

   184

        if self.tree :

   185

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

   186

        else :

   187

            path = node

   188

   189

        return self.url(tree=path)

   190

   191

    def process (self, tree=None) :

   192

        """

   193

            Lookup path -> self.tree.

   194

        """

   195

   196

        if tree :

   197

            try :

   198

                # XXX: unicode?

   199

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

   200

            except ValueError as ex :

   201

                # mask

   202

                raise web.NotFound(tree)

   203

        else :

   204

            # root

   205

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

   206

   207

    def render_list (self, items) :

   208

        return (

   209

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

   210

        )

   211

   212

    def render_rrd (self, rrd) :

   213

        """

   214

            Render overview link/image for given rrd.

   215

        """

   216

   217

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

   218

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

   219

   220

        return html.a(href=target_url)(

   221

                html.p(rrd),

   222

                html.img(src=graph_url),

   223

        )

   224

   225

    def render (self) :

   226

        """

   227

            Render list of trees/rrds.

   228

        """

   229

   230

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

   231

   232

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

   233

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

   234

                    self.render_list(

   235

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

   236

                    for subtree in trees)

   237

                ) if trees else None,

   238

   239

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

   240

   241

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

   242

                    self.render_list(

   243

                        self.render_rrd(rrd)

   244

                    for rrd in rrds)

   245

                ) if rrds else None,

   246

        )

   247

   248

class Target (Handler) :

   249

    """

   250

        Show graphs for RRD file.

   251

    """

   252

   253

    def _title (self) :

   254

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

   255

   256

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

   257

        """

   258

            Lookup tree/target -> self.target

   259

        """

   260

   261

        try :

   262

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

   263

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

   264

            self.target = target

   265

   266

        except ValueError as ex :

   267

            raise web.NotFound(tree, target)

   268

   269

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

   270

        """

   271

            Render detail link/image.

   272

        """

   273

   274

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

   275

   276

        return (

   277

                html.h2(interval.title()),

   278

                html.img(src=graph_url)

   279

        )

   280

   281

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

   282

   283

    def render (self) :

   284

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

   285

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

   286

        )

   287

   288

from pvl.invoke import merge # XXX

   289

import werkzeug # wrap_file

   290

   291

class Graph (Handler) :

   292

    """

   293

        Render graph for RRD.

   294

    """

   295

   296

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

   297

   298

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

   299

        """

   300

            Return Graph for given options.

   301

        """

   302

   303

        try :

   304

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

   305

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

   306

   307

        except ValueError as ex :

   308

            raise web.NotFound(tree, target)

   309

   310

        self.style = style

   311

        self.interval = interval

   312

   313

    def render_png (self) :

   314

        """

   315

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

   316

        """

   317

   318

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

   319

   320

    def respond (self) :

   321

        """

   322

            Return Response for our request.

   323

        """

   324

   325

        # process params+args -> self.graph

   326

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

   327

        response = self.process(**process)

   328

   329

        if response :

   330

            return response

   331

   332

        # PNG output

   333

        render = self.render_png()

   334

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

   335

   336

        # respond with file wrapper

   337

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

   338

   339

# WSGI

   340

class Application (web.Application) :

   341

    urls = urls.Map((

   342

        urls.rule('/',                              Index),

   343

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

   344

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

   345

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

   346

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

   347

    ))

   348

   349

    def __init__ (self, rrd) :

   350

        """

   351

            Initialize app with given RRDDatabase

   352

        """

   353

   354

        self.rrd = rrd

   355