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))
