sla/slicetabsla.py

   1 # this somehow is not used anymore - should it not be ?
   2 from django.template import RequestContext
   3 from django.shortcuts import render_to_response
   4 from django.shortcuts import render
   5 from django import forms
   6
   7 from unfold.loginrequired import FreeAccessView
   8 from unfold.page import Page
   9 from sla.slaclient import restclient
  10 from sla.slaclient import wsag_model
  11 import wsag_helper
  12 from myslice.theme import ThemeView
  13 # from sla import SLAPlugin
  14 from django.core.urlresolvers import reverse
  15 from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
  16
  17 import slaclient.service.fed4fire.fed4fireservice as fed4fireservice
  18 from rest_framework.views import APIView
  19 from django.http import HttpResponse
  20
  21 import json
  22 import traceback
  23 from math import ceil
  24
  25
  26 class Rol:
  27     CONSUMER = "CONSUMER"
  28     PROVIDER = "PROVIDER"
  29
  30
  31 class AgreementsFilter(object):
  32     def __init__(self, status=None, provider=None, consumer=None):
  33         self.status = status
  34         self.provider = provider
  35         self.consumer = consumer
  36
  37     def __repr__(self):
  38         return "<AgreementsFilter(status={}, provider={}, consumer={})>".format(
  39             self.status, self.provider, self.consumer
  40         )
  41
  42     @staticmethod
  43     def _check(expectedvalue, actualvalue):
  44         if expectedvalue is None or expectedvalue == '':
  45             return True
  46         else:
  47             return actualvalue == expectedvalue
  48
  49     def check(self, agreement):
  50         """Check if this agreement satisfy the filter.
  51
  52         The agreement must be previously annotated
  53         """
  54         guaranteestatus = agreement.guaranteestatus
  55         provider = agreement.context.provider
  56         consumer = agreement.context.consumer
  57         return (
  58             AgreementsFilter._check(self.status, guaranteestatus) and
  59             AgreementsFilter._check(self.provider, provider) and
  60             AgreementsFilter._check(self.consumer, consumer)
  61         )
  62
  63
  64 class FilterForm(forms.Form):
  65     _attrs = {'class': 'form-control'}
  66     exclude = ()
  67     status = forms.ChoiceField(
  68         choices=[
  69             ('', 'All'),
  70             (wsag_model.AgreementStatus.StatusEnum.FULFILLED, 'Fulfilled'),
  71             (wsag_model.AgreementStatus.StatusEnum.VIOLATED, 'Violated'),
  72             (wsag_model.AgreementStatus.StatusEnum.NON_DETERMINED, 'Non determined')],
  73         widget=forms.Select(attrs=_attrs),
  74         required=False
  75     )
  76     provider = forms.CharField(
  77         widget=forms.TextInput(attrs=_attrs),
  78         required=False
  79     )
  80     consumer = forms.CharField(
  81         widget=forms.TextInput(attrs=_attrs),
  82         required=False
  83     )
  84
  85
  86 class SLAView (FreeAccessView, ThemeView):
  87     template_name = 'slice-tab-sla.html'
  88
  89     def get (self, request, slicename, state=None):
  90
  91         page=Page(request)
  92
  93         consumer_id = None
  94         agreement_id = None
  95         enforcements = {}
  96         violations = {}
  97         keys = ['provider','agreement','date','status','result','ok']
  98         ag_info = []
  99
 100         filter_ = None
 101         form = FilterForm(request.GET)
 102         if form.is_valid():
 103             filter_ = _get_filter_from_form(form)
 104
 105         consumer_id = _get_consumer_id(request)
 106
 107         agreements = _get_agreements(agreement_id, consumer_id=consumer_id, filter_=filter_)
 108
 109         for agreement in agreements:
 110             row = []
 111             row.append(agreement.context.provider) # Provider
 112             row.append(agreement) # Agreement
 113             row.append(agreement.context.time_formatted()) # Date
 114
 115             enf = _get_enforcement(agreement.agreement_id)
 116
 117             if enf.enabled == 'true':
 118                 row.append('Evaluating') # Status
 119                 row.append('') # Result
 120                 row('') # Ok
 121             else:
 122                 if agreement.guaranteestatus == "NON_DETERMINED":
 123                     row.append('Provisioned') # Status
 124                     row.append('') # Result
 125                     row.append('') # Ok
 126
 127                 else:
 128                     row.append('Finished') # Status
 129
 130                     violations_list = _get_agreement_violations(agreement.agreement_id, "GT_Performance")
 131
 132                     if len(violations_list) > 0:
 133                         value = '%.2f'%float(violations_list[0].actual_value)
 134                         row.append('%d'%(float(value)*100)) # Result
 135                     else:
 136                         row.append('100') # Result
 137
 138                     if agreement.guaranteestatus == "VIOLATED":
 139                         row.append('false') # Ok
 140
 141                     if agreement.guaranteestatus == "FULFILLED":
 142                         row.append('true') # Ok
 143
 144             ag_info.append(dict(zip(keys,row)))
 145
 146             # enf = _get_enforcement(agreement.agreement_id)
 147             # if enf.enabled == 'true':
 148             #     enforcements[agreement.agreement_id] = "ACTIVE"
 149             # else:
 150             #     enforcements[agreement.agreement_id] = "UNACTIVE"
 151             # violations_list = _get_agreement_violations(agreement.agreement_id, "GT_Performance")
 152
 153             # if len(violations_list):
 154             #     violations[agreement.agreement_id] = float(violations_list[0]["actualValue"])*100
 155             # else:
 156             #     violations[agreement.agreement_id] = 100
 157
 158         template_env = {}
 159        # write something of our own instead
 160        # more general variables expected in the template
 161         template_env['title'] = 'SLA Agreements'
 162         template_env['agreements'] = agreements
 163         template_env['username'] = request.user
 164         template_env['slicename'] = slicename
 165         template_env['enforcements'] = enforcements
 166         template_env['last_violation_list'] = violations
 167         template_env['ag_info'] = ag_info
 168
 169
 170        # the prelude object in page contains a summary of the requirements() for all plugins
 171        # define {js,css}_{files,chunks}
 172         prelude_env = page.prelude_env()
 173         template_env.update(prelude_env)
 174
 175         return render_to_response(self.template_name, template_env, context_instance=RequestContext(request))
 176
 177
 178 class AgreementsFilter(object):
 179     def __init__(self, status=None, provider=None, consumer=None):
 180         self.status = status
 181         self.provider = provider
 182         self.consumer = consumer
 183
 184     def __repr__(self):
 185         return "<AgreementsFilter(status={}, provider={}, consumer={})>".format(
 186             self.status, self.provider, self.consumer
 187         )
 188
 189     @staticmethod
 190     def _check(expectedvalue, actualvalue):
 191         if expectedvalue is None or expectedvalue == '':
 192             return True
 193         else:
 194             return actualvalue == expectedvalue
 195
 196     def check(self, agreement):
 197         """Check if this agreement satisfy the filter.
 198
 199         The agreement must be previously annotated
 200         """
 201         guaranteestatus = agreement.guaranteestatus
 202         provider = agreement.context.provider
 203         consumer = agreement.context.consumer
 204         return (
 205             AgreementsFilter._check(self.status, guaranteestatus) and
 206             AgreementsFilter._check(self.provider, provider) and
 207             AgreementsFilter._check(self.consumer, consumer)
 208         )
 209
 210
 211 class ContactForm(forms.Form):
 212     subject = forms.CharField(max_length=100)
 213     message = forms.CharField()
 214     sender = forms.EmailField()
 215     cc_myself = forms.BooleanField(required=False)
 216
 217
 218 def _get_agreements_client():
 219     return restclient.Factory.agreements()
 220
 221
 222 def _get_violations_client():
 223     return restclient.Factory.violations()
 224
 225 def _get_enforcements_client():
 226     return restclient.Factory.enforcements()
 227
 228 def _get_consumer_id(request):
 229     return request.user
 230
 231
 232 def _get_agreement(agreement_id):
 233
 234     agreements_client = _get_agreements_client()
 235     agreement, response = agreements_client.getbyid(agreement_id)
 236     return agreement
 237
 238 def _get_enforcement(agreement_id):
 239
 240     enforcements_client = _get_enforcements_client()
 241     enforcement, response = enforcements_client.getbyagreement(agreement_id)
 242     return enforcement
 243
 244 def _get_filter_from_form(form):
 245
 246     data = form.cleaned_data
 247     result = AgreementsFilter(
 248         data["status"], data["provider"], data["consumer"])
 249     return result
 250
 251 def agreement_term_violations(request, agreement_id, guarantee_name):
 252
 253     page = Page(request)
 254     prelude_env = page.prelude_env()
 255
 256     annotator = wsag_helper.AgreementAnnotator()
 257     agreement = _get_agreement(agreement_id)
 258     violations = _get_agreement_violations(agreement_id, guarantee_name)
 259     annotator.annotate_agreement(agreement)
 260
 261     slicename = request.POST.get('slicename')
 262
 263     paginator = Paginator(violations, 25) # Show 25 violations per page
 264     page_num = request.GET.get('page')
 265
 266     try:
 267         violation_page = paginator.page(page_num)
 268     except PageNotAnInteger:
 269         # If page is not an integer, deliver first page.
 270         violation_page = paginator.page(1)
 271     except EmptyPage:
 272         # If page is out of range (e.g. 9999), deliver first page.
 273         violation_page = paginator.page(1)
 274
 275     context = {
 276         'agreement_id': agreement_id,
 277         'guarantee_term': agreement.guaranteeterms[guarantee_name],
 278         'violations': violation_page,
 279         'agreement': agreement,
 280         'slicename': slicename,
 281         'last_violation': violations[-1].actual_value
 282     }
 283
 284     context.update(prelude_env)
 285
 286     return render_to_response ('violations_template.html', context, context_instance=RequestContext(request))
 287 #     return render(request, 'violations_template.html', context)
 288
 289 def agreement_details(request, agreement_id):
 290
 291     page = Page(request)
 292     prelude_env = page.prelude_env()
 293
 294     annotator = wsag_helper.AgreementAnnotator()
 295     agreement = _get_agreement(agreement_id)
 296     violations = _get_agreement_violations(agreement_id)
 297     status = _get_agreement_status(agreement_id)
 298     annotator.annotate_agreement(agreement, status, violations)
 299
 300     violations_by_date = wsag_helper.get_violations_bydate(violations)
 301     context = {
 302         'agreement_id': agreement_id,
 303         'agreement': agreement,
 304         'status': status,
 305         'violations_by_date': violations_by_date
 306     }
 307
 308     context.update(prelude_env)
 309
 310     return render_to_response ('violations_template.html', context, context_instance=RequestContext(request))
 311     #return render(request, 'agreement_detail.html', context)
 312
 313
 314 def _get_agreements_client():
 315     return restclient.Factory.agreements()
 316
 317
 318 def _get_agreement(agreement_id):
 319
 320     agreements_client = _get_agreements_client()
 321     agreement, response = agreements_client.getbyid(agreement_id)
 322     return agreement
 323
 324 def _get_agreements(agreement_id, provider_id=None, consumer_id=None, filter_=None):
 325
 326     agreements_client = _get_agreements_client()
 327     if agreement_id is None:
 328         if consumer_id is not None:
 329             agreements, response = agreements_client.getbyconsumer(consumer_id)
 330         elif provider_id is not None:
 331             agreements, response = agreements_client.getbyprovider(provider_id)
 332         else:
 333             raise ValueError(
 334                 "Invalid values: consumer_id and provider_id are None")
 335     else:
 336         agreement, response = agreements_client.getbyid(agreement_id)
 337         agreements = [agreement]
 338
 339     annotator = wsag_helper.AgreementAnnotator()
 340     for agreement in agreements:
 341         id_ = agreement.agreement_id
 342         status = _get_agreement_status(id_)
 343         annotator.annotate_agreement(agreement, status)
 344
 345     if filter_ is not None:
 346         print "FILTERING ", repr(filter_)
 347         agreements = filter(filter_.check, agreements);
 348     else:
 349         print "NOT FILTERING"
 350     return agreements
 351
 352
 353 def _get_agreements_by_consumer(consumer_id):
 354
 355     agreements_client = _get_agreements_client()
 356     agreements, response = agreements_client.getbyconsumer(consumer_id)
 357     return agreements
 358
 359 def _get_agreement_status(agreement_id):
 360
 361     agreements_client = _get_agreements_client()
 362     status, response = agreements_client.getstatus(agreement_id)
 363     return status
 364
 365 def _get_agreement_violations(agreement_id, term=None):
 366
 367     violations_client = _get_violations_client()
 368     violations, response = violations_client.getbyagreement(agreement_id, term)
 369     return violations
 370
 371
 372 class AgreementSimple(APIView):
 373     def build_response(self, code, text):
 374         response = HttpResponse(text, content_type="text/plain", status=code)
 375         return response
 376
 377     def post( self, request, **kwargs):
 378         #import pdb; pdb.set_trace()
 379         print "------------------------------------------------1"
 380         data = {}
 381         for key, value in request.DATA.items(): # jgarcia review this
 382             new_key = key
 383             data[new_key] = value
 384
 385         try:
 386             template_id = data['template_id']
 387         except:
 388             return self.build_response(400, 'Invalid template_id')
 389
 390         try:
 391             user = data['user']
 392         except:
 393             return self.build_response(400, 'Invalid user')
 394
 395         try:
 396             expiration_time = data['expiration_time']
 397         except:
 398             return self.build_response(400, 'Invalid expiration_time')
 399
 400         try:
 401             print "Calling createagreementsimplified with template_id:",template_id,"and user:",user
 402             result = fed4fireservice.createagreementsimplified(template_id, user, expiration_time)
 403             print result
 404         except Exception, e:
 405             print traceback.format_exc()
 406             print '%s (%s)' % (e, type(e))
 407
 408             return self.build_response(400, 'Problem creating agreement')
 409
 410         return self.build_response(200, result)