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