def test_protocolToConsumer(self):
"""
L{IProtocol} providers can be adapted to L{IConsumer} providers using
L{ProtocolToConsumerAdapter}.
"""
result = []
p = Protocol()
p.dataReceived = result.append
consumer = IConsumer(p)
consumer.write(b"hello")
self.assertEqual(result, [b"hello"])
self.assertIsInstance(consumer, ProtocolToConsumerAdapter)
def test_protocolToConsumer(self):
"""
L{IProtocol} providers can be adapted to L{IConsumer} providers using
L{ProtocolToConsumerAdapter}.
"""
result = []
p = Protocol()
p.dataReceived = result.append
consumer = IConsumer(p)
consumer.write(b"hello")
self.assertEqual(result, [b"hello"])
self.assertIsInstance(consumer, ProtocolToConsumerAdapter)
def download(self, consumer=None, offset=0, size=None):
assert IConsumer.providedBy(consumer) or self._verify
if consumer:
self._consumer = consumer
# we provide IPushProducer, so streaming=True, per
# IConsumer.
self._consumer.registerProducer(self, streaming=True)
self._done_deferred = defer.Deferred()
self._offset = offset
self._read_length = size
self._setup_download()
self._setup_encoding_parameters()
self.log("starting download")
self._started_fetching = time.time()
# The download process beyond this is a state machine.
# _add_active_peers will select the peers that we want to use
# for the download, and then attempt to start downloading. After
# each segment, it will check for doneness, reacting to broken
# peers and corrupt shares as necessary. If it runs out of good
# peers before downloading all of the segments, _done_deferred
# will errback. Otherwise, it will eventually callback with the
# contents of the mutable file.
self.loop()
return self._done_deferred
def download(self, consumer=None, offset=0, size=None):
assert IConsumer.providedBy(consumer) or self._verify
if consumer:
self._consumer = consumer
# we provide IPushProducer, so streaming=True, per
# IConsumer.
self._consumer.registerProducer(self, streaming=True)
self._done_deferred = defer.Deferred()
self._offset = offset
self._read_length = size
self._setup_encoding_parameters()
self._setup_download()
self.log("starting download")
self._started_fetching = time.time()
# The download process beyond this is a state machine.
# _add_active_servers will select the servers that we want to use
# for the download, and then attempt to start downloading. After
# each segment, it will check for doneness, reacting to broken
# servers and corrupt shares as necessary. If it runs out of good
# servers before downloading all of the segments, _done_deferred
# will errback. Otherwise, it will eventually callback with the
# contents of the mutable file.
self.loop()
return self._done_deferred
def __init__(self, consumer):
self.consumer = consumer
assert IConsumer.implementedBy(consumer.__class__)
self._producers = []
self._sendingLock = DeferredLock()
self._localHeaderLength = 0
self._centralDirectoryLength = 0
def registerConsumer(self, consumer):
"""
How could we push to a consumer without knowing what it is?
"""
if not IConsumer.providedBy(consumer):
raise errors.ImplementationError(
"Object {} isn't a consumer".format(repr(consumer)))
try:
consumer.registerProducer(self, True)
except RuntimeError:
# Ignore any exception raised from a consumer already
# having registered me.
pass
self.consumer = consumer
def processResource(self, resource):
if not isinstance(resource, DeferredResource):
resource = getChildForRequest(resource, self)
if isinstance(resource, DeferredResource):
resource.d.addCallback(self.processResource).addErrback(
self.processingFailed)
else:
self.resource = self._getRealResource(resource)
if IConsumer.providedBy(self.resource):
self.resource.registerProducer(self.channel.transport, True)
self.render(resource) # use resource here to not break proxies
else:
self._fallbackToBuffered = True
# resource is determined, resume producing
self.channel.transport.resumeProducing()
def processResource(self, resource):
if not isinstance(resource, DeferredResource):
resource = getChildForRequest(resource, self)
if isinstance(resource, DeferredResource):
resource.d.addCallback(self.processResource).addErrback(
self.processingFailed)
else:
self.resource = self._getRealResource(resource)
if IConsumer.providedBy(self.resource):
self.resource.registerProducer(self.channel.transport, True)
self.render(resource) # use resource here to not break proxies
else:
self._fallbackToBuffered = True
# resource is determined, resume producing
self.channel.transport.resumeProducing()
def __init__(self, consumer, N, streaming, minInterval, maxInterval=None):
"""
Constructs an instance of me to produce a range of I{N} integer
values with the specified I{interval} between them.
"""
if not IConsumer.providedBy(consumer):
raise errors.ImplementationError(
"Object {} isn't a consumer".format(repr(consumer)))
self.produce = False
self.minInterval = minInterval
self.maxInterval = maxInterval
self.consumer = consumer
self.k, self.N = 0, N
self.streaming = streaming
self.t0 = time.time()
self.d = defer.Deferred()
if streaming:
self.resumeProducing()
consumer.registerProducer(self, streaming)
def download(self, consumer=None, offset=0, size=None):
precondition(self._verify or IConsumer.providedBy(consumer))
if size is None:
size = self._data_length - offset
if self._verify:
_assert(size == self._data_length, (size, self._data_length))
self.log("starting download")
self._done_deferred = defer.Deferred()
if consumer:
self._consumer = consumer
# we provide IPushProducer, so streaming=True, per IConsumer.
self._consumer.registerProducer(self, streaming=True)
self._started = time.time()
self._started_fetching = time.time()
if size == 0:
# short-circuit the rest of the process
self._done()
else:
self._start_download(consumer, offset, size)
return self._done_deferred
def download(self, consumer=None, offset=0, size=None):
precondition(self._verify or IConsumer.providedBy(consumer))
if size is None:
size = self._data_length - offset
if self._verify:
_assert(size == self._data_length, (size, self._data_length))
self.log("starting download")
self._done_deferred = defer.Deferred()
if consumer:
self._consumer = consumer
# we provide IPushProducer, so streaming=True, per IConsumer.
self._consumer.registerProducer(self, streaming=True)
self._started = time.time()
self._started_fetching = time.time()
if size == 0:
# short-circuit the rest of the process
self._done()
else:
self._start_download(consumer, offset, size)
return self._done_deferred
def startProducing(self, consumer: IConsumer) -> Deferred:
consumer.write(self._data)
return succeed(None)
def receive(self):
"""
Return an consumer object able to write the data.
"""
return defer.succeed(IConsumer(self.node))
def registerConsumer(self, consumer):
'''
This is not really part of the IPushProducer interface
'''
self._consumer = IConsumer(consumer)
