Python xmlrpclib.getparser函数代码示例

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