text: # Copyright 2010 Jacob Kaplan-Moss
  # Copyright 2011 OpenStack Foundation
  # Copyright 2011 Piston Cloud Computing, Inc.
  # Copyright 2015 Mirantis Inc.
  #
  # Licensed under the Apache License, Version 2.0 (the "License");
  # you may not use this file except in compliance with the License.
  # You may obtain a copy of the License at
  #
  #    http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the License is distributed on an "AS IS" BASIS,
  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  # implied.
  # See the License for the specific language governing permissions and
  # limitations under the License.
  
  import copy
  import logging
  
  from oslo_serialization import jsonutils
  from oslo_utils import strutils
  import re
  import requests
  import six
  from six.moves.urllib import parse
  
  from manilaclient import exceptions
  
  try:
      from eventlet import sleep
  except ImportError:
      from time import sleep  # noqa
  
  
  class HTTPClient(object):
      """HTTP Client class used by multiple clients.
  
      The imported Requests module caches and reuses objects with the same
      destination. To avoid the problem of sending duplicate requests it is
      necessary that the Requests module is only imported once during client
      execution. This class is shared by multiple client versions so that the
      client can be changed to another version during execution.
      """
      API_VERSION_HEADER = "X-Openstack-Manila-Api-Version"
  
      def __init__(self, endpoint_url, token, user_agent, api_version,
                   insecure=False, cacert=None, timeout=None, retries=None,
                   http_log_debug=False):
          self.endpoint_url = endpoint_url
          self.base_url = self._get_base_url(self.endpoint_url)
          self.retries = int(retries or 0)
          self.http_log_debug = http_log_debug
  
          self.request_options = self._set_request_options(
              insecure, cacert, timeout)
  
          self.default_headers = {
              'X-Auth-Token': token,
              self.API_VERSION_HEADER: api_version.get_string(),
              'User-Agent': user_agent,
              'Accept': 'application/json',
          }
  
          self._add_log_handlers(http_log_debug)
  
      def _add_log_handlers(self, http_log_debug):
          self._logger = logging.getLogger(__name__)
  
          # check that handler hasn't already been added
          if http_log_debug and not self._logger.handlers:
              ch = logging.StreamHandler()
              ch._name = 'http_client_handler'
              self._logger.setLevel(logging.DEBUG)
              self._logger.addHandler(ch)
  
              if hasattr(requests, 'logging'):
                  rql = requests.logging.getLogger(requests.__name__)
                  rql.addHandler(ch)
  
      def _get_base_url(self, url):
          """Truncates url and returns base endpoint"""
          service_endpoint = parse.urlparse(url)
          service_endpoint_base_path = re.search(
              r'(.+?)/v([0-9]+|[0-9]+\.[0-9]+)(/.*|$)', service_endpoint.path)
          base_path = (service_endpoint_base_path.group(1)
                       if service_endpoint_base_path else '')
          base_url = service_endpoint._replace(path=base_path)
          return parse.urlunparse(base_url) + '/'
  
      def _set_request_options(self, insecure, cacert, timeout=None):
          options = {'verify': True}
  
          if insecure:
              options['verify'] = False
          elif cacert:
              options['verify'] = cacert
  
          if timeout:
              options['timeout'] = timeout
  
          return options
  
      def request(self, url, method, **kwargs):
          headers = copy.deepcopy(self.default_headers)
          headers.update(kwargs.get('headers', {}))
  
          options = copy.deepcopy(self.request_options)
  
          if 'body' in kwargs:
              headers['Content-Type'] = 'application/json'
              options['data'] = jsonutils.dumps(kwargs['body'])
  
          self.log_request(method, url, headers, options.get('data', None))
          resp = requests.request(method, url, headers=headers, **options)
          self.log_response(resp)
  
          body = None
  
          if resp.text:
              try:
                  body = jsonutils.loads(resp.text)
              except ValueError:
                  pass
  
          if resp.status_code >= 400:
              raise exceptions.from_response(resp, method, url)
  
          return resp, body
  
      def _cs_request(self, url, method, **kwargs):
          return self._cs_request_with_retries(
              self.endpoint_url + url,
              method,
              **kwargs)
  
      def _cs_request_base_url(self, url, method, **kwargs):
          return self._cs_request_with_retries(
              self.base_url + url,
              method,
              **kwargs)
  
      def _cs_request_with_retries(self, url, method, **kwargs):
          attempts = 0
          timeout = 1
          while True:
              attempts += 1
              try:
                  resp, body = self.request(url, method, **kwargs)
                  return resp, body
              except (exceptions.BadRequest,
                      requests.exceptions.RequestException,
                      exceptions.ClientException) as e:
                  if attempts > self.retries:
                      raise
  
                  self._logger.debug("Request error: %s", six.text_type(e))
  
              self._logger.debug(
                  "Failed attempt(%(current)s of %(total)s), "
                  " retrying in %(sec)s seconds", {
                      'current': attempts,
                      'total': self.retries,
                      'sec': timeout
                  })
              sleep(timeout)
              timeout *= 2
  
      def get_with_base_url(self, url, **kwargs):
          return self._cs_request_base_url(url, 'GET', **kwargs)
  
      def get(self, url, **kwargs):
          return self._cs_request(url, 'GET', **kwargs)
  
      def post(self, url, **kwargs):
          return self._cs_request(url, 'POST', **kwargs)
  
      def put(self, url, **kwargs):
          return self._cs_request(url, 'PUT', **kwargs)
  
      def delete(self, url, **kwargs):
          return self._cs_request(url, 'DELETE', **kwargs)
  
      def log_request(self, method, url, headers, data=None):
          if not self.http_log_debug:
              return
  
          string_parts = ['curl -i', ' -X %s' % method, ' %s' % url]
  
          for element in headers:
              header = ' -H "%s: %s"' % (element, headers[element])
              string_parts.append(header)
  
          if data:
              if "password" in data:
                  data = strutils.mask_password(data)
              string_parts.append(" -d '%s'" % data)
          self._logger.debug("\nREQ: %s\n", "".join(string_parts))
  
      def log_response(self, resp):
          if not self.http_log_debug:
              return
          self._logger.debug(
              "RESP: [%(code)s] %(headers)s\nRESP BODY: %(body)s\n", {
                  'code': resp.status_code,
                  'headers': resp.headers,
                  'body': resp.text
              })
  