import traceback

import time

import itertools

from paste.response import replace_header

from pylons.controllers import WSGIController

from pylons import request

from webob.exc import HTTPError

from kallithea.model.db import User

from kallithea.model import meta

        super(JSONRPCError, self).__init__()

    def __str__(self):

        return safe_str(self.message)

    """

    Generate a Response object with a JSON-RPC error body

        body=json.dumps(dict(id=retid, result=None, error=message)),

        status=code,

class JSONRPCController(WSGIController):

    """

     A WSGI-speaking JSON-RPC controller class

        """

        Parse the request body as JSON, look up the method on the

        controller and if it exists, dispatch to it.

        """

        try:

            return self._handle_request(environ, start_response)

        finally:

            meta.Session.remove()

    def _handle_request(self, environ, start_response):

        start = time.time()

        ip_addr = self.ip_addr = self._get_ip_addr(environ)

        self._req_id = None

        if 'CONTENT_LENGTH' not in environ:

            log.debug("No Content-Length")

                                 message="No Content-Length in request")

        else:

            length = environ['CONTENT_LENGTH'] or 0

            length = int(environ['CONTENT_LENGTH'])

            log.debug('Content-Length: %s', length)

        if length == 0:

                                 message="Content-Length is 0")

        raw_body = environ['wsgi.input'].read(length)

        try:

            json_body = json.loads(raw_body)

        except ValueError as e:

            # catch JSON errors Here

                                 message="JSON parse error ERR:%s RAW:%r"

                                 % (e, raw_body))

        # check AUTH based on API key

        try:

            self._req_api_key = json_body['api_key']

            self._req_id = json_body['id']

            self._req_method = json_body['method']

            self._request_params = json_body['args']

            if not isinstance(self._request_params, dict):

                self._request_params = {}

        except KeyError as e:

                                 message='Incorrect JSON query missing %s' % e)

        # check if we can find this session using api_key

        try:

            u = User.get_by_api_key(self._req_api_key)

            if u is None:

                                     message='Invalid API key')

            auth_u = AuthUser(dbuser=u)

            if not AuthUser.check_ip_allowed(auth_u, ip_addr):

                        message='request from IP:%s not allowed' % (ip_addr,))

            else:

                log.info('Access for IP:%s allowed', ip_addr)

        except Exception as e:

                                 message='Invalid API key')

        self._error = None

        try:

            self._func = self._find_method()

        except AttributeError as e:

                                 message=str(e))

        # now that we have a method, add self._req_params to

        # self.kargs and dispatch control to WGIController

        argspec = inspect.getargspec(self._func)

        arglist = argspec[0][1:]

                # this is checked before so we don't need validate it

                continue

            # skip the required param check if it's default value is

            # NotImplementedType (default_empty)

            if default == default_empty and arg not in self._request_params:

                    retid=self._req_id,

                )

        extra = set(self._request_params).difference(func_kwargs)

        if extra:

                    retid=self._req_id,

                )

        self._rpc_args = {}

        self._rpc_args.update(self._request_params)