Changeset 919f31a in trunk


Ignore:
Timestamp:
2020-12-14T18:31:50Z (4 years ago)
Author:
GitHub <noreply@…>
Branches:
master
Children:
052d95f, 37d46cfb
Parents:
1c2f3ee9 (diff), fc621025 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Itamar Turner-Trauring <itamar@…> (2020-12-14 18:31:50)
git-committer:
GitHub <noreply@…> (2020-12-14 18:31:50)
Message:

Merge pull request #923 from tahoe-lafs/3553.nodemaker-python-3

Port allmydata.nodemaker and .dirnode to Python 3

Fixes ticket:3553

Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed

  • TabularUnified src/allmydata/dirnode.py

    r1c2f3ee9 r919f31a  
    1 """Directory Node implementation."""
     1"""Directory Node implementation.
     2
     3Ported to Python 3.
     4"""
     5from __future__ import absolute_import
     6from __future__ import division
     7from __future__ import print_function
     8from __future__ import unicode_literals
     9
     10from future.utils import PY2
     11if PY2:
     12    # Skip dict so it doesn't break things.
     13    from future.builtins import filter, map, zip, ascii, chr, hex, input, next, oct, open, pow, round, super, bytes, list, object, range, str, max, min  # noqa: F401
    214from past.builtins import unicode
    315
    … …  
    3850NAME = Field.for_types(
    3951    u"name",
     52    # Make sure this works on Python 2; with str, it gets Future str which
     53    # breaks Eliot.
    4054    [unicode],
    4155    u"The name linking the parent to this node.",
    … …  
    180194        children = self.node._unpack_contents(old_contents)
    181195        now = time.time()
    182         for (namex, (child, new_metadata)) in self.entries.iteritems():
     196        for (namex, (child, new_metadata)) in list(self.entries.items()):
    183197            name = normalize(namex)
    184198            precondition(IFilesystemNode.providedBy(child), child)
    … …  
    206220
    207221def _encrypt_rw_uri(writekey, rw_uri):
    208     precondition(isinstance(rw_uri, str), rw_uri)
    209     precondition(isinstance(writekey, str), writekey)
     222    precondition(isinstance(rw_uri, bytes), rw_uri)
     223    precondition(isinstance(writekey, bytes), writekey)
    210224
    211225    salt = hashutil.mutable_rwcap_salt_hash(rw_uri)
    … …  
    222236    # initial_children must have metadata (i.e. {} instead of None)
    223237    children = {}
    224     for (namex, (node, metadata)) in childrenx.iteritems():
     238    for (namex, (node, metadata)) in list(childrenx.items()):
    225239        precondition(isinstance(metadata, dict),
    226240                     "directory creation requires metadata to be a dict, not None", metadata)
    … …  
    246260    immutable, and will raise a MustBeDeepImmutableError if not.
    247261    """
    248     precondition((writekey is None) or isinstance(writekey, str), writekey)
     262    precondition((writekey is None) or isinstance(writekey, bytes), writekey)
    249263
    250264    has_aux = isinstance(children, AuxValueDict)
    251265    entries = []
    252266    for name in sorted(children.keys()):
    253         assert isinstance(name, unicode)
     267        assert isinstance(name, str)
    254268        entry = None
    255269        (child, metadata) = children[name]
    256270        child.raise_error()
    257271        if deep_immutable and not child.is_allowed_in_immutable_directory():
    258             raise MustBeDeepImmutableError("child %s is not allowed in an immutable directory" %
    259                                            quote_output(name, encoding='utf-8'), name)
     272            raise MustBeDeepImmutableError(
     273                "child %r is not allowed in an immutable directory" % (name,),
     274                name)
    260275        if has_aux:
    261276            entry = children.get_aux(name)
    … …  
    265280            rw_uri = child.get_write_uri()
    266281            if rw_uri is None:
    267                 rw_uri = ""
    268             assert isinstance(rw_uri, str), rw_uri
     282                rw_uri = b""
     283            assert isinstance(rw_uri, bytes), rw_uri
    269284
    270285            # should be prevented by MustBeDeepImmutableError check above
    … …  
    273288            ro_uri = child.get_readonly_uri()
    274289            if ro_uri is None:
    275                 ro_uri = ""
    276             assert isinstance(ro_uri, str), ro_uri
     290                ro_uri = b""
     291            assert isinstance(ro_uri, bytes), ro_uri
    277292            if writekey is not None:
    278293                writecap = netstring(_encrypt_rw_uri(writekey, rw_uri))
    279294            else:
    280295                writecap = ZERO_LEN_NETSTR
    281             entry = "".join([netstring(name.encode("utf-8")),
     296            entry = b"".join([netstring(name.encode("utf-8")),
    282297                             netstring(strip_prefix_for_ro(ro_uri, deep_immutable)),
    283298                             writecap,
    284                              netstring(json.dumps(metadata))])
     299                             netstring(json.dumps(metadata).encode("utf-8"))])
    285300        entries.append(netstring(entry))
    286     return "".join(entries)
     301    return b"".join(entries)
    287302
    288303@implementer(IDirectoryNode, ICheckable, IDeepCheckable)
    … …  
    353368        # The rwcapdata is formatted as:
    354369        # pack("16ss32s", iv, AES(H(writekey+iv), plaintext_rw_uri), mac)
    355         assert isinstance(data, str), (repr(data), type(data))
     370        assert isinstance(data, bytes), (repr(data), type(data))
    356371        # an empty directory is serialized as an empty string
    357         if data == "":
     372        if data == b"":
    358373            return AuxValueDict()
    359374        writeable = not self.is_readonly()
    … …  
    374389            name = normalize(namex_utf8.decode("utf-8"))
    375390
    376             rw_uri = ""
     391            rw_uri = b""
    377392            if writeable:
    378393                rw_uri = self._decrypt_rwcapdata(rwcapdata)
    … …  
    385400            # rw_uri and ro_uri will be either None or a non-empty string.
    386401
    387             rw_uri = rw_uri.rstrip(' ') or None
    388             ro_uri = ro_uri.rstrip(' ') or None
     402            rw_uri = rw_uri.rstrip(b' ') or None
     403            ro_uri = ro_uri.rstrip(b' ') or None
    389404
    390405            try:
    … …  
    469484        name = normalize(namex)
    470485        d = self._read()
    471         d.addCallback(lambda children: children.has_key(name))
     486        d.addCallback(lambda children: name in children)
    472487        return d
    473488
    … …  
    544559            pathx = pathx.split("/")
    545560        for p in pathx:
    546             assert isinstance(p, unicode), p
     561            assert isinstance(p, str), p
    547562        childnamex = pathx[0]
    548563        remaining_pathx = pathx[1:]
    … …  
    556571
    557572    def set_uri(self, namex, writecap, readcap, metadata=None, overwrite=True):
    558         precondition(isinstance(writecap, (str,type(None))), writecap)
    559         precondition(isinstance(readcap, (str,type(None))), readcap)
     573        precondition(isinstance(writecap, (bytes, type(None))), writecap)
     574        precondition(isinstance(readcap, (bytes, type(None))), readcap)
    560575
    561576        # We now allow packing unknown nodes, provided they are valid
    … …  
    570585        a = Adder(self, overwrite=overwrite,
    571586                  create_readonly_node=self._create_readonly_node)
    572         for (namex, e) in entries.iteritems():
    573             assert isinstance(namex, unicode), namex
     587        for (namex, e) in entries.items():
     588            assert isinstance(namex, str), namex
    574589            if len(e) == 2:
    575590                writecap, readcap = e
    … …  
    578593                assert len(e) == 3
    579594                writecap, readcap, metadata = e
    580             precondition(isinstance(writecap, (str,type(None))), writecap)
    581             precondition(isinstance(readcap, (str,type(None))), readcap)
     595            precondition(isinstance(writecap, (bytes,type(None))), writecap)
     596            precondition(isinstance(readcap, (bytes,type(None))), readcap)
    582597
    583598            # We now allow packing unknown nodes, provided they are valid
    … …  
    780795        dirkids = []
    781796        filekids = []
    782         for name, (child, metadata) in sorted(children.iteritems()):
     797        for name, (child, metadata) in sorted(children.items()):
    783798            childpath = path + [name]
    784799            if isinstance(child, UnknownNode):

  • TabularUnified src/allmydata/nodemaker.py

    r1c2f3ee9 r919f31a  
     1"""
     2Ported to Python 3.
     3"""
     4from __future__ import absolute_import
     5from __future__ import division
     6from __future__ import print_function
     7from __future__ import unicode_literals
     8
     9from future.utils import PY2
     10if PY2:
     11    from future.builtins import filter, map, zip, ascii, chr, hex, input, next, oct, open, pow, round, super, bytes, dict, list, object, range, str, max, min  # noqa: F401
     12
    113import weakref
    214from zope.interface import implementer
    … …  
    127139    def create_new_mutable_directory(self, initial_children={}, version=None):
    128140        # initial_children must have metadata (i.e. {} instead of None)
    129         for (name, (node, metadata)) in initial_children.iteritems():
     141        for (name, (node, metadata)) in initial_children.items():
    130142            precondition(isinstance(metadata, dict),
    131143                         "create_new_mutable_directory requires metadata to be a dict, not None", metadata)

  • TabularUnified src/allmydata/test/test_dirnode.py

    r1c2f3ee9 r919f31a  
    1 """Tests for the dirnode module."""
    2 import six
     1"""Tests for the dirnode module.
     2
     3Ported to Python 3.
     4"""
     5from __future__ import absolute_import
     6from __future__ import division
     7from __future__ import print_function
     8from __future__ import unicode_literals
     9
     10from past.builtins import long
     11
     12from future.utils import PY2
     13if PY2:
     14    # Skip list() since it results in spurious test failures
     15    from future.builtins import filter, map, zip, ascii, chr, hex, input, next, oct, open, pow, round, super, bytes, dict, object, range, str, max, min  # noqa: F401
     16
    317import time
    418import unicodedata
    … …  
    3246from hypothesis.strategies import text
    3347
    34 if six.PY3:
    35     long = int
    36 
    3748
    3849@implementer(IConsumer)
    … …  
    4960        self.producer.resumeProducing()
    5061
    51 setup_py_uri = "URI:CHK:n7r3m6wmomelk4sep3kw5cvduq:os7ijw5c3maek7pg65e5254k2fzjflavtpejjyhshpsxuqzhcwwq:3:20:14861"
    52 one_uri = "URI:LIT:n5xgk" # LIT for "one"
    53 mut_write_uri = "URI:SSK:vfvcbdfbszyrsaxchgevhmmlii:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq"
    54 mdmf_write_uri = "URI:MDMF:x533rhbm6kiehzl5kj3s44n5ie:4gif5rhneyd763ouo5qjrgnsoa3bg43xycy4robj2rf3tvmhdl3a"
    55 empty_litdir_uri = "URI:DIR2-LIT:"
    56 tiny_litdir_uri = "URI:DIR2-LIT:gqytunj2onug64tufqzdcosvkjetutcjkq5gw4tvm5vwszdgnz5hgyzufqydulbshj5x2lbm" # contains one child which is itself also LIT
    57 mut_read_uri = "URI:SSK-RO:jf6wkflosyvntwxqcdo7a54jvm:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq"
    58 mdmf_read_uri = "URI:MDMF-RO:d4cydxselputycfzkw6qgz4zv4:4gif5rhneyd763ouo5qjrgnsoa3bg43xycy4robj2rf3tvmhdl3a"
    59 future_write_uri = "x-tahoe-crazy://I_am_from_the_future."
    60 future_read_uri = "x-tahoe-crazy-readonly://I_am_from_the_future."
     62setup_py_uri = b"URI:CHK:n7r3m6wmomelk4sep3kw5cvduq:os7ijw5c3maek7pg65e5254k2fzjflavtpejjyhshpsxuqzhcwwq:3:20:14861"
     63one_uri = b"URI:LIT:n5xgk" # LIT for "one"
     64mut_write_uri = b"URI:SSK:vfvcbdfbszyrsaxchgevhmmlii:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq"
     65mdmf_write_uri = b"URI:MDMF:x533rhbm6kiehzl5kj3s44n5ie:4gif5rhneyd763ouo5qjrgnsoa3bg43xycy4robj2rf3tvmhdl3a"
     66empty_litdir_uri = b"URI:DIR2-LIT:"
     67tiny_litdir_uri = b"URI:DIR2-LIT:gqytunj2onug64tufqzdcosvkjetutcjkq5gw4tvm5vwszdgnz5hgyzufqydulbshj5x2lbm" # contains one child which is itself also LIT
     68mut_read_uri = b"URI:SSK-RO:jf6wkflosyvntwxqcdo7a54jvm:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq"
     69mdmf_read_uri = b"URI:MDMF-RO:d4cydxselputycfzkw6qgz4zv4:4gif5rhneyd763ouo5qjrgnsoa3bg43xycy4robj2rf3tvmhdl3a"
     70future_write_uri = b"x-tahoe-crazy://I_am_from_the_future."
     71future_read_uri = b"x-tahoe-crazy-readonly://I_am_from_the_future."
    6172future_nonascii_write_uri = u"x-tahoe-even-more-crazy://I_am_from_the_future_rw_\u263A".encode('utf-8')
    6273future_nonascii_read_uri = u"x-tahoe-even-more-crazy-readonly://I_am_from_the_future_ro_\u263A".encode('utf-8')
    … …  
    96107            cap_formats = []
    97108            if mdmf:
    98                 cap_formats = ["URI:DIR2-MDMF:",
    99                                "URI:DIR2-MDMF-RO:",
    100                                "URI:DIR2-MDMF-Verifier:"]
     109                cap_formats = [b"URI:DIR2-MDMF:",
     110                               b"URI:DIR2-MDMF-RO:",
     111                               b"URI:DIR2-MDMF-Verifier:"]
    101112            else:
    102                 cap_formats = ["URI:DIR2:",
    103                                "URI:DIR2-RO",
    104                                "URI:DIR2-Verifier:"]
     113                cap_formats = [b"URI:DIR2:",
     114                               b"URI:DIR2-RO",
     115                               b"URI:DIR2-Verifier:"]
    105116            rw, ro, v = cap_formats
    106117            self.failUnless(u.startswith(rw), u)
    … …  
    150161                self.subdir = subdir
    151162                new_v = subdir.get_verify_cap().to_string()
    152                 assert isinstance(new_v, str)
     163                assert isinstance(new_v, bytes)
    153164                self.expected_manifest.append( ((u"subdir",), subdir.get_uri()) )
    154165                self.expected_verifycaps.add(new_v)
    … …  
    183194                            "largest-immutable-file": 0,
    184195                            }
    185                 for k,v in expected.iteritems():
     196                for k,v in expected.items():
    186197                    self.failUnlessReallyEqual(stats[k], v,
    187198                                               "stats[%s] was %s, not %s" %
    … …  
    273284            d.addCallback(lambda res: n.get_metadata_for(u"c2"))
    274285            def _has_good_linkcrtime(metadata):
    275                 self.failUnless(metadata.has_key('tahoe'))
    276                 self.failUnless(metadata['tahoe'].has_key('linkcrtime'))
     286                self.failUnless('tahoe' in metadata)
     287                self.failUnless('linkcrtime' in metadata['tahoe'])
    277288                self.failIfEqual(metadata['tahoe']['linkcrtime'], 'bogus')
    278289            d.addCallback(_has_good_linkcrtime)
    … …  
    424435            d.addCallback(self.stall, 0.1)
    425436            d.addCallback(lambda res: n.add_file(u"timestamps",
    426                                                  upload.Data("stamp me", convergence="some convergence string")))
     437                                                 upload.Data(b"stamp me", convergence=b"some convergence string")))
    427438            d.addCallback(self.stall, 0.1)
    428439            def _stop(res):
    … …  
    473484                                                     set([u"child"])))
    474485
    475             uploadable1 = upload.Data("some data", convergence="converge")
     486            uploadable1 = upload.Data(b"some data", convergence=b"converge")
    476487            d.addCallback(lambda res: n.add_file(u"newfile", uploadable1))
    477488            d.addCallback(lambda newnode:
    478489                          self.failUnless(IImmutableFileNode.providedBy(newnode)))
    479             uploadable2 = upload.Data("some data", convergence="stuff")
     490            uploadable2 = upload.Data(b"some data", convergence=b"stuff")
    480491            d.addCallback(lambda res:
    481492                          self.shouldFail(ExistingChildError, "add_file-no",
    … …  
    492503                          self.failUnlessEqual(set(metadata.keys()), set(["tahoe"])))
    493504
    494             uploadable3 = upload.Data("some data", convergence="converge")
     505            uploadable3 = upload.Data(b"some data", convergence=b"converge")
    495506            d.addCallback(lambda res: n.add_file(u"newfile-metadata",
    496507                                                 uploadable3,
    … …  
    508519                self.subdir2 = subdir2
    509520                # put something in the way, to make sure it gets overwritten
    510                 return subdir2.add_file(u"child", upload.Data("overwrite me",
    511                                                               "converge"))
     521                return subdir2.add_file(u"child", upload.Data(b"overwrite me",
     522                                                              b"converge"))
    512523            d.addCallback(_created2)
    513524
    … …  
    667678            self.failUnless(fut_node.is_unknown())
    668679            self.failUnlessReallyEqual(fut_node.get_uri(), future_write_uri)
    669             self.failUnlessReallyEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
     680            self.failUnlessReallyEqual(fut_node.get_readonly_uri(), b"ro." + future_read_uri)
    670681            self.failUnless(isinstance(fut_metadata, dict), fut_metadata)
    671682
    672683            self.failUnless(futna_node.is_unknown())
    673684            self.failUnlessReallyEqual(futna_node.get_uri(), future_nonascii_write_uri)
    674             self.failUnlessReallyEqual(futna_node.get_readonly_uri(), "ro." + future_nonascii_read_uri)
     685            self.failUnlessReallyEqual(futna_node.get_readonly_uri(), b"ro." + future_nonascii_read_uri)
    675686            self.failUnless(isinstance(futna_metadata, dict), futna_metadata)
    676687
    677688            self.failUnless(fro_node.is_unknown())
    678             self.failUnlessReallyEqual(fro_node.get_uri(), "ro." + future_read_uri)
    679             self.failUnlessReallyEqual(fut_node.get_readonly_uri(), "ro." + future_read_uri)
     689            self.failUnlessReallyEqual(fro_node.get_uri(), b"ro." + future_read_uri)
     690            self.failUnlessReallyEqual(fut_node.get_readonly_uri(), b"ro." + future_read_uri)
    680691            self.failUnless(isinstance(fro_metadata, dict), fro_metadata)
    681692
    682693            self.failUnless(frona_node.is_unknown())
    683             self.failUnlessReallyEqual(frona_node.get_uri(), "ro." + future_nonascii_read_uri)
    684             self.failUnlessReallyEqual(futna_node.get_readonly_uri(), "ro." + future_nonascii_read_uri)
     694            self.failUnlessReallyEqual(frona_node.get_uri(), b"ro." + future_nonascii_read_uri)
     695            self.failUnlessReallyEqual(futna_node.get_readonly_uri(), b"ro." + future_nonascii_read_uri)
    685696            self.failUnless(isinstance(frona_metadata, dict), frona_metadata)
    686697
    … …  
    698709            d2.addCallback(lambda ignored: tinylit_node.list())
    699710            d2.addCallback(lambda children: children[u"short"][0].read(MemAccum()))
    700             d2.addCallback(lambda accum: self.failUnlessReallyEqual(accum.data, "The end."))
     711            d2.addCallback(lambda accum: self.failUnlessReallyEqual(accum.data, b"The end."))
    701712            return d2
    702713        d.addCallback(_check_kids)
    … …  
    783794            self.failUnless("RO-IMM" in rep)
    784795            cap = dn.get_cap()
    785             self.failUnlessIn("CHK", cap.to_string())
     796            self.failUnlessIn(b"CHK", cap.to_string())
    786797            self.cap = cap
    787798            return dn.list()
    … …  
    809820
    810821            self.failUnless(fut_node.is_unknown())
    811             self.failUnlessReallyEqual(fut_node.get_uri(), "imm." + future_read_uri)
    812             self.failUnlessReallyEqual(fut_node.get_readonly_uri(), "imm." + future_read_uri)
     822            self.failUnlessReallyEqual(fut_node.get_uri(), b"imm." + future_read_uri)
     823            self.failUnlessReallyEqual(fut_node.get_readonly_uri(), b"imm." + future_read_uri)
    813824            self.failUnless(isinstance(fut_metadata, dict), fut_metadata)
    814825
    815826            self.failUnless(futna_node.is_unknown())
    816             self.failUnlessReallyEqual(futna_node.get_uri(), "imm." + future_nonascii_read_uri)
    817             self.failUnlessReallyEqual(futna_node.get_readonly_uri(), "imm." + future_nonascii_read_uri)
     827            self.failUnlessReallyEqual(futna_node.get_uri(), b"imm." + future_nonascii_read_uri)
     828            self.failUnlessReallyEqual(futna_node.get_readonly_uri(), b"imm." + future_nonascii_read_uri)
    818829            self.failUnless(isinstance(futna_metadata, dict), futna_metadata)
    819830
    … …  
    831842            d2.addCallback(lambda ignored: tinylit_node.list())
    832843            d2.addCallback(lambda children: children[u"short"][0].read(MemAccum()))
    833             d2.addCallback(lambda accum: self.failUnlessReallyEqual(accum.data, "The end."))
     844            d2.addCallback(lambda accum: self.failUnlessReallyEqual(accum.data, b"The end."))
    834845            return d2
    835846
    … …  
    895906            self.failUnless("RO-IMM" in rep)
    896907            cap = dn.get_cap()
    897             self.failUnlessIn("LIT", cap.to_string())
    898             self.failUnlessReallyEqual(cap.to_string(), "URI:DIR2-LIT:")
     908            self.failUnlessIn(b"LIT", cap.to_string())
     909            self.failUnlessReallyEqual(cap.to_string(), b"URI:DIR2-LIT:")
    899910            self.cap = cap
    900911            return dn.list()
    … …  
    913924            self.failUnless("RO-IMM" in rep)
    914925            cap = dn.get_cap()
    915             self.failUnlessIn("LIT", cap.to_string())
     926            self.failUnlessIn(b"LIT", cap.to_string())
    916927            self.failUnlessReallyEqual(cap.to_string(),
    917                                        "URI:DIR2-LIT:gi4tumj2n4wdcmz2kvjesosmjfkdu3rvpbtwwlbqhiwdeot3puwcy")
     928                                       b"URI:DIR2-LIT:gi4tumj2n4wdcmz2kvjesosmjfkdu3rvpbtwwlbqhiwdeot3puwcy")
    918929            self.cap = cap
    919930            return dn.list()
    920931        d.addCallback(_created_small)
    921         d.addCallback(lambda kids: self.failUnlessReallyEqual(kids.keys(), [u"o"]))
     932        d.addCallback(lambda kids: self.failUnlessReallyEqual(list(kids.keys()), [u"o"]))
    922933
    923934        # now test n.create_subdirectory(mutable=False)
    … …  
    929940            d.addCallback(lambda ign: n.list())
    930941            d.addCallback(lambda children:
    931                           self.failUnlessReallyEqual(children.keys(), [u"subdir"]))
     942                          self.failUnlessReallyEqual(list(children.keys()), [u"subdir"]))
    932943            d.addCallback(lambda ign: n.get(u"subdir"))
    933944            d.addCallback(lambda sd: sd.list())
    … …  
    963974        # them again when retrieving them.
    964975
    965         stripped_write_uri = "lafs://from_the_future\t"
    966         stripped_read_uri = "lafs://readonly_from_the_future\t"
    967         spacedout_write_uri = stripped_write_uri + "  "
    968         spacedout_read_uri = stripped_read_uri + "  "
     976        stripped_write_uri = b"lafs://from_the_future\t"
     977        stripped_read_uri = b"lafs://readonly_from_the_future\t"
     978        spacedout_write_uri = stripped_write_uri + b"  "
     979        spacedout_read_uri = stripped_read_uri + b"  "
    969980
    970981        child = nm.create_from_cap(spacedout_write_uri, spacedout_read_uri)
    971982        self.failUnlessReallyEqual(child.get_write_uri(), spacedout_write_uri)
    972         self.failUnlessReallyEqual(child.get_readonly_uri(), "ro." + spacedout_read_uri)
     983        self.failUnlessReallyEqual(child.get_readonly_uri(), b"ro." + spacedout_read_uri)
    973984
    974985        child_dottedi = u"ch\u0131\u0307ld"
    … …  
    10041015                (expected_child, ign) = kids_out[name]
    10051016                self.failUnlessReallyEqual(rw_uri, expected_child.get_write_uri())
    1006                 self.failUnlessReallyEqual("ro." + ro_uri, expected_child.get_readonly_uri())
     1017                self.failUnlessReallyEqual(b"ro." + ro_uri, expected_child.get_readonly_uri())
    10071018                numkids += 1
    10081019
    … …  
    10401051
    10411052            self.failUnlessReallyEqual(child_node.get_write_uri(), stripped_write_uri)
    1042             self.failUnlessReallyEqual(child_node.get_readonly_uri(), "ro." + stripped_read_uri)
     1053            self.failUnlessReallyEqual(child_node.get_readonly_uri(), b"ro." + stripped_read_uri)
    10431054        d.addCallback(_check_kids)
    10441055
    … …  
    10751086        def _created_subdir(subdir):
    10761087            self._subdir = subdir
    1077             d = subdir.add_file(u"file1", upload.Data("data"*100, None))
     1088            d = subdir.add_file(u"file1", upload.Data(b"data"*100, None))
    10781089            d.addCallback(lambda res: subdir.set_node(u"link", self._rootnode))
    10791090            d.addCallback(lambda res: c.create_dirnode())
    … …  
    12511262        filecap = make_chk_file_uri(1234)
    12521263        filenode = nm.create_from_cap(filecap)
    1253         uploadable = upload.Data("some data", convergence="some convergence string")
     1264        uploadable = upload.Data(b"some data", convergence=b"some convergence string")
    12541265
    12551266        d = c.create_dirnode(version=version)
    … …  
    13871398class MinimalFakeMutableFile(object):
    13881399    def get_writekey(self):
    1389         return "writekey"
     1400        return b"writekey"
    13901401
    13911402class Packing(testutil.ReallyEqualMixin, unittest.TestCase):
    … …  
    14061417                              None, None,
    14071418                              {"k": 3, "n": 10}, None, None)
    1408         write_uri = "URI:SSK-RO:e3mdrzfwhoq42hy5ubcz6rp3o4:ybyibhnp3vvwuq2vaw2ckjmesgkklfs6ghxleztqidihjyofgw7q"
     1419        write_uri = b"URI:SSK-RO:e3mdrzfwhoq42hy5ubcz6rp3o4:ybyibhnp3vvwuq2vaw2ckjmesgkklfs6ghxleztqidihjyofgw7q"
    14091420        filenode = nodemaker.create_from_cap(write_uri)
    14101421        node = dirnode.DirectoryNode(filenode, nodemaker, None)
    … …  
    14181429    def _check_children(self, children):
    14191430        # Are all the expected child nodes there?
    1420         self.failUnless(children.has_key(u'file1'))
    1421         self.failUnless(children.has_key(u'file2'))
    1422         self.failUnless(children.has_key(u'file3'))
     1431        self.failUnless(u'file1' in children)
     1432        self.failUnless(u'file2' in children)
     1433        self.failUnless(u'file3' in children)
    14231434
    14241435        # Are the metadata for child 3 right?
    1425         file3_rocap = "URI:CHK:cmtcxq7hwxvfxan34yiev6ivhy:qvcekmjtoetdcw4kmi7b3rtblvgx7544crnwaqtiewemdliqsokq:3:10:5"
    1426         file3_rwcap = "URI:CHK:cmtcxq7hwxvfxan34yiev6ivhy:qvcekmjtoetdcw4kmi7b3rtblvgx7544crnwaqtiewemdliqsokq:3:10:5"
     1436        file3_rocap = b"URI:CHK:cmtcxq7hwxvfxan34yiev6ivhy:qvcekmjtoetdcw4kmi7b3rtblvgx7544crnwaqtiewemdliqsokq:3:10:5"
     1437        file3_rwcap = b"URI:CHK:cmtcxq7hwxvfxan34yiev6ivhy:qvcekmjtoetdcw4kmi7b3rtblvgx7544crnwaqtiewemdliqsokq:3:10:5"
    14271438        file3_metadata = {'ctime': 1246663897.4336269, 'tahoe': {'linkmotime': 1246663897.4336269, 'linkcrtime': 1246663897.4336269}, 'mtime': 1246663897.4336269}
    14281439        self.failUnlessEqual(file3_metadata, children[u'file3'][1])
    … …  
    14331444
    14341445        # Are the metadata for child 2 right?
    1435         file2_rocap = "URI:CHK:apegrpehshwugkbh3jlt5ei6hq:5oougnemcl5xgx4ijgiumtdojlipibctjkbwvyygdymdphib2fvq:3:10:4"
    1436         file2_rwcap = "URI:CHK:apegrpehshwugkbh3jlt5ei6hq:5oougnemcl5xgx4ijgiumtdojlipibctjkbwvyygdymdphib2fvq:3:10:4"
     1446        file2_rocap = b"URI:CHK:apegrpehshwugkbh3jlt5ei6hq:5oougnemcl5xgx4ijgiumtdojlipibctjkbwvyygdymdphib2fvq:3:10:4"
     1447        file2_rwcap = b"URI:CHK:apegrpehshwugkbh3jlt5ei6hq:5oougnemcl5xgx4ijgiumtdojlipibctjkbwvyygdymdphib2fvq:3:10:4"
    14371448        file2_metadata = {'ctime': 1246663897.430218, 'tahoe': {'linkmotime': 1246663897.430218, 'linkcrtime': 1246663897.430218}, 'mtime': 1246663897.430218}
    14381449        self.failUnlessEqual(file2_metadata, children[u'file2'][1])
    … …  
    14431454
    14441455        # Are the metadata for child 1 right?
    1445         file1_rocap = "URI:CHK:olxtimympo7f27jvhtgqlnbtn4:emzdnhk2um4seixozlkw3qx2nfijvdkx3ky7i7izl47yedl6e64a:3:10:10"
    1446         file1_rwcap = "URI:CHK:olxtimympo7f27jvhtgqlnbtn4:emzdnhk2um4seixozlkw3qx2nfijvdkx3ky7i7izl47yedl6e64a:3:10:10"
     1456        file1_rocap = b"URI:CHK:olxtimympo7f27jvhtgqlnbtn4:emzdnhk2um4seixozlkw3qx2nfijvdkx3ky7i7izl47yedl6e64a:3:10:10"
     1457        file1_rwcap = b"URI:CHK:olxtimympo7f27jvhtgqlnbtn4:emzdnhk2um4seixozlkw3qx2nfijvdkx3ky7i7izl47yedl6e64a:3:10:10"
    14471458        file1_metadata = {'ctime': 1246663897.4275661, 'tahoe': {'linkmotime': 1246663897.4275661, 'linkcrtime': 1246663897.4275661}, 'mtime': 1246663897.4275661}
    14481459        self.failUnlessEqual(file1_metadata, children[u'file1'][1])
    … …  
    14531464
    14541465    def _make_kids(self, nm, which):
    1455         caps = {"imm": "URI:CHK:n7r3m6wmomelk4sep3kw5cvduq:os7ijw5c3maek7pg65e5254k2fzjflavtpejjyhshpsxuqzhcwwq:3:20:14861",
    1456                 "lit": "URI:LIT:n5xgk", # LIT for "one"
    1457                 "write": "URI:SSK:vfvcbdfbszyrsaxchgevhmmlii:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq",
    1458                 "read": "URI:SSK-RO:e3mdrzfwhoq42hy5ubcz6rp3o4:ybyibhnp3vvwuq2vaw2ckjmesgkklfs6ghxleztqidihjyofgw7q",
    1459                 "dirwrite": "URI:DIR2:n6x24zd3seu725yluj75q5boaa:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq",
    1460                 "dirread":  "URI:DIR2-RO:b7sr5qsifnicca7cbk3rhrhbvq:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq",
     1466        caps = {"imm": b"URI:CHK:n7r3m6wmomelk4sep3kw5cvduq:os7ijw5c3maek7pg65e5254k2fzjflavtpejjyhshpsxuqzhcwwq:3:20:14861",
     1467                "lit": b"URI:LIT:n5xgk", # LIT for "one"
     1468                "write": b"URI:SSK:vfvcbdfbszyrsaxchgevhmmlii:euw4iw7bbnkrrwpzuburbhppuxhc3gwxv26f6imekhz7zyw2ojnq",
     1469                "read": b"URI:SSK-RO:e3mdrzfwhoq42hy5ubcz6rp3o4:ybyibhnp3vvwuq2vaw2ckjmesgkklfs6ghxleztqidihjyofgw7q",
     1470                "dirwrite": b"URI:DIR2:n6x24zd3seu725yluj75q5boaa:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq",
     1471                "dirread":  b"URI:DIR2-RO:b7sr5qsifnicca7cbk3rhrhbvq:mm6yoqjhl6ueh7iereldqxue4nene4wl7rqfjfybqrehdqmqskvq",
    14611472                }
    14621473        kids = {}
    14631474        for name in which:
    1464             kids[unicode(name)] = (nm.create_from_cap(caps[name]), {})
     1475            kids[str(name)] = (nm.create_from_cap(caps[name]), {})
    14651476        return kids
     1477
     1478    def test_pack_unpack_unknown(self):
     1479        """
     1480        Minimal testing for roundtripping unknown URIs.
     1481        """
     1482        nm = NodeMaker(None, None, None, None, None, {"k": 3, "n": 10}, None, None)
     1483        fn = MinimalFakeMutableFile()
     1484        # UnknownNode has massively complex rules about when it's an error.
     1485        # Just force it not to be an error.
     1486        unknown_rw = UnknownNode(b"whatevs://write", None)
     1487        unknown_rw.error = None
     1488        unknown_ro = UnknownNode(None, b"whatevs://readonly")
     1489        unknown_ro.error = None
     1490        kids = {
     1491            "unknown_rw": (unknown_rw, {}),
     1492            "unknown_ro": (unknown_ro, {})
     1493        }
     1494        packed = dirnode.pack_children(kids, fn.get_writekey(), deep_immutable=False)
     1495
     1496        write_uri = b"URI:SSK-RO:e3mdrzfwhoq42hy5ubcz6rp3o4:ybyibhnp3vvwuq2vaw2ckjmesgkklfs6ghxleztqidihjyofgw7q"
     1497        filenode = nm.create_from_cap(write_uri)
     1498        dn = dirnode.DirectoryNode(filenode, nm, None)
     1499        unkids = dn._unpack_contents(packed)
     1500        self.assertEqual(kids, unkids)
    14661501
    14671502    @given(text(min_size=1, max_size=20))
    … …  
    14861521        }
    14871522        packed = dirnode.pack_children(kids, fn.get_writekey(), deep_immutable=False)
    1488         write_uri = "URI:SSK-RO:e3mdrzfwhoq42hy5ubcz6rp3o4:ybyibhnp3vvwuq2vaw2ckjmesgkklfs6ghxleztqidihjyofgw7q"
     1523        write_uri = b"URI:SSK-RO:e3mdrzfwhoq42hy5ubcz6rp3o4:ybyibhnp3vvwuq2vaw2ckjmesgkklfs6ghxleztqidihjyofgw7q"
    14891524        filenode = nm.create_from_cap(write_uri)
    14901525        dn = dirnode.DirectoryNode(filenode, nm, None)
    … …  
    14991534                                    "dirwrite", "dirread"])
    15001535        packed = dirnode.pack_children(kids, fn.get_writekey(), deep_immutable=False)
    1501         self.failUnlessIn("lit", packed)
     1536        self.failUnlessIn(b"lit", packed)
    15021537
    15031538        kids = self._make_kids(nm, ["imm", "lit"])
    15041539        packed = dirnode.pack_children(kids, fn.get_writekey(), deep_immutable=True)
    1505         self.failUnlessIn("lit", packed)
     1540        self.failUnlessIn(b"lit", packed)
    15061541
    15071542        kids = self._make_kids(nm, ["imm", "lit", "write"])
    … …  
    15291564class FakeMutableFile(object):
    15301565    counter = 0
    1531     def __init__(self, initial_contents=""):
     1566    def __init__(self, initial_contents=b""):
    15321567        data = self._get_initial_contents(initial_contents)
    15331568        self.data = data.read(data.get_size())
    1534         self.data = "".join(self.data)
     1569        self.data = b"".join(self.data)
    15351570
    15361571        counter = FakeMutableFile.counter
    15371572        FakeMutableFile.counter += 1
    1538         writekey = hashutil.ssk_writekey_hash(str(counter))
    1539         fingerprint = hashutil.ssk_pubkey_fingerprint_hash(str(counter))
     1573        writekey = hashutil.ssk_writekey_hash(b"%d" % counter)
     1574        fingerprint = hashutil.ssk_pubkey_fingerprint_hash(b"%d" % counter)
    15401575        self.uri = uri.WriteableSSKFileURI(writekey, fingerprint)
    15411576
    15421577    def _get_initial_contents(self, contents):
    1543         if isinstance(contents, str):
     1578        if isinstance(contents, bytes):
    15441579            return contents
    15451580        if contents is None:
    1546             return ""
     1581            return b""
    15471582        assert callable(contents), "%s should be callable, not %s" % \
    15481583               (contents, type(contents))
    … …  
    15621597
    15631598    def get_writekey(self):
    1564         return "writekey"
     1599        return b"writekey"
    15651600
    15661601    def is_readonly(self):
    … …  
    15851620
    15861621class FakeNodeMaker(NodeMaker):
    1587     def create_mutable_file(self, contents="", keysize=None, version=None):
     1622    def create_mutable_file(self, contents=b"", keysize=None, version=None):
    15881623        return defer.succeed(FakeMutableFile(contents))
    15891624
    … …  
    16321667        # write slot (or URL parameter).
    16331668        d.addCallback(lambda ign: self._node.set_uri(u"add-ro",
    1634                                                      "ro." + future_read_uri, None))
     1669                                                     b"ro." + future_read_uri, None))
    16351670        d.addCallback(lambda ign: self._node.set_uri(u"add-imm",
    1636                                                      "imm." + future_imm_uri, None))
     1671                                                     b"imm." + future_imm_uri, None))
    16371672
    16381673        d.addCallback(lambda ign: self._node.list())
    … …  
    16431678            self.failUnlessReallyEqual(fn.get_uri(), future_write_uri)
    16441679            self.failUnlessReallyEqual(fn.get_write_uri(), future_write_uri)
    1645             self.failUnlessReallyEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
     1680            self.failUnlessReallyEqual(fn.get_readonly_uri(), b"ro." + future_read_uri)
    16461681
    16471682            (fn2, metadata2) = children[u"add-pair"]
    … …  
    16491684            self.failUnlessReallyEqual(fn2.get_uri(), future_write_uri)
    16501685            self.failUnlessReallyEqual(fn2.get_write_uri(), future_write_uri)
    1651             self.failUnlessReallyEqual(fn2.get_readonly_uri(), "ro." + future_read_uri)
     1686            self.failUnlessReallyEqual(fn2.get_readonly_uri(), b"ro." + future_read_uri)
    16521687
    16531688            (fn3, metadata3) = children[u"add-ro"]
    16541689            self.failUnless(isinstance(fn3, UnknownNode), fn3)
    1655             self.failUnlessReallyEqual(fn3.get_uri(), "ro." + future_read_uri)
     1690            self.failUnlessReallyEqual(fn3.get_uri(), b"ro." + future_read_uri)
    16561691            self.failUnlessReallyEqual(fn3.get_write_uri(), None)
    1657             self.failUnlessReallyEqual(fn3.get_readonly_uri(), "ro." + future_read_uri)
     1692            self.failUnlessReallyEqual(fn3.get_readonly_uri(), b"ro." + future_read_uri)
    16581693
    16591694            (fn4, metadata4) = children[u"add-imm"]
    16601695            self.failUnless(isinstance(fn4, UnknownNode), fn4)
    1661             self.failUnlessReallyEqual(fn4.get_uri(), "imm." + future_imm_uri)
     1696            self.failUnlessReallyEqual(fn4.get_uri(), b"imm." + future_imm_uri)
    16621697            self.failUnlessReallyEqual(fn4.get_write_uri(), None)
    1663             self.failUnlessReallyEqual(fn4.get_readonly_uri(), "imm." + future_imm_uri)
     1698            self.failUnlessReallyEqual(fn4.get_readonly_uri(), b"imm." + future_imm_uri)
    16641699
    16651700            # We should also be allowed to copy the "future" UnknownNode, because
    … …  
    16761711            self.failUnlessReallyEqual(fn.get_uri(), future_write_uri)
    16771712            self.failUnlessReallyEqual(fn.get_write_uri(), future_write_uri)
    1678             self.failUnlessReallyEqual(fn.get_readonly_uri(), "ro." + future_read_uri)
     1713            self.failUnlessReallyEqual(fn.get_readonly_uri(), b"ro." + future_read_uri)
    16791714        d.addCallback(_check2)
    16801715        return d
    16811716
    16821717    def test_unknown_strip_prefix_for_ro(self):
    1683         self.failUnlessReallyEqual(strip_prefix_for_ro("foo",     False), "foo")
    1684         self.failUnlessReallyEqual(strip_prefix_for_ro("ro.foo",  False), "foo")
    1685         self.failUnlessReallyEqual(strip_prefix_for_ro("imm.foo", False), "imm.foo")
    1686         self.failUnlessReallyEqual(strip_prefix_for_ro("foo",     True),  "foo")
    1687         self.failUnlessReallyEqual(strip_prefix_for_ro("ro.foo",  True),  "foo")
    1688         self.failUnlessReallyEqual(strip_prefix_for_ro("imm.foo", True),  "foo")
     1718        self.failUnlessReallyEqual(strip_prefix_for_ro(b"foo",     False), b"foo")
     1719        self.failUnlessReallyEqual(strip_prefix_for_ro(b"ro.foo",  False), b"foo")
     1720        self.failUnlessReallyEqual(strip_prefix_for_ro(b"imm.foo", False), b"imm.foo")
     1721        self.failUnlessReallyEqual(strip_prefix_for_ro(b"foo",     True),  b"foo")
     1722        self.failUnlessReallyEqual(strip_prefix_for_ro(b"ro.foo",  True),  b"foo")
     1723        self.failUnlessReallyEqual(strip_prefix_for_ro(b"imm.foo", True),  b"foo")
    16891724
    16901725    def test_unknownnode(self):
    … …  
    16981733        unknown_rw   = [# These are errors because we're only given a rw_uri, and we can't
    16991734                        # diminish it.
    1700                         ( 2, UnknownNode("foo", None)),
    1701                         ( 3, UnknownNode("foo", None, deep_immutable=True)),
    1702                         ( 4, UnknownNode("ro.foo", None, deep_immutable=True)),
    1703                         ( 5, UnknownNode("ro." + mut_read_uri, None, deep_immutable=True)),
    1704                         ( 5.1, UnknownNode("ro." + mdmf_read_uri, None, deep_immutable=True)),
    1705                         ( 6, UnknownNode("URI:SSK-RO:foo", None, deep_immutable=True)),
    1706                         ( 7, UnknownNode("URI:SSK:foo", None)),
     1735                        ( 2, UnknownNode(b"foo", None)),
     1736                        ( 3, UnknownNode(b"foo", None, deep_immutable=True)),
     1737                        ( 4, UnknownNode(b"ro.foo", None, deep_immutable=True)),
     1738                        ( 5, UnknownNode(b"ro." + mut_read_uri, None, deep_immutable=True)),
     1739                        ( 5.1, UnknownNode(b"ro." + mdmf_read_uri, None, deep_immutable=True)),
     1740                        ( 6, UnknownNode(b"URI:SSK-RO:foo", None, deep_immutable=True)),
     1741                        ( 7, UnknownNode(b"URI:SSK:foo", None)),
    17071742                       ]
    17081743        must_be_ro   = [# These are errors because a readonly constraint is not met.
    1709                         ( 8, UnknownNode("ro." + mut_write_uri, None)),
    1710                         ( 8.1, UnknownNode("ro." + mdmf_write_uri, None)),
    1711                         ( 9, UnknownNode(None, "ro." + mut_write_uri)),
    1712                         ( 9.1, UnknownNode(None, "ro." + mdmf_write_uri)),
     1744                        ( 8, UnknownNode(b"ro." + mut_write_uri, None)),
     1745                        ( 8.1, UnknownNode(b"ro." + mdmf_write_uri, None)),
     1746                        ( 9, UnknownNode(None, b"ro." + mut_write_uri)),
     1747                        ( 9.1, UnknownNode(None, b"ro." + mdmf_write_uri)),
    17131748                       ]
    17141749        must_be_imm  = [# These are errors because an immutable constraint is not met.
    1715                         (10, UnknownNode(None, "ro.URI:SSK-RO:foo", deep_immutable=True)),
    1716                         (11, UnknownNode(None, "imm.URI:SSK:foo")),
    1717                         (12, UnknownNode(None, "imm.URI:SSK-RO:foo")),
    1718                         (13, UnknownNode("bar", "ro.foo", deep_immutable=True)),
    1719                         (14, UnknownNode("bar", "imm.foo", deep_immutable=True)),
    1720                         (15, UnknownNode("bar", "imm." + lit_uri, deep_immutable=True)),
    1721                         (16, UnknownNode("imm." + mut_write_uri, None)),
    1722                         (16.1, UnknownNode("imm." + mdmf_write_uri, None)),
    1723                         (17, UnknownNode("imm." + mut_read_uri, None)),
    1724                         (17.1, UnknownNode("imm." + mdmf_read_uri, None)),
    1725                         (18, UnknownNode("bar", "imm.foo")),
     1750                        (10, UnknownNode(None, b"ro.URI:SSK-RO:foo", deep_immutable=True)),
     1751                        (11, UnknownNode(None, b"imm.URI:SSK:foo")),
     1752                        (12, UnknownNode(None, b"imm.URI:SSK-RO:foo")),
     1753                        (13, UnknownNode(b"bar", b"ro.foo", deep_immutable=True)),
     1754                        (14, UnknownNode(b"bar", b"imm.foo", deep_immutable=True)),
     1755                        (15, UnknownNode(b"bar", b"imm." + lit_uri, deep_immutable=True)),
     1756                        (16, UnknownNode(b"imm." + mut_write_uri, None)),
     1757                        (16.1, UnknownNode(b"imm." + mdmf_write_uri, None)),
     1758                        (17, UnknownNode(b"imm." + mut_read_uri, None)),
     1759                        (17.1, UnknownNode(b"imm." + mdmf_read_uri, None)),
     1760                        (18, UnknownNode(b"bar", b"imm.foo")),
    17261761                       ]
    17271762        bad_uri      = [# These are errors because the URI is bad once we've stripped the prefix.
    1728                         (19, UnknownNode("ro.URI:SSK-RO:foo", None)),
    1729                         (20, UnknownNode("imm.URI:CHK:foo", None, deep_immutable=True)),
    1730                         (21, UnknownNode(None, "URI:CHK:foo")),
    1731                         (22, UnknownNode(None, "URI:CHK:foo", deep_immutable=True)),
     1763                        (19, UnknownNode(b"ro.URI:SSK-RO:foo", None)),
     1764                        (20, UnknownNode(b"imm.URI:CHK:foo", None, deep_immutable=True)),
     1765                        (21, UnknownNode(None, b"URI:CHK:foo")),
     1766                        (22, UnknownNode(None, b"URI:CHK:foo", deep_immutable=True)),
    17321767                       ]
    17331768        ro_prefixed  = [# These are valid, and the readcap should end up with a ro. prefix.
    1734                         (23, UnknownNode(None, "foo")),
    1735                         (24, UnknownNode(None, "ro.foo")),
    1736                         (25, UnknownNode(None, "ro." + lit_uri)),
    1737                         (26, UnknownNode("bar", "foo")),
    1738                         (27, UnknownNode("bar", "ro.foo")),
    1739                         (28, UnknownNode("bar", "ro." + lit_uri)),
    1740                         (29, UnknownNode("ro.foo", None)),
    1741                         (30, UnknownNode("ro." + lit_uri, None)),
     1769                        (23, UnknownNode(None, b"foo")),
     1770                        (24, UnknownNode(None, b"ro.foo")),
     1771                        (25, UnknownNode(None, b"ro." + lit_uri)),
     1772                        (26, UnknownNode(b"bar", b"foo")),
     1773                        (27, UnknownNode(b"bar", b"ro.foo")),
     1774                        (28, UnknownNode(b"bar", b"ro." + lit_uri)),
     1775                        (29, UnknownNode(b"ro.foo", None)),
     1776                        (30, UnknownNode(b"ro." + lit_uri, None)),
    17421777                       ]
    17431778        imm_prefixed = [# These are valid, and the readcap should end up with an imm. prefix.
    1744                         (31, UnknownNode(None, "foo", deep_immutable=True)),
    1745                         (32, UnknownNode(None, "ro.foo", deep_immutable=True)),
    1746                         (33, UnknownNode(None, "imm.foo")),
    1747                         (34, UnknownNode(None, "imm.foo", deep_immutable=True)),
    1748                         (35, UnknownNode("imm." + lit_uri, None)),
    1749                         (36, UnknownNode("imm." + lit_uri, None, deep_immutable=True)),
    1750                         (37, UnknownNode(None, "imm." + lit_uri)),
    1751                         (38, UnknownNode(None, "imm." + lit_uri, deep_immutable=True)),
     1779                        (31, UnknownNode(None, b"foo", deep_immutable=True)),
     1780                        (32, UnknownNode(None, b"ro.foo", deep_immutable=True)),
     1781                        (33, UnknownNode(None, b"imm.foo")),
     1782                        (34, UnknownNode(None, b"imm.foo", deep_immutable=True)),
     1783                        (35, UnknownNode(b"imm." + lit_uri, None)),
     1784                        (36, UnknownNode(b"imm." + lit_uri, None, deep_immutable=True)),
     1785                        (37, UnknownNode(None, b"imm." + lit_uri)),
     1786                        (38, UnknownNode(None, b"imm." + lit_uri, deep_immutable=True)),
    17521787                       ]
    17531788        error = unknown_rw + must_be_ro + must_be_imm + bad_uri
    … …  
    17811816
    17821817        for (i, n) in ro_prefixed:
    1783             self.failUnless(n.get_readonly_uri().startswith("ro."), i)
     1818            self.failUnless(n.get_readonly_uri().startswith(b"ro."), i)
    17841819
    17851820        for (i, n) in imm_prefixed:
    1786             self.failUnless(n.get_readonly_uri().startswith("imm."), i)
     1821            self.failUnless(n.get_readonly_uri().startswith(b"imm."), i)
    17871822
    17881823
    … …  
    18681903        c0 = self.g.clients[0]
    18691904        d = c0.create_dirnode()
    1870         small = upload.Data("Small enough for a LIT", None)
     1905        small = upload.Data(b"Small enough for a LIT", None)
    18711906        def _created_dir(dn):
    18721907            self.root = dn
    … …  
    19101945            # root/file2
    19111946            # root/dir1
    1912             d = root_node.add_file(u'file1', upload.Data("Important Things",
     1947            d = root_node.add_file(u'file1', upload.Data(b"Important Things",
    19131948                None))
    19141949            d.addCallback(lambda res:
    1915                 root_node.add_file(u'file2', upload.Data("Sekrit Codes", None)))
     1950                root_node.add_file(u'file2', upload.Data(b"Sekrit Codes", None)))
    19161951            d.addCallback(lambda res:
    19171952                root_node.create_subdirectory(u"dir1"))

  • TabularUnified src/allmydata/unknown.py

    r1c2f3ee9 r919f31a  
    3232    def __init__(self, given_rw_uri, given_ro_uri, deep_immutable=False,
    3333                 name=u"<unknown name>"):
    34         assert given_rw_uri is None or isinstance(given_rw_uri, str)
    35         assert given_ro_uri is None or isinstance(given_ro_uri, str)
     34        assert given_rw_uri is None or isinstance(given_rw_uri, bytes)
     35        assert given_ro_uri is None or isinstance(given_ro_uri, bytes)
    3636        given_rw_uri = given_rw_uri or None
    3737        given_ro_uri = given_ro_uri or None
    … …  
    183183    def check_and_repair(self, monitor, verify, add_lease):
    184184        return defer.succeed(None)
     185
     186    def __eq__(self, other):
     187        if not isinstance(other, UnknownNode):
     188            return False
     189        return other.ro_uri == self.ro_uri and other.rw_uri == self.rw_uri
     190
     191    def __ne__(self, other):
     192        return not (self == other)

  • TabularUnified src/allmydata/util/_python3.py

    r1c2f3ee9 r919f31a  
    3535    "allmydata.crypto.rsa",
    3636    "allmydata.crypto.util",
     37    "allmydata.dirnode",
    3738    "allmydata.hashtree",
    3839    "allmydata.immutable.checker",
    … …  
    6869    "allmydata.mutable.servermap",
    6970    "allmydata.node",
     71    "allmydata.nodemaker",
    7072    "allmydata.storage_client",
    7173    "allmydata.storage.common",
    … …  
    137139    "allmydata.test.test_deferredutil",
    138140    "allmydata.test.test_dictutil",
     141    "allmydata.test.test_dirnode",
    139142    "allmydata.test.test_download",
    140143    "allmydata.test.test_encode",
Note: See TracChangeset for help on using the changeset viewer.