def call(request):
	"""
	This is the view you need to map into your URL space to process RPC
	calls.
	"""
	if request.POST:		
		p, u = xmlrpclib.getparser()
		p.feed(request.raw_post_data)
		p.close()
		#print request.raw_post_data
		args = u.close()
		method = u.getmethodname()		
		func = getattr(__import__('blog'), 'metaweblogapi')
		func = getattr(func,str(method.split('.')[1]))		
		if DEBUG: print method, func, args
		if func is not None:
			try:
				result = func(*args)
				xml = xmlrpclib.dumps((result,), methodresponse=1)
				if DEBUG: print result
			except Exception, e:
				if DEBUG: print e
				xml = xmlrpclib.dumps(xmlrpclib.Fault(-32400, 'system error: %s' % e), methodresponse=1)				
		else:
			xml = xmlrpclib.dumps(xmlrpclib.Fault(-32601, 'method unknown: %s' % method), methodresponse=1)
			
		return HttpResponse(xml, mimetype='text/xml; charset=utf-8')

def parse_response(f, conn, debug=0):
    """parse_response(file_obj)

    Read response from input file object, and parse it
    
    The parsed data is returned to the caller
    """
    p,u=xmlrpclib.getparser()
    if debug:
      s=StringIO.StringIO()
    i=0
    try:
      while 1:
        try:
