src/allmydata/test/test_client.py

   1
   2 import os
   3 from twisted.trial import unittest
   4 from twisted.application import service
   5 from twisted.internet import reactor, defer
   6 from twisted.python import log
   7
   8 import allmydata
   9 from allmydata import client, introducer
  10 from allmydata.util import base32
  11 from foolscap.eventual import flushEventualQueue
  12
  13 class FakeIntroducerClient(introducer.IntroducerClient):
  14     def __init__(self):
  15         self._connections = set()
  16     def add_peer(self, nodeid):
  17         entry = (nodeid, "storage", "rref")
  18         self._connections.add(entry)
  19     def remove_all_peers(self):
  20         self._connections.clear()
  21
  22 class Basic(unittest.TestCase):
  23     def test_loadable(self):
  24         basedir = "test_client.Basic.test_loadable"
  25         os.mkdir(basedir)
  26         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  27         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  28         c = client.Client(basedir)
  29
  30     def test_loadable_without_vdrive(self):
  31         basedir = "test_client.Basic.test_loadable_without_vdrive"
  32         os.mkdir(basedir)
  33         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  34         c = client.Client(basedir)
  35
  36     def test_secrets(self):
  37         basedir = "test_client.Basic.test_secrets"
  38         os.mkdir(basedir)
  39         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  40         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  41         c = client.Client(basedir)
  42         secret_fname = os.path.join(basedir, "private", "secret")
  43         self.failUnless(os.path.exists(secret_fname), secret_fname)
  44         renew_secret = c.get_renewal_secret()
  45         self.failUnless(base32.b2a(renew_secret))
  46         cancel_secret = c.get_cancel_secret()
  47         self.failUnless(base32.b2a(cancel_secret))
  48
  49     def test_sizelimit_1(self):
  50         basedir = "client.Basic.test_sizelimit_1"
  51         os.mkdir(basedir)
  52         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  53         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  54         open(os.path.join(basedir, "sizelimit"), "w").write("1000")
  55         c = client.Client(basedir)
  56         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit, 1000)
  57
  58     def test_sizelimit_2(self):
  59         basedir = "client.Basic.test_sizelimit_2"
  60         os.mkdir(basedir)
  61         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  62         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  63         open(os.path.join(basedir, "sizelimit"), "w").write("10K")
  64         c = client.Client(basedir)
  65         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit, 10*1000)
  66
  67     def test_sizelimit_3(self):
  68         basedir = "client.Basic.test_sizelimit_3"
  69         os.mkdir(basedir)
  70         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  71         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  72         open(os.path.join(basedir, "sizelimit"), "w").write("5mB")
  73         c = client.Client(basedir)
  74         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit,
  75                              5*1000*1000)
  76
  77     def test_sizelimit_4(self):
  78         basedir = "client.Basic.test_sizelimit_4"
  79         os.mkdir(basedir)
  80         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  81         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  82         open(os.path.join(basedir, "sizelimit"), "w").write("78Gb")
  83         c = client.Client(basedir)
  84         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit,
  85                              78*1000*1000*1000)
  86
  87     def test_sizelimit_bad(self):
  88         basedir = "client.Basic.test_sizelimit_bad"
  89         os.mkdir(basedir)
  90         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  91         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  92         open(os.path.join(basedir, "sizelimit"), "w").write("bogus")
  93         c = client.Client(basedir)
  94         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit, None)
  95
  96     def _permute(self, c, key):
  97         return [ peerid
  98                  for (peerid,rref) in c.get_permuted_peers("storage", key) ]
  99
 100     def test_permute(self):
 101         basedir = "test_client.Basic.test_permute"
 102         os.mkdir(basedir)
 103         open(os.path.join(basedir, "introducer.furl"), "w").write("")
 104         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
 105         c = client.Client(basedir)
 106         c.introducer_client = FakeIntroducerClient()
 107         for k in ["%d" % i for i in range(5)]:
 108             c.introducer_client.add_peer(k)
 109
 110         self.failUnlessEqual(self._permute(c, "one"), ['3','1','0','4','2'])
 111         self.failUnlessEqual(self._permute(c, "two"), ['0','4','2','1','3'])
 112         c.introducer_client.remove_all_peers()
 113         self.failUnlessEqual(self._permute(c, "one"), [])
 114
 115         c2 = client.Client(basedir)
 116         c2.introducer_client = FakeIntroducerClient()
 117         for k in ["%d" % i for i in range(5)]:
 118             c2.introducer_client.add_peer(k)
 119         self.failUnlessEqual(self._permute(c2, "one"), ['3','1','0','4','2'])
 120
 121     def test_versions(self):
 122         basedir = "test_client.Basic.test_versions"
 123         os.mkdir(basedir)
 124         open(os.path.join(basedir, "introducer.furl"), "w").write("")
 125         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
 126         c = client.Client(basedir)
 127         ss = c.getServiceNamed("storage")
 128         mine, oldest = ss.remote_get_versions()
 129         self.failUnlessEqual(mine, str(allmydata.__version__))
 130         self.failIfEqual(str(allmydata.__version__), "unknown")
 131         self.failUnless("." in str(allmydata.__version__),
 132                         "non-numeric version in '%s'" % allmydata.__version__)
 133         all_versions = allmydata.get_package_versions_string()
 134         self.failUnless("allmydata" in all_versions)
 135         log.msg("tahoe versions: %s" % all_versions)
 136
 137 def flush_but_dont_ignore(res):
 138     d = flushEventualQueue()
 139     def _done(ignored):
 140         return res
 141     d.addCallback(_done)
 142     return d
 143
 144 class Run(unittest.TestCase):
 145
 146     def setUp(self):
 147         self.sparent = service.MultiService()
 148         self.sparent.startService()
 149     def tearDown(self):
 150         d = self.sparent.stopService()
 151         d.addBoth(flush_but_dont_ignore)
 152         return d
 153
 154     def test_loadable(self):
 155         basedir = "test_client.Run.test_loadable"
 156         os.mkdir(basedir)
 157         dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
 158         open(os.path.join(basedir, "introducer.furl"), "w").write(dummy)
 159         open(os.path.join(basedir, "suicide_prevention_hotline"), "w")
 160         c = client.Client(basedir)
 161
 162     def stall(self, res=None, delay=1):
 163         d = defer.Deferred()
 164         reactor.callLater(delay, d.callback, res)
 165         return d
 166
 167     def test_reloadable(self):
 168         basedir = "test_client.Run.test_reloadable"
 169         os.mkdir(basedir)
 170         dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
 171         open(os.path.join(basedir, "introducer.furl"), "w").write(dummy)
 172         c1 = client.Client(basedir)
 173         c1.setServiceParent(self.sparent)
 174
 175         # delay to let the service start up completely. I'm not entirely sure
 176         # this is necessary.
 177         d = self.stall(delay=2.0)
 178         d.addCallback(lambda res: c1.disownServiceParent())
 179         # the cygwin buildslave seems to need more time to let the old
 180         # service completely shut down. When delay=0.1, I saw this test fail,
 181         # probably due to the logport trying to reclaim the old socket
 182         # number. This suggests that either we're dropping a Deferred
 183         # somewhere in the shutdown sequence, or that cygwin is just cranky.
 184         d.addCallback(self.stall, delay=2.0)
 185         def _restart(res):
 186             # TODO: pause for slightly over one second, to let
 187             # Client._check_hotline poll the file once. That will exercise
 188             # another few lines. Then add another test in which we don't
 189             # update the file at all, and watch to see the node shutdown. (to
 190             # do this, use a modified node which overrides Node.shutdown(),
 191             # also change _check_hotline to use it instead of a raw
 192             # reactor.stop, also instrument the shutdown event in an
 193             # attribute that we can check)
 194             c2 = client.Client(basedir)
 195             c2.setServiceParent(self.sparent)
 196             return c2.disownServiceParent()
 197         d.addCallback(_restart)
 198         return d
 199