def getChild(self, name, request):
# Python2.6/3.0
#log.debug("{0} getting child {1} for {2}".format(
# self, name, request))
log.debug("%r getting child %s for %r" % (self, name, request))
try:
sizeDesc, suffix = name.split(".")
size = int(sizeDesc)
except (TypeError, ValueError):
child = Resource.getChild(self, name, request)
else:
suffix = suffix.upper()
if suffix == "B":
child = Junk(size, self._chunkSize)
elif suffix == "KB":
child = Junk(size * 1024, self._chunkSize)
elif suffix == "MB":
child = Junk(size * 1024 * 1024, self._chunkSize)
else:
child = Resource.getChild(self, name, request)
return child
def setUp(self):
PendrellTestMixin.setUp(self)
log.debug("Setting up md5 site.")
self.md5Server = reactor.listenTCP(
self.http_port,
Site(MD5Root()),
interface=self._lo0)
log.debug("MD5 site is listening.")
def render_GET(self, request):
# Python2.6/3.0
#log.debug("{0} rendering {1:d} bytes for {2}".format(
# self, self.size, request))
log.debug("%r rendering %d bytes for %r" % (self, self.size, request))
request.setHeader("Content-length", self.size)
self._writeJunk(request)
return NOT_DONE_YET
def getAuthorization(self, unauth, authenticators):
authenticators = authenticators[:]
authorization = None
while authenticators and authorization is None:
authenticator = authenticators.pop(0)
for scheme, params in unauth.challenges:
if self._supportedAuthenticationScheme(scheme, authenticator):
try:
authorization = yield maybeDeferred(
authenticator.authorize, scheme, **params)
except Exception, e:
log.debug(e)
def _waitToProcess(self):
"""Wait for noLongerQueued() to be called."""
assert self._queued is None
if self.queued:
log.debug("%r: Waiting to render" % self)
self._queued = d = Deferred()
else:
log.debug("%r: Rendering immediately" % self)
d = succeed(self)
return d
def open(self, request, authenticator=None, authenticators=None,
followRedirect=None, proxy=None, _redirectCount=0, _unauthCount=0,
**kw):
"""Setup and issue a request.
Arguments:
request -- A URL str OR an instance of URLPath OR Request.
Keyword Arguments:
authenticator [default: None] --
If specified and not None, an instance of Authenticator
followRedirect [default: self.followRedirect] --
False if the response should callback with a redirect
response instead of following the redirect.
proxy --
An instance of Proxy.
Additional keyword arguments are passed to the constructor of
self.requestClass.
"""
request = self.buildRequest(request, **kw)
assert proxy is None or isinstance(proxy, Proxy)
timeout = kw.get("timeout", self._timeout)
if followRedirect is None:
followRedirect = self.followRedirect
authorization = self._getCachedAuthorization(request)
if authorization:
request = self._buildAuthenticatedRequest(request, authorization)
if proxy:
request.setProxy(proxy)
requester = self.getRequester(request, timeout=timeout)
try:
response = yield requester.issueRequest(request)
except RedirectedResponse, rr:
if not followRedirect \
or _redirectCount == self.maxRedirects \
or rr.status == http.SEE_OTHER:
raise
log.debug("Redirecting to %r" % (rr.location))
response = yield self.open(
request.redirect(rr.location),
followRedirect = followRedirect,
proxy = proxy,
_redirectCount = _redirectCount+1,
authenticator = authenticator,
authenticators = authenticators,
_unauthCount = _unauthCount,
**kw)
def getChild(self, name, request):
# Python2.6/3.0
# log.debug("{0} getting child {1} for {2}".format(
# self, name, request))
log.debug("%r getting child %s for %r" % (self, name, request))
try:
sizeDesc, suffix = name.split(".")
relativeSize = long(sizeDesc)
size = normalizeBytes(relativeSize, suffix)
except (TypeError, ValueError), e:
log.debug("Failed to determine size for %r: %r" % (name, e.args))
child = Resource.getChild(self, name, request)
def _writeJunk(self, request):
writtenSize = 0
while writtenSize != self.size:
if writtenSize + self.chunkSize > self.size:
writeSize = self.size - writtenSize
else:
writeSize = self.chunkSize
#log.debug("{0} writing {1:d} bytes for {2}".format(
# self, writeSize, request))
log.debug("%r writing %d bytes for %r" % (self, writeSize, request))
yield self._writeJunkChunk(request, writeSize)
writtenSize += writeSize
assert writtenSize == self.size
log.debug("%r wrote %d bytes for %r" % (self, writtenSize, request))
request.finish()
def _writeJunk(self, request):
chunkCount = long()
writtenSize = long()
while writtenSize != self.size:
if writtenSize + self.chunkSize > self.size:
writeSize = self.size - writtenSize
else:
writeSize = self.chunkSize
writtenSize += writeSize
log.debug("Writing chunk %d (%dB/%dB) of %r" % (chunkCount, writeSize, writtenSize, request))
chunkCount += 1
yield self._writeJunkChunk(request, writeSize)
assert writtenSize == self.size
bytes, suffix = humanizeBytes(writtenSize)
log.debug("Wrote %f%s in %d chunks for %r" % (bytes, suffix, chunkCount, request))
request.finish()
def _selectParseHeader(self, header):
"""Find an authentication scheme in a case-insensitive way."""
log.debug("Finding an authenticator for {0}".format(header))
scheme, elements = header.split(' ', 1)
for fact in self._credentialFactories:
if fact.scheme.lower() == scheme.lower():
log.debug("Found an authenticator: {0}".format(fact))
return (fact, elements)
log.debug("No matching authenticator found for {0}".format(scheme))
return (None, None)
def setUp(self):
log.debug("Setting up junk site.")
site = JunkSite(self.chunkSize)
self.junkServer = reactor.listenTCP(self.http_port, site, interface=self._lo0)
log.debug("Junk site is listening.")
def write(self, data):
log.debug("Writing %r" % data)
return self.transport.write(data)
def render_GET(self, request):
log.debug("%r rendering %d bytes for %r" % (self, self.size, request))
d = self._writeJunk(request)
return NOT_DONE_YET
def _test_getJunks(self, count, size, suffix):
log.debug("Waiting for %d responses." % count)
return gatherResults([self._test_getJunk(size, suffix) for i in xrange(0, count)])
def _test_getJunk(self, size, suffix):
url = "%s/%d.%s" % (self._baseURL, size, suffix)
log.debug("Getting junk: %s" % url)
count = yield self.getPageLength(url)
bytes = normalizeBytes(size, suffix)
self.assertEquals(bytes, count)
def writeSequence(self, seq):
log.debug("Writing %r" % str().join(seq))
return self.transport.writeSequence(seq)
def process(self):
yield self._waitToProcess()
log.debug("Rendering: %r" % self)
server.Request.process(self)
def write(self, data):
log.debug("%r writing %r" % (self, data))
return server.Request.write(self, data)
def tearDown(self):
log.debug("Tearing down junk site.")
return self.junkServer.stopListening()
def tearDown(self):
log.debug("Tearing down md5 site.")
yield PendrellTestMixin.tearDown(self)
yield self.md5Server.stopListening()