def mem_report(request, machine_category_id=settings.DEFAULT_MC):
machine_category = get_object_or_404(MachineCategory, pk=machine_category_id)
start, end = get_date_range(request)
job_list = CPUJob.objects.filter(date__gte=start, date__lte=end, machine__category=machine_category)
mem_0_4 = job_list.filter(mem__lte=4 * 1024 * 1024).count()
mem_4_8 = job_list.filter(mem__gt=4 * 1024 * 1024, mem__lte=8 * 1024 * 1024).count()
mem_8_16 = job_list.filter(mem__gt=8 * 1024 * 1024, mem__lte=16 * 1024 * 1024).count()
mem_16_32 = job_list.filter(mem__gt=16 * 1024 * 1024, mem__lte=32 * 1024 * 1024).count()
mem_32_64 = job_list.filter(mem__gt=32 * 1024 * 1024, mem__lte=64 * 1024 * 1024).count()
mem_64_128 = job_list.filter(mem__gt=64 * 1024 * 1024, mem__lte=128 * 1024 * 1024).count()
mem_128 = job_list.filter(mem__gt=128 * 1024 * 1024).count()
data = [mem_0_4, mem_4_8, mem_8_16, mem_16_32, mem_32_64, mem_64_128, mem_128]
total = sum(data)
x_labels = ['0-4', '4-8', '8-16', '16-32', '32-64', '64-128', '128+']
labels = []
max_y = max(data)
data = {'Total jobs': data}
g = GraphGenerator()
graph = g.bar_chart(data, x_labels, max_y, bar_width=50).get_url()
return render_to_response('usage/mem_report.html', locals(), context_instance=RequestContext(request))
def institute_users(request, institute_id, machine_category_id=1):
machine_category = MachineCategory.objects.get(pk=machine_category_id)
institute = get_object_or_404(Institute, pk=institute_id)
if not institute.can_view(request.user) and not getattr(settings, 'USAGE_IS_PUBLIC', False):
return HttpResponseForbidden('<h1>Access Denied</h1>')
start, end = get_date_range(request)
available_time, cpus = get_available_time(start, end, machine_category)
user_list = []
user_total, user_total_jobs = 0, 0
for u in UserCache.objects.order_by('-cpu_hours').filter(start=start, end=end).filter(project__machine_categories=machine_category).filter(user__institute=institute).filter(no_jobs__gt=0):
user_total = user_total + u.cpu_hours
user_total_jobs = user_total_jobs + u.no_jobs
user_list.append({'user': u.user, 'project': u.project, 'usage': u.cpu_hours, 'jobs': u.no_jobs, 'percent': ((u.cpu_hours / available_time) * 100)})
try:
user_percent = (user_total / available_time) * 100
except:
user_percent = 0
querystring = request.META.get('QUERY_STRING', '')
return render_to_response('usage/institute_users.html', locals(), context_instance=RequestContext(request))
def core_report(request, machine_category_id=settings.DEFAULT_MC):
machine_category = get_object_or_404(MachineCategory, pk=machine_category_id)
start, end = get_date_range(request)
job_list = CPUJob.objects.filter(date__gte=start, date__lte=end, machine__category=machine_category)
core_1 = job_list.filter(cores=1).count()
core_2_4 = job_list.filter(cores__gte=2, cores__lte=4).count()
core_5_8 = job_list.filter(cores__gte=5, cores__lte=8).count()
core_9_16 = job_list.filter(cores__gte=9, cores__lte=16).count()
core_17_32 = job_list.filter(cores__gte=17, cores__lte=32).count()
core_33_64 = job_list.filter(cores__gte=33, cores__lte=64).count()
core_65_128 = job_list.filter(cores__gte=65, cores__lte=128).count()
core_128 = job_list.filter(cores__gte=128).count()
data = [core_1, core_2_4, core_5_8, core_9_16, core_17_32, core_33_64, core_65_128, core_128]
total = sum(data)
x_labels = ['1', '2-4', '5-8', '9-16', '17-32', '33-64', '65-128', '128+']
max_y = max(data)
data = {'Total jobs': data}
g = GraphGenerator()
graph = g.bar_chart(data, x_labels, max_y, bar_width=50).get_url()
return render_to_response('usage/core_report.html', locals(), context_instance=RequestContext(request))
def usage_index(request):
mc_list = MachineCategory.objects.all()
start, end = get_date_range(request)
querystring = request.META.get('QUERY_STRING', '')
return render_to_response('usage/mc_list.html', locals(), context_instance=RequestContext(request))
def project_usage(request, project_id, machine_category_id=settings.DEFAULT_MC):
machine_category = get_object_or_404(MachineCategory, pk=machine_category_id)
project = get_object_or_404(Project, pk=project_id)
if not project.can_view(request.user) and not getattr(settings, 'USAGE_IS_PUBLIC', False):
return HttpResponseForbidden('<h1>Access Denied</h1>')
if project.machine_categories.count() == 1:
machine_category = project.machine_categories.all()[0]
usage_list = []
total, total_jobs = 0, 0
querystring = request.META.get('QUERY_STRING', '')
start, end = get_date_range(request)
start_str = start.strftime('%Y-%m-%d')
end_str = end.strftime('%Y-%m-%d')
mc_ids = tuple([(int(m.id)) for m in machine_category.machine_set.all()])
if len(mc_ids) == 1:
mc_ids = "(%i)" % mc_ids[0]
# Custom SQL as need to get users that were removed from project too
cursor = connection.cursor()
sql = "SELECT user_id from cpu_job where project_id = '%s' and `machine_id` IN %s AND `date` >= '%s' AND `date` <= '%s' GROUP BY user_id" % (str(project.pid), mc_ids, start_str, end_str)
cursor.execute(sql)
rows = list(cursor.fetchall())
cursor.close()
for uid in rows:
u = UserAccount.objects.get(id=uid[0]).user
time, jobs = u.get_usage(project, start, end)
if time:
total += time
total_jobs += jobs
if jobs > 0:
usage_list.append({'user': u, 'usage': time, 'jobs': jobs})
for u in usage_list:
if total == 0:
u['percent'] = 0
else:
u['percent'] = (u['usage'] / total) * 100
usage_list = dictsortreversed(usage_list, 'usage')
count = 0
for i in usage_list:
i['colour'] = get_colour(count)
count += 1
graph = get_project_trend_graph_url(project, start, end, machine_category)
return render_to_response('usage/project_usage.html', locals(), context_instance=RequestContext(request))
def user_job_list(request, username):
today = datetime.date.today()
start = today - datetime.timedelta(days=7)
person = get_object_or_404(Person, user__username=username)
start, end = get_date_range(request, start, today)
job_list = []
for ua in person.useraccount_set.all():
job_list.extend(ua.cpujob_set.filter(date__range=(start, end)))
return render_to_response('users/job_list.html', locals(), context_instance=RequestContext(request))
def version_stats(request, package_id, version_id):
version = get_object_or_404(SoftwareVersion, pk=version_id)
start, end = get_date_range(request)
querystring = request.META.get('QUERY_STRING', '')
person_stats = Person.objects.filter(useraccount__cpujob__software=version, useraccount__cpujob__date__range=(start, end)).annotate(jobs=Count('useraccount__cpujob'), usage=Sum('useraccount__cpujob__cpu_usage'))
context = {
'version': version,
'person_stats': person_stats,
'start': start,
'end': end,
'querystring': querystring,
}
return render_to_response('software/version_stats.html', context, context_instance=RequestContext(request))
def top_users(request, machine_category_id=settings.DEFAULT_MC, count=20):
machine_category = MachineCategory.objects.get(pk=machine_category_id)
start, end = get_date_range(request)
available_time, cpus = get_available_time(start, end, machine_category)
user_list = []
user_total, user_total_jobs = 0, 0
for u in UserCache.objects.order_by('-cpu_hours').filter(start=start, end=end).filter(project__machine_categories=machine_category)[:count]:
if u.cpu_hours:
user_total += u.cpu_hours
user_total_jobs += u.no_jobs
user_list.append({'user': u.user, 'project': u.project, 'usage': u.cpu_hours, 'jobs': u.no_jobs, 'percent': ((u.cpu_hours / available_time) * 100)})
user_percent = (user_total / available_time) * 100
querystring = request.META.get('QUERY_STRING', '')
return render_to_response('usage/top_users.html', locals(), context_instance=RequestContext(request))
def profile(request):
person = request.user.get_profile()
project_list = person.project_set.all()
project_requests = []
user_applications = []
start, end = get_date_range(request)
if person.is_leader():
leader = True
leader_project_list = Project.objects.filter(leaders=person, is_active=True)
for project in leader_project_list:
for user_application in project.userapplication_set.filter(state=Application.WAITING_FOR_LEADER):
user_applications.append(user_application)
usage_list = person.usercache_set.filter(start=start, end=end)
return render_to_response('people/profile.html', locals(), context_instance=RequestContext(request))
def software_stats(request, package_id):
package = get_object_or_404(SoftwarePackage, pk=package_id)
start, end = get_date_range(request)
querystring = request.META.get('QUERY_STRING', '')
if package.softwareversion_set.count() == 1:
return HttpResponseRedirect(reverse('kg_softwareversion_stats', args=[package.id, package.softwareversion_set.all()[0].id]))
version_stats = SoftwareVersion.objects.filter(package=package, cpujob__date__range=(start, end)).annotate(jobs=Count('cpujob'), usage=Sum('cpujob__cpu_usage')).filter(usage__isnull=False)
version_totaljobs = version_stats.aggregate(Sum('jobs'))['jobs__sum']
#version_totalusage = version_stats.aggregate(Sum('usage'))
person_stats = Person.objects.filter(useraccount__cpujob__software__package=package, useraccount__cpujob__date__range=(start, end)).annotate(jobs=Count('useraccount__cpujob'), usage=Sum('useraccount__cpujob__cpu_usage'))
context = {
'package': package,
'version_stats': version_stats,
'version_totaljobs': version_totaljobs,
'person_stats': person_stats,
'start': start,
'end': end,
'querystring': querystring,
}
return render_to_response('software/software_stats.html', context, context_instance=RequestContext(request))
def index(request, machine_category_id=settings.DEFAULT_MC):
if not getattr(settings, 'USAGE_IS_PUBLIC', False):
return HttpResponseForbidden('<h1>Access Denied</h1>')
machine_category = get_object_or_404(MachineCategory, pk=machine_category_id)
mc_list = MachineCategory.objects.exclude(id__exact=settings.DEFAULT_MC)
show_zeros = True
institute_list = Institute.active.all()
total, total_jobs = 0, 0
i_list = []
m_list = []
start, end = get_date_range(request)
querystring = request.META.get('QUERY_STRING', '')
available_time, avg_cpus = get_available_time(start, end, machine_category)
for m in machine_category.machine_set.all():
time, jobs = m.get_usage(start, end)
if time is None:
time = 0
if jobs > 0:
m_list.append({'machine': m, 'usage': time, 'jobs': jobs})
for i in institute_list:
time, jobs = i.get_usage(start, end, machine_category)
if time is None:
time = 0
total = total + time
total_jobs = total_jobs + jobs
try:
quota = InstituteChunk.objects.get(institute=i, machine_category=machine_category)
display_quota = quota.quota
except InstituteChunk.DoesNotExist:
display_quota = None
if display_quota or jobs > 0:
data_row = {'institute': i, 'usage': time, 'jobs': jobs, 'quota': display_quota}
try:
data_row['percent'] = Decimal(time) / Decimal(available_time) * 100
except ZeroDivisionError:
data_row['percent'] = 0
if data_row['quota'] is not None:
try:
data_row['p_used'] = (data_row['percent'] / data_row['quota']) * 100
except ZeroDivisionError:
data_row['p_used'] = 0
data_row['diff'] = data_row['percent'] - data_row['quota']
if data_row['diff'] <= 0:
data_row['class'] = 'green'
else:
data_row['class'] = 'red'
else:
data_row['class'] = 'green'
i_list.append(data_row)
# Unused Entry
unused = {'usage': available_time - total, 'quota': 0}
try:
unused['percent'] = (unused['usage'] / available_time) * 100
except ZeroDivisionError:
unused['percent'] = 0
unused['diff'] = unused['percent'] - unused['quota'] / 100
if unused['diff'] <= 0:
unused['class'] = 'green'
else:
unused['class'] = 'red'
try:
utilization = (Decimal(total) / available_time) * 100
except ZeroDivisionError:
utilization = 0
except:
utilization = 0
try:
graph = get_institute_graph_url(start, end, machine_category)
trend_graph = get_trend_graph_url(start, end, machine_category)
except:
pass
return render_to_response('usage/usage_institue_list.html', locals(), context_instance=RequestContext(request))
def institute_trends(request):
start, end = get_date_range(request)
graph_list = get_institutes_trend_graph_urls(start, end)
return render_to_response('usage/institute_trends.html', locals(), context_instance=RequestContext(request))
def institute_usage(request, institute_id, machine_category_id=settings.DEFAULT_MC):
machine_category = get_object_or_404(MachineCategory, pk=machine_category_id)
institute = get_object_or_404(Institute, pk=institute_id)
project_list = []
start, end = get_date_range(request)
institute_list = Institute.active.all()
if not institute.can_view(request.user) and not getattr(settings, 'USAGE_IS_PUBLIC', False):
return HttpResponseForbidden('<h1>Access Denied</h1>')
available_usage, ave_cpus = get_available_time(start, end, machine_category)
querystring = request.META.get('QUERY_STRING', '')
quota = get_object_or_404(InstituteChunk, institute=institute, machine_category=machine_category)
i_usage, i_jobs = institute.get_usage(start, end, machine_category)
if i_jobs > 0:
for p in institute.project_set.filter(machine_categories=machine_category):
p_usage, p_jobs = p.get_usage(start, end, machine_category)
chunk, created = p.projectchunk_set.get_or_create(machine_category=machine_category)
if p_jobs > 0:
mpots = chunk.get_mpots()
if mpots:
try:
percent = (mpots / chunk.get_cap()) * 100
except ZeroDivisionError:
percent = 0
else:
percent = 0
try:
quota_percent = p_usage / (available_usage * quota.quota) * 10000
except:
quota_percent = 0
project_list.append(
{'project': p,
'usage': p_usage,
'jobs': p_jobs,
'percent': percent,
'quota_percent': quota_percent,
})
user_list = []
user_total, user_total_jobs = 0, 0
if i_usage:
for u in UserCache.objects.order_by('-cpu_hours').filter(start=start, end=end).filter(project__institute=institute).filter(project__machine_categories=machine_category)[:5]:
if not u.cpu_hours:
continue
user_total += u.cpu_hours
user_total_jobs += u.no_jobs
try:
quota_percent = u.cpu_hours / (available_usage * quota.quota) * 10000
except ZeroDivisionError:
quota_percent = 0
user_list.append(
{'user': u.user,
'project': u.project,
'usage': u.cpu_hours,
'jobs': u.no_jobs,
'percent': ((u.cpu_hours / i_usage) * 100),
'quota_percent': quota_percent,
})
user_percent = (user_total / i_usage) * 100
graph = get_institute_trend_graph_url(institute, start, end, machine_category)
return render_to_response('usage/usage_institute_detail.html', locals(), context_instance=RequestContext(request))
