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

 def _get_element(self, name, value):
     if value is None:
         xml_elem = Element(name)
         xml_elem.add_attr("xsi:nil", "true")
         return xml_elem
     else:
         return Element(name, value)

 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/flavor-extra-specs" % flavor_id, str(Document(extra_specs)), self.headers)
     body = xml_to_json(etree.fromstring(body))
     return resp, body

 def update_subnet(self, subnet_id, name):
     uri = '%s/subnets/%s' % (self.uri_prefix, str(subnet_id))
     subnet = Element("subnet")
     p2 = Element("name", name)
     subnet.append(p2)
     resp, body = self.put(uri, str(Document(subnet)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body

 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))

 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)), self.headers)
     body = xml_to_json(etree.fromstring(body))
     return resp, body

 def create_security_group(self, name):
     uri = '%s/security-groups' % (self.uri_prefix)
     post_body = Element("security_group")
     p2 = Element("name", name)
     post_body.append(p2)
     resp, body = self.post(uri, str(Document(post_body)))
     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)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body

 def update_health_monitor(self, admin_state_up, uuid):
     uri = '%s/lb/health_monitors/%s' % (self.uri_prefix, str(uuid))
     put_body = Element("health_monitor")
     p2 = Element("admin_state_up", admin_state_up)
     put_body.append(p2)
     resp, body = self.put(uri, str(Document(put_body)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body

 def create_network(self, name):
     uri = '%s/networks' % (self.uri_prefix)
     post_body = Element("network")
     p2 = Element("name", name)
     post_body.append(p2)
     resp, body = self.post(uri, str(Document(post_body)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body

 def update_pool(self, pool_id, new_name):
     uri = '%s/lb/pools/%s' % (self.uri_prefix, str(pool_id))
     put_body = Element("pool")
     p2 = Element("name", new_name)
     put_body.append(p2)
     resp, body = self.put(uri, str(Document(put_body)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body

 def update_member(self, admin_state_up, member_id):
     uri = '%s/lb/members/%s' % (self.uri_prefix, str(member_id))
     put_body = Element("member")
     p2 = Element("admin_state_up", admin_state_up)
     put_body.append(p2)
     resp, body = self.put(uri, str(Document(put_body)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body

 def update_vip(self, vip_id, new_name):
     uri = '%s/lb/vips/%s' % (self.uri_prefix, str(vip_id))
     put_body = Element("vip")
     p2 = Element("name", new_name)
     put_body.append(p2)
     resp, body = self.put(uri, str(Document(put_body)), self.headers)
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body

 def update_port(self, port_id, name):
     uri = '%s/ports/%s' % (self.uri_prefix, str(port_id))
     port = Element("port")
     p2 = Element("name", name)
     port.append(p2)
     resp, body = self.put(uri, str(Document(port)))
     body = _root_tag_fetcher_and_xml_to_json_parse(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)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body

 def update_network(self, net_id, name):
     uri = '%s/networks/%s' % (self.uri_prefix, str(net_id))
     network = Element("network")
     p2 = Element("name", name)
     network.append(p2)
     resp, body = self.put(uri, str(Document(network)))
     body = _root_tag_fetcher_and_xml_to_json_parse(body)
     return resp, body

 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)
     for name, attr in body[root].items():
         elt = Element(name, attr)
         post_body.append(elt)
     return str(Document(post_body))

 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

 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

 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