root@noc:/opt/noc/pm/apps/render # diff -y data.py /root/data.py
# -*- coding: utf-8 -*-                                         # -*- coding: utf-8 -*-
# #----------------------------------------------------------   # #----------------------------------------------------------
## Carbon-compatible data hooks                                 ## Carbon-compatible data hooks
##-----------------------------------------------------------   ##-----------------------------------------------------------
## Copyright (C) 2007-2014 The NOC Project                      ## Copyright (C) 2007-2014 The NOC Project
## See LICENSE for details                                      ## See LICENSE for details
##-----------------------------------------------------------   ##-----------------------------------------------------------

## Python modules                                               ## Python modules
import time                                                     import time
import calendar                                               <
## Third-party modules                                        <
import pytz                                                   <
## NOC modules                                                  ## NOC modules
from noc.pm.db.base import tsdb                                 from noc.pm.db.base import tsdb


class TimeSeries(list):                                         class TimeSeries(list):
    def __init__(self, name, start, end, step, values, consol |     def __init__(self, name, start, end, step, values,
                                                              >                  consolidate="average"):
        list.__init__(self, values)                                     list.__init__(self, values)
        self.name = name                                                self.name = name
        self.start = start                                              self.start = start
        self.end = end                                                  self.end = end
        self.step = step                                                self.step = step
        self.consolidationFunc = consolidate                            self.consolidationFunc = consolidate
        self.valuesPerPoint = 1                                         self.valuesPerPoint = 1
        self.options = {}                                               self.options = {}

    def __iter__(self):                                             def __iter__(self):
        if self.valuesPerPoint > 1:                                     if self.valuesPerPoint > 1:
            return self.__consolidatingGenerator(list.__iter_               return self.__consolidatingGenerator(list.__iter_
        else:                                                           else:
            return list.__iter__(self)                                      return list.__iter__(self)

    def consolidate(self, valuesPerPoint):                          def consolidate(self, valuesPerPoint):
        self.valuesPerPoint = int(valuesPerPoint)                       self.valuesPerPoint = int(valuesPerPoint)

    def __consolidatingGenerator(self, gen):                        def __consolidatingGenerator(self, gen):
        buf = []                                                        buf = []
        for x in gen:                                                   for x in gen:
            buf.append(x)                                                   buf.append(x)
            if len(buf) == self.valuesPerPoint:                             if len(buf) == self.valuesPerPoint:
                while None in buf:                                              while None in buf:
                    buf.remove(None)                                                buf.remove(None)
                if buf:                                                         if buf:
                    yield self.__consolidate(buf)                                   yield self.__consolidate(buf)
                    buf = []                                                        buf = []
                else:                                                           else:
                    yield None                                                      yield None
        while None in buf:                                              while None in buf:
            buf.remove(None)                                                buf.remove(None)
        if buf:                                                         if buf:
            yield self.__consolidate(buf)                                   yield self.__consolidate(buf)
        else:                                                           else:
            yield None                                                      yield None
        raise StopIteration                                             raise StopIteration

    def __consolidate(self, values):                                def __consolidate(self, values):
        usable = [v for v in values if v is not None]                   usable = [v for v in values if v is not None]
        if not usable:                                                  if not usable:
            return None                                                     return None
        if self.consolidationFunc == 'sum':                   |         if self.consolidationFunc == "sum":
            return sum(usable)                                              return sum(usable)
        if self.consolidationFunc == 'average':               |         if self.consolidationFunc == "average":
            return float(sum(usable)) / len(usable)                         return float(sum(usable)) / len(usable)
        if self.consolidationFunc == 'max':                   |         if self.consolidationFunc == "max":
            return max(usable)                                              return max(usable)
        if self.consolidationFunc == 'min':                   |         if self.consolidationFunc == "min":
            return min(usable)                                              return min(usable)
        raise Exception("Invalid consolidation function!")              raise Exception("Invalid consolidation function!")

    def __repr__(self):                                             def __repr__(self):
        return 'TimeSeries(name=%s, start=%s, end=%s, step=%s |         return "TimeSeries(name=%s, start=%s, end=%s, step=%s
            self.name, self.start, self.end, self.step)       |         self.name, self.start, self.end, self.step)

                                                              |     def getInfo(self):
def epoch(dt):                                                |         """Pickle-friendly representation of the series"""
    """                                                       |         return {
    Returns the epoch timestamp of a timezone-aware datetime  |             "name": self.name,
    """                                                       |             "start": self.start,
    return calendar.timegm(dt.astimezone(pytz.utc).timetuple( |             "end": self.end,
                                                              >             "step": self.step,
                                                              >             "values": list(self),
                                                              >         }


                                                              > # Graphite data retrieval API
def fetchData(ctx, path):                                       def fetchData(ctx, path):
    """                                                       <
    Graphite-compatible data-retrieval API                    <
    """                                                       <
    series = []                                                     series = []
    start = int(epoch(ctx["startTime"]))                      |     start = int(time.mktime(ctx["startTime"].timetuple()))
    end = int(epoch(ctx["endTime"]))                          |     end = int(time.mktime(ctx["endTime"].timetuple()))
    step = 1                                                        step = 1
    for metric in tsdb.find(path):                                  for metric in tsdb.find(path):
        values = tsdb.fetch(metric, start, end)                         values = tsdb.fetch(metric, start, end)
        ts = TimeSeries(metric, start, end, step, values)               ts = TimeSeries(metric, start, end, step, values)
        ts.pathExpression = metric                                      ts.pathExpression = metric
        series += [ts]                                                  series += [ts]
    return series                                                   return series
root@noc:/opt/noc/pm/apps/render #