text: # Copyright 2011 OpenStack Foundation
  # All Rights Reserved.
  #
  #    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.
  """Wsgi helper utilities for trove"""
  
  import eventlet.wsgi
  import math
  import jsonschema
  import paste.urlmap
  import re
  import time
  import traceback
  import uuid
  import webob
  import webob.dec
  import webob.exc
  from lxml import etree
  from xml.dom import minidom
  
  from trove.common import context as rd_context
  from trove.common import exception
  from trove.common import utils
  from trove.openstack.common.gettextutils import _
  from trove.openstack.common import jsonutils
  
  from trove.openstack.common import pastedeploy
  from trove.openstack.common import service
  from trove.openstack.common import wsgi as openstack_wsgi
  from trove.openstack.common import log as logging
  from trove.common import cfg
  
  CONTEXT_KEY = 'trove.context'
  Router = openstack_wsgi.Router
  Debug = openstack_wsgi.Debug
  Middleware = openstack_wsgi.Middleware
  JSONDictSerializer = openstack_wsgi.JSONDictSerializer
  XMLDictSerializer = openstack_wsgi.XMLDictSerializer
  XMLDeserializer = openstack_wsgi.XMLDeserializer
  RequestDeserializer = openstack_wsgi.RequestDeserializer
  
  eventlet.patcher.monkey_patch(all=False, socket=True)
  
  LOG = logging.getLogger('trove.common.wsgi')
  
  CONF = cfg.CONF
  
  XMLNS = 'http://docs.openstack.org/database/api/v1.0'
  CUSTOM_PLURALS_METADATA = {'databases': '', 'users': ''}
  CUSTOM_SERIALIZER_METADATA = {
      'instance': {
          'status': '',
          'hostname': '',
          'id': '',
          'name': '',
          'created': '',
          'updated': '',
          'host': '',
          'server_id': '',
          #mgmt/instance
          'local_id': '',
          'task_description': '',
          'deleted': '',
          'deleted_at': '',
          'tenant_id': '',
      },
      'volume': {
          'size': '',
          'used': '',
          #mgmt/instance
          'id': '',
      },
      'configuration': {
          'id': '',
          'name': '',
          'description': '',
          'datastore_version_id': ''
      },
      'flavor': {'id': '', 'ram': '', 'name': ''},
      'link': {'href': '', 'rel': ''},
      'database': {'name': ''},
      'user': {'name': '', 'password': '', 'host': ''},
      'account': {'id': ''},
      'security_group': {'id': '', 'name': '', 'description': '', 'user': '',
                         'tenant_id': ''},
      'security_group_rule': {'id': '', 'group_id': '', 'protocol': '',
                              'from_port': '', 'to_port': '', 'cidr': ''},
      'security_group_instance_association': {'id': '', 'security_group_id': '',
                                              'instance_id': ''},
      # mgmt/host
      'host': {'instanceCount': '', 'name': '', 'usedRAM': '', 'totalRAM': '',
               'percentUsed': ''},
      # mgmt/storage
      'capacity': {'available': '', 'total': ''},
      'provision': {'available': '', 'total': '', 'percent': ''},
      'device': {'used': '', 'name': '', 'type': ''},
      # mgmt/account
      'account': {'id': '', 'num_instances': ''},
      # mgmt/quotas
      'quotas': {'instances': '', 'volumes': '', 'backups': ''},
      #mgmt/instance
      'guest_status': {'state_description': ''},
      #mgmt/instance/diagnostics
      'diagnostics': {'vmHwm': '', 'vmPeak': '', 'vmSize': '', 'threads': '',
                      'version': '', 'vmRss': '', 'fdSize': ''},
      #mgmt/instance/root
      'root_history': {'enabled': '', 'id': '', 'user': ''},
  
  }
  
  
  def versioned_urlmap(*args, **kwargs):
      urlmap = paste.urlmap.urlmap_factory(*args, **kwargs)
      return VersionedURLMap(urlmap)
  
  
  def launch(app_name, port, paste_config_file, data={},
             host='0.0.0.0', backlog=128, threads=1000, workers=None):
      """Launches a wsgi server based on the passed in paste_config_file.
  
        Launch provides a easy way to create a paste app from the config
        file and launch it via the service launcher. It takes care of
        all of the plumbing. The only caveat is that the paste_config_file
        must be a file that paste.deploy can find and handle. There is
        a helper method in cfg.py that finds files.
  
        Example:
          conf_file = CONF.find_file(CONF.api_paste_config)
          launcher = wsgi.launch('myapp', CONF.bind_port, conf_file)
          launcher.wait()
  
      """
      app = pastedeploy.paste_deploy_app(paste_config_file, app_name, data)
      server = openstack_wsgi.Service(app, port, host=host,
                                      backlog=backlog, threads=threads)
      return service.launch(server, workers)
  
  
  # Note: taken from Nova
  def serializers(**serializers):
      """Attaches serializers to a method.
  
      This decorator associates a dictionary of serializers with a
      method.  Note that the function attributes are directly
      manipulated; the method is not wrapped.
      """
  
      def decorator(func):
          if not hasattr(func, 'wsgi_serializers'):
              func.wsgi_serializers = {}
          func.wsgi_serializers.update(serializers)
          return func
  
      return decorator
  
  
  class TroveMiddleware(Middleware):
      # Note: taken from nova
      @classmethod
      def factory(cls, global_config, **local_config):
          """Used for paste app factories in paste.deploy config files.
  
          Any local configuration (that is, values under the [filter:APPNAME]
          section of the paste config) will be passed into the `__init__` method
          as kwargs.
  
          A hypothetical configuration would look like:
  
              [filter:analytics]
              redis_host = 127.0.0.1
              paste.filter_factory = nova.api.analytics:Analytics.factory
  
          which would result in a call to the `Analytics` class as
  
              import nova.api.analytics
              analytics.Analytics(app_from_paste, redis_host='127.0.0.1')
  
          You could of course re-implement the `factory` method in subclasses,
          but using the kwarg passing it shouldn't be necessary.
  
          """
  
          def _factory(app):
              return cls(app, **local_config)
  
          return _factory
  
  
  class VersionedURLMap(object):
      def __init__(self, urlmap):
          self.urlmap = urlmap
  
      def __call__(self, environ, start_response):
          req = Request(environ)
  
          if req.url_version is None and req.accept_version is not None:
              version = "/v" + req.accept_version
              http_exc = webob.exc.HTTPNotAcceptable(_("version not supported"))
              app = self.urlmap.get(version, Fault(http_exc))
          else:
              app = self.urlmap
          return app(environ, start_response)
  
  
  class Router(openstack_wsgi.Router):
      # Original router did not allow for serialization of the 404 error.
      # To fix this the _dispatch was modified to use Fault() objects.
      @staticmethod
      @webob.dec.wsgify
      def _dispatch(req):
          """
          Called by self._router after matching the incoming request to a route
          and putting the information into req.environ.  Either returns 404
          or the routed WSGI app's response.
          """
  
          match = req.environ['wsgiorg.routing_args'][1]
          if not match:
              return Fault(webob.exc.HTTPNotFound())
          app = match['controller']
          return app
  
  
  class Request(openstack_wsgi.Request):
      @property
      def params(self):
          return utils.stringify_keys(super(Request, self).params)
  
      def best_match_content_type(self, supported_content_types=None):
          """Determine the most acceptable content-type.
  
          Based on the query extension then the Accept header.
  
          """
          parts = self.path.rsplit('.', 1)
  
          if len(parts) > 1:
              format = parts[1]
              if format in ['json', 'xml']:
                  return 'application/{0}'.format(parts[1])
  
          ctypes = {
              'application/vnd.openstack.trove+json': "application/json",
              'application/vnd.openstack.trove+xml': "application/xml",
              'application/json': "application/json",
              'application/xml': "application/xml",
          }
          bm = self.accept.best_match(ctypes.keys())
  
          return ctypes.get(bm, 'application/json')
  
      @utils.cached_property
      def accept_version(self):
          accept_header = self.headers.get('ACCEPT', "")
          accept_version_re = re.compile(".*?application/vnd.openstack.trove"
                                         "(\+.+?)?;"
                                         "version=(?P<version_no>\d+\.?\d*)")
  
          match = accept_version_re.search(accept_header)
          return match.group("version_no") if match else None
  
      @utils.cached_property
      def url_version(self):
          versioned_url_re = re.compile("/v(?P<version_no>\d+\.?\d*)")
          match = versioned_url_re.search(self.path)
          return match.group("version_no") if match else None
  
  
  class Result(object):
      """A result whose serialization is compatible with JSON and XML.
  
      This class is used by TroveResponseSerializer, which calls the
      data method to grab a JSON or XML specific dictionary which it then
      passes on to be serialized.
  
      """
  
      def __init__(self, data, status=200):
          self._data = data
          self.status = status
  
      def data(self, serialization_type):
          """Return an appropriate serialized type for the body.
  
          In both cases a dictionary is returned. With JSON it maps directly,
          while with XML the dictionary is expected to have a single key value
          which becomes the root element.
  
          """
          if (serialization_type == "application/xml" and
                  hasattr(self._data, "data_for_xml")):
              return self._data.data_for_xml()
          if hasattr(self._data, "data_for_json"):
              return self._data.data_for_json()
          return self._data
  
  
  class Resource(openstack_wsgi.Resource):
      def __init__(self, controller, deserializer, serializer,
                   exception_map=None):
          exception_map = exception_map or {}
          self.model_exception_map = self._invert_dict_list(exception_map)
          super(Resource, self).__init__(controller, deserializer, serializer)
  
      @webob.dec.wsgify(RequestClass=Request)
      def __call__(self, request):
          return super(Resource, self).__call__(request)
  
      def execute_action(self, action, request, **action_args):
          if getattr(self.controller, action, None) is None:
              return Fault(webob.exc.HTTPNotFound())
          try:
              self.controller.validate_request(action, action_args)
              result = super(Resource, self).execute_action(
                  action,
                  request,
                  **action_args)
              if type(result) is dict:
                  result = Result(result)
              return result
  
          except exception.TroveError as trove_error:
              LOG.debug(traceback.format_exc())
              LOG.debug("Caught Trove Error %s", trove_error)
              httpError = self._get_http_error(trove_error)
              LOG.debug("Mapped Error to %s", httpError)
              return Fault(httpError(str(trove_error), request=request))
          except webob.exc.HTTPError as http_error:
              LOG.debug(traceback.format_exc())
              return Fault(http_error)
          except Exception as error:
              exception_uuid = str(uuid.uuid4())
              LOG.exception(exception_uuid + ": " + str(error))
              return Fault(webob.exc.HTTPInternalServerError(
                  "Internal Server Error. Please keep this ID to help us "
                  "figure out what went wrong: (%s)" % exception_uuid,
                  request=request))
  
      def _get_http_error(self, error):
          return self.model_exception_map.get(type(error),
                                              webob.exc.HTTPBadRequest)
  
      def _invert_dict_list(self, exception_dict):
          """Flattens values of keys and inverts keys and values.
  
          Example:
          {'x': [1, 2, 3], 'y': [4, 5, 6]} converted to
          {1: 'x', 2: 'x', 3: 'x', 4: 'y', 5: 'y', 6: 'y'}
  
          """
          inverted_dict = {}
          for key, value_list in exception_dict.items():
              for value in value_list:
                  inverted_dict[value] = key
          return inverted_dict
  
      def serialize_response(self, action, action_result, accept):
          # If an exception is raised here in the base class, it is swallowed,
          # and the action_result is returned as-is. For us, that's bad news -
          # we never want that to happen except in the case of webob types.
          # So we override the behavior here so we can at least log it.
          try:
              return super(Resource, self).serialize_response(
                  action, action_result, accept)
          except Exception:
              # execute_action either returns the results or a Fault object.
              # If action_result is not a Fault then there really was a
              # serialization error which we log. Otherwise return the Fault.
              if not isinstance(action_result, Fault):
                  LOG.exception("unserializable result detected.")
                  raise
              return action_result
  
  
  class Controller(object):
      """Base controller that creates a Resource with default serializers."""
  
      exception_map = {
          webob.exc.HTTPUnprocessableEntity: [
              exception.UnprocessableEntity,
          ],
          webob.exc.HTTPUnauthorized: [
              exception.Forbidden,
              exception.SwiftAuthError,
          ],
          webob.exc.HTTPBadRequest: [
              exception.InvalidModelError,
              exception.BadRequest,
              exception.CannotResizeToSameSize,
              exception.BadValue,
              exception.DatabaseAlreadyExists,
              exception.UserAlreadyExists,
              exception.LocalStorageNotSpecified,
          ],
          webob.exc.HTTPNotFound: [
              exception.NotFound,
              exception.ComputeInstanceNotFound,
              exception.ModelNotFoundError,
              exception.UserNotFound,
              exception.DatabaseNotFound,
              exception.QuotaResourceUnknown,
              exception.BackupFileNotFound
          ],
          webob.exc.HTTPConflict: [
              exception.BackupNotCompleteError,
              exception.RestoreBackupIntegrityError,
          ],
          webob.exc.HTTPRequestEntityTooLarge: [
              exception.OverLimit,
              exception.QuotaExceeded,
              exception.VolumeQuotaExceeded,
          ],
          webob.exc.HTTPServerError: [
              exception.VolumeCreationFailure,
              exception.UpdateGuestError,
          ],
          webob.exc.HTTPNotImplemented: [
              exception.VolumeNotSupported,
              exception.LocalStorageNotSupported
          ],
      }
  
      schemas = {}
  
      @classmethod
      def get_schema(cls, action, body):
          LOG.debug("Getting schema for %s:%s" %
                    (cls.__class__.__name__, action))
          if cls.schemas:
              matching_schema = cls.schemas.get(action, {})
              if matching_schema:
                  LOG.debug("Found Schema: %s" % matching_schema.get("name",
                                                                     "none"))
              return matching_schema
  
      @staticmethod
      def format_validation_msg(errors):
          # format path like object['field1'][i]['subfield2']
          messages = []
          for error in errors:
              path = list(error.path)
              f_path = "%s%s" % (path[0],
                                 ''.join(['[%r]' % i for i in path[1:]]))
              messages.append("%s %s" % (f_path, error.message))
              for suberror in sorted(error.context, key=lambda e: e.schema_path):
                  messages.append(suberror.message)
          error_msg = "; ".join(messages)
          return "Validation error: %s" % error_msg
  
      def validate_request(self, action, action_args):
          body = action_args.get('body', {})
          schema = self.get_schema(action, body)
          if schema:
              validator = jsonschema.Draft4Validator(schema)
              if not validator.is_valid(body):
                  errors = sorted(validator.iter_errors(body),
                                  key=lambda e: e.path)
                  error_msg = self.format_validation_msg(errors)
                  LOG.info(error_msg)
                  raise exception.BadRequest(message=error_msg)
  
      def create_resource(self):
          serializer = TroveResponseSerializer(
              body_serializers={'application/xml': TroveXMLDictSerializer()})
          return Resource(
              self,
              TroveRequestDeserializer(),
              serializer,
              self.exception_map)
  
      def _extract_limits(self, params):
          return dict([(key, params[key]) for key in params.keys()
                       if key in ["limit", "marker"]])
  
  
  class TroveRequestDeserializer(RequestDeserializer):
      """Break up a Request object into more useful pieces."""
  
      def __init__(self, body_deserializers=None, headers_deserializer=None,
                   supported_content_types=None):
          super(TroveRequestDeserializer, self).__init__(
              body_deserializers,
              headers_deserializer,
              supported_content_types)
  
          self.body_deserializers['application/xml'] = TroveXMLDeserializer()
  
  
  class TroveXMLDeserializer(XMLDeserializer):
      def __init__(self, metadata=None):
          """
          :param metadata: information needed to deserialize xml into
                           a dictionary.
          """
          metadata = metadata or {}
          metadata['plurals'] = CUSTOM_PLURALS_METADATA
          super(TroveXMLDeserializer, self).__init__(metadata)
  
      def default(self, datastring):
          # Sanitize the newlines
          # hub-cap: This feels wrong but minidom keeps the newlines
          # and spaces as childNodes which is expected behavior.
          return {'body': self._from_xml(re.sub(r'((?<=>)\s+)*\n*(\s+(?=<))*',
                                                '', datastring))}
  
      def _from_xml_node(self, node, listnames):
          """Convert a minidom node to a simple Python type.
  
             Overridden from openstack deserializer to skip xmlns attributes and
             remove certain unicode characters
  
          :param listnames: list of XML node names whose subnodes should
                            be considered list items.
  
          """
  
          if len(node.childNodes) == 1 and node.childNodes[0].nodeType == 3:
              return node.childNodes[0].nodeValue
          elif node.nodeName in listnames:
              return [self._from_xml_node(n, listnames) for n in node.childNodes]
          else:
              result = dict()
              for attr in node.attributes.keys():
                  if attr == 'xmlns':
                      continue
                  result[attr] = node.attributes[attr].nodeValue
              for child in node.childNodes:
                  if child.nodeType != node.TEXT_NODE:
                      result[child.nodeName] = self._from_xml_node(child,
                                                                   listnames)
              return result
  
  
  class TroveXMLDictSerializer(openstack_wsgi.XMLDictSerializer):
      def __init__(self, metadata=None, xmlns=None):
          super(TroveXMLDictSerializer, self).__init__(metadata, XMLNS)
  
      def default(self, data):
          # We expect data to be a dictionary containing a single key as the XML
          # root, or two keys, the later being "links."
          # We expect data to contain a single key which is the XML root,
          has_links = False
          root_key = None
          for key in data:
              if key == "links":
                  has_links = True
              elif root_key is None:
                  root_key = key
              else:
                  msg = "Xml issue: multiple root keys found in dict!: %s" % data
                  LOG.error(msg)
                  raise RuntimeError(msg)
          if root_key is None:
              msg = "Missing root key in dict: %s" % data
              LOG.error(msg)
              raise RuntimeError(msg)
          doc = minidom.Document()
          node = self._to_xml_node(doc, self.metadata, root_key, data[root_key])
          if has_links:
              # Create a links element, and mix it into the node element.
              links_node = self._to_xml_node(doc, self.metadata,
                                             'links', data['links'])
              node.appendChild(links_node)
          return self.to_xml_string(node)
  
      def _to_xml_node(self, doc, metadata, nodename, data):
          metadata['attributes'] = CUSTOM_SERIALIZER_METADATA
          if hasattr(data, "to_xml"):
              return data.to_xml()
          return super(TroveXMLDictSerializer, self)._to_xml_node(
              doc,
              metadata,
              nodename,
              data)
  
  
  class TroveResponseSerializer(openstack_wsgi.ResponseSerializer):
      def serialize_body(self, response, data, content_type, action):
          """Overrides body serialization in openstack_wsgi.ResponseSerializer.
  
          If the "data" argument is the Result class, its data
          method is called and *that* is passed to the superclass implementation
          instead of the actual data.
  
          """
          if isinstance(data, Result):
              data = data.data(content_type)
          super(TroveResponseSerializer, self).serialize_body(
              response,
              data,
              content_type,
              action)
  
      def serialize_headers(self, response, data, action):
          super(TroveResponseSerializer, self).serialize_headers(
              response,
              data,
              action)
          if isinstance(data, Result):
              response.status = data.status
  
  
  class Fault(webob.exc.HTTPException):
      """Error codes for API faults."""
  
      code_wrapper = {
          400: webob.exc.HTTPBadRequest,
          401: webob.exc.HTTPUnauthorized,
          403: webob.exc.HTTPUnauthorized,
          404: webob.exc.HTTPNotFound,
      }
  
      resp_codes = [int(code) for code in code_wrapper.keys()]
  
      def __init__(self, exception):
          """Create a Fault for the given webob.exc.exception."""
  
          self.wrapped_exc = exception
  
      @staticmethod
      def _get_error_name(exc):
          # Displays a Red Dwarf specific error name instead of a webob exc name.
          named_exceptions = {
              'HTTPBadRequest': 'badRequest',
              'HTTPUnauthorized': 'unauthorized',
              'HTTPForbidden': 'forbidden',
              'HTTPNotFound': 'itemNotFound',
              'HTTPMethodNotAllowed': 'badMethod',
              'HTTPRequestEntityTooLarge': 'overLimit',
              'HTTPUnsupportedMediaType': 'badMediaType',
              'HTTPInternalServerError': 'instanceFault',
              'HTTPNotImplemented': 'notImplemented',
              'HTTPServiceUnavailable': 'serviceUnavailable',
          }
          name = exc.__class__.__name__
          if name in named_exceptions:
              return named_exceptions[name]
              # If the exception isn't in our list, at least strip off the
          # HTTP from the name, and then drop the case on the first letter.
          name = name.split("HTTP").pop()
          name = name[:1].lower() + name[1:]
          return name
  
      @webob.dec.wsgify(RequestClass=Request)
      def __call__(self, req):
          """Generate a WSGI response based on the exception passed to ctor."""
  
          # Replace the body with fault details.
          fault_name = Fault._get_error_name(self.wrapped_exc)
          fault_data = {
              fault_name: {
                  'code': self.wrapped_exc.status_int,
              }
          }
          if self.wrapped_exc.detail:
              fault_data[fault_name]['message'] = self.wrapped_exc.detail
          else:
              fault_data[fault_name]['message'] = self.wrapped_exc.explanation
  
          # 'code' is an attribute on the fault tag itself
          metadata = {'attributes': {fault_name: 'code'}}
          content_type = req.best_match_content_type()
          serializer = {
              'application/xml': openstack_wsgi.XMLDictSerializer(metadata),
              'application/json': openstack_wsgi.JSONDictSerializer(),
          }[content_type]
  
          self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
          self.wrapped_exc.content_type = content_type
          return self.wrapped_exc
  
  
  class ContextMiddleware(openstack_wsgi.Middleware):
      def __init__(self, application):
          self.admin_roles = CONF.admin_roles
          super(ContextMiddleware, self).__init__(application)
  
      def _extract_limits(self, params):
          return dict([(key, params[key]) for key in params.keys()
                       if key in ["limit", "marker"]])
  
      def process_request(self, request):
          tenant_id = request.headers.get('X-Tenant-Id', None)
          auth_token = request.headers["X-Auth-Token"]
          user_id = request.headers.get('X-User-ID', None)
          roles = request.headers.get('X-Role', '').split(',')
          is_admin = False
          for role in roles:
              if role.lower() in self.admin_roles:
                  is_admin = True
                  break
          limits = self._extract_limits(request.params)
          context = rd_context.TroveContext(auth_token=auth_token,
                                            tenant=tenant_id,
                                            user=user_id,
                                            is_admin=is_admin,
                                            limit=limits.get('limit'),
                                            marker=limits.get('marker'))
          request.environ[CONTEXT_KEY] = context
  
      @classmethod
      def factory(cls, global_config, **local_config):
          def _factory(app):
              LOG.debug(_("Created context middleware with config: %s") %
                        local_config)
              return cls(app)
  
          return _factory
  
  
  class FaultWrapper(openstack_wsgi.Middleware):
      """Calls down the middleware stack, making exceptions into faults."""
  
      @webob.dec.wsgify(RequestClass=openstack_wsgi.Request)
      def __call__(self, req):
          try:
              resp = req.get_response(self.application)
              if resp.status_int in Fault.resp_codes:
                  for (header, value) in resp._headerlist:
                      if header == "Content-Type" and \
                              value == "text/plain; charset=UTF-8":
                          return Fault(Fault.code_wrapper[resp.status_int]())
                  return resp
              return resp
          except Exception as ex:
              LOG.exception(_("Caught error: %s"), unicode(ex))
              exc = webob.exc.HTTPInternalServerError()
              return Fault(exc)
  
      @classmethod
      def factory(cls, global_config, **local_config):
          def _factory(app):
              return cls(app)
          return _factory
  
  
  # ported from Nova
  class OverLimitFault(webob.exc.HTTPException):
      """
      Rate-limited request response.
      """
  
      def __init__(self, message, details, retry_time):
          """
          Initialize new `OverLimitFault` with relevant information.
          """
          hdrs = OverLimitFault._retry_after(retry_time)
          self.wrapped_exc = webob.exc.HTTPRequestEntityTooLarge(headers=hdrs)
          self.content = {"overLimit": {"code": self.wrapped_exc.status_int,
                                        "message": message,
                                        "details": details,
                                        "retryAfter": hdrs['Retry-After'],
                                        },
                          }
  
      @staticmethod
      def _retry_after(retry_time):
          delay = int(math.ceil(retry_time - time.time()))
          retry_after = delay if delay > 0 else 0
          headers = {'Retry-After': '%d' % retry_after}
          return headers
  
      @webob.dec.wsgify(RequestClass=Request)
      def __call__(self, request):
          """
          Return the wrapped exception with a serialized body conforming to our
          error format.
          """
          content_type = request.best_match_content_type()
          metadata = {"attributes": {"overLimit": ["code", "retryAfter"]}}
  
          xml_serializer = XMLDictSerializer(metadata, XMLNS)
          serializer = {'application/xml': xml_serializer,
                        'application/json': JSONDictSerializer(),
                        }[content_type]
  
          content = serializer.serialize(self.content)
          self.wrapped_exc.body = content
          self.wrapped_exc.content_type = content_type
  
          return self.wrapped_exc
  
  
  class ActionDispatcher(object):
      """Maps method name to local methods through action name."""
  
      def dispatch(self, *args, **kwargs):
          """Find and call local method."""
          action = kwargs.pop('action', 'default')
          action_method = getattr(self, str(action), self.default)
          return action_method(*args, **kwargs)
  
      def default(self, data):
          raise NotImplementedError()
  
  
  class DictSerializer(ActionDispatcher):
      """Default request body serialization."""
  
      def serialize(self, data, action='default'):
          return self.dispatch(data, action=action)
  
      def default(self, data):
          return ""
  
  
  class JSONDictSerializer(DictSerializer):
      """Default JSON request body serialization."""
  
      def default(self, data):
          return jsonutils.dumps(data)
  
  
  class XMLDictSerializer(DictSerializer):
      def __init__(self, metadata=None, xmlns=None):
          """
          :param metadata: information needed to deserialize xml into
                           a dictionary.
          :param xmlns: XML namespace to include with serialized xml
          """
          super(XMLDictSerializer, self).__init__()
          self.metadata = metadata or {}
          self.xmlns = xmlns
  
      def default(self, data):
          # We expect data to contain a single key which is the XML root.
          root_key = data.keys()[0]
          doc = minidom.Document()
          node = self._to_xml_node(doc, self.metadata, root_key, data[root_key])
  
          return self.to_xml_string(node)
  
      def to_xml_string(self, node, has_atom=False):
          self._add_xmlns(node, has_atom)
          return node.toxml('UTF-8')
  
      #NOTE (ameade): the has_atom should be removed after all of the
      # xml serializers and view builders have been updated to the current
      # spec that required all responses include the xmlns:atom, the has_atom
      # flag is to prevent current tests from breaking
      def _add_xmlns(self, node, has_atom=False):
          if self.xmlns is not None:
              node.setAttribute('xmlns', self.xmlns)
          if has_atom:
              node.setAttribute('xmlns:atom', "http://www.w3.org/2005/Atom")
  
      def _to_xml_node(self, doc, metadata, nodename, data):
          """Recursive method to convert data members to XML nodes."""
          result = doc.createElement(nodename)
  
          # Set the xml namespace if one is specified
          # TODO(justinsb): We could also use prefixes on the keys
          xmlns = metadata.get('xmlns', None)
          if xmlns:
              result.setAttribute('xmlns', xmlns)
  
          #TODO(bcwaldon): accomplish this without a type-check
          if isinstance(data, list):
              collections = metadata.get('list_collections', {})
              if nodename in collections:
                  metadata = collections[nodename]
                  for item in data:
                      node = doc.createElement(metadata['item_name'])
                      node.setAttribute(metadata['item_key'], str(item))
                      result.appendChild(node)
                  return result
              singular = metadata.get('plurals', {}).get(nodename, None)
              if singular is None:
                  if nodename.endswith('s'):
                      singular = nodename[:-1]
                  else:
                      singular = 'item'
              for item in data:
                  node = self._to_xml_node(doc, metadata, singular, item)
                  result.appendChild(node)
          #TODO(bcwaldon): accomplish this without a type-check
          elif isinstance(data, dict):
              collections = metadata.get('dict_collections', {})
              if nodename in collections:
                  metadata = collections[nodename]
                  for k, v in data.items():
                      node = doc.createElement(metadata['item_name'])
                      node.setAttribute(metadata['item_key'], str(k))
                      text = doc.createTextNode(str(v))
                      node.appendChild(text)
                      result.appendChild(node)
                  return result
              attrs = metadata.get('attributes', {}).get(nodename, {})
              for k, v in data.items():
                  if k in attrs:
                      result.setAttribute(k, str(v))
                  else:
                      if k == "deleted":
                          v = str(bool(v))
                      node = self._to_xml_node(doc, metadata, k, v)
                      result.appendChild(node)
          else:
              # Type is atom
              node = doc.createTextNode(str(data))
              result.appendChild(node)
          return result
  
      def _create_link_nodes(self, xml_doc, links):
          link_nodes = []
          for link in links:
              link_node = xml_doc.createElement('atom:link')
              link_node.setAttribute('rel', link['rel'])
              link_node.setAttribute('href', link['href'])
              if 'type' in link:
                  link_node.setAttribute('type', link['type'])
              link_nodes.append(link_node)
          return link_nodes
  
      def _to_xml(self, root):
          """Convert the xml object to an xml string."""
          return etree.tostring(root, encoding='UTF-8', xml_declaration=True)
  