Esempio n. 1
0
    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))
        return resp, xml_to_json(etree.fromstring(body))
Esempio n. 2
0
    def update_server(self, server_id, name=None, meta=None, access_ip_v4=None,
                      access_ip_v6=None, disk_config=None):
        doc = Document()
        server = Element("server")
        doc.append(server)

        if name is not None:
            server.add_attr("name", name)
        if access_ip_v4 or access_ip_v6:
            server.add_attr('xmlns:os-access-ips',
                            "http://docs.openstack.org/compute/ext/"
                            "os-access-ips/api/v3")
        if access_ip_v4 is not None:
            server.add_attr("os-access-ips:access_ip_v4", access_ip_v4)
        if access_ip_v6 is not None:
            server.add_attr("os-access-ips:access_ip_v6", access_ip_v6)
        if disk_config is not None:
            server.add_attr('xmlns:os-disk-config', "http://docs.openstack.org"
                            "/compute/ext/disk_config/api/v3")
            server.add_attr("os-disk-config:disk_config", 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))
Esempio n. 3
0
 def _metadata_body(image_id, meta):
     post_body = Document("metadata")
     for k, v in meta:
         text = Text(v)
         metadata = Element("meta", text, key=k)
         post_body.append(metadata)
     return post_body
Esempio n. 4
0
 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,
                            body=str(doc))
     body = self._process_xml_interface(etree.fromstring(body))
     return resp, body
Esempio n. 5
0
 def set_server_metadata_item(self, server_id, key, meta):
     doc = Document()
     for k, v in meta.items():
         meta_element = Element("meta", key=k)
         meta_element.append(Text(v))
         doc.append(meta_element)
     resp, body = self.put("servers/%s/metadata/%s" % (str(server_id), key), str(doc), self.headers)
     return resp, xml_to_json(etree.fromstring(body))
Esempio n. 6
0
 def associate_floating_ip_to_server(self, floating_ip, server_id):
     """Associate the provided floating IP to a specific server."""
     url = "servers/%s/action" % str(server_id)
     doc = Document()
     server = Element("addFloatingIp")
     doc.append(server)
     server.add_attr("address", floating_ip)
     resp, body = self.post(url, str(doc))
     return resp, body
Esempio n. 7
0
 def disassociate_floating_ip_from_server(self, floating_ip, server_id):
     """Disassociate the provided floating IP from a specific server."""
     url = "servers/%s/action" % str(server_id)
     doc = Document()
     server = Element("removeFloatingIp")
     doc.append(server)
     server.add_attr("address", floating_ip)
     resp, body = self.post(url, str(doc), self.headers)
     return resp, body
Esempio n. 8
0
 def add_flavor_access(self, flavor_id, tenant_id):
     """Add flavor access for the specified tenant."""
     doc = Document()
     server = Element("add_tenant_access")
     doc.append(server)
     server.add_attr("tenant_id", tenant_id)
     resp, body = self.post("flavors/%s/action" % str(flavor_id), str(doc), self.headers)
     body = self._parse_array_access(etree.fromstring(body))
     return resp, body
Esempio n. 9
0
 def remove_flavor_access(self, flavor_id, tenant_id):
     """Remove flavor access from the specified tenant."""
     doc = Document()
     server = Element("removeTenantAccess")
     doc.append(server)
     server.add_attr("tenant", tenant_id)
     resp, body = self.post('flavors/%s/action' % str(flavor_id), str(doc))
     body = self._parse_array_access(etree.fromstring(body))
     return resp, body
Esempio n. 10
0
 def update_server_metadata(self, server_id, meta):
     doc = Document()
     metadata = Element("metadata")
     doc.append(metadata)
     for k, v in meta.items():
         meta_element = Element("meta", key=k)
         meta_element.append(Text(v))
         metadata.append(meta_element)
     resp, body = self.post("/servers/%s/metadata" % str(server_id), str(doc), headers=self.headers)
     body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 11
0
 def set_server_metadata(self, server_id, meta, no_metadata_field=False):
     doc = Document()
     if not no_metadata_field:
         metadata = Element("metadata")
         doc.append(metadata)
         for k, v in meta.items():
             meta_element = Element("meta", key=k)
             meta_element.append(Text(v))
             metadata.append(meta_element)
     resp, body = self.put('servers/%s/metadata' % str(server_id), str(doc))
     return resp, xml_to_json(etree.fromstring(body))
