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
