def institute_users(request, machine_category_id, institute_id): result = progress(request) if result is not None: return result machine_category = get_object_or_404( MachineCategory, pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_machine_category( request, start, end, machine_category) if result is not None: return render( template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) institute = get_object_or_404(Institute, pk=institute_id) if (not institute.can_view(request) and not getattr(settings, 'USAGE_IS_PUBLIC', False)): return HttpResponseForbidden('<h1>Access Denied</h1>') start, end = get_date_range(request) mc_cache = usage.get_machine_category_usage(machine_category, start, end) available_time = mc_cache.available_time person_list = [] query = models.PersonCache.objects.filter( date=datetime.date.today(), start=start, end=end, machine_category=machine_category, person__institute=institute, no_jobs__gt=0) person_total, person_total_jobs = 0, 0 for u in query.order_by('-cpu_time'): person_total = person_total + u.cpu_time person_total_jobs = person_total_jobs + u.no_jobs person_list.append({ 'person': u.person, 'project': u.project, 'usage': u.cpu_time, 'jobs': u.no_jobs, 'percent': ((u.cpu_time / available_time) * 100), }) if available_time != 0: person_percent = (person_total / available_time) * 100 else: person_percent = 0 return render( template_name='kgusage/institute_users.html', context=locals(), request=request)
def institute_users(request, machine_category_id, institute_id): result = progress(request) if result is not None: return result machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end, machine_category) if result is not None: return render_to_response('kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) institute = get_object_or_404(Institute, pk=institute_id) if (not institute.can_view(request) and not getattr(settings, 'USAGE_IS_PUBLIC', False)): return HttpResponseForbidden('<h1>Access Denied</h1>') start, end = get_date_range(request) mc_cache = usage.get_machine_category_usage(machine_category, start, end) available_time = mc_cache.available_time person_list = [] query = models.PersonCache.objects.filter( date=datetime.date.today(), start=start, end=end, machine_category=machine_category, person__institute=institute, no_jobs__gt=0) person_total, person_total_jobs = 0, 0 for u in query.order_by('-cpu_time'): person_total = person_total + u.cpu_time person_total_jobs = person_total_jobs + u.no_jobs person_list.append({ 'person': u.person, 'project': u.project, 'usage': u.cpu_time, 'jobs': u.no_jobs, 'percent': ((u.cpu_time / available_time) * 100), }) if available_time != 0: person_percent = (person_total / available_time) * 100 else: person_percent = 0 return render_to_response('kgusage/institute_users.html', locals(), context_instance=RequestContext(request))
def mem_report(request): start, end = get_date_range(request) job_list = CPUJob.objects.filter(date__gte=start, date__lte=end) 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(template_name='kgusage/mem_report.html', context=locals(), request=request)
def core_report(request): start, end = get_date_range(request) job_list = CPUJob.objects.filter(date__gte=start, date__lte=end) 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(template_name='kgusage/core_report.html', context=locals(), request=request)
def core_report(request, machine_category_id): 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('kgusage/core_report.html', locals(), context_instance=RequestContext(request))
def software_stats(request, software_id): software = get_object_or_404(Software, pk=software_id) start, end = get_date_range(request) querystring = request.META.get('QUERY_STRING', '') if software.softwareversion_set.count() == 1: sv = software.softwareversion_set.all()[0] url = reverse('kg_software_version_stats', args=[sv.id]) return HttpResponseRedirect(url) version_stats = SoftwareVersion.objects \ .filter(software=software, 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(account__cpujob__software__software=software, account__cpujob__date__range=(start, end)) \ .annotate(jobs=Count('account__cpujob'), usage=Sum('account__cpujob__cpu_usage')) context = { 'software': software, '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 institute_users(request, machine_category_id, institute_id): machine_category = get_object_or_404(MachineCategory, 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) account_list = [] account_total, account_total_jobs = 0, 0 for u in PersonCache.objects.order_by('-cpu_hours').filter(start=start, end=end).filter(machine_category=machine_category).filter(account__institute=institute).filter(no_jobs__gt=0): account_total = account_total + u.cpu_hours account_total_jobs = account_total_jobs + u.no_jobs account_list.append({'account': u.account, 'project': u.project, 'usage': u.cpu_hours, 'jobs': u.no_jobs, 'percent': ((u.cpu_hours / available_time) * 100)}) try: account_percent = (account_total / available_time) * 100 except: account_percent = 0 return render_to_response('usage/institute_users.html', locals(), context_instance=RequestContext(request))
def mem_report(request): start, end = get_date_range(request) job_list = CPUJob.objects.filter(date__gte=start, date__lte=end) 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( template_name='kgusage/mem_report.html', context=locals(), request=request)
def usage_index(request): result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_machine_category_cache(request, start, end) if result is not None: return render_to_response( 'kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) mc_list = [] for machine_category in MachineCategory.objects.all(): mc_list.append({ 'obj': machine_category, 'graph': graphs.get_machine_graph_url( start, end, machine_category), }) return render_to_response( 'kgusage/mc_list.html', locals(), context_instance=RequestContext(request))
def mem_report(request, machine_category_id): 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 core_report(request, machine_category_id): 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( 'kgusage/core_report.html', locals(), context_instance=RequestContext(request))
def usage_index(request): result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_machine_category_cache(request, start, end) if result is not None: return render( template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) mc_list = [] for machine_category in MachineCategory.objects.all(): mc_list.append({ 'obj': machine_category, 'graph': graphs.get_machine_graph_url( start, end, machine_category), }) return render( template_name='kgusage/mc_list.html', context=locals(), request=request)
def version_stats(request, 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(account__cpujob__software=version, account__cpujob__date__range=(start, end)) \ .annotate(jobs=Count('account__cpujob'), usage=Sum('account__cpujob__cpu_usage')) institute_stats = Institute.objects \ .filter(person__account__cpujob__software=version, person__account__cpujob__date__range=(start, end)) \ .annotate(jobs=Count('person__account__cpujob'), usage=Sum('person__account__cpujob__cpu_usage')) context = { 'version': version, 'person_stats': person_stats, 'institute_stats': institute_stats, 'start': start, 'end': end, 'querystring': querystring, } return render_to_response( 'kgusage/version_stats.html', context, context_instance=RequestContext(request))
def core_report(request): start, end = get_date_range(request) job_list = CPUJob.objects.filter(date__gte=start, date__lte=end) 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( template_name='kgusage/core_report.html', context=locals(), request=request)
def usage_index(request): result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_machine_category_cache(request, start, end) if result is not None: return render_to_response('kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) mc_list = [] for machine_category in MachineCategory.objects.all(): mc_list.append({ 'obj': machine_category, 'graph': graphs.get_machine_graph_url(start, end, machine_category), }) return render_to_response('kgusage/mc_list.html', locals(), context_instance=RequestContext(request))
def top_users(request, machine_category_id): count = 20 result = progress(request) if result is not None: return result machine_category = MachineCategory.objects.get(pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_machine_category( request, start, end, machine_category) if result is not None: return render( template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) start, end = get_date_range(request) mc_cache = usage.get_machine_category_usage(machine_category, start, end) available_time = mc_cache.available_time person_list = [] person_total, person_total_jobs = 0, 0 query = models.PersonCache.objects.filter( date=datetime.date.today(), start=start, end=end, machine_category=machine_category) for u in query.order_by('-cpu_time')[:count]: if u.cpu_time: person_total += u.cpu_time person_total_jobs += u.no_jobs person_list.append({ 'person': u.person, 'project': u.project, 'usage': u.cpu_time, 'jobs': u.no_jobs, 'percent': ((u.cpu_time / available_time) * 100) }) person_percent = (person_total / available_time) * 100 return render( template_name='kgusage/top_users.html', context=locals(), request=request)
def top_users(request, machine_category_id): count = 20 result = progress(request) if result is not None: return result machine_category = MachineCategory.objects.get(pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end, machine_category) if result is not None: return render_to_response('kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) start, end = get_date_range(request) mc_cache = usage.get_machine_category_usage(machine_category, start, end) available_time = mc_cache.available_time person_list = [] person_total, person_total_jobs = 0, 0 query = models.PersonCache.objects.filter( date=datetime.date.today(), start=start, end=end, machine_category=machine_category) for u in query.order_by('-cpu_time')[:count]: if u.cpu_time: person_total += u.cpu_time person_total_jobs += u.no_jobs person_list.append({ 'person': u.person, 'project': u.project, 'usage': u.cpu_time, 'jobs': u.no_jobs, 'percent': ((u.cpu_time / available_time) * 100) }) person_percent = (person_total / available_time) * 100 return render_to_response('kgusage/top_users.html', locals(), context_instance=RequestContext(request))
def project_usage(request, project_id): project = get_object_or_404(Project, pid=project_id) if (not project.can_view(request) and not getattr(settings, 'USAGE_IS_PUBLIC', False)): return HttpResponseForbidden('<h1>Access Denied</h1>') result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end) if result is not None: return render(template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) result = gen_cache_for_project(request, start, end, project) if result is not None: return render(template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) usage_list = [] total, total_jobs = 0, 0 # Custom SQL as need to get users that were removed from project too query = CPUJob.objects.filter(project=project, date__range=(start, end)) query = query.values('account').annotate().order_by('account') for row in query: u = Account.objects.get(id=row['account']).person time, jobs = usage.get_person_usage(u, project, start, end) if time: total += time total_jobs += jobs if jobs > 0: usage_list.append({'person': 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'] = graphs.get_colour(count) count += 1 graph = graphs.get_project_trend_graph_url(project, start, end) return render(template_name='kgusage/project_usage.html', context=locals(), request=request)
def institute_trends(request, machine_category_id): machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) start, end = get_date_range(request) graph_list = get_institutes_trend_graph_urls(start, end, machine_category) return render_to_response('usage/institute_trends.html', locals(), context_instance=RequestContext(request))
def project_usage(request, project_id, machine_category_id): machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) project = get_object_or_404(Project, pid=project_id) if not project.can_view(request.user) and not getattr(settings, 'USAGE_IS_PUBLIC', False): return HttpResponseForbidden('<h1>Access Denied</h1>') result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end, machine_category) if result is not None: return result result = gen_cache_for_project(request, start, end, project, machine_category) if result is not None: return result usage_list = [] total, total_jobs = 0, 0 # Custom SQL as need to get users that were removed from project too rows = CPUJob.objects.filter( project=project, machine__category=machine_category, date__range=(start, end) ).values('account').annotate().order_by('account') for row in rows: u = Account.objects.get(id=row['account']).person time, jobs = usage.get_person_usage(u, project, start, end, machine_category) if time: total += time total_jobs += jobs if jobs > 0: usage_list.append({'person': 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'] = graphs.get_colour(count) count += 1 graph = graphs.get_project_trend_graph_url(project, start, end, machine_category) return render_to_response('usage/project_usage.html', locals(), context_instance=RequestContext(request))
def profile_personal(request): person = request.user project_list = person.projects.all() project_requests = [] user_applications = [] start, end = common.get_date_range(request) return render(template_name='karaage/people/profile_personal.html', context=locals(), request=request)
def profile(request): person = request.user project_list = person.projects.all() project_requests = [] user_applications = [] start, end = get_date_range(request) usage_list = person.personcache_set.filter(start=start, end=end) return render_to_response('people/profile.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, username=username) start, end = get_date_range(request, start, today) job_list = [] for ua in person.account_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 profile_personal(request): person = request.user project_list = person.projects.all() project_requests = [] user_applications = [] start, end = common.get_date_range(request) return render( template_name='karaage/people/profile_personal.html', context=locals(), request=request)
def profile_personal(request): person = request.user project_list = person.projects.all() project_requests = [] user_applications = [] start, end = common.get_date_range(request) return render_to_response( 'karaage/people/profile_personal.html', locals(), context_instance=RequestContext(request))
def institute_users(request, machine_category_id, institute_id): if not getattr(settings, 'USAGE_IS_PUBLIC', False): return HttpResponseForbidden('<h1>Access Denied</h1>') result = progress(request) if result is not None: return result machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end, machine_category) if result is not None: return result 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) mc_cache = usage.get_machine_category_usage(machine_category, start, end) available_time = mc_cache.available_time person_list = [] person_total, person_total_jobs = 0, 0 for u in cache.PersonCache.objects.order_by('-cpu_time').filter(start=start, end=end).filter( machine_category=machine_category).filter(person__institute=institute).filter(no_jobs__gt=0): person_total = person_total + u.cpu_time person_total_jobs = person_total_jobs + u.no_jobs person_list.append({'person': u.person, 'project': u.project, 'usage': u.cpu_time, 'jobs': u.no_jobs, 'percent': ((u.cpu_time / available_time) * 100)}) if available_time != 0: person_percent = (person_total / available_time) * 100 else: person_percent = 0 return render_to_response('usage/institute_users.html', locals(), context_instance=RequestContext(request))
def software_stats(request, software_id): software = get_object_or_404(Software, pk=software_id) start, end = get_date_range(request) querystring = request.META.get('QUERY_STRING', '') if software.softwareversion_set.count() == 1: sv = software.softwareversion_set.all()[0] url = reverse('kg_software_version_stats', args=[sv.id]) return HttpResponseRedirect(url) version_stats = SoftwareVersion.objects \ .filter(software=software, 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(account__cpujob__software__software=software, account__cpujob__date__range=(start, end)) \ .annotate(jobs=Count('account__cpujob'), p_usage=Sum('account__cpujob__cpu_usage')) project_stats = Project.objects \ .filter(cpujob__software__software=software, cpujob__date__range=(start, end)) \ .annotate(jobs=Count('cpujob'), p_usage=Sum('cpujob__cpu_usage')) person_institute_stats = Institute.objects \ .filter(person__account__cpujob__software__software=software, person__account__cpujob__date__range=(start, end)) \ .annotate(jobs=Count('person__account__cpujob'), i_usage=Sum('person__account__cpujob__cpu_usage')) project_institute_stats = Institute.objects \ .filter(project__cpujob__software__software=software, project__cpujob__date__range=(start, end)) \ .annotate(jobs=Count('project__cpujob'), i_usage=Sum('project__cpujob__cpu_usage')) context = { 'software': software, 'version_stats': version_stats, 'version_totaljobs': version_totaljobs, 'person_stats': person_stats, 'person_institute_stats': person_institute_stats, 'project_stats': project_stats, 'project_institute_stats': project_institute_stats, 'start': start, 'end': end, 'querystring': querystring, } return render( template_name='kgusage/software_stats.html', context=context, request=request)
def top_users(request, machine_category_id, count=20): if not getattr(settings, 'USAGE_IS_PUBLIC', False): return HttpResponseForbidden('<h1>Access Denied</h1>') result = progress(request) if result is not None: return result machine_category = MachineCategory.objects.get(pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end, machine_category) if result is not None: return result start, end = get_date_range(request) mc_cache = usage.get_machine_category_usage(machine_category, start, end) available_time = mc_cache.available_time person_list = [] person_total, person_total_jobs = 0, 0 for u in cache.PersonCache.objects.order_by('-cpu_time').filter(start=start, end=end).filter( machine_category=machine_category)[:count]: if u.cpu_time: person_total += u.cpu_time person_total_jobs += u.no_jobs person_list.append({ 'person': u.person, 'project': u.project, 'usage': u.cpu_time, 'jobs': u.no_jobs, 'percent': ((u.cpu_time / available_time) * 100) }) person_percent = (person_total / available_time) * 100 return render_to_response('usage/top_users.html', locals(), context_instance=RequestContext(request))
def top_users(request, machine_category_id, 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) account_list = [] account_total, account_total_jobs = 0, 0 for u in PersonCache.objects.order_by('-cpu_hours').filter(start=start, end=end).filter(machine_category=machine_category)[:count]: if u.cpu_hours: account_total += u.cpu_hours account_total_jobs += u.no_jobs account_list.append({'account': u.account, 'project': u.project, 'usage': u.cpu_hours, 'jobs': u.no_jobs, 'percent': ((u.cpu_hours / available_time) * 100)}) account_percent = (account_total / available_time) * 100 return render_to_response('usage/top_users.html', locals(), context_instance=RequestContext(request))
def institute_trends(request, machine_category_id): if not getattr(settings, 'USAGE_IS_PUBLIC', False): return HttpResponseForbidden('<h1>Access Denied</h1>') result = progress(request) if result is not None: return result machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end, machine_category) if result is not None: return result graph_list = graphs.get_institutes_trend_graph_urls(start, end, machine_category) return render_to_response('usage/institute_trends.html', locals(), context_instance=RequestContext(request))
def institute_trends(request): result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_cache_for_all_institutes(request, start, end) if result is not None: return render(template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) graph_list = graphs.get_institutes_trend_graph_urls(start, end) return render(template_name='kgusage/institute_trends.html', context=locals(), request=request)
def usage_index(request): start, end = get_date_range(request) mc_list = [] for machine_category in MachineCategory.objects.all(): m_list = [] for machine in machine_category.machine_set.all(): time, jobs = machine.get_usage(start, end) if time is None: time = 0 m_list.append({'obj': machine, 'usage': time, 'jobs': jobs}) mc_list.append({ 'obj': machine_category, 'machines': m_list, 'graph': get_machine_graph_url(start, end, machine_category), }) del m_list return render_to_response('usage/mc_list.html', locals(), context_instance=RequestContext(request))
def institute_trends(request): result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_cache_for_all_institutes(request, start, end) if result is not None: return render( template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) graph_list = graphs.get_institutes_trend_graph_urls(start, end) return render( template_name='kgusage/institute_trends.html', context=locals(), request=request)
def version_stats(request, 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(account__cpujob__software=version, account__cpujob__date__range=(start, end)) \ .annotate(jobs=Count('account__cpujob'), p_usage=Sum('account__cpujob__cpu_usage')) project_stats = Project.objects \ .filter(cpujob__software=version, cpujob__date__range=(start, end)) \ .annotate(jobs=Count('cpujob'), p_usage=Sum('cpujob__cpu_usage')) person_institute_stats = Institute.objects \ .filter(person__account__cpujob__software=version, person__account__cpujob__date__range=(start, end)) \ .annotate(jobs=Count('person__account__cpujob'), i_usage=Sum('person__account__cpujob__cpu_usage')) project_institute_stats = Institute.objects \ .filter(project__cpujob__software=version, project__cpujob__date__range=(start, end)) \ .annotate(jobs=Count('project__cpujob'), i_usage=Sum('project__cpujob__cpu_usage')) context = { 'version': version, 'person_stats': person_stats, 'person_institute_stats': person_institute_stats, 'project_stats': project_stats, 'project_institute_stats': project_institute_stats, 'start': start, 'end': end, 'querystring': querystring, } return render( template_name='kgusage/version_stats.html', context=context, request=request)
def institute_trends(request, machine_category_id): result = progress(request) if result is not None: return result machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_all_institutes(request, start, end, machine_category) if result is not None: return render_to_response('kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) graph_list = graphs.get_institutes_trend_graph_urls( start, end, machine_category) return render_to_response('kgusage/institute_trends.html', locals(), context_instance=RequestContext(request))
def usage_index(request): if not getattr(settings, 'USAGE_IS_PUBLIC', False): return HttpResponseForbidden('<h1>Access Denied</h1>') result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_machine_category_cache(request, start, end) if result is not None: return result mc_list = [] for machine_category in MachineCategory.objects.all(): mc_list.append({ 'obj': machine_category, 'graph': graphs.get_machine_graph_url(start, end, machine_category), }) return render_to_response('usage/mc_list.html', locals(), context_instance=RequestContext(request))
def mem_report(request, machine_category_id): 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('kgusage/mem_report.html', locals(), context_instance=RequestContext(request))
def institute_trends(request, machine_category_id): result = progress(request) if result is not None: return result machine_category = get_object_or_404( MachineCategory, pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_all_institutes( request, start, end, machine_category) if result is not None: return render_to_response( 'kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) graph_list = graphs.get_institutes_trend_graph_urls( start, end, machine_category) return render_to_response( 'kgusage/institute_trends.html', locals(), context_instance=RequestContext(request))
def institute_trends(request, machine_category_id): result = progress(request) if result is not None: return result machine_category = get_object_or_404( MachineCategory, pk=machine_category_id) start, end = get_date_range(request) result = gen_cache_for_all_institutes( request, start, end, machine_category) if result is not None: return render( template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) graph_list = graphs.get_institutes_trend_graph_urls( start, end, machine_category) return render( template_name='kgusage/institute_trends.html', context=locals(), request=request)
def index(request): result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end) if result is not None: return render(template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) show_zeros = True institute_list = Institute.active.all() m_list = [] mc_cache = usage.get_machine_category_usage(start, end) total = mc_cache.cpu_time total_jobs = mc_cache.no_jobs available_time = mc_cache.available_time total_time = ((end - start).days + 1) * 24 * 60 * 60 avg_cpus = available_time / total_time for m_cache in models.MachineCache.objects.filter( date=datetime.date.today(), start=start, end=end): m = m_cache.machine time = m_cache.cpu_time jobs = m_cache.no_jobs m_list.append({'machine': m, 'usage': time, 'jobs': jobs}) for i_cache in models.InstituteCache.objects.filter( date=datetime.date.today(), start=start, end=end): i = i_cache.institute time = i_cache.cpu_time jobs = i_cache.no_jobs # Unused Entry unused = {'usage': available_time - total, 'quota': 0} if available_time != 0: unused['percent'] = (unused['usage'] / available_time) * 100 else: unused['percent'] = 0 unused['diff'] = unused['percent'] - unused['quota'] // 100 if unused['diff'] <= 0: unused['class'] = 'green' else: unused['class'] = 'red' if available_time != 0: utilization = (Decimal(total) / available_time) * 100 else: utilization = 0 institutes_graph = graphs.get_institute_graph_url(start, end) machines_graph = graphs.get_machine_graph_url(start, end) trend_graph = graphs.get_trend_graph_url(start, end) return render(template_name='kgusage/usage_institute_list.html', context=locals(), request=request)
def search(request): if request.method == 'POST': form = UsageSearchForm(request.POST) if form.is_valid(): data = form.cleaned_data project_query = Project.objects.all() institute_query = Institute.objects.all() # person_list = Person.objects.all() terms = data['terms'].lower() start = data['start_date'] end = data['end_date'] machine_category = data['machine_category'] start_str = start.strftime('%Y-%m-%d') end_str = end.strftime('%Y-%m-%d') if terms: # search for projects query = Q() for term in terms.split(' '): q = Q(pid__icontains=term) | Q(name__icontains=term) query = query & q project_query = project_query.filter(query) # search for institutes query = Q() for term in terms.split(' '): q = Q(name__icontains=term) query = query & q institute_query = institute_query.filter(query) project_list = [] for p in project_query: time, jobs = usage.get_project_usage( p, start, end, machine_category) project_list.append({ 'obj': p, 'time': time, 'jobs': jobs, }) del project_query institute_list = [] for i in institute_query: time, jobs = usage.get_institute_usage( i, start, end, machine_category) institute_list.append({ 'obj': i, 'time': time, 'jobs': jobs, }) del institute_query else: return HttpResponseRedirect( '%s?start=%s&end=%s' % (reverse('kg_usage_list'), start_str, end_str)) else: start, end = get_date_range(request) initial = { 'start_date': start, 'end_date': end, 'machine_category': request.GET.get('machine_category', None) } form = UsageSearchForm(initial=initial) return render_to_response('kgusage/search.html', locals(), context_instance=RequestContext(request))
def institute_usage(request, institute_id, machine_category_id): result = progress(request) if result is not None: return result machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) institute = get_object_or_404(Institute, pk=institute_id) start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end, machine_category) if result is not None: return render_to_response('kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) result = gen_cache_for_institute(request, start, end, institute, machine_category) if result is not None: return render_to_response('kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) project_list = [] institute_list = Institute.active.all() if (not institute.can_view(request) and not getattr(settings, 'USAGE_IS_PUBLIC', False)): return HttpResponseForbidden('<h1>Access Denied</h1>') mc_cache = usage.get_machine_category_usage(machine_category, start, end) available_time = mc_cache.available_time quota = get_object_or_404(InstituteQuota, institute=institute, machine_category=machine_category) i_usage, i_jobs = usage.get_institute_usage(institute, start, end, machine_category) for p_cache in models.ProjectCache.objects.filter( project__institute=institute, machine_category=machine_category, date=datetime.date.today(), start=start, end=end): p = p_cache.project p_usage = p_cache.cpu_time p_jobs = p_cache.no_jobs try: chunk = p.projectquota_set.get(machine_category=machine_category) except ProjectQuota.DoesNotExist: chunk = None if chunk is None and p_usage == 0 and p_jobs == 0: continue if chunk is not None: mpots = mc_cache.get_project_mpots(chunk, start, end) percent = mc_cache.get_project_cap_percent(chunk, start, end) else: mpots = None percent = None if available_time > 0 and quota.quota > 0: quota_percent = p_usage / (available_time * quota.quota) * 10000 else: quota_percent = 0 project_list.append({ 'project': p, 'usage': p_usage, 'jobs': p_jobs, 'percent': percent, 'quota_percent': quota_percent, }) person_list = [] person_total, person_total_jobs = 0, 0 query = models.PersonCache.objects.filter( project__institute=institute, machine_category=machine_category, date=datetime.date.today(), start=start, end=end) query = query.order_by('-cpu_time') for u in query[:5]: person_total += u.cpu_time person_total_jobs += u.no_jobs if i_usage > 0: i_percent = (u.cpu_time / i_usage) * 100 else: i_percent = None if available_time > 0 and quota.quota > 0: quota_percent = u.cpu_time / (available_time * quota.quota) * 10000 else: quota_percent = 0 person_list.append({ 'person': u.person, 'project': u.project, 'usage': u.cpu_time, 'jobs': u.no_jobs, 'percent': i_percent, 'quota_percent': quota_percent, }) if i_usage > 0: person_percent = (person_total / i_usage) * 100 else: person_percent = None graph = graphs.get_institute_trend_graph_url(institute, start, end, machine_category) return render_to_response('kgusage/usage_institute_detail.html', locals(), context_instance=RequestContext(request))
def institute_usage(request, institute_id): result = progress(request) if result is not None: return result institute = get_object_or_404(Institute, pk=institute_id) start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end) if result is not None: return render(template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) result = gen_cache_for_institute(request, start, end, institute) if result is not None: return render(template_name='kgusage/progress.html', context={'task_id': result.task_id}, request=request) project_list = [] institute_list = Institute.active.all() if (not institute.can_view(request) and not getattr(settings, 'USAGE_IS_PUBLIC', False)): return HttpResponseForbidden('<h1>Access Denied</h1>') mc_cache = usage.get_machine_category_usage(start, end) available_time = mc_cache.available_time i_usage, i_jobs = usage.get_institute_usage(institute, start, end) for p_cache in models.ProjectCache.objects.filter( project__institute=institute, date=datetime.date.today(), start=start, end=end): p = p_cache.project p_usage = p_cache.cpu_time p_jobs = p_cache.no_jobs person_list = [] person_total, person_total_jobs = 0, 0 query = models.PersonCache.objects.filter(project__institute=institute, date=datetime.date.today(), start=start, end=end) query = query.order_by('-cpu_time') for u in query[:5]: person_total += u.cpu_time person_total_jobs += u.no_jobs if i_usage > 0: i_percent = (u.cpu_time / i_usage) * 100 else: i_percent = None person_list.append({ 'person': u.person, 'project': u.project, 'usage': u.cpu_time, 'jobs': u.no_jobs, 'percent': i_percent, }) if i_usage > 0: person_percent = (person_total / i_usage) * 100 else: person_percent = None graph = graphs.get_institute_trend_graph_url(institute, start, end) return render(template_name='kgusage/usage_institute_detail.html', context=locals(), request=request)
def search(request): if request.method == 'POST': form = UsageSearchForm(request.POST) if form.is_valid(): data = form.cleaned_data project_query = Project.objects.all() institute_query = Institute.objects.all() # person_list = Person.objects.all() terms = data['terms'].lower() start = data['start_date'] end = data['end_date'] machine_category = data['machine_category'] start_str = start.strftime('%Y-%m-%d') end_str = end.strftime('%Y-%m-%d') if terms: # search for projects query = Q() for term in terms.split(' '): q = Q(pid__icontains=term) | Q(name__icontains=term) query = query & q project_query = project_query.filter(query) # search for institutes query = Q() for term in terms.split(' '): q = Q(name__icontains=term) query = query & q institute_query = institute_query.filter(query) project_list = [] for p in project_query: time, jobs = usage.get_project_usage( p, start, end, machine_category) project_list.append({ 'obj': p, 'time': time, 'jobs': jobs, }) del project_query institute_list = [] for i in institute_query: time, jobs = usage.get_institute_usage( i, start, end, machine_category) institute_list.append({ 'obj': i, 'time': time, 'jobs': jobs, }) del institute_query else: return HttpResponseRedirect( '%s?start=%s&end=%s' % (reverse('kg_usage_list'), start_str, end_str)) else: start, end = get_date_range(request) initial = { 'start_date': start, 'end_date': end, 'machine_category': request.GET.get('machine_category', None) } form = UsageSearchForm(initial=initial) return render_to_response( 'kgusage/search.html', locals(), context_instance=RequestContext(request))
def institute_usage(request, institute_id, machine_category_id): result = progress(request) if result is not None: return result machine_category = get_object_or_404( MachineCategory, pk=machine_category_id) institute = get_object_or_404(Institute, pk=institute_id) start, end = get_date_range(request) result = gen_cache_for_machine_category( request, start, end, machine_category) if result is not None: return render_to_response( 'kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) result = gen_cache_for_institute( request, start, end, institute, machine_category) if result is not None: return render_to_response( 'kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) project_list = [] institute_list = Institute.active.all() if (not institute.can_view(request) and not getattr(settings, 'USAGE_IS_PUBLIC', False)): return HttpResponseForbidden('<h1>Access Denied</h1>') mc_cache = usage.get_machine_category_usage(machine_category, start, end) available_time = mc_cache.available_time quota = get_object_or_404( InstituteQuota, institute=institute, machine_category=machine_category) i_usage, i_jobs = usage.get_institute_usage( institute, start, end, machine_category) for p_cache in models.ProjectCache.objects.filter( project__institute=institute, machine_category=machine_category, date=datetime.date.today(), start=start, end=end): p = p_cache.project p_usage = p_cache.cpu_time p_jobs = p_cache.no_jobs try: chunk = p.projectquota_set.get(machine_category=machine_category) except ProjectQuota.DoesNotExist: chunk = None if chunk is None and p_usage == 0 and p_jobs == 0: continue if chunk is not None: mpots = mc_cache.get_project_mpots(chunk, start, end) percent = mc_cache.get_project_cap_percent(chunk, start, end) else: mpots = None percent = None if available_time > 0 and quota.quota > 0: quota_percent = p_usage / (available_time * quota.quota) * 10000 else: quota_percent = 0 project_list.append( {'project': p, 'usage': p_usage, 'jobs': p_jobs, 'percent': percent, 'quota_percent': quota_percent, }) person_list = [] person_total, person_total_jobs = 0, 0 query = models.PersonCache.objects.filter( project__institute=institute, machine_category=machine_category, date=datetime.date.today(), start=start, end=end) query = query.order_by('-cpu_time') for u in query[:5]: person_total += u.cpu_time person_total_jobs += u.no_jobs if i_usage > 0: i_percent = (u.cpu_time / i_usage) * 100 else: i_percent = None if available_time > 0 and quota.quota > 0: quota_percent = u.cpu_time / (available_time * quota.quota) * 10000 else: quota_percent = 0 person_list.append( {'person': u.person, 'project': u.project, 'usage': u.cpu_time, 'jobs': u.no_jobs, 'percent': i_percent, 'quota_percent': quota_percent, }) if i_usage > 0: person_percent = (person_total / i_usage) * 100 else: person_percent = None graph = graphs.get_institute_trend_graph_url( institute, start, end, machine_category) return render_to_response( 'kgusage/usage_institute_detail.html', locals(), context_instance=RequestContext(request))
def index(request, machine_category_id): machine_category = get_object_or_404( MachineCategory, pk=machine_category_id) mc_list = MachineCategory.objects.exclude(id__exact=machine_category_id) result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_cache_for_machine_category( request, start, end, machine_category) if result is not None: return render_to_response( 'kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) show_zeros = True institute_list = Institute.active.all() i_list = [] m_list = [] mc_cache = usage.get_machine_category_usage(machine_category, start, end) total = mc_cache.cpu_time total_jobs = mc_cache.no_jobs available_time = mc_cache.available_time total_time = ((end - start).days + 1) * 24 * 60 * 60 avg_cpus = available_time / total_time for m_cache in models.MachineCache.objects.filter( machine__category=machine_category, date=datetime.date.today(), start=start, end=end): m = m_cache.machine time = m_cache.cpu_time jobs = m_cache.no_jobs m_list.append({'machine': m, 'usage': time, 'jobs': jobs}) for i_cache in models.InstituteCache.objects.filter( machine_category=machine_category, date=datetime.date.today(), start=start, end=end): i = i_cache.institute time = i_cache.cpu_time jobs = i_cache.no_jobs try: quota = InstituteQuota.objects.get( institute=i, machine_category=machine_category) display_quota = quota.quota except InstituteQuota.DoesNotExist: display_quota = None if display_quota is None and time == 0 and jobs == 0: continue data_row = { 'institute': i, 'usage': time, 'jobs': jobs, 'quota': display_quota } if available_time != 0: data_row['percent'] = Decimal(time) / Decimal(available_time) * 100 else: data_row['percent'] = 0 if data_row['quota'] is not None: if data_row['quota'] != 0: data_row['p_used'] = (data_row['percent'] / data_row['quota']) * 100 else: data_row['p_used'] = None 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' data_row['diff'] = None data_row['p_used'] = None i_list.append(data_row) # Unused Entry unused = {'usage': available_time - total, 'quota': 0} if available_time != 0: unused['percent'] = (unused['usage'] / available_time) * 100 else: unused['percent'] = 0 unused['diff'] = unused['percent'] - unused['quota'] / 100 if unused['diff'] <= 0: unused['class'] = 'green' else: unused['class'] = 'red' if available_time != 0: utilization = (Decimal(total) / available_time) * 100 else: utilization = 0 institutes_graph = graphs.get_institute_graph_url( start, end, machine_category) machines_graph = graphs.get_machine_graph_url( start, end, machine_category) trend_graph = graphs.get_trend_graph_url( start, end, machine_category) return render_to_response( 'kgusage/usage_institute_list.html', locals(), context_instance=RequestContext(request))
def index(request, machine_category_id): machine_category = get_object_or_404(MachineCategory, pk=machine_category_id) mc_list = MachineCategory.objects.exclude(id__exact=machine_category_id) result = progress(request) if result is not None: return result start, end = get_date_range(request) result = gen_cache_for_machine_category(request, start, end, machine_category) if result is not None: return render_to_response('kgusage/progress.html', {'task_id': result.task_id}, context_instance=RequestContext(request)) show_zeros = True institute_list = Institute.active.all() i_list = [] m_list = [] mc_cache = usage.get_machine_category_usage(machine_category, start, end) total = mc_cache.cpu_time total_jobs = mc_cache.no_jobs available_time = mc_cache.available_time total_time = ((end - start).days + 1) * 24 * 60 * 60 avg_cpus = available_time / total_time for m_cache in models.MachineCache.objects.filter( machine__category=machine_category, date=datetime.date.today(), start=start, end=end): m = m_cache.machine time = m_cache.cpu_time jobs = m_cache.no_jobs m_list.append({'machine': m, 'usage': time, 'jobs': jobs}) for i_cache in models.InstituteCache.objects.filter( machine_category=machine_category, date=datetime.date.today(), start=start, end=end): i = i_cache.institute time = i_cache.cpu_time jobs = i_cache.no_jobs try: quota = InstituteQuota.objects.get( institute=i, machine_category=machine_category) display_quota = quota.quota except InstituteQuota.DoesNotExist: display_quota = None if display_quota is None and time == 0 and jobs == 0: continue data_row = { 'institute': i, 'usage': time, 'jobs': jobs, 'quota': display_quota } if available_time != 0: data_row['percent'] = Decimal(time) / Decimal(available_time) * 100 else: data_row['percent'] = 0 if data_row['quota'] is not None: if data_row['quota'] != 0: data_row['p_used'] = (data_row['percent'] / data_row['quota']) * 100 else: data_row['p_used'] = None 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' data_row['diff'] = None data_row['p_used'] = None i_list.append(data_row) # Unused Entry unused = {'usage': available_time - total, 'quota': 0} if available_time != 0: unused['percent'] = (unused['usage'] / available_time) * 100 else: unused['percent'] = 0 unused['diff'] = unused['percent'] - unused['quota'] / 100 if unused['diff'] <= 0: unused['class'] = 'green' else: unused['class'] = 'red' if available_time != 0: utilization = (Decimal(total) / available_time) * 100 else: utilization = 0 institutes_graph = graphs.get_institute_graph_url(start, end, machine_category) machines_graph = graphs.get_machine_graph_url(start, end, machine_category) trend_graph = graphs.get_trend_graph_url(start, end, machine_category) return render_to_response('kgusage/usage_institute_list.html', locals(), context_instance=RequestContext(request))