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.python import log
   6
   7 import allmydata
   8 from allmydata import client
   9 from allmydata.introducer.client import IntroducerClient
  10 from allmydata.util import base32
  11 from foolscap.eventual import flushEventualQueue
  12 import common_util as testutil
  13
  14 class FakeIntroducerClient(IntroducerClient):
  15     def __init__(self):
  16         self._connections = set()
  17     def add_peer(self, nodeid):
  18         entry = (nodeid, "storage", "rref")
  19         self._connections.add(entry)
  20     def remove_all_peers(self):
  21         self._connections.clear()
  22
  23 class Basic(unittest.TestCase):
  24     def test_loadable(self):
  25         basedir = "test_client.Basic.test_loadable"
  26         os.mkdir(basedir)
  27         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  28         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  29         c = client.Client(basedir)
  30
  31     def test_loadable_without_vdrive(self):
  32         basedir = "test_client.Basic.test_loadable_without_vdrive"
  33         os.mkdir(basedir)
  34         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  35         c = client.Client(basedir)
  36
  37     def test_secrets(self):
  38         basedir = "test_client.Basic.test_secrets"
  39         os.mkdir(basedir)
  40         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  41         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  42         c = client.Client(basedir)
  43         secret_fname = os.path.join(basedir, "private", "secret")
  44         self.failUnless(os.path.exists(secret_fname), secret_fname)
  45         renew_secret = c.get_renewal_secret()
  46         self.failUnless(base32.b2a(renew_secret))
  47         cancel_secret = c.get_cancel_secret()
  48         self.failUnless(base32.b2a(cancel_secret))
  49
  50     def test_sizelimit_1(self):
  51         basedir = "client.Basic.test_sizelimit_1"
  52         os.mkdir(basedir)
  53         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  54         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  55         open(os.path.join(basedir, "sizelimit"), "w").write("1000")
  56         c = client.Client(basedir)
  57         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit, 1000)
  58
  59     def test_sizelimit_2(self):
  60         basedir = "client.Basic.test_sizelimit_2"
  61         os.mkdir(basedir)
  62         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  63         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  64         open(os.path.join(basedir, "sizelimit"), "w").write("10K")
  65         c = client.Client(basedir)
  66         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit, 10*1000)
  67
  68     def test_sizelimit_3(self):
  69         basedir = "client.Basic.test_sizelimit_3"
  70         os.mkdir(basedir)
  71         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  72         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  73         open(os.path.join(basedir, "sizelimit"), "w").write("5mB")
  74         c = client.Client(basedir)
  75         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit,
  76                              5*1000*1000)
  77
  78     def test_sizelimit_4(self):
  79         basedir = "client.Basic.test_sizelimit_4"
  80         os.mkdir(basedir)
  81         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  82         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  83         open(os.path.join(basedir, "sizelimit"), "w").write("78Gb")
  84         c = client.Client(basedir)
  85         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit,
  86                              78*1000*1000*1000)
  87
  88     def test_sizelimit_bad(self):
  89         basedir = "client.Basic.test_sizelimit_bad"
  90         os.mkdir(basedir)
  91         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  92         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  93         open(os.path.join(basedir, "sizelimit"), "w").write("bogus")
  94         c = client.Client(basedir)
  95         self.failUnlessEqual(c.getServiceNamed("storage").sizelimit, None)
  96
  97     def _permute(self, c, key):
  98         return [ peerid
  99                  for (peerid,rref) in c.get_permuted_peers("storage", key) ]
 100
 101     def test_permute(self):
 102         basedir = "test_client.Basic.test_permute"
 103         os.mkdir(basedir)
 104         open(os.path.join(basedir, "introducer.furl"), "w").write("")
 105         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
 106         c = client.Client(basedir)
 107         c.introducer_client = FakeIntroducerClient()
 108         for k in ["%d" % i for i in range(5)]:
 109             c.introducer_client.add_peer(k)
 110
 111         self.failUnlessEqual(self._permute(c, "one"), ['3','1','0','4','2'])
 112         self.failUnlessEqual(self._permute(c, "two"), ['0','4','2','1','3'])
 113         c.introducer_client.remove_all_peers()
 114         self.failUnlessEqual(self._permute(c, "one"), [])
 115
 116         c2 = client.Client(basedir)
 117         c2.introducer_client = FakeIntroducerClient()
 118         for k in ["%d" % i for i in range(5)]:
 119             c2.introducer_client.add_peer(k)
 120         self.failUnlessEqual(self._permute(c2, "one"), ['3','1','0','4','2'])
 121
 122     def test_versions(self):
 123         basedir = "test_client.Basic.test_versions"
 124         os.mkdir(basedir)
 125         open(os.path.join(basedir, "introducer.furl"), "w").write("")
 126         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
 127         c = client.Client(basedir)
 128         ss = c.getServiceNamed("storage")
 129         mine, oldest = ss.remote_get_versions()
 130         self.failUnlessEqual(mine, str(allmydata.__version__))
 131         self.failIfEqual(str(allmydata.__version__), "unknown")
 132         self.failUnless("." in str(allmydata.__version__),
 133                         "non-numeric version in '%s'" % allmydata.__version__)
 134         all_versions = allmydata.get_package_versions_string()
 135         self.failUnless("allmydata" in all_versions)
 136         log.msg("tahoe versions: %s" % all_versions)
 137         # also test stats
 138         stats = c.get_stats()
 139         self.failUnless("node.uptime" in stats)
 140         self.failUnless(isinstance(stats["node.uptime"], float))
 141
 142 def flush_but_dont_ignore(res):
 143     d = flushEventualQueue()
 144     def _done(ignored):
 145         return res
 146     d.addCallback(_done)
 147     return d
 148
 149 class Run(unittest.TestCase, testutil.StallMixin):
 150
 151     def setUp(self):
 152         self.sparent = service.MultiService()
 153         self.sparent.startService()
 154     def tearDown(self):
 155         d = self.sparent.stopService()
 156         d.addBoth(flush_but_dont_ignore)
 157         return d
 158
 159     def test_loadable(self):
 160         basedir = "test_client.Run.test_loadable"
 161         os.mkdir(basedir)
 162         dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
 163         open(os.path.join(basedir, "introducer.furl"), "w").write(dummy)
 164         open(os.path.join(basedir, "suicide_prevention_hotline"), "w")
 165         c = client.Client(basedir)
 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