1

from pvl.rrd import api as rrd

     2

import time

     3

     4

from pvl.invoke import merge # XXX

     5

     6

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

     7

     8

"""

     9

    RRDTool graph builders.

    10

    11

    Includes support for Smokeping-inspired interface graphs from MRTG/Collectd.

    12

"""

    13

    14

def timestamp () :

    15

    return time.strftime("%Y/%m/%d %H:%M:%S %Z")

    16

    17

class Graph (object) :

    18

    """

    19

        Render an RRD graph from definitions/options.

    20

    21

        Acts as a semi-magical object, with immutable state, and methods that return updated copies of our state.

    22

    23

        >>> Graph()

    24

        Graph()

    25

        >>> Graph('foo')

    26

        Graph('foo')

    27

        >>> Graph(bar='bar')

    28

        Graph(bar='bar')

    29

        >>> Graph('foo', bar='bar')

    30

        Graph('foo', bar='bar')

    31

        >>> Graph('foo')(bar='bar')

    32

        Graph('foo', bar='bar')

    33

    """

    34

    35

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

    36

        self.defs = defs

    37

        self.opts = opts

    38

    39

    def __call__ (self, *defs, **opts) :

    40

        return type(self)(*(self.defs + defs), **merge(self.opts, opts))

    41

    42

    def __getitem__ (self, key) :

    43

        return self.opts[key]

    44

    45

    def graph (self, out) :

    46

        """

    47

            Render completed graph using pvl.rrd.api.graph()

    48

        """

    49

    50

        return rrd.graph(out, *self.defs, **self.opts)

    51

    52

    def __repr__ (self) :

    53

        return "{type}({args})".format(

    54

                type    = self.__class__.__name__,

    55

                args    = ', '.join([repr(def_) for def_ in self.defs] + [str(opt) + '=' + repr(value) for opt, value in self.opts.iteritems()]),

    56

        )

    57

    58

