def post(self, request, format=None): serializer = AccountSerializer(data=request.data) if serializer.is_valid(): try: if Account.objects.filter(productType=request.data['productType'], instanceId=request.data['instanceId']): print (" [ERROR] There is an entry already with that InstanceId (%s) for the same ProductType (%s)" % (request.data['instanceId'], request.data['productType'])) return Response(status=status.HTTP_400_BAD_REQUEST) serializer.save() #prepares and sends the message to the queue message = {} message['instanceId'] = request.data['instanceId'] message['event'] = request.data['status'] #send_msg(str(message)) send_msg(json.dumps(serializer.data)) #create the SLA agreements in the SLA module based on the already created templates templateId = request.data['productType']+request.data['productId']+request.data['flavour'] createAgreement(templateId, request.data['clientId'], request.data['agreementId']) #start the Agreement enforcement f = restclient.Factory(settings.SLA_URL) a_enforcement = f.enforcements() a_enforcement.start(request.data['agreementId']) except ReferenceError: print " [ERROR] Could not update the messages queue" return Response(status=status.HTTP_408_REQUEST_TIMEOUT) except Exception as e: print "DEBUG: ", e return Response(status=status.HTTP_400_BAD_REQUEST) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None): """ --- parameters: - name: instanceId description: Service instance ID type: string paramType: form - name: metric description: Metric name type: string paramType: form """ print "debug: ", settings.SLA_URL f = restclient.Factory(settings.SLA_URL) instanceId = self.request.query_params.get('instanceId', None) agreementId = 'unknown' if instanceId is not None: print(instanceId) #find all the service running instances with the given Service instance ID queryset = Account.objects.filter(instanceId=instanceId, productType=settings.NETWORK_SERVICE)#, status='running') if queryset: for obj in queryset: agreementId = obj.agreementId metric = self.request.query_params.get('metric', None) start = self.request.query_params.get('start', None) end = self.request.query_params.get('end', None) print ('agreementID: %s, metric: %s, start: %s, end: %s' % (agreementId, metric, start, end)) a_client = f.penalties() penalties = a_client.getbyagreementTermAndDates(agreementId, metric, start, end)[0] #print (violations) return Response(penalties)
def setUp(self): self.context = fed4fireservice.ServiceContext( restclient.Factory("http://localhost:8080/sla-service"), TemplateFactory() ) self.provider_id = str(uuid.uuid4()) self.template_id = str(uuid.uuid4()) self.provider = { "uuid": self.provider_id, "name": "provider-" + self.provider_id[0:4] } self.template = { "template_id": self.template_id, "template_name": "template-name", "provider": self.provider_id, "service_id": "service-test", "expiration_time": "2014-03-28T13:55:00Z", "service_properties": [ {"name": "uptime"}, {"name": "responsetime"} ] } self.agreement = { "agreement_id": str(uuid.uuid4()), "template_id": self.template_id, "expiration_time": "2014-03-28T13:55:00Z", "consumer": "consumer-a", "guarantees": [ { "name": "uptime", "bounds": ["0.9", "1"] } ] }
def get(self, request, format=None): """ --- parameters: - name: clientId description: Client ID kind: string paramType: form - name: type description: Type of the SLA information to be returned: ns (for the customer) or vnf (for the SP) type: string paramType: form serializer: SLAInfoSerializer """ clientId = self.request.query_params.get('clientId', None) kind = self.request.query_params.get('kind', None) print "params: ", clientId, kind if (clientId is not None) and (kind is not None): f = restclient.Factory(settings.SLA_URL) queryset = Account.objects.filter(productType=kind, clientId=clientId) if queryset: resultsList = list() try: for service in queryset: a_client = f.violations() violations = a_client.getbyagreement( service.agreementId)[0] element = {} element['productId'] = service.productId element['productType'] = service.productType element['clientId'] = service.clientId element['providerId'] = service.providerId element['SLAPenalties'] = len(violations) element['agreementId'] = service.agreementId element['dateCreated'] = service.dateCreated if service.status == settings.STATUS_RUNNING: element['dateTerminated'] = None else: element['dateTerminated'] = datetime.datetime.now() resultsList.append(element) except Exception as e: print "DEBUG: ", e raise finally: serializer = SLAInfoSerializer(resultsList, many=True) return Response(serializer.data) serializer = SLAInfoSerializer(queryset, many=True) return Response( serializer.data) #, status=status.HTTP_400_BAD_REQUEST) return Response(status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None): serializer = AccountSerializer(data=request.data) if serializer.is_valid(): try: if Account.objects.filter( productType=request.data['productType'], instanceId=request.data['instanceId']): print( " [ERROR] There is an entry already with that InstanceId (%s) for the same ProductType (%s)" % (request.data['instanceId'], request.data['productType'])) return Response(status=status.HTTP_400_BAD_REQUEST) serializer.save() #create the SLA agreements in the SLA module based on the already created templates #templateId = request.data['productType']+request.data['productId']+request.data['flavour'] templateId = request.data[ 'productType'] + "@" + settings.DOMAIN_ID + "*" + request.data[ 'productId'] + request.data['flavour'] createAgreement(templateId, request.data['clientId'], request.data['agreementId']) #start the Agreement enforcement f = restclient.Factory(settings.SLA_URL) a_enforcement = f.enforcements() a_enforcement.start(request.data['agreementId']) #triggers IMoS monitoring sending the NS instance ID if (request.data['agreementId'].startswith('ns')): print(" [INFO] Contacting IMoS with url: %s" % (settings.IMOS_URL + request.data['instanceId'])) requests.put(str(settings.IMOS_URL) + str(request.data['instanceId']), data=None) #Virtual Links agreements: except Exception as e: print "DEBUG: ", e return Response(status=status.HTTP_400_BAD_REQUEST) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def main(): context = fed4fireservice.ServiceContext( restclient.Factory(), TemplateFactory() ) provider_id = "trento" template_id = "template_vm-Trento:193.205.211.xx" provider = { "uuid": provider_id, "name": "provider-" + provider_id[0:4] } template = { "template_id": template_id, "template_name": "template-name", "provider": provider_id, "service_id": "service-test", "expiration_time": "2014-03-28T13:55:00Z", "service_properties": [ {"name": "uptime"}, {"name": "responsetime"} ] } agreement = { "agreement_id": str(uuid.uuid4()), "template_id": template_id, "expiration_time": "2014-03-28T13:55:00Z", "consumer": "consumer-a", # the provider id must be repeated "provider": provider_id, "guarantees": [ { "name": "uptime", "bounds": ["0.9", "1"] } ] } json_data = json.dumps(agreement) fed4fireservice.createagreement(json_data, context)
def postAgreement(object, agreement): f = restclient.Factory(settings.SLA_URL) a_agreement = f.agreements() a_agreement.create(json.dumps(agreement))
def readTemplate(object, templateId): f = restclient.Factory(settings.SLA_URL) a_template = f.templates() return a_template.getbyid(templateId)[0]
def stopEnforcement(self, agreementId): f = restclient.Factory(settings.SLA_URL) a_enforcement= f.enforcements() a_enforcement.stop(agreementId)
def postProvider(object, provider, sla_url): f = restclient.Factory(sla_url) a_provider = f.providers() a_provider.create(json.dumps(provider))
def readProvider(object, providerId, sla_url): f = restclient.Factory(sla_url) a_provider = f.providers() return a_provider.getbyid(providerId)[0]
def postTemplate(object, template, sla_url): f = restclient.Factory(sla_url) a_template = f.templates() a_template.create(json.dumps(template))
def readTemplate(object, templateId, sla_url): f = restclient.Factory(sla_url) a_template = f.templates() return a_template.getbyid(templateId)[0]
from slagui.util_helper import UtilHelper import wsag_helper from keystone_adapter import KeyStoneAdapter from django.core.cache import cache from __builtin__ import str # # This is not thread safe and there may be problems if SLA_MANAGER_URL is not # a fixed value # # See: # http://blog.roseman.org.uk/2010/02/01/middleware-post-processing-django-gotcha # factory = restclient.Factory(settings.SLA_MANAGER_URL) consumer = oauth.Consumer(settings.SECRET_TOKEN, settings.SECRET_KEY) client = oauth.Client(consumer) def callbackIdm(request): state = request.REQUEST['state'] code = request.REQUEST['code'] http = settings.IDM_HTTP_TYPE host = settings.IDM_URL path = '/oauth2/token' params = { 'grant_type': 'authorization_code', 'code': code, 'redirect_uri': settings.IDM_REDIRECT_URL