def test_getProfileByUsername(self):
request = HttpRequest()
request.user = User.objects.create_user('testuser',
'*****@*****.**',
'testuserpassword')
util.getProfile(request, False)
self.assertEqual(str(util.getProfileByUsername('testuser')),
'Profile for testuser')
self.assertEqual(util.getProfileByUsername('nonexistentuser'), None)
def _views(request):
out = ''
profile = getProfile(request)
for view in profile.view_set.all():
windowList = ','.join([window.name for window in view.window_set.all()])
out += stdout("%s: %s" % (view.name,windowList))
return out
def _vars(request):
profile = getProfile(request)
out = '<font color="#77ddcc">'
for variable in profile.variable_set.all():
out += '%s = %s<br/>' % (variable.name,variable.value)
out += '</font>'
return stdout(out)
def header(request):
"View for the header frame of the browser UI"
context = {}
context['user'] = request.user
context['profile'] = getProfile(request)
context['documentation_url'] = settings.DOCUMENTATION_URL
return render_to_response("browserHeader.html", context)
def _vars(request):
profile = getProfile(request)
out = '<font color="#77ddcc">'
for variable in profile.variable_set.all():
out += '%s = %s<br/>' % (variable.name,variable.value)
out += '</font>'
return stdout(out)
def mygraph(request):
profile = getProfile(request,allowDefault=False)
if not profile: return HttpResponse( "You are not logged in!" )
graphName = request.GET['graphName']
if not graphName:
return HttpResponse("You must type in a graph name.")
action = request.GET['action']
url = request.GET['url']
if action == 'save':
try:
existingGraph = profile.mygraph_set.get(name=graphName)
existingGraph.url = url
existingGraph.save()
except ObjectDoesNotExist:
try:
newGraph = MyGraph(profile=profile,name=graphName,url=url)
newGraph.save()
except:
log.exception("Failed to create new MyGraph in /composer/mygraph/, graphName=%s" % graphName)
return HttpResponse("Failed to save graph %s" % graphName)
return HttpResponse("SAVED")
elif action == 'delete':
try:
existingGraph = profile.mygraph_set.get(name=graphName)
existingGraph.delete()
except ObjectDoesNotExist:
return HttpResponse("No such graph '%s'" % graphName)
return HttpResponse("DELETED")
else:
return HttpResponse("Invalid operation '%s'" % action)
def _dosave(request,viewName):
profile = getProfile(request)
#First find our View
log.info("Saving view '%s' under profile '%s'" % (viewName,profile.user.username))
try:
view = profile.view_set.get(name=viewName)
except ObjectDoesNotExist:
view = View(profile=profile,name=viewName)
view.save()
#Now re-associate the view with the correct Windows
view.window_set.all().delete()
for windowName,encodedString in request.GET.items():
try:
if windowName in ('_','commandInput'): continue
paramString = urllib.unquote_plus(encodedString)
queryParams = cgi.parse_qs(paramString)
modelParams = {}
for key,value in queryParams.items(): #Clean up the window params
key = str(key)
value = str(value[0])
if key in ('top','left'):
value = int(float( value.replace('px','') ))
if key in ('width','height','interval'):
value = int(float(value))
modelParams[key] = value
if 'interval' not in modelParams:
modelParams['interval'] = None
win = Window(view=view,name=windowName,**modelParams)
win.save()
except:
log.exception("Failed to process parameters for window '%s'" % windowName)
return stdout('Saved view %s' % viewName)
def getUserName(request):
profile = getProfile(request,allowDefault=False)
if profile:
return HttpResponse(profile.user.username)
return HttpResponse("");
def _dosave(request,viewName):
profile = getProfile(request)
#First find our View
log.info("Saving view '%s' under profile '%s'" % (viewName,profile.user.username))
try:
view = profile.view_set.get(name=viewName)
except ObjectDoesNotExist:
view = View(profile=profile,name=viewName)
view.save()
#Now re-associate the view with the correct Windows
view.window_set.all().delete()
for windowName,encodedString in request.GET.items():
try:
if windowName in ('_','commandInput'): continue
paramString = urllib.unquote_plus(encodedString)
queryParams = cgi.parse_qs(paramString)
modelParams = {}
for key,value in queryParams.items(): #Clean up the window params
key = str(key)
value = str(value[0])
if key in ('top','left'):
value = int(float( value.replace('px','') ))
if key in ('width','height','interval'):
value = int(float(value))
modelParams[key] = value
if 'interval' not in modelParams:
modelParams['interval'] = None
win = Window(view=view,name=windowName,**modelParams)
win.save()
except:
log.exception("Failed to process parameters for window '%s'" % windowName)
return stdout('Saved view %s' % viewName)
def updateProfile(request):
profile = getProfile(request, allowDefault=False)
if profile:
profile.advancedUI = request.POST.get('advancedUI', 'off') == 'on'
profile.save()
nextPage = request.POST.get('nextPage', '/')
return HttpResponseRedirect(nextPage)
def _views(request):
out = ''
profile = getProfile(request)
for view in profile.view_set.all():
windowList = ','.join([window.name for window in view.window_set.all()])
out += stdout("%s: %s" % (view.name,windowList))
return out
def header(request):
"View for the header frame of the browser UI"
context = {}
context['user'] = request.user
context['profile'] = getProfile(request)
context['documentation_url'] = settings.DOCUMENTATION_URL
return render_to_response("browserHeader.html", context)
def updateProfile(request):
profile = getProfile(request,allowDefault=False)
if profile:
profile.advancedUI = request.POST.get('advancedUI','off') == 'on'
profile.save()
nextPage = request.POST.get('nextPage','/')
return HttpResponseRedirect(nextPage)
def _rmgraph(request,graphName):
profile = getProfile(request,allowDefault=False)
try:
graph = profile.mygraph_set.get(name=graphName)
except ObjectDoesNotExist:
return stderr("No such graph %s" % graphName)
graph.delete()
return stdout("Deleted graph %s" % graphName)
def _rmview(request,viewName):
profile = getProfile(request)
try:
view = profile.view_set.get(name=viewName)
except ObjectDoesNotExist:
return stderr("No such view '%s'" % viewName)
view.delete()
return stdout("Deleted view %s" % viewName)
def _unset(request,name):
profile = getProfile(request)
try:
variable = profile.variable_set.get(name=name)
variable.delete()
except ObjectDoesNotExist:
return stderr("Unknown variable %s" % name)
return ''
def _unset(request,name):
profile = getProfile(request)
try:
variable = profile.variable_set.get(name=name)
variable.delete()
except ObjectDoesNotExist:
return stderr("Unknown variable %s" % name)
return ''
def header(request):
"View for the header frame of the browser UI"
context = {
'user': request.user,
'profile': getProfile(request),
'documentation_url': settings.DOCUMENTATION_URL,
}
return render_to_response("browserHeader.html", context)
def _rmview(request,viewName):
profile = getProfile(request)
try:
view = profile.view_set.get(name=viewName)
except ObjectDoesNotExist:
return stderr("No such view '%s'" % viewName)
view.delete()
return stdout("Deleted view %s" % viewName)
def _rmgraph(request,graphName):
profile = getProfile(request,allowDefault=False)
try:
graph = profile.mygraph_set.get(name=graphName)
except ObjectDoesNotExist:
return stderr("No such graph %s" % graphName)
graph.delete()
return stdout("Deleted graph %s" % graphName)
def header(request):
"View for the header frame of the browser UI"
context = {
'user' : request.user,
'profile' : getProfile(request),
'documentation_url' : settings.DOCUMENTATION_URL,
}
return render_to_response("browserHeader.html", context)
def _set(request,name,value):
profile = getProfile(request)
try:
variable = profile.variable_set.get(name=name)
variable.value = value
except ObjectDoesNotExist:
variable = Variable(profile=profile,name=name,value=value)
variable.save()
return ''
def header(request):
"View for the header frame of the browser UI"
context = {
"user": request.user,
"profile": getProfile(request),
"documentation_url": settings.DOCUMENTATION_URL,
"slash": get_script_prefix(),
}
return render_to_response("browserHeader.html", context)
def updateProfile(request):
profile = getProfile(request,allowDefault=False)
if profile:
profile.advancedUI = request.POST.get('advancedUI','off') == 'on'
default_template = request.POST.get('defaultTemplate','default')
profile.defaultTemplate = default_template.replace(" ","")
profile.save()
nextPage = request.POST.get('nextPage','/')
return HttpResponseRedirect(nextPage)
def updateProfile(request):
profile = getProfile(request, allowDefault=False)
if profile:
profile.advancedUI = request.POST.get('advancedUI', 'off') == 'on'
default_template = request.POST.get('defaultTemplate', 'default')
profile.defaultTemplate = default_template.replace(" ", "")
profile.save()
nextPage = request.POST.get('nextPage', '/')
return HttpResponseRedirect(nextPage)
def _set(request,name,value):
profile = getProfile(request)
try:
variable = profile.variable_set.get(name=name)
variable.value = value
except ObjectDoesNotExist:
variable = Variable(profile=profile,name=name,value=value)
variable.save()
return ''
def header(request):
"View for the header frame of the browser UI"
context = {}
context['user'] = request.user
context['profile'] = getProfile(request)
context['documentation_url'] = settings.DOCUMENTATION_URL
context['login_url'] = settings.LOGIN_URL
context['tenants'] = settings.TENANT_LIST
context['current_tenant'] = get_tenant(request)
return render_to_response("browserHeader.html", context)
def evaluate(request):
if 'commandInput' not in request.GET:
output = commands.stderr("No commandInput parameter!")
return HttpResponse(output, mimetype='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, mimetype='text/plain')
if cmd == '?': cmd = 'help'
try:
tokens = parser.parseInput(cmd)
if not tokens.command:
output = commands.stderr("Invalid syntax")
return HttpResponse(output, mimetype='text/plain')
handler_name = '_' + tokens.command
handler = vars(commands).get(handler_name)
if handler is None:
output = commands.stderr("Unknown command")
return HttpResponse(output, mimetype='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, mimetype='text/plain')
def find_view(request):
"View for finding metrics matching a given pattern"
profile = getProfile(request)
format = request.REQUEST.get('format', 'treejson')
local_only = int( request.REQUEST.get('local', 0) )
contexts = int( request.REQUEST.get('contexts', 0) )
wildcards = int( request.REQUEST.get('wildcards', 0) )
try:
query = str( request.REQUEST['query'] )
except:
return HttpResponseBadRequest(content="Missing required parameter 'query'", mimetype="text/plain")
if '.' in query:
base_path = query.rsplit('.', 1)[0] + '.'
else:
base_path = ''
if local_only:
store = LOCAL_STORE
else:
store = STORE
matches = list( store.find(query) )
log.info('find_view query=%s local_only=%s matches=%d' % (query, local_only, len(matches)))
matches.sort(key=lambda node: node.name)
if format == 'treejson':
content = tree_json(matches, base_path, wildcards=profile.advancedUI or wildcards, contexts=contexts)
response = HttpResponse(content, mimetype='text/json')
elif format == 'pickle':
content = pickle_nodes(matches, contexts=contexts)
response = HttpResponse(content, mimetype='application/pickle')
elif format == 'completer':
#if len(matches) == 1 and (not matches[0].isLeaf()) and query == matches[0].metric_path + '*': # auto-complete children
# matches = list( store.find(query + '.*') )
results = [ dict(path=node.metric_path, name=node.name) for node in matches ]
if len(results) > 1 and wildcards:
wildcardNode = {'name' : '*'}
results.append(wildcardNode)
content = json.dumps({ 'metrics' : results })
response = HttpResponse(content, mimetype='text/json')
else:
return HttpResponseBadRequest(content="Invalid value for 'format' parameter", mimetype="text/plain")
response['Pragma'] = 'no-cache'
response['Cache-Control'] = 'no-cache'
return response
def _gsave(request,graphName):
profile = getProfile(request,allowDefault=False)
if not profile: return stderr("You must be logged in to save graphs")
out = "img = $('%s_img');\n" % graphName
out += "if (!img) {\n"
out += " alert('No such window');\n"
out += "} else {\n"
out += " queryString = 'commandInput=dogsave%%20%s&url=' + escape(img.src);\n" % graphName
out += " savereq = new Ajax.Request('/cli/eval', {method: 'get', parameters: queryString, onException: handleException, onComplete: handleResponse});\n"
out += "}\n"
return out
def _gsave(request,graphName):
profile = getProfile(request,allowDefault=False)
if not profile: return stderr("You must be logged in to save graphs")
out = "img = $('%s_img');\n" % graphName
out += "if (!img) {\n"
out += " alert('No such window');\n"
out += "} else {\n"
out += " queryString = 'commandInput=dogsave%%20%s&url=' + escape(img.src);\n" % graphName
out += " savereq = new Ajax.Request('/cli/eval', {method: 'get', parameters: queryString, onException: handleException, onComplete: handleResponse});\n"
out += "}\n"
return out
def evaluate(request):
if 'commandInput' not in request.GET:
output = commands.stderr("No commandInput parameter!")
return HttpResponse(output, mimetype='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, mimetype='text/plain')
if cmd == '?': cmd = 'help'
try:
tokens = parser.parseInput(cmd)
if not tokens.command:
output = commands.stderr("Invalid syntax")
return HttpResponse(output, mimetype='text/plain')
handler_name = '_' + tokens.command
handler = vars(commands).get(handler_name)
if handler is None:
output = commands.stderr("Unknown command")
return HttpResponse(output, mimetype='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, mimetype='text/plain')
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 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 composer(request):
profile = getProfile(request)
context = RequestContext(request, {
'queryString' : request.GET.urlencode().replace('+','%20'),
'showTarget' : request.GET.get('showTarget',''),
'user' : request.user,
'profile' : profile,
'showMyGraphs' : int( profile.user.username != 'default' ),
'searchEnabled' : int( os.access(settings.INDEX_FILE, os.R_OK) ),
'debug' : settings.DEBUG,
'jsdebug' : settings.DEBUG,
})
return render_to_response("composer.html",context)
def composer(request):
profile = getProfile(request)
context = {
'queryString' : request.GET.urlencode(),
'showTarget' : request.GET.get('showTarget',''),
'user' : request.user,
'profile' : profile,
'showMyGraphs' : int( profile.user.username != 'default' ),
'searchEnabled' : int( os.access(settings.INDEX_FILE, os.R_OK) ),
'debug' : settings.DEBUG,
'jsdebug' : settings.DEBUG,
}
return render_to_response("composer.html",context)
def composer(request):
profile = getProfile(request)
context = {
"queryString": request.GET.urlencode().replace("+", "%20"),
"showTarget": request.GET.get("showTarget", ""),
"user": request.user,
"profile": profile,
"showMyGraphs": int(profile.user.username != "default"),
"searchEnabled": int(os.access(settings.INDEX_FILE, os.R_OK)),
"refreshInterval": settings.AUTO_REFRESH_INTERVAL,
"debug": settings.DEBUG,
"jsdebug": settings.DEBUG,
}
return render_to_response("composer.html", context)
def _gload(request,user=None,graphName=None):
if not user:
profile = getProfile(request,allowDefault=False)
if not profile: return stderr("You are not logged in so you must specify a username")
else:
try:
profile = getProfileByUsername(user)
except ObjectDoesNotExist:
return stderr("User does not exist")
try:
myGraph = profile.mygraph_set.get(name=graphName)
except ObjectDoesNotExist:
return stderr("Graph does not exist")
out = _create(request,myGraph.name)
out += "changeImage(%s_win,'%s');\n" % (myGraph.name,myGraph.url)
return out
def _gload(request,user=None,graphName=None):
if not user:
profile = getProfile(request,allowDefault=False)
if not profile: return stderr("You are not logged in so you must specify a username")
else:
try:
profile = getProfileByUsername(user)
except ObjectDoesNotExist:
return stderr("User does not exist")
try:
myGraph = profile.mygraph_set.get(name=graphName)
except ObjectDoesNotExist:
return stderr("Graph does not exist")
out = _create(request,myGraph.name)
out += "changeImage(%s_win,'%s');\n" % (myGraph.name.replace('.', '_'), myGraph.url)
return out
def _dogsave(request,graphName):
profile = getProfile(request,allowDefault=False)
if not profile: return stderr("You must be logged in to save graphs")
url = request.GET.get('url')
if not url: return stderr("No url specified!")
try:
existingGraph = profile.mygraph_set.get(name=graphName)
existingGraph.url = url
existingGraph.save()
except ObjectDoesNotExist:
try:
newGraph = MyGraph(profile=profile,name=graphName,url=url)
newGraph.save()
except:
log.exception("Failed to create new MyGraph in _dogsave(), graphName=%s" % graphName)
return stderr("Failed to save graph %s" % graphName)
return stdout("Saved graph %s" % graphName)
def _graphs(request,user=None):
if not user:
profile = getProfile(request,allowDefault=False)
if not profile: return stderr("You are not logged in so you must specify a username")
else:
try:
profile = getProfileByUsername(user)
except ObjectDoesNotExist:
return stderr("User does not exist")
out = ""
if user:
prefix = "~%s/" % user
else:
prefix = ""
for graph in profile.mygraph_set.all():
out += stdout(prefix + graph.name)
return out
def _graphs(request,user=None):
if not user:
profile = getProfile(request,allowDefault=False)
if not profile: return stderr("You are not logged in so you must specify a username")
else:
try:
profile = getProfileByUsername(user)
except ObjectDoesNotExist:
return stderr("User does not exist")
out = ""
if user:
prefix = "~%s/" % user
else:
prefix = ""
for graph in profile.mygraph_set.all():
out += stdout(prefix + graph.name)
return out
def _dogsave(request,graphName):
profile = getProfile(request,allowDefault=False)
if not profile: return stderr("You must be logged in to save graphs")
url = request.GET.get('url')
if not url: return stderr("No url specified!")
try:
existingGraph = profile.mygraph_set.get(name=graphName)
existingGraph.url = url
existingGraph.save()
except ObjectDoesNotExist:
try:
newGraph = MyGraph(profile=profile,name=graphName,url=url)
newGraph.save()
except:
log.exception("Failed to create new MyGraph in _dogsave(), graphName=%s" % graphName)
return stderr("Failed to save graph %s" % graphName)
return stdout("Saved graph %s" % graphName)
def mygraph(request):
profile = getProfile(request, allowDefault=False)
if not profile:
return HttpResponse("You are not logged in!")
action = request.GET['action']
graphName = request.GET['graphName']
if not graphName:
return HttpResponse("You must type in a graph name.")
if action == 'save':
url = request.GET['url']
try:
existingGraph = profile.mygraph_set.get(name=graphName)
existingGraph.url = url
existingGraph.save()
except ObjectDoesNotExist:
try:
newGraph = MyGraph(profile=profile, name=graphName, url=url)
newGraph.save()
except:
log.exception(
"Failed to create new MyGraph in /composer/mygraph/, graphName=%s"
% graphName)
return HttpResponse("Failed to save graph %s" % graphName)
return HttpResponse("SAVED")
elif action == 'delete':
try:
existingGraph = profile.mygraph_set.get(name=graphName)
existingGraph.delete()
except ObjectDoesNotExist:
return HttpResponse("No such graph '%s'" % graphName)
return HttpResponse("DELETED")
else:
return HttpResponse("Invalid operation '%s'" % action)
def _load(request,viewName,above=None):
if above:
out = stdout("Loading view %s above the current view" % viewName)
else:
out = stdout("Loading view %s" % viewName)
profile = getProfile(request)
try:
view = profile.view_set.get(name=viewName)
except ObjectDoesNotExist:
return stderr("Unknown view %s" % viewName)
if not above:
out += "Windows.windows.each( function(w) {w.destroy();} );"
for window in view.window_set.all():
out += _create(request,window.name)
out += "win = %s_win;" % window.name
out += "$('%s_img').src = '%s';" % (window.name,window.url)
out += "win.show();"
out += "win.setLocation(%d,%d);" % (window.top,window.left)
out += "win.setSize(%d,%d);" % (window.width,window.height)
if window.interval:
out += "window.%s_interval = %d;" % (window.name,window.interval)
out += "window.%s_timer = setTimeout('window.%s_redraw()', window.%s_interval);" % ((window.name,) * 3)
return out
def _load(request,viewName,above=None):
if above:
out = stdout("Loading view %s above the current view" % viewName)
else:
out = stdout("Loading view %s" % viewName)
profile = getProfile(request)
try:
view = profile.view_set.get(name=viewName)
except ObjectDoesNotExist:
return stderr("Unknown view %s" % viewName)
if not above:
out += "Windows.windows.each( function(w) {w.destroy();} );"
for window in view.window_set.all():
out += _create(request,window.name)
out += "win = %s_win;" % window.name
out += "$('%s_img').src = '%s';" % (window.name,window.url)
out += "win.show();"
out += "win.setLocation(%d,%d);" % (window.top,window.left)
out += "win.setSize(%d,%d);" % (window.width,window.height)
if window.interval:
out += "window.%s_interval = %d;" % (window.name,window.interval)
out += "window.%s_timer = setTimeout('window.%s_redraw()', window.%s_interval);" % ((window.name,) * 3)
return out
def cli(request):
context = RequestContext(request, dict( request.GET.items() ))
context['user'] = request.user
context['profile'] = getProfile(request)
return render_to_response("cli.html", context)
def cli(request):
context = dict( request.GET.items() )
context['user'] = request.user
context['profile'] = getProfile(request)
return render_to_response("cli.html", context)
def renderView(request):
start = time()
try:
global_timeout_duration = getattr(settings, 'RENDER_DURATION_TIMEOUT')
except:
global_timeout_duration = 60
if request.REQUEST.has_key('json_request'):
(graphOptions, requestOptions) = parseDataOptions(request.REQUEST['json_request'])
elif request.is_ajax() and request.method == 'POST':
(graphOptions, requestOptions) = parseDataOptions(request.raw_post_data)
else:
(graphOptions, requestOptions) = parseOptions(request)
useCache = 'noCache' not in requestOptions
cacheTimeout = requestOptions['cacheTimeout']
requestContext = {
'startTime' : requestOptions['startTime'],
'endTime' : requestOptions['endTime'],
'localOnly' : requestOptions['localOnly'],
'data' : []
}
data = requestContext['data']
# add template to graphOptions
try:
user_profile = getProfile(request, allowDefault=False)
graphOptions['defaultTemplate'] = user_profile.defaultTemplate
except:
graphOptions['defaultTemplate'] = "default"
if request.method == 'GET':
cache_request_obj = request.GET.copy()
else:
cache_request_obj = request.POST.copy()
# hack request object to add defaultTemplate param
cache_request_obj.appendlist("template", graphOptions['defaultTemplate'])
# First we check the request cache
requestKey = hashRequest(cache_request_obj)
requestHash = hashRequestWTime(cache_request_obj)
requestContext['request_key'] = requestHash
request_data = ""
if request.method == "POST":
for k,v in request.POST.items():
request_data += "%s=%s&" % (k.replace("\t",""),v.replace("\t",""))
else:
request_data = request.META['QUERY_STRING']
log.info("DEBUG:Request_meta:[%s]\t%s\t%s\t%s\t\"%s\"" %\
(requestHash,\
request.META['REMOTE_ADDR'],\
request.META['REQUEST_METHOD'],\
request_data,\
request.META['HTTP_USER_AGENT']))
if useCache:
cachedResponse = cache.get(requestKey)
if cachedResponse:
log.cache('Request-Cache hit [%s]' % requestHash)
log.rendering('[%s] Returned cached response in %.6f' % (requestHash, (time() - start)))
log.info("RENDER:[%s]:Timings:Cached %.5f" % (requestHash, time() - start))
return cachedResponse
else:
log.cache('Request-Cache miss [%s]' % requestHash)
# Now we prepare the requested data
if requestOptions['graphType'] == 'pie':
for target in requestOptions['targets']:
if target.find(':') >= 0:
try:
name,value = target.split(':',1)
value = float(value)
except:
raise ValueError("Invalid target '%s'" % target)
data.append( (name,value) )
else:
q = Queue(maxsize=1)
p = Process(target = evaluateWithQueue, args = (q, requestContext, target))
p.start()
seriesList = None
try:
seriesList = q.get(True, global_timeout_duration)
p.join()
except Exception, e:
log.info("DEBUG:[%s] got an exception on trying to get seriesList from queue, error: %s" % (requestHash,e))
p.terminate()
return errorPage("Failed to fetch data")
if seriesList == None:
log.info("DEBUG:[%s] request timed out" % requestHash)
p.terminate()
return errorPage("Request timed out")
for series in seriesList:
func = PieFunctions[requestOptions['pieMode']]
data.append( (series.name, func(requestContext, series) or 0 ))
def editProfile(request):
if not request.user.is_authenticated():
return HttpResponseRedirect('../..')
context = {'profile': getProfile(request)}
return render_to_response("editProfile.html", context)
def myGraphLookup(request):
"View for My Graphs navigation"
profile = getProfile(request, allowDefault=False)
assert profile
nodes = []
leafNode = {
'allowChildren': 0,
'expandable': 0,
'leaf': 1,
}
branchNode = {
'allowChildren': 1,
'expandable': 1,
'leaf': 0,
}
try:
path = request.GET.get('path', u'')
if path:
if path.endswith('.'):
userpath_prefix = path
else:
userpath_prefix = path + '.'
else:
userpath_prefix = u""
matches = [
graph for graph in profile.mygraph_set.all().order_by('name')
if graph.name.startswith(userpath_prefix)
]
log.info(
"myGraphLookup: username=%s, path=%s, userpath_prefix=%s, %ld graph to process"
% (profile.user.username, path, userpath_prefix, len(matches)))
branch_inserted = set()
leaf_inserted = set()
for graph in matches: #Now let's add the matching graph
isBranch = False
dotPos = graph.name.find('.', len(userpath_prefix))
if dotPos >= 0:
isBranch = True
name = graph.name[len(userpath_prefix):dotPos]
if name in branch_inserted: continue
branch_inserted.add(name)
else:
name = graph.name[len(userpath_prefix):]
if name in leaf_inserted: continue
leaf_inserted.add(name)
node = {'text': escape(name)}
if isBranch:
node.update({'id': userpath_prefix + name + '.'})
node.update(branchNode)
else:
m = md5()
m.update(name.encode('utf-8'))
# Sanitize target
urlEscaped = str(graph.url)
graphUrl = urlparse(urlEscaped)
graphUrlParams = {}
graphUrlParams['target'] = []
for param in parse_qsl(graphUrl.query):
if param[0] != 'target':
graphUrlParams[param[0]] = param[1]
else:
graphUrlParams[param[0]].append(escape(param[1]))
urlEscaped = graphUrl._replace(
query=urlencode(graphUrlParams, True)).geturl()
node.update({
'id': str(userpath_prefix + m.hexdigest()),
'graphUrl': urlEscaped
})
node.update(leafNode)
nodes.append(node)
except:
log.exception(
"browser.views.myGraphLookup(): could not complete request.")
if not nodes:
no_graphs = {'text': "No saved graphs", 'id': 'no-click'}
no_graphs.update(leafNode)
nodes.append(no_graphs)
return json_response(nodes, request)
def find_view(request):
"View for finding metrics matching a given pattern"
profile = getProfile(request)
format = request.REQUEST.get("format", "treejson")
local_only = int(request.REQUEST.get("local", 0))
wildcards = int(request.REQUEST.get("wildcards", 0))
fromTime = int(request.REQUEST.get("from", -1))
untilTime = int(request.REQUEST.get("until", -1))
if fromTime == -1:
fromTime = None
if untilTime == -1:
untilTime = None
automatic_variants = int(request.REQUEST.get("automatic_variants", 0))
try:
query = str(request.REQUEST["query"])
except:
return HttpResponseBadRequest(content="Missing required parameter 'query'", content_type="text/plain")
if "." in query:
base_path = query.rsplit(".", 1)[0] + "."
else:
base_path = ""
if format == "completer":
query = query.replace("..", "*.")
if not query.endswith("*"):
query += "*"
if automatic_variants:
query_parts = query.split(".")
for i, part in enumerate(query_parts):
if "," in part and "{" not in part:
query_parts[i] = "{%s}" % part
query = ".".join(query_parts)
tenant = request.session["tenant"]
try:
matches = list(STORE.find(query, tenant, fromTime, untilTime, local=local_only))
except:
log.exception()
raise
log.info("find_view query=%s local_only=%s matches=%d" % (query, local_only, len(matches)))
matches.sort(key=lambda node: node.name)
log.info(
"received remote find request: pattern=%s from=%s until=%s local_only=%s format=%s matches=%d"
% (query, fromTime, untilTime, local_only, format, len(matches))
)
if format == "treejson":
content = tree_json(matches, base_path, wildcards=profile.advancedUI or wildcards)
response = json_response_for(request, content)
elif format == "pickle":
content = pickle_nodes(matches)
response = HttpResponse(content, content_type="application/pickle")
elif format == "completer":
results = []
for node in matches:
node_info = dict(path=node.path, name=node.name, is_leaf=str(int(node.is_leaf)))
if not node.is_leaf:
node_info["path"] += "."
results.append(node_info)
if len(results) > 1 and wildcards:
wildcardNode = {"name": "*"}
results.append(wildcardNode)
response = json_response_for(request, {"metrics": results})
else:
return HttpResponseBadRequest(content="Invalid value for 'format' parameter", content_type="text/plain")
response["Pragma"] = "no-cache"
response["Cache-Control"] = "no-cache"
return response
def myGraphLookup(request):
"View for My Graphs navigation"
profile = getProfile(request, allowDefault=False)
assert profile
nodes = []
leafNode = {
'allowChildren': 0,
'expandable': 0,
'leaf': 1,
}
branchNode = {
'allowChildren': 1,
'expandable': 1,
'leaf': 0,
}
try:
path = str(request.GET['path'])
if path:
if path.endswith('.'):
userpath_prefix = path
else:
userpath_prefix = path + '.'
else:
userpath_prefix = ""
matches = [
graph for graph in profile.mygraph_set.all().order_by('name')
if graph.name.startswith(userpath_prefix)
]
log.info(
"myGraphLookup: username=%s, path=%s, userpath_prefix=%s, %ld graph to process"
% (profile.user.username, path, userpath_prefix, len(matches)))
branch_inserted = set()
leaf_inserted = set()
for graph in matches: #Now let's add the matching graph
isBranch = False
dotPos = graph.name.find('.', len(userpath_prefix))
if dotPos >= 0:
isBranch = True
name = graph.name[len(userpath_prefix):dotPos]
if name in branch_inserted: continue
branch_inserted.add(name)
else:
name = graph.name[len(userpath_prefix):]
if name in leaf_inserted: continue
leaf_inserted.add(name)
node = {'text': str(name)}
if isBranch:
node.update({'id': str(userpath_prefix + name + '.')})
node.update(branchNode)
else:
m = md5()
m.update(name)
node.update({
'id': str(userpath_prefix + m.hexdigest()),
'graphUrl': str(graph.url)
})
node.update(leafNode)
nodes.append(node)
except:
log.exception(
"browser.views.myGraphLookup(): could not complete request.")
if not nodes:
no_graphs = {'text': "No saved graphs", 'id': 'no-click'}
no_graphs.update(leafNode)
nodes.append(no_graphs)
return json_response(nodes, request)
def find_view(request):
"View for finding metrics matching a given pattern"
profile = getProfile(request)
queryParams = request.GET.copy()
queryParams.update(request.POST)
format = queryParams.get('format', 'treejson')
local_only = int(queryParams.get('local', 0))
wildcards = int(queryParams.get('wildcards', 0))
fromTime = int(queryParams.get('from', -1))
untilTime = int(queryParams.get('until', -1))
nodePosition = int(queryParams.get('position', -1))
jsonp = queryParams.get('jsonp', False)
if fromTime == -1:
fromTime = None
if untilTime == -1:
untilTime = None
automatic_variants = int(queryParams.get('automatic_variants', 0))
try:
query = str(queryParams['query'])
except:
return HttpResponseBadRequest(
content="Missing required parameter 'query'",
content_type='text/plain')
if '.' in query:
base_path = query.rsplit('.', 1)[0] + '.'
else:
base_path = ''
if format == 'completer':
query = query.replace('..', '*.')
if not query.endswith('*'):
query += '*'
if automatic_variants:
query_parts = query.split('.')
for i, part in enumerate(query_parts):
if ',' in part and '{' not in part:
query_parts[i] = '{%s}' % part
query = '.'.join(query_parts)
try:
matches = list(STORE.find(query, fromTime, untilTime,
local=local_only))
except:
log.exception()
raise
log.info('find_view query=%s local_only=%s matches=%d' %
(query, local_only, len(matches)))
matches.sort(key=lambda node: node.name)
log.info(
"received remote find request: pattern=%s from=%s until=%s local_only=%s format=%s matches=%d"
% (query, fromTime, untilTime, local_only, format, len(matches)))
if format == 'treejson':
content = tree_json(matches,
base_path,
wildcards=profile.advancedUI or wildcards)
response = json_response_for(request, content, jsonp=jsonp)
elif format == 'nodelist':
content = nodes_by_position(matches, nodePosition)
response = json_response_for(request, content, jsonp=jsonp)
elif format == 'pickle':
content = pickle_nodes(matches)
response = HttpResponse(content, content_type='application/pickle')
elif format == 'completer':
results = []
for node in matches:
node_info = dict(path=node.path,
name=node.name,
is_leaf=str(int(node.is_leaf)))
if not node.is_leaf:
node_info['path'] += '.'
results.append(node_info)
if len(results) > 1 and wildcards:
wildcardNode = {'name': '*'}
results.append(wildcardNode)
response = json_response_for(request, {'metrics': results},
jsonp=jsonp)
else:
return HttpResponseBadRequest(
content="Invalid value for 'format' parameter",
content_type='text/plain')
response['Pragma'] = 'no-cache'
response['Cache-Control'] = 'no-cache'
return response
def myGraphLookup(request):
"View for My Graphs navigation"
profile = getProfile(request,allowDefault=False)
assert profile
nodes = []
leafNode = {
'allowChildren' : 0,
'expandable' : 0,
'leaf' : 1,
}
branchNode = {
'allowChildren' : 1,
'expandable' : 1,
'leaf' : 0,
}
try:
path = str( request.GET['path'] )
if path:
if path.endswith('.'):
userpath_prefix = path
else:
userpath_prefix = path + '.'
else:
userpath_prefix = ""
matches = [ graph for graph in profile.mygraph_set.all().order_by('name') if graph.name.startswith(userpath_prefix) ]
log.info( "myGraphLookup: username=%s, path=%s, userpath_prefix=%s, %ld graph to process" % (profile.user.username, path, userpath_prefix, len(matches)) )
branch_inserted = set()
leaf_inserted = set()
for graph in matches: #Now let's add the matching graph
isBranch = False
dotPos = graph.name.find( '.', len(userpath_prefix) )
if dotPos >= 0:
isBranch = True
name = graph.name[ len(userpath_prefix) : dotPos ]
if name in branch_inserted: continue
branch_inserted.add(name)
else:
name = graph.name[ len(userpath_prefix): ]
if name in leaf_inserted: continue
leaf_inserted.add(name)
node = {'text' : str(name) }
if isBranch:
node.update( { 'id' : str(userpath_prefix + name + '.') } )
node.update(branchNode)
else:
m = md5()
m.update(name)
node.update( { 'id' : str(userpath_prefix + m.hexdigest()), 'graphUrl' : str(graph.url) } )
node.update(leafNode)
nodes.append(node)
except:
log.exception("browser.views.myGraphLookup(): could not complete request.")
if not nodes:
no_graphs = { 'text' : "No saved graphs", 'id' : 'no-click' }
no_graphs.update(leafNode)
nodes.append(no_graphs)
return json_response(nodes, request)
def renderView(request):
start = time()
if request.REQUEST.has_key('json_request'):
(graphOptions,
requestOptions) = parseDataOptions(request.REQUEST['json_request'])
elif request.is_ajax() and request.method == 'POST':
(graphOptions,
requestOptions) = parseDataOptions(request.raw_post_data)
else:
(graphOptions, requestOptions) = parseOptions(request)
useCache = 'noCache' not in requestOptions
cacheTimeout = requestOptions['cacheTimeout']
requestContext = {
'startTime': requestOptions['startTime'],
'endTime': requestOptions['endTime'],
'localOnly': requestOptions['localOnly'],
'data': []
}
data = requestContext['data']
# First we check the request cache
if useCache:
requestKey = hashRequest(request)
cachedResponse = cache.get(requestKey)
if cachedResponse:
log.cache('Request-Cache hit [%s]' % requestKey)
log.rendering('Returned cached response in %.6f' %
(time() - start))
return cachedResponse
else:
log.cache('Request-Cache miss [%s]' % requestKey)
# Now we prepare the requested data
if requestOptions['graphType'] == 'pie':
for target in requestOptions['targets']:
if target.find(':') >= 0:
try:
name, value = target.split(':', 1)
value = float(value)
except:
raise ValueError("Invalid target '%s'" % target)
data.append((name, value))
else:
seriesList = evaluateTarget(requestContext, target)
for series in seriesList:
func = PieFunctions[requestOptions['pieMode']]
data.append((series.name, func(requestContext, series)
or 0))
elif requestOptions['graphType'] == 'line':
# Let's see if at least our data is cached
if useCache:
targets = requestOptions['targets']
startTime = requestOptions['startTime']
endTime = requestOptions['endTime']
dataKey = hashData(targets, startTime, endTime)
cachedData = cache.get(dataKey)
if cachedData:
log.cache("Data-Cache hit [%s]" % dataKey)
else:
log.cache("Data-Cache miss [%s]" % dataKey)
else:
cachedData = None
if cachedData is not None:
requestContext['data'] = data = cachedData
else: # Have to actually retrieve the data now
for target in requestOptions['targets']:
if not target.strip():
continue
t = time()
seriesList = evaluateTarget(requestContext, target)
log.rendering("Retrieval of %s took %.6f" %
(target, time() - t))
data.extend(seriesList)
if useCache:
cache.add(dataKey, data, cacheTimeout)
# If data is all we needed, we're done
format = requestOptions.get('format')
if format == 'csv':
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
if format == 'json':
series_data = []
if 'maxDataPoints' in requestOptions and any(data):
startTime = min([series.start for series in data])
endTime = max([series.end for series in data])
timeRange = endTime - startTime
maxDataPoints = requestOptions['maxDataPoints']
for series in data:
numberOfDataPoints = timeRange / series.step
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)
timestamps = range(series.start, series.end,
secondsPerPoint)
else:
timestamps = range(series.start, series.end,
series.step)
datapoints = zip(series, timestamps)
series_data.append(
dict(target=series.name, datapoints=datapoints))
else:
for series in data:
timestamps = range(series.start, series.end, series.step)
datapoints = zip(series, timestamps)
series_data.append(
dict(target=series.name, datapoints=datapoints))
if 'jsonp' in requestOptions:
response = HttpResponse(
content="%s(%s)" %
(requestOptions['jsonp'], json.dumps(series_data)),
content_type='text/javascript')
else:
response = HttpResponse(content=json.dumps(series_data),
content_type='application/json')
response['Pragma'] = 'no-cache'
response['Cache-Control'] = 'no-cache'
return response
if format == 'raw':
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(str, series)))
response.write('\n')
log.rendering('Total rawData rendering time %.6f' %
(time() - start))
return response
if format == 'svg':
graphOptions['outputFormat'] = 'svg'
if format == 'pickle':
response = HttpResponse(content_type='application/pickle')
seriesInfo = [series.getInfo() for series in data]
pickle.dump(seriesInfo, response, protocol=-1)
log.rendering('Total pickle rendering time %.6f' %
(time() - start))
return response
# add template to graphOptions
try:
user_profile = getProfile(request, allowDefault=False)
graphOptions['defaultTemplate'] = user_profile.defaultTemplate
except:
graphOptions['defaultTemplate'] = "default"
# We've got the data, now to render it
graphOptions['data'] = data
if settings.REMOTE_RENDERING: # Rendering on other machines is faster in some situations
image = delegateRendering(requestOptions['graphType'], graphOptions)
else:
image = doImageRender(requestOptions['graphClass'], graphOptions)
useSVG = graphOptions.get('outputFormat') == 'svg'
if useSVG and 'jsonp' in requestOptions:
response = HttpResponse(content="%s(%s)" %
(requestOptions['jsonp'], json.dumps(image)),
content_type='text/javascript')
else:
response = buildResponse(image,
'image/svg+xml' if useSVG else 'image/png')
if useCache:
cache.set(requestKey, response, cacheTimeout)
log.rendering('Total rendering time %.6f seconds' % (time() - start))
return response
def renderView(request):
start = time()
try:
global_timeout_duration = getattr(settings, 'RENDER_DURATION_TIMEOUT')
except:
global_timeout_duration = 60
if request.REQUEST.has_key('json_request'):
(graphOptions,
requestOptions) = parseDataOptions(request.REQUEST['json_request'])
elif request.is_ajax() and request.method == 'POST':
(graphOptions,
requestOptions) = parseDataOptions(request.raw_post_data)
else:
(graphOptions, requestOptions) = parseOptions(request)
useCache = 'noCache' not in requestOptions
cacheTimeout = requestOptions['cacheTimeout']
requestContext = {
'startTime': requestOptions['startTime'],
'endTime': requestOptions['endTime'],
'localOnly': requestOptions['localOnly'],
'data': []
}
data = requestContext['data']
# add template to graphOptions
try:
user_profile = getProfile(request, allowDefault=False)
graphOptions['defaultTemplate'] = user_profile.defaultTemplate
except:
graphOptions['defaultTemplate'] = "default"
if request.method == 'GET':
cache_request_obj = request.GET.copy()
else:
cache_request_obj = request.POST.copy()
# hack request object to add defaultTemplate param
cache_request_obj.appendlist("template", graphOptions['defaultTemplate'])
# First we check the request cache
requestKey = hashRequest(cache_request_obj)
requestHash = hashRequestWTime(cache_request_obj)
requestContext['request_key'] = requestHash
request_data = ""
if request.method == "POST":
for k, v in request.POST.items():
request_data += "%s=%s&" % (k.replace("\t", ""), v.replace(
"\t", ""))
else:
request_data = request.META['QUERY_STRING']
log.info("DEBUG:Request_meta:[%s]\t%s\t%s\t%s\t\"%s\"" %\
(requestHash,\
request.META['REMOTE_ADDR'],\
request.META['REQUEST_METHOD'],\
request_data,\
request.META['HTTP_USER_AGENT']))
if useCache:
cachedResponse = cache.get(requestKey)
if cachedResponse:
log.cache('Request-Cache hit [%s]' % requestHash)
log.rendering('[%s] Returned cached response in %.6f' %
(requestHash, (time() - start)))
log.info("RENDER:[%s]:Timings:Cached %.5f" %
(requestHash, time() - start))
return cachedResponse
else:
log.cache('Request-Cache miss [%s]' % requestHash)
# Now we prepare the requested data
if requestOptions['graphType'] == 'pie':
for target in requestOptions['targets']:
if target.find(':') >= 0:
try:
name, value = target.split(':', 1)
value = float(value)
except:
raise ValueError("Invalid target '%s'" % target)
data.append((name, value))
else:
q = Queue(maxsize=1)
p = Process(target=evaluateWithQueue,
args=(q, requestContext, target))
p.start()
seriesList = None
try:
seriesList = q.get(True, global_timeout_duration)
p.join()
except Exception, e:
log.info(
"DEBUG:[%s] got an exception on trying to get seriesList from queue, error: %s"
% (requestHash, e))
p.terminate()
return errorPage("Failed to fetch data")
if seriesList == None:
log.info("DEBUG:[%s] request timed out" % requestHash)
p.terminate()
return errorPage("Request timed out")
for series in seriesList:
func = PieFunctions[requestOptions['pieMode']]
data.append((series.name, func(requestContext, series)
or 0))
def find_view(request):
"View for finding metrics matching a given pattern"
profile = getProfile(request)
format = request.REQUEST.get('format', 'treejson')
local_only = int( request.REQUEST.get('local', 0) )
wildcards = int( request.REQUEST.get('wildcards', 0) )
fromTime = int( request.REQUEST.get('from', -1) )
untilTime = int( request.REQUEST.get('until', -1) )
jsonp = request.REQUEST.get('jsonp', False)
if fromTime == -1:
fromTime = None
if untilTime == -1:
untilTime = None
automatic_variants = int( request.REQUEST.get('automatic_variants', 0) )
try:
query = str( request.REQUEST['query'] )
except:
return HttpResponseBadRequest(content="Missing required parameter 'query'",
content_type="text/plain")
if '.' in query:
base_path = query.rsplit('.', 1)[0] + '.'
else:
base_path = ''
if format == 'completer':
query = query.replace('..', '*.')
if not query.endswith('*'):
query += '*'
if automatic_variants:
query_parts = query.split('.')
for i,part in enumerate(query_parts):
if ',' in part and '{' not in part:
query_parts[i] = '{%s}' % part
query = '.'.join(query_parts)
try:
matches = list( STORE.find(query, fromTime, untilTime, local=local_only) )
except:
log.exception()
raise
log.info('find_view query=%s local_only=%s matches=%d' % (query, local_only, len(matches)))
matches.sort(key=lambda node: node.name)
log.info("received remote find request: pattern=%s from=%s until=%s local_only=%s format=%s matches=%d" % (query, fromTime, untilTime, local_only, format, len(matches)))
if format == 'treejson':
content = tree_json(matches, base_path, wildcards=profile.advancedUI or wildcards)
response = json_response_for(request, content, jsonp=jsonp)
elif format == 'pickle':
content = pickle_nodes(matches)
response = HttpResponse(content, content_type='application/pickle')
elif format == 'completer':
results = []
for node in matches:
node_info = dict(path=node.path, name=node.name, is_leaf=str(int(node.is_leaf)))
if not node.is_leaf:
node_info['path'] += '.'
results.append(node_info)
if len(results) > 1 and wildcards:
wildcardNode = {'name' : '*'}
results.append(wildcardNode)
response = json_response_for(request, { 'metrics' : results }, jsonp=jsonp)
else:
return HttpResponseBadRequest(
content="Invalid value for 'format' parameter",
content_type="text/plain")
response['Pragma'] = 'no-cache'
response['Cache-Control'] = 'no-cache'
return response
def find_view(request):
"View for finding metrics matching a given pattern"
profile = getProfile(request)
format = request.REQUEST.get('format', 'treejson')
local_only = int( request.REQUEST.get('local', 0) )
contexts = int( request.REQUEST.get('contexts', 0) )
wildcards = int( request.REQUEST.get('wildcards', 0) )
automatic_variants = int( request.REQUEST.get('automatic_variants', 0) )
jsonp = request.REQUEST.get('jsonp', False)
try:
query = str( request.REQUEST['query'] )
except:
return HttpResponseBadRequest(content="Missing required parameter 'query'", content_type="text/plain")
if '.' in query:
base_path = query.rsplit('.', 1)[0] + '.'
else:
base_path = ''
if local_only:
store = LOCAL_STORE
else:
store = STORE
if format == 'completer':
query = query.replace('..', '*.')
if not query.endswith('*'):
query += '*'
if automatic_variants:
query_parts = query.split('.')
for i,part in enumerate(query_parts):
if ',' in part and '{' not in part:
query_parts[i] = '{%s}' % part
query = '.'.join(query_parts)
try:
matches = list( store.find(query) )
except:
log.exception()
raise
log.info('find_view query=%s local_only=%s matches=%d' % (query, local_only, len(matches)))
matches.sort(key=lambda node: node.name)
if format == 'treejson':
content = tree_json(matches, base_path, wildcards=profile.advancedUI or wildcards, contexts=contexts)
response = json_response_for(request, content)
elif format == 'pickle':
content = pickle_nodes(matches, contexts=contexts)
response = HttpResponse(content, content_type='application/pickle')
elif format == 'completer':
#if len(matches) == 1 and (not matches[0].isLeaf()) and query == matches[0].metric_path + '*': # auto-complete children
# matches = list( store.find(query + '.*') )
results = []
for node in matches:
node_info = dict(path=node.metric_path, name=node.name, is_leaf=str(int(node.isLeaf())))
if not node.isLeaf():
node_info['path'] += '.'
results.append(node_info)
if len(results) > 1 and wildcards:
wildcardNode = {'name' : '*'}
results.append(wildcardNode)
response = json_response_for(request, { 'metrics' : results }, jsonp=jsonp)
else:
return HttpResponseBadRequest(content="Invalid value for 'format' parameter", content_type="text/plain")
response['Pragma'] = 'no-cache'
response['Cache-Control'] = 'no-cache'
return response
