1

# encoding: utf-8

     2

"""

     3

    http://verkko.paivola.fi/rrd

     4

"""

     5

     6

from pvl import 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

# View/Controller

    15

class Handler (web.Handler) :

    16

    CSS = (

    18

    )

    19

    20

    def title (self) :

    21

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

    22

    23

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

    24

        """

    25

            Yield (title, url) navigation breadcrumbs

    26

        """

    27

    28

        yield '/', self.url(Index)

    29

    30

        if _tree :

    31

            tree = ''

    32

    33

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

    34

                tree = urls.join(tree, part)

    35

    36

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

    37

    38

        if target :

    39

            # Target

    40

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

    41

    42

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

    43

        """

    44

            Render breadcrumb -> html.div

    45

        """

    46

    47

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

    48

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

    49

        )

    50

    51

class Index (Handler) :

    52

    """

    53

        Browse trees, show overview graphs for targets.

    54

    """

    55

    56

    def _title (self) :

    57

        if self.tree :

    58

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

    59

        else :

    60

            return ""

    61

    62

    def url_tree (self, node) :

    63

        """

    64

            Return url for given sub-node.

    65

        """

    66

    67

        if self.tree :

    68

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

    69

        else :

    70

            path = node

    71

    72

        return self.url(tree=path)

    73

    74

    def process (self, tree=None) :

    75

        """

    76

            Lookup path -> self.tree.

    77

        """

    78

    79

        if tree :

    80

            try :

    81

                # XXX: unicode?

    82

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

    83

    84

            except ValueError as ex :

    85

                # mask

    86

                raise web.NotFound(tree)

    87

        else :

    88

            # root

    89

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

    90

    91

    def render_list (self, items) :

    92

        return (

    93

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

    94

        )

    95

    96

    def render_rrd (self, rrd) :

    97

        """

    98

            Render overview link/image for given rrd.

    99

        """

   100

   101

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

   102

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

   103

   104

        return html.a(href=target_url)(

   105

                html.h3(rrd),

   106

                html.img(src=graph_url),

   107

        )

   108

   109

    def render (self) :

   110

        """

   111

            Render list of trees/rrds.

   112

        """

   113

   114

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

   115

   116

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

   117

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

   118

                    self.render_list(

   119

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

   120

                    for subtree in trees)

   121

                ) if trees else None,

   122

   123

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

   124

   125

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

   126

                    self.render_list(

   127

                        self.render_rrd(rrd)

   128

                    for rrd in rrds)

   129

                ) if rrds else None,

   130

        )

   131

   132

class Target (Handler) :

   133

    """

   134

        Show graphs for RRD file.

   135

    """

   136

   137

    def _title (self) :

   138

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

   139

   140

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

   141

        """

   142

            Lookup tree/target -> self.target

   143

        """

   144

   145

        try :

   146

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

   147

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

   148

            self.target = target

   149

   150

        except ValueError as ex :

   151

            raise web.NotFound(tree + '/' + target)

   152

   153

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

   154

        """

   155

            Render detail link/image.

   156

        """

   157

   158

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

   159

   160

        return (

   161

                html.h2(interval.title()),

   162

                html.img(src=graph_url)

   163

        )

   164

   165

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

   166

   167

    def render (self) :

   168

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

   169

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

   170

        )

   171

   172

from pvl.invoke import merge # XXX

   173

import werkzeug # wrap_file

   174

   175

class Graph (Handler) :

   176

    """

   177

        Render graph for RRD.

   178

    """

   179

   180

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

   181

   182

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

   183

        """

   184

            Return Graph for given options.

   185

        """

   186

   187

        try :

   188

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

   189

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

   190

   191

        except ValueError as ex :

   192

            raise web.NotFound(tree + '/' + target)

   193

   194

        self.style = style

   195

        self.interval = interval

   196

   197

    def render_png (self) :

   198

        """

   199

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

   200

        """

   201

   202

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

   203

   204

    def respond (self) :

   205

        """

   206

            Return Response for our request.

   207

        """

   208

   209

        # process params+args -> self.graph

   210

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

   211

        response = self.process(**process)

   212

   213

        if response :

   214

            return response

   215

   216

        # PNG output

   217

        render = self.render_png()

   218

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

   219

   220

        # respond with file wrapper

   221

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

   222

   223

# WSGI

   224

class Application (web.Application) :

   225

    # dispatch

   226

    urls = urls.Map((

   227

        urls.rule('/',                              Index),

   228

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

   229

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

   230

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

   231

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

   232

    ))

   233

   234

    def __init__ (self, rrd) :

   235

        """

   236

            rrd     - pvl.rrd.RRDDatabase

   237

        """

   238

   239

        self.rrd = rrd

   240