Merge branch 'devel'
[qcg-portal.git] / qcg / views.py
1 # coding=utf-8
2 from datetime import datetime, timedelta
3
4 from django.conf import settings
5 from django.contrib import messages
6 from django.contrib.auth import REDIRECT_FIELD_NAME
7 from django.contrib.auth.decorators import login_required
8 from django.core.exceptions import SuspiciousOperation
9 from django.core.urlresolvers import reverse
10 from django.db.models import Q
11 from django.http import HttpResponse, QueryDict
12 from django.shortcuts import render, get_object_or_404, redirect
13 from django.utils.html import format_html
14 from django.utils.http import urlencode
15 from django.utils.timezone import UTC
16 from django.views.decorators.http import require_POST
17 from django_openid_auth.views import make_consumer
18 from openid.extensions import ax
19 from pyqcg.utils import PyqcgException
20
21 from filex.forms import HostPathNameForm, RenameForm, ArchiveForm, HostPathForm
22 from filex.ftp import FTPOperation, FTPError
23 from filex.views import make_url
24 from qcg.forms import FiltersForm, ColumnsForm, JobDescriptionForm, EnvFormSet, JobTemplateForm
25 from qcg.models import JobTemplate
26 from qcg.utils import paginator_context, to_job_desc, to_form_data, generate_md_inputfile
27 from qcg.service import update_user_data, update_job, cancel, clean
28
29
30 from django.utils import encoding
31 import string
32 import random
33 import os
34 from qcg import constants
35 from qcg.utils import chunks
36 # for Debugging
37 from pprint import pprint
38
39 def index(request):
40     return render(request, 'qcg/base.html')
41
42
43 def openid_begin(request):
44     openid_request = make_consumer(request).begin(settings.OPENID_SSO_SERVER_URL)
45
46     fetch_request = ax.FetchRequest()
47     for (attr, alias) in [('http://axschema.org/namePerson/friendly', 'nickname'),
48                           ('http://axschema.org/contact/email', 'email'),
49                           ('http://axschema.org/namePerson', 'fullname'),
50                           ('http://openid.plgrid.pl/certificate/proxy', 'proxy'),
51                           ('http://openid.plgrid.pl/certificate/userCert', 'userCert'),
52                           ('http://openid.plgrid.pl/certificate/proxyPrivKey', 'proxyPrivKey'),
53                           ('http://openid.plgrid.pl/POSTresponse', 'POSTresponse')]:
54         fetch_request.add(ax.AttrInfo(attr, alias=alias, required=True))
55     openid_request.addExtension(fetch_request)
56
57     return_to = request.build_absolute_uri(reverse('openid-complete'))
58
59     redirect_to = request.GET.get(REDIRECT_FIELD_NAME)
60     if redirect_to:
61         return_to += '?' + urlencode({REDIRECT_FIELD_NAME: redirect_to})
62
63     return HttpResponse(openid_request.htmlMarkup(request.build_absolute_uri('/'), return_to))
64
65
66 search_fields = ('status_description', 'type', 'note', 'task_id', 'job__note', 'job__project', 'job__job_id',
67                  'allocations__status_description', 'allocations__processes_group_id', 'allocations__comment')
68
69
70 def parse_date(string):
71     return datetime.strptime(string.strip(), "%d.%m.%Y").replace(tzinfo=UTC())
72
73
74 @login_required
75 def jobs_list(request):
76     update_user_data(request.user, request.session['proxy'])
77
78     tasks = request.user.tasks.order_by('-job__submission_time', '-submission_time') \
79         .select_related('job').prefetch_related('allocations__nodes')
80
81     filters = FiltersForm(request.GET)
82     selected_filters = []
83     if filters.is_valid():
84         keywords = filters.cleaned_data['keywords']
85         status = filters.cleaned_data['status']
86         host = filters.cleaned_data['host']
87         purged = filters.cleaned_data['purged']
88         submission = filters.cleaned_data['submission']
89         finish = filters.cleaned_data['finish']
90
91         if keywords:
92             and_query = Q()
93
94             for q in keywords.split():
95                 or_query = Q()
96                 for field in search_fields:
97                     or_query |= Q(**{field + '__icontains': q})
98                 and_query &= or_query
99
100             tasks = tasks.filter(and_query)
101             selected_filters.append((keywords, 'keywords', keywords))
102
103         if status:
104             statuses = []
105             for s in status:
106                 si = int(s)
107                 statuses.extend(FiltersForm.STATUS_MAP[si])
108                 selected_filters.append((FiltersForm.STATUS_CHOICES_DICT[si], 'status', s))
109
110             tasks = tasks.filter(status__in=statuses)
111
112         if host:
113             tasks = tasks.filter(allocations__host_name__in=host)
114
115             host_dict = dict(filters.fields['host'].choices)
116             for h in host:
117                 selected_filters.append((host_dict[h], 'host', h))
118
119         if isinstance(purged, bool):
120             tasks = tasks.filter(purged=purged)
121
122             if purged:
123                 selected_filters.append((u"Usunięty katalog roboczy", 'purged', '1'))
124             else:
125                 selected_filters.append((u"Istniejący katalog roboczy", 'purged', '0'))
126
127         if submission:
128             start, end = submission.split('-')
129
130             tasks = tasks.filter(submission_time__gte=parse_date(start),
131                                  submission_time__lte=parse_date(end) + timedelta(days=1))
132             selected_filters.append((u'Data zlecenia: ' + submission, 'submission', submission))
133
134         if finish:
135             start, end = finish.split('-')
136
137             tasks = tasks.filter(finish_time__gte=parse_date(start),
138                                  finish_time__lte=parse_date(end) + timedelta(days=1))
139             selected_filters.append((u'Data zakończenia: ' + finish, 'finish', finish))
140
141         tasks = tasks.distinct()
142
143     checked_status = {i: widget.is_checked() for i, widget in enumerate(filters['status'])}
144
145     columns = ColumnsForm(QueryDict(request.COOKIES.get('columns', '')))
146
147     displayed = None
148     if columns.is_valid():
149         displayed = {int(c) for c in columns.cleaned_data['columns']}
150
151     # if invalid or empty
152     if not displayed:
153         displayed = set(columns.fields['columns'].initial)
154
155     context = {'filters': filters, 'checked_status': checked_status, 'selected_filters': selected_filters,
156                'columns': ColumnsForm(initial={'columns': displayed}), 'displayed': displayed}
157
158     context.update(paginator_context(request, tasks))
159
160     return render(request, 'qcg/jobs.html', context)
161
162
163 @login_required
164 def job_details(request, job_id):
165     job = get_object_or_404(request.user.jobs.prefetch_related('tasks'), job_id=job_id)
166
167     return render(request, 'qcg/job.html', process_details(request, job))
168
169
170 @login_required
171 def task_details(request, job_id, task_id):
172     task = get_object_or_404(request.user.tasks.select_related('job').prefetch_related('allocations'),
173                              job__job_id=job_id, task_id=task_id)
174
175     return render(request, 'qcg/task.html', process_details(request, task.job, task))
176
177
178 def process_details(request, job, task=None):
179     if not job.terminated or not job.purged:
180         update_job(job, request.session['proxy'])
181
182     form_data = to_form_data(job.qcg_description)
183     env_formset_data = [{'name': name, 'value': value} for name, value in form_data.pop('env_variables', ())]
184
185     form = JobDescriptionForm(initial=form_data)
186     env_formset = EnvFormSet(initial=env_formset_data)
187     template_form = JobTemplateForm(initial={'name': (task and task.note) or u'Szablon z {}'.format(job.job_id)})
188
189     for field in form:
190         field.field.widget.attrs['disabled'] = 'True'
191     for env_form in env_formset:
192         for field in env_form:
193             field.field.widget.attrs['disabled'] = 'True'
194
195     return {'job': job, 'task': task, 'form': form, 'env_formset': env_formset, 'template_form': template_form}
196
197
198 def id_generator(size=6, chars=string.ascii_uppercase + string.digits):
199     return ''.join(random.choice(chars) for _ in range(size))
200
201 @login_required
202 def job_submit(request, template_id=None):
203     save_template = 'save-template' in request.POST
204     template = get_object_or_404(request.user.templates, id=template_id) if template_id is not None else None
205
206     if template is not None:
207         form_data = to_form_data(template.description)
208         env_formset_data = [{'name': name, 'value': value} for name, value in form_data.pop('env_variables', ())]
209     else:
210         form_data, env_formset_data = None, None
211
212     if request.method == 'POST':
213         form = JobDescriptionForm(request.POST, initial=form_data)
214         env_formset = EnvFormSet(request.POST, initial=env_formset_data)
215         template_form = JobTemplateForm(request.POST, prefix='template', instance=template)
216
217         if form.is_valid() and env_formset.is_valid() and (not save_template or template_form.is_valid()):
218             params = form.cleaned_data
219             params['env_variables'] = [(env['name'], env['value'])
220                                        for env in env_formset.cleaned_data if env and not env['DELETE']]
221
222             # Generowanie pliku inputowego
223             md_input=generate_md_inputfile(params)
224             url=os.path.splitext(params['pdb_file'])[0]+'_MD_genarated.inp'
225             params['master_file']=url
226             params['stage_in'].append(params['pdb_file'])
227             # Upload
228             ftp = FTPOperation(request.session['proxy'])
229             ftp.put(url)
230             for chunk in chunks('\n'.join([str(i) for i in md_input] ), 4096):
231                 ftp.stream.put(chunk)
232             ftp.stream.put(None)
233             ftp.wait()
234             
235             params['persistent'] = True
236
237             job_desc = to_job_desc(params, request.session['proxy'])
238
239
240             if save_template:
241                 template = template_form.save(commit=False)
242
243                 template.owner = request.user
244                 template.description = job_desc.xml_description
245                 template.save()
246
247                 return redirect(template)
248             
249             job = job_desc.submit()
250
251             messages.success(request,
252                              format_html('<span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span> '
253                                          u'Zlecono zadanie <em>{}</em>.', job.job_id))
254             
255             return redirect('jobs')
256     else:
257         form = JobDescriptionForm(initial=form_data)
258         env_formset = EnvFormSet(initial=env_formset_data)
259         template_form = JobTemplateForm(prefix='template', instance=template)
260
261     errors = form.errors or (env_formset.is_bound and not env_formset.is_valid) or (
262         save_template and template_form.errors)
263
264     return render(request, 'qcg/job_submit.html', {'form': form, 'env_formset': env_formset, 'errors': errors,
265                                                    'template_form': template_form, 'template': template})
266
267
268 @require_POST
269 @login_required
270 def job_cancel(request, job_id):
271     return obj_cancel(request, get_object_or_404(request.user.jobs, job_id=job_id))
272
273
274 @require_POST
275 @login_required
276 def task_cancel(request, job_id, task_id):
277     return obj_cancel(request, get_object_or_404(request.user.tasks, job__job_id=job_id, task_id=task_id))
278
279
280 def obj_cancel(request, obj):
281     try:
282         cancel(obj, request.session['proxy'])
283     except PyqcgException as e:
284         messages.error(request, format_html('<span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span> {}',
285                                             e.message))
286     else:
287         messages.success(request, format_html('<span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span> '
288                                               'Zadanie anulowano.'))
289
290     return redirect(obj)
291
292
293 @require_POST
294 @login_required
295 def job_clean(request, job_id):
296     return obj_clean(request, get_object_or_404(request.user.jobs, job_id=job_id))
297
298
299 @require_POST
300 @login_required
301 def task_clean(request, job_id, task_id):
302     return obj_clean(request, get_object_or_404(request.user.tasks, job__job_id=job_id, task_id=task_id))
303
304
305 def obj_clean(request, obj):
306     try:
307         clean(obj, request.session['proxy'])
308     except PyqcgException as e:
309         messages.error(request, format_html('<span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span> {}',
310                                             e.message))
311     else:
312         messages.success(request, format_html('<span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span> '
313                                               'Usunięto katalog roboczy.'))
314
315     return redirect(obj)
316
317
318 @login_required
319 def gridftp(request):
320     return render(request, 'qcg/gridftp.html',
321                   {'new_dir_form': HostPathNameForm(), 'rename_form': RenameForm(), 'archive_form': ArchiveForm()})
322
323
324 @login_required
325 def gridftp_upload(request):
326     form = HostPathForm(request.GET)
327
328     if not form.is_valid():
329         raise SuspiciousOperation('Invalid parameters for `gridftp_upload`!')
330
331     error = None
332     try:
333         FTPOperation(request.session['proxy']).info(make_url(form.cleaned_data, 'path'))
334     except FTPError as e:
335         error = e.message
336
337     return render(request, 'qcg/gridftp_upload.html',
338                   {'error': error, 'url': reverse('filex:upload') + '?' + urlencode(form.cleaned_data),
339                    'host': form.cleaned_data['host'], 'path': form.cleaned_data['path'],
340                    'sep': '/' if form.cleaned_data['path'].startswith('~') else ''})
341
342
343 @login_required
344 def job_templates(request):
345     return render(request, 'qcg/job_templates.html', {'templates': request.user.templates.all()})
346
347
348 @require_POST
349 @login_required
350 def template_delete(request, template_id):
351     template = get_object_or_404(request.user.templates, id=template_id)
352     template.delete()
353
354     messages.success(request, format_html('<span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span> '
355                                           u'Usunięto szablon <em>{}</em>.', template.name))
356
357     return redirect('job_templates')
358
359
360 @require_POST
361 @login_required
362 def job_save_template(request, job_id):
363     job = get_object_or_404(request.user.jobs, job_id=job_id)
364
365     template_form = JobTemplateForm(request.POST,
366                                     instance=JobTemplate(owner=request.user, description=job.qcg_description))
367
368     if template_form.is_valid():
369         template = template_form.save()
370
371         return redirect(template)
372
373     messages.error(request, format_html('<span class="glyphicon glyphicon-info-sign" aria-hidden="true"></span> {}'
374                                         'Nie udało się zapisać szablonu!', template_form.errors))
375
376     return redirect(job)