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 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 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 __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 parse_response_xmlrpc(f, conn, debug=1): """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: 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 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 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 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 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 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_action_data(self, action): """ Parse action data and returns (method, params) """ data = action['action'] parser, decoder = xmlrpclib.getparser() parser.feed(bstr(data)) 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, 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 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 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 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 __send(self, methodname, args): self.__ensure_channel() request=xmlrpclib.dumps(args, methodname, encoding=None) # allow_none=False (allow_none is py2.3+) 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() # if the response was a Fault, then it is raised by u.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 _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 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 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 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)
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)
def getparser(self): return xmlrpclib.getparser()
test_line.stop() """ import httplib import logging import select import socket import threading import time import xmlrpclib __all__ = ['TaskDistributionTool', 'TestResultProxy', 'TestResultLineProxy', 'patchRPCParser'] # Depending on used xmlrpc backend, different exceptions can be thrown. SAFE_RPC_EXCEPTION_LIST = [socket.error, xmlrpclib.ProtocolError, xmlrpclib.Fault, httplib.BadStatusLine, httplib.ResponseNotReady] parser, _ = xmlrpclib.getparser() if xmlrpclib.ExpatParser and isinstance(parser, xmlrpclib.ExpatParser): SAFE_RPC_EXCEPTION_LIST.append(xmlrpclib.expat.ExpatError) else: import sys print >> sys.stderr, 'Warning: unhandled xmlrpclib parser %r, some ' \ 'exceptions might get through safeRpcCall' % (parser, ) del sys SAFE_RPC_EXCEPTION_LIST = tuple(SAFE_RPC_EXCEPTION_LIST) del parser, _ def null_callable(*args, **kw): pass class NullLogger(object): def __getattr__(self, name):
def __parse_response(self, response_body): p, u = xmlrpclib.getparser(use_datetime=self._use_datetime) p.feed(response_body) return u.close()
def getparser(self): # get parser and unmarshaller return getparser()
def getparser(self): # get parser and unmarshaller return xmlrpclib.getparser()
def getparser(self): return getparser(use_datetime=self._use_datetime)
import socket import threading import time import xmlrpclib __all__ = [ 'TaskDistributor', 'TestResultProxy', 'TestResultLineProxy', 'patchRPCParser' ] # Depending on used xmlrpc backend, different exceptions can be thrown. SAFE_RPC_EXCEPTION_LIST = [ socket.error, xmlrpclib.ProtocolError, xmlrpclib.Fault, httplib.BadStatusLine, httplib.ResponseNotReady ] parser, _ = xmlrpclib.getparser() if xmlrpclib.ExpatParser and isinstance(parser, xmlrpclib.ExpatParser): SAFE_RPC_EXCEPTION_LIST.append(xmlrpclib.expat.ExpatError) else: import sys print('Warning: unhandled xmlrpclib parser %r, some exceptions might get' ' through safeRpcCall' % parser, file=sys.stderr) del sys SAFE_RPC_EXCEPTION_LIST = tuple(SAFE_RPC_EXCEPTION_LIST) del parser, _ def null_callable(*args, **kw): pass
def __parse_response(self, response_body): p, u = xmlrpclib.getparser(use_datetime=False) p.feed(response_body) return u.close()
def getparser(self): return getparser()