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

    # builders

    59

class Interface (Graph) :

    60

    """

    61

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

    62

    """

    63

    64

    @classmethod

    65

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

    66

        """

    67

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

    68

    69

                title       - common(title=...)

    70

                rrd         - data(rrd=...)

    71

                style       - style(style=...)

    72

                interval    - interval(interval=...)

    73

        """

    74

    75

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

    76

    77

    # builders

    78

    def common (self, title) :

    79

        """

    80

            Common options for all views

    81

        """

    82

    83

        return self(

    84

            # output

    85

            imgformat           = "PNG",

    86

            #        lazy                = True,

    87

    88

            color               = [

    89

                # disable border

    90

                # border            = 0,

    91

                "SHADEA#ffffff00",

    92

                "SHADEB#ffffff00",

    93

    94

                # keep background transparent

    95

                "BACK#ffffff00",

    96

                "SHADEB#ffffff00",

    97

            ],

    98

    99

            # labels

   100

            vertical_label      = "bits/s",

   101

            title               = title,

   102

            units               = "si",

   103

   104

            # use logarithmic scaling?

   105

            #        logarithmic         = True,

   106

   107

            # smooth out lines

   108

            slope_mode          = True,

   109

        )

   110

   111

    ## data

   112

    # DS names; in/out bytes

   113

    IN = OUT = None

   114

   115

    def source (self, rrd) :

   116

        """

   117

            Abstract: rrd -> in/out

   118

        """

   119

   120

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

   121

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

   122

   123

        log.debug("%s", rrd)

   124

   125

        return self(

   126

            # data sources, bytes/s

   127

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

   128

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

   129

   130

            # data, bits/s

   131

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

   132

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

   133

        )

   134

   135

    ## style

   136

    def style_overview (graph) :

   137

        """

   138

            in/out bps -> overview graph

   139

        """

   140

   141

        return graph(

   142

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

   143

   144

            "VDEF:max=all,MAXIMUM",

   145

            "VDEF:avg=all,AVERAGE",

   146

            "VDEF:min=all,MINIMUM",

   147

   148

            "LINE1:in#0000FF:In",

   149

            "LINE1:out#00CC00:Out",

   150

   151

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

   152

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

   153

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

   154

   155

            # dimensions

   156

            width               = 600,

   157

            height              = 50,

   158

        )

   159

   160

    def style_detail (graph) :

   161

        """

   162

            in/out bps -> detail graph

   163

        """

   164

   165

        return graph(

   166

            # values

   167

            'VDEF:in_max=in,MAXIMUM',

   168

            'VDEF:in_avg=in,AVERAGE',

   169

            'VDEF:in_min=in,MINIMUM',

   170

            'VDEF:in_cur=in,LAST',

   171

            'VDEF:out_max=out,MAXIMUM',

   172

            'VDEF:out_avg=out,AVERAGE',

   173

            'VDEF:out_min=out,MINIMUM',

   174

            'VDEF:out_cur=out,LAST',

   175

   176

            # legend/graph

   177

            "COMMENT:%4s" % "",

   178

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

   179

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

   180

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

   181

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

   182

   183

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

   184

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

   185

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

   186

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

   187

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

   188

   189

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

   190

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

   191

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

   192

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

   193

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

   194

   195

            # mark

   196

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

   197

   198

            # dimensions

   199

            width               = 600,

   200

            height              = 200,

   201

        )

   202

   203

    STYLE = {

   204

        'overview': style_overview,

   205

        'detail':   style_detail,

   206

    }

   207

   208

    def style (self, style) :

   209

        return self.STYLE[style](self)

   210

   211

    ## interval

   212

    def interval_daily (graph) :

   213

        """

   214

            Common options for the 'daily' view

   215

        """

   216

   217

        return graph(

   218

            # labels

   219

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

   220

   221

            # general info

   222

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

   223

   224

            # interval

   225

            start               = "-24h",

   226

        )

   227

   228

    def interval_weekly (graph) :

   229

        return graph(

   230

            # labels

   231

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

   232

   233

            # general info

   234

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

   235

   236

            # interval

   237

            start               = "-7d",

   238

        )

   239

   240

    def interval_yearly (graph) :

   241

        return graph(

   242

            # labels

   243

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

   244

   245

            # general info

   246

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

   247

   248

            # interval

   249

            start               = "-1y",

   250

        )

   251

   252

    INTERVAL = {

   253

        'daily':    interval_daily,

   254

        'weekly':   interval_weekly,

   255

        'yearly':   interval_yearly,

   256

    }

   257

   258

    def interval (self, interval) :

   259

        return self.INTERVAL[interval](self)

   260

   261

# specific types

   262

class Mrtg (Interface) :

   263

    """

   264

        MRTG -> in/out

   265

    """

   266

   267

    IN = 'ds0'

   268

    OUT = 'ds1'

   269

   270

class CollectdIfOctets (Interface) :

   271

    """

   272

        Collectd if_octets -> in/out

   273

    """

   274

   275

    IN = 'rx'

   276

    OUT = 'tx'

   277

   278

INTERFACE = {

   279

    'mrtg':         Mrtg,

   280

    'collectd':     CollectdIfOctets,

   281

}

   282

   283

def interface_type (type) :

   284

    """

   285

        Lookup Interface -subclass for given type.

   286

    """

   287

   288

    return INTERFACE[type]

   289

   290

# XXX: legacy

   291

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

   292

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

   293

   294

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

   295

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

   296

   297

if __name__ == '__main__':

   298

    import doctest

   299

    doctest.testmod()

   300