Ticket #778: behavior.txt

Wed Sep 23 21:19:32 PDT 2009  Kevan Carstensen <kevan@isnotajoke.com>
  * Alter CiphertextDownloader to work with servers_of_happiness

Tue Nov  3 19:32:41 PST 2009  Kevan Carstensen <kevan@isnotajoke.com>
  * Alter the signature of set_shareholders in IEncoder to add a 'servermap' parameter, which gives IEncoders enough information to perform a sane check for servers_of_happiness.

Wed Nov  4 03:12:22 PST 2009  Kevan Carstensen <kevan@isnotajoke.com>
  * Alter 'immutable/encode.py' and 'immutable/upload.py' to use servers_of_happiness instead of shares_of_happiness.

Mon Nov 16 11:28:05 PST 2009  Kevan Carstensen <kevan@isnotajoke.com>
  * Alter Tahoe2PeerSelector to make sure that it recognizes existing shares on readonly servers, fixing an issue in #778

Mon Nov 16 13:24:59 PST 2009  Kevan Carstensen <kevan@isnotajoke.com>
  * Change stray "shares_of_happiness" to "servers_of_happiness"

Tue Nov 17 17:45:42 PST 2009  Kevan Carstensen <kevan@isnotajoke.com>
  * Eliminate overcounting iof servers_of_happiness in Tahoe2PeerSelector; also reorganize some things.

Sun Nov 22 16:24:05 PST 2009  Kevan Carstensen <kevan@isnotajoke.com>
  * Alter the error message returned when peer selection fails
  
  The Tahoe2PeerSelector returned either NoSharesError or NotEnoughSharesError
  for a variety of error conditions that weren't informatively described by them.
  This patch creates a new error, UploadHappinessError, replaces uses of 
  NoSharesError and NotEnoughSharesError with it, and alters the error message
  raised with the errors to be more in line with the new servers_of_happiness
  behavior. See ticket #834 for more information.

Fri Dec  4 20:30:37 PST 2009  Kevan Carstensen <kevan@isnotajoke.com>
  * Change "UploadHappinessError" to "UploadUnhappinessError"

Wed Dec 30 13:03:44 PST 2009  Kevan Carstensen <kevan@isnotajoke.com>
  * Alter the error message when an upload fails, per some comments in #778.
  
  When I first implemented #778, I just altered the error messages to refer to
  servers where they referred to shares. The resulting error messages weren't
  very good. These are a bit better.

Mon Feb 15 12:22:14 PST 2010  Kevan Carstensen <kevan@isnotajoke.com>
  * Fix up the behavior of #778, per reviewers' comments
  
    - Make some important utility functions clearer and more thoroughly 
      documented.
    - Assert in upload.servers_of_happiness that the buckets attributes
      of PeerTrackers passed to it are mutually disjoint.
    - Get rid of some silly non-Pythonisms that I didn't see when I first
      wrote these patches.
    - Make sure that should_add_server returns true when queried about a 
      shnum that it doesn't know about yet.
    - Change Tahoe2PeerSelector.preexisting_shares to map a shareid to a set
      of peerids, alter dependencies to deal with that.
    - Remove upload.should_add_servers, because it is no longer necessary
    - Move upload.shares_of_happiness and upload.shares_by_server to a utility
      file.
    - Change some points in Tahoe2PeerSelector.
    - Compute servers_of_happiness using a bipartite matching algorithm that 
      we know is optimal instead of an ad-hoc greedy algorithm that isn't.
    - Change servers_of_happiness to just take a sharemap as an argument,
      change its callers to merge existing_shares and used_peers before 
      calling it.
    - Change an error message in the encoder to be more appropriate for 
      servers of happiness.
  

New patches:

[Alter CiphertextDownloader to work with servers_of_happiness
Kevan Carstensen <kevan@isnotajoke.com>**20090924041932
 Ignore-this: e81edccf0308c2d3bedbc4cf217da197
] hunk ./src/allmydata/immutable/download.py 1039
             # Repairer (uploader) needs the encodingparams.
             self._target.set_encodingparams((
                 self._verifycap.needed_shares,
-                self._verifycap.total_shares, # I don't think the target actually cares about "happy".
+                0, # see ticket #778 for why this is
                 self._verifycap.total_shares,
                 self._vup.segment_size
                 ))
[Alter the signature of set_shareholders in IEncoder to add a 'servermap' parameter, which gives IEncoders enough information to perform a sane check for servers_of_happiness.
Kevan Carstensen <kevan@isnotajoke.com>**20091104033241
 Ignore-this: b3a6649a8ac66431beca1026a31fed94
] {
hunk ./src/allmydata/interfaces.py 1341
         Once this is called, set_size() and set_params() may not be called.
         """
 
-    def set_shareholders(shareholders):
+    def set_shareholders(shareholders, servermap):
         """Tell the encoder where to put the encoded shares. 'shareholders'
         must be a dictionary that maps share number (an integer ranging from
hunk ./src/allmydata/interfaces.py 1344
-        0 to n-1) to an instance that provides IStorageBucketWriter. This
-        must be performed before start() can be called."""
+        0 to n-1) to an instance that provides IStorageBucketWriter.
+        'servermap' is a dictionary that maps share number (as defined above)
+        to a peerid. This must be performed before start() can be called."""
 
     def start():
         """Begin the encode/upload process. This involves reading encrypted
}
[Alter 'immutable/encode.py' and 'immutable/upload.py' to use servers_of_happiness instead of shares_of_happiness.
Kevan Carstensen <kevan@isnotajoke.com>**20091104111222
 Ignore-this: abb3283314820a8bbf9b5d0cbfbb57c8
] {
hunk ./src/allmydata/immutable/encode.py 121
         assert not self._codec
         k, happy, n, segsize = params
         self.required_shares = k
-        self.shares_of_happiness = happy
+        self.servers_of_happiness = happy
         self.num_shares = n
         self.segment_size = segsize
         self.log("got encoding parameters: %d/%d/%d %d" % (k,happy,n, segsize))
hunk ./src/allmydata/immutable/encode.py 179
         if name == "storage_index":
             return self._storage_index
         elif name == "share_counts":
-            return (self.required_shares, self.shares_of_happiness,
+            return (self.required_shares, self.servers_of_happiness,
                     self.num_shares)
         elif name == "num_segments":
             return self.num_segments
hunk ./src/allmydata/immutable/encode.py 194
         else:
             raise KeyError("unknown parameter name '%s'" % name)
 
-    def set_shareholders(self, landlords):
+    def set_shareholders(self, landlords, servermap):
         assert isinstance(landlords, dict)
         for k in landlords:
             assert IStorageBucketWriter.providedBy(landlords[k])
hunk ./src/allmydata/immutable/encode.py 199
         self.landlords = landlords.copy()
+        assert isinstance(servermap, dict)
+        self.servermap = servermap.copy()
 
     def start(self):
         """ Returns a Deferred that will fire with the verify cap (an instance of
hunk ./src/allmydata/immutable/encode.py 491
             # even more UNUSUAL
             self.log("they weren't in our list of landlords", parent=ln,
                      level=log.WEIRD, umid="TQGFRw")
-        if len(self.landlords) < self.shares_of_happiness:
-            msg = "lost too many shareholders during upload (still have %d, want %d): %s" % \
-                  (len(self.landlords), self.shares_of_happiness, why)
-            if self.landlords:
+        del(self.servermap[shareid])
+        servers_left = list(set(self.servermap.values()))
+        if len(servers_left) < self.servers_of_happiness:
+            msg = "lost too many servers during upload (still have %d, want %d): %s" % \
+                  (len(servers_left),
+                   self.servers_of_happiness, why)
+            if servers_left:
                 raise NotEnoughSharesError(msg)
             else:
                 raise NoSharesError(msg)
hunk ./src/allmydata/immutable/encode.py 502
         self.log("but we can still continue with %s shares, we'll be happy "
-                 "with at least %s" % (len(self.landlords),
-                                       self.shares_of_happiness),
+                 "with at least %s" % (len(servers_left),
+                                       self.servers_of_happiness),
                  parent=ln)
 
     def _gather_responses(self, dl):
hunk ./src/allmydata/immutable/upload.py 131
         self.buckets.update(b)
         return (alreadygot, set(b.keys()))
 
+def servers_with_shares(existing_shares, used_peers=None):
+    servers = []
+    if used_peers:
+        peers = list(used_peers.copy())
+        # We do this because the preexisting shares list goes by peerid.
+        peers = [x.peerid for x in peers]
+        servers.extend(peers)
+    servers.extend(existing_shares.values())
+    return list(set(servers))
+
+def shares_by_server(existing_shares):
+    servers = {}
+    for server in set(existing_shares.values()):
+        servers[server] = set([x for x in existing_shares.keys()
+                               if existing_shares[x] == server])
+    return servers
+
 class Tahoe2PeerSelector:
 
     def __init__(self, upload_id, logparent=None, upload_status=None):
hunk ./src/allmydata/immutable/upload.py 164
 
     def get_shareholders(self, storage_broker, secret_holder,
                          storage_index, share_size, block_size,
-                         num_segments, total_shares, shares_of_happiness):
+                         num_segments, total_shares, servers_of_happiness):
         """
         @return: (used_peers, already_peers), where used_peers is a set of
                  PeerTracker instances that have agreed to hold some shares
hunk ./src/allmydata/immutable/upload.py 177
             self._status.set_status("Contacting Peers..")
 
         self.total_shares = total_shares
-        self.shares_of_happiness = shares_of_happiness
+        self.servers_of_happiness = servers_of_happiness
 
         self.homeless_shares = range(total_shares)
         # self.uncontacted_peers = list() # peers we haven't asked yet
hunk ./src/allmydata/immutable/upload.py 242
         d = defer.maybeDeferred(self._loop)
         return d
 
+
     def _loop(self):
         if not self.homeless_shares:
hunk ./src/allmydata/immutable/upload.py 245
-            # all done
-            msg = ("placed all %d shares, "
-                   "sent %d queries to %d peers, "
-                   "%d queries placed some shares, %d placed none, "
-                   "got %d errors" %
-                   (self.total_shares,
-                    self.query_count, self.num_peers_contacted,
-                    self.good_query_count, self.bad_query_count,
-                    self.error_count))
-            log.msg("peer selection successful for %s: %s" % (self, msg),
+            effective_happiness = servers_with_shares(
+                                                   self.preexisting_shares,
+                                                   self.use_peers)
+            if self.servers_of_happiness <= len(effective_happiness):
+                msg = ("placed all %d shares, "
+                       "sent %d queries to %d peers, "
+                       "%d queries placed some shares, %d placed none, "
+                       "got %d errors" %
+                       (self.total_shares,
+                        self.query_count, self.num_peers_contacted,
+                        self.good_query_count, self.bad_query_count,
+                        self.error_count))
+                log.msg("peer selection successful for %s: %s" % (self, msg),
                     parent=self._log_parent)
hunk ./src/allmydata/immutable/upload.py 259
-            return (self.use_peers, self.preexisting_shares)
+                return (self.use_peers, self.preexisting_shares)
+            else:
+                delta = self.servers_of_happiness - len(effective_happiness)
+                shares = shares_by_server(self.preexisting_shares)
+                # Each server in shares maps to a set of shares stored on it.
+                # Since we want to keep at least one share on each server 
+                # that has one (otherwise we'd only be making
+                # the situation worse by removing distinct servers),
+                # each server has len(its shares) - 1 to spread around.
+                shares_to_spread = sum([len(list(sharelist)) - 1
+                                        for (server, sharelist)
+                                        in shares.items()])
+                if delta <= len(self.uncontacted_peers) and \
+                   shares_to_spread >= delta:
+                    # Loop through the allocated shares, removing 
+                    items = shares.items()
+                    while len(self.homeless_shares) < delta:
+                        servernum, sharelist = items.pop()
+                        if len(sharelist) > 1:
+                            share = sharelist.pop()
+                            self.homeless_shares.append(share)
+                            del(self.preexisting_shares[share])
+                            items.append((servernum, sharelist))
+                    return self._loop()
+                else:
+                    raise NotEnoughSharesError("shares could only be placed on %d "
+                                            "servers (%d were requested)" %
+                                            (len(effective_happiness),
+                                             self.servers_of_happiness))
 
         if self.uncontacted_peers:
             peer = self.uncontacted_peers.pop(0)
hunk ./src/allmydata/immutable/upload.py 336
         else:
             # no more peers. If we haven't placed enough shares, we fail.
             placed_shares = self.total_shares - len(self.homeless_shares)
-            if placed_shares < self.shares_of_happiness:
+            effective_happiness = servers_with_shares(
+                                                   self.preexisting_shares,
+                                                   self.use_peers)
+            if len(effective_happiness) < self.servers_of_happiness:
                 msg = ("placed %d shares out of %d total (%d homeless), "
hunk ./src/allmydata/immutable/upload.py 341
-                       "want to place %d, "
+                       "want to place on %d servers, "
                        "sent %d queries to %d peers, "
                        "%d queries placed some shares, %d placed none, "
                        "got %d errors" %
hunk ./src/allmydata/immutable/upload.py 347
                        (self.total_shares - len(self.homeless_shares),
                         self.total_shares, len(self.homeless_shares),
-                        self.shares_of_happiness,
+                        self.servers_of_happiness,
                         self.query_count, self.num_peers_contacted,
                         self.good_query_count, self.bad_query_count,
                         self.error_count))
hunk ./src/allmydata/immutable/upload.py 394
                     level=log.NOISY, parent=self._log_parent)
             progress = False
             for s in alreadygot:
+                if self.preexisting_shares.has_key(s):
+                    old_size = len(servers_with_shares(self.preexisting_shares))
+                    new_candidate = self.preexisting_shares.copy()
+                    new_candidate[s] = peer.peerid
+                    new_size = len(servers_with_shares(new_candidate))
+                    if old_size >= new_size: continue
                 self.preexisting_shares[s] = peer.peerid
                 if s in self.homeless_shares:
                     self.homeless_shares.remove(s)
hunk ./src/allmydata/immutable/upload.py 825
         for peer in used_peers:
             assert isinstance(peer, PeerTracker)
         buckets = {}
+        servermap = already_peers.copy()
         for peer in used_peers:
             buckets.update(peer.buckets)
             for shnum in peer.buckets:
hunk ./src/allmydata/immutable/upload.py 830
                 self._peer_trackers[shnum] = peer
+                servermap[shnum] = peer.peerid
         assert len(buckets) == sum([len(peer.buckets) for peer in used_peers])
hunk ./src/allmydata/immutable/upload.py 832
-        encoder.set_shareholders(buckets)
+        encoder.set_shareholders(buckets, servermap)
 
     def _encrypted_done(self, verifycap):
         """ Returns a Deferred that will fire with the UploadResults instance. """
replace ./src/allmydata/immutable/upload.py [A-Za-z_0-9] _servers_with_shares _servers_with_unique_shares
replace ./src/allmydata/immutable/upload.py [A-Za-z_0-9] servers_with_shares servers_with_unique_shares
}
[Alter Tahoe2PeerSelector to make sure that it recognizes existing shares on readonly servers, fixing an issue in #778
Kevan Carstensen <kevan@isnotajoke.com>**20091116192805
 Ignore-this: 15289f4d709e03851ed0587b286fd955
] {
hunk ./src/allmydata/immutable/upload.py 117
         d.addCallback(self._got_reply)
         return d
 
+    def query_allocated(self):
+        d = self._storageserver.callRemote("get_buckets",
+                                           self.storage_index)
+        d.addCallback(self._got_allocate_reply)
+        return d
+
+    def _got_allocate_reply(self, buckets):
+        return (self.peerid, buckets)
+
     def _got_reply(self, (alreadygot, buckets)):
         #log.msg("%s._got_reply(%s)" % (self, (alreadygot, buckets)))
         b = {}
hunk ./src/allmydata/immutable/upload.py 195
         self._started_second_pass = False
         self.use_peers = set() # PeerTrackers that have shares assigned to them
         self.preexisting_shares = {} # sharenum -> peerid holding the share
+        # We don't try to allocate shares to these servers, since they've 
+        # said that they're incapable of storing shares of the size that 
+        # we'd want to store. We keep them around because they may have
+        # existing shares for this storage index, which we want to know
+        # about for accurate servers_of_happiness accounting
+        self.readonly_peers = []
 
         peers = storage_broker.get_servers_for_index(storage_index)
         if not peers:
hunk ./src/allmydata/immutable/upload.py 227
             (peerid, conn) = peer
             v1 = conn.version["http://allmydata.org/tahoe/protocols/storage/v1"]
             return v1["maximum-immutable-share-size"]
-        peers = [peer for peer in peers
-                 if _get_maxsize(peer) >= allocated_size]
-        if not peers:
-            raise NoServersError("no peers could accept an allocated_size of %d" % allocated_size)
+        new_peers = [peer for peer in peers
+                     if _get_maxsize(peer) >= allocated_size]
+        old_peers = list(set(peers).difference(set(new_peers)))
+        peers = new_peers
 
         # decide upon the renewal/cancel secrets, to include them in the
         # allocate_buckets query.
hunk ./src/allmydata/immutable/upload.py 241
                                                        storage_index)
         file_cancel_secret = file_cancel_secret_hash(client_cancel_secret,
                                                      storage_index)
-
-        trackers = [ PeerTracker(peerid, conn,
-                                 share_size, block_size,
-                                 num_segments, num_share_hashes,
-                                 storage_index,
-                                 bucket_renewal_secret_hash(file_renewal_secret,
-                                                            peerid),
-                                 bucket_cancel_secret_hash(file_cancel_secret,
+        def _make_trackers(peers):
+           return [ PeerTracker(peerid, conn,
+                                share_size, block_size,
+                                num_segments, num_share_hashes,
+                                storage_index,
+                                bucket_renewal_secret_hash(file_renewal_secret,
                                                            peerid),
hunk ./src/allmydata/immutable/upload.py 248
-                                 )
-                     for (peerid, conn) in peers ]
-        self.uncontacted_peers = trackers
-
-        d = defer.maybeDeferred(self._loop)
+                                bucket_cancel_secret_hash(file_cancel_secret,
+                                                          peerid))
+                    for (peerid, conn) in peers]
+        self.uncontacted_peers = _make_trackers(peers)
+        self.readonly_peers = _make_trackers(old_peers)
+        # Talk to the readonly servers to get an idea of what servers
+        # have what shares (if any) for this storage index
+        d = defer.maybeDeferred(self._existing_shares)
+        d.addCallback(lambda ign: self._loop())
         return d
 
hunk ./src/allmydata/immutable/upload.py 259
+    def _existing_shares(self):
+        if self.readonly_peers:
+            peer = self.readonly_peers.pop()
+            assert isinstance(peer, PeerTracker)
+            d = peer.query_allocated()
+            d.addCallback(self._handle_allocate_response)
+            return d
+
+    def _handle_allocate_response(self, (peer, buckets)):
+        for bucket in buckets:
+            self.preexisting_shares[bucket] = peer
+            if self.homeless_shares:
+                self.homeless_shares.remove(bucket)
+        return self._existing_shares()
 
     def _loop(self):
         if not self.homeless_shares:
}
[Change stray "shares_of_happiness" to "servers_of_happiness"
Kevan Carstensen <kevan@isnotajoke.com>**20091116212459
 Ignore-this: 1c971ba8c3c4d2e7ba9f020577b28b73
] {
hunk ./docs/architecture.txt 183
 place a quantity known as "shares of happiness", we'll do the upload anyways.
 If we cannot place at least this many, the upload is declared a failure.
 
-The current defaults use k=3, shares_of_happiness=7, and N=10, meaning that
+The current defaults use k=3, servers_of_happiness=7, and N=10, meaning that
 we'll try to place 10 shares, we'll be happy if we can place 7, and we need
 to get back any 3 to recover the file. This results in a 3.3x expansion
 factor. In general, you should set N about equal to the number of nodes in
hunk ./src/allmydata/immutable/upload.py 411
                 pass
             else:
                 # No more peers, so this upload might fail (it depends upon
-                # whether we've hit shares_of_happiness or not). Log the last
+                # whether we've hit servers_of_happiness or not). Log the last
                 # failure we got: if a coding error causes all peers to fail
                 # in the same way, this allows the common failure to be seen
                 # by the uploader and should help with debugging
hunk ./src/allmydata/interfaces.py 809
 
 class NotEnoughSharesError(Exception):
     """Download was unable to get enough shares, or upload was unable to
-    place 'shares_of_happiness' shares."""
+    place 'servers_of_happiness' shares."""
 
 class NoSharesError(Exception):
     """Upload or Download was unable to get any shares at all."""
hunk ./src/allmydata/interfaces.py 1308
                          pushed.
 
         'share_counts': return a tuple describing how many shares are used:
-                        (needed_shares, shares_of_happiness, total_shares)
+                        (needed_shares, servers_of_happiness, total_shares)
 
         'num_segments': return an int with the number of segments that
                         will be encoded.
hunk ./src/allmydata/test/test_encode.py 768
     def test_lost_one_shareholder(self):
         # we have enough shareholders when we start, but one segment in we
         # lose one of them. The upload should still succeed, as long as we
-        # still have 'shares_of_happiness' peers left.
+        # still have 'servers_of_happiness' peers left.
         modemap = dict([(i, "good") for i in range(9)] +
                        [(i, "lost") for i in range(9, 10)])
         return self.send_and_recover((4,8,10), bucket_modes=modemap)
hunk ./src/allmydata/test/test_encode.py 776
     def test_lost_one_shareholder_early(self):
         # we have enough shareholders when we choose peers, but just before
         # we send the 'start' message, we lose one of them. The upload should
-        # still succeed, as long as we still have 'shares_of_happiness' peers
+        # still succeed, as long as we still have 'servers_of_happiness' peers
         # left.
         modemap = dict([(i, "good") for i in range(9)] +
                        [(i, "lost-early") for i in range(9, 10)])
}
[Eliminate overcounting iof servers_of_happiness in Tahoe2PeerSelector; also reorganize some things.
Kevan Carstensen <kevan@isnotajoke.com>**20091118014542
 Ignore-this: a6cb032cbff74f4f9d4238faebd99868
] {
hunk ./src/allmydata/immutable/upload.py 141
         return (alreadygot, set(b.keys()))
 
 def servers_with_unique_shares(existing_shares, used_peers=None):
+    """
+    I accept a dict of shareid -> peerid mappings (and optionally a list
+    of PeerTracker instances) and return a list of servers that have shares.
+    """
     servers = []
hunk ./src/allmydata/immutable/upload.py 146
+    existing_shares = existing_shares.copy()
     if used_peers:
hunk ./src/allmydata/immutable/upload.py 148
+        peerdict = {}
+        for peer in used_peers:
+            peerdict.update(dict([(i, peer.peerid) for i in peer.buckets]))
+        for k in peerdict.keys():
+            if existing_shares.has_key(k):
+                # Prevent overcounting; favor the bucket, and not the 
+                # prexisting share.
+                del(existing_shares[k])
         peers = list(used_peers.copy())
         # We do this because the preexisting shares list goes by peerid.
         peers = [x.peerid for x in peers]
hunk ./src/allmydata/immutable/upload.py 164
     return list(set(servers))
 
 def shares_by_server(existing_shares):
+    """
+    I accept a dict of shareid -> peerid mappings, and return a dict
+    of peerid -> shareid mappings
+    """
     servers = {}
     for server in set(existing_shares.values()):
         servers[server] = set([x for x in existing_shares.keys()
hunk ./src/allmydata/immutable/upload.py 174
                                if existing_shares[x] == server])
     return servers
 
+def should_add_server(existing_shares, server, bucket):
+    """
+    I tell my caller whether the servers_of_happiness number will be
+    increased or decreased if a particular server is added as the peer
+    already holding a particular share. I take a dictionary, a peerid,
+    and a bucket as arguments, and return a boolean.
+    """
+    old_size = len(servers_with_unique_shares(existing_shares))
+    new_candidate = existing_shares.copy()
+    new_candidate[bucket] = server
+    new_size = len(servers_with_unique_shares(new_candidate))
+    return old_size < new_size
+
 class Tahoe2PeerSelector:
 
     def __init__(self, upload_id, logparent=None, upload_status=None):
hunk ./src/allmydata/immutable/upload.py 294
             peer = self.readonly_peers.pop()
             assert isinstance(peer, PeerTracker)
             d = peer.query_allocated()
-            d.addCallback(self._handle_allocate_response)
+            d.addCallback(self._handle_existing_response)
             return d
 
hunk ./src/allmydata/immutable/upload.py 297
-    def _handle_allocate_response(self, (peer, buckets)):
+    def _handle_existing_response(self, (peer, buckets)):
         for bucket in buckets:
hunk ./src/allmydata/immutable/upload.py 299
-            self.preexisting_shares[bucket] = peer
-            if self.homeless_shares:
-                self.homeless_shares.remove(bucket)
+            if should_add_server(self.preexisting_shares, peer, bucket):
+                self.preexisting_shares[bucket] = peer
+                if self.homeless_shares and bucket in self.homeless_shares:
+                    self.homeless_shares.remove(bucket)
         return self._existing_shares()
 
     def _loop(self):
hunk ./src/allmydata/immutable/upload.py 346
                             items.append((servernum, sharelist))
                     return self._loop()
                 else:
-                    raise NotEnoughSharesError("shares could only be placed on %d "
-                                            "servers (%d were requested)" %
-                                            (len(effective_happiness),
-                                             self.servers_of_happiness))
+                    raise NotEnoughSharesError("shares could only be placed "
+                                   "on %d servers (%d were requested)" %
+                                   (len(effective_happiness),
+                                   self.servers_of_happiness))
 
         if self.uncontacted_peers:
             peer = self.uncontacted_peers.pop(0)
hunk ./src/allmydata/immutable/upload.py 425
                 # we placed enough to be happy, so we're done
                 if self._status:
                     self._status.set_status("Placed all shares")
-                return self.use_peers
+                return (self.use_peers, self.preexisting_shares)
 
     def _got_response(self, res, peer, shares_to_ask, put_peer_here):
         if isinstance(res, failure.Failure):
hunk ./src/allmydata/immutable/upload.py 456
                     level=log.NOISY, parent=self._log_parent)
             progress = False
             for s in alreadygot:
