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