def logs(request): print '-- system logs:', request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/logs/","logs",ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() servers = mongo.servers.find({'secret':secret,}) activities = mongo.activity.find({'secret':secret,}).sort("_id",pymongo.DESCENDING) activities = activities.limit(10) return render_to_response( 'logs.html', { 'request':request, 'secret':profile.secret, 'servers':servers, 'activities':activities, }, context_instance=RequestContext(request), )
def user_activity_report(request, user_id): print '-- admin report user activity', user_id #if not request.user.is_superuser: # print 'anonymous' # return HttpResponseRedirect("/") print request.user profile = Profile.objects.get(user=request.user) u = User.objects.get(pk=user_id) ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/admin/user/" + str(user_id) + "/report/", "user_activity_report", ip=ip) user_activity = Activity.objects.filter(user=u).order_by('-pk') user_activity_clicks = Activity.objects.filter( user=u, activity="click").order_by('-pk') user_activity_other = Activity.objects.filter( user=u).filter(~Q(activity="click")).order_by('-pk') user_profile = Profile.objects.get(user=u) try: vms_cache = Cache.objects.get(user=u) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response #vms_cached_response['last_seen'] = vms_cache.last_seen except: vms_cached_response = None servers = mongo.servers.find({ 'secret': user_profile.secret, }).sort('_id', -1) import datetime user = request.user user.last_login = datetime.datetime.now() user.save() return render_to_response('admin_user_report.html', { 'u': u, 'vms_cached_response': vms_cached_response, 'user_profile': user_profile, 'user_files': [], 'user_activity': user_activity, 'user_activity_clicks': user_activity_clicks, 'user_activity_other': user_activity_other, 'profile': profile, 'servers': servers, }, context_instance=RequestContext(request))
def admin(request): print '-- admin page:' if not request.user.is_staff: return HttpResponseRedirect("/") print request.user users = Profile.objects.all().order_by('-last_seen') profile = Profile.objects.get(user=request.user) import datetime user = request.user user.last_login = datetime.datetime.now() user.save() users = Profile.objects.all().order_by('-pk') ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/admin/", "admin", ip=ip) return render_to_response('admin.html', { 'users': users, 'files': [], 'profile': profile, 'request': request, }, context_instance=RequestContext(request))
def incidents(request): print '-- system logs:', request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/logs/","logs",ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() notifs_counter = 0 active_service_statuses = mongo.active_service_statuses active_service_statuses_data = active_service_statuses.find({"$and": [{"secret": secret}, {"current_overall_status": {"$ne": "OK"}}]}) notifs_counter = active_service_statuses_data.count() unknown_notifs = active_service_statuses.find({"secret":secret,"current_overall_status":"UNKNOWN"}) warning_notifs = active_service_statuses.find({"secret":secret,"current_overall_status":"WARNING"}) critical_notifs = active_service_statuses.find({"secret":secret,"current_overall_status":"CRITICAL"}) return render_to_response('incidents.html', {'request':request,'notifs_counter':notifs_counter,'active_service_statuses':active_service_statuses_data,'unknown_notifs':unknown_notifs,'warning_notifs':warning_notifs,'critical_notifs':critical_notifs,'profile':profile,}, context_instance=RequestContext(request))
def logs(request): print '-- system logs:', request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/logs/", "logs", ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() servers = mongo.servers.find({ 'secret': secret, }) activities = mongo.activity.find({ 'secret': secret, }).sort("_id", pymongo.DESCENDING) activities = activities.limit(10) return render_to_response( 'logs.html', { 'request': request, 'secret': profile.secret, 'servers': servers, 'activities': activities, }, context_instance=RequestContext(request), )
def admin(request): print "-- admin page:" if not request.user.is_staff: return HttpResponseRedirect("/") print request.user users = Profile.objects.all().order_by("-last_seen") profile = Profile.objects.get(user=request.user) user = request.user user.last_login = datetime.datetime.now() user.save() users = Profile.objects.all().order_by("-pk") ip = request.META["REMOTE_ADDR"] _log_user_activity(profile, "click", "/admin/", "admin", ip=ip) return render_to_response( "admin.html", {"users": users, "files": [], "profile": profile, "request": request}, context_instance=RequestContext(request), )
def home(request): if not request.user.is_authenticated(): print '-- web:' return render_to_response('web.html', {'request':request,}, context_instance=RequestContext(request)) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/","home",ip=ip) is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None return render_to_response('dashboard.html', {'is_updating':is_updating,'vms_cached_response':vms_cached_response,}, context_instance=RequestContext(request))
def home(request): if not request.user.is_authenticated(): print '-- web:' random_motto = CLOUDLY_MOTTOS[random.randint(0, len(CLOUDLY_MOTTOS) - 1)] return render_to_response('current-web.html', { 'random_motto': random_motto, }) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] try: _log_user_activity(profile, "click", "/", "home", ip=ip) except: pass is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None servers = mongo.servers.find({ 'secret': profile.secret, }).sort('_id', -1) servers_tags = {} for server in servers: if 'tags' in server: for tag_category in server['tags']: if (not servers_tags.has_key(tag_category)): servers_tags[tag_category] = [] for inner_tag in server['tags'][tag_category]: if (not inner_tag[0] in servers_tags[tag_category]): servers_tags[tag_category].append(inner_tag[0]) return render_to_response('dashboard.html', { 'servers_tags': servers_tags, 'is_updating': is_updating, 'vms_cached_response': vms_cached_response, }, context_instance=RequestContext(request))
def home(request): if not request.user.is_authenticated(): print '-- web:' random_motto = CLOUDLY_MOTTOS[ random.randint(0,len(CLOUDLY_MOTTOS)-1) ] return render_to_response( 'current-web.html', {'random_motto':random_motto,} ) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] try: _log_user_activity(profile,"click","/","home",ip=ip) except: pass is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None servers = mongo.servers.find({'secret':profile.secret,}).sort('_id',-1); servers_tags = {} for server in servers: if 'tags' in server: for tag_category in server['tags']: if(not servers_tags.has_key(tag_category)): servers_tags[tag_category] = []; for inner_tag in server['tags'][tag_category]: if(not inner_tag[0] in servers_tags[tag_category]): servers_tags[tag_category].append(inner_tag[0]) return render_to_response( 'dashboard.html', { 'servers_tags':servers_tags, 'is_updating':is_updating, 'vms_cached_response':vms_cached_response, }, context_instance=RequestContext(request) )
def incidents(request): print '-- system logs:', request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/logs/", "logs", ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() notifs_counter = 0 active_service_statuses = mongo.active_service_statuses active_service_statuses_data = active_service_statuses.find({ "$and": [{ "secret": secret }, { "current_overall_status": { "$ne": "OK" } }] }) notifs_counter = active_service_statuses_data.count() unknown_notifs = active_service_statuses.find({ "secret": secret, "current_overall_status": "UNKNOWN" }) warning_notifs = active_service_statuses.find({ "secret": secret, "current_overall_status": "WARNING" }) critical_notifs = active_service_statuses.find({ "secret": secret, "current_overall_status": "CRITICAL" }) return render_to_response('incidents.html', { 'request': request, 'notifs_counter': notifs_counter, 'active_service_statuses': active_service_statuses_data, 'unknown_notifs': unknown_notifs, 'warning_notifs': warning_notifs, 'critical_notifs': critical_notifs, 'profile': profile, }, context_instance=RequestContext(request))
def server_view(request, hwaddr): print '-- server_view' print request.user user = request.user profile = userprofile.objects.get(user=request.user) ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/server/"+hwaddr,"server_view",ip=ip) hwaddr_orig = hwaddr hwaddr = hwaddr.replace('-',':') server = mongo.servers.find_one({'secret':profile.secret,'uuid':hwaddr,}) server_status = "Running" if((datetime.datetime.utcnow()-server['last_seen']).total_seconds()>20): server_status = "Stopped" if((datetime.datetime.utcnow()-server['last_seen']).total_seconds()>1800): server_status = "Offline" try: uuid = server['uuid'] except: return HttpResponse("access denied") disks_usage_ = [] #disks_usage = mongo.disks_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in disks_usage: disks_usage_.append(i) disks_usage = disks_usage_ networking_ = [] #networking = mongo.networking.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in networking: networking_.append(i) networking = networking_ mem_usage_ = [] #mem_usage = mongo.memory_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in mem_usage: mem_usage_.append(i) mem_usage = mem_usage_ loadavg_ = [] #loadavg = mongo.loadavg.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in loadavg: loadavg_.append(i) loadavg = loadavg_ activity = mongo.activity.find({'uuid':uuid,}).sort('_id',-1).limit(3) disks = [] disks_ = server[u'disks_usage'] for disk in disks_: if not disk[5] in disks: disks.append(disk[5]) return render_to_response('server_detail.html', {'secret':profile.secret,'hwaddr':hwaddr,'hwaddr_orig':hwaddr_orig,'server':server,'server_status':server_status,'disks_usage':disks_usage,'disks':disks,'mem_usage':mem_usage,'loadavg':loadavg,'networking':networking,'activity':activity,}, context_instance=RequestContext(request))
def download_agent(request): print "-- download agent:" server_url = request.build_absolute_uri("/") api_server_url = server_url api_server_url = api_server_url.replace("http://", "").replace("https://", "") api_server_url = api_server_url.split(":")[0].replace("/", "") api_server_url = api_server_url + ":5001" if "projectcloudly.com" in api_server_url: api_server_url = "api.projectcloudly.com:5001" ip = request.META["REMOTE_ADDR"] try: profile = userprofile.objects.get(user=request.user) except: pass print "server_url", server_url print "api_server_url", api_server_url if request.GET: try: xuuid = request.GET["xuuid"] profile = userprofile.objects.get(agent_hash=xuuid) except: return HttpResponseForbidden() _log_user_activity(profile, "download", "/download/agent/", "download_agent", ip=ip) agent_code = "" for line in open("agent.py"): if 'SECRET = ""' in line: agent_code += 'SECRET = "' + profile.secret + '"\n' continue if 'API_SERVER = ""' in line: agent_code += 'API_SERVER = "' + api_server_url + '"\n' continue agent_code += line return HttpResponse(agent_code) try: agent_download_url = server_url + "download/agent?xuuid=" + profile.agent_hash print "agent_download_url", agent_download_url except: return HttpResponseRedirect("https://raw.githubusercontent.com/jparicka/cloudly/master/agent.py") return render_to_response( "agent_download.html", {"request": request, "profile": profile, "agent_download_url": agent_download_url}, context_instance=RequestContext(request), )
def welcome(request): print "-- welcome page:", request.user ip = request.META["REMOTE_ADDR"] profile = userprofile.objects.get(user=request.user) _log_user_activity(profile, "click", "/welcome/", "welcome", ip=ip) print request.user return render_to_response("welcome.html", locals(), context_instance=RequestContext(request))
def welcome(request): print '-- welcome page:', request.user ip = request.META['REMOTE_ADDR'] profile = userprofile.objects.get(user=request.user) _log_user_activity(profile, "click", "/welcome/", "welcome", ip=ip) print request.user return render_to_response('welcome.html', locals(), context_instance=RequestContext(request))
def user_activity_report(request, user_id): print "-- admin report user activity", user_id if not request.user.is_staff: return HttpResponseRedirect("/") print request.user profile = Profile.objects.get(user=request.user) u = User.objects.get(pk=user_id) ip = request.META["REMOTE_ADDR"] _log_user_activity(profile, "click", "/admin/user/" + str(user_id) + "/report/", "user_activity_report", ip=ip) user_activity = Activity.objects.filter(user=u).order_by("-pk") user_activity_clicks = Activity.objects.filter(user=u, activity="click").order_by("-pk") user_activity_other = Activity.objects.filter(user=u).filter(~Q(activity="click")).order_by("-pk") user_profile = Profile.objects.get(user=u) try: vms_cache = Cache.objects.get(user=u) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response # vms_cached_response['last_seen'] = vms_cache.last_seen except: vms_cached_response = None servers = mongo.servers.find({"secret": user_profile.secret}).sort("_id", -1) user = request.user user.last_login = datetime.datetime.now() user.save() return render_to_response( "admin_user_report.html", { "u": u, "vms_cached_response": vms_cached_response, "user_profile": user_profile, "user_files": [], "user_activity": user_activity, "user_activity_clicks": user_activity_clicks, "user_activity_other": user_activity_other, "profile": profile, "servers": servers, }, context_instance=RequestContext(request), )
def download_agent(request): print '-- download agent:' server_url = request.build_absolute_uri('/') api_server_url = server_url api_server_url = api_server_url.replace('http://','').replace('https://','') api_server_url = api_server_url.split(':')[0].replace('/','') api_server_url = api_server_url + ":5001" if('projectcloudly.com' in api_server_url): api_server_url = "api.projectcloudly.com:5001" ip = request.META['REMOTE_ADDR'] try: profile = userprofile.objects.get(user=request.user) except: pass print 'server_url', server_url print 'api_server_url', api_server_url if(request.GET): try: xuuid = request.GET['xuuid'] profile = userprofile.objects.get(agent_hash=xuuid) except: return HttpResponseForbidden() _log_user_activity(profile,"download","/download/agent/","download_agent",ip=ip) agent_code = "" for line in open('agent.py'): if("SECRET = \"\"" in line): agent_code += "SECRET = \""+profile.secret+"\"\n" continue if("API_SERVER = \"\"" in line): agent_code += "API_SERVER = \""+api_server_url+"\"\n" continue agent_code += line return HttpResponse(agent_code) try: agent_download_url = server_url + "download/agent?xuuid="+profile.agent_hash print 'agent_download_url', agent_download_url except: return HttpResponseRedirect("https://raw.githubusercontent.com/ProjectCloudly/Cloudly/master/agent.py") return render_to_response('agent_download.html', {'request': request, 'profile':profile,'agent_download_url':agent_download_url,}, context_instance=RequestContext(request))
def control_aws_vm(request, vm_name, action): print request.user user = request.user profile = userprofile.objects.get(user=request.user) user.last_login = datetime.datetime.now() user.save() ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/aws/" + vm_name + "/" + action + "/", "control_aws_vm", ip=ip) vms_cache = Cache.objects.get(user=user) vm_cache = vms_cache.vms_response vm_cache = base64.b64decode(vm_cache) vm_cache = pickle.loads(vm_cache)[vm_name] if (vm_cache['user_id'] != request.user.id): return HttpResponse("access denied") aws_access_key = profile.aws_access_key aws_secret_key = profile.aws_secret_key aws_ec2_verified = profile.aws_ec2_verified ec2_region = vm_cache['instance']['region']['name'] ec2conn = boto.ec2.connect_to_region(ec2_region, aws_access_key_id=aws_access_key, aws_secret_access_key=aws_secret_key) if (action == "reboot"): ec2conn.reboot_instances([ vm_name, ]) if (action == "start"): ec2conn.start_instances([ vm_name, ]) if (action == "stop"): ec2conn.stop_instances([ vm_name, ]) if (action == "terminate"): ec2conn.terminate_instances([ vm_name, ]) return HttpResponseRedirect("/")
def investors(request): print '-- investors page:', request.user ip = request.META['REMOTE_ADDR'] try: profile = userprofile.objects.get(user=request.user) _log_user_activity(profile,"click","/investors/","welcome",ip=ip) except: return HttpResponseRedirect("https://github.com/jparicka/cloudly") print request.user return render_to_response('investors.html', locals(), context_instance=RequestContext(request))
def incidents(request): print '-- incidents:', request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/incidents/","incidents",ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() servers = mongo.servers.find({'secret':profile.secret},{'uuid':1,'name':1}).sort('_id',-1); serversNames = {} for server in servers: serversNames[server['uuid']] = server['name'] active_service_statuses = mongo.active_service_statuses active_notifs = {} notifs_types = ["CRITICAL","WARNING","UNKNOWN",] for notifs_type in notifs_types: active_notifs[notifs_type] = [] notifs = active_service_statuses.find({"secret":secret,"current_overall_status":notifs_type}) for notif in notifs: notif.update({'name':serversNames[notif['server_id']]}) server = mongo.servers.find_one({'uuid':notif['server_id'],}) if((datetime.datetime.now()-server['last_seen']).total_seconds()<20): active_notifs[notifs_type].append(notif) servers = [] for server in mongo.servers.find({"secret":profile.secret,}): servers.append(server) return render_to_response( 'incidents.html', { 'request':request, 'secret':profile.secret, 'servers': servers, 'active_notifs':active_notifs }, context_instance=RequestContext(request), )
def investors(request): print '-- investors page:', request.user ip = request.META['REMOTE_ADDR'] try: profile = userprofile.objects.get(user=request.user) _log_user_activity(profile, "click", "/investors/", "welcome", ip=ip) except: return HttpResponseRedirect("https://github.com/jparicka/cloudly") print request.user return render_to_response('investors.html', locals(), context_instance=RequestContext(request))
def credits(request): try: print "-- credits page:", request.user except: print "-- credits page: anonymous" ip = request.META["REMOTE_ADDR"] try: profile = userprofile.objects.get(user=request.user) _log_user_activity(profile, "click", "/credits/", "credits", ip=ip) except: return HttpResponseRedirect("https://github.com/jparicka/cloudly") print request.user return render_to_response("credits.html", {"request": request}, context_instance=RequestContext(request))
def incidents(request): print '-- system logs:', request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/logs/","logs",ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() return render_to_response('incidents.html', {'profile':profile,}, context_instance=RequestContext(request))
def home(request): if not request.user.is_authenticated(): print '-- web:' CLOUDLY_MOTTOS = [ "The Power of Now!", "Relax, it’s going to take no time!", "Saves you money and resources!", "Real-time servers monitoring.", ] return render_to_response('web.html', { 'request': request, 'CLOUDLY_MOTTOS': CLOUDLY_MOTTOS, }, context_instance=RequestContext(request)) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/", "home", ip=ip) is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None return render_to_response('dashboard.html', { 'is_updating': is_updating, 'vms_cached_response': vms_cached_response, }, context_instance=RequestContext(request))
def incidents(request): print '-- incidents:', request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/incidents/","incidents",ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() servers = mongo.servers.find({'secret':profile.secret},{'uuid':1,'name':1}).sort('_id',-1); serversNames = {} for server in servers: serversNames[server['uuid']] = server['name'] active_service_statuses = mongo.active_service_statuses active_notifs = {} notifs_types = ["CRITICAL","WARNING","UNKNOWN",] for notifs_type in notifs_types: active_notifs[notifs_type] = [] notifs = active_service_statuses.find({"secret":secret,"current_overall_status":notifs_type}) for notif in notifs: notif.update({'name':serversNames[notif['server_id']]}) server = mongo.servers.find_one({'uuid':notif['server_id'],}) if((datetime.datetime.now()-server['last_seen']).total_seconds()<20): active_notifs[notifs_type].append(notif) return render_to_response( 'incidents.html', { 'request':request, 'secret':profile.secret, 'active_notifs':active_notifs }, context_instance=RequestContext(request), )
def credits(request): try: print '-- credits page:', request.user except: print '-- credits page: anonymous' ip = request.META['REMOTE_ADDR'] try: profile = userprofile.objects.get(user=request.user) _log_user_activity(profile, "click", "/credits/", "credits", ip=ip) except: return HttpResponseRedirect("https://github.com/jparicka/cloudly") print request.user return render_to_response('credits.html', locals(), context_instance=RequestContext(request))
def credits(request): try: print '-- credits page:', request.user except: print '-- credits page: anonymous' ip = request.META['REMOTE_ADDR'] try: profile = userprofile.objects.get(user=request.user) _log_user_activity(profile,"click","/credits/","credits",ip=ip) except: return HttpResponseRedirect("/") print request.user return render_to_response('credits.html', {'request':request,}, context_instance=RequestContext(request))
def incidents(request): print '-- system logs:', request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/logs/", "logs", ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() return render_to_response('incidents.html', { 'profile': profile, }, context_instance=RequestContext(request))
def user_activity_report(request, user_id): print '-- admin report user activity', user_id #if not request.user.is_superuser: # print 'anonymous' # return HttpResponseRedirect("/") print request.user profile = Profile.objects.get(user=request.user) u = User.objects.get(pk=user_id) ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/admin/user/"+str(user_id)+"/report/","user_activity_report",ip=ip) user_activity = Activity.objects.filter(user=u).order_by('-pk') user_activity_clicks = Activity.objects.filter(user=u,activity="click").order_by('-pk') user_activity_other = Activity.objects.filter(user=u).filter(~Q(activity="click")).order_by('-pk') user_profile = Profile.objects.get(user=u) try: vms_cache = Cache.objects.get(user=u) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response #vms_cached_response['last_seen'] = vms_cache.last_seen except: vms_cached_response = None servers = mongo.servers.find({'secret':user_profile.secret,}).sort('_id',-1) import datetime user = request.user user.last_login = datetime.datetime.now() user.save() return render_to_response('admin_user_report.html', {'u':u,'vms_cached_response':vms_cached_response,'user_profile':user_profile,'user_files':[],'user_activity':user_activity,'user_activity_clicks':user_activity_clicks,'user_activity_other':user_activity_other,'profile':profile,'servers':servers,}, context_instance=RequestContext(request))
def control_aws_vm(request, vm_name, action): print request.user user = request.user profile = userprofile.objects.get(user=request.user) user.last_login = datetime.datetime.now() user.save() ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/aws/"+vm_name+"/"+action+"/","control_aws_vm",ip=ip) vms_cache = Cache.objects.get(user=user) vm_cache = vms_cache.vms_response vm_cache = base64.b64decode(vm_cache) vm_cache = pickle.loads(vm_cache)[vm_name] if(vm_cache['user_id']!=request.user.id): return HttpResponse("access denied") aws_access_key = profile.aws_access_key aws_secret_key = profile.aws_secret_key aws_ec2_verified = profile.aws_ec2_verified ec2_region = vm_cache['instance']['region']['name'] ec2conn = boto.ec2.connect_to_region(ec2_region,aws_access_key_id=aws_access_key,aws_secret_access_key=aws_secret_key) if(action=="reboot"): ec2conn.reboot_instances([vm_name,]) if(action=="start"): ec2conn.start_instances([vm_name,]) if(action=="stop"): ec2conn.stop_instances([vm_name,]) if(action=="terminate"): ec2conn.terminate_instances([vm_name,]) # XXX duplicate, auto-scaling on, auto-scaling off, backup return HttpResponseRedirect("/")
def home(request): if not request.user.is_authenticated(): print '-- web:' return render_to_response('web.html', { 'request': request, }, context_instance=RequestContext(request)) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/", "home", ip=ip) is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None return render_to_response('dashboard.html', { 'is_updating': is_updating, 'vms_cached_response': vms_cached_response, }, context_instance=RequestContext(request))
def home(request): if not request.user.is_authenticated(): print '-- web:' CLOUDLY_MOTTOS = [ "The Power of Now!", "Relax, it’s going to take no time!", "Saves you money and resources!", "Real-time servers monitoring.", ] return render_to_response('web.html', {'request':request,'CLOUDLY_MOTTOS':CLOUDLY_MOTTOS,}, context_instance=RequestContext(request)) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/","home",ip=ip) is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None return render_to_response('dashboard.html', {'is_updating':is_updating,'vms_cached_response':vms_cached_response,}, context_instance=RequestContext(request))
def admin(request): print '-- admin page:' if not request.user.is_staff: return HttpResponseRedirect("/") print request.user users = Profile.objects.all().order_by('-last_seen') profile = Profile.objects.get(user=request.user) import datetime user = request.user user.last_login = datetime.datetime.now() user.save() users = Profile.objects.all().order_by('-pk') ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/admin/","admin",ip=ip) return render_to_response('admin.html', {'users':users,'files':[],'profile':profile,'request':request,}, context_instance=RequestContext(request))
def incidents(request): print "-- system logs:", request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META["REMOTE_ADDR"] _log_user_activity(profile, "click", "/logs/", "logs", ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() servers = mongo.servers.find({"secret": profile.secret}, {"uuid": 1, "name": 1}).sort("_id", -1) serversNames = {} for server in servers: serversNames[server["uuid"]] = server["name"] active_service_statuses = mongo.active_service_statuses active_notifs = {} notifs_types = ["CRITICAL", "WARNING", "UNKNOWN"] for notifs_type in notifs_types: active_notifs[notifs_type] = [] notifs = active_service_statuses.find({"secret": secret, "current_overall_status": notifs_type}) for notif in notifs: notif.update({"name": serversNames[notif["server_id"]]}) active_notifs[notifs_type].append(notif) return render_to_response( "incidents.html", {"request": request, "secret": profile.secret, "active_notifs": active_notifs}, context_instance=RequestContext(request), )
def download_agent(request): print '-- download agent:' server_url = request.build_absolute_uri('/') api_server_url = server_url api_server_url = api_server_url.replace('http://', '').replace('https://', '') api_server_url = api_server_url.split(':')[0].replace('/', '') api_server_url = api_server_url + ":5001" if ('projectcloudly.com' in api_server_url): api_server_url = "api.projectcloudly.com:5001" ip = request.META['REMOTE_ADDR'] try: profile = userprofile.objects.get(user=request.user) except: pass print 'server_url', server_url print 'api_server_url', api_server_url if (request.GET): try: xuuid = request.GET['xuuid'] profile = userprofile.objects.get(agent_hash=xuuid) except: return HttpResponseForbidden() _log_user_activity(profile, "download", "/download/agent/", "download_agent", ip=ip) agent_code = "" for line in open('agent.py'): if ("SECRET = \"\"" in line): agent_code += "SECRET = \"" + profile.secret + "\"\n" continue if ("API_SERVER = \"\"" in line): agent_code += "API_SERVER = \"" + api_server_url + "\"\n" continue agent_code += line return HttpResponse(agent_code) try: agent_download_url = server_url + "download/agent?xuuid=" + profile.agent_hash print 'agent_download_url', agent_download_url except: return HttpResponseRedirect( "https://raw.githubusercontent.com/ProjectCloudly/Cloudly/master/agent.py" ) return render_to_response('agent_download.html', { 'request': request, 'profile': profile, 'agent_download_url': agent_download_url, }, context_instance=RequestContext(request))
def home(request): if not request.user.is_authenticated(): print '-- web:' CLOUDLY_MOTTOS = [ "The Power of Now!", "Relax, it's going to take no time!", "Saves you money and resources!", "Real-time servers monitoring.", "Real-time and very playful monitoring.", "Does the server monitoring for you like no other.", "Cheerful Servers Monitoring.", ] return render_to_response('web.html', { 'request': request, 'CLOUDLY_MOTTOS': CLOUDLY_MOTTOS, }, context_instance=RequestContext(request)) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/", "home", ip=ip) is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None servers = mongo.servers.find({ 'secret': profile.secret, }).sort('_id', -1) servers_tags = {} for server in servers: try: server['tags'] except: break for tag_category in server['tags']: if (not servers_tags.has_key(tag_category)): servers_tags[tag_category] = [] for inner_tag in server['tags'][tag_category]: if (not inner_tag in servers_tags[tag_category]): servers_tags[tag_category].append(inner_tag[0]) # XXX this needs go on the ajax notifs_counter = 0 active_service_statuses = mongo.active_service_statuses active_service_statuses = active_service_statuses.find({ "$and": [{ "secret": secret }, { "current_overall_status": { "$ne": "OK" } }] }) notifs_counter = active_service_statuses.count() return render_to_response('dashboard.html', { 'request': request, 'notifs_counter': notifs_counter, 'servers_tags': servers_tags, 'is_updating': is_updating, 'vms_cached_response': vms_cached_response, }, context_instance=RequestContext(request))
def home(request): if not request.user.is_authenticated(): print '-- web:' CLOUDLY_MOTTOS = [ "The Power of Now!", "Details Matters!", "Bulletproof monitoring out of the box.", "Save time and effort with our simple, reliable server monitoring.", "Get your servers into shape! 100% free for Open Source.", "The only Servers Monitoring that does the Heartbeats!", "Your Servers Heartbeat Visualised.", "Magical Servers Monitoring.", "Monitoring Solution for your Servers.", "Admins and DevOps love it!", "Relax, it's going to take no time!", "Saves you money and resources!", "Real-time servers monitoring.", "Real-time playful monitoring.", "Playful Servers Monitoring.", "Playful Servers Dashboard.", "Does the server monitoring for you.", "Cheerful Posix Servers Monitoring.", "Old School Servers Monitoring.", "Keeps a watchfull eye on your servers.", "The Coolest Servers Monitoring Out There!", "The Coolest Monitoring Out There!", "The Coolest Real-time Monitoring.", "The Ultimate Dashboard for Your Servers.", "The Ultimate Servers Monitoring.", "The Ultimate Servers and Devices Monitoring.", "The Ultimate Servers Dashboard.", "The Ultimate Real-time Servers Monitoring.", "Dreamlike Servers Monitoring.", "OpenTSDB Powered Servers Monitoring.", "Monitor Anything and Everything.", "Monitoring in the snap of a finger.", "An Open Work Monitoring Cloud.", "Servers And Apps Monitoring.", "Servers, Devices and Apps Monitoring.", "Hadoop Powered Servers Monitoring.", "Hadoop & OpenTSDB Powered Servers Monitoring.", "The first line of defence for your servers.", ] return render_to_response('web.html', {'CLOUDLY_MOTTOS':CLOUDLY_MOTTOS,},) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] try: _log_user_activity(profile,"click","/","home",ip=ip) except: pass is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None servers = mongo.servers.find({'secret':profile.secret,}).sort('_id',-1); servers_tags = {} for server in servers: if 'tags' in server: for tag_category in server['tags']: if(not servers_tags.has_key(tag_category)): servers_tags[tag_category] = []; for inner_tag in server['tags'][tag_category]: if(not inner_tag[0] in servers_tags[tag_category]): servers_tags[tag_category].append(inner_tag[0]) return render_to_response( 'dashboard.html', { 'servers_tags':servers_tags, 'is_updating':is_updating, 'vms_cached_response':vms_cached_response, }, context_instance=RequestContext(request) )
def home(request): if not request.user.is_authenticated(): print '-- web:' CLOUDLY_MOTTOS = [ "The Power of Now!", "Relax, it's going to take no time!", "Saves you money and resources!", "Real-time servers monitoring.", "Real-time and very playful monitoring.", "Does the server monitoring for you like no other.", "Cheerful Servers Monitoring.", "Old School Servers Monitoring.", ] return render_to_response('web.html', {'request':request,'CLOUDLY_MOTTOS':CLOUDLY_MOTTOS,}, context_instance=RequestContext(request)) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/","home",ip=ip) is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None servers = mongo.servers.find({'secret':profile.secret,}).sort('_id',-1); servers_tags = {} for server in servers: if 'tags' in server: for tag_category in server['tags']: if(not servers_tags.has_key(tag_category)): servers_tags[tag_category] = []; for inner_tag in server['tags'][tag_category]: if(not inner_tag[0] in servers_tags[tag_category]): servers_tags[tag_category].append(inner_tag[0]) return render_to_response( 'dashboard.html', { 'request':request, 'servers_tags':servers_tags, 'is_updating':is_updating, 'vms_cached_response':vms_cached_response, }, context_instance=RequestContext(request) )
def server_view(request, hwaddr): print '-- server_view' print request.user user = request.user profile = userprofile.objects.get(user=request.user) ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/server/" + hwaddr, "server_view", ip=ip) hwaddr_orig = hwaddr hwaddr = hwaddr.replace('-', ':') server = mongo.servers.find_one({ 'secret': profile.secret, 'uuid': hwaddr, }) server_status = "Running" if ((datetime.datetime.utcnow() - server['last_seen']).total_seconds() > 20): server_status = "Stopped" if ((datetime.datetime.utcnow() - server['last_seen']).total_seconds() > 1800): server_status = "Offline" try: uuid = server['uuid'] except: return HttpResponse("access denied") disks_usage_ = [] #disks_usage = mongo.disks_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in disks_usage: disks_usage_.append(i) disks_usage = disks_usage_ networking_ = [] #networking = mongo.networking.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in networking: networking_.append(i) networking = networking_ mem_usage_ = [] #mem_usage = mongo.memory_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in mem_usage: mem_usage_.append(i) mem_usage = mem_usage_ loadavg_ = [] #loadavg = mongo.loadavg.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in loadavg: loadavg_.append(i) loadavg = loadavg_ activity = mongo.activity.find({ 'uuid': uuid, }).sort('_id', -1).limit(3) disks = [] disks_ = server[u'disks_usage'] for disk in disks_: if not disk[5] in disks: disks.append(disk[5]) return render_to_response('server_detail.html', { 'secret': profile.secret, 'hwaddr': hwaddr, 'hwaddr_orig': hwaddr_orig, 'server': server, 'server_status': server_status, 'disks_usage': disks_usage, 'disks': disks, 'mem_usage': mem_usage, 'loadavg': loadavg, 'networking': networking, 'activity': activity, }, context_instance=RequestContext(request))
def home(request): if not request.user.is_authenticated(): print "-- web:" CLOUDLY_MOTTOS = [ "The Power of Now!", "Relax, it's going to take no time!", "Saves you money and resources!", "Real-time servers monitoring.", "Real-time and very playful monitoring.", "Does the server monitoring for you like no other.", "Cheerful Servers Monitoring.", "Old School Servers Monitoring.", "Keeps a watchfull eye on your servers.", ] return render_to_response( "web.html", {"request": request, "CLOUDLY_MOTTOS": CLOUDLY_MOTTOS}, context_instance=RequestContext(request) ) print "-- dashboard:" print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META["REMOTE_ADDR"] _log_user_activity(profile, "click", "/", "home", ip=ip) is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response["last_seen"] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None servers = mongo.servers.find({"secret": profile.secret}).sort("_id", -1) servers_tags = {} for server in servers: if "tags" in server: for tag_category in server["tags"]: if not servers_tags.has_key(tag_category): servers_tags[tag_category] = [] for inner_tag in server["tags"][tag_category]: if not inner_tag[0] in servers_tags[tag_category]: servers_tags[tag_category].append(inner_tag[0]) return render_to_response( "dashboard.html", { "request": request, "servers_tags": servers_tags, "is_updating": is_updating, "vms_cached_response": vms_cached_response, }, context_instance=RequestContext(request), )
def logs(request): print '-- system logs:', request.user user = request.user profile = Profile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/logs/", "logs", ip=ip) user = request.user user.last_login = datetime.datetime.now() user.save() servers = mongo.servers.find({ 'secret': secret, }) activities = mongo.activity.find({ 'secret': secret, }).sort("_id", pymongo.DESCENDING) activities = activities.limit(300) servers_ = mongo.servers.find({ 'secret': profile.secret }, { 'uuid': 1, 'name': 1 }).sort('_id', -1) serversNames = {} for server in servers_: serversNames[server['uuid']] = server['name'] active_service_statuses = mongo.active_service_statuses active_notifs = {} notifs_types = [ "CRITICAL", "WARNING", "UNKNOWN", ] for notifs_type in notifs_types: active_notifs[notifs_type] = [] notifs = active_service_statuses.find({ "secret": secret, "current_overall_status": notifs_type }) for notif in notifs: notif.update({'name': serversNames[notif['server_id']]}) server = mongo.servers.find_one({ 'uuid': notif['server_id'], }) if ((datetime.datetime.now() - server['last_seen']).total_seconds() < 20): active_notifs[notifs_type].append(notif) # XXX test for offline servers offline_servers = [] for server in mongo.servers.find({ "secret": profile.secret, }): if ((datetime.datetime.now() - server['last_seen']).total_seconds() > 300): offline_servers.append(server) servers = [] for server in mongo.servers.find({ "secret": profile.secret, }): servers.append(server) return render_to_response( 'logs.html', { 'request': request, 'secret': profile.secret, 'servers': servers, 'offline_servers': offline_servers, 'activities': activities, 'active_notifs': active_notifs }, context_instance=RequestContext(request), )
def home(request): if not request.user.is_authenticated(): print '-- web:' CLOUDLY_MOTTOS = [ "The Power of Now!", "Details Matters!", "Get your servers into shape! 100% free for Open Source.", "The only Servers Monitoring that does the Heartbeats!", "Your Servers Heartbeat Visualised.", "Magical Servers Monitoring.", "Monitoring Solution for your Servers.", "Admins and DevOps love it!", "Relax, it's going to take no time!", "Saves you money and resources!", "Real-time servers monitoring.", "Real-time playful monitoring.", "Playful Servers Monitoring.", "Playful Servers Dashboard.", "Does the server monitoring for you.", "Cheerful Posix Servers Monitoring.", "Old School Servers Monitoring.", "Keeps a watchfull eye on your servers.", "The Coolest Servers Monitoring Out There!", "The Coolest Monitoring Out There!", "The Coolest Real-time Monitoring.", "The Ultimate Dashboard for Your Servers.", "The Ultimate Servers Monitoring.", "The Ultimate Servers and Devices Monitoring.", "The Ultimate Servers Dashboard.", "The Ultimate Real-time Servers Monitoring.", "Dreamlike Servers Monitoring.", "OpenTSDB Powered Servers Monitoring.", "Monitor Anything and Everything.", "Monitoring in the snap of a finger.", "An Open Work Monitoring Cloud.", "Servers And Apps Monitoring.", "Servers, Devices and Apps Monitoring.", "Hadoop Powered Servers Monitoring.", "Hadoop & OpenTSDB Powered Servers Monitoring.", "The first line of defence for your servers.", ] return render_to_response('web.html', { 'request': request, 'CLOUDLY_MOTTOS': CLOUDLY_MOTTOS, }, context_instance=RequestContext(request)) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/", "home", ip=ip) is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None servers = mongo.servers.find({ 'secret': profile.secret, }).sort('_id', -1) servers_tags = {} for server in servers: if 'tags' in server: for tag_category in server['tags']: if (not servers_tags.has_key(tag_category)): servers_tags[tag_category] = [] for inner_tag in server['tags'][tag_category]: if (not inner_tag[0] in servers_tags[tag_category]): servers_tags[tag_category].append(inner_tag[0]) return render_to_response('dashboard.html', { 'request': request, 'servers_tags': servers_tags, 'is_updating': is_updating, 'vms_cached_response': vms_cached_response, }, context_instance=RequestContext(request))
def aws_vm_view(request,vm_name): print '-- aws_vm_view' print request.user user = request.user profile = userprofile.objects.get(user=request.user) user.last_login = datetime.datetime.now() user.save() aws_access_key = profile.aws_access_key aws_secret_key = profile.aws_secret_key ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/aws/"+vm_name,"aws_vm_view",ip=ip) vms_cache = Cache.objects.get(user=user) vm_cache = vms_cache.vms_response vm_cache = base64.b64decode(vm_cache) try: vm_cache = pickle.loads(vm_cache)[vm_name] except: return HttpResponse("XXX " + vm_name) ec2_region = vm_cache['instance']['region']['name'] if(vm_cache['user_id']!=request.user.id): return HttpResponse("access denied") if(vms_cache.vms_console_output_cache): console_output = vms_cache.vms_console_output_cache else: aws_access_key = profile.aws_access_key aws_secret_key = profile.aws_secret_key aws_ec2_verified = profile.aws_ec2_verified ec2conn = boto.ec2.connect_to_region(ec2_region,aws_access_key_id=aws_access_key,aws_secret_access_key=aws_secret_key) reservations = ec2conn.get_all_instances(instance_ids=[vm_name,]) instance = reservations[0].instances[0] console_output = instance.get_console_output() console_output = console_output.output if(not console_output): console_output = "" vms_cache.vms_console_output_cache = console_output vms_cache.save() end = datetime.datetime.now() start = end - datetime.timedelta(minutes=60) ec2conn = boto.ec2.connect_to_region(ec2_region,aws_access_key_id=aws_access_key,aws_secret_access_key=aws_secret_key) cloudwatch = boto.ec2.cloudwatch.connect_to_region(ec2_region,aws_access_key_id=aws_access_key,aws_secret_access_key=aws_secret_key) metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="NetworkIn")[0] networkin_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="NetworkOut")[0] networkout_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="DiskReadOps")[0] disk_readops_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="DiskWriteOps")[0] disk_writeops_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="DiskReadBytes")[0] disk_readbytes_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="DiskWriteBytes")[0] disk_writebytes_datapoints = metric.query(start, end, 'Average', '') networkin_datapoints = json.dumps(networkin_datapoints,default=date_handler) networkout_datapoints = json.dumps(networkout_datapoints,default=date_handler) disk_readops_datapoints = json.dumps(disk_readops_datapoints,default=date_handler) disk_writeops_datapoints = json.dumps(disk_writeops_datapoints,default=date_handler) disk_readbytes_datapoints = json.dumps(disk_readbytes_datapoints,default=date_handler) disk_writebytes_datapoints = json.dumps(disk_writebytes_datapoints,default=date_handler) return render_to_response('aws_vm.html', {'vm_name':vm_name,'vm_cache':vm_cache,'console_output':console_output,'networkin_datapoints':networkin_datapoints,'networkout_datapoints':networkout_datapoints,'disk_readops_datapoints':disk_readops_datapoints,'disk_writeops_datapoints':disk_writeops_datapoints,'disk_readbytes_datapoints':disk_readbytes_datapoints,'disk_writebytes_datapoints':disk_writebytes_datapoints,}, context_instance=RequestContext(request))
def server_view(request, hwaddr): print '-- server_view' print request.user user = request.user profile = userprofile.objects.get(user=request.user) ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/server/"+hwaddr,"server_view",ip=ip) hwaddr_orig = hwaddr hwaddr = hwaddr.replace('-',':') server = mongo.servers.find_one({'secret':profile.secret,'uuid':hwaddr,}) server['link'] = '/server/'+hwaddr_orig+'/' server_status = "Running" if((datetime.datetime.now()-server['last_seen']).total_seconds()>20): server_status = "Stopped" if((datetime.datetime.now()-server['last_seen']).total_seconds()>1800): server_status = "Offline" try: uuid = server['uuid'] except: return HttpResponse("access denied") disks_usage_ = [] #disks_usage = mongo.disks_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in disks_usage: disks_usage_.append(i) disks_usage = disks_usage_ networking_ = [] #networking = mongo.networking.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in networking: networking_.append(i) networking = networking_ mem_usage_ = [] #mem_usage = mongo.memory_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in mem_usage: mem_usage_.append(i) mem_usage = mem_usage_ loadavg_ = [] #loadavg = mongo.loadavg.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in loadavg: loadavg_.append(i) loadavg = loadavg_ activity = mongo.activity.find({'uuid':uuid,}).sort('_id',-1).limit(3) disks = [] disks_ = server[u'disks_usage'] for disk in disks_: if not disk[5] in disks: disks.append(disk[5]) reduced_disks = [] for disk in disks: if(disk[:4]!="/run" and disk[:5]!="/boot" and disk[:4]!="/sys" and disk[:4]!="/dev"): reduced_disks.append(disk) historical_service_statuses = mongo.historical_service_statuses historical_service_statuses = historical_service_statuses.find({'secret':profile.secret,'server_id':server['uuid']}) historical_service_statuses = historical_service_statuses.sort("_id",pymongo.DESCENDING) historical_service_statuses = historical_service_statuses.limit(20) try: recently_clicked_servers = request.session["recently_clicked_servers"] except: recently_clicked_servers = [] s_ = {'name':server['name'],'hwaddr':hwaddr,'link':'/server/'+hwaddr.replace(':','-')} if(not s_ in recently_clicked_servers): recently_clicked_servers.append(s_) else: server_to_delete = [i for i,x in enumerate(recently_clicked_servers) if x == s_] del recently_clicked_servers[server_to_delete[0]] recently_clicked_servers.append(s_) request.session["recently_clicked_servers"] = recently_clicked_servers request.session.modified = True services_common = mongo.services_tags.find() services = [] for service in services_common: services.append(service) services_discovered = [] try: server['tags'] except: services_tags = [] for process in server['processes']: for service in services: if(service['process'].lower() in process.lower()): if(not [service['tag'],service['description']] in services_tags): services_tags.append([service['tag'],service['description']]) try: if(not [service['extra_tag'],""] in services_tags): services_tags.append([service['extra_tag'],""]) except: pass server['tags'] = {} server['tags']['tags'] = services_tags server['tags']['datacenters'] = [] if(server['cpu_virtualization']): server['tags']['datacenters'].append(['Metal','Physical HW']) else: pass mongo.servers.update({'secret':server['secret'], 'uuid':server['uuid']}, server) return render_to_response( 'server_detail.html', { 'request':request, 'secret':profile.secret, 'recently_clicked_servers':recently_clicked_servers, 'hwaddr':hwaddr, 'hwaddr_orig':hwaddr_orig, 'server':server, 'server_status':server_status, 'disks_usage':disks_usage, 'disks':disks, 'reduced_disks':reduced_disks, 'mem_usage':mem_usage, 'loadavg':loadavg, 'networking':networking, 'historical_service_statuses':historical_service_statuses, 'activity':activity, }, context_instance=RequestContext(request))
def server_view(request, hwaddr): print '-- server_view' print request.user user = request.user profile = userprofile.objects.get(user=request.user) ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/server/"+hwaddr,"server_view",ip=ip) hwaddr_orig = hwaddr hwaddr = hwaddr.replace('-',':') server = mongo.servers.find_one({'secret':profile.secret,'uuid':hwaddr,}) server['link'] = '/server/'+hwaddr_orig+'/' server_status = "Running" if((datetime.datetime.now()-server['last_seen']).total_seconds()>20): server_status = "Stopped" if((datetime.datetime.now()-server['last_seen']).total_seconds()>300): server_status = "Offline" try: uuid = server['uuid'] except: return HttpResponse("access denied") networking_graph__enable = False params = {'start':'3m-ago','m':'avg:3s-avg:' + hwaddr.replace(':','-') + '.sys.network'} tsdb = requests.get('http://'+settings.TSDB_HOST+':'+str(settings.TSDB_PORT)+'/api/query',params=params) tsdb_response = json.loads(tsdb.text) if(not "error" in tsdb_response and tsdb_response): networking_graph__enable = tsdb_response mem_usage_ = [] #mem_usage = mongo.memory_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in mem_usage: mem_usage_.append(i) mem_usage = mem_usage_ loadavg_ = [] #loadavg = mongo.loadavg.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in loadavg: loadavg_.append(i) loadavg = loadavg_ disks = [] disks_ = server[u'disks_usage'] for disk in disks_: if not disk[5] in disks: disks.append(disk[5]) reduced_disks = [] for disk in disks: if(disk[:4]!="/run" and disk[:5]!="/boot" and disk[:4]!="/sys" and disk[:4]!="/dev"): reduced_disks.append(disk) historical_service_statuses = mongo.historical_service_statuses historical_service_statuses = historical_service_statuses.find({'secret':profile.secret,'server_id':server['uuid'],'type':'status',}) activity_cummulative_types = [] for event in historical_service_statuses: if not event["service"] in activity_cummulative_types: activity_cummulative_types.append(event["service"]) historical_service_statuses = mongo.historical_service_statuses historical_service_statuses = historical_service_statuses.find({'secret':profile.secret,'server_id':server['uuid'],'type':'status',}) historical_service_statuses = historical_service_statuses.sort("_id",pymongo.DESCENDING) historical_service_statuses = historical_service_statuses.limit(20) activity = mongo.historical_service_statuses activity = activity.find({'secret':profile.secret,'server_id':server['uuid'],'type':'activity',}) activity = activity.sort("_id",pymongo.DESCENDING) activity = activity.limit(20) try: recently_clicked_servers = request.session["recently_clicked_servers"] except: recently_clicked_servers = [] s_ = {'name':server['name'],'hwaddr':hwaddr,'link':'/server/'+hwaddr.replace(':','-')} if(not s_ in recently_clicked_servers): recently_clicked_servers.append(s_) else: server_to_delete = [i for i,x in enumerate(recently_clicked_servers) if x == s_] del recently_clicked_servers[server_to_delete[0]] recently_clicked_servers.append(s_) request.session["recently_clicked_servers"] = recently_clicked_servers request.session.modified = True services_common = mongo.services_tags.find() services = [] for service in services_common: services.append(service) services_discovered = [] try: server['tags'] except: services_tags = [] for process in server['processes']: for service in services: if(service['process'].lower() in process.lower()): if(not [service['tag'],service['description']] in services_tags): services_tags.append([service['tag'],service['description']]) try: if(not [service['extra_tag'],""] in services_tags): services_tags.append([service['extra_tag'],""]) except: pass server['tags'] = {} server['tags']['tags'] = services_tags server['tags']['datacenters'] = [] if(server['cpu_virtualization']): server['tags']['datacenters'].append(['Metal','Physical Office HW']) else: pass mongo.servers.update({'secret':server['secret'], 'uuid':server['uuid']}, server) active_service_statuses = mongo.active_service_statuses notifs = active_service_statuses.find({"$and":[{"secret": profile.secret,"server_id":server['uuid']},{"current_overall_status":{"$ne":"OK"}}]}) server_notifs_count = notifs.count() for line in open('agent.py','rt').readlines(): if('AGENT_VERSION' in line): AGENT_VERSION_CURRENT = line.split('"')[1] break is_outdated_agent_version = False if(server['agent_version'] != AGENT_VERSION_CURRENT): is_outdated_agent_version = True return render_to_response( 'server_detail.html', { 'request':request, 'secret':profile.secret, 'recently_clicked_servers':recently_clicked_servers, 'hwaddr':hwaddr, 'hwaddr_orig':hwaddr_orig, 'server':server, 'server_status':server_status, 'disks':disks, 'reduced_disks':reduced_disks, 'mem_usage':mem_usage, 'loadavg':loadavg, 'disks':disks, 'networking_graph__enable':networking_graph__enable, 'historical_service_statuses':historical_service_statuses, 'activity':activity, 'activity_cummulative_types':activity_cummulative_types, 'server_notifs_count':server_notifs_count, 'is_outdated_agent_version':is_outdated_agent_version, 'notifs':notifs, }, context_instance=RequestContext(request))
def server_view(request, hwaddr): print '-- server_view' print request.user user = request.user profile = userprofile.objects.get(user=request.user) ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/server/"+hwaddr,"server_view",ip=ip) hwaddr_orig = hwaddr hwaddr = hwaddr.replace('-',':') server = mongo.servers.find_one({'secret':profile.secret,'uuid':hwaddr,}) server['link'] = '/server/'+hwaddr_orig+'/' server_status = "Running" if((datetime.datetime.now()-server['last_seen']).total_seconds()>20): server_status = "Stopped" if((datetime.datetime.now()-server['last_seen']).total_seconds()>300): server_status = "Offline" try: uuid = server['uuid'] except: return HttpResponse("access denied") disks_usage_ = [] #disks_usage = mongo.disks_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in disks_usage: disks_usage_.append(i) disks_usage = disks_usage_ networking_ = [] #networking = mongo.networking.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in networking: networking_.append(i) networking = networking_ mem_usage_ = [] #mem_usage = mongo.memory_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in mem_usage: mem_usage_.append(i) mem_usage = mem_usage_ loadavg_ = [] #loadavg = mongo.loadavg.find({'uuid':uuid,}).sort('_id',-1).limit(60) #for i in loadavg: loadavg_.append(i) loadavg = loadavg_ activity = mongo.activity.find({'uuid':uuid,}).sort('_id',-1).limit(3) disks = [] disks_ = server[u'disks_usage'] for disk in disks_: if not disk[5] in disks: disks.append(disk[5]) reduced_disks = [] for disk in disks: if(disk[:4]!="/run" and disk[:5]!="/boot" and disk[:4]!="/sys" and disk[:4]!="/dev"): reduced_disks.append(disk) historical_service_statuses = mongo.historical_service_statuses historical_service_statuses = historical_service_statuses.find({'secret':profile.secret,'server_id':server['uuid'],'type':'status',}) historical_service_statuses = historical_service_statuses.sort("_id",pymongo.DESCENDING) historical_service_statuses = historical_service_statuses.limit(20) try: recently_clicked_servers = request.session["recently_clicked_servers"] except: recently_clicked_servers = [] s_ = {'name':server['name'],'hwaddr':hwaddr,'link':'/server/'+hwaddr.replace(':','-')} if(not s_ in recently_clicked_servers): recently_clicked_servers.append(s_) else: server_to_delete = [i for i,x in enumerate(recently_clicked_servers) if x == s_] del recently_clicked_servers[server_to_delete[0]] recently_clicked_servers.append(s_) request.session["recently_clicked_servers"] = recently_clicked_servers request.session.modified = True services_common = mongo.services_tags.find() services = [] for service in services_common: services.append(service) services_discovered = [] try: server['tags'] except: services_tags = [] for process in server['processes']: for service in services: if(service['process'].lower() in process.lower()): if(not [service['tag'],service['description']] in services_tags): services_tags.append([service['tag'],service['description']]) try: if(not [service['extra_tag'],""] in services_tags): services_tags.append([service['extra_tag'],""]) except: pass server['tags'] = {} server['tags']['tags'] = services_tags server['tags']['datacenters'] = [] if(server['cpu_virtualization']): server['tags']['datacenters'].append(['Metal','Physical Office HW']) else: pass mongo.servers.update({'secret':server['secret'], 'uuid':server['uuid']}, server) active_service_statuses = mongo.active_service_statuses notifs = active_service_statuses.find({"$and":[{"secret": profile.secret,"server_id":server['uuid']},{"current_overall_status":{"$ne":"OK"}}]}) server_notifs_count = notifs.count() for line in open('agent.py','rt').readlines(): if('AGENT_VERSION' in line): AGENT_VERSION_CURRENT = line.split('"')[1] break is_outdated_agent_version = False if(server['agent_version'] != AGENT_VERSION_CURRENT): is_outdated_agent_version = True return render_to_response( 'server_detail.html', { 'request':request, 'secret':profile.secret, 'recently_clicked_servers':recently_clicked_servers, 'hwaddr':hwaddr, 'hwaddr_orig':hwaddr_orig, 'server':server, 'server_status':server_status, 'disks_usage':disks_usage, 'disks':disks, 'reduced_disks':reduced_disks, 'mem_usage':mem_usage, 'loadavg':loadavg, 'networking':networking, 'historical_service_statuses':historical_service_statuses, 'activity':activity, 'server_notifs_count':server_notifs_count, 'is_outdated_agent_version':is_outdated_agent_version, 'notifs':notifs, }, context_instance=RequestContext(request))
def home(request): if not request.user.is_authenticated(): print '-- web:' CLOUDLY_MOTTOS = [ "The Power of Now!", "Relax, it's going to take no time!", "Saves you money and resources!", "Real-time servers monitoring.", "Real-time and very playful monitoring.", "Playful Servers Monitoring.", "Playful Servers Dashboard.", "Does the server monitoring for you like no other.", "Cheerful Servers Monitoring.", "Old School Servers Monitoring.", "Keeps a watchfull eye on your servers.", "The Coolest Servers Monitoring Out There!", "The Coolest Monitoring Out There!", "The Coolest Real-time Monitoring.", "The Ultimate Dashboard for Your Servers.", "The Ultimate Servers Monitoring.", "The Ultimate Servers and Devices Monitoring.", "The Ultimate Servers Dashboard.", "The Ultimate Real-time Servers Monitoring.", "Dreamlike Servers Monitoring", ] return render_to_response('web.html', { 'request': request, 'CLOUDLY_MOTTOS': CLOUDLY_MOTTOS, }, context_instance=RequestContext(request)) print '-- dashboard:' print request.user user = request.user user.last_login = datetime.datetime.now() user.save() profile = userprofile.objects.get(user=request.user) secret = profile.secret ip = request.META['REMOTE_ADDR'] _log_user_activity(profile, "click", "/", "home", ip=ip) is_updating = False try: vms_cache = Cache.objects.get(user=request.user) vms_response = vms_cache.vms_response vms_response = base64.b64decode(vms_response) vms_response = pickle.loads(vms_response) vms_cached_response = vms_response vms_cached_response['last_seen'] = vms_cache.last_seen is_updating = vms_cache.is_updating except: vms_cached_response = None servers = mongo.servers.find({ 'secret': profile.secret, }).sort('_id', -1) servers_tags = {} for server in servers: if 'tags' in server: for tag_category in server['tags']: if (not servers_tags.has_key(tag_category)): servers_tags[tag_category] = [] for inner_tag in server['tags'][tag_category]: if (not inner_tag[0] in servers_tags[tag_category]): servers_tags[tag_category].append(inner_tag[0]) return render_to_response('dashboard.html', { 'request': request, 'servers_tags': servers_tags, 'is_updating': is_updating, 'vms_cached_response': vms_cached_response, }, context_instance=RequestContext(request))
def server_view(request, hwaddr): print '-- server_view' print request.user user = request.user profile = userprofile.objects.get(user=request.user) ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/server/"+hwaddr,"server_view",ip=ip) hwaddr = hwaddr.replace('-',':') server = mongo.servers.find_one({'secret':profile.secret,'uuid':hwaddr,}) try: uuid = server['uuid'] except: return HttpResponse("access denied") cpu_usage = mongo.cpu_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) loadavg = mongo.loadavg.find({'uuid':uuid,}).sort('_id',-1).limit(60) mem_usage = mongo.memory_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) disks_usage = mongo.disks_usage.find({'uuid':uuid,}).sort('_id',-1).limit(60) activity = mongo.activity.find({'uuid':uuid,}).sort('_id',-1).limit(3) server_status = "Running" if((datetime.datetime.utcnow()-server['last_seen']).total_seconds()>20): server_status = "Stopped" if((datetime.datetime.utcnow()-server['last_seen']).total_seconds()>1800): server_status = "Offline" processes_ = [] processes = server['processes'] c=0 for line in processes: if(c>0): if not line:break line = line.split(' ') line_ = [] for i in line: if i: line_.append(i) line = line_ process_user = line[0] process_pid = line[1] process_cpu = line[2] process_mem = line[3] process_vsz = line[4] process_rss = line[5] process_tty = line[6] process_stat = line[7] process_start_time = line[8]+'-'+line[9] process_command = line[10:] process_name = "" # XXX work in process name process = { 'user': process_user, 'pid': process_pid, 'cpu': process_cpu, 'mem': process_mem, 'vsz': process_vsz, 'rss': process_rss, 'tty': process_tty, 'stat': process_stat, 'start_time': process_start_time, 'command': process_command, 'name': process_name, } processes_.append(process) c+=1 processes = processes_ loadavg_ = [] for i in loadavg: loadavg_.append(i) loadavg = loadavg_ #mem_usage_ = [] #for i in mem_usage: mem_usage_.append(i) #mem_usage = mem_usage_ disks_usage_ = [] for i in disks_usage: disks_usage_.append(i) disks_usage = disks_usage_ return render_to_response('server_detail.html', {'hwaddr':hwaddr,'server':server,'server_status':server_status,'processes':processes,'cpu_usage':cpu_usage,'loadavg':loadavg,'mem_usage':mem_usage,'disks_usage':disks_usage,'activity':activity,}, context_instance=RequestContext(request))
def aws_vm_view(request,vm_name): print '-- aws_vm_view' print request.user user = request.user profile = userprofile.objects.get(user=request.user) user.last_login = datetime.datetime.now() user.save() aws_access_key = profile.aws_access_key aws_secret_key = profile.aws_secret_key ip = request.META['REMOTE_ADDR'] _log_user_activity(profile,"click","/aws/"+vm_name,"aws_vm_view",ip=ip) vms_cache = Cache.objects.get(user=user) vm_cache = vms_cache.vms_response vm_cache = base64.b64decode(vm_cache) try: vm_cache = pickle.loads(vm_cache)[vm_name] except: return HttpResponse(vm_name) ec2_region = vm_cache['instance']['region']['name'] if(vm_cache['user_id']!=request.user.id): return HttpResponse("access denied") if(vms_cache.vms_console_output_cache): console_output = vms_cache.vms_console_output_cache else: aws_access_key = profile.aws_access_key aws_secret_key = profile.aws_secret_key aws_ec2_verified = profile.aws_ec2_verified ec2conn = boto.ec2.connect_to_region(ec2_region,aws_access_key_id=aws_access_key,aws_secret_access_key=aws_secret_key) reservations = ec2conn.get_all_instances(instance_ids=[vm_name,]) instance = reservations[0].instances[0] console_output = instance.get_console_output() console_output = console_output.output if(not console_output): console_output = "" vms_cache.vms_console_output_cache = console_output vms_cache.save() end = datetime.datetime.now() start = end - datetime.timedelta(minutes=60) ec2conn = boto.ec2.connect_to_region(ec2_region,aws_access_key_id=aws_access_key,aws_secret_access_key=aws_secret_key) cloudwatch = boto.ec2.cloudwatch.connect_to_region(ec2_region,aws_access_key_id=aws_access_key,aws_secret_access_key=aws_secret_key) metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="NetworkIn")[0] networkin_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="NetworkOut")[0] networkout_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="DiskReadOps")[0] disk_readops_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="DiskWriteOps")[0] disk_writeops_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="DiskReadBytes")[0] disk_readbytes_datapoints = metric.query(start, end, 'Average', '') metric = cloudwatch.list_metrics(dimensions={'InstanceId':vm_cache['id']}, metric_name="DiskWriteBytes")[0] disk_writebytes_datapoints = metric.query(start, end, 'Average', '') networkin_datapoints = json.dumps(networkin_datapoints,default=date_handler) networkout_datapoints = json.dumps(networkout_datapoints,default=date_handler) disk_readops_datapoints = json.dumps(disk_readops_datapoints,default=date_handler) disk_writeops_datapoints = json.dumps(disk_writeops_datapoints,default=date_handler) disk_readbytes_datapoints = json.dumps(disk_readbytes_datapoints,default=date_handler) disk_writebytes_datapoints = json.dumps(disk_writebytes_datapoints,default=date_handler) return render_to_response( 'aws_vm.html', { 'vm_name':vm_name, 'vm_cache':vm_cache, 'console_output':console_output, 'networkin_datapoints':networkin_datapoints, 'networkout_datapoints':networkout_datapoints, 'disk_readops_datapoints':disk_readops_datapoints, 'disk_writeops_datapoints':disk_writeops_datapoints, 'disk_readbytes_datapoints':disk_readbytes_datapoints, 'disk_writebytes_datapoints':disk_writebytes_datapoints, }, context_instance=RequestContext(request))