def student_update(request, sid, status_value):
s_id = int(sid)
usera = UserAccessProfile(request)
user_type = usera.user_type
if user_type != 2:
messages.error(request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
std_obj = MyUser.objects.get(id=s_id)
std_obj.status = status_value
std_obj.save()
messages.success(request, 'Success: Update User.')
return HttpResponseRedirect("/lab/students/")
def student_course_cancel(request, cid):
course_id = int(cid)
usera = UserAccessProfile(request)
#c_user = get_user_by_email(the_user(request))
user_type = usera.user_type # get_user_type(c_user)
if user_type != 3:
# messages.error(page.request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
course = StudentCourses.objects.get(id=course_id)
remove_course_by_emails(usera.username, course.course_ref.id)
course.delete()
messages.success(request, 'Success: Unroll from Course.')
return HttpResponseRedirect("/lab/my_courses/")
def get_context_data(self, **kwargs):
page = Page(self.request)
#node_list = Node.objects.all()
context = super(TimelineView, self).get_context_data(**kwargs)
#context['node_list'] = node_list
context['last_update'] = datetime.now()
context['title'] = 'TIMELINE VIEW'
context['username'] = UserAccessProfile(self.request).username
context['topmenu_items'] = topmenu_items('Timeline View', page.request)
prelude_env = page.prelude_env()
context.update(prelude_env)
return context
def omf_exe(request):
if not slice_on_time(request, "omf"):
return HttpResponse('eof', content_type="text/plain")
else:
script = request.POST.get('script_text', '')
if not script:
return HttpResponse(request,
'Script Empty',
content_type="text/plain")
username = UserAccessProfile(
request).username # get_username_by_email(the_user(request))
t = exe_script("%s" % script, username)
if t != 0:
return HttpResponse(t, content_type="application/json")
return HttpResponse({"error": "Error, Invalid Script"},
content_type="text/plain")
def get_context_data(self, **kwargs):
page = Page(self.request)
page.add_js_files([
"js/jquery.validate.js", "js/my_account.register.js",
"js/my_account.edit_profile.js"
])
page.add_css_files(["css/plugin.css"])
usera = UserAccessProfile(self.request)
c_user = usera.user_obj # get_user_by_email(the_user(self.request))
get_count_active_slice(c_user=c_user, username=usera.session_username)
pending_list_1 = Reservation.objects.filter(
user_ref=c_user,
username=usera.session_username,
status=ReservationStatus.get_pending())
active_list_1 = Reservation.objects.filter(
user_ref=c_user,
username=usera.session_username,
status=ReservationStatus.get_active())
pending_list_2 = SimReservation.objects.filter(
user_ref=c_user,
username=usera.session_username,
status=ReservationStatus.get_pending())
active_list_2 = SimReservation.objects.filter(
user_ref=c_user,
username=usera.session_username,
status=ReservationStatus.get_active())
context = super(SliceCurrentView, self).get_context_data(**kwargs)
context['current_list_1'] = pending_list_1
context['active_list_1'] = active_list_1
context['current_list_2'] = pending_list_2
context['active_list_2'] = active_list_2
context['time_now'] = timezone.now()
# XXX This is repeated in all pages
# more general variables expected in the template
context['title'] = 'Reservation Panel'
# the menu items on the top
# context['topmenu_items'] = topmenu_items('Reservation Status', page.request) # @qursaan change from _live
# so we can sho who is logged
context['username'] = usera.username # the_user(self.request)
# context ['firstname'] = config['firstname']
prelude_env = page.prelude_env()
context.update(prelude_env)
return context
def access_token_gen(request):
stype = request.POST.get('stype', None)
if stype is None:
return HttpResponse("error: Please go back and try again",
content_type="text/plain")
if not slice_on_time(request, stype):
return HttpResponse('eof', content_type="text/plain")
else:
r = -1
usera = UserAccessProfile(request)
slice_id = request.session.get('slice_id', None)
slice_id = int(slice_id)
current_slice = None
if stype == "omf":
current_slice = Reservation.objects.get(id=slice_id)
elif stype == "sim":
current_slice = SimReservation.objects.get(id=slice_id)
username = usera.user_obj.first_name + randomStringDigits(6)
password = randomStringDigits(10)
recipients = []
recipients.append(usera.user_obj.email)
ctx = {
'slice_name': current_slice.slice_name,
'slice_duration': current_slice.slice_duration,
'password': password,
'access_token': username,
}
# TODO: qursaan@ call backend here
r = 1
# if cc_myself:
recipients.append(SUPPORT_EMAIL)
msg = render_to_string('access-token-email.txt', ctx)
# print "email, msg, email, recipients", email , msg, email, recipients
send_mail("CRCLAB user %s requested Access Password" % usera.username,
msg, DEFAULT_FROM_EMAIL, recipients)
if r == 1:
return HttpResponse("Success", content_type="text/plain")
return HttpResponse("Fail, Try again!", content_type="text/plain")
def get_or_post(self, request, method):
usera = UserAccessProfile(request)
self.user_email = usera.username # the_user(request)
page = Page(request)
self.errors = []
# user = get_user_by_email(the_user(self.request))
user_type = usera.user_type # get_user_type(user)
if user_type != 0:
messages.error(
page.request,
'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
fedlist = Site.objects.all()
if method == 'POST':
self.errors = []
'''site_name = request.POST.get('site_name', '')
site_url = request.POST.get('site_url', '')
site_ip = request.POST.get('site_ip', '')
site_location = request.POST.get('site_location', '')
site_contact = request.POST.get('site_contact', '')
if not self.errors and site:
site.name = site_name
site.url = site_url
site.ip = site_ip
site.location = site_location
site.contact_email = site_contact
site.save()
messages.success(request, 'Success: Update site information')'''
template_name = "fed-list.html"
template_env = {
'topmenu_items': topmenu_items('Site Information', page.request),
'username': usera.username, # the_user(self.request),
'fedlist': fedlist,
'title': 'Site Information',
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_or_post(self, request, method):
page = Page(self.request)
usera = UserAccessProfile(request)
c_user = usera.user_obj # get_user_by_email(the_user(self.request))
user_type = usera.user_type # get_user_type(c_user)
if user_type != 3:
# messages.error(page.request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
template_name = "std-courses-view.html"
add_all_courses_by_email(usera.username)
courses_list = StudentCourses.objects.filter(students_ref=c_user)
template_env = {
'topmenu_items': topmenu_items('My Courses', page.request),
'username': usera.username, #the_user(self.request),
'courses_list': courses_list,
'title': 'My Courses',
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_context_data(self, **kwargs):
page = Page(self.request)
n_local_user = MyUser.objects.filter().count()
n_remote_user = '******' # 'Users.objects.filter().count()
n_remote_site = Site.objects.filter().count() - 1
n_local_resources = PhysicalNode.objects.filter().count()
n_remote_resources = '#'
context = super(FedView, self).get_context_data(**kwargs)
context['fed_service'] = get_fed_status()
context['n_local_user'] = n_local_user
context['n_remote_user'] = n_remote_user
context['n_remote_site'] = n_remote_site
context['n_local_res'] = n_local_resources
context['n_remote_res'] = n_remote_resources
context['username'] = UserAccessProfile(self.request).username # the_user(self.request)
context['topmenu_items'] = topmenu_items('Testbed View', page.request)
prelude_env = page.prelude_env()
context.update(prelude_env)
return context
def get_or_post(self, request, method):
page = Page(self.request)
usera = UserAccessProfile(request)
c_user = usera.user_obj
user_type = usera.user_type
if user_type != 2:
messages.error(page.request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
template_name = "ins_students_manage.html"
student_list = MyUser.objects.filter(supervisor_id=c_user.id, user_type=3)
template_env = {
'topmenu_items': topmenu_items('Students List', page.request),
# 'errors': errors,
'username': usera.username, #the_user(self.request),
'student_list': student_list,
'time_now': timezone.now,
'title': 'Current Students',
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_or_post(self, request, method):
page = Page(self.request)
usera = UserAccessProfile(request)
c_user = usera.user_obj #get_user_by_email(the_user(self.request))
user_type = usera.user_type #get_user_type(c_user)
if user_type != 2:
messages.error(page.request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
template_name = "ins-courses-view.html"
courses_list = Course.objects.filter(instructor_ref=c_user)
template_env = {
'topmenu_items': topmenu_items('Courses List', page.request),
# 'errors': errors,
'username': usera.username, #the_user(self.request),
'courses_list': courses_list,
'time_now': timezone.now,
'title': 'Current Active Courses',
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_or_post(self, request, method):
page = Page(self.request)
usera = UserAccessProfile(request)
c_user = usera.user_obj #get_user_by_email(the_user(self.request))
user_type = usera.user_type #get_user_type(c_user)
if user_type != 3:
# messages.error(page.request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
template_name = "std-experiments-view.html"
s_courses_list = StudentCourses.objects.filter(students_ref=c_user)
c_ids = []
for c in s_courses_list:
c_ids.append(c.course_ref.id)
courses_list = Course.objects.filter(id__in=c_ids)
exp_list = Experiments.objects.filter(course_ref__in=courses_list,
status=0)
res_exp_list = Experiments.objects.filter(course_ref__in=courses_list)
std_exp_list = StudentsExperiment.objects.filter(
students_ref=c_user, experiment_ref__in=res_exp_list)
res_std_list_id = []
for s in std_exp_list:
res_std_list_id.append(s.experiment_ref.id)
exp_list = exp_list.exclude(id__in=res_std_list_id)
template_env = {
'topmenu_items': topmenu_items('My Courses', page.request),
'username': usera.username,
'exp_list': exp_list,
'std_exp_list': std_exp_list,
'title': 'My Courses',
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_or_post(self, request, method):
page = Page(self.request)
usera = UserAccessProfile(self.request)
c_user = usera.user_obj # get_user_by_email(the_user(self.request))
user_type = usera.user_type # get_user_type(c_user)
if user_type > 3:
messages.error(page.request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
lib_list = None
lib_name = request.POST.get('lib_name', '')
lib_auth = request.POST.get('lib_auth', '')
lib_type = request.POST.get('lib_type', '')
lib_tag = request.POST.get('lib_tag', '')
lib_desc = request.POST.get('lib_desc', '')
if method == 'POST':
lib_list = CustomLibrary.objects.filter(name__icontains=lib_name, author__icontains=lib_auth,
type__icontains=lib_type, tag__icontains=lib_tag,
description__icontains=lib_desc)
else:
lib_list = CustomLibrary.objects.all()
template_name = "library-view.html"
template_env = {
'topmenu_items': topmenu_items('Library List', page.request),
# 'errors': errors,
'lib_list': lib_list,
'lib_name': lib_name,
'lib_auth': lib_auth,
'lib_type': lib_type,
'lib_tag': lib_tag,
'lib_desc': lib_desc,
'username': usera.username, # the_user(self.request),
'title': 'Custom Libraries',
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_context_data(self, **kwargs):
page = Page(self.request)
the_date = datetime.now(tz=timezone.get_current_timezone()) # datetime.today()
year_l, year_v = get_total_last_year(the_date, 't')
year_vl, year_vv = get_total_last_year(the_date, 'v')
year_sl, year_sv = get_total_last_year(the_date, 's')
# user_list, value_list = get_month_usage_by_users(None)
res_l , res_v, res_c = get_total_resource_usage()
context = super(StatsAdminView, self).get_context_data(**kwargs)
context['year_l'] = year_l
context['year_vv'] = year_vv
context['year_sv'] = year_sv
context['year_v'] = year_v
context['res_l'] = res_l
context['res_v'] = res_v
context['res_c'] = res_c
context['username'] = UserAccessProfile(self.request).username # the_user(self.request)
context['topmenu_items'] = topmenu_items('Testbed View', page.request)
prelude_env = page.prelude_env()
context.update(prelude_env)
return context
def get(self, request):
page = Page(self.request)
usera = UserAccessProfile(request)
c_user = usera.user_obj #get_user_by_email(the_user(self.request))
user_type = usera.user_type #get_user_type(c_user)
if user_type != 2:
messages.error(
page.request,
'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
template_name = "ins-validate-view.html"
std_requests = get_std_requests(c_user.id)
template_env = {
'topmenu_items': topmenu_items('Validation', page.request),
# 'errors': errors,
'username': usera.username,
'std_pending_list': std_requests,
'title': 'Manage Student',
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_or_post(self, request, fid, method):
usera = UserAccessProfile(request)
self.user_email = usera.username # the_user(request)
page = Page(request)
self.errors = []
user_type = usera.user_type # get_user_type(user)
if user_type != 0:
messages.error(
page.request,
'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
site = None
if fid:
try:
site = Site.objects.get(id=fid)
except Site.DoesNotExist:
site = None
if site:
site_name = site.name
site_url = site.url
site_ip = site.ip
site_location = site.location
site_contact = site.contact_email
site_pkey = site.public_key
else:
site_name = ''
site_url = ''
site_ip = ''
site_location = ''
site_contact = ''
site_pkey = ''
if method == 'POST':
self.errors = []
site_name = request.POST.get('site_name', '')
site_url = request.POST.get('site_url', '')
site_ip = request.POST.get('site_ip', '')
site_location = request.POST.get('site_location', '')
site_contact = request.POST.get('site_contact', '')
site_pkey = request.POST.get('site_pkey', '')
# UPDATE
if not self.errors and site:
site.name = site_name
site.url = site_url
site.ip = site_ip
site.location = site_location
site.contact_email = site_contact
site.public_key = site_pkey
site.save()
messages.success(request, 'Success: Update site information')
return HttpResponseRedirect('/federation/list')
else: # create new site
site = Site(
name=site_name,
url=site_url,
ip=site_ip,
location=site_location,
contact_email=site_contact,
public_key=site_pkey,
)
site.save()
messages.success(request, 'Success: Add new site information')
return HttpResponseRedirect('/federation/list')
template_name = "fed-site.html"
template_env = {
'topmenu_items': topmenu_items('Site Information', page.request),
'username': usera.username, # the_user(self.request),
'site_name': site_name,
'site_url': site_url,
'site_ip': site_ip,
'site_location': site_location,
'site_contact': site_contact,
'site_pkey': site_pkey,
'site_info': 0,
'title': 'Site Information',
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_or_post(self, request, method):
usera = UserAccessProfile(request)
self.user_email = usera.username # the_user(request)
page = Page(request)
user = usera.user_obj # get_user_by_email(the_user(request))
user_type = usera.user_type # get_user_type(user)
if user_type > 3:
messages.error(page.request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
if method == 'POST':
self.errors = []
lib_name = request.POST.get('lib_name', None)
lib_auth = request.POST.get('lib_auth', None)
lib_type = request.POST.get('lib_type', None)
lib_type_other = request.POST.get('lib_type_other', None)
lib_tag = request.POST.get('lib_tag', None)
lib_link = request.POST.get('lib_link', None)
lib_desc = request.POST.get('lib_desc', None)
lib_file = None
request_date = timezone.now()
if len(request.FILES) > 0:
lib_file = request.FILES['lib_file']
if lib_name is None or lib_name == '':
self.errors.append('Library Name is mandatory')
if lib_file is None or lib_file == '':
self.errors.append('Code file is mandatory')
if lib_type is None or lib_type == '':
self.errors.append('Code type is mandatory')
if lib_type == 'Other' and (lib_type_other is None or lib_type_other == ''):
self.errors.append('Code type is mandatory')
if not self.errors:
if lib_type == 'Other':
lib_type = ''.join(e for e in lib_type_other if e.isalnum())
c = CustomLibrary(
user_ref=user,
name=lib_name,
author=lib_auth,
type=lib_type,
tag=lib_tag,
external_link=lib_link,
description=lib_desc,
)
sv_library = c.save()
# if sv_library:
# Save file and update
if lib_file:
fs = FileSystemStorage(location='media/' + lib_type + '/')
new_filename = user.username + "_" + request_date.strftime('%d_%m_%Y') + "_" + lib_file.name
# directory = os.path.join(fs.location, lib_type)
if not os.path.exists(fs.location):
os.makedirs(fs.location)
filename = fs.save(new_filename, lib_file)
uploaded_file_url = fs.url(lib_type + '/' + filename)
c.file = uploaded_file_url
sv_library = c.save()
# if not sv_library:
# c.delete()
# messages.error(page.request, 'Error: Cannot Upload file')
messages.success(page.request, 'Success: Add new course')
return HttpResponseRedirect("/lab/library")
c.delete()
messages.error(page.request, 'Error: Saving Library')
template_env = {
'topmenu_items': topmenu_items('Add new library', page.request),
'username': usera.username, # the_user(request),
'errors': self.errors,
'title': "Add New Library"
}
template_env.update(page.prelude_env())
return render(request, 'library-add.html', template_env)
def get_context_data(self, **kwargs):
page = Page(self.request)
page.add_js_files([
"js/jquery.validate.js", "js/my_account.register.js",
"js/my_account.edit_profile.js"
])
page.add_css_files(["css/account_view.css", "css/plugin.css"])
# @qursaan
# user_details = MyUser.objects.filter(email=the_user(self.request))
# user_query = Query().get('local:user').select('config','email','status')
# user_details = execute_query(self.request, user_query)
usera = UserAccessProfile(self.request)
user_detail = usera.user_obj # get_user_by_email(the_user(self.request))
# not always found in user_details...
config = {}
user_status = 'N/A'
user_fname = '?'
user_lname = '?'
user_authu = 'Unknown Authority'
# for user_detail in user_details:
if user_detail:
# different significations of user_status
if user_detail.status == 0:
user_status = 'Disabled'
elif user_detail.status == 1:
user_status = 'Validation Pending'
elif user_detail.status == 2:
user_status = 'Enabled'
else:
user_status = 'N/A'
user_fname = user_detail.first_name
user_lname = user_detail.last_name
user_authu = user_detail.authority_hrn
context = super(AccountView, self).get_context_data(**kwargs)
# context['principal_acc'] = principal_acc_list
# context['ref_acc'] = ref_acc_list
# context['platform_list'] = platform_list
# context['my_users'] = my_users
# context['my_slices'] = my_slices
# context['my_auths'] = my_auths
context['user_status'] = user_status
context['person'] = self.request.user
context['firstname'] = user_fname # config.get('firstname',"?")
context['lastname'] = user_lname # config.get('lastname',"?")
context['fullname'] = context['firstname'] + ' ' + context['lastname']
context[
'authority'] = user_authu # config.get('authority',"Unknown Authority")
# context['user_private_key'] = account_priv_key
# XXX This is repeated in all pages
# more general variables expected in the template
context['title'] = 'Account Information'
# the menu items on the top
context['topmenu_items'] = topmenu_items(
'My Account', page.request) # @qursaan change from _live
# so we can sho who is logged
context['username'] = usera.username
prelude_env = page.prelude_env()
context.update(prelude_env)
return context
def action_load_save_image(request, action):
stype = request.POST.get('stype', None)
if stype is None:
return HttpResponse("error: Please go back and try again",
content_type="text/plain")
if not slice_on_time(request, stype):
return HttpResponse('eof', content_type="text/plain")
# for any action ############# TODO: @qursaan
# node_name = None
if action == 'load':
node_name = request.POST.getlist('the_node[]', None)
else: # Save
node_name = request.POST.get('the_node', None)
if not node_name:
return HttpResponse("error: Please select at least one node",
content_type="text/plain")
slice_id = request.session.get('slice_id', None)
if slice_id is None:
return HttpResponse("error: Please go back and try again")
slice_id = int(slice_id)
task_id = None
task_id_list = None
if action == 'load':
task_id_list = []
for n in node_name:
task_id = str(get_task_id(slice_id, n, stype))
task_id_list.append(task_id)
else: # Save
task_id = get_task_id(slice_id, node_name, stype)
if task_id:
if not check_next_task_duration(task_id, stype):
return HttpResponse('warning: wait 5 min before next try',
content_type="text/plain")
# end for any action ###########
r = 0
# if stype == 'omf':
# for load action ###########
if action == 'load':
os_id = request.POST.get('the_os', '')
os_type = request.POST.get('the_type', '')
os_location = ''
os_obj = None
if os_type == 'base_image':
if stype == 'omf':
os_obj = TestbedImage.objects.get(id=os_id)
elif stype == 'sim':
os_obj = SimulationImage.objects.get(id=os_id)
elif os_type == 'user_image':
os_obj = UserImage.objects.get(id=os_id)
if os_obj:
os_location = os_obj.location
r = load_images(task_id_list, os_location, ".", node_name)
if r == 1:
for t in task_id_list:
update_task_testbed(t, action, stype)
# for save action ###########
elif action == 'save':
user_image_name = request.POST.get('the_image',
'untitled').replace(" ", "_")
if user_image_name == '':
user_image_name = "untitled"
usera = UserAccessProfile(request)
#user_name = the_user(request)
user = usera.user_obj # get_user_by_email(user_name)
r = save_images(task_id, user_image_name, ".", node_name)
if r == 1:
image_name = user_image_name + "_" + node_name
update_user_images(image_name, user, usera.session_username)
update_task_testbed(task_id, action, stype)
# for any action ##########
if r == 1:
return HttpResponse('success: start ' + action + ' ...',
content_type="text/plain")
return HttpResponse('error: Unable to ' + action + ' image',
content_type="text/plain")
def get(self, request, slicename=tmp_default_slice):
page = Page(request)
page.add_css_files('css/slice-view.css')
page.add_js_files(["js/common.functions.js"])
page.add_js_chunks(
'$(function() { messages.debug("sliceview: jQuery version " + $.fn.jquery); });'
)
page.add_js_chunks(
'$(function() { messages.debug("sliceview: users turned %s"); });'
% ("on" if do_query_users else "off"))
page.add_js_chunks(
'$(function() { messages.debug("sliceview: leases turned %s"); });'
% ("on" if do_query_leases else "off"))
page.add_js_chunks(
'$(function() { messages.debug("manifold URL %s"); });' %
(ConfigEngine().manifold_url()))
# metadata = page.get_metadata()
# resource_md = metadata.details_by_object('resource')
# resource_fields = [column['name'] for column in resource_md['column']]
# user_md = metadata.details_by_object('user')
# user_fields = ['user_hrn'] # [column['name'] for column in user_md['column']]
# TODO The query to run is embedded in the URL
main_query = Query.get('slice').filter_by('slice_hrn', '=', slicename)
main_query.select(
'slice_hrn',
# 'resource.hrn', 'resource.urn',
'resource.hostname',
'resource.type',
'resource.network_hrn',
'lease.urn',
'user.user_hrn',
# 'application.measurement_point.counter'
)
# for internal use in the querytable plugin;
# needs to be a unique column present for each returned record
main_query_init_key = 'hostname'
# variables that will get passed to the view-unfold1.html template
template_env = {}
# define 'unfold_main' to the template engine - the main contents
# template_env [ 'unfold_main' ] = main_stack.render(request)
# more general variables expected in the template
template_env['title'] = '%(slicename)s' % locals()
# the menu items on the top
template_env['topmenu_items'] = topmenu_items('Slice', page.request)
# so we can sho who is logged
template_env['username'] = UserAccessProfile(request).username
# don't forget to run the requests
# page.expose_js_metadata()
# the prelude object in page contains a summary of the requirements() for all plugins
# define {js,css}_{files,chunks}
template_env.update(page.prelude_env())
return render_to_response('view-unfold1.html',
template_env,
context_instance=RequestContext(request))
def get_or_post(self, request, method, exp_id):
usera = UserAccessProfile(request)
self.user_email = usera.username
page = Page(request)
self.errors = []
# print "EXP:", exp_id
user = usera.user_obj # get_user_by_email(the_user(self.request))
user_type = usera.user_type # get_user_type(user)
if user_type != 3 or exp_id is None:
messages.error(
page.request,
'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
exp = Experiments.objects.get(id=exp_id)
max_duration = exp.max_duration
start_time = None
end_time = None
if exp.server_type == "omf":
start_time = exp.reservation_ref.start_time
end_time = exp.reservation_ref.end_time
elif exp.server_type == "sim":
start_time = exp.sim_reservation_ref.start_time
end_time = exp.sim_reservation_ref.end_time
s = None
if method == 'POST':
self.errors = []
request_date = timezone.now(
) # request.POST.get('request_date', '')
authority_hrn = get_authority_by_user(usera.username)
purpose = request.POST.get('ex_detail', '')
# date
start_date = request.POST.get('req_time_date1', '')
start_date = parser.parse(start_date)
end_date = request.POST.get('req_time_date2', '')
end_date = parser.parse(end_date)
# time
start_time = request.POST.get('req_time_time1', '')
end_time = request.POST.get('req_time_time2', '')
h1 = int(parser.parse(start_time).strftime('%H'))
h2 = int(parser.parse(end_time).strftime('%H'))
m1 = int(parser.parse(start_time).strftime('%M'))
m2 = int(parser.parse(end_time).strftime('%M'))
start_datetime = start_date + timedelta(hours=h1, minutes=m1)
end_datetime = end_date + timedelta(hours=h2, minutes=m2)
diff = end_datetime - start_datetime
dur = diff.seconds / 60 / 60
slice_duration = request.POST.get('max_duration', dur)
if request_date is None or request_date == '':
self.errors.append(
'Please, determine the request date and time')
if purpose is None or purpose == '':
self.errors.append('Purpose is mandatory')
if not self.errors:
exp = Experiments.objects.get(id=exp_id)
if exp.server_type == "omf":
s = Reservation(
user_ref=user,
username=usera.session_username,
f_start_time=start_datetime,
f_end_time=end_datetime,
slice_name=exp.reservation_ref.slice_name,
slice_duration=slice_duration, # approve_date
request_date=request_date,
authority_hrn=authority_hrn,
request_type=exp.reservation_ref.request_type,
base_image_ref=exp.reservation_ref.
base_image_ref, # ref
purpose=purpose,
status=ReservationStatus.get_pending(),
)
s.save()
resources = ReservationDetail.objects.filter(
reservation_ref=exp.reservation_ref)
for i in resources:
p = ReservationDetail(
reservation_ref=s,
node_ref=i.node_ref,
image_ref=i.image_ref,
)
p.save()
freq_group = ReservationFrequency.objects.filter(
reservation_ref=exp.reservation_ref)
for i in freq_group:
p = ReservationFrequency(reservation_ref=s,
frequency_ref=i.frequency_ref)
p.save()
# TODO: @qursaan
if not schedule_auto_online(
s.id, "omf", use_bulk=True, reserve_type="R"):
self.errors.append('Sorry, Time slot is not free')
s.delete()
elif exp.server_type == "sim":
s = SimReservation(
user_ref=user,
username=usera.session_username,
slice_name=exp.sim_reservation_ref.slice_name,
slice_duration=slice_duration, # approve_date
request_date=request_date,
f_start_time=start_datetime,
f_end_time=end_datetime,
authority_hrn=authority_hrn,
request_type=exp.sim_reservation_ref.request_type,
image_ref=exp.sim_reservation_ref.image_ref, # ref
node_ref=exp.sim_reservation_ref.node_ref, # ref
purpose=purpose,
status=ReservationStatus.get_pending(),
n_processor=exp.sim_reservation_ref.sim_no_proc,
n_ram=exp.sim_reservation_ref.sim_ram_size,
)
s.save()
# TODO: @qursaan
if not schedule_auto_online(
s.id, "sim", use_bulk=True, reserve_type="R"):
self.errors.append('Sorry, Time slot is not free')
s.delete()
if not self.errors:
# save experiment
se = StudentsExperiment(
students_ref=user,
experiment_ref=exp,
start_time=start_datetime,
end_time=end_datetime,
status=0,
)
if exp.server_type == "omf":
se.reservation_ref = s
elif exp.server_type == "sim":
se.sim_reservation_ref = s
se.save()
template_env = {
'topmenu_items': topmenu_items('Request Slice', request),
'username': usera.username,
'title': 'Request',
}
template_env.update(page.prelude_env())
return render(request, 'slice-request-ack-view.html',
template_env) # Redirect after POST
template_name = "std-experiments-add.html"
template_env = {
'topmenu_items': topmenu_items('Reserve Experiment', page.request),
'username': usera.username,
'ex_title': exp.title,
'exp_id': exp_id,
'max_duration': max_duration,
'start_date': start_time,
'end_date': end_time,
'title': 'Reserve Experiment',
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_or_post(self, request, method, course_id):
usera = UserAccessProfile(request)
self.user_email = usera.username #the_user(request)
page = Page(request)
course_title = ''
course_key = ''
course_detail = ''
course_max = ''
course_code = ''
course_emails = ''
if method == 'GET' and course_id:
c = Course.objects.get(id=course_id)
if c:
course_title = c.title
course_key = c.key
course_detail = c.description
course_max = c.max_students
course_code = c.code
course_emails = c.email_list
if method == 'POST':
self.errors = []
course_title = request.POST.get('course_title', '')
course_key = request.POST.get('course_key', '')
course_detail = request.POST.get('course_detail', '')
course_max = request.POST.get('course_max', '')
course_code = request.POST.get('course_code', '')
course_emails = request.POST.get('course_emails', '')
user = usera.user_obj #get_user_by_email(the_user(self.request))
user_type = usera.user_type #get_user_type(user)
if user_type != 2:
messages.error(
page.request,
'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
if course_title is None or course_title == '':
self.errors.append('Course title is mandatory')
if course_key is None or course_key == '':
self.errors.append('Course key is mandatory')
if not self.errors:
sv_course = False
if not course_id:
c = Course(
instructor_ref=user,
title=course_title,
code=course_code,
key=course_key,
description=course_detail,
max_students=course_max,
email_list=course_emails,
)
sv_course = c.save()
else:
c = Course.objects.get(id=course_id)
if c:
c.title = course_title
c.code = course_code
c.key = course_key
c.description = course_detail
c.max_students = course_max
c.email_list = course_emails
sv_course = c.save()
#if sv_course:
# look for add student already register
s_email = [x.strip() for x in course_emails.split(',')]
for se in s_email:
add_course_by_email(c, se)
messages.error(page.request, 'Success: Add new course')
return HttpResponseRedirect("/lab/courses")
# template_env = {
# 'topmenu_items': topmenu_items('Add a course', page.request),
# 'username': the_user(request),
# 'title': "Add New Course",
# }
# template_env.update(page.prelude_env())
# return render(request, 'courses-add.html', template_env) # Redirect after POST
template_env = {
'topmenu_items': topmenu_items('Add a course', page.request),
'username': usera.username, #the_user(request),
'errors': self.errors,
'course_title': course_title,
'course_key': course_key,
'course_code': course_code,
'course_detail': course_detail,
'course_max': course_max,
'course_emails': course_emails,
'title': "Add New Course"
}
template_env.update(page.prelude_env())
return render(request, 'ins-courses-add.html', template_env)
def get_or_post(self, request, method):
template_name = "slice-control-view.html"
page = Page(self.request)
page.add_js_files([
"js/jquery-1.11.1.js", "js/my_account.register.js",
"js/my_account.edit_profile.js"
])
page.add_css_files(["css/plugin.css"]) # "css/onelab.css"
image_list = None
current_slice = None
user_image_list = []
node_list = []
freq_list = []
allow_ssh = True
allow_crt = True
allow_img = True
supp_file = None
show_lab = False
lab_ref = None
lab_param_list = []
# vnc_link_access = None
# vnc = False
usera = UserAccessProfile(self.request)
user = usera.user_obj # get_user_by_email(the_user(self.request))
if usera.access_all is False:
user_image_list = UserImage.objects.filter(
user_ref=user, username=usera.session_username).all()
elif user:
user_image_list = UserImage.objects.filter(user_ref=user).all()
user_type = usera.user_type # get_user_type(user)
slice_id = page.request.session.get('slice_id', None)
stype = page.request.session.get('stype', None)
t = ''
if not slice_id or not slice_on_time(page.request, stype):
# messages.error(page.request, 'Error: You have not permission to access this page.')
return HttpResponseRedirect("/portal/lab/current/")
if slice_id:
if stype == "omf":
current_slice = Reservation.objects.get(id=slice_id)
node_list = ReservationDetail.objects.filter(
reservation_ref=current_slice)
freq_list = ReservationFrequency.objects.filter(
reservation_ref=current_slice)
image_list = TestbedImage.objects.all()
t = 'Testbeds Remote Control Panel'
elif stype == "sim":
current_slice = SimReservation.objects.get(id=slice_id)
node_list = SimReservation.objects.filter(
id=slice_id) # current_slice.vm_ref
image_list = SimulationImage.objects.all()
t = 'Simulation Remote Control Panel'
# active_page = page.request.session.get('active_page','0')
if not current_slice:
return HttpResponseRedirect("/portal/lab/current/")
if user_type == 3:
allow_crt, allow_img, allow_ssh, supp_file, lab_ref, lab_param_list = get_control_options(
stype, current_slice)
if lab_ref:
show_lab = True
output_script = ''
template_env = {
'topmenu_items': topmenu_items('Control Panel', page.request),
# 'errors': errors,
'image_list': image_list,
'slice_id': slice_id,
'deadline': current_slice.end_time,
'user_image_list': user_image_list,
'node_list': node_list,
'freq_list': freq_list,
'output': output_script,
'username': usera.username, # the_user(self.request),
'user_id': user.id,
'title': t,
'stype': stype,
'allow_ssh': allow_ssh,
'allow_crt': allow_crt,
'allow_img': allow_img,
'supp_file': supp_file,
'show_lab': show_lab,
'lab_ref': lab_ref,
'lab_param_list': lab_param_list,
'vnc_link_access': "http://" + BACKENDIP + ":6080/vnc.html",
'terminal_ip': "https://" + BACKENDIP + ":4200/"
# 'vnc' :vnc,
}
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_or_post(self, request, method, url):
usera = UserAccessProfile(request)
self.user_email = usera.username # the_user(request)
page = Page(request)
reserve_type = None
use_bulk = False
maintenance = False
if url == "reservation":
reserve_type = "R"
elif url == "reservation_a":
reserve_type = "M"
maintenance = True
elif url == "bulk":
reserve_type = "I"
use_bulk = True
user_hrn = usera.username # the_user(request)
usera = UserAccessProfile(request)
user = usera.user_obj # get_user_by_email(user_hrn)
user_type = usera.user_type # get_user_type(user)
if user_type != 2 and reserve_type == "I": # (user_type != 1 and reserve_type == "R")
messages.error(
page.request,
'Error: You have not permission to access this page.')
return HttpResponseRedirect("/")
print("UT: ", reserve_type, "template: ", url)
# Load System Parameters
sim_max_duration = MAX_SIM_DURATION
omf_max_duration = MAX_OMF_DURATION
# bulk_max_duration = MAX_BUK_DURATION
template_name = None
courses_list = None
slice_name = ''
purpose = ''
if reserve_type == "I":
courses_list = Course.objects.filter(instructor_ref=user)
labs_list = LabsTemplate.objects.all()
template_name = "ins-experiments-add.html"
omf_max_duration = sim_max_duration
elif reserve_type == "R":
template_name = "reservation-view.html"
elif reserve_type == "M":
template_name = "reservation-view.html"
slice_name = "Maintenance"
purpose = "HW Maintenance"
s = None
if method == 'POST':
self.errors = []
ex_title = None
ex_course = None
ex_due_date = None
ex_detail = None
# ex_reserve_type = None
ex_max_duration = None
ex_allow_shh = None
ex_allow_crt = None
ex_allow_img = None
ex_file = None
ex_use_labs = None
ex_idx_lab = None
ex_tmp_lab = None
if reserve_type == "I":
ex_title = request.POST.get('ex_title', '')
ex_course = request.POST.get('ex_course', '')
ex_due_date = request.POST.get('due_date', '')
ex_detail = request.POST.get('ex_detail', '')
# ex_reserve_type = request.POST.get('reserve_type', '')
ex_max_duration = request.POST.get('max_duration', '')
if len(request.FILES) > 0:
ex_file = request.FILES['ex_file']
ex_allow_shh = request.POST.get('allow_ssh', False)
ex_allow_crt = request.POST.get('allow_crt', False)
ex_allow_img = request.POST.get('allow_img', False)
ex_use_labs = request.POST.get('use_lab', False)
ex_idx_lab = int(request.POST.get('pre_exp', '-1'))
ex_tmp_lab = request.POST.getlist('t_lab', [])
if ex_title is None or ex_title == '':
self.errors.append('Experiment Name is mandatory')
if ex_due_date is None or ex_due_date == '':
self.errors.append('ex_due_date is mandatory')
authority_hrn = get_authority_by_user(usera.username)
slice_name = request.POST.get('slice_name', slice_name)
server_type = request.POST.get('server_type', '')
request_type = request.POST.get('request_type', '')
request_date = timezone.now(
) # request.POST.get('request_date', '')
resource_group = request.POST.getlist('resource_group', [])
if server_type == "omf":
omf_img = request.POST.get('omf_img', '')
freq_group = request.POST.getlist('freq_group', [])
elif server_type == "sim":
sim_img = request.POST.get('sim_img', '')
sim_vm = request.POST.get('sim_vm', '1')
sim_no_proc = request.POST.get('sim_no_proc', '1')
sim_ram_size = request.POST.get('sim_ram_size', '1024')
purpose = request.POST.get('purpose', purpose)
# date
start_date = request.POST.get('req_time_date1', '')
start_date = parser.parse(start_date)
end_date = request.POST.get('req_time_date2', '')
end_date = parser.parse(end_date)
# time
start_time = request.POST.get('req_time_time1', '')
end_time = request.POST.get('req_time_time2', '')
h1 = int(parser.parse(start_time).strftime('%H'))
h2 = int(parser.parse(end_time).strftime('%H'))
m1 = int(parser.parse(start_time).strftime('%M'))
m2 = int(parser.parse(end_time).strftime('%M'))
start_datetime = start_date + timedelta(hours=h1, minutes=m1)
end_datetime = end_date + timedelta(hours=h2, minutes=m2)
diff = end_datetime - start_datetime
dur = diff.seconds / 60 / 60
slice_duration = request.POST.get('slice_duration', dur)
# in case of urgent reservation set duration with time range
if request_type == 'lazy_t':
slice_duration = dur
email = self.user_email
# cc_myself = True
# request_date = parser.parse(request_date)
if request_date is None or request_date == '':
self.errors.append(
'Please, determine the request date and time')
if slice_name is None or slice_name == '':
self.errors.append('Slice Name is mandatory')
if purpose is None or purpose == '':
self.errors.append('Purpose is mandatory')
if not self.errors:
if server_type == "omf":
s = Reservation(
user_ref=user,
username=usera.session_username,
f_start_time=start_datetime,
f_end_time=end_datetime,
slice_name=slice_name,
slice_duration=slice_duration, # approve_date
request_date=request_date,
authority_hrn=authority_hrn,
request_type=request_type, # ref
purpose=purpose,
status=ReservationStatus.get_pending(),
)
if omf_img:
s.base_image_ref = TestbedImage.objects.get(id=omf_img)
s.save()
for i in resource_group:
p = ReservationDetail(
reservation_ref=s,
node_ref=VirtualNode.objects.get(id=i),
)
if omf_img:
p.image_ref = TestbedImage.objects.get(id=omf_img)
p.save()
for i in freq_group:
p = ReservationFrequency(
reservation_ref=s,
frequency_ref=FrequencyRanges.objects.get(id=i),
)
p.save()
# TODO: @qursaan
if not schedule_auto_online(s.id, "omf", use_bulk,
reserve_type):
self.errors.append('Sorry, Time slot is not free')
s.delete()
elif server_type == "sim":
s = SimReservation(
user_ref=user,
username=usera.session_username,
slice_name=slice_name,
slice_duration=slice_duration, # approve_date
request_date=request_date,
f_start_time=start_datetime,
f_end_time=end_datetime,
authority_hrn=authority_hrn,
request_type=request_type,
node_ref=SimulationVM.objects.get(id=sim_vm), # ref
purpose=purpose,
status=ReservationStatus.get_pending(),
n_processor=sim_no_proc,
n_ram=sim_ram_size,
)
if sim_img:
s.image_ref = SimulationImage.objects.get(
id=sim_img) # ref
s.save()
# TODO: @qursaan
if not schedule_auto_online(s.id, "sim", use_bulk,
reserve_type):
self.errors.append('Sorry, Time slot is not free')
s.delete()
if not self.errors:
# save experiment
if reserve_type == "I":
se = Experiments(
title=ex_title,
course_ref=Course.objects.get(id=ex_course),
due_date=parser.parse(ex_due_date),
description=ex_detail,
reservation_type=0,
max_duration=ex_max_duration,
server_type=server_type,
instructor_ref=user,
allow_ssh=ex_allow_shh,
allow_img=ex_allow_img,
allow_crt=ex_allow_crt,
)
if server_type == "omf":
se.reservation_ref = s
elif server_type == "sim":
se.sim_reservation_ref = s
se.save()
# Save file and update
if ex_file:
fs = FileSystemStorage()
new_filename = user.username + "_" + request_date.strftime(
'%d_%m_%Y') + "_" + ex_file.name
filename = fs.save(new_filename, ex_file)
uploaded_file_url = fs.url(filename)
se.sup_files = uploaded_file_url
se.save()
if ex_use_labs and len(ex_tmp_lab) > ex_idx_lab >= 0:
lab_temp_id = int(ex_tmp_lab[ex_idx_lab])
lab_temp_obj = LabsTemplate.objects.get(id=lab_temp_id)
if lab_temp_obj:
se.lab_template_ref = lab_temp_obj
se.save()
# The recipients are the PI of the authority
# TODO: @qursaan
recipients = get_authority_emails(
authority_hrn
) # authority_get_pi_emails(request, authority_hrn)
ctx = {
'email': email,
'slice_name': slice_name,
'authority_hrn': authority_hrn,
'server_type': server_type,
'request_type': request_type,
'slice_duration': slice_duration,
'purpose': purpose,
'request_date': request_date,
}
# if cc_myself:
recipients.append(SUPPORT_EMAIL)
msg = render_to_string('slice-request-email.txt', ctx)
send_mail("CRC user %s requested a slice" % email, msg, email,
recipients)
template_env = {
'topmenu_items': topmenu_items('test_page', request),
'username': usera.username,
'title': 'Request',
}
template_env.update(page.prelude_env())
return render(request, 'slice-request-ack-view.html',
template_env) # Redirect after POST
# Resources
if usera.access_all:
node_list = PhysicalNode.objects.filter(type=0)
sim_vm_list = SimulationVM.objects.all()
freq_list = FrequencyRanges.objects.all()
else:
# profile_list = ResourceProfile.objects.filter(shared=True)
shared_Only = True
node_list = PhysicalNode.objects.filter(shared=shared_Only, type=0)
sim_vm_list = None
freq_list = None
resources_list = VirtualNode.objects.filter(node_ref__id__in=node_list)
resources_info = ResourcesInfo.objects.all()
# Images
sim_img_list = SimulationImage.objects.all()
omf_img_list = TestbedImage.objects.all()
user_used, user_size = check_user_reserve(usera.user_obj)
template_env = {
'topmenu_items': topmenu_items('Request a slice', page.request),
'username': usera.username,
'errors': self.errors,
'slice_name': request.POST.get('slice_name', slice_name),
'server_type': request.POST.get('server_type', ''),
'request_type': request.POST.get('request_type', ''),
'freq_list': freq_list,
'freq_group': request.POST.getlist('freq_group', []),
'node_list': node_list,
'resource_list': resources_list,
'resource_info': resources_info,
'resource_group': request.POST.getlist('resource_group', []),
'sim_vm_list': sim_vm_list,
'sim_vm': request.POST.get('sim_vm', ''),
'sim_no_proc': request.POST.get('sim_no_proc', '1'),
'sim_ram_size': request.POST.get('sim_ram_size', '1024'),
'sim_enable': SIM_RESERVATION,
'sim_max_duration': sim_max_duration,
'omf_max_duration': omf_max_duration,
# 'buk_max_duration': bulk_max_duration,
'sim_img_list': sim_img_list,
'omf_img_list': omf_img_list,
'sim_img': request.POST.get('sim_img', ''),
'slice_duration': request.POST.get('slice_duration', ''),
'number_of_nodes': request.POST.get('number_of_nodes', ''),
'purpose': request.POST.get('purpose', ''),
'email': self.user_email,
'user_hrn': user_hrn,
'user_size': user_size,
'user_used': user_used,
'user_free': user_size - user_used,
# 'login' : user.username,
# 'cc_myself' : True,
'time_now': timezone.now(),
'title': "Reservation System",
# General
'reserve_type': reserve_type,
'maintenance': maintenance,
}
if reserve_type == "I":
if not courses_list:
messages.success(request, 'Success: Add a Course First!')
return HttpResponseRedirect("/lab/courses/")
template_env['ex_title'] = request.POST.get('ex_title', '')
template_env['ex_course'] = request.POST.get('ex_course', '')
template_env['due_date'] = request.POST.get('ex_due_date', '')
template_env['ex_detail'] = request.POST.get('ex_detail', '')
template_env['reserve_type'] = request.POST.get(
'ex_reserve_type', '')
template_env['max_duration'] = request.POST.get(
'ex_max_duration', '')
template_env['ex_courses_list'] = courses_list
template_env['labs_list'] = labs_list
template_env['title'] = "Add New Experiment"
template_env.update(page.prelude_env())
return render(request, template_name, template_env)
def get_or_post(self, request, method):
# Using cache manifold-tables to get the list of authorities faster
# @qursaan: comment and change
# authorities_query = Query.get('authority').select('name', 'authority_hrn')
# authorities = Authority.objects.all() #execute_admin_query(request, authorities_query)
# if authorities is not None:
# authorities = sorted(authorities)
# user_query = User.objects.get()
# user_query = Query().get('local:user').select('email')
# user_email = execute_query(self.request, user_query)
usera = UserAccessProfile(request)
self.user_email = usera.username # user_email[0].get('email')
# account_query = Query().get('local:account').select('user_id','platform_id','auth_type','config')
# account_details = execute_query(self.request, account_query)
# platform_query = Query().get('local:platform').select('platform_id','platform','gateway_type','disabled')
# platform_details = execute_query(self.request, platform_query)
# getting user_hrn from local:account
# for account_detail in account_details:
# for platform_detail in platform_details:
# if platform_detail['platform_id'] == account_detail['platform_id']:
# # taking user_hrn only from myslice account
# # NOTE: we should later handle accounts filter_by auth_type= managed OR user
# if 'myslice' in platform_detail['platform']:
# account_config = json.loads(account_detail['config'])
# user_hrn = account_config.get('user_hrn','N/A')
# user_query = Query().get('user').select('user_hrn').filter_by('user_hrn','==','$user_hrn')
# @qursaan: must change
user_hrn = usera.username # execute_query(self.request, user_query)
# self.user_hrn = user_hrn[0].get('user_hrn')
total_nodes = PhysicalNode.objects.count()
node_list = PhysicalNode.objects.all()
# for i in range(int(total_nodes)):
# node_list.append(i+1)
# total_resources = NodeResource.objects.count()
resources_list = VirtualNode.objects.all(
) # [[range(total_resources)] for x in range(total_nodes)]
resources_info = ResourcesInfo.objects.all()
duration_list = []
for i in range(1, 25, 1):
duration_list.append(i)
sim_os_list = SimulationImage.objects.all()
page = Page(request)
# page.add_css_files(["http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css"])
if method == 'POST':
self.errors = []
# The form has been submitted
slice_name = request.POST.get('slice_name', '')
authority_hrn = get_authority_by_user(
usera.username) # request.POST.get('authority_hrn', '')
request_date = request.POST.get('request_date', '')
server_type = request.POST.get('server_type', '')
request_type = request.POST.get('request_type', '')
resource_group = request.POST.getlist('resource_group', [])
# number_of_nodes = request.POST.get('number_of_nodes', '')
purpose = request.POST.get('purpose', '')
slice_duration = request.POST.get('sim_duration', '1')
sim_os_image = request.POST.get('sim_os', '1')
email = self.user_email
# user_hrn = user_hrn
# cc_myself = True
# print request_date
# 10/01/2015 12:00 PM
request_date = parser.parse(request_date)
print(request_date)
# if (authority_hrn is None or authority_hrn == ''):
# self.errors.append('Please, select an authority')
if request_date is None or request_date == '':
self.errors.append(
'Please, determine the request date and time')
# What kind of slice name is valid?
if slice_name is None or slice_name == '':
self.errors.append('Slice Name is mandatory')
if purpose is None or purpose == '':
self.errors.append('Purpose is mandatory')
if not self.errors:
ctx = {
'email': email,
'slice_name': slice_name,
'authority_hrn': authority_hrn,
'server_type': server_type,
'request_type': request_type,
# 'number_of_nodes': number_of_nodes,
'slice_duration': slice_duration,
'purpose': purpose,
'request_date': request_date,
}
s = PendingSlice(
slice_name=slice_name,
user_hrn=user_hrn,
request_date=request_date,
authority_hrn=authority_hrn,
server_type=server_type,
request_type=request_type,
base_image=sim_os_image,
slice_duration=slice_duration,
# number_of_nodes = number_of_nodes,
purpose=purpose,
status=ReservationStatus.get_pending(),
)
s.save()
# for i in resource_group:
# duration_list.append(i)
# p = PendingReservationDetail(
# slice_id=s,
# node_resource_id=NodeResource.objects.get(id=i),
# )
# p.save()
# schedule_slice(s.id)
# The recipients are the PI of the authority
recipients = get_authority_emails(
authority_hrn
) # authority_get_pi_emails(request, authority_hrn)
# if cc_myself:
recipients.append(SUPPORT_EMAIL)
msg = render_to_string('slice-request-email.txt', ctx)
# print "email, msg, email, recipients", email , msg, email, recipients
send_mail("CRC user %s requested a slice" % email, msg, email,
recipients)
template_env = {
'topmenu_items': topmenu_items('test_page', request),
'username': usera.username,
'title': 'Request',
}
template_env.update(page.prelude_env())
return render(request, 'slice-request-ack-view.html',
template_env) # Redirect after POST
template_env = {
#'topmenu_items': topmenu_items('Request a slice', page.request),
'username': usera.username,
'errors': self.errors,
'slice_name': request.POST.get('slice_name', ''),
# 'authority_hrn': request.POST.get('authority_hrn', ''),
'node_list': node_list,
'resource_list': resources_list,
'resource_info': resources_info,
'duration_list': duration_list,
'sim_os_list': sim_os_list,
'sim_os': request.POST.get('sim_os', ''),
'resource_group': request.POST.getlist('resource_group', []),
'server_type': request.POST.get('server_type', ''),
'request_type': request.POST.get('request_type', ''),
'sim_duration': request.POST.get('slice_duration', ''),
'number_of_nodes': request.POST.get('number_of_nodes', ''),
'purpose': request.POST.get('purpose', ''),
'email': self.user_email,
'user_hrn': user_hrn,
'cc_myself': True,
'time_now': timezone.now(),
# 'authorities': authorities,
'title': "Request a Slice"
}
template_env.update(page.prelude_env())
return render(request, 'slicerequest-view.html', template_env)