Esempio n. 12
0
    def update_flavor_extra_spec(self, flavor_id, key, **kwargs):
        """Update extra Specs details of the mentioned flavor and key."""
        doc = Document()
        for (k, v) in kwargs.items():
            element = Element(k)
            doc.append(element)
            value = Text(v)
            element.append(value)

        resp, body = self.put("flavors/%s/flavor-extra-specs/%s" % (flavor_id, key), str(doc), self.headers)
        body = xml_to_json(etree.fromstring(body))
        return resp, {key: body}
Esempio n. 13
0
 def create_floating_ip(self, pool_name=None):
     """Allocate a floating IP to the project."""
     url = 'os-floating-ips'
     if pool_name:
         doc = Document()
         pool = Element("pool")
         pool.append(Text(pool_name))
         doc.append(pool)
         resp, body = self.post(url, str(doc), self.headers)
     else:
         resp, body = self.post(url, None, self.headers)
     body = self._parse_floating_ip(etree.fromstring(body))
     return resp, body
Esempio n. 14
0
 def update_aggregate(self, aggregate_id, name, availability_zone=None):
     """Update a aggregate."""
     put_body = Element("aggregate",
                        name=name,
                        availability_zone=availability_zone)
     resp, body = self.put('os-aggregates/%s' % str(aggregate_id),
                           str(Document(put_body)), self.headers)
     aggregate = self._format_aggregate(etree.fromstring(body))
     return resp, aggregate
Esempio n. 15
0
 def create_aggregate(self, name, availability_zone=None):
     """Creates a new aggregate."""
     post_body = Element("aggregate",
                         name=name,
                         availability_zone=availability_zone)
     resp, body = self.post('os-aggregates', str(Document(post_body)),
                            self.headers)
     aggregate = self._format_aggregate(etree.fromstring(body))
     return resp, aggregate
Esempio n. 16
0
 def set_flavor_extra_spec(self, flavor_id, specs):
     """Sets extra Specs to the mentioned flavor."""
     extra_specs = Element("extra_specs")
     for key in specs.keys():
         extra_specs.add_attr(key, specs[key])
     resp, body = self.post('flavors/%s/os-extra_specs' % flavor_id,
                            str(Document(extra_specs)), self.headers)
     body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 17
0
    def update_volume(self, volume_id, **kwargs):
        """Updates the Specified Volume."""
        put_body = Element("volume", xmlns=XMLNS_11, **kwargs)

        resp, body = self.put('volumes/%s' % volume_id,
                              str(Document(put_body)),
                              self.headers)
        body = xml_to_json(etree.fromstring(body))
        return resp, body
Esempio n. 18
0
 def extend_volume(self, volume_id, extend_size):
     """Extend a volume."""
     post_body = Element("os-extend",
                         new_size=extend_size)
     url = 'volumes/%s/action' % str(volume_id)
     resp, body = self.post(url, str(Document(post_body)), self.headers)
     if body:
         body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 19
0
 def update_volume_readonly(self, volume_id, readonly):
     """Update the Specified Volume readonly."""
     post_body = Element("os-update_readonly_flag",
                         readonly=readonly)
     url = 'volumes/%s/action' % str(volume_id)
     resp, body = self.post(url, str(Document(post_body)), self.headers)
     if body:
         body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 20
0
 def update_snapshot_metadata_item(self, snapshot_id, id, meta_item):
     """Update metadata item for the snapshot."""
     for k, v in meta_item.items():
         put_body = Element('meta', key=k)
         put_body.append(Text(v))
     url = "snapshots/%s/metadata/%s" % (str(snapshot_id), str(id))
     resp, body = self.put(url, str(Document(put_body)), self.headers)
     body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 21
0
 def create_service(self, serv_type, name=None, description=None):
     post_body = Element("service",
                         xmlns=XMLNS,
                         name=name,
                         description=description,
                         type=serv_type)
     resp, body = self.post("services", str(Document(post_body)))
     body = self._parse_body(etree.fromstring(body))
     return resp, body
Esempio n. 22
0
    def update_snapshot(self, snapshot_id, **kwargs):
        """Updates a snapshot."""
        put_body = Element("snapshot", xmlns=XMLNS_11, **kwargs)

        resp, body = self.put('snapshots/%s' % snapshot_id,
                              str(Document(put_body)),
                              self.headers)
        body = xml_to_json(etree.fromstring(body))
        return resp, body
