def update_project(self, project_id, **kwargs): """Updates a Project.""" resp, body = self.get_project(project_id) name = kwargs.get('name', body['name']) desc = kwargs.get('description', body['description']) en = kwargs.get('enabled', body['enabled']) domain_id = kwargs.get('domain_id', body['domain_id']) post_body = common.Element("project", xmlns=XMLNS, name=name, description=desc, enabled=str(en).lower(), domain_id=domain_id) resp, body = self.patch('projects/%s' % project_id, str(common.Document(post_body))) self.expected_success(200, resp.status) body = self._parse_body(etree.fromstring(body)) return resp, body
def update_quota_set(self, tenant_id, gigabytes=None, volumes=None, snapshots=None): post_body = {} element = xml.Element("quota_set") if gigabytes is not None: post_body['gigabytes'] = gigabytes if volumes is not None: post_body['volumes'] = volumes if snapshots is not None: post_body['snapshots'] = snapshots xml.deep_dict_to_xml(element, post_body) resp, body = self.put('os-quota-sets/%s' % tenant_id, str(xml.Document(element))) body = xml.xml_to_json(etree.fromstring(body)) return resp, self._format_quota(body)
def create_user(self, user_name, **kwargs): """Creates a user.""" password = kwargs.get('password', None) email = kwargs.get('email', None) en = kwargs.get('enabled', 'true') project_id = kwargs.get('project_id', None) description = kwargs.get('description', None) domain_id = kwargs.get('domain_id', 'default') post_body = common.Element("user", xmlns=XMLNS, name=user_name, password=password, description=description, email=email, enabled=str(en).lower(), project_id=project_id, domain_id=domain_id) resp, body = self.post('users', str(common.Document(post_body))) body = self._parse_body(etree.fromstring(body)) return resp, body
def update_user(self, user_id, name, **kwargs): """Updates a user.""" resp, body = self.get_user(user_id) email = kwargs.get('email', body['email']) en = kwargs.get('enabled', body['enabled']) project_id = kwargs.get('project_id', body['project_id']) description = kwargs.get('description', body['description']) domain_id = kwargs.get('domain_id', body['domain_id']) update_user = common.Element("user", xmlns=XMLNS, name=name, email=email, project_id=project_id, domain_id=domain_id, description=description, enabled=str(en).lower()) resp, body = self.patch('users/%s' % user_id, str(common.Document(update_user))) body = self._parse_body(etree.fromstring(body)) return resp, body
def create_user(self, user_name, password=None, project_id=None, email=None, domain_id='default', **kwargs): """Creates a user.""" en = kwargs.get('enabled', 'true') description = kwargs.get('description', None) post_body = common.Element("user", xmlns=XMLNS, name=user_name, password=password, description=description, email=email, enabled=str(en).lower(), project_id=project_id, domain_id=domain_id) resp, body = self.post('users', str(common.Document(post_body))) self.expected_success(201, resp.status) body = self._parse_body(etree.fromstring(body)) return resp, body
def update_endpoint(self, endpoint_id, service_id=None, interface=None, url=None, region=None, enabled=None, **kwargs): """Updates an endpoint with given parameters. Normally this function wouldn't allow setting values that are not allowed for 'enabled'. Use `force_enabled` to set a non-boolean. """ doc = common.Document() endpoint = common.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 'force_enabled' in kwargs: endpoint.add_attr("enabled", kwargs['force_enabled']) elif enabled is not None: endpoint.add_attr("enabled", str(enabled).lower()) resp, body = self.patch('endpoints/%s' % str(endpoint_id), str(doc)) self.expected_success(200, resp.status) body = self._parse_body(etree.fromstring(body)) return resp, body
def test_parse_resp_body_item(self): body_item = xml.Element("item", **self.item_expected) body = self.rest_client._parse_resp(str(xml.Document(body_item))) self.assertEqual(self.item_expected, body)
def create_server(self, name, image_ref, flavor_ref, **kwargs): """ Creates an instance of a server. name (Required): The name of the server. image_ref (Required): Reference to the image used to build the server. flavor_ref (Required): The flavor used to build the server. Following optional keyword arguments are accepted: adminPass: Sets the initial root password. key_name: Key name of keypair that was created earlier. meta: A dictionary of values to be used as metadata. personality: A list of dictionaries for files to be injected into the server. security_groups: A list of security group dicts. networks: A list of network dicts with UUID and fixed_ip. user_data: User data for instance. availability_zone: Availability zone in which to launch instance. accessIPv4: The IPv4 access address for the server. accessIPv6: The IPv6 access address for the server. min_count: Count of minimum number of instances to launch. max_count: Count of maximum number of instances to launch. disk_config: Determines if user or admin controls disk configuration. block_device_mapping: Block device mapping for the server. """ server = xml_utils.Element("server", xmlns=xml_utils.XMLNS_11, imageRef=image_ref, flavorRef=flavor_ref, name=name) for attr in [ "adminPass", "accessIPv4", "accessIPv6", "key_name", "user_data", "availability_zone", "min_count", "max_count", "return_reservation_id", "block_device_mapping" ]: if attr in kwargs: server.add_attr(attr, kwargs[attr]) if 'disk_config' in kwargs: server.add_attr( 'xmlns:OS-DCF', "http://docs.openstack.org/" "compute/ext/disk_config/api/v1.1") server.add_attr('OS-DCF:diskConfig', kwargs['disk_config']) if 'security_groups' in kwargs: secgroups = xml_utils.Element("security_groups") server.append(secgroups) for secgroup in kwargs['security_groups']: s = xml_utils.Element("security_group", name=secgroup['name']) secgroups.append(s) if 'networks' in kwargs: networks = xml_utils.Element("networks") server.append(networks) for network in kwargs['networks']: s = xml_utils.Element("network", uuid=network['uuid'], fixed_ip=network['fixed_ip']) networks.append(s) if 'meta' in kwargs: metadata = xml_utils.Element("metadata") server.append(metadata) for k, v in kwargs['meta'].items(): meta = xml_utils.Element("meta", key=k) meta.append(xml_utils.Text(v)) metadata.append(meta) if 'personality' in kwargs: personality = xml_utils.Element('personality') server.append(personality) for k in kwargs['personality']: temp = xml_utils.Element('file', path=k['path']) temp.append(xml_utils.Text(k['contents'])) personality.append(temp) if 'sched_hints' in kwargs: sched_hints = kwargs.get('sched_hints') hints = xml_utils.Element("os:scheduler_hints") hints.add_attr('xmlns:os', xml_utils.XMLNS_11) for attr in sched_hints: p1 = xml_utils.Element(attr) p1.append(sched_hints[attr]) hints.append(p1) server.append(hints) resp, body = self.post('servers', str(xml_utils.Document(server))) server = self._parse_server(etree.fromstring(body)) return resp, server
def auth(self, user=None, password=None, tenant=None, user_type='id', domain=None, token=None): """ :param user: user id or name, as specified in user_type :param domain: the user and tenant domain :param token: a token to re-scope. Accepts different combinations of credentials. Restrictions: - tenant and domain are only name (no id) - user domain and tenant domain are assumed identical - domain scope is not supported here Sample sample valid combinations: - token - token, tenant, domain - user_id, password - username, password, domain - username, password, tenant, domain Validation is left to the server side. """ methods = common.Element('methods') identity = common.Element('identity') if token: method = common.Element('method') method.append(common.Text('token')) methods.append(method) token = common.Element('token', id=token) identity.append(token) if user and password: if user_type == 'id': _user = common.Element('user', id=user, password=password) else: _user = common.Element('user', name=user, password=password) if domain is not None: _domain = common.Element('domain', name=domain) _user.append(_domain) password = common.Element('password') password.append(_user) method = common.Element('method') method.append(common.Text('password')) methods.append(method) identity.append(password) identity.append(methods) auth = common.Element('auth') auth.append(identity) if tenant is not None: project = common.Element('project', name=tenant) _domain = common.Element('domain', name=domain) project.append(_domain) scope = common.Element('scope') scope.append(project) auth.append(scope) resp, body = self.post(self.auth_url, body=str(common.Document(auth))) return resp, body
def add_dhcp_agent_to_network(self, agent_id, network_id): uri = '%s/agents/%s/dhcp-networks' % (self.uri_prefix, agent_id) network = common.Element("network_id", network_id) resp, body = self.post(uri, str(common.Document(network))) body = _root_tag_fetcher_and_xml_to_json_parse(body) return resp, body
def add_router_to_l3_agent(self, agent_id, router_id): uri = '%s/agents/%s/l3-routers' % (self.uri_prefix, agent_id) router = (common.Element("router_id", router_id)) resp, body = self.post(uri, str(common.Document(router))) body = _root_tag_fetcher_and_xml_to_json_parse(body) return resp, body
def create_role(self, name): """Create a Role.""" post_body = common.Element("role", xmlns=XMLNS, name=name) resp, body = self.post('roles', str(common.Document(post_body))) body = self._parse_body(etree.fromstring(body)) return resp, body
def create_role(self, name): """Create a role.""" create_role = xml.Element("role", xmlns=XMLNS, name=name) resp, body = self.post('OS-KSADM/roles', str(xml.Document(create_role))) return resp, self._parse_resp(body)
def enable_disable_user(self, user_id, enabled): """Enables or disables a user.""" enable_user = xml.Element("user", enabled=str(enabled).lower()) resp, body = self.put('users/%s/enabled' % user_id, str(xml.Document(enable_user))) return resp, self._parse_resp(body)
def update_user_password(self, user_id, new_pass): """Update User Password.""" put_body = xml.Element("user", id=user_id, password=new_pass) resp, body = self.put('users/%s/OS-KSADM/password' % user_id, str(xml.Document(put_body))) return resp, self._parse_resp(body)
def update_quota_set(self, tenant_id, user_id=None, 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 = xml_utils.Element("quota_set", xmlns=xml_utils.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) if user_id: resp, body = self.put( 'os-quota-sets/%s?user_id=%s' % (str(tenant_id), str(user_id)), str(xml_utils.Document(post_body))) else: resp, body = self.put('os-quota-sets/%s' % str(tenant_id), str(xml_utils.Document(post_body))) body = xml_utils.xml_to_json(etree.fromstring(body)) body = format_quota(body) return resp, body