def get_intervals(self):
if self.cheat_times:
logger.debug(caller='get_intervals', msg="cheat_times enabled. this is gonna be quick..", debug_key=self.path)
now = int(time.time())
return IntervalSet([Interval(1, now)])
key_first = "%s_first" % self.path
first = self.cache.get(key_first)
if first is None:
logger.debug(caller='get_intervals', cache_miss=key_first, debug_key=self.path)
q = 'select * from "%s" limit 1 order asc' % self.path
with statsd.timer('service=graphite-api.ext_service=influxdb.target_type=gauge.unit=ms.what=query_individual_first_point_duration'):
first_data = self.client.query(q)
first = 0
valid_res = False
try:
first = first_data[0]['points'][0][0]
valid_res = True
except Exception:
pass
if valid_res:
logger.debug(caller='get_intervals', cache_add=key_first, debug_key=self.path)
self.cache.add(key_first, first, timeout=self.step * 1000)
else:
logger.debug(caller='get_intervals', cache_hit=key_first, debug_key=self.path)
key_last = "%s_last" % self.path
last = self.cache.get(key_last)
if last is None:
logger.debug(caller='get_intervals', cache_miss=key_last, debug_key=self.path)
q = 'select * from "%s" limit 1' % self.path
with statsd.timer('service=graphite-api.ext_service=influxdb.target_type=gauge.unit=ms.what=query_individual_last_point_duration'):
last_data = self.client.query(q)
last = 0
valid_res = False
try:
last = last_data[0]['points'][0][0]
valid_res = True
except Exception:
pass
if valid_res:
logger.debug(caller='get_intervals', cache_add=key_last, debug_key=self.path)
self.cache.add(key_last, last, timeout=self.step)
else:
logger.debug(caller='get_intervals', cache_hit=key_last, debug_key=self.path)
return IntervalSet([Interval(first, last)])
def _yield_intervals(self):
rrd_info = rrdtool.info(self.path)
step = rrd_info['step']
last_update = rrd_info['last_update']
for rra in _yield_rras(rrd_info):
if rra['cf'] != self.cf:
continue
yield Interval(last_update - (step * rra['steps']), last_update)
def test_interval_set(self):
i = Interval(0, 1)
j = Interval(1, 2)
s = IntervalSet([i, j])
self.assertEqual(repr(s), '[<Interval: (0, 2)>]')
s = IntervalSet([i, j], disjoint=True)
it = iter(s)
self.assertEqual(next(it), i)
self.assertEqual(next(it), j)
self.assertTrue(s)
self.assertFalse(IntervalSet([]))
self.assertEqual(s - IntervalSet([i]), IntervalSet([j]))
self.assertFalse(IntervalSet([]).intersect(s))
self.assertEqual(s.union(IntervalSet([Interval(3, 4)])),
IntervalSet([Interval(3, 4), i, j]))
def get_intervals(self):
last_data = self.client.query("select * from %s limit 1" % self.path)
first_data = self.client.query("select * from %s limit 1 order asc" %
self.path)
last = 0
first = 0
try:
last = last_data[0]['points'][0][0]
first = first_data[0]['points'][0][0]
except Exception:
pass
return IntervalSet([Interval(first, last)])
def get_intervals(self):
return IntervalSet([Interval(time.time() - 3600, time.time())])
def test_interval(self):
with self.assertRaises(ValueError):
Interval(1, 0)
i = Interval(0, 1)
j = Interval(1, 2)
k = Interval(0, 1)
l = Interval(0, 0)
self.assertNotEqual(i, j)
self.assertEqual(i, k)
self.assertEqual(hash(i), hash(k))
with self.assertRaises(TypeError):
len(i)
self.assertTrue(j > i)
self.assertTrue(i)
self.assertFalse(l)
self.assertEqual(repr(i), '<Interval: (0, 1)>')
self.assertIsNone(i.intersect(j))
self.assertEqual(i.intersect(k), k)
self.assertTrue(i.overlaps(j))
self.assertEqual(i.union(j), Interval(0, 2))
with self.assertRaises(TypeError):
j.union(l)
self.assertEqual(union_overlapping([i, j, k, l]),
[Interval(0, 2)])
def get_intervals(self):
return IntervalSet([Interval(0, int(time.time()))])
def get_intervals(self):
# FIXME: mineshaft server should allow for obtaining this data
start = time.time() - 3600 * 2
end = max(start, time.time())
return IntervalSet([Interval(start, end)])
def get_intervals(self):
now = int(time.time())
return IntervalSet([Interval(1, now)])
def get_intervals(self):
# todo: make this a lot smarter.
intervals = []
millis = int(round(time.time() * 1000))
intervals.append(Interval(0, millis))
return IntervalSet(intervals)
def get_intervals(self):
with open(self.fs_path) as f:
start = time.time() - kenshin.header(f)['max_retention']
end = max(os.stat(self.fs_path).st_mtime, start)
return IntervalSet([Interval(start, end)])
def get_intervals(self):
start = float('-inf')
end = float('inf')
logger.debug("get_intervals", finder="newts", start=start, end=end)
return IntervalSet([Interval(start, end)])
def get_intervals(self):
# TODO: can we return real data?
return IntervalSet([Interval(0, int(time.time()))])
def get_intervals(self):
# TODO use cyanite info
return IntervalSet([Interval(0, int(time.time()))])
