Changeset 0d0dd4d in trunk


Ignore:
Timestamp:
2021-03-31T14:35:25Z (4 years ago)
Author:
Itamar Turner-Trauring <itamar@…>
Branches:
master
Children:
cf63a3a
Parents:
69ece36
Message:

Rip out all references to the unused IProgress API.

Location:
src/allmydata
Files:
1 deleted
12 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified src/allmydata/blacklist.py

    r69ece36 r0d0dd4d  
    143143        raise FileProhibited(self.reason)
    144144
    145     def download_best_version(self, progress=None):
     145    def download_best_version(self):
    146146        raise FileProhibited(self.reason)
    147147

  • TabularUnified src/allmydata/dirnode.py

    r69ece36 r0d0dd4d  
    647647
    648648
    649     def add_file(self, namex, uploadable, metadata=None, overwrite=True, progress=None):
     649    def add_file(self, namex, uploadable, metadata=None, overwrite=True):
    650650        """I upload a file (using the given IUploadable), then attach the
    651651        resulting FileNode to the directory at the given name. I return a
    … …  
    658658            else:
    659659                # XXX should pass reactor arg
    660                 d = DeferredContext(self._uploader.upload(uploadable, progress=progress))
     660                d = DeferredContext(self._uploader.upload(uploadable))
    661661                d.addCallback(lambda results:
    662662                              self._create_and_validate_node(results.get_uri(), None,

  • TabularUnified src/allmydata/immutable/encode.py

    r69ece36 r0d0dd4d  
    9191class Encoder(object):
    9292
    93     def __init__(self, log_parent=None, upload_status=None, progress=None):
     93    def __init__(self, log_parent=None, upload_status=None):
    9494        object.__init__(self)
    9595        self.uri_extension_data = {}
    … …  
    103103                                   facility="tahoe.encoder", parent=log_parent)
    104104        self._aborted = False
    105         self._progress = progress
    106105
    107106    def __repr__(self):
    … …  
    124123            self.log(format="file size: %(size)d", size=size)
    125124            self.file_size = size
    126             if self._progress:
    127                 self._progress.set_progress_total(self.file_size)
    128125        d.addCallback(_got_size)
    129126        d.addCallback(lambda res: eu.get_all_encoding_parameters())
    … …  
    462459
    463460        dl = self._gather_responses(dl)
    464 
    465         def do_progress(ign):
    466             done = self.segment_size * (segnum + 1)
    467             if self._progress:
    468                 self._progress.set_progress(done)
    469             return ign
    470         dl.addCallback(do_progress)
    471461
    472462        def _logit(res):

  • TabularUnified src/allmydata/immutable/filenode.py

    r69ece36 r0d0dd4d  
    338338        return defer.succeed(self)
    339339
    340     def download_best_version(self, progress=None):
     340    def download_best_version(self):
    341341        """
    342342        Download the best version of this file, returning its contents
    … …  
    344344        file, we download and return the contents of this file.
    345345        """
    346         d = consumer.download_to_data(self, progress=progress)
     346        d = consumer.download_to_data(self)
    347347        return d
    348348

  • TabularUnified src/allmydata/immutable/literal.py

    r69ece36 r0d0dd4d  
    114114
    115115
    116     def download_best_version(self, progress=None):
    117         if progress is not None:
    118             progress.set_progress_total(len(self.u.data))
    119             progress.set_progress(len(self.u.data))
     116    def download_best_version(self):
    120117        return defer.succeed(self.u.data)
    121118

  • TabularUnified src/allmydata/immutable/offloaded.py

    r69ece36 r0d0dd4d  
    155155                 helper, storage_broker, secret_holder,
    156156                 incoming_file, encoding_file,
    157                  log_number, progress=None):
    158         upload.CHKUploader.__init__(self, storage_broker, secret_holder, progress=progress)
     157                 log_number):
     158        upload.CHKUploader.__init__(self, storage_broker, secret_holder)
    159159        self._storage_index = storage_index
    160160        self._helper = helper

  • TabularUnified src/allmydata/immutable/upload.py

    r69ece36 r0d0dd4d  
    4949     IEncryptedUploadable, RIEncryptedUploadable, IUploadStatus, \
    5050     NoServersError, InsufficientVersionError, UploadUnhappinessError, \
    51      DEFAULT_MAX_SEGMENT_SIZE, IProgress, IPeerSelector
     51     DEFAULT_MAX_SEGMENT_SIZE, IPeerSelector
    5252from allmydata.immutable import layout
    5353
    … …  
    946946    CHUNKSIZE = 50*1024
    947947
    948     def __init__(self, original, log_parent=None, progress=None, chunk_size=None):
     948    def __init__(self, original, log_parent=None, chunk_size=None):
    949949        """
    950950        :param chunk_size: The number of bytes to read from the uploadable at a
    … …  
    963963        self._ciphertext_bytes_read = 0
    964964        self._status = None
    965         self._progress = progress
    966965        if chunk_size is not None:
    967966            self.CHUNKSIZE = chunk_size
    … …  
    986985            if self._status:
    987986                self._status.set_size(size)
    988             if self._progress:
    989                 self._progress.set_progress_total(size)
    990987            return size
    991988        d.addCallback(_got_size)
    … …  
    12301227class CHKUploader(object):
    12311228
    1232     def __init__(self, storage_broker, secret_holder, progress=None, reactor=None):
     1229    def __init__(self, storage_broker, secret_holder, reactor=None):
    12331230        # server_selector needs storage_broker and secret_holder
    12341231        self._storage_broker = storage_broker
    … …  
    12401237        self._upload_status.set_helper(False)
    12411238        self._upload_status.set_active(True)
    1242         self._progress = progress
    12431239        self._reactor = reactor
    12441240
    … …  
    12951291            self._log_number,
    12961292            self._upload_status,
    1297             progress=self._progress,
    12981293        )
    12991294        # this just returns itself
    … …  
    14291424class LiteralUploader(object):
    14301425
    1431     def __init__(self, progress=None):
     1426    def __init__(self):
    14321427        self._status = s = UploadStatus()
    14331428        s.set_storage_index(None)
    … …  
    14351430        s.set_progress(0, 1.0)
    14361431        s.set_active(False)
    1437         self._progress = progress
    14381432
    14391433    def start(self, uploadable):
    … …  
    14431437            self._size = size
    14441438            self._status.set_size(size)
    1445             if self._progress:
    1446                 self._progress.set_progress_total(size)
    14471439            return read_this_many_bytes(uploadable, size)
    14481440        d.addCallback(_got_size)
    … …  
    14681460        self._status.set_progress(2, 1.0)
    14691461        self._status.set_results(ur)
    1470         if self._progress:
    1471             self._progress.set_progress(self._size)
    14721462        return ur
    14731463
    … …  
    18681858    URI_LIT_SIZE_THRESHOLD = 55
    18691859
    1870     def __init__(self, helper_furl=None, stats_provider=None, history=None, progress=None):
     1860    def __init__(self, helper_furl=None, stats_provider=None, history=None):
    18711861        self._helper_furl = helper_furl
    18721862        self.stats_provider = stats_provider
    … …  
    18741864        self._helper = None
    18751865        self._all_uploads = weakref.WeakKeyDictionary() # for debugging
    1876         self._progress = progress
    18771866        log.PrefixingLogMixin.__init__(self, facility="tahoe.immutable.upload")
    18781867        service.MultiService.__init__(self)
    … …  
    19081897
    19091898
    1910     def upload(self, uploadable, progress=None, reactor=None):
     1899    def upload(self, uploadable, reactor=None):
    19111900        """
    19121901        Returns a Deferred that will fire with the UploadResults instance.
    … …  
    19141903        assert self.parent
    19151904        assert self.running
    1916         assert progress is None or IProgress.providedBy(progress)
    19171905
    19181906        uploadable = IUploadable(uploadable)
    … …  
    19231911            precondition("max_segment_size" in default_params, default_params)
    19241912            uploadable.set_default_encoding_parameters(default_params)
    1925             if progress:
    1926                 progress.set_progress_total(size)
    19271913
    19281914            if self.stats_provider:
    … …  
    19311917
    19321918            if size <= self.URI_LIT_SIZE_THRESHOLD:
    1933                 uploader = LiteralUploader(progress=progress)
     1919                uploader = LiteralUploader()
    19341920                return uploader.start(uploadable)
    19351921            else:
    … …  
    19441930                    storage_broker = self.parent.get_storage_broker()
    19451931                    secret_holder = self.parent._secret_holder
    1946                     uploader = CHKUploader(storage_broker, secret_holder, progress=progress, reactor=reactor)
     1932                    uploader = CHKUploader(storage_broker, secret_holder, reactor=reactor)
    19471933                    d2.addCallback(lambda x: uploader.start(eu))
    19481934

  • TabularUnified src/allmydata/interfaces.py

    r69ece36 r0d0dd4d  
    734734
    735735
    736 class IProgress(Interface):
    737     """
    738     Remembers progress measured in arbitrary units. Users of these
    739     instances must call ``set_progress_total`` at least once before
    740     progress can be valid, and must use the same units for both
    741     ``set_progress_total`` and ``set_progress calls``.
    742 
    743     See also:
    744     :class:`allmydata.util.progress.PercentProgress`
    745     """
    746 
    747     progress = Attribute(
    748         "Current amount of progress (in percentage)"
    749     )
    750 
    751     def set_progress(value):
    752         """
    753         Sets the current amount of progress.
    754 
    755         Arbitrary units, but must match units used for
    756         set_progress_total.
    757         """
    758 
    759     def set_progress_total(value):
    760         """
    761         Sets the total amount of expected progress
    762 
    763         Arbitrary units, but must be same units as used when calling
    764         set_progress() on this instance)..
    765         """
    766 
    767 
    768736class IReadable(Interface):
    769737    """I represent a readable object -- either an immutable file, or a
    … …  
    795763        """Return the length (in bytes) of this readable object."""
    796764
    797     def download_to_data(progress=None):
     765    def download_to_data():
    798766        """Download all of the file contents. I return a Deferred that fires
    799767        with the contents as a byte string.
    800 
    801         :param progress: None or IProgress implementer
    802768        """
    803769
    … …  
    11071073        """
    11081074
    1109     def download_best_version(progress=None):
     1075    def download_best_version():
    11101076        """Download the contents of the version that would be returned
    11111077        by get_best_readable_version(). This is equivalent to calling
    11121078        download_to_data() on the IReadable given by that method.
    1113 
    1114         progress is anything that implements IProgress
    11151079
    11161080        I return a Deferred that fires with a byte string when the file
    … …  
    12591223        """
    12601224
    1261     def upload(new_contents, servermap, progress=None):
     1225    def upload(new_contents, servermap):
    12621226        """Replace the contents of the file with new ones. This requires a
    12631227        servermap that was previously updated with MODE_WRITE.
    … …  
    12801244        able to write the new version without incident.
    12811245
    1282         ``progress`` is either None or an IProgress provider
    1283 
    12841246        I return a Deferred that fires (with a PublishStatus object) when the
    12851247        publish has completed. I will update the servermap in-place with the
    … …  
    14721434        efficient."""
    14731435
    1474     def add_file(name, uploadable, metadata=None, overwrite=True, progress=None):
     1436    def add_file(name, uploadable, metadata=None, overwrite=True):
    14751437        """I upload a file (using the given IUploadable), then attach the
    14761438        resulting ImmutableFileNode to the directory at the given name. I set
    14771439        metadata the same way as set_uri and set_node. The child name must be
    14781440        a unicode string.
    1479 
    1480         ``progress`` either provides IProgress or is None
    14811441
    14821442        I return a Deferred that fires (with the IFileNode of the uploaded

  • TabularUnified src/allmydata/mutable/filenode.py

    r69ece36 r0d0dd4d  
    419419
    420420
    421     def download_best_version(self, progress=None):
     421    def download_best_version(self):
    422422        """
    423423        I return a Deferred that fires with the contents of the best
    424424        version of this mutable file.
    425425        """
    426         return self._do_serialized(self._download_best_version, progress=progress)
    427 
    428 
    429     def _download_best_version(self, progress=None):
     426        return self._do_serialized(self._download_best_version)
     427
     428
     429    def _download_best_version(self):
    430430        """
    431431        I am the serialized sibling of download_best_version.
    … …  
    433433        d = self.get_best_readable_version()
    434434        d.addCallback(self._record_size)
    435         d.addCallback(lambda version: version.download_to_data(progress=progress))
     435        d.addCallback(lambda version: version.download_to_data())
    436436
    437437        # It is possible that the download will fail because there
    … …  
    448448            d = self.get_best_mutable_version()
    449449            d.addCallback(self._record_size)
    450             d.addCallback(lambda version: version.download_to_data(progress=progress))
     450            d.addCallback(lambda version: version.download_to_data())
    451451            return d
    452452
    … …  
    565565
    566566
    567     def upload(self, new_contents, servermap, progress=None):
     567    def upload(self, new_contents, servermap):
    568568        """
    569569        I overwrite the contents of the best recoverable version of this
    … …  
    952952
    953953
    954     def download_to_data(self, fetch_privkey=False, progress=None):  # type: ignore # fixme
     954    def download_to_data(self, fetch_privkey=False):  # type: ignore # fixme
    955955        """
    956956        I return a Deferred that fires with the contents of this
    … …  
    958958
    959959        """
    960         c = consumer.MemoryConsumer(progress=progress)
     960        c = consumer.MemoryConsumer()
    961961        d = self.read(c, fetch_privkey=fetch_privkey)
    962962        d.addCallback(lambda mc: b"".join(mc.chunks))

  • TabularUnified src/allmydata/test/common.py

    r69ece36 r0d0dd4d  
    540540
    541541
    542     def download_to_data(self, progress=None):
    543         return download_to_data(self, progress=progress)
     542    def download_to_data(self):
     543        return download_to_data(self)
    544544
    545545
    … …  
    718718        return d
    719719
    720     def download_best_version(self, progress=None):
    721         return defer.succeed(self._download_best_version(progress=progress))
    722 
    723 
    724     def _download_best_version(self, ignored=None, progress=None):
     720    def download_best_version(self):
     721        return defer.succeed(self._download_best_version())
     722
     723
     724    def _download_best_version(self, ignored=None):
    725725        if isinstance(self.my_uri, uri.LiteralFileURI):
    726726            return self.my_uri.data

  • TabularUnified src/allmydata/test/test_dirnode.py

    r69ece36 r0d0dd4d  
    15931593        return self.uri.to_string()
    15941594
    1595     def download_best_version(self, progress=None):
     1595    def download_best_version(self):
    15961596        return defer.succeed(self.data)
    15971597

  • TabularUnified src/allmydata/util/consumer.py

    r69ece36 r0d0dd4d  
    1010class MemoryConsumer(object):
    1111
    12     def __init__(self, progress=None):
     12    def __init__(self):
    1313        self.chunks = []
    1414        self.done = False
    15         self._progress = progress
    1615
    1716    def registerProducer(self, p, streaming):
    … …  
    2625    def write(self, data):
    2726        self.chunks.append(data)
    28         if self._progress is not None:
    29             self._progress.set_progress(sum([len(c) for c in self.chunks]))
    3027
    3128    def unregisterProducer(self):
    3229        self.done = True
    3330
    34 def download_to_data(n, offset=0, size=None, progress=None):
     31def download_to_data(n, offset=0, size=None):
    3532    """
    36     :param progress: None or an IProgress implementer
     33    Return Deferred that fires with results of reading from the given filenode.
    3734    """
    38     d = n.read(MemoryConsumer(progress=progress), offset, size)
     35    d = n.read(MemoryConsumer(), offset, size)
    3936    d.addCallback(lambda mc: b"".join(mc.chunks))
    4037    return d
Note: See TracChangeset for help on using the changeset viewer.