#          print f.fp._line_consumed, f.fp._line_left
          response = f.read()
        except AssertionError:
          break
        if not response:
            break
        if debug:
          s.write(response)
        p.feed(response)
      if debug:
        err_msg(s.getvalue())
      p.close()
      return u.close()
    except:
      if debug:
        err_msg(s.getvalue())
      raise

    def request(self, host, handler, request_body, verbose=0):
        p, u = getparser()
        ssh = self.getssh()
        ssh.stdin.write("""POST /%s HTTP/1.1
User-Agent: Xen
Host: %s
Content-Type: text/xml
Content-Length: %d

%s""" % (handler, host, len(request_body), request_body))
        ssh.stdin.flush()

        content_length = 0
        line = ssh.stdout.readline()
        if line.split()[1] != '200':
            raise Fault(0, 'Server returned %s' % (' '.join(line[1:])))
        
        while line not in ['', '\r\n', '\n']:
            if line.lower().startswith('content-length:'):
                content_length = int(line[15:].strip())
            line = ssh.stdout.readline()
        content = ssh.stdout.read(content_length)
        p.feed(content)
        p.close()
        return u.close()

 def http_POST(self, request):
     parser, unmarshaller = xmlrpclib.getparser()
     deferred = stream.readStream(request.stream, parser.feed)
     deferred.addCallback(lambda x: self._cbDispatch(request, parser, unmarshaller))
     deferred.addErrback(self._ebRender)
     deferred.addCallback(self._cbRender, request)
     return deferred

	def __send(self, methodname, args):

        self.__ensure_channel()

        request=xmlrpclib.dumps(args, methodname, encoding=None) 

        self.__channel.sendall( ("%08d" % (len(request),))+request)

        resplen=self.__recvall(self.__channel, 8)

        resplen=int(resplen)

        response=self.__recvall(self.__channel, resplen)

        p, u = xmlrpclib.getparser()

        p.feed(response)

        p.close()

        try:

            response=u.close()

        except xmlrpclib.Fault,e:

            if e.faultCode!=17:

                raise e

            klass,str=e.faultString.split(':', 1)

            raise common.getfullname(klass)(str)

 def process_request(self, request):
     format_string = getattr(settings, 'FORMAT_STRING', 'format')
     format = request.GET.get(format_string, '')
     if format:
         request.format = format.lower() #could be "json", "xmlrpc", etc
     else:
         request.format = getattr(settings, 'DEFAULT_FORMAT', 'json')
     if request.format == 'xmlrpc':
         import xmlrpclib
         p, u = xmlrpclib.getparser()
         p.feed(request.raw_post_data)
         p.close()
         
         args = u.close()
         if len(args) > 0:
             args = args[0]
             if not isinstance(args, dict):
                 xml = xmlrpclib.dumps(xmlrpclib.Fault(-32400, 'system error: %s' % 'Arguments should be a dict'), methodresponse=1)				
                 return HttpResponse(xml, mimetype='text/xml; charset=utf-8')
                 
             old = request.POST._mutable
             request.POST._mutable = True
             for k, v in args.items():
                 request.POST[k] = v
             request.POST._mutable = old

 def request(self, host, handler, request, verbose):
     response = self._session.post(self._uri, data = request,
             headers={"Content-Type": "text/xml; charset=UTF-8"})
     p, u = xmlrpclib.getparser()
     p.feed(response.content)
     p.close()
     response.close()
     return u.close()

 def _read_request(self, stream):
     parser, unmarshaller = getparser()
     while True:
         chunk = stream.read(8192)
         if not chunk:
             break
         parser.feed(chunk)
     parser.close()
     return unmarshaller.close(), unmarshaller.getmethodname()

 def __parse_action_data(self, action):
     """ Parse action data and returns (method, params) """
     data = action['action']
     parser, decoder = xmlrpclib.getparser()
     parser.feed(data.encode("utf-8"))
     parser.close()
     params = decoder.close()
     method = decoder.getmethodname()
     return (method, params)

 def __parse(self, response):
     p, u = xmlrpclib.getparser()
     p.feed(response.body)
     p.close()
     tmp = u.close()
     
     if len(tmp) == 1:
         tmp = tmp[0]
         
     return tmp

	def request(self, host, uripath, body, verbose=0):
		self._http_request(uripath, body, host)
		response=self.conn.getresponse()
		if response.status != 200:
			raise xmlrpclib.ProtocolError(host+uripath, response.status,
							response.reason, response.msg)
		data=response.read()
		parser, unmarshaller=xmlrpclib.getparser()
		parser.feed(data)
		parser.close()
		return unmarshaller.close()

 def _read_request(self, stream):
     parser, unmarshaller = getparser()
     rlen = 0
     maxlen = opts.get('MaxRequestLength', None)
     while True:
         chunk = stream.read(8192)
         if not chunk:
             break
         rlen += len(chunk)
         if maxlen and rlen > maxlen:
             raise koji.GenericError, 'Request too long'
         parser.feed(chunk)
     parser.close()
     return unmarshaller.close(), unmarshaller.getmethodname()

  def _parse_response(self, response_body):
    """Parse XML-RPC response without socket connection.

    Args:
      response_body: string, XML-RPC response body.

    Returns:
      A tuple containing the unmarshalled XML-RPC response.
    """

    # pylint: disable-msg=E6412
    # Disable error for unexpected keyword argument.
    parser, unmarshaller = xmlrpclib.getparser(use_datetime=0)
    # pylint: enable-msg=E6412
    parser.feed(response_body)
    return unmarshaller.close()

    def request(self, host, handler, request_body, verbose = False):
        parser, unmarshaller = getparser()

        response = self.client.post(handler, request_body, 'text/xml')

        if response.status_code != 200:
            raise ProtocolError(
              '%s%s' % (host, handler),
              response.status_code,
              responses.get(response.status_code, ''),
              dict(response.items()),
            )

        parser.feed(response.content)

        return unmarshaller.close()

    def _parse(self, f, chan):
        n = 0
        line = f.readline()
        if line.split()[1] != '200':
            raise ControlConnectError, 'HTTP request failed' + line

        while n == 0:
            if line.lower().startswith('content-length:'):
                n = int(line[15:].strip())
            line = f.readline()
        content = f.read(n)
        f.close()
        chan.close()

        p, u = xmlrpclib.getparser()
        p.feed(content)
        p.close()
        return u.close()

	def continue_request( self, data, request ):
		if self.set.conf.has_key('defaultencoding'):
			encoding = self.set.conf['defaultencoding']
			new = self.set.PatchEncodingHeader( data )
			OriginalUnmarshaller = xmlrpclib.Unmarshaller
			xmlrpclib.Unmarshaller = Unmarshaller
			p, u = xmlrpclib.getparser()
			xmlrpclib.Unmarshaller = OriginalUnmarshaller
			u.set_resultencoding( encoding )
			p.feed( new )
			p.close()
			params = u.close()
			method = u.getmethodname()
			#parms = []
			#for p in params:
			#	if type( p ) == type( u'' ):
			#		parms.append( p.encode( encoding ) )
			#	else:
			#		parms.append( p )
			#params = tuple(parms)
			try:
				# generate response
				try:
					response = self.call( method, params )
					if type( response ) != type( () ):
						response = ( response, )
				except:
					# report exception back to server
					response = xmlrpclib.dumps( 
						xmlrpclib.Fault( 1, "%s:%s" % (sys.exc_type, sys.exc_value))
						)
				else:
					response = xmlrpclib.dumps( response, methodresponse=1, encoding=encoding )
			except:
				# report internal error
				request.error( 500 )
			else:
				# got a valid response
				request['Content-Type'] = 'text/xml'
				request.push( response )
				request.done()
		else:
			xmlrpc_handler.xmlrpc_handler.continue_request( self, data, request )

    def __init__(self, client_version, req):
        self.client = client_version
        self.req = req
        # grab an Input object
        self.input = transports.Input(req.headers_in)
        # make sure we have a parser and a decoder available
        self.parser, self.decoder = xmlrpclib.getparser()
        # Make sure the decoder doesn't assume UTF-8 data, that would break if
        # non-UTF-8 chars are sent (bug 139370)
        self.decoder._encoding = None

        # extract the server we're talking to and the root directory
        # from the request configuration options
        req_config = req.get_options()
        # XXX: attempt to catch these KeyErrors sometime when there is
        # time to play nicely
        self.server = req_config["SERVER"]
        # Load the server classes
        # XXX: some day we're going to trust the timestamp stuff...
        self.servers = None
        self._setup_servers()