class Interface (Graph) :

    59

    """

    60

        An RRD graph showing in/out traffic in bits/s on an interface, with style/interval support.

    61

    """

    62

    63

    @classmethod

    64

    def build (cls, title, rrd, style, interval) :

    65

        """

    66

            Return a simple Graph using the given title, RRD and style/interval

    67

    68

                title       - common(title=...)

    69

                rrd         - data(rrd=...)

    70

                style       - style(style=...)

    71

                interval    - interval(interval=...)

    72

        """

    73

    74

        return cls().common(title).source(rrd).style(style).interval(interval)

    75

    76

    # builders

    77

    def common (self, title) :

    78

        """

    79

            Common options for all views

    80

        """

    81

    82

        return self(

    83

            # output

    84

            imgformat           = "PNG",

    85

            #        lazy                = True,

    86

    87

            color               = [

    88

                # disable border

    89

                # border            = 0,

    90

                "SHADEA#ffffff00",

    91

                "SHADEB#ffffff00",

    92

    93

                # keep background transparent

    94

                "BACK#ffffff00",

    95

                "SHADEB#ffffff00",

    96

            ],

    97

    98

            # labels

    99

            vertical_label      = "bits/s",

   100

            title               = title,

   101

            units               = "si",

   102

   103

            # use logarithmic scaling?

   104

            #        logarithmic         = True,

   105

   106

            # smooth out lines

   107

            slope_mode          = True,

   108

        )

   109

   110

    ## data

   111

    # DS names; in/out bytes

   112

    IN = OUT = None

   113

   114

    def source (self, rrd) :

   115

        """

   116

            Abstract: rrd -> in/out

   117

        """

   118

   119

        if not (self.IN and self.OUT) :

   120

            raise TypeError("No IN/OUT DS names for %s" % (self, ))

   121

   122

        log.debug("%s", rrd)

   123

   124

        return self(

   125

            # data sources, bytes/s

   126

            r'DEF:in0={rrd}:{ds_in}:AVERAGE'.format(rrd=rrd, ds_in=self.IN),

   127

            r'DEF:out0={rrd}:{ds_out}:AVERAGE'.format(rrd=rrd, ds_out=self.OUT),

   128

   129

            # data, bits/s

   130

            'CDEF:in=in0,8,*',

   131

            'CDEF:out=out0,8,*',

   132

        )

   133

   134

    ## style

   135

    def style_overview (graph) :

   136

        """

   137

            in/out bps -> overview graph

   138

        """

   139

   140

        return graph(

   141

            "CDEF:all=in,out,+",

   142

   143

            "VDEF:max=all,MAXIMUM",

   144

            "VDEF:avg=all,AVERAGE",

   145

            "VDEF:min=all,MINIMUM",

   146

   147

            "LINE1:in#0000FF:In",

   148

            "LINE1:out#00CC00:Out",

   149

   150

            "GPRINT:max:%6.2lf %Sbps max",

   151

            "GPRINT:avg:%6.2lf %Sbps avg",

   152

            "GPRINT:min:%6.2lf %Sbps min\\l",

   153

   154

            # dimensions

   155

            width               = 600,

   156

            height              = 50,

   157

        )

   158

   159

    def style_detail (graph) :

   160

        """

   161

            in/out bps -> detail graph

   162

        """

   163

   164

        return graph(

   165

            # values

   166

            'VDEF:in_max=in,MAXIMUM',

   167

            'VDEF:in_avg=in,AVERAGE',

   168

            'VDEF:in_min=in,MINIMUM',

   169

            'VDEF:in_cur=in,LAST',

   170

            'VDEF:out_max=out,MAXIMUM',

   171

            'VDEF:out_avg=out,AVERAGE',

   172

            'VDEF:out_min=out,MINIMUM',

   173

            'VDEF:out_cur=out,LAST',

   174

   175

            # legend/graph

   176

            "COMMENT:%4s" % "",

   177

            "COMMENT:%11s" % "Maximum",

   178

            "COMMENT:%11s" % "Average",

   179

            "COMMENT:%11s" % "Minimum",

   180

            "COMMENT:%11s\\l" % "Current",

   181

   182

            "LINE1:in#0000FF:%4s" % "In",

   183

            'GPRINT:in_max:%6.2lf %Sbps',

   184

            'GPRINT:in_avg:%6.2lf %Sbps',

   185

            'GPRINT:in_min:%6.2lf %Sbps',

   186

            'GPRINT:in_cur:%6.2lf %Sbps\\l',

   187

   188

            "LINE1:out#00CC00:%4s" % "Out",

   189

            'GPRINT:out_max:%6.2lf %Sbps',

   190

            'GPRINT:out_avg:%6.2lf %Sbps',

   191

            'GPRINT:out_min:%6.2lf %Sbps',

   192

            'GPRINT:out_cur:%6.2lf %Sbps\\l',

   193

   194

            # mark

   195

            "COMMENT:Generated {now}\\r".format(now=timestamp().replace(':', '\\:')),

   196

   197

            # dimensions

   198

            width               = 600,

   199

            height              = 200,

   200

        )

   201

   202

    STYLE = {

   203

        'overview': style_overview,

   204

        'detail':   style_detail,

   205

    }

   206

   207

    def style (self, style) :

   208

        return self.STYLE[style](self)

   209

   210

    ## interval

   211

    def interval_daily (graph) :

   212

        """

   213

            Common options for the 'daily' view

   214

        """

   215

   216

        return graph(

   217

            # labels

   218

            x_grid              = "MINUTE:15:HOUR:1:HOUR:4:0:%H:%M",

   219

   220

            # general info

   221

            title               = "Daily {graph[title]}".format(graph=graph),

   222

   223

            # interval

   224

            start               = "-24h",

   225

        )

   226

   227

    def interval_weekly (graph) :

   228

        return graph(

   229

            # labels

   230

            #        x_grid              = "MINUTE:15:HOUR:1:HOUR:4:0:%H:%M",

   231

   232

            # general info

   233

            title               = "Weekly {graph[title]}".format(graph=graph),

   234

   235

            # interval

   236

            start               = "-7d",

   237

        )

   238

   239

    def interval_yearly (graph) :

   240

        return graph(

   241

            # labels

   242

            #        x_grid              = "MINUTE:15:HOUR:1:HOUR:4:0:%H:%M",

   243

   244

            # general info

   245

            title               = "Yearly {graph[title]}".format(graph=graph),

   246

   247

            # interval

   248

            start               = "-1y",

   249

        )

   250

   251

    INTERVAL = {

   252

        'daily':    interval_daily,

   253

        'weekly':   interval_weekly,

   254

        'yearly':   interval_yearly,

   255

    }

   256

   257

    def interval (self, interval) :

   258

        return self.INTERVAL[interval](self)

   259

   260

# specific types

   261

class Mrtg (Interface) :

   262

    """

   263

        MRTG -> in/out

   264

    """

   265

   266

    IN = 'ds0'

   267

    OUT = 'ds1'

   268

   269

class CollectdIfOctets (Interface) :

   270

    """

   271

        Collectd if_octets -> in/out

   272

    """

   273

   274

    IN = 'rx'

   275

    OUT = 'tx'

   276

   277

INTERFACE = {

   278

    'mrtg':         Mrtg,

   279

    'collectd':     CollectdIfOctets,

   280

}

   281

   282

def interface_type (type) :

   283

    """

   284

        Lookup Interface -subclass for given type.

   285

    """

   286

   287

    return INTERFACE[type]

   288

   289

# XXX: legacy

   290

def mrtg (style, interval, title, rrd, out) :

   291

    return MrtgInterface.build(title, rrd, style, interval).graph(out)

   292

   293

def collectd_ifoctets (style, interval, title, rrd, out) :

   294

    return CollectdIfOctets.build(title, rrd, style, interval).graph(out)

   295

   296

if __name__ == '__main__':

   297

    import doctest

   298

    doctest.testmod()

   299