-                if self.preexisting_shares.has_key(s):
-                    old_size = len(servers_with_unique_shares(self.preexisting_shares))
-                    new_candidate = self.preexisting_shares.copy()
-                    new_candidate[s] = peer.peerid
-                    new_size = len(servers_with_unique_shares(new_candidate))
-                    if old_size >= new_size: continue
-                self.preexisting_shares[s] = peer.peerid
-                if s in self.homeless_shares:
-                    self.homeless_shares.remove(s)
-                    progress = True
+                if should_add_server(self.preexisting_shares,
+                                     peer.peerid, s):
+                    self.preexisting_shares[s] = peer.peerid
+                    if s in self.homeless_shares:
+                        self.homeless_shares.remove(s)
+                        progress = True
 
             # the PeerTracker will remember which shares were allocated on
             # that peer. We just have to remember to use them.
}
[Alter the error message returned when peer selection fails
Kevan Carstensen <kevan@isnotajoke.com>**20091123002405
 Ignore-this: b2a7dc163edcab8d9613bfd6907e5166
 
 The Tahoe2PeerSelector returned either NoSharesError or NotEnoughSharesError
 for a variety of error conditions that weren't informatively described by them.
 This patch creates a new error, UploadHappinessError, replaces uses of 
 NoSharesError and NotEnoughSharesError with it, and alters the error message
 raised with the errors to be more in line with the new servers_of_happiness
 behavior. See ticket #834 for more information.
] {
hunk ./src/allmydata/immutable/encode.py 14
 from allmydata.util.assertutil import _assert, precondition
 from allmydata.codec import CRSEncoder
 from allmydata.interfaces import IEncoder, IStorageBucketWriter, \
-     IEncryptedUploadable, IUploadStatus, NotEnoughSharesError, NoSharesError
+     IEncryptedUploadable, IUploadStatus, UploadHappinessError
+
 
 """
 The goal of the encoder is to turn the original file into a series of
hunk ./src/allmydata/immutable/encode.py 498
             msg = "lost too many servers during upload (still have %d, want %d): %s" % \
                   (len(servers_left),
                    self.servers_of_happiness, why)
-            if servers_left:
-                raise NotEnoughSharesError(msg)
-            else:
-                raise NoSharesError(msg)
+            raise UploadHappinessError(msg)
         self.log("but we can still continue with %s shares, we'll be happy "
                  "with at least %s" % (len(servers_left),
                                        self.servers_of_happiness),
hunk ./src/allmydata/immutable/encode.py 508
         d = defer.DeferredList(dl, fireOnOneErrback=True)
         def _eatNotEnoughSharesError(f):
             # all exceptions that occur while talking to a peer are handled
-            # in _remove_shareholder. That might raise NotEnoughSharesError,
+            # in _remove_shareholder. That might raise UploadHappinessError,
             # which will cause the DeferredList to errback but which should
hunk ./src/allmydata/immutable/encode.py 510
-            # otherwise be consumed. Allow non-NotEnoughSharesError exceptions
+            # otherwise be consumed. Allow non-UploadHappinessError exceptions
             # to pass through as an unhandled errback. We use this in lieu of
             # consumeErrors=True to allow coding errors to be logged.
hunk ./src/allmydata/immutable/encode.py 513
-            f.trap(NotEnoughSharesError, NoSharesError)
+            f.trap(UploadHappinessError)
             return None
         for d0 in dl:
             d0.addErrback(_eatNotEnoughSharesError)
hunk ./src/allmydata/immutable/upload.py 20
 from allmydata.util.rrefutil import add_version_to_remote_reference
 from allmydata.interfaces import IUploadable, IUploader, IUploadResults, \
      IEncryptedUploadable, RIEncryptedUploadable, IUploadStatus, \
-     NotEnoughSharesError, NoSharesError, NoServersError, \
-     InsufficientVersionError
+     NoServersError, InsufficientVersionError, UploadHappinessError
 from allmydata.immutable import layout
 from pycryptopp.cipher.aes import AES
 
hunk ./src/allmydata/immutable/upload.py 119
     def query_allocated(self):
         d = self._storageserver.callRemote("get_buckets",
                                            self.storage_index)
-        d.addCallback(self._got_allocate_reply)
         return d
 
hunk ./src/allmydata/immutable/upload.py 121
-    def _got_allocate_reply(self, buckets):
-        return (self.peerid, buckets)
-
     def _got_reply(self, (alreadygot, buckets)):
         #log.msg("%s._got_reply(%s)" % (self, (alreadygot, buckets)))
         b = {}
hunk ./src/allmydata/immutable/upload.py 187
     def __init__(self, upload_id, logparent=None, upload_status=None):
         self.upload_id = upload_id
         self.query_count, self.good_query_count, self.bad_query_count = 0,0,0
+        # Peers that are working normally, but full.
+        self.full_count = 0
         self.error_count = 0
         self.num_peers_contacted = 0
         self.last_failure_msg = None
hunk ./src/allmydata/immutable/upload.py 291
             peer = self.readonly_peers.pop()
             assert isinstance(peer, PeerTracker)
             d = peer.query_allocated()
-            d.addCallback(self._handle_existing_response)
+            d.addBoth(self._handle_existing_response, peer.peerid)
+            self.num_peers_contacted += 1
+            self.query_count += 1
+            log.msg("asking peer %s for any existing shares for upload id %s"
+                    % (idlib.shortnodeid_b2a(peer.peerid), self.upload_id),
+                    level=log.NOISY, parent=self._log_parent)
+            if self._status:
+                self._status.set_status("Contacting Peer %s to find "
+                                        "any existing shares"
+                                        % idlib.shortnodeid_b2a(peer.peerid))
             return d
 
hunk ./src/allmydata/immutable/upload.py 303
-    def _handle_existing_response(self, (peer, buckets)):
-        for bucket in buckets:
-            if should_add_server(self.preexisting_shares, peer, bucket):
-                self.preexisting_shares[bucket] = peer
-                if self.homeless_shares and bucket in self.homeless_shares:
-                    self.homeless_shares.remove(bucket)
+    def _handle_existing_response(self, res, peer):
+        if isinstance(res, failure.Failure):
+            log.msg("%s got error during existing shares check: %s"
+                    % (idlib.shortnodeid_b2a(peer), res),
+                    level=log.UNUSUAL, parent=self._log_parent)
+            self.error_count += 1
+            self.bad_query_count += 1
+        else:
+            buckets = res
+            log.msg("response from peer %s: alreadygot=%s"
+                    % (idlib.shortnodeid_b2a(peer), tuple(sorted(buckets))),
+                    level=log.NOISY, parent=self._log_parent)
+            for bucket in buckets:
+                if should_add_server(self.preexisting_shares, peer, bucket):
+                    self.preexisting_shares[bucket] = peer
+                    if self.homeless_shares and bucket in self.homeless_shares:
+                        self.homeless_shares.remove(bucket)
+            self.full_count += 1
+            self.bad_query_count += 1
         return self._existing_shares()
 
     def _loop(self):
hunk ./src/allmydata/immutable/upload.py 365
                             items.append((servernum, sharelist))
                     return self._loop()
                 else:
-                    raise NotEnoughSharesError("shares could only be placed "
+                    raise UploadHappinessError("shares could only be placed "
                                    "on %d servers (%d were requested)" %
                                    (len(effective_happiness),
                                    self.servers_of_happiness))
hunk ./src/allmydata/immutable/upload.py 424
                 msg = ("placed %d shares out of %d total (%d homeless), "
                        "want to place on %d servers, "
                        "sent %d queries to %d peers, "
-                       "%d queries placed some shares, %d placed none, "
-                       "got %d errors" %
+                       "%d queries placed some shares, %d placed none "
+                       "(of which %d placed none due to the server being"
+                       " full and %d placed none due to an error)" %
                        (self.total_shares - len(self.homeless_shares),
                         self.total_shares, len(self.homeless_shares),
                         self.servers_of_happiness,
hunk ./src/allmydata/immutable/upload.py 432
                         self.query_count, self.num_peers_contacted,
                         self.good_query_count, self.bad_query_count,
-                        self.error_count))
+                        self.full_count, self.error_count))
                 msg = "peer selection failed for %s: %s" % (self, msg)
                 if self.last_failure_msg:
                     msg += " (%s)" % (self.last_failure_msg,)
hunk ./src/allmydata/immutable/upload.py 437
                 log.msg(msg, level=log.UNUSUAL, parent=self._log_parent)
-                if placed_shares:
-                    raise NotEnoughSharesError(msg)
-                else:
-                    raise NoSharesError(msg)
+                raise UploadHappinessError(msg)
             else:
                 # we placed enough to be happy, so we're done
                 if self._status:
hunk ./src/allmydata/immutable/upload.py 451
             log.msg("%s got error during peer selection: %s" % (peer, res),
                     level=log.UNUSUAL, parent=self._log_parent)
             self.error_count += 1
+            self.bad_query_count += 1
             self.homeless_shares = list(shares_to_ask) + self.homeless_shares
             if (self.uncontacted_peers
                 or self.contacted_peers
hunk ./src/allmydata/immutable/upload.py 479
                     self.preexisting_shares[s] = peer.peerid
                     if s in self.homeless_shares:
                         self.homeless_shares.remove(s)
-                        progress = True
 
             # the PeerTracker will remember which shares were allocated on
             # that peer. We just have to remember to use them.
hunk ./src/allmydata/immutable/upload.py 495
                 self.good_query_count += 1
             else:
                 self.bad_query_count += 1
+                self.full_count += 1
 
             if still_homeless:
                 # In networks with lots of space, this is very unusual and
hunk ./src/allmydata/interfaces.py 808
         """
 
 class NotEnoughSharesError(Exception):
-    """Download was unable to get enough shares, or upload was unable to
-    place 'servers_of_happiness' shares."""
+    """Download was unable to get enough shares"""
 
 class NoSharesError(Exception):
hunk ./src/allmydata/interfaces.py 811
-    """Upload or Download was unable to get any shares at all."""
+    """Download was unable to get any shares at all."""
+
+class UploadHappinessError(Exception):
+    """Upload was unable to satisfy 'servers_of_happiness'"""
 
 class UnableToFetchCriticalDownloadDataError(Exception):
     """I was unable to fetch some piece of critical data which is supposed to
}
[Change "UploadHappinessError" to "UploadUnhappinessError"
Kevan Carstensen <kevan@isnotajoke.com>**20091205043037
 Ignore-this: 236b64ab19836854af4993bb5c1b221a
] {
replace ./src/allmydata/immutable/encode.py [A-Za-z_0-9] UploadHappinessError UploadUnhappinessError
replace ./src/allmydata/immutable/upload.py [A-Za-z_0-9] UploadHappinessError UploadUnhappinessError
replace ./src/allmydata/interfaces.py [A-Za-z_0-9] UploadHappinessError UploadUnhappinessError
}
[Alter the error message when an upload fails, per some comments in #778.
Kevan Carstensen <kevan@isnotajoke.com>**20091230210344
 Ignore-this: ba97422b2f9737c46abeb828727beb1
 
 When I first implemented #778, I just altered the error messages to refer to
 servers where they referred to shares. The resulting error messages weren't
 very good. These are a bit better.
] {
hunk ./src/allmydata/immutable/upload.py 200
 
     def get_shareholders(self, storage_broker, secret_holder,
                          storage_index, share_size, block_size,
-                         num_segments, total_shares, servers_of_happiness):
+                         num_segments, total_shares, needed_shares,
+                         servers_of_happiness):
         """
         @return: (used_peers, already_peers), where used_peers is a set of
                  PeerTracker instances that have agreed to hold some shares
hunk ./src/allmydata/immutable/upload.py 215
 
         self.total_shares = total_shares
         self.servers_of_happiness = servers_of_happiness
+        self.needed_shares = needed_shares
 
         self.homeless_shares = range(total_shares)
         # self.uncontacted_peers = list() # peers we haven't asked yet
hunk ./src/allmydata/immutable/upload.py 230
         # existing shares for this storage index, which we want to know
         # about for accurate servers_of_happiness accounting
         self.readonly_peers = []
+        # These peers have shares -- any shares -- for our SI. We keep track
+        # of these to write an error message with them later.
+        self.peers_with_shares = []
 
         peers = storage_broker.get_servers_for_index(storage_index)
         if not peers:
hunk ./src/allmydata/immutable/upload.py 317
             self.bad_query_count += 1
         else:
             buckets = res
+            if buckets:
+                self.peers_with_shares.append(peer)
             log.msg("response from peer %s: alreadygot=%s"
                     % (idlib.shortnodeid_b2a(peer), tuple(sorted(buckets))),
                     level=log.NOISY, parent=self._log_parent)
hunk ./src/allmydata/immutable/upload.py 331
             self.bad_query_count += 1
         return self._existing_shares()
 
+    def _get_progress_message(self):
+        if not self.homeless_shares:
+            msg = "placed all %d shares, " % (self.total_shares)
+        else:
+            msg = ("placed %d shares out of %d total (%d homeless), " %
+                   (self.total_shares - len(self.homeless_shares),
+                    self.total_shares,
+                    len(self.homeless_shares)))
+        return (msg + "want to place shares on at least %d servers such that "
+                      "any %d of them have enough shares to recover the file, "
+                      "sent %d queries to %d peers, "
+                      "%d queries placed some shares, %d placed none "
+                      "(of which %d placed none due to the server being"
+                      " full and %d placed none due to an error)" %
+                        (self.servers_of_happiness, self.needed_shares,
+                         self.query_count, self.num_peers_contacted,
+                         self.good_query_count, self.bad_query_count,
+                         self.full_count, self.error_count))
+
+
     def _loop(self):
         if not self.homeless_shares:
             effective_happiness = servers_with_unique_shares(
hunk ./src/allmydata/immutable/upload.py 357
                                                    self.preexisting_shares,
                                                    self.use_peers)
             if self.servers_of_happiness <= len(effective_happiness):
-                msg = ("placed all %d shares, "
-                       "sent %d queries to %d peers, "
-                       "%d queries placed some shares, %d placed none, "
-                       "got %d errors" %
-                       (self.total_shares,
-                        self.query_count, self.num_peers_contacted,
-                        self.good_query_count, self.bad_query_count,
-                        self.error_count))
-                log.msg("peer selection successful for %s: %s" % (self, msg),
-                    parent=self._log_parent)
+                msg = ("peer selection successful for %s: %s" % (self,
+                            self._get_progress_message()))
+                log.msg(msg, parent=self._log_parent)
                 return (self.use_peers, self.preexisting_shares)
             else:
                 delta = self.servers_of_happiness - len(effective_happiness)
hunk ./src/allmydata/immutable/upload.py 375
                 if delta <= len(self.uncontacted_peers) and \
                    shares_to_spread >= delta:
                     # Loop through the allocated shares, removing 
+                    # one from each server that has more than one and putting
+                    # it back into self.homeless_shares until we've done
+                    # this delta times.
                     items = shares.items()
                     while len(self.homeless_shares) < delta:
                         servernum, sharelist = items.pop()
hunk ./src/allmydata/immutable/upload.py 388
                             items.append((servernum, sharelist))
                     return self._loop()
                 else:
-                    raise UploadUnhappinessError("shares could only be placed "
-                                   "on %d servers (%d were requested)" %
-                                   (len(effective_happiness),
-                                   self.servers_of_happiness))
+                    peer_count = len(list(set(self.peers_with_shares)))
+                    # If peer_count < needed_shares, then the second error
+                    # message is nonsensical, so we use this one.
+                    if peer_count < self.needed_shares:
+                        msg = ("shares could only be placed or found on %d "
+                               "server(s). "
+                               "We were asked to place shares on at least %d "
+                               "server(s) such that any %d of them have "
+                               "enough shares to recover the file." %
+                               (peer_count,
+                                self.servers_of_happiness,
+                                self.needed_shares))
+                    # Otherwise, if we've placed on at least needed_shares
+                    # peers, but there isn't an x-happy subset of those peers
+                    # for x < needed_shares, we use this error message.
+                    elif len(effective_happiness) < self.needed_shares:
+                        msg = ("shares could be placed or found on %d "
+                               "server(s), but they are not spread out evenly "
+                               "enough to ensure that any %d of these servers "
+                               "would have enough shares to recover the file. "
+                               "We were asked to place "
+                               "shares on at least %d servers such that any "
+                               "%d of them have enough shares to recover the "
+                               "file." %
+                               (peer_count,
+                                self.needed_shares,
+                                self.servers_of_happiness,
+                                self.needed_shares))
+                    # Otherwise, if there is an x-happy subset of peers where
+                    # x >= needed_shares, but x < shares_of_happiness, then 
+                    # we use this message.
+                    else:
+                        msg = ("shares could only be placed on %d server(s) "
+                               "such that any %d of them have enough shares "
+                               "to recover the file, but we were asked to use "
+                               "at least %d such servers." %
+                                               (len(effective_happiness),
+                                                self.needed_shares,
+                                                self.servers_of_happiness))
+                    raise UploadUnhappinessError(msg)
 
         if self.uncontacted_peers:
             peer = self.uncontacted_peers.pop(0)
hunk ./src/allmydata/immutable/upload.py 480
                                                    self.preexisting_shares,
                                                    self.use_peers)
             if len(effective_happiness) < self.servers_of_happiness:
-                msg = ("placed %d shares out of %d total (%d homeless), "
-                       "want to place on %d servers, "
-                       "sent %d queries to %d peers, "
-                       "%d queries placed some shares, %d placed none "
-                       "(of which %d placed none due to the server being"
-                       " full and %d placed none due to an error)" %
-                       (self.total_shares - len(self.homeless_shares),
-                        self.total_shares, len(self.homeless_shares),
-                        self.servers_of_happiness,
-                        self.query_count, self.num_peers_contacted,
-                        self.good_query_count, self.bad_query_count,
-                        self.full_count, self.error_count))
-                msg = "peer selection failed for %s: %s" % (self, msg)
+                msg = ("peer selection failed for %s: %s" % (self,
+                                self._get_progress_message()))
                 if self.last_failure_msg:
                     msg += " (%s)" % (self.last_failure_msg,)
                 log.msg(msg, level=log.UNUSUAL, parent=self._log_parent)
hunk ./src/allmydata/immutable/upload.py 534
                 self.use_peers.add(peer)
                 progress = True
 
+            if allocated or alreadygot:
+                self.peers_with_shares.append(peer.peerid)
+
             not_yet_present = set(shares_to_ask) - set(alreadygot)
             still_homeless = not_yet_present - set(allocated)
 
hunk ./src/allmydata/immutable/upload.py 931
         d = peer_selector.get_shareholders(storage_broker, secret_holder,
                                            storage_index,
                                            share_size, block_size,
-                                           num_segments, n, desired)
+                                           num_segments, n, k, desired)
         def _done(res):
             self._peer_selection_elapsed = time.time() - peer_selection_started
             return res
}
[Fix up the behavior of #778, per reviewers' comments
Kevan Carstensen <kevan@isnotajoke.com>**20100215202214
 Ignore-this: 14bf3680b77fa1b2dafa85eb22c2ebf9
 
   - Make some important utility functions clearer and more thoroughly 
     documented.
   - Assert in upload.servers_of_happiness that the buckets attributes
     of PeerTrackers passed to it are mutually disjoint.
   - Get rid of some silly non-Pythonisms that I didn't see when I first
     wrote these patches.
   - Make sure that should_add_server returns true when queried about a 
     shnum that it doesn't know about yet.
   - Change Tahoe2PeerSelector.preexisting_shares to map a shareid to a set
     of peerids, alter dependencies to deal with that.
   - Remove upload.should_add_servers, because it is no longer necessary
   - Move upload.shares_of_happiness and upload.shares_by_server to a utility
     file.
   - Change some points in Tahoe2PeerSelector.
   - Compute servers_of_happiness using a bipartite matching algorithm that 
     we know is optimal instead of an ad-hoc greedy algorithm that isn't.
   - Change servers_of_happiness to just take a sharemap as an argument,
     change its callers to merge existing_shares and used_peers before 
     calling it.
   - Change an error message in the encoder to be more appropriate for 
     servers of happiness.
 
] {
hunk ./src/allmydata/immutable/encode.py 10
 from allmydata import uri
 from allmydata.storage.server import si_b2a
 from allmydata.hashtree import HashTree
-from allmydata.util import mathutil, hashutil, base32, log
+from allmydata.util import mathutil, hashutil, base32, log, happinessutil
 from allmydata.util.assertutil import _assert, precondition
 from allmydata.codec import CRSEncoder
 from allmydata.interfaces import IEncoder, IStorageBucketWriter, \
hunk ./src/allmydata/immutable/encode.py 201
             assert IStorageBucketWriter.providedBy(landlords[k])
         self.landlords = landlords.copy()
         assert isinstance(servermap, dict)
+        for k in servermap:
+            assert isinstance(servermap[k], set)
         self.servermap = servermap.copy()
 
     def start(self):
hunk ./src/allmydata/immutable/encode.py 489
                       level=log.UNUSUAL, failure=why)
         if shareid in self.landlords:
             self.landlords[shareid].abort()
+            peerid = self.landlords[shareid].get_peerid()
             del self.landlords[shareid]
hunk ./src/allmydata/immutable/encode.py 491
+            if peerid:
+                self.servermap[shareid].remove(peerid)
+            if not self.servermap[shareid]:
+                del self.servermap[shareid]
         else:
             # even more UNUSUAL
             self.log("they weren't in our list of landlords", parent=ln,
hunk ./src/allmydata/immutable/encode.py 499
                      level=log.WEIRD, umid="TQGFRw")
