src/allmydata/test/test_client.py

   1
   2 import os, stat
   3 from twisted.trial import unittest
   4 from twisted.application import service
   5 from twisted.internet import reactor, defer
   6
   7 import allmydata
   8 from allmydata import client, introducer
   9 from allmydata.util import version_class, idlib
  10 from foolscap.eventual import flushEventualQueue
  11
  12 class MyIntroducerClient(introducer.IntroducerClient):
  13     def __init__(self):
  14         self.connections = {}
  15
  16 def permute(c, key):
  17     return [ y for x, y, z in c.get_permuted_peers(key) ]
  18
  19 class Basic(unittest.TestCase):
  20     def test_loadable(self):
  21         basedir = "test_client.Basic.test_loadable"
  22         os.mkdir(basedir)
  23         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  24         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  25         c = client.Client(basedir)
  26
  27     def test_loadable_without_vdrive(self):
  28         basedir = "test_client.Basic.test_loadable_without_vdrive"
  29         os.mkdir(basedir)
  30         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  31         c = client.Client(basedir)
  32
  33     def test_secrets(self):
  34         basedir = "test_client.Basic.test_secrets"
  35         os.mkdir(basedir)
  36         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  37         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  38         c = client.Client(basedir)
  39         secret_file = os.path.join(basedir, "secret")
  40         self.failUnless(os.path.exists(secret_file))
  41         self.failUnlessEqual(os.stat(secret_file)[stat.ST_MODE] & 0777, 0600)
  42         renew_secret = c.get_renewal_secret()
  43         self.failUnless(idlib.b2a(renew_secret))
  44         cancel_secret = c.get_cancel_secret()
  45         self.failUnless(idlib.b2a(cancel_secret))
  46
  47     def test_sizelimit_1(self):
  48         basedir = "client.Basic.test_sizelimit_1"
  49         os.mkdir(basedir)
  50         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  51         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  52         open(os.path.join(basedir, "sizelimit"), "w").write("1000")
  53         c = client.Client(basedir)
  54         self.failUnlessEqual(c.getServiceNamed("storageserver").sizelimit,
  55                              1000)
  56
  57     def test_sizelimit_2(self):
  58         basedir = "client.Basic.test_sizelimit_2"
  59         os.mkdir(basedir)
  60         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  61         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  62         open(os.path.join(basedir, "sizelimit"), "w").write("10K")
  63         c = client.Client(basedir)
  64         self.failUnlessEqual(c.getServiceNamed("storageserver").sizelimit,
  65                              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("storageserver").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("storageserver").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("storageserver").sizelimit,
  95                              None)
  96
  97     def test_permute(self):
  98         basedir = "test_client.Basic.test_permute"
  99         os.mkdir(basedir)
 100         open(os.path.join(basedir, "introducer.furl"), "w").write("")
 101         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
 102         c = client.Client(basedir)
 103         c.introducer_client = MyIntroducerClient()
 104         for k in ["%d" % i for i in range(5)]:
 105             c.introducer_client.connections[k] = None
 106         self.failUnlessEqual(permute(c, "one"), ['3','1','0','4','2'])
 107         self.failUnlessEqual(permute(c, "two"), ['0','4','2','1','3'])
 108         c.introducer_client.connections.clear()
 109         self.failUnlessEqual(permute(c, "one"), [])
 110
 111         c2 = client.Client(basedir)
 112         c2.introducer_client = MyIntroducerClient()
 113         for k in ["%d" % i for i in range(5)]:
 114             c2.introducer_client.connections[k] = None
 115         self.failUnlessEqual(permute(c2, "one"), ['3','1','0','4','2'])
 116
 117     def test_versions(self):
 118         basedir = "test_client.Basic.test_versions"
 119         os.mkdir(basedir)
 120         open(os.path.join(basedir, "introducer.furl"), "w").write("")
 121         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
 122         c = client.Client(basedir)
 123         mine, oldest = c.remote_get_versions()
 124         self.failUnlessEqual(version_class.Version(mine), allmydata.__version__)
 125
 126 def flush_but_dont_ignore(res):
 127     d = flushEventualQueue()
 128     def _done(ignored):
 129         return res
 130     d.addCallback(_done)
 131     return d
 132
 133 class Run(unittest.TestCase):
 134
 135     def setUp(self):
 136         self.sparent = service.MultiService()
 137         self.sparent.startService()
 138     def tearDown(self):
 139         d = self.sparent.stopService()
 140         d.addBoth(flush_but_dont_ignore)
 141         return d
 142
 143     def test_loadable(self):
 144         basedir = "test_client.Run.test_loadable"
 145         os.mkdir(basedir)
 146         dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
 147         open(os.path.join(basedir, "introducer.furl"), "w").write(dummy)
 148         open(os.path.join(basedir, "suicide_prevention_hotline"), "w")
 149         c = client.Client(basedir)
 150
 151     def stall(self, res=None, delay=1):
 152         d = defer.Deferred()
 153         reactor.callLater(delay, d.callback, res)
 154         return d
 155
 156     def test_reloadable(self):
 157         basedir = "test_client.Run.test_reloadable"
 158         os.mkdir(basedir)
 159         dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
 160         open(os.path.join(basedir, "introducer.furl"), "w").write(dummy)
 161         c1 = client.Client(basedir)
 162         c1.setServiceParent(self.sparent)
 163
 164         d = self.stall(delay=0.1)
 165         d.addCallback(lambda res: c1.disownServiceParent())
 166         def _restart(res):
 167             c2 = client.Client(basedir)
 168             c2.setServiceParent(self.sparent)
 169             return c2.disownServiceParent()
 170         d.addCallback(_restart)
 171         return d
 172