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.web.response

    11

import pvl.rrd

    12

    13

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

    14

    15

# errors

    16

import os.path

    17

    18

class RRDNotFound (pvl.web.response.NotFound) :

    19

    """

    20

        404 Not Found for tree/rrd.

    21

    """

    22

    23

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

    24

        if tree and rrd :

    25

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

    26

        elif tree :

    27

            path = tree

    28

        elif rrd :

    29

            path = rrd

    30

        else :

    31

            path = ''

    32

    33

        pvl.web.response.NotFound.__init__(self, path)

    34

    35

# View/Controller

    36

class Handler (web.Handler) :

    37

    CSS = (

    38

        "/static/rrd/rrd.css", 

    39

    )

    40

    41

    def title (self) :

    42

        return u"Network RRD Traffic Graphs"

    43

    44

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

    45

        """

    46

            Yield (title, url) navigation breadcrumbs

    47

        """

    48

    49

        yield '/', self.url(Index)

    50

    51

        if _tree :

    52

            tree = ''

    53

    54

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

    55

                tree = urls.join(tree, part)

    56

    57

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

    58

    59

        if target :

    60

            # Target

    61

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

    62

    63

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

    64

        """

    65

            Render breadcrumb -> html.div

    66

        """

    67

    68

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

    69

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

    70

        )

    71

    72

class Index (Handler) :

    73

    """

    74

        Browse trees, show overview graphs for targets.

    75

    """

    76

    77

    def _title (self) :

    78

        if self.tree :

    79

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

    80

        else :

    81

            return ""

    82

    83

    def url_tree (self, node) :

    84

        """

    85

            Return url for given sub-node.

    86

        """

    87

    88

        if self.tree :

    89

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

    90

        else :

    91

            path = node

    92

    93

        return self.url(tree=path)

    94

    95

    def process (self, tree=None) :

    96

        """

    97

            Lookup path -> self.tree.

    98

        """

    99

   100

        if tree :

   101

            try :

   102

                # XXX: unicode?

   103

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

   104

   105

            except ValueError as ex :

   106

                # mask

   107

                raise RRDNotFound(tree)

   108

        else :

   109

            # root

   110

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

   111

   112

    def render_list (self, items) :

   113

        return (

   114

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

   115

        )

   116

   117

    def render_rrd (self, rrd) :

   118

        """

   119

            Render overview link/image for given rrd.

   120

        """

   121

   122

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

   123

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

   124

   125

        return html.a(href=target_url)(

   126

                html.h3(rrd),

   127

                html.img(src=graph_url),

   128

        )

   129

   130

    def render (self) :

   131

        """

   132

            Render list of trees/rrds.

   133

        """

   134

   135

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

   136

   137

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

   138

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

   139

                    self.render_list(

   140

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

   141

                    for subtree in trees)

   142

                ) if trees else None,

   143

   144

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

   145

   146

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

   147

                    self.render_list(

   148

                        self.render_rrd(rrd)

   149

                    for rrd in rrds)

   150

                ) if rrds else None,

   151

        )

   152

   153

class Target (Handler) :

   154

    """

   155

        Show graphs for RRD file.

   156

    """

   157

   158

    def _title (self) :

   159

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

   160

   161

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

   162

        """

   163

            Lookup tree/target -> self.target

   164

        """

   165

   166

        try :

   167

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

   168

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

   169

            self.target = target

   170

   171

        except ValueError as ex :

   172

            raise RRDNotFound(tree, target)

   173

   174

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

   175

        """

   176

            Render detail link/image.

   177

        """

   178

   179

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

   180

   181

        return (

   182

                html.h2(interval.title()),

   183

                html.img(src=graph_url)

   184

        )

   185

   186

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

   187

   188

    def render (self) :

   189

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

   190

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

   191

        )

   192

   193

from pvl.invoke import merge # XXX

   194

import werkzeug # wrap_file

   195

   196

class Graph (Handler) :

   197

    """

   198

        Render graph for RRD.

   199

    """

   200

   201

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

   202

   203

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

   204

        """

   205

            Return Graph for given options.

   206

        """

   207

   208

        try :

   209

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

   210

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

   211

   212

        except ValueError as ex :

   213

            raise RRDNotFound(tree, target)

   214

   215

        self.style = style

   216

        self.interval = interval

   217

   218

    def render_png (self) :

   219

        """

   220

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

   221

        """

   222

   223

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

   224

   225

    def respond (self) :

   226

        """

   227

            Return Response for our request.

   228

        """

   229

   230

        # process params+args -> self.graph

   231

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

   232

        response = self.process(**process)

   233

   234

        if response :

   235

            return response

   236

   237

        # PNG output

   238

        file = self.render_png()

   239

   240

        # respond with file wrapper

   241

        return pvl.web.response.image(self.response_file(file), type='png')

   242

   243

# WSGI

   244

class Application (web.Application) :

   245

    # dispatch

   246

    URLS = urls.Map((

   247

        urls.rule('/',                              Index),

   248

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

   249

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

   250

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

   251

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

   252

    ))

   253

   254

    def __init__ (self, rrd, **opts) :

   255

        """

   256

            rrd     - pvl.rrd.RRDDatabase

   257

        """

   258

   259

        super(Application, self).__init__(**opts)

   260

   261

        self.rrd = rrd

   262