def update_volume_metadata(self, volume_id, metadata):
"""Update metadata for the volume."""
put_body = self._metadata_body(metadata)
url = "volumes/%s/metadata" % str(volume_id)
resp, body = self.put(url, str(Document(put_body)))
body = self._parse_key_value(etree.fromstring(body))
return resp, body
def accept_volume_transfer(self, transfer_id, transfer_auth_key):
"""Accept a volume transfer."""
post_body = Element("accept", auth_key=transfer_auth_key)
url = 'os-volume-transfer/%s/accept' % transfer_id
resp, body = self.post(url, str(Document(post_body)))
volume = xml_to_json(etree.fromstring(body))
return resp, volume
def create_volume_metadata(self, volume_id, metadata):
"""Create metadata for the volume."""
post_body = self._metadata_body(metadata)
resp, body = self.post('volumes/%s/metadata' % volume_id,
str(Document(post_body)))
body = self._parse_key_value(etree.fromstring(body))
return resp, body
def create_volume(self, size, display_name=None, metadata=None):
"""Creates a new Volume.
:param size: Size of volume in GB. (Required)
:param display_name: Optional Volume Name.
:param metadata: An optional dictionary of values for metadata.
"""
volume = Element("volume",
xmlns=XMLNS_11,
size=size)
if display_name:
volume.add_attr('display_name', display_name)
if metadata:
_metadata = Element('metadata')
volume.append(_metadata)
for key, value in metadata.items():
meta = Element('meta')
meta.add_attr('key', key)
meta.append(Text(value))
_metadata.append(meta)
resp, body = self.post('os-volumes', str(Document(volume)),
self.headers)
body = xml_to_json(etree.fromstring(body))
return resp, body
def update_snapshot_metadata(self, snapshot_id, metadata):
"""Update metadata for the snapshot."""
put_body = self._metadata_body(metadata)
url = "snapshots/%s/metadata" % str(snapshot_id)
resp, body = self.put(url, str(Document(put_body)), self.headers)
body = self._parse_key_value(etree.fromstring(body))
return resp, body
def create_policy(self, blob, type):
"""Creates a Policy."""
create_policy = Element("policy", xmlns=XMLNS, blob=blob, type=type)
resp, body = self.post('policies', str(Document(create_policy)),
self.headers)
body = self._parse_body(etree.fromstring(body))
return resp, body
def set_image_metadata(self, image_id, meta):
"""Sets the metadata for an image."""
post_body = self._metadata_body(meta)
resp, body = self.put('images/%s/metadata' % image_id,
str(Document(post_body)))
body = self._parse_key_value(etree.fromstring(body))
return resp, body
def create_volume(self, size, **kwargs):
"""Creates a new Volume.
:param size: Size of volume in GB. (Required)
:param display_name: Optional Volume Name.
:param metadata: An optional dictionary of values for metadata.
:param volume_type: Optional Name of volume_type for the volume
:param snapshot_id: When specified the volume is created from
this snapshot
:param imageRef: When specified the volume is created from this
image
"""
# NOTE(afazekas): it should use a volume namespace
volume = Element("volume", xmlns=XMLNS_11, size=size)
if 'metadata' in kwargs:
_metadata = Element('metadata')
volume.append(_metadata)
for key, value in kwargs['metadata'].items():
meta = Element('meta')
meta.add_attr('key', key)
meta.append(Text(value))
_metadata.append(meta)
attr_to_add = kwargs.copy()
del attr_to_add['metadata']
else:
attr_to_add = kwargs
for key, value in attr_to_add.items():
volume.add_attr(key, value)
resp, body = self.post('volumes', str(Document(volume)), self.headers)
body = xml_to_json(etree.fromstring(body))
return resp, body
def attach_volume(self, server_id, volume_id, device='/dev/vdz'):
post_body = Element("volumeAttachment",
volumeId=volume_id,
device=device)
resp, body = self.post('servers/%s/os-volume_attachments' % server_id,
str(Document(post_body)), self.headers)
return resp, body
def create_security_group_rule(self, parent_group_id, ip_proto, from_port,
to_port, **kwargs):
"""
Creating a new security group rules.
parent_group_id :ID of Security group
ip_protocol : ip_proto (icmp, tcp, udp).
from_port: Port at start of range.
to_port : Port at end of range.
Following optional keyword arguments are accepted:
cidr : CIDR for address range.
group_id : ID of the Source group
"""
group_rule = Element("security_group_rule")
elements = dict()
elements['cidr'] = kwargs.get('cidr')
elements['group_id'] = kwargs.get('group_id')
elements['parent_group_id'] = parent_group_id
elements['ip_protocol'] = ip_proto
elements['from_port'] = from_port
elements['to_port'] = to_port
for k, v in elements.items():
if v is not None:
element = Element(k)
element.append(Text(content=str(v)))
group_rule.append(element)
url = 'os-security-group-rules'
resp, body = self.post(url, str(Document(group_rule)), self.headers)
body = self._parse_body(etree.fromstring(body))
return resp, body
def update_server(self, server_id, name=None, meta=None, accessIPv4=None,
accessIPv6=None, disk_config=None):
doc = Document()
server = Element("server")
doc.append(server)
if name is not None:
server.add_attr("name", name)
if accessIPv4 is not None:
server.add_attr("accessIPv4", accessIPv4)
if accessIPv6 is not None:
server.add_attr("accessIPv6", accessIPv6)
if disk_config is not None:
server.add_attr('xmlns:OS-DCF', "http://docs.openstack.org/"
"compute/ext/disk_config/api/v1.1")
server.add_attr("OS-DCF:diskConfig", disk_config)
if meta is not None:
metadata = Element("metadata")
server.append(metadata)
for k, v in meta:
meta = Element("meta", key=k)
meta.append(Text(v))
metadata.append(meta)
resp, body = self.put('servers/%s' % str(server_id),
str(doc), self.headers)
return resp, xml_to_json(etree.fromstring(body))
def create_flavor(self, name, ram, vcpus, disk, flavor_id, **kwargs):
"""Creates a new flavor or instance type."""
flavor = Element("flavor",
xmlns=XMLNS_11,
ram=ram,
vcpus=vcpus,
disk=disk,
id=flavor_id,
name=name)
if kwargs.get('rxtx'):
flavor.add_attr('rxtx_factor', kwargs.get('rxtx'))
if kwargs.get('swap'):
flavor.add_attr('swap', kwargs.get('swap'))
if kwargs.get('ephemeral'):
flavor.add_attr('OS-FLV-EXT-DATA:ephemeral',
kwargs.get('ephemeral'))
if kwargs.get('is_public'):
flavor.add_attr('os-flavor-access:is_public',
kwargs.get('is_public'))
flavor.add_attr('xmlns:OS-FLV-EXT-DATA', XMLNS_OS_FLV_EXT_DATA)
flavor.add_attr('xmlns:os-flavor-access', XMLNS_OS_FLV_ACCESS)
resp, body = self.post('flavors', str(Document(flavor)), self.headers)
body = xml_to_json(etree.fromstring(body))
flavor = self._format_flavor(body)
return resp, flavor
def add_router_interface_with_subnet_id(self, router_id, subnet_id):
uri = '%s/routers/%s/add_router_interface' % (self.uri_prefix,
router_id)
subnet = Element("subnet_id", subnet_id)
resp, body = self.put(uri, str(Document(subnet)), self.headers)
body = _root_tag_fetcher_and_xml_to_json_parse(body)
return resp, body
def remove_router_interface_with_port_id(self, router_id, port_id):
uri = '%s/routers/%s/remove_router_interface' % (self.uri_prefix,
router_id)
port = Element("port_id", port_id)
resp, body = self.put(uri, str(Document(port)), self.headers)
body = _root_tag_fetcher_and_xml_to_json_parse(body)
return resp, body
def update_server(self,
server_id,
name=None,
meta=None,
accessIPv4=None,
accessIPv6=None):
doc = Document()
server = Element("server")
doc.append(server)
if name is not None:
server.add_attr("name", name)
if accessIPv4 is not None:
server.add_attr("accessIPv4", accessIPv4)
if accessIPv6 is not None:
server.add_attr("accessIPv6", accessIPv6)
if meta is not None:
metadata = Element("metadata")
server.append(metadata)
for k, v in meta:
meta = Element("meta", key=k)
meta.append(Text(v))
metadata.append(meta)
resp, body = self.put('servers/%s' % str(server_id), str(doc),
self.headers)
return resp, xml_to_json(etree.fromstring(body))
def create_interface(self,
server,
port_id=None,
network_id=None,
fixed_ip=None):
doc = Document()
iface = Element('interfaceAttachment')
if port_id:
_port_id = Element('port_id')
_port_id.append(Text(port_id))
iface.append(_port_id)
if network_id:
_network_id = Element('net_id')
_network_id.append(Text(network_id))
iface.append(_network_id)
if fixed_ip:
_fixed_ips = Element('fixed_ips')
_fixed_ip = Element('fixed_ip')
_ip_address = Element('ip_address')
_ip_address.append(Text(fixed_ip))
_fixed_ip.append(_ip_address)
_fixed_ips.append(_fixed_ip)
iface.append(_fixed_ips)
doc.append(iface)
resp, body = self.post('servers/%s/os-interface' % server,
headers=self.headers,
body=str(doc))
body = self._process_xml_interface(etree.fromstring(body))
return resp, body
def update_endpoint(self,
endpoint_id,
service_id=None,
interface=None,
url=None,
region=None,
enabled=None):
"""Updates an endpoint with given parameters."""
doc = Document()
endpoint = Element("endpoint")
doc.append(endpoint)
if service_id:
endpoint.add_attr("service_id", service_id)
if interface:
endpoint.add_attr("interface", interface)
if url:
endpoint.add_attr("url", url)
if region:
endpoint.add_attr("region", region)
if enabled is not None:
endpoint.add_attr("enabled", enabled)
resp, body = self.patch('endpoints/%s' % str(endpoint_id), str(doc),
self.headers)
body = self._parse_body(etree.fromstring(body))
return resp, body
def update_role(self, name, role_id):
"""Updates a Role."""
post_body = Element("role", xmlns=XMLNS, name=name)
resp, body = self.patch('roles/%s' % str(role_id),
str(Document(post_body)))
body = self._parse_body(etree.fromstring(body))
return resp, body
def add_host(self, aggregate_id, host):
"""Adds a host to the given aggregate."""
post_body = Element("add_host", host=host)
resp, body = self.post('os-aggregates/%s/action' % aggregate_id,
str(Document(post_body)))
aggregate = self._format_aggregate(etree.fromstring(body))
return resp, aggregate
def remove_host(self, aggregate_id, host):
"""Removes a host from the given aggregate."""
post_body = Element("remove_host", host=host)
resp, body = self.post('os-aggregates/%s/action' % aggregate_id,
str(Document(post_body)), self.headers)
aggregate = self._format_aggregate(etree.fromstring(body))
return resp, aggregate
def create_volume_type(self, name, **kwargs):
"""
Creates a new Volume_type.
name(Required): Name of volume_type.
Following optional keyword arguments are accepted:
extra_specs: A dictionary of values to be used as extra_specs.
"""
vol_type = Element("volume_type", xmlns=XMLNS_11)
if name:
vol_type.add_attr('name', name)
extra_specs = kwargs.get('extra_specs')
if extra_specs:
_extra_specs = Element('extra_specs')
vol_type.append(_extra_specs)
for key, value in extra_specs.items():
spec = Element('extra_spec')
spec.add_attr('key', key)
spec.append(Text(value))
_extra_specs.append(spec)
resp, body = self.post('types', str(Document(vol_type)),
self.headers)
body = xml_to_json(etree.fromstring(body))
return resp, body
def create_role(self, name):
"""Create a role."""
create_role = Element("role", xmlns=XMLNS, name=name)
resp, body = self.post('OS-KSADM/roles', str(Document(create_role)),
self.headers)
body = self._parse_body(etree.fromstring(body))
return resp, body
def enable_disable_user(self, user_id, enabled):
"""Enables or disables a user."""
enable_user = Element("user", enabled=str(enabled).lower())
resp, body = self.put('users/%s/enabled' % user_id,
str(Document(enable_user)), self.headers)
body = self._parse_array(etree.fromstring(body))
return resp, body
def update_image_metadata(self, image_id, meta):
"""Updates the metadata for an image."""
post_body = self._metadata_body(meta)
resp, body = self.post('images/%s/metadata' % str(image_id),
str(Document(post_body)), self.headers)
body = self._parse_key_value(etree.fromstring(body))
return resp, body
def rebuild(self, server_id, image_ref, **kwargs):
kwargs['imageRef'] = image_ref
if 'disk_config' in kwargs:
kwargs['OS-DCF:diskConfig'] = kwargs['disk_config']
del kwargs['disk_config']
kwargs['xmlns:OS-DCF'] = "http://docs.openstack.org/"\
"compute/ext/disk_config/api/v1.1"
kwargs['xmlns:atom'] = "http://www.w3.org/2005/Atom"
if 'xmlns' not in kwargs:
kwargs['xmlns'] = XMLNS_11
attrs = kwargs.copy()
if 'metadata' in attrs:
del attrs['metadata']
rebuild = Element("rebuild", **attrs)
if 'metadata' in kwargs:
metadata = Element("metadata")
rebuild.append(metadata)
for k, v in kwargs['metadata'].items():
meta = Element("meta", key=k)
meta.append(Text(v))
metadata.append(meta)
resp, body = self.post('servers/%s/action' % server_id,
str(Document(rebuild)), self.headers)
server = self._parse_server(etree.fromstring(body))
return resp, server
def update_image_metadata_item(self, image_id, key, meta):
"""Sets the value for a specific image metadata key."""
post_body = Document('meta', Text(meta), key=key)
resp, body = self.put('images/%s/metadata/%s' % (str(image_id), key),
post_body, self.headers)
body = xml_to_json(etree.fromstring(body))
return resp, body['meta']
def create_snapshot_metadata(self, snapshot_id, metadata):
"""Create metadata for the snapshot."""
post_body = self._metadata_body(metadata)
resp, body = self.post('snapshots/%s/metadata' % snapshot_id,
str(Document(post_body)))
body = self._parse_key_value(etree.fromstring(body))
return resp, body
def update_quota_set(self, tenant_id, force=None,
injected_file_content_bytes=None,
metadata_items=None, ram=None, floating_ips=None,
fixed_ips=None, key_pairs=None, instances=None,
security_group_rules=None, injected_files=None,
cores=None, injected_file_path_bytes=None,
security_groups=None):
"""
Updates the tenant's quota limits for one or more resources
"""
post_body = Element("quota_set",
xmlns=XMLNS_11)
if force is not None:
post_body.add_attr('force', force)
if injected_file_content_bytes is not None:
post_body.add_attr('injected_file_content_bytes',
injected_file_content_bytes)
if metadata_items is not None:
post_body.add_attr('metadata_items', metadata_items)
if ram is not None:
post_body.add_attr('ram', ram)
if floating_ips is not None:
post_body.add_attr('floating_ips', floating_ips)
if fixed_ips is not None:
post_body.add_attr('fixed_ips', fixed_ips)
if key_pairs is not None:
post_body.add_attr('key_pairs', key_pairs)
if instances is not None:
post_body.add_attr('instances', instances)
if security_group_rules is not None:
post_body.add_attr('security_group_rules', security_group_rules)
if injected_files is not None:
post_body.add_attr('injected_files', injected_files)
if cores is not None:
post_body.add_attr('cores', cores)
if injected_file_path_bytes is not None:
post_body.add_attr('injected_file_path_bytes',
injected_file_path_bytes)
if security_groups is not None:
post_body.add_attr('security_groups', security_groups)
resp, body = self.put('os-quota-sets/%s' % str(tenant_id),
str(Document(post_body)))
body = xml_to_json(etree.fromstring(body))
body = self._format_quota(body)
return resp, body
def update_router(self, router_id, **kwargs):
uri = '%s/routers/%s' % (self.uri_prefix, router_id)
router = Element("router")
for element, content in kwargs.iteritems():
router.append(Element(element, content))
resp, body = self.put(uri, str(Document(router)), self.headers)
body = _root_tag_fetcher_and_xml_to_json_parse(body)
return resp, body
def create_router(self, name, **kwargs):
uri = '%s/routers' % (self.uri_prefix)
router = Element("router")
router.append(Element("name", name))
deep_dict_to_xml(router, kwargs)
resp, body = self.post(uri, str(Document(router)), self.headers)
body = _root_tag_fetcher_and_xml_to_json_parse(body)
return resp, body