def patchRPCParser(error_handler):
    """
    Patch xmlrpcmlib's parser class, so it logs data content in case of errors,
    to ease debugging.
    Warning: this installs a monkey patch on a generic class, so it's last
    comes wins. Must *not* be enabled by default.

    error_handler (callable)
      Receives the erroneous data as first parameter, and the exception
      instance as second parameter.
      If it returns a false value (ie, handler did not recover from the error),
      exception is re-raised.
    """
    parser, _ = xmlrpclib.getparser()
    parser_klass = parser.__class__
    original_feed = parser_klass.feed
    def verbose_feed(self, data):
        try:
            return original_feed(self, data)
        except Exception, exc:
            if not error_handler(data, exc):
                raise

    def warranted(cls):
        # We cache it so that we don't actually retest.
        if cls._warranted is not None:
            return cls._warranted

        good = True
        parser, unmarshaller = xmlrpclib.getparser()
        try:
            # This will fail if the unmarshaller is unable to handle ex:nil.
            # We do not test for every value that we patch for. We assume if
            # ex:nil won't work, no other extended value will.
            parser.feed("<params><param><value><ex:nil/></value></param></params>")
        except xmlrpclib.ResponseError:
            good = False

        # Trying to close if there was an error earlier won't work.
        if good:
            parser.close()
            unmarshaller.close()

        cls._warranted = not good
        return cls._warranted

def handle_action(action):
    global server

    log.log_debug("handle_action", action)

    version = action['version']
    action_id = action['id']
    data = action['action']

    log.log_debug("handle_action actionid = %s, version = %s" % (
        action_id, version))

    # Decipher the data
    parser, decoder = xmlrpclib.getparser()
    parser.feed(data)
    parser.close()
    params = decoder.close()
    method = decoder.getmethodname()
    data = {}

    (status, message, data) = run_action(method, params)

    log.log_debug("Sending back response", (status, message, data))
    return submit_response(action_id, status, message, data)