def _xml_ele_to_obj(cls, element):
image_dict = element.attrib
if 'minDisk' in image_dict:
image_dict['minDisk'] = image_dict.get('minDisk') \
and int(image_dict.get('minDisk'))
if 'progress' in image_dict:
image_dict['progress'] = image_dict.get('progress') \
and int(image_dict.get('progress'))
if 'minRam' in image_dict:
image_dict['minRam'] = image_dict.get('minRam') \
and int(image_dict.get('minRam'))
links = None
metadata = None
server = None
if element.find('link') is not None:
links = Links._xml_ele_to_obj(element)
if element.find('metadata') is not None:
metadata = Metadata._xml_ele_to_obj(element)
if element.find('server') is not None:
'''To prevent circular import issue import just in time'''
from cloudcafe.compute.servers_api.models.servers import ServerMin
server = ServerMin._xml_ele_to_obj(element)
image = Image(image_dict.get('diskConfig'), image_dict.get('size'),
image_dict.get('id'), image_dict.get('name'),
image_dict.get('status'), image_dict.get('updated'),
image_dict.get('created'), image_dict.get('minDisk'),
image_dict.get('minRam'), image_dict.get('progress'),
links, metadata, server)
return image
def _dict_to_obj(cls, json_dict):
links = None
metadata = None
server = None
if 'links' in json_dict:
links = Links._dict_to_obj(json_dict['links'])
if 'metadata' in json_dict:
metadata = Metadata._dict_to_obj(json_dict['metadata'])
if 'server' in json_dict:
# Prevents circular import issue import just in time
from cloudcafe.compute.servers_api.models.servers import ServerMin
server = ServerMin._dict_to_obj(json_dict['server'])
image = Image(
disk_config=json_dict.get('OS-DCF:diskConfig'),
size=json_dict.get('OS-EXT-IMG-SIZE:size'),
id=json_dict.get('id'), name=json_dict.get('name'),
status=json_dict.get('status'),
updated=json_dict.get('updated'),
created=json_dict.get('created'),
min_disk=json_dict.get('minDisk'),
min_ram=json_dict.get('minRam'),
progress=json_dict.get('progress'),
links=links, metadata=metadata, server=server)
return image
def _xml_ele_to_obj(cls, element):
image_dict = element.attrib
if 'minDisk' in image_dict:
image_dict['minDisk'] = image_dict.get('minDisk') \
and int(image_dict.get('minDisk'))
if 'progress' in image_dict:
image_dict['progress'] = image_dict.get('progress') \
and int(image_dict.get('progress'))
if 'minRam' in image_dict:
image_dict['minRam'] = image_dict.get('minRam') \
and int(image_dict.get('minRam'))
links = None
metadata = None
server = None
if element.find('link') is not None:
links = Links._xml_ele_to_obj(element)
if element.find('metadata') is not None:
metadata = Metadata._xml_ele_to_obj(element)
if element.find('server') is not None:
'''To prevent circular import issue import just in time'''
from cloudcafe.compute.servers_api.models.servers import ServerMin
server = ServerMin._xml_ele_to_obj(element)
image = Image(image_dict.get('diskConfig'),
image_dict.get('id'), image_dict.get('name'),
image_dict.get('status'), image_dict.get('updated'),
image_dict.get('created'), image_dict.get('minDisk'),
image_dict.get('minRam'), image_dict.get('progress'),
links, metadata, server)
return image
def _assert_server_details(self, server, expected_name,
expected_accessIPv4, expected_accessIPv6,
expected_flavor):
self.assertEqual(expected_accessIPv4,
server.accessIPv4,
msg="AccessIPv4 did not match")
self.assertEqual(expected_accessIPv6,
server.accessIPv6,
msg="AccessIPv6 did not match")
self.assertEqual(expected_name,
server.name,
msg="Server name did not match")
self.assertEqual(self.image_ref,
server.image.id,
msg="Image id did not match")
self.assertEqual(expected_flavor,
server.flavor.id,
msg="Flavor id did not match")
self.assertTrue(server.created is not None,
msg="Server created date was not set")
self.assertTrue(server.updated is not None,
msg="Server updated date was not set")
self.assertGreaterEqual(
server.updated,
server.created,
msg="Server updated date was before the created date")
self.assertEqual(self.meta,
Metadata._obj_to_dict(server.metadata),
msg="Metadata did not match")
def _dict_to_obj(cls, json_dict):
links = None
metadata = None
server = None
if 'links' in json_dict:
links = Links._dict_to_obj(json_dict['links'])
if 'metadata' in json_dict:
metadata = Metadata._dict_to_obj(json_dict['metadata'])
if 'server' in json_dict:
# Prevents circular import issue import just in time
from cloudcafe.compute.servers_api.models.servers import ServerMin
server = ServerMin._dict_to_obj(json_dict['server'])
image = Image(disk_config=json_dict.get('OS-DCF:diskConfig'),
size=json_dict.get('OS-EXT-IMG-SIZE:size'),
id=json_dict.get('id'),
name=json_dict.get('name'),
status=json_dict.get('status'),
updated=json_dict.get('updated'),
created=json_dict.get('created'),
min_disk=json_dict.get('minDisk'),
min_ram=json_dict.get('minRam'),
progress=json_dict.get('progress'),
links=links,
metadata=metadata,
server=server)
return image
def _obj_to_xml(self):
element = ET.Element(self.ROOT_TAG)
xml = Constants.XML_HEADER
element.set('xmlns', Constants.XML_API_NAMESPACE)
element.set('name', self.name)
element.set('imageRef', self.imageRef)
element.set('flavorRef', self.flavorRef)
if self.adminPass is not None:
element.set('adminPass', self.adminPass)
if self.diskConfig is not None:
element.set('xmlns:OS-DCF',
Constants.XML_API_DISK_CONFIG_NAMESPACE)
element.set('OS-DCF:diskConfig', self.diskConfig)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
if self.networks is not None:
networks_ele = ET.Element('networks')
for network_id in self.networks:
network = ET.Element('network')
network.set('uuid', network_id['uuid'])
networks_ele.append(network)
element.append(networks_ele)
if self.personality is not None:
personality_ele = ET.Element('personality')
personality_ele.append(Personality._obj_to_xml(self.personality))
element.append(personality_ele)
if self.accessIPv4 is not None:
element.set('accessIPv4', self.accessIPv4)
if self.accessIPv6 is not None:
element.set('accessIPv6', self.accessIPv6)
xml += ET.tostring(element)
return xml
def _xml_ele_to_obj(cls, element):
image_dict = element.attrib
if 'minDisk' in image_dict:
image_dict['minDisk'] = (image_dict.get('minDisk')
and int(image_dict.get('minDisk')))
if 'progress' in image_dict:
image_dict['progress'] = (image_dict.get('progress')
and int(image_dict.get('progress')))
if 'minRam' in image_dict:
image_dict['minRam'] = (image_dict.get('minRam')
and int(image_dict.get('minRam')))
links = None
metadata = None
server = None
if element.find('link') is not None:
links = Links._xml_ele_to_obj(element)
if element.find('metadata') is not None:
metadata = Metadata._xml_ele_to_obj(element.find('metadata'))
if element.find('server') is not None:
# Prevents circular import issue import just in time
from cloudcafe.compute.servers_api.models.servers import ServerMin
server = ServerMin._xml_ele_to_obj(element)
image = Image(
disk_config=image_dict.get('diskConfig'),
size=image_dict.get('size'), id=image_dict.get('id'),
name=image_dict.get('name'), status=image_dict.get('status'),
updated=image_dict.get('updated'),
created=image_dict.get('created'),
min_disk=image_dict.get('minDisk'),
min_ram=image_dict.get('minRam'),
progress=image_dict.get('progress'),
links=links, metadata=metadata, server=server)
return image
def _assert_server_details(self, server, expected_name, expected_accessIPv4, expected_accessIPv6, expected_flavor):
self.assertEqual(expected_accessIPv4, server.accessIPv4, msg="AccessIPv4 did not match")
self.assertEqual(expected_accessIPv6, server.accessIPv6, msg="AccessIPv6 did not match")
self.assertEqual(expected_name, server.name, msg="Server name did not match")
self.assertEqual(self.image_ref, server.image.id, msg="Image id did not match")
self.assertEqual(expected_flavor, server.flavor.id, msg="Flavor id did not match")
self.assertTrue(server.created is not None, msg="Server created date was not set")
self.assertTrue(server.updated is not None, msg="Server updated date was not set")
self.assertGreaterEqual(server.updated, server.created, msg="Server updated date was before the created date")
self.assertEqual(self.meta, Metadata._obj_to_dict(server.metadata), msg="Metadata did not match")
def setUpClass(cls):
cls.metadata = Metadata()
cls.metadata['key1'] = 'value1'
cls.expected_xml = \
('<?xml version=\'1.0\' encoding=\'UTF-8\'?>'
'<metadata xmlns="http://docs.openstack.org/compute/api/v1.1">'
'<meta key="key1">value1</meta>'
'</metadata>')
cls.expected_json = json.dumps({'metadata': {'key1': 'value1'}})
def _xml_ele_to_obj(cls, element):
"""Helper method to turn ElementTree instance to Server instance."""
server = element.attrib
addresses = None
flavor = None
image = None
metadata = None
links = Links._xml_ele_to_obj(element)
if element.find("addresses") is not None:
addresses = Addresses._xml_ele_to_obj(element.find("addresses"))
if element.find("flavor") is not None:
flavor = Flavor._xml_ele_to_obj(element.find("flavor"))
if element.find("image") is not None:
image = Image._xml_ele_to_obj(element.find("image"))
if element.find("metadata") is not None:
metadata = Metadata._xml_ele_to_obj(element.find("metadata"))
if "progress" in server:
progress = server.get("progress") and int(server.get("progress"))
else:
progress = None
server = Server(
id=server.get("id"),
disk_config=server.get("diskConfig"),
power_state=server.get("power_state"),
progress=progress,
task_state=server.get("task_state").lower(),
vm_state=server.get("vm_state"),
name=server.get("name"),
tenant_id=server.get("tenant_id"),
status=server.get("status"),
updated=server.get("updated"),
created=server.get("created"),
host_id=server.get("hostId"),
user_id=server.get("userId"),
accessIPv4=server.get("accessIPv4"),
config_drive=server.get("config_drive"),
accessIPv6=server.get("accessIPv6"),
addresses=addresses,
flavor=flavor,
image=image,
links=links,
metadata=metadata,
admin_pass=server.get("adminPass"),
key_name=server.get("key_name"),
host=server.get("host"),
instance_name=server.get("instance_name"),
hypervisor_name=server.get("hypervisor_hostname"),
)
return server
def _obj_to_xml(self):
element = ET.Element('server')
xml = Constants.XML_HEADER
element.set('xmlns', Constants.XML_API_NAMESPACE)
element.set('name', self.name)
element.set('imageRef', self.image_ref)
element.set('flavorRef', self.flavor_ref)
if self.admin_pass is not None:
element.set('adminPass', self.admin_pass)
if self.disk_config is not None:
element.set('xmlns:OS-DCF',
Constants.XML_API_DISK_CONFIG_NAMESPACE)
element.set('OS-DCF:diskConfig', self.disk_config)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
if self.networks is not None:
networks_ele = ET.Element('networks')
for network_id in self.networks:
network = ET.Element('network')
network.set('uuid', network_id['uuid'])
networks_ele.append(network)
element.append(networks_ele)
if self.personality is not None:
personality_ele = ET.Element('personality')
personality_ele.append(Personality._obj_to_xml(self.personality))
element.append(personality_ele)
if self.block_device_mapping is not None:
block_device_ele = ET.Element('block_device_mapping')
block_device_ele.append(
BlockDeviceMapping._obj_to_xml(self.block_device_mapping))
element.append(block_device_ele)
if self.user_data is not None:
element.set('user_data', self.user_data)
if self.accessIPv4 is not None:
element.set('accessIPv4', self.accessIPv4)
if self.accessIPv6 is not None:
element.set('accessIPv6', self.accessIPv6)
if self.key_name is not None:
element.set('key_name', self.key_name)
if self.config_drive is not None:
element.set('config_drive', self.config_drive)
if self.scheduler_hints is not None:
hints_ele = ET.Element('OS-SCH-HNT:scheduler_hints')
for key, value in self.metadata.iteritems():
meta_element = ET.Element(key)
meta_element.text = value
hints_ele.append(meta_element)
xml += ET.tostring(element)
return xml
def _obj_to_xml(self):
element = ET.Element('server')
xml = Constants.XML_HEADER
element.set('xmlns', Constants.XML_API_NAMESPACE)
element.set('name', self.name)
element.set('imageRef', self.image_ref)
element.set('flavorRef', self.flavor_ref)
if self.admin_pass is not None:
element.set('adminPass', self.admin_pass)
if self.disk_config is not None:
element.set('xmlns:OS-DCF',
Constants.XML_API_DISK_CONFIG_NAMESPACE)
element.set('OS-DCF:diskConfig', self.disk_config)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
if self.networks is not None:
networks_ele = ET.Element('networks')
for network_id in self.networks:
network = ET.Element('network')
network.set('uuid', network_id['uuid'])
networks_ele.append(network)
element.append(networks_ele)
if self.personality is not None:
personality_ele = ET.Element('personality')
personality_ele.append(Personality._obj_to_xml(self.personality))
element.append(personality_ele)
if self.block_device_mapping is not None:
block_device_ele = ET.Element('block_device_mapping')
block_device_ele.append(BlockDeviceMapping._obj_to_xml(
self.block_device_mapping))
element.append(block_device_ele)
if self.user_data is not None:
element.set('user_data', self.user_data)
if self.accessIPv4 is not None:
element.set('accessIPv4', self.accessIPv4)
if self.accessIPv6 is not None:
element.set('accessIPv6', self.accessIPv6)
if self.key_name is not None:
element.set('key_name', self.key_name)
if self.config_drive is not None:
element.set('config_drive', self.config_drive)
if self.scheduler_hints is not None:
hints_ele = ET.Element('OS-SCH-HNT:scheduler_hints')
for key, value in self.metadata.iteritems():
meta_element = ET.Element(key)
meta_element.text = value
hints_ele.append(meta_element)
xml += ET.tostring(element)
return xml
def _xml_ele_to_obj(cls, element):
"""Helper method to turn ElementTree instance to Server instance."""
server = element.attrib
addresses = None
flavor = None
image = None
metadata = None
links = Links._xml_ele_to_obj(element)
if element.find('addresses') is not None:
addresses = Addresses._xml_ele_to_obj(element.find('addresses'))
if element.find('flavor') is not None:
flavor = Flavor._xml_ele_to_obj(element.find('flavor'))
if element.find('image'):
image = Image._xml_ele_to_obj(element.find('image'))
if element.find('metadata') is not None:
metadata = Metadata._xml_ele_to_obj(element.find('metadata'))
if 'progress' in server:
progress = (server.get('progress') and int(server.get('progress')))
else:
progress = None
server = Server(id=server.get('id'),
disk_config=server.get('diskConfig'),
power_state=server.get('power_state'),
progress=progress,
task_state=server.get('task_state').lower(),
vm_state=server.get('vm_state'),
name=server.get('name'),
tenant_id=server.get('tenant_id'),
status=server.get('status'),
updated=server.get('updated'),
created=server.get('created'),
host_id=server.get('hostId'),
user_id=server.get('userId'),
accessIPv4=server.get('accessIPv4'),
config_drive=server.get('config_drive'),
accessIPv6=server.get('accessIPv6'),
addresses=addresses,
flavor=flavor,
image=image,
links=links,
metadata=metadata,
admin_pass=server.get('adminPass'),
key_name=server.get('key_name'),
host=server.get('host'),
instance_name=server.get('instance_name'),
hypervisor_name=server.get('hypervisor_hostname'))
return server
def _obj_to_xml(self):
xml = Constants.XML_HEADER
element = ET.Element('createImage')
element.set('xmlns', Constants.XML_API_NAMESPACE)
element.set('xmlns:atom', Constants.XML_API_ATOM_NAMESPACE)
element.set('name', self.name)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
xml += ET.tostring(element)
return xml
def _obj_to_xml(self):
xml = Constants.XML_HEADER
element = ET.Element('createImage')
element.set('xmlns', Constants.XML_API_NAMESPACE)
element.set('xmlns:atom', Constants.XML_API_ATOM_NAMESPACE)
element.set('name', self.name)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
xml += ET.tostring(element)
return xml
def _dict_to_obj(cls, server_dict):
"""Helper method to turn dictionary into Server instance."""
addresses = None
flavor = None
image = None
links = None
metadata = None
fault = None
if 'links' in server_dict:
links = Links._dict_to_obj(server_dict['links'])
if 'addresses' in server_dict:
addresses = Addresses._dict_to_obj(server_dict['addresses'])
if 'flavor' in server_dict:
flavor = FlavorMin._dict_to_obj(server_dict['flavor'])
if 'image' in server_dict and server_dict.get('image'):
image = ImageMin._dict_to_obj(server_dict['image'])
if 'metadata' in server_dict:
metadata = Metadata._dict_to_obj(server_dict['metadata'])
if 'fault' in server_dict:
fault = Fault._dict_to_obj(server_dict['fault'])
server = Server(
id=server_dict.get('id') or server_dict.get('uuid'),
disk_config=server_dict.get('OS-DCF:diskConfig'),
power_state=server_dict.get('OS-EXT-STS:power_state'),
progress=server_dict.get('progress', 0),
task_state=server_dict.get('OS-EXT-STS:task_state'),
vm_state=server_dict.get('OS-EXT-STS:vm_state'),
name=server_dict.get('name'),
config_drive=server_dict.get('config_drive'),
tenant_id=server_dict.get('tenant_id'),
status=server_dict.get('status'),
updated=server_dict.get('updated'),
created=server_dict.get('created'),
host_id=server_dict.get('hostId'),
user_id=server_dict.get('user_id'),
accessIPv4=server_dict.get('accessIPv4'),
accessIPv6=server_dict.get('accessIPv6'), addresses=addresses,
flavor=flavor, image=image, links=links, metadata=metadata,
admin_pass=server_dict.get('adminPass'),
key_name=server_dict.get('key_name'),
host=server_dict.get('OS-EXT-SRV-ATTR:host'),
instance_name=server_dict.get('OS-EXT-SRV-ATTR:instance_name'),
hypervisor_name=server_dict.get(
'OS-EXT-SRV-ATTR:hypervisor_hostname'),
security_groups=server_dict.get('security_groups'),
fault=fault)
return server
def _dict_to_obj(cls, server_dict):
"""Helper method to turn dictionary into Server instance."""
addresses = None
flavor = None
image = None
links = None
metadata = None
if "links" in server_dict:
links = Links._dict_to_obj(server_dict["links"])
if "addresses" in server_dict:
addresses = Addresses._dict_to_obj(server_dict["addresses"])
if "flavor" in server_dict:
flavor = FlavorMin._dict_to_obj(server_dict["flavor"])
if "image" in server_dict:
image = ImageMin._dict_to_obj(server_dict["image"])
if "metadata" in server_dict:
metadata = Metadata._dict_to_obj(server_dict["metadata"])
server = Server(
id=server_dict.get("id") or server_dict.get("uuid"),
disk_config=server_dict.get("OS-DCF:diskConfig"),
power_state=server_dict.get("OS-EXT-STS:power_state"),
progress=server_dict.get("progress", 0),
task_state=server_dict.get("OS-EXT-STS:task_state"),
vm_state=server_dict.get("OS-EXT-STS:vm_state"),
name=server_dict.get("name"),
config_drive=server_dict.get("config_drive"),
tenant_id=server_dict.get("tenant_id"),
status=server_dict.get("status"),
updated=server_dict.get("updated"),
created=server_dict.get("created"),
host_id=server_dict.get("hostId"),
user_id=server_dict.get("user_id"),
accessIPv4=server_dict.get("accessIPv4"),
accessIPv6=server_dict.get("accessIPv6"),
addresses=addresses,
flavor=flavor,
image=image,
links=links,
metadata=metadata,
admin_pass=server_dict.get("adminPass"),
key_name=server_dict.get("key_name"),
host=server_dict.get("OS-EXT-SRV-ATTR:host"),
instance_name=server_dict.get("OS-EXT-SRV-ATTR:instance_name"),
hypervisor_name=server_dict.get("OS-EXT-SRV-ATTR:hypervisor_hostname"),
)
return server
def _dict_to_obj(cls, server_dict):
"""Helper method to turn dictionary into Server instance."""
addresses = None
flavor = None
image = None
links = None
metadata = None
if 'links' in server_dict:
links = Links._dict_to_obj(server_dict['links'])
if 'addresses' in server_dict:
addresses = Addresses._dict_to_obj(server_dict['addresses'])
if 'flavor' in server_dict:
flavor = FlavorMin._dict_to_obj(server_dict['flavor'])
if 'image' in server_dict and server_dict.get('image'):
image = ImageMin._dict_to_obj(server_dict['image'])
if 'metadata' in server_dict:
metadata = Metadata._dict_to_obj(server_dict['metadata'])
server = Server(
id=server_dict.get('id') or server_dict.get('uuid'),
disk_config=server_dict.get('OS-DCF:diskConfig'),
power_state=server_dict.get('OS-EXT-STS:power_state'),
progress=server_dict.get('progress', 0),
task_state=server_dict.get('OS-EXT-STS:task_state'),
vm_state=server_dict.get('OS-EXT-STS:vm_state'),
name=server_dict.get('name'),
config_drive=server_dict.get('config_drive'),
tenant_id=server_dict.get('tenant_id'),
status=server_dict.get('status'),
updated=server_dict.get('updated'),
created=server_dict.get('created'),
host_id=server_dict.get('hostId'),
user_id=server_dict.get('user_id'),
accessIPv4=server_dict.get('accessIPv4'),
accessIPv6=server_dict.get('accessIPv6'),
addresses=addresses,
flavor=flavor,
image=image,
links=links,
metadata=metadata,
admin_pass=server_dict.get('adminPass'),
key_name=server_dict.get('key_name'),
host=server_dict.get('OS-EXT-SRV-ATTR:host'),
instance_name=server_dict.get('OS-EXT-SRV-ATTR:instance_name'),
hypervisor_name=server_dict.get(
'OS-EXT-SRV-ATTR:hypervisor_hostname'))
return server
def _dict_to_obj(cls, json_dict):
image = Image(json_dict.get('OS-DCF:diskConfig'), json_dict.get('id'),
json_dict.get('name'), json_dict.get('status'),
json_dict.get('updated'), json_dict.get('created'),
json_dict.get('minDisk'), json_dict.get('minRam'),
json_dict.get('progress'))
if 'links' in json_dict:
image.links = Links._dict_to_obj(json_dict['links'])
if 'metadata' in json_dict:
image.metadata = Metadata._dict_to_obj(json_dict['metadata'])
if 'server' in json_dict:
from cloudcafe.compute.servers_api.models.servers import ServerMin
image.server = ServerMin._dict_to_obj(json_dict['server'])
return image
def _xml_ele_to_obj(cls, element):
"""Helper method to turn ElementTree instance to Server instance."""
server_dict = element.attrib
addresses = None
flavor = None
image = None
links = None
metadata = None
links = Links._xml_ele_to_obj(element)
if element.find("addresses") is not None:
addresses = Addresses._xml_ele_to_obj(element.find("addresses"))
if element.find("flavor") is not None:
flavor = Flavor._xml_ele_to_obj(element.find("flavor"))
if element.find("image") is not None:
image = Image._xml_ele_to_obj(element.find("image"))
if element.find("metadata") is not None:
metadata = Metadata._xml_ele_to_obj(element)
if "progress" in server_dict:
progress = server_dict.get("progress") and int(server_dict.get("progress"))
if "tenantId" in server_dict:
tenant_id = server_dict.get("tenantId")
if "userId" in server_dict:
user_id = server_dict.get("userId")
server = Server(
server_dict["id"],
server_dict["diskConfig"],
server_dict["power_state"],
progress,
server_dict["task_state"],
server_dict["vm_state"],
server_dict["name"],
tenant_id,
server_dict["status"],
server_dict["updated"],
server_dict["created"],
server_dict["hostId"],
user_id,
server_dict["accessIPv4"],
server_dict["accessIPv6"],
addresses,
flavor,
image,
links,
metadata,
)
return server
def _dict_to_obj(cls, json_dict):
image = Image(json_dict.get('OS-DCF:diskConfig'), json_dict.get('id'),
json_dict.get('name'), json_dict.get('status'),
json_dict.get('updated'), json_dict.get('created'),
json_dict.get('minDisk'), json_dict.get('minRam'),
json_dict.get('progress'))
if 'links' in json_dict:
image.links = Links._dict_to_obj(json_dict['links'])
if 'metadata' in json_dict:
image.metadata = Metadata._dict_to_obj(json_dict['metadata'])
if 'server' in json_dict:
from cloudcafe.compute.servers_api.models.servers import ServerMin
image.server = ServerMin._dict_to_obj(json_dict['server'])
return image
def _dict_to_obj(cls, server_dict):
"""Helper method to turn dictionary into Server instance."""
addresses = None
flavor = None
image = None
links = None
metadata = None
if "links" in server_dict:
links = Links._dict_to_obj(server_dict["links"])
if "addresses" in server_dict:
addresses = Addresses._dict_to_obj(server_dict["addresses"])
if "flavor" in server_dict:
flavor = FlavorMin._dict_to_obj(server_dict["flavor"])
if "image" in server_dict:
image = ImageMin._dict_to_obj(server_dict["image"])
if "metadata" in server_dict:
metadata = Metadata._dict_to_obj(server_dict["metadata"])
server = Server(
server_dict["id"],
server_dict.get("OS-DCF:diskConfig"),
server_dict.get("OS-EXT-STS:power_state"),
server_dict.get("progress", 0),
server_dict.get("OS-EXT-STS:task_state"),
server_dict.get("OS-EXT-STS:vm_state"),
server_dict.get("name"),
server_dict.get("tenant_id"),
server_dict.get("status"),
server_dict.get("updated"),
server_dict.get("created"),
server_dict.get("hostId"),
server_dict.get("user_id"),
server_dict.get("accessIPv4"),
server_dict.get("accessIPv6"),
addresses,
flavor,
image,
links,
metadata,
server_dict.get("adminPass"),
)
for each in server_dict:
if each.startswith("{"):
newkey = re.split("}", each)[1]
setattr(server, newkey, server_dict[each])
return server
def _obj_to_xml(self):
xml = Constants.XML_HEADER
element = ET.Element(self.ROOT_TAG)
element.set('xmlns', Constants.XML_API_NAMESPACE)
element.set('xmlns:atom', Constants.XML_API_ATOM_NAMESPACE)
element.set('name', self.name)
element.set('backup_type', self.backup_type)
element.set('rotation', self.rotation)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
xml += ET.tostring(element)
return xml
def _obj_to_xml(self):
xml = Constants.XML_HEADER
element = ET.Element(self.ROOT_TAG)
element.set('xmlns', Constants.XML_API_NAMESPACE)
element.set('xmlns:atom', Constants.XML_API_ATOM_NAMESPACE)
element.set('name', self.name)
element.set('backup_type', self.backup_type)
element.set('rotation', self.rotation)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
xml += ET.tostring(element)
return xml
def _xml_ele_to_obj(cls, element):
"""Helper method to turn ElementTree instance to Server instance."""
server = element.attrib
addresses = None
flavor = None
image = None
metadata = None
fault = None
links = Links._xml_ele_to_obj(element)
if element.find('addresses') is not None:
addresses = Addresses._xml_ele_to_obj(element.find('addresses'))
if element.find('flavor') is not None:
flavor = Flavor._xml_ele_to_obj(element.find('flavor'))
if element.find('image'):
image = Image._xml_ele_to_obj(element.find('image'))
if element.find('metadata') is not None:
metadata = Metadata._xml_ele_to_obj(element.find('metadata'))
if element.find('fault') is not None:
fault = Fault._xml_ele_to_obj(element.find('fault'))
if 'progress' in server:
progress = (server.get('progress')
and int(server.get('progress')))
else:
progress = None
server = Server(
id=server.get('id'), disk_config=server.get('diskConfig'),
power_state=server.get('power_state'), progress=progress,
task_state=server.get('task_state').lower(),
vm_state=server.get('vm_state'), name=server.get('name'),
tenant_id=server.get('tenant_id'), status=server.get('status'),
updated=server.get('updated'), created=server.get('created'),
host_id=server.get('hostId'), user_id=server.get('userId'),
accessIPv4=server.get('accessIPv4'),
config_drive=server.get('config_drive'),
accessIPv6=server.get('accessIPv6'), addresses=addresses,
flavor=flavor, image=image, links=links, metadata=metadata,
admin_pass=server.get('adminPass'),
key_name=server.get('key_name'), host=server.get('host'),
instance_name=server.get('instance_name'),
hypervisor_name=server.get('hypervisor_hostname'),
security_groups=server.get('security_groups'),
fault=fault)
return server
def _obj_to_xml(self):
element = ET.Element('server')
xml = Constants.XML_HEADER
element.set('xmlns', Constants.XML_API_NAMESPACE)
if self.name is not None:
element.set('name', self.name)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
if self.accessIPv4 is not None:
element.set('accessIPv4', self.accessIPv4)
if self.accessIPv6 is not None:
element.set('accessIPv6', self.accessIPv6)
xml += ET.tostring(element)
return xml
def _obj_to_xml(self):
element = ET.Element('server')
xml = Constants.XML_HEADER
element.set('xmlns', Constants.XML_API_NAMESPACE)
if self.name is not None:
element.set('name', self.name)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
if self.accessIPv4 is not None:
element.set('accessIPv4', self.accessIPv4)
if self.accessIPv6 is not None:
element.set('accessIPv6', self.accessIPv6)
xml += ET.tostring(element)
return xml
def set_image_metadata(self, image_id, metadata, requestslib_kwargs=None):
'''
@summary: Sets metadata for the specified image
@param image_id: Image ID
@type image_id:String
@param metadata: Metadata to be set for an image
@type metadata: dictionary
@return: Metadata associated with an image on success
@rtype: Response object with metadata dictionary as entity
'''
url = '{base_url}/images/{image_id}/metadata'.format(base_url=self.url,
image_id=image_id)
request_object = Metadata(metadata)
image_response = self.request('PUT', url,
response_entity_type=Metadata,
request_entity=request_object,
requestslib_kwargs=requestslib_kwargs)
return image_response
def set_server_metadata(self, server_id, metadata,
requestslib_kwargs=None):
"""
@summary: Sets metadata for the specified server
@param server_id: server ID
@type server_id:String
@param metadata: Metadata to be set for an server
@type metadata: dictionary
@return: Metadata associated with an server on success
@rtype: Requests.response
"""
url = '{base_url}/servers/{server_id}/metadata'.format(
base_url=self.url, server_id=server_id)
request_metadata_object = Metadata(metadata)
resp = self.request('PUT', url, response_entity_type=Metadata,
request_entity=request_metadata_object,
requestslib_kwargs=requestslib_kwargs)
return resp
def _obj_to_xml(self):
elements_dict = {
'name': self.name,
'flavorRef': self.flavor_ref,
'max_count': self.max_count,
'min_count': self.min_count,
'image_ref': self.image_ref,
'user_data': self.user_data,
'accessIPv4': self.accessIPv4,
'accessIPv6': self.accessIPv6,
'adminPass': self.admin_pass,
'key_name': self.key_name,
'config_drive': self.config_drive,
'security_groups': self.security_groups
}
element = ET.Element('server')
element.set('xmlns', Constants.XML_API_NAMESPACE)
block_device_ele = ET.Element('block_device_mapping_v2')
block_device_ele.append(
BlockDeviceMappingV2._obj_to_xml(self.block_device_mapping_v2))
element.append(block_device_ele)
if self.networks is not None:
networks_ele = ET.Element('networks')
for network_id in self.networks:
network = ET.Element('network')
network.set('uuid', network_id['uuid'])
networks_ele.append(network)
element.append(networks_ele)
if self.personality is not None:
personality_ele = ET.Element('personality')
personality_ele.append(Personality._obj_to_xml(self.personality))
element.append(personality_ele)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
if self.disk_config is not None:
element.set('xmlns:OS-DCF',
Constants.XML_API_DISK_CONFIG_NAMESPACE)
element.set('OS-DCF:diskConfig', self.disk_config)
element = self._set_xml_etree_element(element, elements_dict)
return ''.join([Constants.XML_HEADER, ET.tostring(element)])
def _obj_to_xml(self):
elements_dict = {
'name': self.name,
'flavorRef': self.flavor_ref,
'max_count': self.max_count,
'min_count': self.min_count,
'image_ref': self.image_ref,
'user_data': self.user_data,
'accessIPv4': self.accessIPv4,
'accessIPv6': self.accessIPv6,
'adminPass': self.admin_pass,
'key_name': self.key_name,
'config_drive': self.config_drive,
'security_groups': self.security_groups
}
element = ET.Element('server')
element.set('xmlns', Constants.XML_API_NAMESPACE)
block_device_ele = ET.Element('block_device_mapping_v2')
block_device_ele.append(BlockDeviceMappingV2._obj_to_xml(
self.block_device_mapping_v2))
element.append(block_device_ele)
if self.networks is not None:
networks_ele = ET.Element('networks')
for network_id in self.networks:
network = ET.Element('network')
network.set('uuid', network_id['uuid'])
networks_ele.append(network)
element.append(networks_ele)
if self.personality is not None:
personality_ele = ET.Element('personality')
personality_ele.append(Personality._obj_to_xml(self.personality))
element.append(personality_ele)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
if self.disk_config is not None:
element.set('xmlns:OS-DCF',
Constants.XML_API_DISK_CONFIG_NAMESPACE)
element.set('OS-DCF:diskConfig', self.disk_config)
element = self._set_xml_etree_element(element, elements_dict)
return ''.join([Constants.XML_HEADER, ET.tostring(element)])
def _dict_to_obj(cls, server_dict):
'''Helper method to turn dictionary into Server instance.'''
addresses = None
flavor = None
image = None
links = None
metadata = None
if 'links' in server_dict:
links = Links._dict_to_obj(server_dict['links'])
if 'addresses' in server_dict:
addresses = Addresses._dict_to_obj(server_dict['addresses'])
if 'flavor' in server_dict:
flavor = FlavorMin._dict_to_obj(server_dict['flavor'])
if 'image' in server_dict:
image = ImageMin._dict_to_obj(server_dict['image'])
if 'metadata' in server_dict:
metadata = Metadata._dict_to_obj(server_dict['metadata'])
server = Server(
id=server_dict.get('id') or server_dict.get('uuid'),
disk_config=server_dict.get('OS-DCF:diskConfig'),
power_state=server_dict.get('OS-EXT-STS:power_state'),
progress=server_dict.get('progress', 0),
task_state=server_dict.get('OS-EXT-STS:task_state'),
vm_state=server_dict.get('OS-EXT-STS:vm_state'),
name=server_dict.get('name'),
tenant_id=server_dict.get('tenant_id'),
status=server_dict.get('status'),
updated=server_dict.get('updated'),
created=server_dict.get('created'),
host_id=server_dict.get('hostId'),
user_id=server_dict.get('user_id'),
accessIPv4=server_dict.get('accessIPv4'),
accessIPv6=server_dict.get('accessIPv6'), addresses=addresses,
flavor=flavor, image=image, links=links, metadata=metadata,
admin_pass=server_dict.get('adminPass'),
key_name=server_dict.get('key_name'))
return server
def _xml_ele_to_obj(cls, element):
'''Helper method to turn ElementTree instance to Server instance.'''
server_dict = element.attrib
addresses = None
flavor = None
image = None
links = None
metadata = None
links = Links._xml_ele_to_obj(element)
if element.find('addresses') is not None:
addresses = Addresses._xml_ele_to_obj(element.find('addresses'))
if element.find('flavor') is not None:
flavor = Flavor._xml_ele_to_obj(element.find('flavor'))
if element.find('image') is not None:
image = Image._xml_ele_to_obj(element.find('image'))
if element.find('metadata') is not None:
metadata = Metadata._xml_ele_to_obj(element)
if 'progress' in server_dict:
progress = server_dict.get('progress') \
and int(server_dict.get('progress'))
if 'tenantId' in server_dict:
tenant_id = server_dict.get('tenantId')
if 'userId' in server_dict:
user_id = server_dict.get('userId')
server = Server(server_dict['id'], server_dict['diskConfig'],
server_dict['power_state'], progress,
server_dict['task_state'],
server_dict['vm_state'],
server_dict['name'], tenant_id,
server_dict['status'], server_dict['updated'],
server_dict['created'], server_dict['hostId'],
user_id, server_dict['accessIPv4'],
server_dict['accessIPv6'], addresses, flavor,
image, links, metadata)
return server
def _xml_ele_to_obj(cls, element):
'''Helper method to turn ElementTree instance to Server instance.'''
server = element.attrib
addresses = None
flavor = None
image = None
metadata = None
links = Links._xml_ele_to_obj(element)
if element.find('addresses') is not None:
addresses = Addresses._xml_ele_to_obj(element.find('addresses'))
if element.find('flavor') is not None:
flavor = Flavor._xml_ele_to_obj(element.find('flavor'))
if element.find('image') is not None:
image = Image._xml_ele_to_obj(element.find('image'))
if element.find('metadata') is not None:
metadata = Metadata._xml_ele_to_obj(element)
if 'progress' in server:
progress = server.get('progress') \
and int(server.get('progress'))
else:
progress = None
server = Server(
id=server.get('id'), disk_config=server.get('diskConfig'),
power_state=server.get('power_state'), progress=progress,
task_state=server.get('task_state'),
vm_state=server.get('vm_state'), name=server.get('name'),
tenant_id=server.get('tenant_id'), status=server.get('status'),
updated=server.get('updated'), created=server.get('created'),
host_id=server.get('hostId'), user_id=server.get('user_id'),
accessIPv4=server.get('accessIPv4'),
accessIPv6=server.get('accessIPv6'), addresses=addresses,
flavor=flavor, image=image, links=links, metadata=metadata,
admin_pass=server.get('adminPass'))
return server
def _dict_to_obj(cls, server_dict):
'''Helper method to turn dictionary into Server instance.'''
addresses = None
flavor = None
image = None
links = None
metadata = None
if 'links' in server_dict:
links = Links._dict_to_obj(server_dict['links'])
if 'addresses' in server_dict:
addresses = Addresses._dict_to_obj(server_dict['addresses'])
if 'flavor' in server_dict:
flavor = FlavorMin._dict_to_obj(server_dict['flavor'])
if 'image' in server_dict:
image = ImageMin._dict_to_obj(server_dict['image'])
if 'metadata' in server_dict:
metadata = Metadata._dict_to_obj(server_dict['metadata'])
server = Server(
server_dict['id'], server_dict.get('OS-DCF:diskConfig'),
server_dict.get('OS-EXT-STS:power_state'),
server_dict.get('progress', 0),
server_dict.get('OS-EXT-STS:task_state'),
server_dict.get('OS-EXT-STS:vm_state'),
server_dict.get('name'), server_dict.get('tenant_id'),
server_dict.get('status'), server_dict.get('updated'),
server_dict.get('created'), server_dict.get('hostId'),
server_dict.get('user_id'), server_dict.get('accessIPv4'),
server_dict.get('accessIPv6'), addresses, flavor,
image, links, metadata, server_dict.get('adminPass'))
for each in server_dict:
if each.startswith("{"):
newkey = re.split("}", each)[1]
setattr(server, newkey, server_dict[each])
return server
def _obj_to_xml(self):
element = ET.Element('rebuild')
xml = Constants.XML_HEADER
element.set('xmlns', Constants.XML_API_NAMESPACE)
element.set('name', self.name)
element.set('imageRef', self.image_ref)
if self.admin_pass is not None:
element.set('adminPass', self.admin_pass)
if self.disk_config is not None:
element.set('xmlns:OS-DCF',
Constants.XML_API_DISK_CONFIG_NAMESPACE)
element.set('OS-DCF:diskConfig', self.disk_config)
if self.metadata is not None:
meta_ele = ET.Element('metadata')
for key, value in self.metadata.items():
meta_ele.append(Metadata._dict_to_xml(key, value))
element.append(meta_ele)
if self.networks is not None:
networks_ele = ET.Element('networks')
for network_id in self.networks:
network = ET.Element('network')
network.set('uuid', network_id['uuid'])
networks_ele.append(network)
element.append(networks_ele)
if self.personality is not None:
personality_ele = ET.Element('personality')
personality_ele.append(Personality._obj_to_xml(self.personality))
element.append(personality_ele)
if self.user_data is not None:
element.set('user_data', self.user_data)
if self.accessIPv4 is not None:
element.set('accessIPv4', self.accessIPv4)
if self.accessIPv6 is not None:
element.set('accessIPv6', self.accessIPv6)
if self.key_name is not None:
element.set('key_name', self.key_name)
xml += ET.tostring(element)
return xml
def test_metadata_json_deserialization(self):
metadata = Metadata.deserialize(self.expected_json, 'json')
self.assertIsNotNone(metadata)
self.assertEqual(metadata.get('key1'), 'value1')
def test_metadata_json_deserialization(self):
metadata = Metadata.deserialize(self.expected_json, 'json')
self.assertIsNotNone(metadata)
self.assertEqual(metadata.get('key1'), 'value1')
