7

    RRDTool graph builders.

     8

     9

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

    15

class Graph (object) :

    17

        Render an RRD graph from definitions/options.

    19

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

    21

        >>> Graph()

    22

        Graph()

    23

        >>> Graph('foo')

    24

        Graph('foo')

    25

        >>> Graph(bar='bar')

    26

        Graph(bar='bar')

    27

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

    28

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

    29

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

    30

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

    33

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

    34

        self.defs = defs

    35

        self.opts = opts

    37

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

    38

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

    40

    def __getitem__ (self, key) :

    41

        return self.opts[key]

    43

    def graph (self, out) :

    44

        """

    45

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

    46

        """

    48

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

    49

    50

    def __repr__ (self) :

    51

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

    52

                type    = self.__class__.__name__,

    53

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

    54

        )

    55

    56

    # builders

    57

class Interface (Graph) :

    59

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

    62

    @classmethod

    63

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

    64

        """

    65

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

    67

                title       - common(title=...)

    68

                rrd         - data(rrd=...)

    69

                style       - style(style=...)

    70

                interval    - interval(interval=...)

    71

        """

    72

    73

        graph = cls()

    74

        graph = graph.common(title)

    75

        graph = graph.source(rrd)

    76

        graph = graph.style(style)

    77

        graph = graph.interval(interval)

    78

    79

        return graph

    80

    81

    # builders

    82

    def common (self, title) :

    83

        """

    84

            Common options for all views

    85

        """

    86

    87

        return self(

    88

            # output

    89

            imgformat           = "PNG",

    90

            #        lazy                = True,

    91

    92

            color               = [

    93

                # disable border

    94

                # border            = 0,

    95

                "SHADEA#ffffff00",

    96

                "SHADEB#ffffff00",

    97

    98

                # keep background transparent

    99

                "BACK#ffffff00",

   100

                "SHADEB#ffffff00",

   101

            ],

   102

   103

            # labels

   104

            vertical_label      = "bits/s",

   105

            title               = title,

   106

            units               = "si",

   107

   108

            # use logarithmic scaling?

   109

            #        logarithmic         = True,

   110

   111

            # smooth out lines

   112

            slope_mode          = True,

   113

        )

   115

    ## data

   116

    # DS names; in/out bytes

   117

    IN = OUT = None

   119

    def source (self, rrd) :

   120

        """

   121

            Abstract: rrd -> in/out

   122

        """

   123

   124

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

   125

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

   126

   127

        return self(

   128

            # data sources, bytes/s

   129

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

   130

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

   131

   132

            # data, bits/s

   133

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

   134

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

   135

        )

   137

    ## style

   138

    def style_overview (graph) :

   139

        """

   140

            in/out bps -> overview graph

   141

        """

   142

   143

        return graph(

   144

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

   145

   146

            "VDEF:max=all,MAXIMUM",

   147

            "VDEF:avg=all,AVERAGE",

   148

            "VDEF:min=all,MINIMUM",

   149

   150

            "LINE1:in#0000FF:In",

   151

            "LINE1:out#00CC00:Out",

   152

   153

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

   154

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

   155

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

   156

   157

            # dimensions

   158

            width               = 600,

   159

            height              = 50,

   160

        )

   161

   162

    def style_detail (graph) :

   163

        """

   164

            in/out bps -> detail graph

   165

        """

   166

   167

        return graph(

   168

            # values

   169

            'VDEF:in_max=in,MAXIMUM',

   170

            'VDEF:in_avg=in,AVERAGE',

   171

            'VDEF:in_min=in,MINIMUM',

   172

            'VDEF:in_cur=in,LAST',

   173

            'VDEF:out_max=out,MAXIMUM',

   174

            'VDEF:out_avg=out,AVERAGE',

   175

            'VDEF:out_min=out,MINIMUM',

   176

            'VDEF:out_cur=out,LAST',

   177

   178

            # legend/graph

   179

            "COMMENT:%4s" % "",

   180

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

   181

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

   182

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

   183

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

   184

   185

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

   186

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

   187

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

   188

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

   189

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

   190

   191

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

   192

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

   193

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

   194

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

   195

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

   196

   197

            # mark

   198

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

   199

   200

            # dimensions

   201

            width               = 600,

   202

            height              = 200,

   203

        )

   204

   205

    STYLE = {

   206

        'overview': style_overview,

   207

        'detail':   style_detail,

   208

    }

   209

   210

    def style (self, style) :

   211

        return self.STYLE[style](self)

   213

    ## interval

   214

    def interval_daily (graph) :

   215

        """

   216

            Common options for the 'daily' view

   217

        """

   219

        return graph(

   220

            # labels

   221

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

   222

   223

            # general info

   224

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

   225

   226

            # interval

   227

            start               = "-24h",

   228

        )

   230

    def interval_weekly (graph) :

   231

        return graph(

   232

            # labels

   233

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

   234

   235

            # general info

   236

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

   237

   238

            # interval

   239

            start               = "-7d",

   240

        )

   241

   242

    def interval_yearly (graph) :

   243

        return graph(

   244

            # labels

   245

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

   246

   247

            # general info

   248

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

   249

   250

            # interval

   251

            start               = "-1y",

   252

        )

   253

   254

    INTERVAL = {

   255

        'daily':    interval_daily,

   256

        'weekly':   interval_weekly,

   257

        'yearly':   interval_yearly,

   258

    }

   259

   260

    def interval (self, interval) :

   261

        return self.INTERVAL[interval](self)

   262

   263

# specific types

   264

class Mrtg (Interface) :

   265

    """

   266

        MRTG -> in/out

   267

    """

   268

   269

    IN = 'ds0'

   270

    OUT = 'ds1'

   271

   272

class CollectdIfOctets (Interface) :

   273

    """

   274

        Collectd if_octets -> in/out

   275

    """

   276

   277

    IN = 'rx'

   278

    OUT = 'tx'

   279

   280

INTERFACE = {

   281

    'mrtg':         Mrtg,

   282

    'collectd':     CollectdIfOctets,

   285

def interface (type) :

   287

        Lookup Interface -subclass for given type.

   290

    return INTERFACE[type]

   292

# XXX: legacy

   293

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

   294

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

   296

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

   297

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

   299

if __name__ == '__main__':

   300

    import doctest

   301

    doctest.testmod()