def testGetImage1(self): srv = self.newService() imageId = '0000000000000000000000000000000000000001' uri = '%s/images/%s' % (self._baseCloudUrl, imageId) client = self.newClient(srv, uri) response = client.request('GET') hndlr = images.Handler() response = util.BoundedStringIO(response.read()) node = hndlr.parseFile(response) self.failUnless(isinstance(node, images.BaseImages), node) self.failUnlessEqual(len(node), 1) self.failUnlessEqual([x.getImageId() for x in node], [imageId]) self.failUnlessEqual([x.getLongName() for x in node], ['8/some-file-8-1-x86 (emi-0435d06d)']) # Should be able to fetch the image with the target image id too targetImageId = 'emi-0435d06d' uri = '%s/images/%s' % (self._baseCloudUrl, targetImageId) client = self.newClient(srv, uri) response = client.request('GET') hndlr = images.Handler() response = util.BoundedStringIO(response.read()) node = hndlr.parseFile(response) self.failUnless(isinstance(node, images.BaseImages), node) self.failUnlessEqual(len(node), 1) self.failUnlessEqual([x.getImageId() for x in node], [imageId]) self.failUnlessEqual([x.getLongName() for x in node], ['8/some-file-8-1-x86 (emi-0435d06d)'])
def testGetCloudTypes1(self): uri = 'clouds?_method=GET' srv = self.newService() client = self.newClient(srv, uri) response = client.request("POST") self.failUnlessEqual(response.msg['Content-Type'], 'application/xml') hndlr = cloud_types.Handler() response = util.BoundedStringIO(response.read()) nodes = hndlr.parseFile(response) self.failUnlessEqual([x.getCloudTypeName() for x in nodes], self.supportedCloudTypes) expIds = [ "http://%s/TOPLEVEL/clouds/%s" % (client.hostport, exp) for exp in self.supportedCloudTypes ] self.failUnlessEqual([x.getId() for x in nodes], expIds) expRefs = [x + '/instances' for x in expIds] self.failUnlessEqual([x.getCloudInstances().getHref() for x in nodes], expRefs) expRefs = [x + '/descriptor/configuration' for x in expIds] self.failUnlessEqual( [x.getDescriptorInstanceConfiguration().getHref() for x in nodes], expRefs) expRefs = [x + '/descriptor/credentials' for x in expIds] self.failUnlessEqual( [x.getDescriptorCredentials().getHref() for x in nodes], expRefs)
def testGetImages1(self): DummyTransport.dataMap[ 'VM.get_all_records'] = mockedData.xenent_listImages1 srv = self.newService() uri = 'clouds/xen-enterprise/instances/xs01.eng.rpath.com/images' client = self.newClient(srv, uri) response = client.request('GET') hndlr = images.Handler() response = util.BoundedStringIO(response.read()) nodes = hndlr.parseFile(response) self.failUnless(isinstance(nodes, images.BaseImages), nodes) self.failUnlessEqual([x.getImageId() for x in nodes], [ '0903de41206786d4407ff24ab6e972c0d6b801f3', '0xPrivateImage', '52f75c4d-9782-15a2-6f76-a96a71d3d9b1', 'b3fb7387bb04b1403bc0eb06bd55c0ef5f02d9bb', 'c4664768-622b-8ab7-a76f-5a1c62c2688f', 'd0bf8f0e-afce-d9fb-8121-e9e174a7c99b', ]) self.assertEquals([x.getBuildPageUrl() for x in nodes], [ 'http://test.rpath.local2/project/foo/build?id=6', 'http://test.rpath.local2/project/foo/build?id=7', None, 'http://test.rpath.local2/project/foo/build?id=1', None, None, ])
def _readlineify(self): if hasattr(self.fp, 'readline'): return fp = util.BoundedStringIO() util.copyfileobj(self.fp, fp) fp.seek(0) self.fp = fp
def no_testUpload1(self): # Not intended to run as part of the testsuite (yet) client = xenent.xenentclient.UploadClient( "http://*****:*****@localhost:1234/abc") sio = util.BoundedStringIO("01234" * 5) sio.seek(0) resp = client.request(sio)
def testGetOneCloud1(self): srv = self.newService() uri = 'clouds/ec2/instances/aws' client = self.newClient(srv, uri) response = client.request('GET') response = util.BoundedStringIO(response.read()) hndlr = clouds.Handler() nodes = hndlr.parseFile(response) self.failUnlessEqual([x.getCloudName() for x in nodes], ['aws'])
def testXMLRPCbinary(self): # CNY-1932 # Make sure we properly encode and decode XMLRPC Binary objects on the # fly marshaller = util.XMLRPCMarshaller("utf-8", allow_none=False) srcdata = "abc\x80" data = marshaller.dumps((srcdata, )) self.assertEqual( data, "<params>\n<param>\n<value><base64>\nYWJjgA==\n</base64></value>\n" "</param>\n</params>\n") data = util.xmlrpcDump((srcdata, ), methodresponse=True) self.assertEqual( data, "<?xml version='1.0'?>\n" "<methodResponse>\n" "<params>\n<param>\n<value><base64>\nYWJjgA==\n</base64></value>\n" "</param>\n</params>\n" "</methodResponse>\n") srcdata = ["abc\x80", util.ProtectedString("abc\x80")] data = util.xmlrpcDump((srcdata, ), methodresponse=True) sio = StringIO.StringIO(data) params, methodname = util.xmlrpcLoad(sio) self.assertEqual(params, (srcdata, )) self.assertEqual(methodname, None) # Produce a very large string representation srcdata = ["abc\x80"] * 4096 sio = util.BoundedStringIO() util.xmlrpcDump((srcdata, ), methodname="somemethod", stream=sio) sio.seek(0) params, methodname = util.xmlrpcLoad(sio) self.assertEqual(params, (srcdata, )) self.assertEqual(methodname, 'somemethod') sio.seek(0) params, methodname = util.xmlrpcLoad(sio.read()) self.assertEqual(params, (srcdata, )) self.assertEqual(methodname, 'somemethod') # Test a Fault too x = util.xmlrpclib.Fault(1001, "blah") repr1 = util.xmlrpclib.dumps(x) repr2 = util.xmlrpcDump(x) self.assertEqual(repr1, repr2) try: util.xmlrpcLoad(repr1) except util.xmlrpclib.Fault, x2: self.assertEqual(x.faultCode, x2.faultCode) self.assertEqual(x.faultString, x2.faultString)
def testGetCloudTypes2(self): uri = 'clouds?_method=GET' srv = self.newService() client = self.newClient(srv, uri) response = client.request("POST") self.failUnlessEqual(response.msg['Content-Type'], 'application/xml') hndlr = cloud_types.Handler() response = util.BoundedStringIO(response.read()) nodes = hndlr.parseFile(response) self.failUnlessEqual([x.getCloudTypeName() for x in nodes], self.supportedCloudTypes)
def _testGetClouds(self, uri, cloudType, expected, method='POST'): srv = self.newService() client = self.newClient(srv, uri) response = client.request(method) self.failUnlessEqual(response.msg['Content-Type'], 'application/xml') hndlr = clouds.Handler() response = util.BoundedStringIO(response.read()) nodes = hndlr.parseFile(response) self.failUnlessEqual([x.getType().getText() for x in nodes], [cloudType] * len(nodes)) expTypeRefs = [ "http://%s/TOPLEVEL/clouds/%s" % (client.hostport, cloudType) ] * len(nodes) self.failUnlessEqual([x.getType().getHref() for x in nodes], expTypeRefs) expIds = [ "http://%s/TOPLEVEL/clouds/%s/instances/%s" % (client.hostport, cloudType, x['cloudName']) for x in expected ] self.failUnlessEqual([x.getId() for x in nodes], expIds) self.failUnlessEqual([x.getCloudName() for x in nodes], [x['cloudName'] for x in expected]) self.failUnlessEqual([x.getCloudAlias() for x in nodes], [x['cloudAlias'] for x in expected]) self.failUnlessEqual([x.getDescription() for x in nodes], [x['description'] for x in expected]) self.failUnlessEqual([x.getImages().getHref() for x in nodes], [x + '/images' for x in expIds]) self.failUnlessEqual([x.getInstances().getHref() for x in nodes], [x + '/instances' for x in expIds]) self.failUnlessEqual( [x.getDescriptorLaunch().getHref() for x in nodes], [x + '/descriptor/launch' for x in expIds]) self.failUnlessEqual([x.getConfiguration().getHref() for x in nodes], [x + '/configuration' for x in expIds]) self.failUnlessEqual( [x.getUserCredentials().getHref() for x in nodes], [x + '/users/JeanValjean/credentials' for x in expIds]) expHrefs = [ "http://%s/TOPLEVEL/jobs/types/instance-launch/jobs?cloudName=%s&cloudType=%s&status=Running" % (client.hostport, x['cloudName'], cloudType) for x in expected ] self.failUnlessEqual([x.getActiveJobs().getHref() for x in nodes], expHrefs)
def testGetInstances1(self): # We need to mock the image data self._mockRequest(DescribeImages=_t(mockedData.xml_getAllImages3)) srv = self.newService() uri = '%s/instances' % (self._baseCloudUrl, ) client = self.newClient(srv, uri) response = client.request('GET') self.failUnlessEqual(response.msg['Content-Type'], 'application/xml') self.failUnlessEqual(response.msg['Cache-Control'], 'no-store') hndlr = self.InstancesHandler() response = util.BoundedStringIO(response.read()) node = hndlr.parseFile(response) self.failUnless(isinstance(node, instances.BaseInstances), node) self.failUnlessEqual(len(node), 2) expId = [ 'i-1639fe7f', 'i-805f98e9', ] self.failUnlessEqual([x.getInstanceId() for x in node], expId) self.failUnlessEqual( [x.getId() for x in node], [self.makeUri(client, "%s/%s" % (uri, x)) for x in expId]) self.failUnlessEqual([x.getCloudName() for x in node], [self.cloudName] * len(node)) self.failUnlessEqual([x.getCloudType() for x in node], [self.cloudType] * len(node)) self.failUnlessEqual([x.getCloudAlias() for x in node], ['euca1'] * len(node)) self.failUnlessEqual([x.getInstanceName() for x in node], [ 'reviewboard-1.0-x86_13964.img (emi-3675905f)', 'reviewboard-1.0-x86_13965.img (emi-957590fc)' ]) self.failUnlessEqual([x.getInstanceDescription() for x in node], [ 'reviewboard-1.0-x86_13964.img (emi-3675905f)', 'reviewboard-1.0-x86_13965.img (emi-957590fc)' ]) self.failUnlessEqual([x.getLaunchTime() for x in node], ['1207592569', '1207665151']) self.failUnlessEqual([x.getPlacement() for x in node], ['us-east-1c', 'imperial-russia']) self.assertEquals([x.getProductCode() for x in node], [None, None]) self.failUnlessEqual([[x.getId() for x in n.getSecurityGroup()] for n in node], [['BEA Demo'], ['BEA Demo']])
def testGetImages1(self): srv = self.newService() uri = '%s/images?_method=GET' % (self._baseCloudUrl, ) correctedUri = '%s/images' % (self._baseCloudUrl, ) client = self.newClient(srv, uri) response = client.request('POST') self.failUnlessEqual(response.msg['Content-Type'], 'application/xml') self.failUnlessEqual(response.msg['Cache-Control'], 'no-store') hndlr = images.Handler() response = util.BoundedStringIO(response.read()) node = hndlr.parseFile(response) self.failUnless(isinstance(node, images.BaseImages), node) imageIds = [ '0000000000000000000000000000000000000001', '361d7fa1d99431e16a3a438c8d4ebaa79aea075a', ] self.failUnlessEqual([x.getImageId() for x in node], imageIds) # make sure the ?_method=GET portion of the URI didn't persist self.failUnlessEqual([x.getId() for x in node], [ self.makeUri(client, "%s/%s" % (correctedUri, x)) \ for x in imageIds ]) # this data comes from the mockModule for mint. we're just testing # that it gets integrated self.assertEquals( [x.getProductDescription() for x in node], ['product description for bar', 'words words SPARKY words']) self.assertEquals( [x.getBuildDescription() for x in node], ['build description for bar 8', 'just words and stuff']) self.assertEquals([x.getIsPrivate_rBuilder() for x in node], [False, False]) self.assertEquals([x.getProductName() for x in node], ['bar project', 'foo project']) self.assertEquals([x.getRole() for x in node], ['developer', 'developer']) self.assertEquals([x.getPublisher() for x in node], ['Bob Loblaw', 'Bob Loblaw']) self.assertEquals([x.getAwsAccountNumber() for x in node], [None, None]) self.assertEquals([x.getBuildName() for x in node], ['bar project', 'foo project']) self.assertEquals([x.getIs_rBuilderImage() for x in node], [True, True]) self.assertEquals([x.getBuildPageUrl() for x in node], [ 'http://test.rpath.local2/project/bar/build?id=8', 'http://test.rpath.local2/project/foo/build?id=6' ]) self.assertEquals([x.getProductCode() for x in node], [None, None])
def _testSha1CopyAndUncompress(self, offset): infd = -1 outfd = -1 try: # set up some constants teststr = ' ' * 1000 path = self.workDir + '/testfile' # open a sparse file and seek out to the requested offset f = open(path, 'w') f.seek(offset) # write a gzip file containing the test string gz = util.BoundedStringIO() compressor = gzip.GzipFile(None, "w", fileobj=gz) compressor.write(teststr) compressor.close() gz.seek(0) s = gz.read() f.write(s) f.close() # open using unbuffered io infd = os.open(path, os.O_RDONLY) outfd = os.open(path + '-copy', os.O_CREAT | os.O_WRONLY) # copy from the large sparse file to the output file, # decompressing the data and returning a sha1 of the uncompressed # contents sha = digest_uncompress.sha1Copy((infd, offset, len(s)), [outfd]) # also decompress to a target file, while performing a sha1sum # of the uncompressed contents target = path + '-uncompressed' sha2, tmpname = digest_uncompress.sha1Uncompress( infd, offset, len(s), os.path.dirname(target), os.path.basename(target)) # make sure the sha matches what we expect expected = sha1helper.sha1String(teststr) self.assertEqual(sha, expected) self.assertEqual(sha2, expected) # make sure that the copied file matches the gzip compressed # string f = open(path + '-copy') self.assertEqual(f.read(), s) # and that it also is correctly uncompressed f = open(tmpname) self.assertEqual(f.read(), teststr) finally: if infd > 0: os.close(infd) if outfd > 0: os.close(outfd) file_utils.removeIfExists(path) file_utils.removeIfExists(path + '-copy')
def testTerminateEC2InstancesPOST(self): instanceId = 'i-60f12709' srv = self.newService() uri = 'clouds/ec2/instances/aws/instances/%s?_method=DELETE' % instanceId client = self.newClient(srv, uri) response = client.request('POST', mockedData.xml_terminateInstance1) hndlr = instances.Handler() response = util.BoundedStringIO(response.read()) node = hndlr.parseFile(response) self.failUnless(isinstance(node, instances.BaseInstance), node) self.failUnlessEqual( node.getId(), self.makeUri(client, 'clouds/ec2/instances/aws/instances/' + instanceId))
def testGetJobsTypes(self): job1 = self.store.create(cloudType=self.cloudType, cloudName=self.cloudName, instanceId=self.targetSystemIds[0]) self.restdb.commit() srv = self.newService() uri = 'jobs/types' client = self.newClient(srv, uri) response = client.request('GET') hndlr = job_types.Handler() response = util.BoundedStringIO(response.read()) nodes = hndlr.parseFile(response) prefix = self.makeUri(client, 'jobs/types') self.failUnlessEqual([x.id for x in nodes], [ "%s/%s" % (prefix, x) for x in [ 'instance-launch', 'software-version-refresh', 'image-deployment', 'instance-update' ] ]) uri = 'jobs/types/software-version-refresh' client = self.newClient(srv, uri) response = client.request('GET') response.read() uri = 'jobs/types/no-such-job-type' client = self.newClient(srv, uri) resp = self.failUnlessRaises(ResponseError, client.request, 'GET') self.failUnlessEqual(resp.status, 404) uri = 'jobs/types/software-version-refresh/jobs' client = self.newClient(srv, uri) response = client.request('GET') data = response.read() storedJobs = jobmodels.Jobs() storedJobs.parseStream(data) self.failUnlessEqual(len(storedJobs.job), 1) self.failUnlessEqual(storedJobs.job[0].get_id(), self.makeUri(client, "%s/%s" % (uri, job1.jobId))) uri = 'jobs/types/no-such-job-type/jobs' client = self.newClient(srv, uri) resp = self.failUnlessRaises(ResponseError, client.request, 'GET') self.failUnlessEqual(resp.status, 404)
def testGetClouds1(self): srv = self.newService() uri = 'clouds/%s/instances' % self.cloudType client = self.newClient(srv, uri) response = client.request('GET') hndlr = clouds.Handler() response = util.BoundedStringIO(response.read()) nodes = hndlr.parseFile(response) self.failUnlessEqual([x.getCloudName() for x in nodes], [self.cloudName]) self.failUnlessEqual([x.getCloudAlias() for x in nodes], ['euca1']) self.failUnlessEqual([x.getDescription() for x in nodes], ['Eucalyptus server'])
def testGetClouds1(self): srv = self.newService() uri = 'clouds/xen-enterprise/instances' client = self.newClient(srv, uri) response = client.request('GET') hndlr = clouds.Handler() response = util.BoundedStringIO(response.read()) nodes = hndlr.parseFile(response) self.failUnlessEqual([x.getCloudName() for x in nodes], ['abc.eng.rpath.com', 'xs01.eng.rpath.com']) self.failUnlessEqual([x.getCloudAlias() for x in nodes], ['abc', 'xs01']) self.failUnlessEqual([x.getDescription() for x in nodes], ['abc cloud', 'xs01 cloud'])
def testGetNoInstances(self): # ensure listing instances when there are none actually returns def FakeGetAllInstances(*args, **kwargs): return boto.resultset.ResultSet() from catalogService.rest.drivers.ec2.ec2client import EC2Connection self.mock(EC2Connection, 'get_all_instances', FakeGetAllInstances) srv = self.newService() uri = 'clouds/ec2/instances/aws/instances?_method=GET' client = self.newClient(srv, uri) response = client.request('POST') self.failUnlessEqual(response.msg['Content-Type'], 'application/xml') hndlr = instances.Handler() response = util.BoundedStringIO(response.read()) node = hndlr.parseFile(response) self.failUnless(isinstance(node, instances.BaseInstances), node) self.failUnlessEqual(len(node), 0)
def testBoundedStringIO(self): x = util.BoundedStringIO(maxMemorySize=256) self.assertEqual(x.getBackendType(), 'memory') self.assertTrue(isinstance(x._backend, StringIO.StringIO)) x.write("0123456789" * 30) self.assertEqual(x.getBackendType(), 'file') self.assertTrue(isinstance(x._backend, file)) # Test truncate x.truncate(298) self.assertEqual(x.getBackendType(), 'file') self.assertTrue(isinstance(x._backend, file)) # Truncate some more x.truncate(255) self.assertEqual(x.getBackendType(), 'memory') self.assertTrue(isinstance(x._backend, StringIO.StringIO))
def testNewInstances5NoCookie(self): cloudName = 'xs01.eng.rpath.com' cloudType = xenent.driver.cloudType def fakeOpenUrl(slf, url, headers): if headers: raise Exception("pysid was passed in") raise xenent.xenentclient.errors.DownloadError( "No no no, you don't love me and I know now") def fakeDaemonize(slf, *args, **kwargs): return slf.function(*args, **kwargs) def fakeMakeRequest(slf, loginUrl, data, headers): class FakeAddInfoUrl(object): pass o = FakeAddInfoUrl() o.headers = {} return o self.mock(xenent.xenentclient.baseDriver.CookieClient, "makeRequest", fakeMakeRequest) srv, client, job, response = self._setUpNewInstanceTest( cloudName, fakeDaemonize, 'some-file-7-1-x86', imageId='0xPrivateImage', openUrlFunc=fakeOpenUrl) jobUrlPath = 'jobs/types/instance-launch/jobs/1' self.failUnlessEqual(job.get_id(), self.makeUri(client, jobUrlPath)) job = self.waitForJob(srv, jobUrlPath, "Failed") errorResponse = job.get_errorResponse() sio = util.BoundedStringIO() errorResponse.export(sio, 0, '') sio.seek(0) self.assertXMLEquals( sio.getvalue(), """<errorResponse><fault><code>404</code><message>No no no, you don't love me and I know now</message></fault></errorResponse>""" )
def testMalformedURI(self): # pass a uri that doesn't have an ID (it should) to see if the system # tips over or not. srv = self.newService() uri = 'clouds/ec2/instances?_method=GET' client = self.newClient(srv, uri) response = client.request('POST') self.failUnlessEqual(response.msg['Content-Type'], 'application/xml') hndlr = clouds.Handler() response = util.BoundedStringIO(response.read()) nodes = hndlr.parseFile(response) self.failUnlessEqual(len(nodes), 1) expected = ['ec2/instances/aws'] self.failUnlessEqual([x.getType().getText() for x in nodes], [x.split('/')[0] for x in expected]) self.failUnlessEqual([x.getCloudName() for x in nodes], [x.split('/')[2] for x in expected]) for exp, x in zip(expected, nodes): self.failUnlessEqual(x.getName(), 'cloud') cloudId = x.getId() expUrl = "http://%s/TOPLEVEL/clouds/%s" % (client.hostport, exp) self.failUnlessEqual(cloudId, expUrl)
def handleXml(self, authToken): contentLength = int(self.headers['Content-Length']) sio = util.BoundedStringIO() actual = util.copyStream(self.rfile, sio, contentLength) if contentLength != actual: raise Exception(contentLength, actual) sio.seek(0) encoding = self.headers.get('Content-Encoding', None) if encoding == 'deflate': sio = util.decompressStream(sio) sio.seek(0) (params, method) = util.xmlrpcLoad(sio) logMe( 3, "decoded xml-rpc call %s from %d bytes request" % (method, contentLength)) if self.netProxy: repos = self.netProxy else: repos = self.netRepos localHost, localPort = self.request.getsockname()[:2] if ':' in localHost: localHost = '[%s]' % localHost localAddr = '%s:%s' % (localHost, localPort) request = xmlshims.RequestArgs.fromWire(params) if repos is not None: try: response, extraInfo = repos.callWrapper( protocol='http', port=None, methodname=method, authToken=authToken, request=request, remoteIp=self.connection.getpeername()[0], rawUrl=self.path, localAddr=localAddr, protocolString=self.request_version, headers=self.headers, isSecure=self.server.isSecure, ) except errors.InsufficientPermission: self.send_error(403) return None except: # exceptions are handled (logged) in callWrapper - send # 500 code back to the client to indicate an error happened self.send_error(500) from conary.lib import formattrace excType, excValue, excTb = sys.exc_info() formattrace.formatTrace(excType, excValue, excTb, withLocals=False) return None logMe(3, "returned from", method) rawResponse, headers = response.toWire(request.version) sio = util.BoundedStringIO() util.xmlrpcDump((rawResponse, ), stream=sio, methodresponse=1) respLen = sio.tell() logMe(3, "encoded xml-rpc response to %d bytes" % respLen) self.send_response(200) encoding = self.headers.get('Accept-encoding', '') if respLen > 200 and 'deflate' in encoding: sio.seek(0) sio = util.compressStream(sio, level=5) respLen = sio.tell() self.send_header('Content-encoding', 'deflate') self.send_header("Content-type", "text/xml") self.send_header("Content-length", str(respLen)) for key, value in sorted(headers.items()): self.send_header(key, value) if extraInfo: # If available, send to the client the via headers all the way up # to us self.send_header( 'Via', proxy.formatViaHeader(localAddr, 'HTTP/1.0', prefix=extraInfo.getVia())) self.end_headers() sio.seek(0) util.copyStream(sio, self.wfile) logMe(3, "sent response to client", respLen, "bytes") return respLen
def post(port, isSecure, repos, req, authToken=None, repServer=None): if authToken is None: authToken = getAuth(req) if authToken is None: return apache.HTTP_BAD_REQUEST if authToken[0] != "anonymous" and not isSecure and repos.cfg.forceSSL: return apache.HTTP_FORBIDDEN if isSecure: protocol = "https" else: protocol = "http" extraInfo = None repos.log.reset() if req.headers_in['Content-Type'] == "text/xml": # handle XML-RPC requests encoding = req.headers_in.get('Content-Encoding', None) sio = util.BoundedStringIO() try: util.copyStream(req, sio) except IOError, e: # if we got a read timeout, marshal an exception back # to the client print >> sys.stderr, 'error reading from client: %s' % e method = 'unknown - client timeout' response = xmlshims.ResponseArgs.newException( 'ClientTimeout', 'The server was not able to read the ' 'XML-RPC request sent by this client. ' 'This is sometimes caused by MTU problems ' 'on your network connection. Using a ' 'smaller MTU may work around this ' 'problem.') headers = {} startTime = time.time() else: # otherwise, we've read the data, let's process it if encoding == 'deflate': sio.seek(0) try: sio = util.decompressStream(sio) except zlib.error, error: req.log_error("zlib inflate error in POST: %s" % error) return apache.HTTP_BAD_REQUEST startTime = time.time() sio.seek(0) try: (params, method) = util.xmlrpcLoad(sio) except: req.log_error('error parsing XMLRPC request') return apache.HTTP_BAD_REQUEST repos.log(3, "decoding=%s" % method, authToken[0], "%.3f" % (time.time() - startTime)) # req.connection.local_addr[0] is the IP address the server # listens on, not the IP address of the accepted socket. Most of # the times it will be 0.0.0.0 which is not very useful. We're # using local_ip instead, and we grab just the port from # local_addr. localAddr = "%s:%s" % (req.connection.local_ip, req.connection.local_addr[1]) remoteIp = req.connection.remote_ip # Get the IP address of the original request in the case # of a proxy, otherwise use the connection's remote_ip if 'X-Forwarded-For' in req.headers_in: # pick the right-most client, since that is # the one closest to us. For example, if # we have "X-Forwarded-For: 1.2.3.4, 4.5.6.7" # we want to use 4.5.6.7 clients = req.headers_in['X-Forwarded-For'] remoteIp = clients.split(',')[-1].strip() try: request = xmlshims.RequestArgs.fromWire(params) except (TypeError, ValueError, IndexError): req.log_error('error parsing XMLRPC arguments') return apache.HTTP_BAD_REQUEST try: response, extraInfo = repos.callWrapper( protocol=protocol, port=port, methodname=method, authToken=authToken, request=request, remoteIp=remoteIp, rawUrl=req.unparsed_uri, localAddr=localAddr, protocolString=req.protocol, headers=req.headers_in, isSecure=isSecure, ) except errors.InsufficientPermission: return apache.HTTP_FORBIDDEN
methodname=method, authToken=authToken, request=request, remoteIp=remoteIp, rawUrl=req.unparsed_uri, localAddr=localAddr, protocolString=req.protocol, headers=req.headers_in, isSecure=isSecure, ) except errors.InsufficientPermission: return apache.HTTP_FORBIDDEN rawResponse, headers = response.toWire(request.version) sio = util.BoundedStringIO() util.xmlrpcDump((rawResponse, ), stream=sio, methodresponse=1) respLen = sio.tell() repos.log(1, method, "time=%.3f size=%d" % (time.time() - startTime, respLen)) req.content_type = "text/xml" # check to see if the client will accept a compressed response encoding = req.headers_in.get('Accept-encoding', '') if respLen > 200 and 'deflate' in encoding: req.headers_out['Content-encoding'] = 'deflate' sio.seek(0) sio = util.compressStream(sio, 5) respLen = sio.tell() req.headers_out['Content-length'] = '%d' % respLen for key, value in sorted(headers.items()):
def fakeOpenUrl(slf, url): return util.BoundedStringIO("""\ <clientInfo><remoteIp>1.2.3.4</remoteIp><hostName>rdu-wireless.rpath.com</hostName></clientInfo>""" )