Esempio n. 23
0
 def set_image_metadata_item(self, image_id, key, meta):
     """Sets the value for a specific image metadata key."""
     for k, v in meta.items():
         post_body = Element('meta', key=key)
         post_body.append(Text(v))
     resp, body = self.put('images/%s/metadata/%s' % (str(image_id), key),
                           str(Document(post_body)))
     body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 24
0
 def action(self, server_id, action_name, response_key, **kwargs):
     if 'xmlns' not in kwargs:
         kwargs['xmlns'] = XMLNS_11
     doc = Document((Element(action_name, **kwargs)))
     resp, body = self.post("servers/%s/action" % server_id, str(doc),
                            self.headers)
     if response_key is not None:
         body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 25
0
 def update_agent(self, agent_id, agent_info):
     uri = '%s/agents/%s' % (self.uri_prefix, agent_id)
     agent = Element('agent')
     for (key, value) in agent_info.items():
         p = Element(key, value)
         agent.append(p)
     resp, body = self.put(uri, str(Document(agent)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body
Esempio n. 26
0
 def create_floating_ip(self, ext_network_id, **kwargs):
     uri = '%s/floatingips' % (self.uri_prefix)
     floatingip = Element('floatingip')
     floatingip.append(Element("floating_network_id", ext_network_id))
     for element, content in kwargs.iteritems():
         floatingip.append(Element(element, content))
     resp, body = self.post(uri, str(Document(floatingip)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body
Esempio n. 27
0
 def update_volume_metadata_item(self, volume_id, id, meta_item):
     """Update metadata item for the volume."""
     for k, v in meta_item.items():
         put_body = Element('meta', key=k)
         put_body.append(Text(v))
     url = "volumes/%s/metadata/%s" % (str(volume_id), str(id))
     resp, body = self.put(url, str(Document(put_body)))
     body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 28
0
 def upload_volume(self, volume_id, image_name, disk_format):
     """Uploads a volume in Glance."""
     post_body = Element("os-volume_upload_image",
                         image_name=image_name,
                         disk_format=disk_format)
     url = 'volumes/%s/action' % str(volume_id)
     resp, body = self.post(url, str(Document(post_body)))
     volume = xml_to_json(etree.fromstring(body))
     return resp, volume
Esempio n. 29
0
 def associate_health_monitor_with_pool(self, health_monitor_id,
                                        pool_id):
     uri = '%s/lb/pools/%s/health_monitors' % (self.uri_prefix,
                                               pool_id)
     post_body = Element("health_monitor")
     p1 = Element("id", health_monitor_id,)
     post_body.append(p1)
     resp, body = self.post(uri, str(Document(post_body)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body
Esempio n. 30
0
 def reset_snapshot_status(self, snapshot_id, status):
     """Reset the specified snapshot's status."""
     post_body = Element("os-reset_status",
                         status=status
                         )
     url = 'snapshots/%s/action' % str(snapshot_id)
     resp, body = self.post(url, str(Document(post_body)), self.headers)
     if body:
         body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 31
0
    def resize(self, server_id, flavor_ref, disk_config=None):
        resize = Element("resize",
                         xmlns=XMLNS_11,
                         flavorRef=flavor_ref)

        if disk_config is not None:
            raise Exception("Sorry, disk_config not supported via XML yet")

        return self.post('servers/%s/action' % server_id,
                         str(Document(resize)), self.headers)
Esempio n. 32
0
 def attach_volume(self, volume_id, instance_uuid, mountpoint):
     """Attaches a volume to a given instance on a given mountpoint."""
     post_body = Element("os-attach",
                         instance_uuid=instance_uuid,
                         mountpoint=mountpoint)
     url = 'volumes/%s/action' % str(volume_id)
     resp, body = self.post(url, str(Document(post_body)), self.headers)
     if body:
         body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 33
0
 def reset_volume_status(self, volume_id, status):
     """Reset the Specified Volume's Status."""
     post_body = Element("os-reset_status",
                         status=status
                         )
     url = 'volumes/%s/action' % str(volume_id)
     resp, body = self.post(url, str(Document(post_body)), self.headers)
     if body:
         body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 34
0
    def update_user(self, user_id, **kwargs):
        """Updates a user."""
        if 'enabled' in kwargs:
            kwargs['enabled'] = str(kwargs['enabled']).lower()
        update_user = Element("user", xmlns=XMLNS, **kwargs)

        resp, body = self.put('users/%s' % user_id, str(Document(update_user)),
                              self.headers)
        body = self._parse_body(etree.fromstring(body))
        return resp, body
Esempio n. 35
0
 def auth(self, user, password, tenant):
     passwordCreds = Element("passwordCredentials",
                             username=user,
                             password=password)
     auth = Element("auth", tenantName=tenant)
     auth.append(passwordCreds)
     headers = {'Content-Type': 'application/xml'}
     resp, body = self.post(self.auth_url, headers=headers,
                            body=str(Document(auth)))
     return resp, body
Esempio n. 36
0
    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
Esempio n. 37
0
 def update_policy(self, policy_id, **kwargs):
     """Updates a policy."""
     resp, body = self.get_policy(policy_id)
     type = kwargs.get('type')
     update_policy = Element("policy", xmlns=XMLNS, type=type)
     url = 'policies/%s' % policy_id
     resp, body = self.patch(url, str(Document(update_policy)),
                             self.headers)
     body = self._parse_body(etree.fromstring(body))
     return resp, body
Esempio n. 38
0
 def auth(self, user, password, tenant):
     passwordCreds = Element("passwordCredentials",
                             username=user,
                             password=password)
     auth = Element("auth", tenantName=tenant)
     auth.append(passwordCreds)
     resp, body = self.post(self.auth_url,
                            headers=self.headers,
                            body=str(Document(auth)))
     return resp, body['access']
Esempio n. 39
0
 def create_volume_transfer(self, vol_id, display_name=None):
     """Create a volume transfer."""
     post_body = Element("transfer",
                         volume_id=vol_id)
     if display_name:
         post_body.add_attr('name', display_name)
     resp, body = self.post('os-volume-transfer',
                            str(Document(post_body)),
                            self.headers)
     volume = xml_to_json(etree.fromstring(body))
     return resp, volume
Esempio n. 40
0
 def create_port(self, net_uuid, **kwargs):
     uri = '%s/ports' % (self.uri_prefix)
     port = Element("port")
     p1 = Element('network_id', net_uuid)
     port.append(p1)
     for key, val in kwargs.items():
         key = Element(key, val)
         port.append(key)
     resp, body = self.post(uri, str(Document(port)), self.headers)
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body
Esempio n. 41
0
 def serialize(self, body):
     #TODO(enikanorov): implement better json to xml conversion
     # expecting the dict with single key
     root = body.keys()[0]
     post_body = Element(root)
     post_body.add_attr('xmlns:xsi',
                        'http://www.w3.org/2001/XMLSchema-instance')
     for name, attr in body[root].items():
         elt = self._get_element(name, attr)
         post_body.append(elt)
     return str(Document(post_body))
Esempio n. 42
0
 def reserve_fixed_ip(self, ip, body):
     """This reserves and unreserves fixed ips."""
     url = "os-fixed-ips/%s/action" % (ip)
     # NOTE(maurosr): First converts the dict body to a json string then
     # accept any action key value here to permit tests to cover cases with
     # invalid actions raising badrequest.
     key, value = body.popitem()
     xml_body = Element(key)
     xml_body.append(Text(value))
     resp, body = self.post(url, str(Document(xml_body)), self.headers)
     return resp, body
Esempio n. 43
0
 def update_snapshot_status(self, snapshot_id, status, progress):
     """Update the specified snapshot's status."""
     post_body = Element("os-update_snapshot_status",
                         status=status,
                         progress=progress
                         )
     url = 'snapshots/%s/action' % str(snapshot_id)
     resp, body = self.post(url, str(Document(post_body)))
     if body:
         body = xml_to_json(etree.fromstring(body))
     return resp, body
Esempio n. 44
0
    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))
Esempio n. 45
0
    def live_migrate_server(self, server_id, dest_host, use_block_migration):
        """This should be called with administrator privileges ."""

        req_body = Element("os-migrateLive",
                           xmlns=XMLNS_11,
                           disk_over_commit=False,
                           block_migration=use_block_migration,
                           host=dest_host)

        resp, body = self.post("servers/%s/action" % str(server_id),
                               str(Document(req_body)), self.headers)
        return resp, body
Esempio n. 46
0
    def create_keypair(self, name, pub_key=None):
        doc = Document()

        keypair_element = Element("keypair")

        if pub_key:
            public_key_element = Element("public_key")
            public_key_text = Text(pub_key)
            public_key_element.append(public_key_text)
            keypair_element.append(public_key_element)

        name_element = Element("name")
        name_text = Text(name)
        name_element.append(name_text)
        keypair_element.append(name_element)

        doc.append(keypair_element)

        resp, body = self.post("os-keypairs", body=str(doc))
        body = xml_to_json(etree.fromstring(body))
        return resp, body