def get_product_release_info(self, product_name, product_version):
headers = {
'X-Auth-Token': self.token,
'Tenant-Id': self.vdc,
'Accept': "application/json"
}
#get product release
url = "%s/%s/%s/%s/%s" % (self.sdc_url, "catalog/product",
product_name, "release", product_version)
response = http.get(url, headers)
if response.status != 200:
print 'error to get the product ' + product_name + ' ' + str(
response.status)
sys.exit(1)
else:
data = json.loads(response.read())
if data == None:
return None
product = ProductRelease(data['product']['name'], data['version'],
data['product']['description'])
try:
for att in data['attributes']:
attribute = Attribute(att['key'], att['version'])
product.add_attribute(attribute)
except:
pass
return product
def process_tier(tier):
"""
Process the tier provided as dictionary.
:param tiers: tier to be processed.
:return: a Tier object.
"""
processed_tier = Tier(tier['name'], world.config[PAAS][TIER_IMAGE])
try:
product_dtos = tier['productReleaseDtos']
if isinstance(product_dtos, list):
for product_dto in product_dtos:
processed_tier.add_product(ProductRelease(product_dto['productName'],
product_dto['version']))
else:
processed_tier.add_product(ProductRelease(product_dtos['productName'],
product_dtos['version']))
except:
pass
try:
network_dtos = tier['networkDto']
if isinstance(network_dtos, list):
for network_dto in network_dtos:
processed_tier.add_network(Network(network_dto['networkName']))
else:
processed_tier.add_network(Network(network_dtos['networkName']))
except:
pass
return processed_tier
def get_product_release_info(self, product_name, product_version):
#headers={'X-Auth-Token': self.token,
# 'Accept': "application/json"}
headers = {'Accept': "application/json"}
#get product release
url = "%s/%s/%s/%s/%s" % (self.sdc_url, "catalog/product", product_name, "release", product_version )
response = http.get(url, headers)
if response.status != 200:
print 'error to get the product ' + product_name + ' ' + str(response.status)
sys.exit(1)
else:
data = json.loads(response.read())
if data == None:
return None
product = ProductRelease(data['product']['name'], data['version'], data['product']['description'])
try:
for att in data['attributes']:
attribute = Attribute(att['key'], att['version']);
product.add_attribute(attribute)
except:
pass
return product
def process_tier(tier):
"""
Process the tier provided as dictionary.
:param tiers: tier to be processed.
:return: a Tier object.
"""
processed_tier = Tier(tier_name=tier['name'],
tier_image=tier['image'],
tier_num_min=tier['minimumNumberInstances'],
tier_num_max=tier['maximumNumberInstances'],
tier_num_initial=tier['initialNumberInstances'],
tier_flavour=tier['flavour'],
tier_keypair=tier['keypair'],
tier_floatingip=tier['floatingip'],
tier_region=tier['region'])
if 'productReleaseDtos' in tier:
product_dtos = tier['productReleaseDtos']
if isinstance(product_dtos, list):
for product_dto in product_dtos:
attribute_list = product_dto[
'attributes'] if 'attributes' in product_dto else None
processed_tier.add_product(
ProductRelease(product_dto['productName'],
product_dto['version'],
parse_attribute_from_dict(attribute_list)))
else:
attribute_list = product_dtos[
'attributes'] if 'attributes' in product_dtos else None
processed_tier.add_product(
ProductRelease(product_dtos['productName'],
product_dtos['version'],
parse_attribute_from_dict(attribute_list)))
try:
network_dtos = tier['networkDto']
if isinstance(network_dtos, list):
for network_dto in network_dtos:
processed_tier.add_network(Network(network_dto['networkName']))
else:
processed_tier.add_network(Network(network_dtos['networkName']))
except:
pass
return processed_tier
def add_product_release(self, product_name, version):
url = "%s/%s/%s/%s" % (self.sdc_url, "catalog/product", product_name, "release")
headers = {'Content-Type': 'application/xml'}
# product = self.get_product_info (product_name)
product = Product(product_name)
product_release = ProductRelease(product, version)
payload = product_release.to_product_xml()
response = http.post(url, headers, tostring(payload))
## Si la respuesta es la adecuada, creo el diccionario de los datos en JSON.
if response.status != 200:
print 'error to add the product release to sdc ' + str(response.status)
sys.exit(1)
else:
self.products.append(product)
def __process_environment(self, env):
environment = Environment(env['name'], env['description'])
try:
tiers_string = env['tierDtos']
except:
environment.to_string()
return environment
if isinstance(tiers_string, list):
for tier_string in tiers_string:
tier = Tier(tier_string['name'], self.image, tier_string['region'])
try:
products_string = tier_string['productReleaseDtos']
if isinstance(products_string, list):
for product_string in products_string:
product = ProductRelease(product_string['productName'], product_string['version'])
tier.add_product(product)
else:
product = ProductRelease(products_string['productName'], products_string['version'])
tier.add_product(product)
except:
pass
environment.add_tier(tier)
else:
tier = Tier(tiers_string['name'], self.image)
try:
products_string = tiers_string['productReleaseDtos']
if isinstance(products_string, list):
for product_string in products_string:
producte = Product(product_string['productName'])
product_release = ProductRelease(producte, product_string['version'])
tier.add_product(product_release)
else:
product = ProductRelease(products_string['productName'], products_string['version'])
tier.add_product(product)
environment.add_tier(tier)
except:
print 'error'
pass
environment.to_string()
return environment
def __check_product_exist(self, product_name, product_version):
#request=ProductRequest(self.keystone_url, self.sdc_url, self.tenant, self.user, self.password)
#product = request.get_product_info(product_name,product_version)
# if product is None:
# print 'Error: the product ' + product_name + ' ' + product_version + ' does not exit'
product = ProductRelease(product_name, product_version)
return product
def add_product_release(self, product_name, version):
url = "%s/%s/%s/%s" % (self.sdc_url, "catalog/product", product_name,
"release")
headers = {'Content-Type': 'application/xml'}
# product = self.get_product_info (product_name)
product = Product(product_name)
product_release = ProductRelease(product, version)
payload = product_release.to_product_xml()
response = http.post(url, headers, tostring(payload))
## Si la respuesta es la adecuada, creo el diccionario de los datos en JSON.
if response.status != 200:
print 'error to add the product release to sdc ' + str(
response.status)
sys.exit(1)
else:
self.products.append(product)
def parse_products(products_information):
"""
Parses a list of products in the format prod1=vers1,prod2=vers2,...
:param products_information: string with the products to parse.
:return: a list of ProductsRelease objects.
"""
products = []
if products_information:
products_info_list = products_information.split(',')
for product_info in products_info_list:
product_name, product_version = product_info.split('=')
products.append(ProductRelease(product_name, product_version))
return products
def __process_product(self, product_information):
a = product_information.split('=')
product = ProductRelease(a[0], a[1])
return product
