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
   7 import allmydata
   8 from allmydata import client, introducer
   9 from allmydata.util import version
  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_sizelimit_1(self):
  34         basedir = "client.Basic.test_sizelimit_1"
  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         open(os.path.join(basedir, "sizelimit"), "w").write("1000")
  39         c = client.Client(basedir)
  40         self.failUnlessEqual(c.getServiceNamed("storageserver").sizelimit,
  41                              1000)
  42
  43     def test_sizelimit_2(self):
  44         basedir = "client.Basic.test_sizelimit_2"
  45         os.mkdir(basedir)
  46         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  47         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  48         open(os.path.join(basedir, "sizelimit"), "w").write("10K")
  49         c = client.Client(basedir)
  50         self.failUnlessEqual(c.getServiceNamed("storageserver").sizelimit,
  51                              10*1000)
  52
  53     def test_sizelimit_3(self):
  54         basedir = "client.Basic.test_sizelimit_3"
  55         os.mkdir(basedir)
  56         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  57         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  58         open(os.path.join(basedir, "sizelimit"), "w").write("5mB")
  59         c = client.Client(basedir)
  60         self.failUnlessEqual(c.getServiceNamed("storageserver").sizelimit,
  61                              5*1000*1000)
  62
  63     def test_sizelimit_4(self):
  64         basedir = "client.Basic.test_sizelimit_4"
  65         os.mkdir(basedir)
  66         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  67         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  68         open(os.path.join(basedir, "sizelimit"), "w").write("78Gb")
  69         c = client.Client(basedir)
  70         self.failUnlessEqual(c.getServiceNamed("storageserver").sizelimit,
  71                              78*1000*1000*1000)
  72
  73     def test_sizelimit_bad(self):
  74         basedir = "client.Basic.test_sizelimit_bad"
  75         os.mkdir(basedir)
  76         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  77         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  78         open(os.path.join(basedir, "sizelimit"), "w").write("bogus")
  79         c = client.Client(basedir)
  80         self.failUnlessEqual(c.getServiceNamed("storageserver").sizelimit,
  81                              None)
  82
  83     def test_permute(self):
  84         basedir = "test_client.Basic.test_permute"
  85         os.mkdir(basedir)
  86         open(os.path.join(basedir, "introducer.furl"), "w").write("")
  87         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
  88         c = client.Client(basedir)
  89         c.introducer_client = MyIntroducerClient()
  90         for k in ["%d" % i for i in range(5)]:
  91             c.introducer_client.connections[k] = None
  92         self.failUnlessEqual(permute(c, "one"), ['3','1','0','4','2'])
  93         self.failUnlessEqual(permute(c, "two"), ['0','4','2','1','3'])
  94         c.introducer_client.connections.clear()
  95         self.failUnlessEqual(permute(c, "one"), [])
  96
  97         c2 = client.Client(basedir)
  98         c2.introducer_client = MyIntroducerClient()
  99         for k in ["%d" % i for i in range(5)]:
 100             c2.introducer_client.connections[k] = None
 101         self.failUnlessEqual(permute(c2, "one"), ['3','1','0','4','2'])
 102
 103     def test_versions(self):
 104         basedir = "test_client.Basic.test_versions"
 105         os.mkdir(basedir)
 106         open(os.path.join(basedir, "introducer.furl"), "w").write("")
 107         open(os.path.join(basedir, "vdrive.furl"), "w").write("")
 108         c = client.Client(basedir)
 109         mine, oldest = c.remote_get_versions()
 110         self.failUnlessEqual(version.Version(mine), allmydata.__version__)
 111
 112 def flush_but_dont_ignore(res):
 113     d = flushEventualQueue()
 114     def _done(ignored):
 115         return res
 116     d.addCallback(_done)
 117     return d
 118
 119 class Run(unittest.TestCase):
 120
 121     def setUp(self):
 122         self.sparent = service.MultiService()
 123         self.sparent.startService()
 124     def tearDown(self):
 125         d = self.sparent.stopService()
 126         d.addBoth(flush_but_dont_ignore)
 127         return d
 128
 129     def test_loadable(self):
 130         basedir = "test_client.Run.test_loadable"
 131         os.mkdir(basedir)
 132         dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
 133         open(os.path.join(basedir, "introducer.furl"), "w").write(dummy)
 134         open(os.path.join(basedir, "suicide_prevention_hotline"), "w")
 135         c = client.Client(basedir)
 136
 137     def stall(self, res=None, delay=1):
 138         d = defer.Deferred()
 139         reactor.callLater(delay, d.callback, res)
 140         return d
 141
 142     def test_reloadable(self):
 143         basedir = "test_client.Run.test_reloadable"
 144         os.mkdir(basedir)
 145         dummy = "pb://wl74cyahejagspqgy4x5ukrvfnevlknt@127.0.0.1:58889/bogus"
 146         open(os.path.join(basedir, "introducer.furl"), "w").write(dummy)
 147         c1 = client.Client(basedir)
 148         c1.setServiceParent(self.sparent)
 149
 150         d = self.stall(delay=0.1)
 151         d.addCallback(lambda res: c1.disownServiceParent())
 152         def _restart(res):
 153             c2 = client.Client(basedir)
 154             c2.setServiceParent(self.sparent)
 155             return c2.disownServiceParent()
 156         d.addCallback(_restart)
 157         return d
 158