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