-        del(self.servermap[shareid])
-        servers_left = list(set(self.servermap.values()))
-        if len(servers_left) < self.servers_of_happiness:
-            msg = "lost too many servers during upload (still have %d, want %d): %s" % \
-                  (len(servers_left),
-                   self.servers_of_happiness, why)
+        happiness = happinessutil.servers_of_happiness(self.servermap)
+        if happiness < self.servers_of_happiness:
+            msg = ("lost too many servers during upload "
+                   "(happiness is now %d, but we wanted %d): %s" %
+                   (happiness,
+                    self.servers_of_happiness, why))
             raise UploadUnhappinessError(msg)
         self.log("but we can still continue with %s shares, we'll be happy "
hunk ./src/allmydata/immutable/encode.py 507
-                 "with at least %s" % (len(servers_left),
+                 "with at least %s" % (happiness,
                                        self.servers_of_happiness),
                  parent=ln)
 
hunk ./src/allmydata/immutable/encode.py 513
     def _gather_responses(self, dl):
         d = defer.DeferredList(dl, fireOnOneErrback=True)
-        def _eatNotEnoughSharesError(f):
+        def _eatUploadUnhappinessError(f):
             # all exceptions that occur while talking to a peer are handled
             # in _remove_shareholder. That might raise UploadUnhappinessError,
             # which will cause the DeferredList to errback but which should
hunk ./src/allmydata/immutable/encode.py 523
             f.trap(UploadUnhappinessError)
             return None
         for d0 in dl:
-            d0.addErrback(_eatNotEnoughSharesError)
+            d0.addErrback(_eatUploadUnhappinessError)
         return d
 
     def finish_hashing(self):
hunk ./src/allmydata/immutable/layout.py 245
     def abort(self):
         return self._rref.callRemoteOnly("abort")
 
+
+    def get_peerid(self):
+        if self._nodeid:
+            return self._nodeid
+        return None
+
 class WriteBucketProxy_v2(WriteBucketProxy):
     fieldsize = 8
     fieldstruct = ">Q"
hunk ./src/allmydata/immutable/upload.py 16
 from allmydata.storage.server import si_b2a
 from allmydata.immutable import encode
 from allmydata.util import base32, dictutil, idlib, log, mathutil
+from allmydata.util.happinessutil import servers_of_happiness, \
+                                         shares_by_server, merge_peers
 from allmydata.util.assertutil import precondition
 from allmydata.util.rrefutil import add_version_to_remote_reference
 from allmydata.interfaces import IUploadable, IUploader, IUploadResults, \
hunk ./src/allmydata/immutable/upload.py 119
         return d
 
     def query_allocated(self):
-        d = self._storageserver.callRemote("get_buckets",
-                                           self.storage_index)
-        return d
+        return self._storageserver.callRemote("get_buckets",
+                                              self.storage_index)
 
     def _got_reply(self, (alreadygot, buckets)):
         #log.msg("%s._got_reply(%s)" % (self, (alreadygot, buckets)))
hunk ./src/allmydata/immutable/upload.py 136
         self.buckets.update(b)
         return (alreadygot, set(b.keys()))
 
-def servers_with_unique_shares(existing_shares, used_peers=None):
-    """
-    I accept a dict of shareid -> peerid mappings (and optionally a list
-    of PeerTracker instances) and return a list of servers that have shares.
-    """
-    servers = []
-    existing_shares = existing_shares.copy()
-    if used_peers:
-        peerdict = {}
-        for peer in used_peers:
-            peerdict.update(dict([(i, peer.peerid) for i in peer.buckets]))
-        for k in peerdict.keys():
-            if existing_shares.has_key(k):
-                # Prevent overcounting; favor the bucket, and not the 
-                # prexisting share.
-                del(existing_shares[k])
-        peers = list(used_peers.copy())
-        # We do this because the preexisting shares list goes by peerid.
-        peers = [x.peerid for x in peers]
-        servers.extend(peers)
-    servers.extend(existing_shares.values())
-    return list(set(servers))
-
-def shares_by_server(existing_shares):
-    """
-    I accept a dict of shareid -> peerid mappings, and return a dict
-    of peerid -> shareid mappings
-    """
-    servers = {}
-    for server in set(existing_shares.values()):
-        servers[server] = set([x for x in existing_shares.keys()
-                               if existing_shares[x] == server])
-    return servers
-
-def should_add_server(existing_shares, server, bucket):
-    """
-    I tell my caller whether the servers_of_happiness number will be
-    increased or decreased if a particular server is added as the peer
-    already holding a particular share. I take a dictionary, a peerid,
-    and a bucket as arguments, and return a boolean.
-    """
-    old_size = len(servers_with_unique_shares(existing_shares))
-    new_candidate = existing_shares.copy()
-    new_candidate[bucket] = server
-    new_size = len(servers_with_unique_shares(new_candidate))
-    return old_size < new_size
 
 class Tahoe2PeerSelector:
 
hunk ./src/allmydata/immutable/upload.py 161
         @return: (used_peers, already_peers), where used_peers is a set of
                  PeerTracker instances that have agreed to hold some shares
                  for us (the shnum is stashed inside the PeerTracker),
-                 and already_peers is a dict mapping shnum to a peer
-                 which claims to already have the share.
+                 and already_peers is a dict mapping shnum to a set of peers
+                 which claim to already have the share.
         """
 
         if self._status:
hunk ./src/allmydata/immutable/upload.py 173
         self.needed_shares = needed_shares
 
         self.homeless_shares = range(total_shares)
-        # self.uncontacted_peers = list() # peers we haven't asked yet
         self.contacted_peers = [] # peers worth asking again
         self.contacted_peers2 = [] # peers that we have asked again
         self._started_second_pass = False
hunk ./src/allmydata/immutable/upload.py 177
         self.use_peers = set() # PeerTrackers that have shares assigned to them
-        self.preexisting_shares = {} # sharenum -> peerid holding the share
-        # We don't try to allocate shares to these servers, since they've 
-        # said that they're incapable of storing shares of the size that 
-        # we'd want to store. We keep them around because they may have
-        # existing shares for this storage index, which we want to know
-        # about for accurate servers_of_happiness accounting
-        self.readonly_peers = []
-        # These peers have shares -- any shares -- for our SI. We keep track
-        # of these to write an error message with them later.
+        self.preexisting_shares = {} # shareid => set(peerids) holding shareid
+        # We don't try to allocate shares to these servers, since they've said
+        # that they're incapable of storing shares of the size that we'd want
+        # to store. We keep them around because they may have existing shares
+        # for this storage index, which we want to know about for accurate
+        # servers_of_happiness accounting
+        # (this is eventually a list, but it is initialized later)
+        self.readonly_peers = None
+        # These peers have shares -- any shares -- for our SI. We keep
+        # track of these to write an error message with them later.
         self.peers_with_shares = []
 
hunk ./src/allmydata/immutable/upload.py 189
-        peers = storage_broker.get_servers_for_index(storage_index)
-        if not peers:
-            raise NoServersError("client gave us zero peers")
-
         # this needed_hashes computation should mirror
         # Encoder.send_all_share_hash_trees. We use an IncompleteHashTree
         # (instead of a HashTree) because we don't require actual hashing
hunk ./src/allmydata/immutable/upload.py 201
                                              num_share_hashes, EXTENSION_SIZE,
                                              None)
         allocated_size = wbp.get_allocated_size()
+        all_peers = storage_broker.get_servers_for_index(storage_index)
+        if not all_peers:
+            raise NoServersError("client gave us zero peers")
 
         # filter the list of peers according to which ones can accomodate
         # this request. This excludes older peers (which used a 4-byte size
hunk ./src/allmydata/immutable/upload.py 213
             (peerid, conn) = peer
             v1 = conn.version["http://allmydata.org/tahoe/protocols/storage/v1"]
             return v1["maximum-immutable-share-size"]
-        new_peers = [peer for peer in peers
-                     if _get_maxsize(peer) >= allocated_size]
-        old_peers = list(set(peers).difference(set(new_peers)))
-        peers = new_peers
+        writable_peers = [peer for peer in all_peers
+                          if _get_maxsize(peer) >= allocated_size]
+        readonly_peers = set(all_peers) - set(writable_peers)
 
         # decide upon the renewal/cancel secrets, to include them in the
         # allocate_buckets query.
hunk ./src/allmydata/immutable/upload.py 227
         file_cancel_secret = file_cancel_secret_hash(client_cancel_secret,
                                                      storage_index)
         def _make_trackers(peers):
-           return [ PeerTracker(peerid, conn,
-                                share_size, block_size,
-                                num_segments, num_share_hashes,
-                                storage_index,
-                                bucket_renewal_secret_hash(file_renewal_secret,
-                                                           peerid),
-                                bucket_cancel_secret_hash(file_cancel_secret,
-                                                          peerid))
+           return [PeerTracker(peerid, conn,
+                               share_size, block_size,
+                               num_segments, num_share_hashes,
+                               storage_index,
+                               bucket_renewal_secret_hash(file_renewal_secret,
+                                                          peerid),
+                               bucket_cancel_secret_hash(file_cancel_secret,
+                                                         peerid))
                     for (peerid, conn) in peers]
hunk ./src/allmydata/immutable/upload.py 236
-        self.uncontacted_peers = _make_trackers(peers)
-        self.readonly_peers = _make_trackers(old_peers)
-        # Talk to the readonly servers to get an idea of what servers
-        # have what shares (if any) for this storage index
+        self.uncontacted_peers = _make_trackers(writable_peers)
+        self.readonly_peers = _make_trackers(readonly_peers)
+        # We now ask peers that can't hold any new shares about existing
+        # shares that they might have for our SI. Once this is done, we
+        # start placing the shares that we haven't already accounted
+        # for.
         d = defer.maybeDeferred(self._existing_shares)
         d.addCallback(lambda ign: self._loop())
         return d
hunk ./src/allmydata/immutable/upload.py 247
 
     def _existing_shares(self):
+        """
+        I loop through the list of peers that aren't accepting any new
+        shares for this upload, asking each of them to tell me about the
+        shares they already have for this upload's SI.
+        """
         if self.readonly_peers:
             peer = self.readonly_peers.pop()
             assert isinstance(peer, PeerTracker)
hunk ./src/allmydata/immutable/upload.py 269
             return d
 
     def _handle_existing_response(self, res, peer):
+        """
+        I handle responses to the queries sent by
+        Tahoe2PeerSelector._existing_shares.
+        """
         if isinstance(res, failure.Failure):
             log.msg("%s got error during existing shares check: %s"
                     % (idlib.shortnodeid_b2a(peer), res),
hunk ./src/allmydata/immutable/upload.py 287
                     % (idlib.shortnodeid_b2a(peer), tuple(sorted(buckets))),
                     level=log.NOISY, parent=self._log_parent)
             for bucket in buckets:
-                if should_add_server(self.preexisting_shares, peer, bucket):
-                    self.preexisting_shares[bucket] = peer
-                    if self.homeless_shares and bucket in self.homeless_shares:
-                        self.homeless_shares.remove(bucket)
+                self.preexisting_shares.setdefault(bucket, set()).add(peer)
+                if self.homeless_shares and bucket in self.homeless_shares:
+                    self.homeless_shares.remove(bucket)
             self.full_count += 1
             self.bad_query_count += 1
         return self._existing_shares()
hunk ./src/allmydata/immutable/upload.py 316
 
     def _loop(self):
         if not self.homeless_shares:
-            effective_happiness = servers_with_unique_shares(
-                                                   self.preexisting_shares,
-                                                   self.use_peers)
-            if self.servers_of_happiness <= len(effective_happiness):
+            merged = merge_peers(self.preexisting_shares, self.use_peers)
+            effective_happiness = servers_of_happiness(merged)
+            if self.servers_of_happiness <= effective_happiness:
                 msg = ("peer selection successful for %s: %s" % (self,
                             self._get_progress_message()))
                 log.msg(msg, parent=self._log_parent)
hunk ./src/allmydata/immutable/upload.py 324
                 return (self.use_peers, self.preexisting_shares)
             else:
-                delta = self.servers_of_happiness - len(effective_happiness)
+                # We're not okay right now, but maybe we can fix it by
+                # redistributing some shares. In cases where one or two
+                # servers has, before the upload, all or most of the
+                # shares for a given SI, this can work by allowing _loop
+                # a chance to spread those out over the other peers, 
+                delta = self.servers_of_happiness - effective_happiness
                 shares = shares_by_server(self.preexisting_shares)
                 # Each server in shares maps to a set of shares stored on it.
                 # Since we want to keep at least one share on each server 
hunk ./src/allmydata/immutable/upload.py 341
                                         in shares.items()])
                 if delta <= len(self.uncontacted_peers) and \
                    shares_to_spread >= delta:
-                    # Loop through the allocated shares, removing 
-                    # one from each server that has more than one and putting
-                    # it back into self.homeless_shares until we've done
-                    # this delta times.
                     items = shares.items()
                     while len(self.homeless_shares) < delta:
hunk ./src/allmydata/immutable/upload.py 343
-                        servernum, sharelist = items.pop()
+                        # Loop through the allocated shares, removing
+                        # one from each server that has more than one
+                        # and putting it back into self.homeless_shares
+                        # until we've done this delta times.
+                        server, sharelist = items.pop()
                         if len(sharelist) > 1:
                             share = sharelist.pop()
                             self.homeless_shares.append(share)
hunk ./src/allmydata/immutable/upload.py 351
-                            del(self.preexisting_shares[share])
-                            items.append((servernum, sharelist))
+                            self.preexisting_shares[share].remove(server)
+                            if not self.preexisting_shares[share]:
+                                del self.preexisting_shares[share]
+                            items.append((server, sharelist))
                     return self._loop()
                 else:
hunk ./src/allmydata/immutable/upload.py 357
+                    # Redistribution won't help us; fail.
                     peer_count = len(list(set(self.peers_with_shares)))
                     # If peer_count < needed_shares, then the second error
                     # message is nonsensical, so we use this one.
hunk ./src/allmydata/immutable/upload.py 373
                     # Otherwise, if we've placed on at least needed_shares
                     # peers, but there isn't an x-happy subset of those peers
                     # for x < needed_shares, we use this error message.
-                    elif len(effective_happiness) < self.needed_shares:
+                    elif effective_happiness < self.needed_shares:
                         msg = ("shares could be placed or found on %d "
                                "server(s), but they are not spread out evenly "
                                "enough to ensure that any %d of these servers "
hunk ./src/allmydata/immutable/upload.py 387
                                 self.servers_of_happiness,
                                 self.needed_shares))
                     # Otherwise, if there is an x-happy subset of peers where
-                    # x >= needed_shares, but x < shares_of_happiness, then 
+                    # x >= needed_shares, but x < servers_of_happiness, then 
                     # we use this message.
                     else:
                         msg = ("shares could only be placed on %d server(s) "
hunk ./src/allmydata/immutable/upload.py 394
                                "such that any %d of them have enough shares "
                                "to recover the file, but we were asked to use "
                                "at least %d such servers." %
-                                               (len(effective_happiness),
+                                               (effective_happiness,
                                                 self.needed_shares,
                                                 self.servers_of_happiness))
                     raise UploadUnhappinessError(msg)
hunk ./src/allmydata/immutable/upload.py 446
         else:
             # no more peers. If we haven't placed enough shares, we fail.
             placed_shares = self.total_shares - len(self.homeless_shares)
-            effective_happiness = servers_with_unique_shares(
-                                                   self.preexisting_shares,
-                                                   self.use_peers)
-            if len(effective_happiness) < self.servers_of_happiness:
+            merged = merge_peers(self.preexisting_shares, self.use_peers)
+            effective_happiness = servers_of_happiness(merged)
+            if effective_happiness < self.servers_of_happiness:
                 msg = ("peer selection failed for %s: %s" % (self,
                                 self._get_progress_message()))
                 if self.last_failure_msg:
hunk ./src/allmydata/immutable/upload.py 491
                     level=log.NOISY, parent=self._log_parent)
             progress = False
             for s in alreadygot:
-                if should_add_server(self.preexisting_shares,
-                                     peer.peerid, s):
-                    self.preexisting_shares[s] = peer.peerid
-                    if s in self.homeless_shares:
-                        self.homeless_shares.remove(s)
+                self.preexisting_shares.setdefault(s, set()).add(peer.peerid)
+                if s in self.homeless_shares:
+                    self.homeless_shares.remove(s)
 
             # the PeerTracker will remember which shares were allocated on
             # that peer. We just have to remember to use them.
hunk ./src/allmydata/immutable/upload.py 908
     def set_shareholders(self, (used_peers, already_peers), encoder):
         """
         @param used_peers: a sequence of PeerTracker objects
-        @paran already_peers: a dict mapping sharenum to a peerid that
-                              claims to already have this share
+        @paran already_peers: a dict mapping sharenum to a set of peerids
+                              that claim to already have this share
         """
         self.log("_send_shares, used_peers is %s" % (used_peers,))
         # record already-present shares in self._results
hunk ./src/allmydata/immutable/upload.py 924
             buckets.update(peer.buckets)
             for shnum in peer.buckets:
                 self._peer_trackers[shnum] = peer
-                servermap[shnum] = peer.peerid
+                servermap.setdefault(shnum, set()).add(peer.peerid)
         assert len(buckets) == sum([len(peer.buckets) for peer in used_peers])
         encoder.set_shareholders(buckets, servermap)
 
hunk ./src/allmydata/interfaces.py 1348
         must be a dictionary that maps share number (an integer ranging from
         0 to n-1) to an instance that provides IStorageBucketWriter.
         'servermap' is a dictionary that maps share number (as defined above)
-        to a peerid. This must be performed before start() can be called."""
+        to a set of peerids. This must be performed before start() can be
+        called."""
 
     def start():
         """Begin the encode/upload process. This involves reading encrypted
addfile ./src/allmydata/util/happinessutil.py
hunk ./src/allmydata/util/happinessutil.py 1
+"""
+I contain utilities useful for calculating servers_of_happiness
+"""
+
+def shares_by_server(servermap):
+    """
+    I accept a dict of shareid -> set(peerid) mappings, and return a
+    dict of peerid -> set(shareid) mappings. My argument is a dictionary
+    with sets of peers, indexed by shares, and I transform that into a
+    dictionary of sets of shares, indexed by peerids.
+    """
+    ret = {}
+    for shareid, peers in servermap.iteritems():
+        assert isinstance(peers, set)
+        for peerid in peers:
+            ret.setdefault(peerid, set()).add(shareid)
+    return ret
+
+def merge_peers(servermap, used_peers=None):
+    """
+    I accept a dict of shareid -> set(peerid) mappings, and optionally a
+    set of PeerTrackers. If no set of PeerTrackers is provided, I return
+    my first argument unmodified. Otherwise, I update a copy of my first
+    argument to include the shareid -> peerid mappings implied in the
+    set of PeerTrackers, returning the resulting dict.
+    """
+    if not used_peers:
+        return servermap
+
+    assert(isinstance(servermap, dict))
+    assert(isinstance(used_peers, set))
+
+    # Since we mutate servermap, and are called outside of a 
+    # context where it is okay to do that, make a copy of servermap and
+    # work with it.
+    servermap = servermap.copy()
+    for peer in used_peers:
+        for shnum in peer.buckets:
+            servermap.setdefault(shnum, set()).add(peer.peerid)
+    return servermap
+
+def servers_of_happiness(sharemap):
+    """
+    I accept 'sharemap', a dict of shareid -> set(peerid) mappings. I
+    return the 'servers_of_happiness' number that sharemap results in.
+
+    To calculate the 'servers_of_happiness' number for the sharemap, I
+    construct a bipartite graph with servers in one partition of vertices
+    and shares in the other, and with an edge between a server s and a share t
+    if s is to store t. I then compute the size of a maximum matching in
+    the resulting graph; this is then returned as the 'servers_of_happiness'
+    for my arguments.
+
+    For example, consider the following layout:
+
+      server 1: shares 1, 2, 3, 4
+      server 2: share 6
+      server 3: share 3
+      server 4: share 4
+      server 5: share 2
+
+    From this, we can construct the following graph:
+
+      L = {server 1, server 2, server 3, server 4, server 5}
+      R = {share 1, share 2, share 3, share 4, share 6}
+      V = L U R
+      E = {(server 1, share 1), (server 1, share 2), (server 1, share 3),
+           (server 1, share 4), (server 2, share 6), (server 3, share 3),
+           (server 4, share 4), (server 5, share 2)}
+      G = (V, E)
+
+    Note that G is bipartite since every edge in e has one endpoint in L
+    and one endpoint in R.
+
+    A matching in a graph G is a subset M of E such that, for any vertex
+    v in V, v is incident to at most one edge of M. A maximum matching
+    in G is a matching that is no smaller than any other matching. For
+    this graph, a matching of cardinality 5 is:
+
+      M = {(server 1, share 1), (server 2, share 6),
+           (server 3, share 3), (server 4, share 4),
+           (server 5, share 2)}
+
+    Since G is bipartite, and since |L| = 5, we cannot have an M' such
+    that |M'| > |M|. Then M is a maximum matching in G. Intuitively, and
+    as long as k <= 5, we can see that the layout above has
+    servers_of_happiness = 5, which matches the results here.
+    """
+    if sharemap == {}:
+        return 0
+    sharemap = shares_by_server(sharemap)
+    graph = flow_network_for(sharemap)
+    # This is an implementation of the Ford-Fulkerson method for finding
+    # a maximum flow in a flow network applied to a bipartite graph. 
+    # Specifically, it is the Edmonds-Karp algorithm, since it uses a 
+    # BFS to find the shortest augmenting path at each iteration, if one
+    # exists. 
+    # 
+    # The implementation here is an adapation of an algorithm described in 
+    # "Introduction to Algorithms", Cormen et al, 2nd ed., pp 658-662. 
+    dim = len(graph)
+    flow_function = [[0 for sh in xrange(dim)] for s in xrange(dim)]
+    residual_graph, residual_function = residual_network(graph, flow_function)
+    while augmenting_path_for(residual_graph):
+        path = augmenting_path_for(residual_graph)
+        # Delta is the largest amount that we can increase flow across
+        # all of the edges in path. Because of the way that the residual
+        # function is constructed, f[u][v] for a particular edge (u, v)
+        # is the amount of unused capacity on that edge. Taking the
+        # minimum of a list of those values for each edge in the
+        # augmenting path gives us our delta.
+        delta = min(map(lambda (u, v): residual_function[u][v], path))
+        for (u, v) in path:
+            flow_function[u][v] += delta
+            flow_function[v][u] -= delta
+        residual_graph, residual_function = residual_network(graph,
+                                                             flow_function)
+    num_servers = len(sharemap)
+    # The value of a flow is the total flow out of the source vertex
+    # (vertex 0, in our graph). We could just as well sum across all of
+    # f[0], but we know that vertex 0 only has edges to the servers in
+    # our graph, so we can stop after summing flow across those. The
+    # value of a flow computed in this way is the size of a maximum
+    # matching on the bipartite graph described above.
+    return sum([flow_function[0][v] for v in xrange(1, num_servers+1)])
+
+def flow_network_for(sharemap):
+    """
+    I take my argument, a dict of peerid -> set(shareid) mappings, and
+    turn it into a flow network suitable for use with Edmonds-Karp. I
+    then return the adjacency list representation of that network.
+
+    Specifically, I build G = (V, E), where:
+      V = { peerid in sharemap } U { shareid in sharemap } U {s, t}
+      E = {(s, peerid) for each peerid}
+          U {(peerid, shareid) if peerid is to store shareid }
+          U {(shareid, t) for each shareid}
+
+    s and t will be source and sink nodes when my caller starts treating
+    the graph I return like a flow network. Without s and t, the
+    returned graph is bipartite.
+    """
+    # Servers don't have integral identifiers, and we can't make any
+    # assumptions about the way shares are indexed -- it's possible that
+    # there are missing shares, for example. So before making a graph,
+    # we re-index so that all of our vertices have integral indices, and
+    # that there aren't any holes. We start indexing at 1, so that we
+    # can add a source node at index 0.
+    sharemap, num_shares = reindex(sharemap, base_index=1)
+    num_servers = len(sharemap)
+    graph = [] # index -> [index], an adjacency list
+    # Add an entry at the top (index 0) that has an edge to every server
+    # in sharemap 
+    graph.append(sharemap.keys())
+    # For each server, add an entry that has an edge to every share that it
+    # contains (or will contain).
+    for k in sharemap:
+        graph.append(sharemap[k])
+    # For each share, add an entry that has an edge to the sink.
+    sink_num = num_servers + num_shares + 1
+    for i in xrange(num_shares):
+        graph.append([sink_num])
+    # Add an empty entry for the sink, which has no outbound edges.
+    graph.append([])
+    return graph
+
+def reindex(sharemap, base_index):
+    """
+    Given sharemap, I map peerids and shareids to integers that don't
+    conflict with each other, so they're useful as indices in a graph. I
+    return a sharemap that is reindexed appropriately, and also the
+    number of distinct shares in the resulting sharemap as a convenience
+    for my caller. base_index tells me where to start indexing.
+    """
+    shares  = {} # shareid  -> vertex index
+    num = base_index
+    ret = {} # peerid -> [shareid], a reindexed sharemap.
+    # Number the servers first
+    for k in sharemap:
+        ret[num] = sharemap[k]
+        num += 1
+    # Number the shares
+    for k in ret:
+        for shnum in ret[k]:
+            if not shares.has_key(shnum):
+                shares[shnum] = num
+                num += 1
+        ret[k] = map(lambda x: shares[x], ret[k])
+    return (ret, len(shares))
+
+def residual_network(graph, f):
+    """
+    I return the residual network and residual capacity function of the
+    flow network represented by my graph and f arguments. graph is a
+    flow network in adjacency-list form, and f is a flow in graph.
+    """
+    new_graph = [[] for i in xrange(len(graph))]
+    cf = [[0 for s in xrange(len(graph))] for sh in xrange(len(graph))]
+    for i in xrange(len(graph)):
+        for v in graph[i]:
+            if f[i][v] == 1:
+                # We add an edge (v, i) with cf[v,i] = 1. This means
+                # that we can remove 1 unit of flow from the edge (i, v) 
+                new_graph[v].append(i)
+                cf[v][i] = 1
+                cf[i][v] = -1
+            else:
+                # We add the edge (i, v), since we're not using it right
+                # now.
+                new_graph[i].append(v)
+                cf[i][v] = 1
+                cf[v][i] = -1
+    return (new_graph, cf)
+
+def augmenting_path_for(graph):
+    """
+    I return an augmenting path, if there is one, from the source node
+    to the sink node in the flow network represented by my graph argument.
+    If there is no augmenting path, I return False. I assume that the
+    source node is at index 0 of graph, and the sink node is at the last
+    index. I also assume that graph is a flow network in adjacency list
+    form.
+    """
+    bfs_tree = bfs(graph, 0)
+    if bfs_tree[len(graph) - 1]:
+        n = len(graph) - 1
+        path = [] # [(u, v)], where u and v are vertices in the graph
+        while n != 0:
+            path.insert(0, (bfs_tree[n], n))
+            n = bfs_tree[n]
+        return path
+    return False
+
+def bfs(graph, s):
+    """
+    Perform a BFS on graph starting at s, where graph is a graph in
+    adjacency list form, and s is a node in graph. I return the
+    predecessor table that the BFS generates.
+    """
+    # This is an adaptation of the BFS described in "Introduction to
+    # Algorithms", Cormen et al, 2nd ed., p. 532.
+    # WHITE vertices are those that we haven't seen or explored yet.
+    WHITE = 0
+    # GRAY vertices are those we have seen, but haven't explored yet
+    GRAY  = 1
+    # BLACK vertices are those we have seen and explored
+    BLACK = 2
+    color        = [WHITE for i in xrange(len(graph))]
+    predecessor  = [None for i in xrange(len(graph))]
+    distance     = [-1 for i in xrange(len(graph))]
+    queue = [s] # vertices that we haven't explored yet.
+    color[s] = GRAY
+    distance[s] = 0
+    while queue:
+        n = queue.pop(0)
+        for v in graph[n]:
+            if color[v] == WHITE:
+                color[v] = GRAY
+                distance[v] = distance[n] + 1
+                predecessor[v] = n
+                queue.append(v)
+        color[n] = BLACK
+    return predecessor
}

