def findSeries(request):
if request.method not in ['GET', 'POST']:
return HttpResponse(status=405)
queryParams = request.GET.copy()
queryParams.update(request.POST)
exprs = []
# Normal format: ?expr=tag1=value1&expr=tag2=value2
if len(queryParams.getlist('expr')) > 0:
exprs = queryParams.getlist('expr')
# Rails/PHP/jQuery common practice format: ?expr[]=tag1=value1&expr[]=tag2=value2
elif len(queryParams.getlist('expr[]')) > 0:
exprs = queryParams.getlist('expr[]')
if not exprs:
return HttpResponse(json.dumps(
{'error': 'no tag expressions specified'}),
content_type='application/json',
status=400)
return HttpResponse(json.dumps(
STORE.tagdb.find_series(
exprs,
requestContext=_requestContext(request),
) if STORE.tagdb else [],
indent=(2 if queryParams.get('pretty') else None),
sort_keys=bool(queryParams.get('pretty'))),
content_type='application/json')
def post_event(request):
if request.method == 'POST':
event = json.loads(request.body)
assert isinstance(event, dict)
tags = event.get('tags')
if tags is not None:
if isinstance(tags, list):
tags = ' '.join(tags)
elif not isinstance(tags, basestring):
return HttpResponse(json.dumps({
'error':
'"tags" must be an array or space-separated string'
}),
status=400)
else:
tags = None
if 'when' in event:
when = epoch_to_dt(event['when'])
else:
when = now()
Event.objects.create(
what=event.get('what'),
tags=tags,
when=when,
data=event.get('data', ''),
)
return HttpResponse(status=200)
else:
return HttpResponse(status=405)
def tagList(request):
if request.method != 'GET':
return HttpResponse(status=405)
return HttpResponse(
json.dumps(STORE.tagdb.list_tags() if STORE.tagdb else []),
content_type='application/json')
def post_event(request):
if request.method == 'POST':
event = json.loads(request.body)
assert isinstance(event, dict)
tags = event.get('tags')
if tags:
if not isinstance(tags, list):
return HttpResponse(json.dumps(
{'error': '"tags" must be an array'}),
status=400)
tags = ' '.join(tags)
if 'when' in event:
when = make_aware(
datetime.datetime.utcfromtimestamp(event.get('when')),
pytz.utc)
else:
when = now()
Event.objects.create(
what=event.get('what'),
tags=tags,
when=when,
data=event.get('data', ''),
)
return HttpResponse(status=200)
else:
return HttpResponse(status=405)
def tagDetails(request, tag):
if request.method != 'GET':
return HttpResponse(status=405)
return HttpResponse(
json.dumps(STORE.tagdb.get_tag(tag) if STORE.tagdb else None),
content_type='application/json')
def renderViewDygraph(requestOptions, data):
labels = ['Time']
output = '{}'
if data:
datapoints = [[ts]
for ts in range(data[0].start, data[0].end, data[0].step)
]
for series in data:
labels.append(series.name)
for i, point in enumerate(series):
if point is None:
point = 'null'
elif point == float('inf'):
point = 'Infinity'
elif point == float('-inf'):
point = '-Infinity'
elif math.isnan(point):
point = 'null'
datapoints[i].append(point)
line_template = '[%%s000%s]' % ''.join([', %s'] * len(data))
lines = [line_template % tuple(points) for points in datapoints]
output = '{"labels" : %s, "data" : [%s]}' % (json.dumps(labels),
', '.join(lines))
if 'jsonp' in requestOptions:
response = HttpResponse(content="%s(%s)" %
(requestOptions['jsonp'], output),
content_type='text/javascript')
else:
response = HttpResponse(content=output,
content_type='application/json')
return response
def search(request):
query = request.POST.get('query')
if not query:
return HttpResponse("")
patterns = query.split()
regexes = [re.compile(p, re.I) for p in patterns]
def matches(s):
for regex in regexes:
if regex.search(s):
return True
return False
results = []
index_file = open(settings.INDEX_FILE)
for line in index_file:
if matches(line):
results.append(line.strip())
if len(results) >= 100:
break
index_file.close()
result_string = ','.join(results)
return HttpResponse(result_string, content_type='text/plain')
def autoCompleteValues(request):
if request.method not in ['GET', 'POST']:
return HttpResponse(status=405)
queryParams = request.GET.copy()
queryParams.update(request.POST)
exprs = []
# Normal format: ?expr=tag1=value1&expr=tag2=value2
if len(queryParams.getlist('expr')) > 0:
exprs = queryParams.getlist('expr')
# Rails/PHP/jQuery common practice format: ?expr[]=tag1=value1&expr[]=tag2=value2
elif len(queryParams.getlist('expr[]')) > 0:
exprs = queryParams.getlist('expr[]')
tag = queryParams.get('tag')
if not tag:
return HttpResponse(json.dumps({'error': 'no tag specified'}),
content_type='application/json',
status=400)
valuePrefix = queryParams.get('valuePrefix')
result = STORE.tagdb.auto_complete_values(
exprs,
tag,
valuePrefix,
limit=queryParams.get('limit'),
requestContext=_requestContext(request))
return HttpResponse(json.dumps(
result,
indent=(2 if queryParams.get('pretty') else None),
sort_keys=bool(queryParams.get('pretty'))),
content_type='application/json')
def renderViewJson(requestOptions, data):
series_data = []
if any(data):
startTime = min([series.start for series in data])
endTime = max([series.end for series in data])
timeRange = endTime - startTime
for series in data:
if 'maxDataPoints' in requestOptions:
maxDataPoints = requestOptions['maxDataPoints']
if maxDataPoints == 1:
series.consolidate(len(series))
else:
numberOfDataPoints = len(series)
if maxDataPoints < numberOfDataPoints:
valuesPerPoint = math.ceil(
float(numberOfDataPoints) / float(maxDataPoints))
secondsPerPoint = int(valuesPerPoint * series.step)
# Nudge start over a little bit so that the consolidation bands align with each call
# removing 'jitter' seen when refreshing.
nudge = secondsPerPoint + (
series.start % series.step) - (series.start %
secondsPerPoint)
series.start = series.start + nudge
valuesToLose = int(nudge / series.step)
for r in range(1, valuesToLose):
del series[0]
series.consolidate(valuesPerPoint)
datapoints = series.datapoints()
if 'noNullPoints' in requestOptions:
datapoints = [
point for point in datapoints
if point[0] is not None and not math.isnan(point[0])
]
if not datapoints:
continue
series_data.append(
dict(target=series.name,
tags=series.tags,
datapoints=datapoints))
output = json.dumps(
series_data,
indent=(2 if requestOptions.get('pretty') else None)).replace(
'None,', 'null,').replace('NaN,',
'null,').replace('Infinity,', '1e9999,')
if 'jsonp' in requestOptions:
response = HttpResponse(content="%s(%s)" %
(requestOptions['jsonp'], output),
content_type='text/javascript')
else:
response = HttpResponse(content=output,
content_type='application/json')
return response
def get_data(request):
if 'jsonp' in request.REQUEST:
response = HttpResponse("%s(%s)" %
(request.REQUEST.get('jsonp'),
json.dumps(fetch(request), cls=EventEncoder)),
content_type='text/javascript')
else:
response = HttpResponse(json.dumps(fetch(request), cls=EventEncoder),
content_type="application/json")
return response
def tagDetails(request, tag):
if request.method != 'GET':
return HttpResponse(status=405)
return HttpResponse(json.dumps(
STORE.tagdb.get_tag(tag, valueFilter=request.GET.get('filter'))
if STORE.tagdb else None,
indent=(2 if request.GET.get('pretty') else None),
sort_keys=bool(request.GET.get('pretty'))),
content_type='application/json')
def tagList(request):
if request.method != 'GET':
return HttpResponse(status=405)
return HttpResponse(json.dumps(
STORE.tagdb.list_tags(
tagFilter=request.GET.get('filter')) if STORE.tagdb else [],
indent=(2 if request.GET.get('pretty') else None),
sort_keys=bool(request.GET.get('pretty'))),
content_type='application/json')
def evaluate(request):
if 'commandInput' not in request.GET:
output = commands.stderr("No commandInput parameter!")
return HttpResponse(output, content_type='text/plain')
#Variable substitution
profile = getProfile(request)
my_vars = {}
for variable in profile.variable_set.all():
my_vars[variable.name] = variable.value
cmd = request.GET['commandInput']
while '$' in cmd and not cmd.startswith('code'):
i = cmd.find('$')
j = i+1
for char in cmd[i+1:]:
if char not in letters: break
j += 1
var = cmd[i+1:j]
if var in my_vars:
cmd = cmd[:i] + my_vars[var] + cmd[j:]
else:
output = commands.stderr("Unknown variable %s" % var)
return HttpResponse(output, content_type='text/plain')
if cmd == '?': cmd = 'help'
try:
tokens = parser.parseInput(cmd)
if not tokens.command:
output = commands.stderr("Invalid syntax")
return HttpResponse(output, content_type='text/plain')
handler_name = '_' + tokens.command
handler = vars(commands).get(handler_name)
if handler is None:
output = commands.stderr("Unknown command")
return HttpResponse(output, content_type='text/plain')
args = dict( tokens.items() )
del args['command']
output = handler(request, **args)
except:
output = commands.printException()
#Save command to history
history = profile.history.split('\n')
history.insert(0,cmd)
while len(history) > 30: history.pop()
profile.history = '\n'.join(history)
profile.save()
return HttpResponse(output, content_type='text/plain')
def tagSeries(request):
if request.method != 'POST':
return HttpResponse(status=405)
path = request.POST.get('path')
if not path:
return HttpResponse(json.dumps({'error': 'no path specified'}),
status=400)
return HttpResponse(
json.dumps(STORE.tagdb.tag_series(path)) if STORE.tagdb else 'null',
content_type='application/json')
def get_data(request):
query_params = request.GET.copy()
query_params.update(request.POST)
if 'jsonp' in query_params:
response = HttpResponse("%s(%s)" %
(query_params.get('jsonp'),
json.dumps(fetch(request), cls=EventEncoder)),
content_type='text/javascript')
else:
response = HttpResponse(json.dumps(fetch(request), cls=EventEncoder),
content_type='application/json')
return response
def json_response(nodes, request=None):
if request:
jsonp = request.REQUEST.get('jsonp', False)
else:
jsonp = False
json_data = json.dumps(nodes)
if jsonp:
response = HttpResponse("%s(%s)" % (jsonp, json_data),
content_type="text/javascript")
else:
response = HttpResponse(json_data, content_type="application/json")
response['Pragma'] = 'no-cache'
response['Cache-Control'] = 'no-cache'
return response
def json_response(nodes, request=None):
if request:
jsonp = request.GET.get('jsonp', False) or request.POST.get('jsonp', False)
else:
jsonp = False
#json = str(nodes) #poor man's json encoder for simple types
json_data = json.dumps(nodes)
if jsonp:
response = HttpResponse("%s(%s)" % (jsonp, json_data),
content_type="text/javascript")
else:
response = HttpResponse(json_data, content_type="application/json")
response['Pragma'] = 'no-cache'
response['Cache-Control'] = 'no-cache'
return response
def full_path_zon_test(request):
# 0. Parse parameters
queryParams = request.GET.copy()
queryParams.update(request.POST)
# TODO: remove the default values, the default values are what we are using currently
port = queryParams.get('port', '31509')
metric_name = queryParams.get('metric', 'test.fullstack.graphite')
# 1. Send data to graphite
random_data = _send_random_data(metric_name)
# 2. Wait (allow some latency)
time.sleep(1)
# 3. Query graphite
try:
res = urlopen(
"http://localhost:{0}/render/?format=json&target={1}&from=-1min&noCache"
.format(port, metric_name))
s = res.read().decode('utf-8')
json_obj = json.loads(s)
except Exception:
raise
# 4. Check Result
result = ""
details = "Expected value: {0}".format(random_data)
if not json_obj:
result = "fail"
details = "graphite query response is empty"
else:
json_obj = json_obj[0]
if "target" not in json_obj:
result = "fail"
details = "target field is missing"
elif "datapoints" not in json_obj:
result = "fail"
details = "datapoints field is missing"
elif len(json_obj["datapoints"]) != 1:
result = "fail"
details = "the number of returned datapoints is inconsistent"
elif json_obj["datapoints"][0][0] is None:
result = "fail"
details = "datapoint is returned but its value is None"
else:
real_value = int(json_obj["datapoints"][0][0])
expected_value = random_data
if real_value == expected_value:
result = "pass"
else:
result = "fail"
details = "Expected value: {0}, Real Value: {1}".format(
expected_value, real_value)
# 5. Response
result_json_obj = {"result": result, "details": details}
response = HttpResponse(content=json.dumps(result_json_obj),
content_type='application/json')
return response
def cache_metric(request):
queryParams = request.GET.copy()
metric = queryParams.get('metric', 'yun.test')
datapoints = CarbonLink.query(metric)
result_json_obj = {"target": metric, "datapoints": datapoints}
response = HttpResponse(content=json.dumps(result_json_obj),
content_type='application/json')
return response
def save_event(request):
if request.method == 'POST' || request.method == 'PUT':
event = json.loads(request.body)
assert isinstance(event, dict)
tags = event.get('tags')
if tags:
if not isinstance(tags, list):
return HttpResponse(
json.dumps({'error': '"tags" must be an array'}),
status=400)
tags = ' '.join(tags)
if 'when' in event:
when = make_aware(
datetime.datetime.utcfromtimestamp(
event.get('when')), pytz.utc)
else:
when = now()
if request.method == 'POST':
Event.objects.create(
what=event.get('what'),
tags=tags,
when=when,
data=event.get('data', ''),
)
elif request.method == 'PUT':
event_id = event.get('id')
try:
e = Event.objects.get(id=event_id)
e.what = event.get('what')
e.tags = tags
e.when = when
e.data = event.get('data', '')
e.save()
except ObjectDoesNotExist:
error = {'error': 'Event matching query does not exist'}
response = JsonResponse(error, status=404)
return response
else
return HttpResponse(status=405)
return HttpResponse(status=200)
else:
return HttpResponse(status=405)
def tagList(request, queryParams):
if request.method != 'GET':
return HttpResponse(status=405)
return STORE.tagdb.list_tags(
tagFilter=request.GET.get('filter'),
limit=request.GET.get('limit'),
requestContext=_requestContext(request),
)
def renderViewRaw(requestOptions, data):
response = HttpResponse(content_type='text/plain')
for series in data:
response.write( "%s,%d,%d,%d|" % (series.name, series.start, series.end, series.step) )
response.write( ','.join(map(repr,series)) )
response.write('\n')
return response
def post_event(request):
if request.method == 'POST':
event = json.loads(request.body)
assert isinstance(event, dict)
values = {}
values["what"] = event["what"]
values["tags"] = event.get("tags", None)
values["when"] = datetime.datetime.fromtimestamp(
event.get("when", time.time()))
if "data" in event:
values["data"] = event["data"]
e = models.Event(**values)
e.save()
return HttpResponse(status=200)
else:
return HttpResponse(status=405)
def renderViewCsv(requestOptions, data):
response = HttpResponse(content_type='text/csv')
writer = csv.writer(response, dialect='excel')
for series in data:
for i, value in enumerate(series):
timestamp = datetime.fromtimestamp(series.start + (i * series.step), requestOptions['tzinfo'])
writer.writerow((series.name, timestamp.strftime("%Y-%m-%d %H:%M:%S"), value))
return response
def post_event(request):
if request.method == 'POST':
event = json.loads(request.body)
assert isinstance(event, dict)
if 'when' in event:
when = make_aware(
datetime.datetime.utcfromtimestamp(event['when']), pytz.utc)
else:
when = now()
Event.objects.create(
what=event['what'],
tags=event.get("tags"),
when=when,
data=event.get("data", ""),
)
return HttpResponse(status=200)
else:
return HttpResponse(status=405)
def renderViewRickshaw(requestOptions, data):
series_data = []
for series in data:
timestamps = range(series.start, series.end, series.step)
datapoints = [{'x': x, 'y': y} for x, y in zip(timestamps, series)]
series_data.append(dict(target=series.name, datapoints=datapoints))
output = json.dumps(series_data,
indent=(2 if requestOptions.get('pretty') else None))
if 'jsonp' in requestOptions:
response = HttpResponse(content="%s(%s)" %
(requestOptions['jsonp'], output),
content_type='text/javascript')
else:
response = HttpResponse(content=output,
content_type='application/json')
return response
def tagSeries(request, queryParams):
if request.method != 'POST':
return HttpResponse(status=405)
path = queryParams.get('path')
if not path:
raise HttpError('no path specified', status=400)
return STORE.tagdb.tag_series(path,
requestContext=_requestContext(request))
def tagDetails(request, queryParams, tag):
if request.method != 'GET':
return HttpResponse(status=405)
return STORE.tagdb.get_tag(
tag,
valueFilter=queryParams.get('filter'),
limit=queryParams.get('limit'),
requestContext=_requestContext(request),
)
def autocomplete(request):
assert 'path' in request.GET, "Invalid request, no 'path' parameter!"
path = request.GET['path']
shortnames = bool( request.GET.get('short') )
if request.GET['path'][:1] == '!':
profile = getProfile(request)
html = completer.completeHistory(path, profile)
else:
html = completer.completePath(path, shortnames=shortnames)
return HttpResponse( html )
def delete_event(request):
if request.method == 'DELETE':
try:
data = json.loads(request.body)
assert isinstance(event_ids, dict)
event_ids = data.get('event_ids')
if not isinstance(event_ids, list)
return HttpResponse(
json.dumps({'error': '"event_ids" must be an array'}),
status=400)
for event_id in event_ids:
Event.objects.delete(id=event_id)
return HttpResponse(status=200)
except ObjectDoesNotExist:
error = {'error': 'Event matching query does not exist'}
response = JsonResponse(error, status=404)
return response
else:
return HttpResponse(status=405)