Context:

[web/storage.py: display total-seen on the last-complete-cycle line. For #940.
Brian Warner <warner@lothar.com>**20100208002010
 Ignore-this: c0ed860f3e9628d3171d2b055d96c5aa
] 
[adding pycrypto to the auto dependencies
secorp@allmydata.com**20100206054314
 Ignore-this: b873fc00a6a5b001d30d479e6053cf2f
] 
[docs running.html - "tahoe run ." does not work with the current installation, replaced with "tahoe start ."
secorp@allmydata.com**20100206165320
 Ignore-this: fdb2dcb0e417d303cd43b1951a4f8c03
] 
[code coverage: replace figleaf with coverage.py, should work on py2.6 now.
Brian Warner <warner@lothar.com>**20100203165421
 Ignore-this: 46ab590360be6a385cb4fc4e68b6b42c
 
 It still lacks the right HTML report (the builtin report is very pretty, but
 lacks the "lines uncovered" numbers that I want), and the half-finished
 delta-from-last-run measurements.
] 
[More comprehensive changes and ticket references for NEWS
david-sarah@jacaranda.org**20100202061256
 Ignore-this: 696cf0106e8a7fd388afc5b55fba8a1b
] 
[docs: install.html: link into Python 2.5.5 download page
zooko@zooko.com**20100202065852
 Ignore-this: 1a9471b8175b7de5741d8445a7ede29d
] 
[TAG allmydata-tahoe-1.6.0
zooko@zooko.com**20100202061125
 Ignore-this: dee6ade7ac1452cf5d1d9c69a8146d84
] 
[docs: install.html: recommend Python 2.5 (because I can build extension modules for it with mingw), architecture.txt: point out that our Proof of Retrievability feature is client-side-only
zooko@zooko.com**20100202053842
 Ignore-this: e33fd413a91771c77b17d7de0f215bea
] 
[architecture.txt: remove trailing whitespace, wrap lines: no content changes
Brian Warner <warner@lothar.com>**20100202055304
 Ignore-this: 1662f37d1162858ac2619db27bcc411f
] 
[docs: a couple of small edits to release notes (thanks Peter)
zooko@zooko.com**20100202054832
 Ignore-this: 1d0963c43ff19c92775b124c49c8a88a
] 
[docs: CREDITS: where due
zooko@zooko.com**20100202053831
 Ignore-this: 11646dd603ac715ae8277a4bb9562215
] 
[docs: a few small edits to performance.txt and README
zooko@zooko.com**20100202052750
 Ignore-this: bf8b1b7438e8fb6da09eec9713c78533
] 
[docs: a few edits to architecture.txt, most significantly highlighting "future work" to avoid confusing it with the current version, and adding a "future work" about a random-sampling Proof of Retrievability verifier
zooko@zooko.com**20100202045117
 Ignore-this: 81122b3042ea9ee6bc12e795c2386d59
] 
[docs: a few edits and updates to relnotes.txt, relnotes-short.txt, and NEWS in preparation for v1.6.0
zooko@zooko.com**20100202043222
 Ignore-this: d90c644fa61d78e33cbdf0be428bb07a
] 
[Document leakage of cap URLs via phishing filters in known_issues.txt
david-sarah@jacaranda.org**20100202015238
 Ignore-this: 78e668dbca77c0e3a73e10c0b74cf024
] 
[docs: updates to relnotes.txt, NEWS, architecture, historical_known_issues, install.html, etc.
zooko@zooko.com**20100201181809
 Ignore-this: f4fc924652af746862c8ee4d9ba97bf6
] 
[immutable: downloader accepts notifications of buckets even if those notifications arrive after he has begun downloading shares.
zooko@zooko.com**20100201061610
 Ignore-this: 5b09709f27603a3157eba7ba70028955
 This can be useful if one of the ones that he has already begun downloading fails. See #287 for discussion. This fixes part of #287 which part was a regression caused by #928, namely this fixes fail-over in case a share is corrupted (or the server returns an error or disconnects). This does not fix the related issue mentioned in #287 if a server hangs and doesn't reply to requests for blocks.
 
] 
[tests: don't require tahoe to run with no noise if we are using an old twisted that emits DeprecationWarnings
zooko@zooko.com**20100201052323
 Ignore-this: 69668c772cce612a0c6936a2195ebd2a
] 
[Use if instead of assert to check for twisted ftp patch
david-sarah@jacaranda.org**20100127015529
 Ignore-this: 66959d946bd1a835ece6f074e75086b2
] 
[tests: stop being surprised that Nevow no longer prints out warnings when it tries to find its static files
zooko@zooko.com**20100201041144
 Ignore-this: 77b4ac383165d98dfe2a9008ce794742
 Unless we are using a sufficiently new version of Nevow, in which case if it prints out warnings then this is a hard test failure. :-)
] 
[cli: suppress DeprecationWarnings emitted from importing nevow and twisted. Fixes #859
david-sarah@jacaranda.org**20100201004429
 Ignore-this: 22d7216921cd5f04381c0194ed501bbe
] 
[Fill in 'docs/performance.txt' with some performance information
Kevan Carstensen <kevan@isnotajoke.com>**20100202005914
 Ignore-this: c66b255b2bd2e7e11f5707b25e7b38be
] 
[Improvements to test_unknownnode to cover invalid cap URIs with known prefixes
david-sarah@jacaranda.org**20100130063908
 Ignore-this: e1a298942c21207473e418ea5efd6276
] 
[Fix invalid trailing commas in JSON example
david-sarah@jacaranda.org**20100129201742
 Ignore-this: d99e0a8ead4fafabf39a1daf11ec450b
] 
[Improvements to test_hung_server, and fix for status updates in download.py
david-sarah@jacaranda.org**20100130064303
 Ignore-this: dd889c643afdcf0f86d55855aafda6ad
] 
[immutable: fix bug in tests, change line-endings to unix style, add comment
zooko@zooko.com**20100129184237
 Ignore-this: f6bd875fe974c55c881e05eddf8d3436
] 
[New tests for #928
david-sarah@jacaranda.org**20100129123845
 Ignore-this: 5c520f40141f0d9c000ffb05a4698995
] 
[immutable: download from the first servers which provide at least K buckets instead of waiting for all servers to reply
zooko@zooko.com**20100127233417
 Ignore-this: c855355a40d96827e1d0c469a8d8ab3f
 This should put an end to the phenomenon I've been seeing that a single hung server can cause all downloads on a grid to hang.  Also it should speed up all downloads by (a) not-waiting for responses to queries that it doesn't need, and (b) downloading shares from the servers which answered the initial query the fastest.
 Also, do not count how many buckets you've gotten when deciding whether the download has enough shares or not -- instead count how many buckets to *unique* shares that you've gotten.  This appears to improve a slightly weird behavior in the current download code in which receiving >= K different buckets all to the same sharenumber would make it think it had enough to download the file when in fact it hadn't.
 This patch needs tests before it is actually ready for trunk.
] 
[Eliminate 'foo if test else bar' syntax that isn't supported by Python 2.4
david-sarah@jacaranda.org**20100129035210
 Ignore-this: 70eafd487b4b6299beedd63b4a54a0c
] 
[Fix example JSON in webapi.txt that cannot occur in practice
david-sarah@jacaranda.org**20100129032742
 Ignore-this: 361a1ba663d77169aeef93caef870097
] 
[Add mutable field to t=json output for unknown nodes, when mutability is known
david-sarah@jacaranda.org**20100129031424
 Ignore-this: 1516d63559bdfeb6355485dff0f5c04e
] 
[Show -IMM and -RO suffixes for types of immutable and read-only unknown nodes in directory listings
david-sarah@jacaranda.org**20100128220800
 Ignore-this: dc5c17c0a566398f88e4303c41321e66
] 
[Fix inaccurate comment in test_mutant_dirnodes_are_omitted
david-sarah@jacaranda.org**20100128202456
 Ignore-this: 9fa17ed7feac9e4d084f1b2338c76fca
] 
[docs: update relnotes.txt for Tahoe-LAFS v1.6
zooko@zooko.com**20100128171257
 Ignore-this: 920df92152aead69ef861b9b2e8ff218
] 
[Address comments by Kevan on 833 and add test for stripping spaces
david-sarah@jacaranda.org**20100127230642
 Ignore-this: de36aeaf4afb3ba05dbeb49a5e9a6b26
] 
[Miscellaneous documentation, test, and code formatting tweaks.
david-sarah@jacaranda.org**20100127070309
 Ignore-this: 84ca7e4bb7c64221ae2c61144ef5edef
] 
[Prevent mutable objects from being retrieved from an immutable directory, and associated forward-compatibility improvements.
david-sarah@jacaranda.org**20100127064430
 Ignore-this: 5ef6a3554cf6bef0bf0712cc7d6c0252
] 
[test_runner: cleanup, refactor common code into a non-executable method
Brian Warner <warner@lothar.com>**20100127224040
 Ignore-this: 4cb4aada87777771f688edfd8129ffca
 
 Having both test_node() and test_client() (one of which calls the other) felt
 confusing to me, so I changed it to have test_node(), test_client(), and a
 common do_create() helper method.
] 
[scripts/runner.py: simplify David-Sarah's clever grouped-commands usage trick
Brian Warner <warner@lothar.com>**20100127223758
 Ignore-this: 70877ebf06ae59f32960b0aa4ce1d1ae
] 
[tahoe backup: skip all symlinks, with warning. Fixes #850, addresses #641.
Brian Warner <warner@lothar.com>**20100127223517
 Ignore-this: ab5cf05158d32a575ca8efc0f650033f
] 
[NEWS: update with all recent user-visible changes
Brian Warner <warner@lothar.com>**20100127222209
 Ignore-this: 277d24568018bf4f3fb7736fda64eceb
] 
["tahoe backup": fix --exclude-vcs docs to include Git
Brian Warner <warner@lothar.com>**20100127201044
 Ignore-this: 756a58dde21bdc65aa62b81803605b5
] 
[docs: fix references to --no-storage, explanation of [storage] section
Brian Warner <warner@lothar.com>**20100127200956
 Ignore-this: f4be1763a585e1ac6299a4f1b94a59e0
] 
[docs: further CREDITS level-ups for Nils, Kevan, David-Sarah
zooko@zooko.com**20100126170021
 Ignore-this: 1e513e85cf7b7abf57f056e6d7544b38
] 
[Patch to accept t=set-children as well as t=set_children
david-sarah@jacaranda.org**20100124030020
 Ignore-this: 2c061f12af817cdf77feeeb64098ec3a
] 
[Fix boodlegrid use of set_children
david-sarah@jacaranda.org**20100126063414
 Ignore-this: 3aa2d4836f76303b2bacecd09611f999
] 
[ftpd: clearer error message if Twisted needs a patch (by Nils Durner)
zooko@zooko.com**20100126143411
 Ignore-this: 440e6831ae6da5135c1edd081c93871f
] 
[Add 'docs/performance.txt', which (for the moment) describes mutable file performance issues
Kevan Carstensen <kevan@isnotajoke.com>**20100115204500
 Ignore-this: ade4e500217db2509aee35aacc8c5dbf
] 
[docs: more CREDITS for François, Kevan, and David-Sarah
zooko@zooko.com**20100126132133
 Ignore-this: f37d4977c13066fcac088ba98a31b02e
] 
[tahoe_backup.py: display warnings on errors instead of stopping the whole backup. Fix #729.
francois@ctrlaltdel.ch**20100120094249
 Ignore-this: 7006ea4b0910b6d29af6ab4a3997a8f9
 
 This patch displays a warning to the user in two cases:
   
   1. When special files like symlinks, fifos, devices, etc. are found in the
      local source.
   
   2. If files or directories are not readables by the user running the 'tahoe
      backup' command.
 
 In verbose mode, the number of skipped files and directories is printed at the
 end of the backup.
 
 Exit status returned by 'tahoe backup':
 
   - 0 everything went fine
   - 1 the backup failed
   - 2 files were skipped during the backup
 
] 
[Warn about test failures due to setting FLOG* env vars
david-sarah@jacaranda.org**20100124220629
 Ignore-this: 1c25247ca0f0840390a1b7259a9f4a3c
] 
[Message saying that we couldn't find bin/tahoe should say where we looked
david-sarah@jacaranda.org**20100116204556
 Ignore-this: 1068576fd59ea470f1e19196315d1bb
] 
[Change running.html to describe 'tahoe run'
david-sarah@jacaranda.org**20100112044409
 Ignore-this: 23ad0114643ce31b56e19bb14e011e4f
] 
[cli: merge the better version of David-Sarah's split-usage-and-help patch with the earlier version that I mistakenly committed
zooko@zooko.com**20100126044559
 Ignore-this: 284d188e13b7901013cbb650168e6447
] 
[Split tahoe --help options into groups.
david-sarah@jacaranda.org**20100112043935
 Ignore-this: 610f9c41b00e6863e3cd047379733e3a
] 
[cli: split usage strings into groups (patch by David-Sarah Hopwood)
zooko@zooko.com**20100126043921
 Ignore-this: 51928d266a7292b873f87f7d53c9a01e
] 
[Add create-node CLI command, and make create-client equivalent to create-node --no-storage (fixes #760)
david-sarah@jacaranda.org**20100116052055
 Ignore-this: 47d08b18c69738685e13ff365738d5a
] 
[Remove replace= parameter to mkdir-immutable and mkdir-with-children
david-sarah@jacaranda.org**20100124224325
 Ignore-this: 25207bcc946c0c43d9528718e76ba7b
] 
[contrib/fuse/runtests.py: Fix #888, configure settings in tahoe.cfg and don't treat warnings as failure
francois@ctrlaltdel.ch**20100109123010
 Ignore-this: 2590d44044acd7dfa3690c416cae945c
 
 Fix a few bitrotten pieces in the FUSE test script.  It now configures tahoe
 node settings by editing tahoe.cfg which is the new supported method.
 
 It alos tolerate warnings issued by the mount command, the cause of these
 warnings is the same as in #876 (contrib/fuse/runtests.py doesn't tolerate
 deprecations warnings).
 
] 
[Fix webapi t=mkdir with multpart/form-data, as on the Welcome page. Closes #919.
Brian Warner <warner@lothar.com>**20100121065052
 Ignore-this: 1f20ea0a0f1f6d6c1e8e14f193a92c87
] 
[tahoe_add_alias.py: minor refactoring
Brian Warner <warner@lothar.com>**20100115064220
 Ignore-this: 29910e81ad11209c9e493d65fd2dab9b
] 
[test_dirnode.py: reduce scope of a Client instance, suggested by Kevan.
Brian Warner <warner@lothar.com>**20100115062713
 Ignore-this: b35efd9e6027e43de6c6f509bfb4ccaa
] 
[test_provisioning: STAN is not always a list. Fix by David-Sarah Hopwood.
Brian Warner <warner@lothar.com>**20100115014632
 Ignore-this: 9989de7f1e00907706d2b63153138219
] 
[web/directory.py mkdir-immutable: hush pyflakes, add TODO for #903 behavior
Brian Warner <warner@lothar.com>**20100114222804
 Ignore-this: 717cd3b9a1c8aeee76938c9641db7356
] 
[hush pyflakes-0.4.0 warnings: slightly less-trivial fixes. Closes #900.
Brian Warner <warner@lothar.com>**20100114221719
 Ignore-this: f774f4637e256ad55502659413a811a8
 
 This includes one fix (in test_web) which was testing the wrong thing.
] 
[hush pyflakes-0.4.0 warnings: remove trivial unused variables. For #900.
Brian Warner <warner@lothar.com>**20100114221529
 Ignore-this: e96106c8f1a99fbf93306fbfe9a294cf
] 
[tahoe add-alias/create-alias: don't corrupt non-newline-terminated alias
Brian Warner <warner@lothar.com>**20100114210246
 Ignore-this: 9c994792e53a85159d708760a9b1b000
 file. Closes #741.
] 
[change docs and --help to use "grid" instead of "virtual drive": closes #892.
Brian Warner <warner@lothar.com>**20100114201119
 Ignore-this: a20d4a4dcc4de4e3b404ff72d40fc29b
 
 Thanks to David-Sarah Hopwood for the patch.
] 
[backupdb.txt: fix ST_CTIME reference
Brian Warner <warner@lothar.com>**20100114194052
 Ignore-this: 5a189c7a1181b07dd87f0a08ea31b6d3
] 
[client.py: fix/update comments on KeyGenerator
Brian Warner <warner@lothar.com>**20100113004226
 Ignore-this: 2208adbb3fd6a911c9f44e814583cabd
] 
[Clean up log.err calls, for one of the issues in #889.
Brian Warner <warner@lothar.com>**20100112013343
 Ignore-this: f58455ce15f1fda647c5fb25d234d2db
 
 allmydata.util.log.err() either takes a Failure as the first positional
 argument, or takes no positional arguments and must be invoked in an
 exception handler. Fixed its signature to match both foolscap.logging.log.err
 and twisted.python.log.err . Included a brief unit test.
] 
[tidy up DeadReferenceError handling, ignore them in add_lease calls
Brian Warner <warner@lothar.com>**20100112000723
 Ignore-this: 72f1444e826fd0b9db6d318f89603c38
 
 Stop checking separately for ConnectionDone/ConnectionLost, since those have
 been folded into DeadReferenceError since foolscap-0.3.1 . Write
 rrefutil.trap_deadref() in terms of rrefutil.trap_and_discard() to improve
 code coverage.
] 
[NEWS: improve "tahoe backup" notes, mention first-backup-after-upgrade duration
Brian Warner <warner@lothar.com>**20100111190132
 Ignore-this: 10347c590b3375964579ba6c2b0edb4f
 
 Thanks to Francois Deppierraz for the suggestion.
] 
[test_repairer: add (commented-out) test_each_byte, to see exactly what the
Brian Warner <warner@lothar.com>**20100110203552
 Ignore-this: 8e84277d5304752edeff052b97821815
 Verifier misses
 
 The results (described in #819) match our expectations: it misses corruption
 in unused share fields and in most container fields (which are only visible
 to the storage server, not the client). 1265 bytes of a 2753 byte
 share (hosting a 56-byte file with an artifically small segment size) are
 unused, mostly in the unused tail of the overallocated UEB space (765 bytes),
 and the allocated-but-unwritten plaintext_hash_tree (480 bytes).
] 
[repairer: fix some wrong offsets in the randomized verifier tests, debugged by Brian
zooko@zooko.com**20100110203721
 Ignore-this: 20604a609db8706555578612c1c12feb
 fixes #819
] 
[test_repairer: fix colliding basedir names, which caused test inconsistencies
Brian Warner <warner@lothar.com>**20100110084619
 Ignore-this: b1d56dd27e6ab99a7730f74ba10abd23
] 
[repairer: add deterministic test for #819, mark as TODO
zooko@zooko.com**20100110013619
 Ignore-this: 4cb8bb30b25246de58ed2b96fa447d68
] 
[contrib/fuse/runtests.py: Tolerate the tahoe CLI returning deprecation warnings
francois@ctrlaltdel.ch**20100109175946
 Ignore-this: 419c354d9f2f6eaec03deb9b83752aee
 
 Depending on the versions of external libraries such as Twisted of Foolscap,
 the tahoe CLI can display deprecation warnings on stdout.  The tests should
 not interpret those warnings as a failure if the node is in fact correctly
 started.
   
 See http://allmydata.org/trac/tahoe/ticket/859 for an example of deprecation
 warnings.
 
 fixes #876
] 
[contrib: fix fuse_impl_c to use new Python API
zooko@zooko.com**20100109174956
 Ignore-this: 51ca1ec7c2a92a0862e9b99e52542179
 original patch by Thomas Delaet, fixed by François, reviewed by Brian, committed by me
] 
[docs: CREDITS: add David-Sarah to the CREDITS file
zooko@zooko.com**20100109060435
 Ignore-this: 896062396ad85f9d2d4806762632f25a
] 
[mutable/publish: don't loop() right away upon DeadReferenceError. Closes #877
Brian Warner <warner@lothar.com>**20100102220841
 Ignore-this: b200e707b3f13aa8251981362b8a3e61
 
 The bug was that a disconnected server could cause us to re-enter the initial
 loop() call, sending multiple queries to a single server, provoking an
 incorrect UCWE. To fix it, stall the loop() with an eventual.fireEventually()
] 
[immutable/checker.py: oops, forgot some imports. Also hush pyflakes.
Brian Warner <warner@lothar.com>**20091229233909
 Ignore-this: 4d61bd3f8113015a4773fd4768176e51
] 
[mutable repair: return successful=False when numshares<k (thus repair fails),
Brian Warner <warner@lothar.com>**20091229233746
 Ignore-this: d881c3275ff8c8bee42f6a80ca48441e
 instead of weird errors. Closes #874 and #786.
 
 Previously, if the file had 0 shares, this would raise TypeError as it tried
 to call download_version(None). If the file had some shares but fewer than
 'k', it would incorrectly raise MustForceRepairError.
 
 Added get_successful() to the IRepairResults API, to give repair() a place to
 report non-code-bug problems like this.
] 
[node.py/interfaces.py: minor docs fixes
Brian Warner <warner@lothar.com>**20091229230409
 Ignore-this: c86ad6342ef0f95d50639b4f99cd4ddf
] 
[NEWS: fix 1.4.1 announcement w.r.t. add-lease behavior in older releases
Brian Warner <warner@lothar.com>**20091229230310
 Ignore-this: bbbbb9c961f3bbcc6e5dbe0b1594822
] 
[checker: don't let failures in add-lease affect checker results. Closes #875.
Brian Warner <warner@lothar.com>**20091229230108
 Ignore-this: ef1a367b93e4d01298c2b1e6ca59c492
 
 Mutable servermap updates and the immutable checker, when run with
 add_lease=True, send both the do-you-have-block and add-lease commands in
 parallel, to avoid an extra round trip time. Many older servers have problems
 with add-lease and raise various exceptions, which don't generally matter.
 The client-side code was catching+ignoring some of them, but unrecognized
 exceptions were passed through to the DYHB code, concealing the DYHB results
 from the checker, making it think the server had no shares.
 
 The fix is to separate the code paths. Both commands are sent at the same
 time, but the errback path from add-lease is handled separately. Known
 exceptions are ignored, the others (both unknown-remote and all-local) are
 logged (log.WEIRD, which will trigger an Incident), but neither will affect
 the DYHB results.
 
 The add-lease message is sent first, and we know that the server handles them
 synchronously. So when the checker is done, we can be sure that all the
 add-lease messages have been retired. This makes life easier for unit tests.
] 
[test_cli: verify fix for "tahoe get" not creating empty file on error (#121)
Brian Warner <warner@lothar.com>**20091227235444
 Ignore-this: 6444d52413b68eb7c11bc3dfdc69c55f
] 
[addendum to "Fix 'tahoe ls' on files (#771)"
Brian Warner <warner@lothar.com>**20091227232149
 Ignore-this: 6dd5e25f8072a3153ba200b7fdd49491
 
 tahoe_ls.py: tolerate missing metadata
 web/filenode.py: minor cleanups
 test_cli.py: test 'tahoe ls FILECAP'
] 
[Fix 'tahoe ls' on files (#771). Patch adapted from Kevan Carstensen.
Brian Warner <warner@lothar.com>**20091227225443
 Ignore-this: 8bf8c7b1cd14ea4b0ebd453434f4fe07
 
 web/filenode.py: also serve edge metadata when using t=json on a
                  DIRCAP/childname object.
 tahoe_ls.py: list file objects as if we were listing one-entry directories.
              Show edge metadata if we have it, which will be true when doing
              'tahoe ls DIRCAP/filename' and false when doing 'tahoe ls
              FILECAP'
] 
[tahoe_get: don't create the output file on error. Closes #121.
Brian Warner <warner@lothar.com>**20091227220404
 Ignore-this: 58d5e793a77ec6e87d9394ade074b926
] 
[webapi: don't accept zero-length childnames during traversal. Closes #358, #676.
Brian Warner <warner@lothar.com>**20091227201043
 Ignore-this: a9119dec89e1c7741f2289b0cad6497b
 
 This forbids operations that would implicitly create a directory with a
 zero-length (empty string) name, like what you'd get if you did "tahoe put
 local /oops/blah" (#358) or "POST /uri/CAP//?t=mkdir" (#676). The error
 message is fairly friendly too.
 
 Also added code to "tahoe put" to catch this error beforehand and suggest the
 correct syntax (i.e. without the leading slash).
] 
[CLI: send 'Accept:' header to ask for text/plain tracebacks. Closes #646.
Brian Warner <warner@lothar.com>**20091227195828
 Ignore-this: 44c258d4d4c7dac0ed58adb22f73331
 
 The webapi has been looking for an Accept header since 1.4.0, but it treats a
 missing header as equal to */* (to honor RFC2616). This change finally
 modifies our CLI tools to ask for "text/plain, application/octet-stream",
 which seems roughly correct (we either want a plain-text traceback or error
 message, or an uninterpreted chunk of binary data to save to disk). Some day
 we'll figure out how JSON fits into this scheme.
] 
[Makefile: upload-tarballs: switch from xfer-client to flappclient, closes #350
Brian Warner <warner@lothar.com>**20091227163703
 Ignore-this: 3beeecdf2ad9c2438ab57f0e33dcb357
 
 I've also set up a new flappserver on source@allmydata.org to receive the
 tarballs. We still need to replace the gutsy buildslave (which is where the
 tarballs used to be generated+uploaded) and give it the new FURL.
] 
[misc/ringsim.py: make it deterministic, more detail about grid-is-full behavior
Brian Warner <warner@lothar.com>**20091227024832
 Ignore-this: a691cc763fb2e98a4ce1767c36e8e73f
] 
[misc/ringsim.py: tool to discuss #302
Brian Warner <warner@lothar.com>**20091226060339
 Ignore-this: fc171369b8f0d97afeeb8213e29d10ed
] 
[docs: fix helper.txt to describe new config style
zooko@zooko.com**20091224223522
 Ignore-this: 102e7692dc414a4b466307f7d78601fe
] 
[docs/stats.txt: add TOC, notes about controlling gatherer's listening port
Brian Warner <warner@lothar.com>**20091224202133
 Ignore-this: 8eef63b0e18db5aa8249c2eafde02c05
 
 Thanks to Jody Harris for the suggestions.
] 
[Add docs/stats.py, explaining Tahoe stats, the gatherer, and the munin plugins.
Brian Warner <warner@lothar.com>**20091223052400
 Ignore-this: 7c9eeb6e5644eceda98b59a67730ccd5
] 
[more #859: avoid deprecation warning for unit tests too, hush pyflakes
Brian Warner <warner@lothar.com>**20091215000147
 Ignore-this: 193622e24d31077da825a11ed2325fd3
 
 * factor maybe-import-sha logic into util.hashutil
] 
[use hashlib module if available, thus avoiding a DeprecationWarning for importing the old sha module; fixes #859
zooko@zooko.com**20091214212703
 Ignore-this: 8d0f230a4bf8581dbc1b07389d76029c
] 
[docs: reflow architecture.txt to 78-char lines
zooko@zooko.com**20091208232943
 Ignore-this: 88f55166415f15192e39407815141f77
] 
[docs: update the about.html a little
zooko@zooko.com**20091208212737
 Ignore-this: 3fe2d9653c6de0727d3e82bd70f2a8ed
] 
[docs: remove obsolete doc file "codemap.txt"
zooko@zooko.com**20091113163033
 Ignore-this: 16bc21a1835546e71d1b344c06c61ebb
 I started to update this to reflect the current codebase, but then I thought (a) nobody seemed to notice that it hasn't been updated since December 2007, and (b) it will just bit-rot again, so I'm removing it.
] 
[mutable/retrieve.py: stop reaching into private MutableFileNode attributes
Brian Warner <warner@lothar.com>**20091208172921
 Ignore-this: 61e548798c1105aed66a792bf26ceef7
] 
[mutable/servermap.py: stop reaching into private MutableFileNode attributes
Brian Warner <warner@lothar.com>**20091208172608
 Ignore-this: b40a6b62f623f9285ad96fda139c2ef2
] 
[mutable/servermap.py: oops, query N+e servers in MODE_WRITE, not k+e
Brian Warner <warner@lothar.com>**20091208171156
 Ignore-this: 3497f4ab70dae906759007c3cfa43bc
 
 under normal conditions, this wouldn't cause any problems, but if the shares
 are really sparse (perhaps because new servers were added), then
 file-modifies might stop looking too early and leave old shares in place
] 
[control.py: fix speedtest: use download_best_version (not read) on mutable nodes
Brian Warner <warner@lothar.com>**20091207060512
 Ignore-this: 7125eabfe74837e05f9291dd6414f917
] 
[FTP-and-SFTP.txt: fix ssh-keygen pointer
Brian Warner <warner@lothar.com>**20091207052803
 Ignore-this: bc2a70ee8c58ec314e79c1262ccb22f7
] 
[setup: ignore _darcs in the "test-clean" test and make the "clean" step remove all .egg's in the root dir
zooko@zooko.com**20091206184835
 Ignore-this: 6066bd160f0db36d7bf60aba405558d2
] 
[remove MutableFileNode.download(), prefer download_best_version() instead
Brian Warner <warner@lothar.com>**20091201225438
 Ignore-this: 5733eb373a902063e09fd52cc858dec0
] 
[Simplify immutable download API: use just filenode.read(consumer, offset, size)
Brian Warner <warner@lothar.com>**20091201225330
 Ignore-this: bdedfb488ac23738bf52ae6d4ab3a3fb
 
 * remove Downloader.download_to_data/download_to_filename/download_to_filehandle
 * remove download.Data/FileName/FileHandle targets
 * remove filenode.download/download_to_data/download_to_filename methods
 * leave Downloader.download (the whole Downloader will go away eventually)
 * add util.consumer.MemoryConsumer/download_to_data, for convenience
   (this is mostly used by unit tests, but it gets used by enough non-test
    code to warrant putting it in allmydata.util)
 * update tests
 * removes about 180 lines of code. Yay negative code days!
 
 Overall plan is to rewrite immutable/download.py and leave filenode.read() as
 the sole read-side API.
] 
[server.py: undo my bogus 'correction' of David-Sarah's comment fix
Brian Warner <warner@lothar.com>**20091201024607
 Ignore-this: ff4bb58f6a9e045b900ac3a89d6f506a
 
 and move it to a better line
] 
[Implement more coherent behavior when copying with dircaps/filecaps (closes #761). Patch by Kevan Carstensen.
"Brian Warner <warner@lothar.com>"**20091130211009] 
[storage.py: update comment
"Brian Warner <warner@lothar.com>"**20091130195913] 
[storage server: detect disk space usage on Windows too (fixes #637)
david-sarah@jacaranda.org**20091121055644
 Ignore-this: 20fb30498174ce997befac7701fab056
] 
[make status of finished operations consistently "Finished"
david-sarah@jacaranda.org**20091121061543
 Ignore-this: 97d483e8536ccfc2934549ceff7055a3
] 
[NEWS: update with all user-visible changes since the last release
Brian Warner <warner@lothar.com>**20091127224217
 Ignore-this: 741da6cd928e939fb6d21a61ea3daf0b
] 
[update "tahoe backup" docs, and webapi.txt's mkdir-with-children
Brian Warner <warner@lothar.com>**20091127055900
 Ignore-this: defac1fb9a2335b0af3ef9dbbcc67b7e
] 
[Add dirnodes to backupdb and "tahoe backup", closes #606.
Brian Warner <warner@lothar.com>**20091126234257
 Ignore-this: fa88796fcad1763c6a2bf81f56103223
 
 * backups now share dirnodes with any previous backup, in any location,
   so renames and moves are handled very efficiently
 * "tahoe backup" no longer bothers reading the previous snapshot
 * if you switch grids, you should delete ~/.tahoe/private/backupdb.sqlite,
   to force new uploads of all files and directories
] 
[webapi: fix t=check for DIR2-LIT (i.e. empty immutable directories)
Brian Warner <warner@lothar.com>**20091126232731
 Ignore-this: 8513c890525c69c1eca0e80d53a231f8
] 
[PipelineError: fix str() on python2.4 . Closes #842.
Brian Warner <warner@lothar.com>**20091124212512
 Ignore-this: e62c92ea9ede2ab7d11fe63f43b9c942
] 
[test_uri.py: s/NewDirnode/Dirnode/ , now that they aren't "new" anymore
Brian Warner <warner@lothar.com>**20091120075553
 Ignore-this: 61c8ef5e45a9d966873a610d8349b830
] 
[interface name cleanups: IFileNode, IImmutableFileNode, IMutableFileNode
Brian Warner <warner@lothar.com>**20091120075255
 Ignore-this: e3d193c229e2463e1d0b0c92306de27f
 
 The proper hierarchy is:
  IFilesystemNode
  +IFileNode
  ++IMutableFileNode
  ++IImmutableFileNode
  +IDirectoryNode
 
 Also expand test_client.py (NodeMaker) to hit all IFilesystemNode types.
] 
[class name cleanups: s/FileNode/ImmutableFileNode/
Brian Warner <warner@lothar.com>**20091120072239
 Ignore-this: 4b3218f2d0e585c62827e14ad8ed8ac1
 
 also fix test/bench_dirnode.py for recent dirnode changes
] 
[Use DIR-IMM and t=mkdir-immutable for "tahoe backup", for #828
Brian Warner <warner@lothar.com>**20091118192813
 Ignore-this: a4720529c9bc6bc8b22a3d3265925491
] 
[web/directory.py: use "DIR-IMM" to describe immutable directories, not DIR-RO
Brian Warner <warner@lothar.com>**20091118191832
 Ignore-this: aceafd6ab4bf1cc0c2a719ef7319ac03
] 
[web/info.py: hush pyflakes
Brian Warner <warner@lothar.com>**20091118191736
 Ignore-this: edc5f128a2b8095fb20686a75747c8
] 
[make get_size/get_current_size consistent for all IFilesystemNode classes
Brian Warner <warner@lothar.com>**20091118191624
 Ignore-this: bd3449cf96e4827abaaf962672c1665a
 
 * stop caching most_recent_size in dirnode, rely upon backing filenode for it
 * start caching most_recent_size in MutableFileNode
 * return None when you don't know, not "?"
 * only render None as "?" in the web "more info" page
 * add get_size/get_current_size to UnknownNode
] 
[ImmutableDirectoryURIVerifier: fix verifycap handling
Brian Warner <warner@lothar.com>**20091118164238
 Ignore-this: 6bba5c717b54352262eabca6e805d590
] 
[Add t=mkdir-immutable to the webapi. Closes #607.
Brian Warner <warner@lothar.com>**20091118070900
 Ignore-this: 311e5fab9a5f28b9e8a28d3d08f3c0d
 
 * change t=mkdir-with-children to not use multipart/form encoding. Instead,
   the request body is all JSON. t=mkdir-immutable uses this format too.
 * make nodemaker.create_immutable_dirnode() get convergence from SecretHolder,
   but let callers override it
 * raise NotDeepImmutableError instead of using assert()
 * add mutable= argument to DirectoryNode.create_subdirectory(), default True
] 
[move convergence secret into SecretHolder, next to lease secret
Brian Warner <warner@lothar.com>**20091118015444
 Ignore-this: 312f85978a339f2d04deb5bcb8f511bc
] 
[nodemaker: implement immutable directories (internal interface), for #607
Brian Warner <warner@lothar.com>**20091112002233
 Ignore-this: d09fccf41813fdf7e0db177ed9e5e130
 
 * nodemaker.create_from_cap() now handles DIR2-CHK and DIR2-LIT
 * client.create_immutable_dirnode() is used to create them
 * no webapi yet
] 
[stop using IURI()/etc as an adapter
Brian Warner <warner@lothar.com>**20091111224542
 Ignore-this: 9611da7ea6a4696de2a3b8c08776e6e0
] 
[clean up uri-vs-cap terminology, emphasize cap instances instead of URI strings
Brian Warner <warner@lothar.com>**20091111222619
 Ignore-this: 93626385f6e7f039ada71f54feefe267
 
  * "cap" means a python instance which encapsulates a filecap/dircap (uri.py)
  * "uri" means a string with a "URI:" prefix
  * FileNode instances are created with (and retain) a cap instance, and
    generate uri strings on demand
  * .get_cap/get_readcap/get_verifycap/get_repaircap return cap instances
  * .get_uri/get_readonly_uri return uri strings
 
 * add filenode.download_to_filename() for control.py, should find a better way
 * use MutableFileNode.init_from_cap, not .init_from_uri
 * directory URI instances: use get_filenode_cap, not get_filenode_uri
 * update/cleanup bench_dirnode.py to match, add Makefile target to run it
] 
[add parser for immutable directory caps: DIR2-CHK, DIR2-LIT, DIR2-CHK-Verifier
Brian Warner <warner@lothar.com>**20091104181351
 Ignore-this: 854398cc7a75bada57fa97c367b67518
] 
[wui: s/TahoeLAFS/Tahoe-LAFS/
zooko@zooko.com**20091029035050
 Ignore-this: 901e64cd862e492ed3132bd298583c26
] 
[tests: bump up the timeout on test_repairer to see if 120 seconds was too short for François's ARM box to do the test even when it was doing it right.
zooko@zooko.com**20091027224800
 Ignore-this: 95e93dc2e018b9948253c2045d506f56
] 
[dirnode.pack_children(): add deep_immutable= argument
Brian Warner <warner@lothar.com>**20091026162809
 Ignore-this: d5a2371e47662c4bc6eff273e8181b00
 
 This will be used by DIR2:CHK to enforce the deep-immutability requirement.
] 
[webapi: use t=mkdir-with-children instead of a children= arg to t=mkdir .
Brian Warner <warner@lothar.com>**20091026011321
 Ignore-this: 769cab30b6ab50db95000b6c5a524916
 
 This is safer: in the earlier API, an old webapi server would silently ignore
 the initial children, and clients trying to set them would have to fetch the
 newly-created directory to discover the incompatibility. In the new API,
 clients using t=mkdir-with-children against an old webapi server will get a
 clear error.
] 
[nodemaker.create_new_mutable_directory: pack_children() in initial_contents=
Brian Warner <warner@lothar.com>**20091020005118
 Ignore-this: bd43c4eefe06fd32b7492bcb0a55d07e
 instead of creating an empty file and then adding the children later.
 
 This should speed up mkdir(initial_children) considerably, removing two
 roundtrips and an entire read-modify-write cycle, probably bringing it down
 to a single roundtrip. A quick test (against the volunteergrid) suggests a
 30% speedup.
 
 test_dirnode: add new tests to enforce the restrictions that interfaces.py
 claims for create_new_mutable_directory(): no UnknownNodes, metadata dicts
] 
[test_dirnode.py: add tests of initial_children= args to client.create_dirnode
Brian Warner <warner@lothar.com>**20091017194159
 Ignore-this: 2e2da28323a4d5d815466387914abc1b
 and nodemaker.create_new_mutable_directory
] 
[update many dirnode interfaces to accept dict-of-nodes instead of dict-of-caps
Brian Warner <warner@lothar.com>**20091017192829
 Ignore-this: b35472285143862a856bf4b361d692f0
 
 interfaces.py: define INodeMaker, document argument values, change
                create_new_mutable_directory() to take dict-of-nodes. Change
                dirnode.set_nodes() and dirnode.create_subdirectory() too.
 nodemaker.py: use INodeMaker, update create_new_mutable_directory()
 client.py: have create_dirnode() delegate initial_children= to nodemaker
 dirnode.py (Adder): take dict-of-nodes instead of list-of-nodes, which
                     updates set_nodes() and create_subdirectory()
 web/common.py (convert_initial_children_json): create dict-of-nodes
 web/directory.py: same
 web/unlinked.py: same
 test_dirnode.py: update tests to match
] 
[dirnode.py: move pack_children() out to a function, for eventual use by others
Brian Warner <warner@lothar.com>**20091017180707
 Ignore-this: 6a823fb61f2c180fd38d6742d3196a7a
] 
[move dirnode.CachingDict to dictutil.AuxValueDict, generalize method names,
Brian Warner <warner@lothar.com>**20091017180005
 Ignore-this: b086933cf429df0fcea16a308d2640dd
 improve tests. Let dirnode _pack_children accept either dict or AuxValueDict.
] 
[test/common.py: update FakeMutableFileNode to new contents= callable scheme
Brian Warner <warner@lothar.com>**20091013052154
 Ignore-this: 62f00a76454a2190d1c8641c5993632f
] 
[The initial_children= argument to nodemaker.create_new_mutable_directory is
Brian Warner <warner@lothar.com>**20091013031922
 Ignore-this: 72e45317c21f9eb9ec3bd79bd4311f48
 now enabled.
] 
[client.create_mutable_file(contents=) now accepts a callable, which is
Brian Warner <warner@lothar.com>**20091013031232
 Ignore-this: 3c89d2f50c1e652b83f20bd3f4f27c4b
 invoked with the new MutableFileNode and is supposed to return the initial
 contents. This can be used by e.g. a new dirnode which needs the filenode's
 writekey to encrypt its initial children.
 
 create_mutable_file() still accepts a bytestring too, or None for an empty
 file.
] 
[webapi: t=mkdir now accepts initial children, using the same JSON that t=json
Brian Warner <warner@lothar.com>**20091013023444
 Ignore-this: 574a46ed46af4251abf8c9580fd31ef7
 emits.
 
 client.create_dirnode(initial_children=) now works.
] 
[replace dirnode.create_empty_directory() with create_subdirectory(), which
Brian Warner <warner@lothar.com>**20091013021520
 Ignore-this: 6b57cb51bcfcc6058d0df569fdc8a9cf
 takes an initial_children= argument
] 
[dirnode.set_children: change return value: fire with self instead of None
Brian Warner <warner@lothar.com>**20091013015026
 Ignore-this: f1d14e67e084e4b2a4e25fa849b0e753
] 
[dirnode.set_nodes: change return value: fire with self instead of None
Brian Warner <warner@lothar.com>**20091013014546
 Ignore-this: b75b3829fb53f7399693f1c1a39aacae
] 
[dirnode.set_children: take a dict, not a list
Brian Warner <warner@lothar.com>**20091013002440
 Ignore-this: 540ce72ce2727ee053afaae1ff124e21
] 
[dirnode.set_uri/set_children: change signature to take writecap+readcap
Brian Warner <warner@lothar.com>**20091012235126
 Ignore-this: 5df617b2d379a51c79148a857e6026b1
 instead of a single cap. The webapi t=set_children call benefits too.
] 
[replace Client.create_empty_dirnode() with create_dirnode(), in anticipation
Brian Warner <warner@lothar.com>**20091012224506
 Ignore-this: cbdaa4266ecb3c6496ffceab4f95709d
 of adding initial_children= argument.
 
 Includes stubbed-out initial_children= support.
] 
[test_web.py: use a less-fake client, making test harness smaller
Brian Warner <warner@lothar.com>**20091012222808
 Ignore-this: 29e95147f8c94282885c65b411d100bb
] 
[webapi.txt: document t=set_children, other small edits
Brian Warner <warner@lothar.com>**20091009200446
 Ignore-this: 4d7e76b04a7b8eaa0a981879f778ea5d
] 
[Verifier: check the full cryptext-hash tree on each share. Removed .todos
Brian Warner <warner@lothar.com>**20091005221849
 Ignore-this: 6fb039c5584812017d91725e687323a5
 from the last few test_repairer tests that were waiting on this.
] 
[Verifier: check the full block-hash-tree on each share
Brian Warner <warner@lothar.com>**20091005214844
 Ignore-this: 3f7ccf6d253f32340f1bf1da27803eee
 
 Removed the .todo from two test_repairer tests that check this. The only
 remaining .todos are on the three crypttext-hash-tree tests.
] 
[Verifier: check the full share-hash chain on each share
Brian Warner <warner@lothar.com>**20091005213443
 Ignore-this: 3d30111904158bec06a4eac22fd39d17
 
 Removed the .todo from two test_repairer tests that check this.
] 
[test_repairer: rename Verifier test cases to be more precise and less verbose
Brian Warner <warner@lothar.com>**20091005201115
 Ignore-this: 64be7094e33338c7c2aea9387e138771
] 
[immutable/checker.py: rearrange code a little bit, make it easier to follow
Brian Warner <warner@lothar.com>**20091005200252
 Ignore-this: 91cc303fab66faf717433a709f785fb5
] 
[test/common.py: wrap docstrings to 80cols so I can read them more easily
Brian Warner <warner@lothar.com>**20091005200143
 Ignore-this: b180a3a0235cbe309c87bd5e873cbbb3
] 
[immutable/download.py: wrap to 80cols, no functional changes
Brian Warner <warner@lothar.com>**20091005192542
 Ignore-this: 6b05fe3dc6d78832323e708b9e6a1fe
] 
[CHK-hashes.svg: cross out plaintext hashes, since we don't include
Brian Warner <warner@lothar.com>**20091005010803
 Ignore-this: bea2e953b65ec7359363aa20de8cb603
 them (until we finish #453)
] 
[docs: a few licensing clarifications requested by Ubuntu
zooko@zooko.com**20090927033226
 Ignore-this: 749fc8c9aeb6dc643669854a3e81baa7
] 
[setup: remove binary WinFUSE modules
zooko@zooko.com**20090924211436
 Ignore-this: 8aefc571d2ae22b9405fc650f2c2062
 I would prefer to have just source code, or indications of what 3rd-party packages are required, under revision control, and have the build process generate o
 r acquire the binaries as needed.  Also, having these in our release tarballs is interfering with getting Tahoe-LAFS uploaded into Ubuntu Karmic.  (Technicall
 y, they would accept binary modules as long as they came with the accompanying source so that they could satisfy their obligations under GPL2+ and TGPPL1+, bu
 t it is easier for now to remove the binaries from the source tree.)
 In this case, the binaries are from the tahoe-w32-client project: http://allmydata.org/trac/tahoe-w32-client , from which you can also get the source.
] 
[setup: remove binary _fusemodule.so 's
zooko@zooko.com**20090924211130
 Ignore-this: 74487bbe27d280762ac5dd5f51e24186
 I would prefer to have just source code, or indications of what 3rd-party packages are required, under revision control, and have the build process generate or acquire the binaries as needed.  Also, having these in our release tarballs is interfering with getting Tahoe-LAFS uploaded into Ubuntu Karmic.  (Technically, they would accept binary modules as long as they came with the accompanying source so that they could satisfy their obligations under GPL2+ and TGPPL1+, but it is easier for now to remove the binaries from the source tree.)
 In this case, these modules come from the MacFUSE project: http://code.google.com/p/macfuse/
] 
[doc: add a copy of LGPL2 for documentation purposes for ubuntu
zooko@zooko.com**20090924054218
 Ignore-this: 6a073b48678a7c84dc4fbcef9292ab5b
] 
[setup: remove a convenience copy of figleaf, to ease inclusion into Ubuntu Karmic Koala
zooko@zooko.com**20090924053215
 Ignore-this: a0b0c990d6e2ee65c53a24391365ac8d
 We need to carefully document the licence of figleaf in order to get Tahoe-LAFS into Ubuntu Karmic Koala.  However, figleaf isn't really a part of Tahoe-LAFS per se -- this is just a "convenience copy" of a development tool.  The quickest way to make Tahoe-LAFS acceptable for Karmic then, is to remove figleaf from the Tahoe-LAFS tarball itself.  People who want to run figleaf on Tahoe-LAFS (as everyone should want) can install figleaf themselves.  I haven't tested this -- there may be incompatibilities between upstream figleaf and the copy that we had here...
] 
[setup: shebang for misc/build-deb.py to fail quickly
zooko@zooko.com**20090819135626
 Ignore-this: 5a1b893234d2d0bb7b7346e84b0a6b4d
 Without this patch, when I ran "chmod +x ./misc/build-deb.py && ./misc/build-deb.py" then it hung indefinitely.  (I wonder what it was doing.)
] 
[docs: Shawn Willden grants permission for his contributions under GPL2+|TGPPL1+
zooko@zooko.com**20090921164651
 Ignore-this: ef1912010d07ff2ffd9678e7abfd0d57
] 
[docs: Csaba Henk granted permission to license fuse.py under the same terms as Tahoe-LAFS itself
zooko@zooko.com**20090921154659
 Ignore-this: c61ba48dcb7206a89a57ca18a0450c53
] 
[setup: mark setup.py as having utf-8 encoding in it
zooko@zooko.com**20090920180343
 Ignore-this: 9d3850733700a44ba7291e9c5e36bb91
] 
[doc: licensing cleanups
zooko@zooko.com**20090920171631
 Ignore-this: 7654f2854bf3c13e6f4d4597633a6630
 Use nice utf-8 © instead of "(c)". Remove licensing statements on utility modules that have been assigned to allmydata.com by their original authors. (Nattraverso was not assigned to allmydata.com -- it was LGPL'ed -- but I checked and src/allmydata/util/iputil.py was completely rewritten and doesn't contain any line of code from nattraverso.)  Add notes to misc/debian/copyright about licensing on files that aren't just allmydata.com-licensed.
] 
[build-deb.py: run darcsver early, otherwise we get the wrong version later on
Brian Warner <warner@lothar.com>**20090918033620
 Ignore-this: 6635c5b85e84f8aed0d8390490c5392a
] 
[new approach for debian packaging, sharing pieces across distributions. Still experimental, still only works for sid.
warner@lothar.com**20090818190527
 Ignore-this: a75eb63db9106b3269badbfcdd7f5ce1
] 
[new experimental deb-packaging rules. Only works for sid so far.
Brian Warner <warner@lothar.com>**20090818014052
 Ignore-this: 3a26ad188668098f8f3cc10a7c0c2f27
] 
[setup.py: read _version.py and pass to setup(version=), so more commands work
Brian Warner <warner@lothar.com>**20090818010057
 Ignore-this: b290eb50216938e19f72db211f82147e
 like "setup.py --version" and "setup.py --fullname"
] 
[test/check_speed.py: fix shbang line
Brian Warner <warner@lothar.com>**20090818005948
 Ignore-this: 7f3a37caf349c4c4de704d0feb561f8d
] 
[setup: remove bundled version of darcsver-1.2.1
zooko@zooko.com**20090816233432
 Ignore-this: 5357f26d2803db2d39159125dddb963a
 That version of darcsver emits a scary error message when the darcs executable or the _darcs subdirectory is not found.
 This error is hidden (unless the --loud option is passed) in darcsver >= 1.3.1.
 Fixes #788.
] 
[de-Service-ify Helper, pass in storage_broker and secret_holder directly.
Brian Warner <warner@lothar.com>**20090815201737
 Ignore-this: 86b8ac0f90f77a1036cd604dd1304d8b
 This makes it more obvious that the Helper currently generates leases with
 the Helper's own secrets, rather than getting values from the client, which
 is arguably a bug that will likely be resolved with the Accounting project.
] 
[immutable.Downloader: pass StorageBroker to constructor, stop being a Service
Brian Warner <warner@lothar.com>**20090815192543
 Ignore-this: af5ab12dbf75377640a670c689838479
 child of the client, access with client.downloader instead of
 client.getServiceNamed("downloader"). The single "Downloader" instance is
 scheduled for demolition anyways, to be replaced by individual
 filenode.download calls.
] 
[tests: double the timeout on test_runner.RunNode.test_introducer since feisty hit a timeout
zooko@zooko.com**20090815160512
 Ignore-this: ca7358bce4bdabe8eea75dedc39c0e67
 I'm not sure if this is an actual timing issue (feisty is running on an overloaded VM if I recall correctly), or it there is a deeper bug.
] 
[stop making History be a Service, it wasn't necessary
Brian Warner <warner@lothar.com>**20090815114415
 Ignore-this: b60449231557f1934a751c7effa93cfe
] 
[Overhaul IFilesystemNode handling, to simplify tests and use POLA internally.
Brian Warner <warner@lothar.com>**20090815112846
 Ignore-this: 1db1b9c149a60a310228aba04c5c8e5f
 
 * stop using IURI as an adapter
 * pass cap strings around instead of URI instances
 * move filenode/dirnode creation duties from Client to new NodeMaker class
 * move other Client duties to KeyGenerator, SecretHolder, History classes
 * stop passing Client reference to dirnode/filenode constructors
   - pass less-powerful references instead, like StorageBroker or Uploader
 * always create DirectoryNodes by wrapping a filenode (mutable for now)
 * remove some specialized mock classes from unit tests
 
 Detailed list of changes (done one at a time, then merged together)
 
 always pass a string to create_node_from_uri(), not an IURI instance
 always pass a string to IFilesystemNode constructors, not an IURI instance
 stop using IURI() as an adapter, switch on cap prefix in create_node_from_uri()
 client.py: move SecretHolder code out to a separate class
 test_web.py: hush pyflakes
 client.py: move NodeMaker functionality out into a separate object
 LiteralFileNode: stop storing a Client reference
 immutable Checker: remove Client reference, it only needs a SecretHolder
 immutable Upload: remove Client reference, leave SecretHolder and StorageBroker
 immutable Repairer: replace Client reference with StorageBroker and SecretHolder
 immutable FileNode: remove Client reference
 mutable.Publish: stop passing Client
 mutable.ServermapUpdater: get StorageBroker in constructor, not by peeking into Client reference
 MutableChecker: reference StorageBroker and History directly, not through Client
 mutable.FileNode: removed unused indirection to checker classes
 mutable.FileNode: remove Client reference
 client.py: move RSA key generation into a separate class, so it can be passed to the nodemaker
 move create_mutable_file() into NodeMaker
 test_dirnode.py: stop using FakeClient mockups, use NoNetworkGrid instead. This simplifies the code, but takes longer to run (17s instead of 6s). This should come down later when other cleanups make it possible to use simpler (non-RSA) fake mutable files for dirnode tests.
 test_mutable.py: clean up basedir names
 client.py: move create_empty_dirnode() into NodeMaker
 dirnode.py: get rid of DirectoryNode.create
 remove DirectoryNode.init_from_uri, refactor NodeMaker for customization, simplify test_web's mock Client to match
 stop passing Client to DirectoryNode, make DirectoryNode.create_with_mutablefile the normal DirectoryNode constructor, start removing client from NodeMaker
 remove Client from NodeMaker
 move helper status into History, pass History to web.Status instead of Client
 test_mutable.py: fix minor typo
] 
[docs: edits for docs/running.html from Sam Mason
zooko@zooko.com**20090809201416
 Ignore-this: 2207e80449943ebd4ed50cea57c43143
] 
[docs: install.html: instruct Debian users to use this document and not to go find the DownloadDebianPackages page, ignore the warning at the top of it, and try it
zooko@zooko.com**20090804123840
 Ignore-this: 49da654f19d377ffc5a1eff0c820e026
 http://allmydata.org/pipermail/tahoe-dev/2009-August/002507.html
] 
[docs: relnotes.txt: reflow to 63 chars wide because google groups and some web forms seem to wrap to that
zooko@zooko.com**20090802135016
 Ignore-this: 53b1493a0491bc30fb2935fad283caeb
] 
[docs: about.html: fix English usage noticed by Amber
zooko@zooko.com**20090802050533
 Ignore-this: 89965c4650f9bd100a615c401181a956
] 
[docs: fix mis-spelled word in about.html
zooko@zooko.com**20090802050320
 Ignore-this: fdfd0397bc7cef9edfde425dddeb67e5
] 
[TAG allmydata-tahoe-1.5.0
zooko@zooko.com**20090802031303
 Ignore-this: 94e5558e7225c39a86aae666ea00f166
] 
Patch bundle hash:
b8174b5e869654c7a2692f660b0b14fb22102888