src/allmydata/test/common.py

   1 import os, random, struct
   2 from zope.interface import implements
   3 from twisted.internet import defer
   4 from twisted.internet.interfaces import IPullProducer
   5 from twisted.python import failure
   6 from twisted.application import service
   7 from twisted.web.error import Error as WebError
   8 from foolscap.api import flushEventualQueue, fireEventually
   9 from allmydata import uri, dirnode, client
  10 from allmydata.introducer.server import IntroducerNode
  11 from allmydata.interfaces import IMutableFileNode, IImmutableFileNode,\
  12                                  NotEnoughSharesError, ICheckable, \
  13                                  IMutableUploadable, SDMF_VERSION, \
  14                                  MDMF_VERSION
  15 from allmydata.check_results import CheckResults, CheckAndRepairResults, \
  16      DeepCheckResults, DeepCheckAndRepairResults
  17 from allmydata.mutable.common import CorruptShareError
  18 from allmydata.mutable.layout import unpack_header
  19 from allmydata.mutable.publish import MutableData
  20 from allmydata.storage.mutable import MutableShareFile
  21 from allmydata.util import hashutil, log, fileutil, pollmixin
  22 from allmydata.util.assertutil import precondition
  23 from allmydata.util.consumer import download_to_data
  24 from allmydata.stats import StatsGathererService
  25 from allmydata.key_generator import KeyGeneratorService
  26 import allmydata.test.common_util as testutil
  27 from allmydata import immutable
  28
  29
  30 def flush_but_dont_ignore(res):
  31     d = flushEventualQueue()
  32     def _done(ignored):
  33         return res
  34     d.addCallback(_done)
  35     return d
  36
  37 class DummyProducer:
  38     implements(IPullProducer)
  39     def resumeProducing(self):
  40         pass
  41
  42 class FakeCHKFileNode:
  43     """I provide IImmutableFileNode, but all of my data is stored in a
  44     class-level dictionary."""
  45     implements(IImmutableFileNode)
  46     all_contents = {}
  47     bad_shares = {}
  48
  49     def __init__(self, filecap):
  50         precondition(isinstance(filecap, (uri.CHKFileURI, uri.LiteralFileURI)), filecap)
  51         self.my_uri = filecap
  52         self.storage_index = self.my_uri.get_storage_index()
  53
  54     def get_uri(self):
  55         return self.my_uri.to_string()
  56     def get_write_uri(self):
  57         return None
  58     def get_readonly_uri(self):
  59         return self.my_uri.to_string()
  60     def get_cap(self):
  61         return self.my_uri
  62     def get_verify_cap(self):
  63         return self.my_uri.get_verify_cap()
  64     def get_repair_cap(self):
  65         return self.my_uri.get_verify_cap()
  66     def get_storage_index(self):
  67         return self.storage_index
  68
  69     def check(self, monitor, verify=False, add_lease=False):
  70         r = CheckResults(self.my_uri, self.storage_index)
  71         is_bad = self.bad_shares.get(self.storage_index, None)
  72         data = {}
  73         data["count-shares-needed"] = 3
  74         data["count-shares-expected"] = 10
  75         data["count-good-share-hosts"] = 10
  76         data["count-wrong-shares"] = 0
  77         nodeid = "\x00"*20
  78         data["list-corrupt-shares"] = []
  79         data["sharemap"] = {1: [nodeid]}
  80         data["servers-responding"] = [nodeid]
  81         data["count-recoverable-versions"] = 1
  82         data["count-unrecoverable-versions"] = 0
  83         if is_bad:
  84             r.set_healthy(False)
  85             r.set_recoverable(True)
  86             data["count-shares-good"] = 9
  87             data["list-corrupt-shares"] = [(nodeid, self.storage_index, 0)]
  88             r.problems = failure.Failure(CorruptShareError(is_bad))
  89         else:
  90             r.set_healthy(True)
  91             r.set_recoverable(True)
  92             data["count-shares-good"] = 10
  93             r.problems = []
  94         r.set_data(data)
  95         r.set_needs_rebalancing(False)
  96         return defer.succeed(r)
  97     def check_and_repair(self, monitor, verify=False, add_lease=False):
  98         d = self.check(verify)
  99         def _got(cr):
 100             r = CheckAndRepairResults(self.storage_index)
 101             r.pre_repair_results = r.post_repair_results = cr
 102             return r
 103         d.addCallback(_got)
 104         return d
 105
 106     def is_mutable(self):
 107         return False
 108     def is_readonly(self):
 109         return True
 110     def is_unknown(self):
 111         return False
 112     def is_allowed_in_immutable_directory(self):
 113         return True
 114     def raise_error(self):
 115         pass
 116
 117     def get_size(self):
 118         if isinstance(self.my_uri, uri.LiteralFileURI):
 119             return self.my_uri.get_size()
 120         try:
 121             data = self.all_contents[self.my_uri.to_string()]
 122         except KeyError, le:
 123             raise NotEnoughSharesError(le, 0, 3)
 124         return len(data)
 125
 126     def read(self, consumer, offset=0, size=None):
 127         # we don't bother to call registerProducer/unregisterProducer,
 128         # because it's a hassle to write a dummy Producer that does the right
 129         # thing (we have to make sure that DummyProducer.resumeProducing
 130         # writes the data into the consumer immediately, otherwise it will
 131         # loop forever).
 132
 133         d = defer.succeed(None)
 134         d.addCallback(self._read, consumer, offset, size)
 135         return d
 136
 137     def _read(self, ignored, consumer, offset, size):
 138         if isinstance(self.my_uri, uri.LiteralFileURI):
 139             data = self.my_uri.data
 140         else:
 141             if self.my_uri.to_string() not in self.all_contents:
 142                 raise NotEnoughSharesError(None, 0, 3)
 143             data = self.all_contents[self.my_uri.to_string()]
 144         start = offset
 145         if size is not None:
 146             end = offset + size
 147         else:
 148             end = len(data)
 149         consumer.write(data[start:end])
 150         return consumer
 151
 152
 153     def get_best_readable_version(self):
 154         return defer.succeed(self)
 155
 156
 157     def download_to_data(self):
 158         return download_to_data(self)
 159
 160
 161     download_best_version = download_to_data
 162
 163
 164     def get_size_of_best_version(self):
 165         return defer.succeed(self.get_size)
 166
 167
 168 def make_chk_file_cap(size):
 169     return uri.CHKFileURI(key=os.urandom(16),
 170                           uri_extension_hash=os.urandom(32),
 171                           needed_shares=3,
 172                           total_shares=10,
 173                           size=size)
 174 def make_chk_file_uri(size):
 175     return make_chk_file_cap(size).to_string()
 176
 177 def create_chk_filenode(contents):
 178     filecap = make_chk_file_cap(len(contents))
 179     n = FakeCHKFileNode(filecap)
 180     FakeCHKFileNode.all_contents[filecap.to_string()] = contents
 181     return n
 182
 183
 184 class FakeMutableFileNode:
 185     """I provide IMutableFileNode, but all of my data is stored in a
 186     class-level dictionary."""
 187
 188     implements(IMutableFileNode, ICheckable)
 189     MUTABLE_SIZELIMIT = 10000
 190     all_contents = {}
 191     bad_shares = {}
 192     file_types = {} # storage index => MDMF_VERSION or SDMF_VERSION
 193
 194     def __init__(self, storage_broker, secret_holder,
 195                  default_encoding_parameters, history):
 196         self.init_from_cap(make_mutable_file_cap())
 197         self._k = default_encoding_parameters['k']
 198         self._segsize = default_encoding_parameters['max_segment_size']
 199     def create(self, contents, key_generator=None, keysize=None,
 200                version=SDMF_VERSION):
 201         if version == MDMF_VERSION and \
 202             isinstance(self.my_uri, (uri.ReadonlySSKFileURI,
 203                                  uri.WriteableSSKFileURI)):
 204             self.init_from_cap(make_mdmf_mutable_file_cap())
 205         self.file_types[self.storage_index] = version
 206         initial_contents = self._get_initial_contents(contents)
 207         data = initial_contents.read(initial_contents.get_size())
 208         data = "".join(data)
 209         self.all_contents[self.storage_index] = data
 210         self.my_uri.set_extension_params([self._k, self._segsize])
 211         return defer.succeed(self)
 212     def _get_initial_contents(self, contents):
 213         if contents is None:
 214             return MutableData("")
 215
 216         if IMutableUploadable.providedBy(contents):
 217             return contents
 218
 219         assert callable(contents), "%s should be callable, not %s" % \
 220                (contents, type(contents))
 221         return contents(self)
 222     def init_from_cap(self, filecap):
 223         assert isinstance(filecap, (uri.WriteableSSKFileURI,
 224                                     uri.ReadonlySSKFileURI,
 225                                     uri.WritableMDMFFileURI,
 226                                     uri.ReadonlyMDMFFileURI))
 227         self.my_uri = filecap
 228         self.storage_index = self.my_uri.get_storage_index()
 229         if isinstance(filecap, (uri.WritableMDMFFileURI,
 230                                 uri.ReadonlyMDMFFileURI)):
 231             self.file_types[self.storage_index] = MDMF_VERSION
 232
 233         else:
 234             self.file_types[self.storage_index] = SDMF_VERSION
 235
 236         return self
 237     def get_cap(self):
 238         return self.my_uri
 239     def get_readcap(self):
 240         return self.my_uri.get_readonly()
 241     def get_uri(self):
 242         return self.my_uri.to_string()
 243     def get_write_uri(self):
 244         if self.is_readonly():
 245             return None
 246         return self.my_uri.to_string()
 247     def get_readonly(self):
 248         return self.my_uri.get_readonly()
 249     def get_readonly_uri(self):
 250         return self.my_uri.get_readonly().to_string()
 251     def get_verify_cap(self):
 252         return self.my_uri.get_verify_cap()
 253     def get_repair_cap(self):
 254         if self.my_uri.is_readonly():
 255             return None
 256         return self.my_uri
 257     def is_readonly(self):
 258         return self.my_uri.is_readonly()
 259     def is_mutable(self):
 260         return self.my_uri.is_mutable()
 261     def is_unknown(self):
 262         return False
 263     def is_allowed_in_immutable_directory(self):
 264         return not self.my_uri.is_mutable()
 265     def raise_error(self):
 266         pass
 267     def get_writekey(self):
 268         return "\x00"*16
 269     def get_size(self):
 270         return len(self.all_contents[self.storage_index])
 271     def get_current_size(self):
 272         return self.get_size_of_best_version()
 273     def get_size_of_best_version(self):
 274         return defer.succeed(len(self.all_contents[self.storage_index]))
 275
 276     def get_storage_index(self):
 277         return self.storage_index
 278
 279     def get_servermap(self, mode):
 280         return defer.succeed(None)
 281
 282     def get_version(self):
 283         assert self.storage_index in self.file_types
 284         return self.file_types[self.storage_index]
 285
 286     def check(self, monitor, verify=False, add_lease=False):
 287         r = CheckResults(self.my_uri, self.storage_index)
 288         is_bad = self.bad_shares.get(self.storage_index, None)
 289         data = {}
 290         data["count-shares-needed"] = 3
 291         data["count-shares-expected"] = 10
 292         data["count-good-share-hosts"] = 10
 293         data["count-wrong-shares"] = 0
 294         data["list-corrupt-shares"] = []
 295         nodeid = "\x00"*20
 296         data["sharemap"] = {"seq1-abcd-sh0": [nodeid]}
 297         data["servers-responding"] = [nodeid]
 298         data["count-recoverable-versions"] = 1
 299         data["count-unrecoverable-versions"] = 0
 300         if is_bad:
 301             r.set_healthy(False)
 302             r.set_recoverable(True)
 303             data["count-shares-good"] = 9
 304             r.problems = failure.Failure(CorruptShareError("peerid",
 305                                                            0, # shnum
 306                                                            is_bad))
 307         else:
 308             r.set_healthy(True)
 309             r.set_recoverable(True)
 310             data["count-shares-good"] = 10
 311             r.problems = []
 312         r.set_data(data)
 313         r.set_needs_rebalancing(False)
 314         return defer.succeed(r)
 315
 316     def check_and_repair(self, monitor, verify=False, add_lease=False):
 317         d = self.check(verify)
 318         def _got(cr):
 319             r = CheckAndRepairResults(self.storage_index)
 320             r.pre_repair_results = r.post_repair_results = cr
 321             return r
 322         d.addCallback(_got)
 323         return d
 324
 325     def deep_check(self, verify=False, add_lease=False):
 326         d = self.check(verify)
 327         def _done(r):
 328             dr = DeepCheckResults(self.storage_index)
 329             dr.add_check(r, [])
 330             return dr
 331         d.addCallback(_done)
 332         return d
 333
 334     def deep_check_and_repair(self, verify=False, add_lease=False):
 335         d = self.check_and_repair(verify)
 336         def _done(r):
 337             dr = DeepCheckAndRepairResults(self.storage_index)
 338             dr.add_check(r, [])
 339             return dr
 340         d.addCallback(_done)
 341         return d
 342
 343     def download_best_version(self):
 344         return defer.succeed(self._download_best_version())
 345
 346
 347     def _download_best_version(self, ignored=None):
 348         if isinstance(self.my_uri, uri.LiteralFileURI):
 349             return self.my_uri.data
 350         if self.storage_index not in self.all_contents:
 351             raise NotEnoughSharesError(None, 0, 3)
 352         return self.all_contents[self.storage_index]
 353
 354
 355     def overwrite(self, new_contents):
 356         assert not self.is_readonly()
 357         new_data = new_contents.read(new_contents.get_size())
 358         new_data = "".join(new_data)
 359         self.all_contents[self.storage_index] = new_data
 360         self.my_uri.set_extension_params([self._k, self._segsize])
 361         return defer.succeed(None)
 362     def modify(self, modifier):
 363         # this does not implement FileTooLargeError, but the real one does
 364         return defer.maybeDeferred(self._modify, modifier)
 365     def _modify(self, modifier):
 366         assert not self.is_readonly()
 367         old_contents = self.all_contents[self.storage_index]
 368         new_data = modifier(old_contents, None, True)
 369         self.all_contents[self.storage_index] = new_data
 370         self.my_uri.set_extension_params([self._k, self._segsize])
 371         return None
 372
 373     # As actually implemented, MutableFilenode and MutableFileVersion
 374     # are distinct. However, nothing in the webapi uses (yet) that
 375     # distinction -- it just uses the unified download interface
 376     # provided by get_best_readable_version and read. When we start
 377     # doing cooler things like LDMF, we will want to revise this code to
 378     # be less simplistic.
 379     def get_best_readable_version(self):
 380         return defer.succeed(self)
 381
 382
 383     def get_best_mutable_version(self):
 384         return defer.succeed(self)
 385
 386     # Ditto for this, which is an implementation of IWritable.
 387     # XXX: Declare that the same is implemented.
 388     def update(self, data, offset):
 389         assert not self.is_readonly()
 390         def modifier(old, servermap, first_time):
 391             new = old[:offset] + "".join(data.read(data.get_size()))
 392             new += old[len(new):]
 393             return new
 394         return self.modify(modifier)
 395
 396
 397     def read(self, consumer, offset=0, size=None):
 398         data = self._download_best_version()
 399         if size:
 400             data = data[offset:offset+size]
 401         consumer.write(data)
 402         return defer.succeed(consumer)
 403
 404
 405 def make_mutable_file_cap():
 406     return uri.WriteableSSKFileURI(writekey=os.urandom(16),
 407                                    fingerprint=os.urandom(32))
 408
 409 def make_mdmf_mutable_file_cap():
 410     return uri.WritableMDMFFileURI(writekey=os.urandom(16),
 411                                    fingerprint=os.urandom(32))
 412
 413 def make_mutable_file_uri(mdmf=False):
 414     if mdmf:
 415         uri = make_mdmf_mutable_file_cap()
 416     else:
 417         uri = make_mutable_file_cap()
 418
 419     return uri.to_string()
 420
 421 def make_verifier_uri():
 422     return uri.SSKVerifierURI(storage_index=os.urandom(16),
 423                               fingerprint=os.urandom(32)).to_string()
 424
 425 def create_mutable_filenode(contents, mdmf=False):
 426     # XXX: All of these arguments are kind of stupid.
 427     if mdmf:
 428         cap = make_mdmf_mutable_file_cap()
 429     else:
 430         cap = make_mutable_file_cap()
 431
 432     encoding_params = {}
 433     encoding_params['k'] = 3
 434     encoding_params['max_segment_size'] = 128*1024
 435
 436     filenode = FakeMutableFileNode(None, None, encoding_params, None)
 437     filenode.init_from_cap(cap)
 438     if mdmf:
 439         filenode.create(MutableData(contents), version=MDMF_VERSION)
 440     else:
 441         filenode.create(MutableData(contents), version=SDMF_VERSION)
 442     return filenode
 443
 444
 445 class FakeDirectoryNode(dirnode.DirectoryNode):
 446     """This offers IDirectoryNode, but uses a FakeMutableFileNode for the
 447     backing store, so it doesn't go to the grid. The child data is still
 448     encrypted and serialized, so this isn't useful for tests that want to
 449     look inside the dirnodes and check their contents.
 450     """
 451     filenode_class = FakeMutableFileNode
 452
 453 class LoggingServiceParent(service.MultiService):
 454     def log(self, *args, **kwargs):
 455         return log.msg(*args, **kwargs)
 456
 457 class SystemTestMixin(pollmixin.PollMixin, testutil.StallMixin):
 458
 459     # SystemTestMixin tests tend to be a lot of work, and we have a few
 460     # buildslaves that are pretty slow, and every once in a while these tests
 461     # run up against the default 120 second timeout. So increase the default
 462     # timeout. Individual test cases can override this, of course.
 463     timeout = 300
 464
 465     def setUp(self):
 466         self.sparent = service.MultiService()
 467         self.sparent.startService()
 468
 469         self.stats_gatherer = None
 470         self.stats_gatherer_furl = None
 471         self.key_generator_svc = None
 472         self.key_generator_furl = None
 473
 474     def tearDown(self):
 475         log.msg("shutting down SystemTest services")
 476         d = self.sparent.stopService()
 477         d.addBoth(flush_but_dont_ignore)
 478         return d
 479
 480     def getdir(self, subdir):
 481         return os.path.join(self.basedir, subdir)
 482
 483     def add_service(self, s):
 484         s.setServiceParent(self.sparent)
 485         return s
 486
 487     def set_up_nodes(self, NUMCLIENTS=5,
 488                      use_stats_gatherer=False, use_key_generator=False):
 489         self.numclients = NUMCLIENTS
 490         iv_dir = self.getdir("introducer")
 491         if not os.path.isdir(iv_dir):
 492             fileutil.make_dirs(iv_dir)
 493             fileutil.write(os.path.join(iv_dir, 'tahoe.cfg'), \
 494                                "[node]\n" + \
 495                                "web.port = tcp:0:interface=127.0.0.1\n")
 496             if SYSTEM_TEST_CERTS:
 497                 os.mkdir(os.path.join(iv_dir, "private"))
 498                 f = open(os.path.join(iv_dir, "private", "node.pem"), "w")
 499                 f.write(SYSTEM_TEST_CERTS[0])
 500                 f.close()
 501         iv = IntroducerNode(basedir=iv_dir)
 502         self.introducer = self.add_service(iv)
 503         d = self.introducer.when_tub_ready()
 504         d.addCallback(self._get_introducer_web)
 505         if use_stats_gatherer:
 506             d.addCallback(self._set_up_stats_gatherer)
 507         if use_key_generator:
 508             d.addCallback(self._set_up_key_generator)
 509         d.addCallback(self._set_up_nodes_2)
 510         if use_stats_gatherer:
 511             d.addCallback(self._grab_stats)
 512         return d
 513
 514     def _get_introducer_web(self, res):
 515         f = open(os.path.join(self.getdir("introducer"), "node.url"), "r")
 516         self.introweb_url = f.read().strip()
 517         f.close()
 518
 519     def _set_up_stats_gatherer(self, res):
 520         statsdir = self.getdir("stats_gatherer")
 521         fileutil.make_dirs(statsdir)
 522         self.stats_gatherer_svc = StatsGathererService(statsdir)
 523         self.stats_gatherer = self.stats_gatherer_svc.stats_gatherer
 524         self.add_service(self.stats_gatherer_svc)
 525
 526         d = fireEventually()
 527         sgf = os.path.join(statsdir, 'stats_gatherer.furl')
 528         def check_for_furl():
 529             return os.path.exists(sgf)
 530         d.addCallback(lambda junk: self.poll(check_for_furl, timeout=30))
 531         def get_furl(junk):
 532             self.stats_gatherer_furl = file(sgf, 'rb').read().strip()
 533         d.addCallback(get_furl)
 534         return d
 535
 536     def _set_up_key_generator(self, res):
 537         kgsdir = self.getdir("key_generator")
 538         fileutil.make_dirs(kgsdir)
 539
 540         self.key_generator_svc = KeyGeneratorService(kgsdir,
 541                                                      display_furl=False,
 542                                                      default_key_size=522)
 543         self.key_generator_svc.key_generator.pool_size = 4
 544         self.key_generator_svc.key_generator.pool_refresh_delay = 60
 545         self.add_service(self.key_generator_svc)
 546
 547         d = fireEventually()
 548         def check_for_furl():
 549             return os.path.exists(os.path.join(kgsdir, 'key_generator.furl'))
 550         d.addCallback(lambda junk: self.poll(check_for_furl, timeout=30))
 551         def get_furl(junk):
 552             kgf = os.path.join(kgsdir, 'key_generator.furl')
 553             self.key_generator_furl = file(kgf, 'rb').read().strip()
 554         d.addCallback(get_furl)
 555         return d
 556
 557     def _set_up_nodes_2(self, res):
 558         q = self.introducer
 559         self.introducer_furl = q.introducer_url
 560         self.clients = []
 561         basedirs = []
 562         for i in range(self.numclients):
 563             basedir = self.getdir("client%d" % i)
 564             basedirs.append(basedir)
 565             fileutil.make_dirs(os.path.join(basedir, "private"))
 566             if len(SYSTEM_TEST_CERTS) > (i+1):
 567                 f = open(os.path.join(basedir, "private", "node.pem"), "w")
 568                 f.write(SYSTEM_TEST_CERTS[i+1])
 569                 f.close()
 570
 571             config = "[client]\n"
 572             config += "introducer.furl = %s\n" % self.introducer_furl
 573             if self.stats_gatherer_furl:
 574                 config += "stats_gatherer.furl = %s\n" % self.stats_gatherer_furl
 575
 576             if i == 0:
 577                 # clients[0] runs a webserver and a helper, no key_generator
 578                 config += "[node]\n"
 579                 config += "web.port = tcp:0:interface=127.0.0.1\n"
 580                 config += "timeout.keepalive = 600\n"
 581                 config += "[helper]\n"
 582                 config += "enabled = True\n"
 583             if i == 3:
 584                 # clients[3] runs a webserver and uses a helper, uses
 585                 # key_generator
 586                 if self.key_generator_furl:
 587                     config += "key_generator.furl = %s\n" % self.key_generator_furl
 588                 config += "[node]\n"
 589                 config += "web.port = tcp:0:interface=127.0.0.1\n"
 590                 config += "timeout.disconnect = 1800\n"
 591
 592             fileutil.write(os.path.join(basedir, 'tahoe.cfg'), config)
 593
 594         # give subclasses a chance to append lines to the node's tahoe.cfg
 595         # files before they are launched.
 596         self._set_up_nodes_extra_config()
 597
 598         # start clients[0], wait for it's tub to be ready (at which point it
 599         # will have registered the helper furl).
 600         c = self.add_service(client.Client(basedir=basedirs[0]))
 601         self.clients.append(c)
 602         c.set_default_mutable_keysize(522)
 603         d = c.when_tub_ready()
 604         def _ready(res):
 605             f = open(os.path.join(basedirs[0],"private","helper.furl"), "r")
 606             helper_furl = f.read()
 607             f.close()
 608             self.helper_furl = helper_furl
 609             if self.numclients >= 4:
 610                 f = open(os.path.join(basedirs[3], 'tahoe.cfg'), 'ab+')
 611                 f.write(
 612                       "[client]\n"
 613                       "helper.furl = %s\n" % helper_furl)
 614                 f.close()
 615
 616             # this starts the rest of the clients
 617             for i in range(1, self.numclients):
 618                 c = self.add_service(client.Client(basedir=basedirs[i]))
 619                 self.clients.append(c)
 620                 c.set_default_mutable_keysize(522)
 621             log.msg("STARTING")
 622             return self.wait_for_connections()
 623         d.addCallback(_ready)
 624         def _connected(res):
 625             log.msg("CONNECTED")
 626             # now find out where the web port was
 627             self.webish_url = self.clients[0].getServiceNamed("webish").getURL()
 628             if self.numclients >=4:
 629                 # and the helper-using webport
 630                 self.helper_webish_url = self.clients[3].getServiceNamed("webish").getURL()
 631         d.addCallback(_connected)
 632         return d
 633
 634     def _set_up_nodes_extra_config(self):
 635         # for overriding by subclasses
 636         pass
 637
 638     def _grab_stats(self, res):
 639         d = self.stats_gatherer.poll()
 640         return d
 641
 642     def bounce_client(self, num):
 643         c = self.clients[num]
 644         d = c.disownServiceParent()
 645         # I think windows requires a moment to let the connection really stop
 646         # and the port number made available for re-use. TODO: examine the
 647         # behavior, see if this is really the problem, see if we can do
 648         # better than blindly waiting for a second.
 649         d.addCallback(self.stall, 1.0)
 650         def _stopped(res):
 651             new_c = client.Client(basedir=self.getdir("client%d" % num))
 652             self.clients[num] = new_c
 653             new_c.set_default_mutable_keysize(522)
 654             self.add_service(new_c)
 655             return new_c.when_tub_ready()
 656         d.addCallback(_stopped)
 657         d.addCallback(lambda res: self.wait_for_connections())
 658         def _maybe_get_webport(res):
 659             if num == 0:
 660                 # now find out where the web port was
 661                 self.webish_url = self.clients[0].getServiceNamed("webish").getURL()
 662         d.addCallback(_maybe_get_webport)
 663         return d
 664
 665     def add_extra_node(self, client_num, helper_furl=None,
 666                        add_to_sparent=False):
 667         # usually this node is *not* parented to our self.sparent, so we can
 668         # shut it down separately from the rest, to exercise the
 669         # connection-lost code
 670         basedir = self.getdir("client%d" % client_num)
 671         if not os.path.isdir(basedir):
 672             fileutil.make_dirs(basedir)
 673         config = "[client]\n"
 674         config += "introducer.furl = %s\n" % self.introducer_furl
 675         if helper_furl:
 676             config += "helper.furl = %s\n" % helper_furl
 677         fileutil.write(os.path.join(basedir, 'tahoe.cfg'), config)
 678
 679         c = client.Client(basedir=basedir)
 680         self.clients.append(c)
 681         c.set_default_mutable_keysize(522)
 682         self.numclients += 1
 683         if add_to_sparent:
 684             c.setServiceParent(self.sparent)
 685         else:
 686             c.startService()
 687         d = self.wait_for_connections()
 688         d.addCallback(lambda res: c)
 689         return d
 690
 691     def _check_connections(self):
 692         for c in self.clients:
 693             if not c.connected_to_introducer():
 694                 return False
 695             sb = c.get_storage_broker()
 696             if len(sb.get_connected_servers()) != self.numclients:
 697                 return False
 698         return True
 699
 700     def wait_for_connections(self, ignored=None):
 701         # TODO: replace this with something that takes a list of peerids and
 702         # fires when they've all been heard from, instead of using a count
 703         # and a threshold
 704         return self.poll(self._check_connections, timeout=200)
 705
 706
 707 # our system test uses the same Tub certificates each time, to avoid the
 708 # overhead of key generation
 709 SYSTEM_TEST_CERTS = [
 710 """-----BEGIN CERTIFICATE-----
 711 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 712 aW5neTAeFw0wODA3MjUyMjQyMDVaFw0wOTA3MjUyMjQyMDVaMBcxFTATBgNVBAMU
 713 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAxHCWajrR
 714 2h/iurw8k93m8WUdE3xypJiiAITw7GkKlKbCLD+dEce2MXwVVYca0n/MZZsj89Cu
 715 Ko0lLjksMseoSDoj98iEmVpaY5mc2ntpQ+FXdoEmPP234XRWEg2HQ+EaK6+WkGQg
 716 DDXQvFJCVCQk/n1MdAwZZ6vqf2ITzSuD44kCAwEAATANBgkqhkiG9w0BAQQFAAOB
 717 gQBn6qPKGdFjWJy7sOOTUFfm/THhHQqAh1pBDLkjR+OtzuobCoP8n8J1LNG3Yxds
 718 Jj7NWQL7X5TfOlfoi7e9jK0ujGgWh3yYU6PnHzJLkDiDT3LCSywQuGXCjh0tOStS
 719 2gaCmmAK2cfxSStKzNcewl2Zs8wHMygq8TLFoZ6ozN1+xQ==
 720 -----END CERTIFICATE-----
 721 -----BEGIN RSA PRIVATE KEY-----
 722 MIICXQIBAAKBgQDEcJZqOtHaH+K6vDyT3ebxZR0TfHKkmKIAhPDsaQqUpsIsP50R
 723 x7YxfBVVhxrSf8xlmyPz0K4qjSUuOSwyx6hIOiP3yISZWlpjmZzae2lD4Vd2gSY8
 724 /bfhdFYSDYdD4Rorr5aQZCAMNdC8UkJUJCT+fUx0DBlnq+p/YhPNK4PjiQIDAQAB
 725 AoGAZyDMdrymiyMOPwavrtlicvyohSBid3MCKc+hRBvpSB0790r2RO1aAySndp1V
 726 QYmCXx1RhKDbrs8m49t0Dryu5T+sQrFl0E3usAP3vvXWeh4jwJ9GyiRWy4xOEuEQ
 727 3ewjbEItHqA/bRJF0TNtbOmZTDC7v9FRPf2bTAyFfTZep5kCQQD33q1RA8WUYtmQ
 728 IArgHqt69i421lpXlOgqotFHwTx4FiGgVzDQCDuXU6txB9EeKRM340poissav/n6
 729 bkLZ7/VDAkEAyuIPkeI59sE5NnmW+N47NbCfdM1Smy1YxZpv942EmP9Veub5N0dw
 730 iK5bLAgEguUIjpTsh3BRmsE9Xd+ItmnRQwJBAMZhbg19G1EbnE0BmDKv2UbcaThy
 731 bnPSNc6J6T2opqDl9ZvCrMqTDD6dNIWOYAvni/4a556sFsoeBBAu10peBskCQE6S
 732 cB86cuJagLLVMh/dySaI6ahNoFFSpY+ZuQUxfInYUR2Q+DFtbGqyw8JwtHaRBthZ
 733 WqU1XZVGg2KooISsxIsCQQD1PS7//xHLumBb0jnpL7n6W8gmiTyzblT+0otaCisP
 734 fN6rTlwV1o8VsOUAz0rmKO5RArCbkmb01WtMgPCDBYkk
 735 -----END RSA PRIVATE KEY-----
 736 """, # 0
 737 """-----BEGIN CERTIFICATE-----
 738 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 739 aW5neTAeFw0wODA3MjUyMjQyMDVaFw0wOTA3MjUyMjQyMDVaMBcxFTATBgNVBAMU
 740 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAs9CALdmW
 741 kJ6r0KPSLdGCA8rzQKxWayrMckT22ZtbRv3aw6VA96dWclpY+T2maV0LrAzmMSL8
 742 n61ydJHM33iYDOyWbwHWN45XCjY/e20PL54XUl/DmbBHEhQVQLIfCldcRcnWEfoO
 743 iOhDJfWpDO1dmP/aOYLdkZCZvBtPAfyUqRcCAwEAATANBgkqhkiG9w0BAQQFAAOB
 744 gQAN9eaCREkzzk4yPIaWYkWHg3Igs1vnOR/iDw3OjyxO/xJFP2lkA2WtrwL2RTRq
 745 dxA8gwdPyrWgdiZElwZH8mzTJ4OdUXLSMclLOg9kvH6gtSvhLztfEDwDP1wRhikh
 746 OeWWu2GIC+uqFCI1ftoGgU+aIa6yrHswf66rrQvBSSvJPQ==
 747 -----END CERTIFICATE-----
 748 -----BEGIN RSA PRIVATE KEY-----
 749 MIICXQIBAAKBgQCz0IAt2ZaQnqvQo9It0YIDyvNArFZrKsxyRPbZm1tG/drDpUD3
 750 p1ZyWlj5PaZpXQusDOYxIvyfrXJ0kczfeJgM7JZvAdY3jlcKNj97bQ8vnhdSX8OZ
 751 sEcSFBVAsh8KV1xFydYR+g6I6EMl9akM7V2Y/9o5gt2RkJm8G08B/JSpFwIDAQAB
 752 AoGBAIUy5zCPpSP+FeJY6CG+t6Pdm/IFd4KtUoM3KPCrT6M3+uzApm6Ny9Crsor2
 753 qyYTocjSSVaOxzn1fvpw4qWLrH1veUf8ozMs8Z0VuPHD1GYUGjOXaBPXb5o1fQL9
 754 h7pS5/HrDDPN6wwDNTsxRf/fP58CnfwQUhwdoxcx8TnVmDQxAkEA6N3jBXt/Lh0z
 755 UbXHhv3QBOcqLZA2I4tY7wQzvUvKvVmCJoW1tfhBdYQWeQv0jzjL5PzrrNY8hC4l
 756 8+sFM3h5TwJBAMWtbFIEZfRSG1JhHK3evYHDTZnr/j+CdoWuhzP5RkjkIKsiLEH7
 757 2ZhA7CdFQLZF14oXy+g1uVCzzfB2WELtUbkCQQDKrb1XWzrBlzbAipfkXWs9qTmj
 758 uJ32Z+V6+0xRGPOXxJ0sDDqw7CeFMfchWg98zLFiV+SEZV78qPHtkAPR3ayvAkB+
 759 hUMhM4N13t9x2IoclsXAOhp++9bdG0l0woHyuAdOPATUw6iECwf4NQVxFRgYEZek
 760 4Ro3Y7taddrHn1dabr6xAkAic47OoLOROYLpljmJJO0eRe3Z5IFe+0D2LfhAW3LQ
 761 JU+oGq5pCjfnoaDElRRZn0+GmunnWeQEYKoflTi/lI9d
 762 -----END RSA PRIVATE KEY-----
 763 """, # 1
 764 """-----BEGIN CERTIFICATE-----
 765 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 766 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 767 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAsxG7LTrz
 768 DF+9wegOR/BRJhjSumPUbYQnNAUKtPraFsGjAJILP44AHdnHt1MONLgTeX1ynapo
 769 q6O/q5cdKtBB7uEh7FpkLCCwpZt/m0y79cynn8AmWoQVgl8oS0567UmPeJnTzFPv
 770 dmT5dlaQALeX5YGceAsEvhmAsdOMttaor38CAwEAATANBgkqhkiG9w0BAQQFAAOB
 771 gQA345rxotfvh2kfgrmRzAyGewVBV4r23Go30GSZir8X2GoH3qKNwO4SekAohuSw
 772 AiXzLUbwIdSRSqaLFxSC7Duqc9eIeFDAWjeEmpfFLBNiw3K8SLA00QrHCUXnECTD
 773 b/Kk6OGuvPOiuuONVjEuEcRdCH3/Li30D0AhJaMynjhQJQ==
 774 -----END CERTIFICATE-----
 775 -----BEGIN RSA PRIVATE KEY-----
 776 MIICXQIBAAKBgQCzEbstOvMMX73B6A5H8FEmGNK6Y9RthCc0BQq0+toWwaMAkgs/
 777 jgAd2ce3Uw40uBN5fXKdqmiro7+rlx0q0EHu4SHsWmQsILClm3+bTLv1zKefwCZa
 778 hBWCXyhLTnrtSY94mdPMU+92ZPl2VpAAt5flgZx4CwS+GYCx04y21qivfwIDAQAB
 779 AoGBAIlhFg/aRPL+VM9539LzHN60dp8GzceDdqwjHhbAySZiQlLCuJx2rcI4/U65
 780 CpIJku9G/fLV9N2RkA/trDPXeGyqCTJfnNzyZcvvMscRMFqSGyc21Y0a+GS8bIxt
 781 1R2B18epSVMsWSWWMypeEgsfv29LV7oSWG8UKaqQ9+0h63DhAkEA4i2L/rori/Fb
 782 wpIBfA+xbXL/GmWR7xPW+3nG3LdLQpVzxz4rIsmtO9hIXzvYpcufQbwgVACyMmRf
 783 TMABeSDM7wJBAMquEdTaVXjGfH0EJ7z95Ys2rYTiCXjBfyEOi6RXXReqV9SXNKlN
 784 aKsO22zYecpkAjY1EdUdXWP/mNVEybjpZnECQQCcuh0JPS5RwcTo9c2rjyBOjGIz
 785 g3B1b5UIG2FurmCrWe6pgO3ZJFEzZ/L2cvz0Hj5UCa2JKBZTDvRutZoPumfnAkAb
 786 nSW+y1Rz1Q8m9Ub4v9rjYbq4bRd/RVWtyk6KQIDldYbr5wH8wxgsniSVKtVFFuUa
 787 P5bDY3HS6wMGo42cTOhxAkAcdweQSQ3j7mfc5vh71HeAC1v/VAKGehGOUdeEIQNl
 788 Sb2WuzpZkbfsrVzW6MdlgY6eE7ufRswhDPLWPC8MP0d1
 789 -----END RSA PRIVATE KEY-----
 790 """, # 2
 791 """-----BEGIN CERTIFICATE-----
 792 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 793 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 794 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAxnH+pbOS
 795 qlJlsHpKUQtV0oN1Mv+ESG+yUDxStFFGjkJv/UIRzpxqFqY/6nJ3D03kZsDdcXyi
 796 CfV9hPYQaVNMn6z+puPmIagfBQ0aOyuI+nUhCttZIYD9071BjW5bCMX5NZWL/CZm
 797 E0HdAZ77H6UrRckJ7VR8wAFpihBxD5WliZcCAwEAATANBgkqhkiG9w0BAQQFAAOB
 798 gQAwXqY1Sjvp9JSTHKklu7s0T6YmH/BKSXrHpS2xO69svK+ze5/+5td3jPn4Qe50
 799 xwRNZSFmSLuJLfCO32QJSJTB7Vs5D3dNTZ2i8umsaodm97t8hit7L75nXRGHKH//
 800 xDVWAFB9sSgCQyPMRkL4wB4YSfRhoSKVwMvaz+XRZDUU0A==
 801 -----END CERTIFICATE-----
 802 -----BEGIN RSA PRIVATE KEY-----
 803 MIICXAIBAAKBgQDGcf6ls5KqUmWwekpRC1XSg3Uy/4RIb7JQPFK0UUaOQm/9QhHO
 804 nGoWpj/qcncPTeRmwN1xfKIJ9X2E9hBpU0yfrP6m4+YhqB8FDRo7K4j6dSEK21kh
 805 gP3TvUGNblsIxfk1lYv8JmYTQd0BnvsfpStFyQntVHzAAWmKEHEPlaWJlwIDAQAB
 806 AoGAdHNMlXwtItm7ZrY8ihZ2xFP0IHsk60TwhHkBp2LSXoTKJvnwbSgIcUYZ18BX
 807 8Zkp4MpoqEIU7HcssyuaMdR572huV2w0D/2gYJQLQ5JapaR3hMox3YG4wjXasN1U
 808 1iZt7JkhKlOy+ElL5T9mKTE1jDsX2RAv4WALzMpYFo7vs4ECQQDxqrPaqRQ5uYS/
 809 ejmIk05nM3Q1zmoLtMDrfRqrjBhaf/W3hqGihiqN2kL3PIIYcxSRWiyNlYXjElsR
 810 2sllBTe3AkEA0jcMHVThwKt1+Ce5VcE7N6hFfbsgISTjfJ+Q3K2NkvJkmtE8ZRX5
 811 XprssnPN8owkfF5yuKbcSZL3uvaaSGN9IQJAfTVnN9wwOXQwHhDSbDt9/KRBCnum
 812 n+gHqDrKLaVJHOJ9SZf8eLswoww5c+UqtkYxmtlwie61Tp+9BXQosilQ4wJBAIZ1
 813 XVNZmriBM4jR59L5MOZtxF0ilu98R+HLsn3kqLyIPF9mXCoQPxwLHkEan213xFKk
 814 mt6PJDIPRlOZLqAEuuECQFQMCrn0VUwPg8E40pxMwgMETvVflPs/oZK1Iu+b7+WY
 815 vBptAyhMu31fHQFnJpiUOyHqSZnOZyEn1Qu2lszNvUg=
 816 -----END RSA PRIVATE KEY-----
 817 """, # 3
 818 """-----BEGIN CERTIFICATE-----
 819 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 820 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 821 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAnjiOwipn
 822 jigDuNMfNG/tBJhPwYUHhSbQdvrTubhsxw1oOq5XpNqUwRtC8hktOKM3hghyqExP
 823 62EOi0aJBkRhtwtPSLBCINptArZLfkog/nTIqVv4eLEzJ19nTi/llHHWKcgA6XTI
 824 sU/snUhGlySA3RpETvXqIJTauQRZz0kToSUCAwEAATANBgkqhkiG9w0BAQQFAAOB
 825 gQCQ+u/CsX5WC5m0cLrpyIS6qZa62lrB3mj9H1aIQhisT5kRsMz3FJ1aOaS8zPRz
 826 w0jhyRmamCcSsWf5WK539iOtsXbKMdAyjNtkQO3g+fnsLgmznAjjst24jfr+XU59
 827 0amiy1U6TY93gtEBZHtiLldPdUMsTuFbBlqbcMBQ50x9rA==
 828 -----END CERTIFICATE-----
 829 -----BEGIN RSA PRIVATE KEY-----
 830 MIICXAIBAAKBgQCeOI7CKmeOKAO40x80b+0EmE/BhQeFJtB2+tO5uGzHDWg6rlek
 831 2pTBG0LyGS04ozeGCHKoTE/rYQ6LRokGRGG3C09IsEIg2m0Ctkt+SiD+dMipW/h4
 832 sTMnX2dOL+WUcdYpyADpdMixT+ydSEaXJIDdGkRO9eoglNq5BFnPSROhJQIDAQAB
 833 AoGAAPrst3s3xQOucjismtCOsVaYN+SxFTwWUoZfRWlFEz6cBLELzfOktEWM9p79
 834 TrqEH4px22UNobGqO2amdql5yXwEFVhYQkRB8uDA8uVaqpL8NLWTGPRXxZ2DSU+n
 835 7/FLf/TWT3ti/ZtXaPVRj6E2/Mq9AVEVOjUYzkNjM02OxcECQQDKEqmPbdZq2URU
 836 7RbUxkq5aTp8nzAgbpUsgBGQ9PDAymhj60BDEP0q28Ssa7tU70pRnQ3AZs9txgmL
 837 kK2g97FNAkEAyHH9cIb6qXOAJPIr/xamFGr5uuYw9TJPz/hfVkVimW/aZnBB+e6Q
 838 oALJBDKJWeYPzdNbouJYg8MeU0qWdZ5DOQJADUk+1sxc/bd9U6wnBSRog1pU2x7I
 839 VkmPC1b8ULCaJ8LnLDKqjf5O9wNuIfwPXB1DoKwX3F+mIcyUkhWYJO5EPQJAUj5D
 840 KMqZSrGzYHVlC/M1Daee88rDR7fu+3wDUhiCDkbQq7tftrbl7GF4LRq3NIWq8l7I
 841 eJq6isWiSbaO6Y+YMQJBAJFBpVhlY5Px2BX5+Hsfq6dSP3sVVc0eHkdsoZFFxq37
 842 fksL/q2vlPczvBihgcxt+UzW/UrNkelOuX3i57PDvFs=
 843 -----END RSA PRIVATE KEY-----
 844 """, # 4
 845 """-----BEGIN CERTIFICATE-----
 846 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 847 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 848 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAsCQuudDF
 849 zgmY5tDpT0TkUo8fpJ5JcvgCkLFpSDD8REpXhLFkHWhTmTj3CAxfv4lA3sQzHZxe
 850 4S9YCb5c/VTbFEdgwc/wlxMmJiz2jYghdmWPBb8pBEk31YihIhC+u4kex6gJBH5y
 851 ixiZ3PPRRMaOBBo+ZfM50XIyWbFOOM/7FwcCAwEAATANBgkqhkiG9w0BAQQFAAOB
 852 gQB4cFURaiiUx6n8eS4j4Vxrii5PtsaNEI4acANFSYknGd0xTP4vnmoivNmo5fWE
 853 Q4hYtGezNu4a9MnNhcQmI20KzXmvhLJtkwWCgGOVJtMem8hDWXSALV1Ih8hmVkGS
 854 CI1elfr9eyguunGp9eMMQfKhWH52WHFA0NYa0Kpv5BY33A==
 855 -----END CERTIFICATE-----
 856 -----BEGIN RSA PRIVATE KEY-----
 857 MIICWwIBAAKBgQCwJC650MXOCZjm0OlPRORSjx+knkly+AKQsWlIMPxESleEsWQd
 858 aFOZOPcIDF+/iUDexDMdnF7hL1gJvlz9VNsUR2DBz/CXEyYmLPaNiCF2ZY8FvykE
 859 STfViKEiEL67iR7HqAkEfnKLGJnc89FExo4EGj5l8znRcjJZsU44z/sXBwIDAQAB
 860 AoGABA7xXKqoxBSIh1js5zypHhXaHsre2l1Igdj0mgs25MPpvE7yBZNvyan8Vx0h
 861 36Hj8r4Gh3og3YNfvem67sNTwNwONY0ep+Xho/3vG0jFATGduSXdcT04DusgZNqg
 862 UJqW75cqxrD6o/nya5wUoN9NL5pcd5AgVMdOYvJGbrwQuaECQQDiCs/5dsUkUkeC
 863 Tlur1wh0wJpW4Y2ctO3ncRdnAoAA9y8dELHXMqwKE4HtlyzHY7Bxds/BDh373EVK
 864 rsdl+v9JAkEAx3xTmsOQvWa1tf/O30sdItVpGogKDvYqkLCNthUzPaL85BWB03E2
 865 xunHcVVlqAOE5tFuw0/UEyEkOaGlNTJTzwJAPIVel9FoCUiKYuYt/z1swy3KZRaw
 866 /tMmm4AZHvh5Y0jLcYHFy/OCQpRkhkOitqQHWunPyEXKW2PnnY5cTv68GQJAHG7H
 867 B88KCUTjb25nkQIGxBlA4swzCtDhXkAb4rEA3a8mdmfuWjHPyeg2ShwO4jSmM7P0
 868 Iph1NMjLff9hKcTjlwJARpItOFkYEdtSODC7FMm7KRKQnNB27gFAizsOYWD4D2b7
 869 w1FTEZ/kSA9wSNhyNGt7dgUo6zFhm2u973HBCUb3dg==
 870 -----END RSA PRIVATE KEY-----
 871 """, # 5
 872 """-----BEGIN CERTIFICATE-----
 873 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 874 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 875 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAvhTRj1dA
 876 NOfse/UBeTfMekZKxZHsNPr+qBYaveWAHDded/BMyMgaMV2n6HQdiDaRjJkzjHCF
 877 3xBtpIJeEGUqfrF0ob8BIZXy3qk68eX/0CVUbgmjSBN44ahlo63NshyXmZtEAkRV
 878 VE/+cRKw3N2wtuTed5xwfNcL6dg4KTOEYEkCAwEAATANBgkqhkiG9w0BAQQFAAOB
 879 gQCN+CLuVwLeWjSdVbdizYyrOVckqtwiIHG9BbGMlcIdm0qpvD7V7/sN2csk5LaT
 880 BNiHi1t5628/4UHqqodYmFw8ri8ItFwB+MmTJi11CX6dIP9OUhS0qO8Z/BKtot7H
 881 j04oNwl+WqZZfHIYwTIEL0HBn60nOvCQPDtnWG2BhpUxMA==
 882 -----END CERTIFICATE-----
 883 -----BEGIN RSA PRIVATE KEY-----
 884 MIICXQIBAAKBgQC+FNGPV0A05+x79QF5N8x6RkrFkew0+v6oFhq95YAcN1538EzI
 885 yBoxXafodB2INpGMmTOMcIXfEG2kgl4QZSp+sXShvwEhlfLeqTrx5f/QJVRuCaNI
 886 E3jhqGWjrc2yHJeZm0QCRFVUT/5xErDc3bC25N53nHB81wvp2DgpM4RgSQIDAQAB
 887 AoGALl2BqIdN4Bnac3oV++2CcSkIQB0SEvJOf820hDGhCEDxSCxTbn5w9S21MVxx
 888 f7Jf2n3cNxuTbA/jzscGDtW+gXCs+WAbAr5aOqHLUPGEobhKQrQT2hrxQHyv3UFp
 889 0tIl9eXFknOyVAaUJ3athK5tyjSiCZQQHLGzeLaDSKVAPqECQQD1GK7DkTcLaSvw
 890 hoTJ3dBK3JoKT2HHLitfEE0QV58mkqFMjofpe+nyeKWvEb/oB4WBp/cfTvtf7DJK
 891 zl1OSf11AkEAxomWmJeub0xpqksCmnVI1Jt1mvmcE4xpIcXq8sxzLHRc2QOv0kTw
 892 IcFl4QcN6EQBmE+8kl7Tx8SPAVKfJMoZBQJAGsUFYYrczjxAdlba7glyFJsfn/yn
 893 m0+poQpwwFYxpc7iGzB+G7xTAw62WfbAVSFtLYog7aR8xC9SFuWPP1vJeQJBAILo
 894 xBj3ovgWTXIRJbVM8mnl28UFI0msgsHXK9VOw/6i93nMuYkPFbtcN14KdbwZ42dX
 895 5EIrLr+BNr4riW4LqDUCQQCbsEEpTmj3upKUOONPt+6CH/OOMjazUzYHZ/3ORHGp
 896 Q3Wt+I4IrR/OsiACSIQAhS4kBfk/LGggnj56DrWt+oBl
 897 -----END RSA PRIVATE KEY-----
 898 """, #6
 899 """-----BEGIN CERTIFICATE-----
 900 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 901 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 902 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAtKhx6sEA
 903 jn6HWc6T2klwlPn0quyHtATIw8V3ezP46v6g2rRS7dTywo4GTP4vX58l+sC9z9Je
 904 qhQ1rWSwMK4FmnDMZCu7AVO7oMIXpXdSz7l0bgCnNjvbpkA2pOfbB1Z8oj8iebff
 905 J33ID5DdkmCzqYVtKpII1o/5z7Jo292JYy8CAwEAATANBgkqhkiG9w0BAQQFAAOB
 906 gQA0PYMA07wo9kEH4fv9TCfo+zz42Px6lUxrQBPxBvDiGYhk2kME/wX0IcoZPKTV
 907 WyBGmDAYWvFaHWbrbbTOfzlLWfYrDD913hCi9cO8iF8oBqRjIlkKcxAoe7vVg5Az
 908 ydVcrY+zqULJovWwyNmH1QNIQfMat0rj7fylwjiS1y/YsA==
 909 -----END CERTIFICATE-----
 910 -----BEGIN RSA PRIVATE KEY-----
 911 MIICXAIBAAKBgQC0qHHqwQCOfodZzpPaSXCU+fSq7Ie0BMjDxXd7M/jq/qDatFLt
 912 1PLCjgZM/i9fnyX6wL3P0l6qFDWtZLAwrgWacMxkK7sBU7ugwheld1LPuXRuAKc2
 913 O9umQDak59sHVnyiPyJ5t98nfcgPkN2SYLOphW0qkgjWj/nPsmjb3YljLwIDAQAB
 914 AoGAU4CYRv22mCZ7wVLunDLdyr5ODMMPZnHfqj2XoGbBYz0WdIBs5GlNXAfxeZzz
 915 oKsbDvAPzANcphh5RxAHMDj/dT8rZOez+eJrs1GEV+crl1T9p83iUkAuOJFtgUgf
 916 TtQBL9vHaj7DfvCEXcBPmN/teDFmAAOyUNbtuhTkRa3PbuECQQDwaqZ45Kr0natH
 917 V312dqlf9ms8I6e873pAu+RvA3BAWczk65eGcRjEBxVpTvNEcYKFrV8O5ZYtolrr
 918 VJl97AfdAkEAwF4w4KJ32fLPVoPnrYlgLw86NejMpAkixblm8cn51avPQmwbtahb
 919 BZUuca22IpgDpjeEk5SpEMixKe/UjzxMewJBALy4q2cY8U3F+u6sshLtAPYQZIs3
 920 3fNE9W2dUKsIQvRwyZMlkLN7UhqHCPq6e+HNTM0MlCMIfAPkf4Rdy4N6ZY0CQCKE
 921 BAMaQ6TwgzFDw5sIjiCDe+9WUPmRxhJyHL1/fvtOs4Z4fVRP290ZklbFU2vLmMQH
 922 LBuKzfb7+4XJyXrV1+cCQBqfPFQQZLr5UgccABYQ2jnWVbJPISJ5h2b0cwXt+pz/
 923 8ODEYLjqWr9K8dtbgwdpzwbkaGhQYpyvsguMvNPMohs=
 924 -----END RSA PRIVATE KEY-----
 925 """, #7
 926 """-----BEGIN CERTIFICATE-----
 927 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 928 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 929 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAnBfNHycn
 930 5RnYzDN4EWTk2q1BBxA6ZYtlG1WPkj5iKeaYKzUk58zBL7mNOA0ucq+yTwh9C4IC
 931 EutWPaKBSKY5XI+Rdebh+Efq+urtOLgfJHlfcCraEx7hYN+tqqMVgEgnO/MqIsn1
 932 I1Fvnp89mSYbQ9tmvhSH4Hm+nbeK6iL2tIsCAwEAATANBgkqhkiG9w0BAQQFAAOB
 933 gQBt9zxfsKWoyyV764rRb6XThuTDMNSDaVofqePEWjudAbDu6tp0pHcrL0XpIrnT
 934 3iPgD47pdlwQNbGJ7xXwZu2QTOq+Lv62E6PCL8FljDVoYqR3WwJFFUigNvBT2Zzu
 935 Pxx7KUfOlm/M4XUSMu31sNJ0kQniBwpkW43YmHVNFb/R7g==
 936 -----END CERTIFICATE-----
 937 -----BEGIN RSA PRIVATE KEY-----
 938 MIICXQIBAAKBgQCcF80fJyflGdjMM3gRZOTarUEHEDpli2UbVY+SPmIp5pgrNSTn
 939 zMEvuY04DS5yr7JPCH0LggIS61Y9ooFIpjlcj5F15uH4R+r66u04uB8keV9wKtoT
 940 HuFg362qoxWASCc78yoiyfUjUW+enz2ZJhtD22a+FIfgeb6dt4rqIva0iwIDAQAB
 941 AoGBAIHstcnWd7iUeQYPWUNxLaRvTY8pjNH04yWLZEOgNWkXDVX5mExw++RTmB4t
 942 qpm/cLWkJSEtB7jjthb7ao0j/t2ljqfr6kAbClDv3zByAEDhOu8xB/5ne6Ioo+k2
 943 dygC+GcVcobhv8qRU+z0fpeXSP8yS1bQQHOaa17bSGsncvHRAkEAzwsn8jBTOqaW
 944 6Iymvr7Aql++LiwEBrqMMRVyBZlkux4hiKa2P7XXEL6/mOPR0aI2LuCqE2COrO7R
 945 0wAFZ54bjwJBAMEAe6cs0zI3p3STHwA3LoSZB81lzLhGUnYBvOq1yoDSlJCOYpld
 946 YM1y3eC0vwiOnEu3GG1bhkW+h6Kx0I/qyUUCQBiH9NqwORxI4rZ4+8S76y4EnA7y
 947 biOx9KxYIyNgslutTUHYpt1TmUDFqQPfclvJQWw6eExFc4Iv5bJ/XSSSyicCQGyY
 948 5PrwEfYTsrm5fpwUcKxTnzxHp6WYjBWybKZ0m/lYhBfCxmAdVrbDh21Exqj99Zv0
 949 7l26PhdIWfGFtCEGrzECQQCtPyXa3ostSceR7zEKxyn9QBCNXKARfNNTBja6+VRE
 950 qDC6jLqzu/SoOYaqa13QzCsttO2iZk8Ygfy3Yz0n37GE
 951 -----END RSA PRIVATE KEY-----
 952 """, #8
 953 """-----BEGIN CERTIFICATE-----
 954 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 955 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 956 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA4mnLf+x0
 957 CWKDKP5PLZ87t2ReSDE/J5QoI5VhE0bXaahdhPrQTC2wvOpT+N9nzEpI9ASh/ejV
 958 kYGlc03nNKRL7zyVM1UyGduEwsRssFMqfyJhI1p+VmxDMWNplex7mIAheAdskPj3
 959 pwi2CP4VIMjOj368AXvXItPzeCfAhYhEVaMCAwEAATANBgkqhkiG9w0BAQQFAAOB
 960 gQAEzmwq5JFI5Z0dX20m9rq7NKgwRyAH3h5aE8bdjO8nEc69qscfDRx79Lws3kK8
 961 A0LG0DhxKB8cTNu3u+jy81tjcC4pLNQ5IKap9ksmP7RtIHfTA55G8M3fPl2ZgDYQ
 962 ZzsWAZvTNXd/eme0SgOzD10rfntA6ZIgJTWHx3E0RkdwKw==
 963 -----END CERTIFICATE-----
 964 -----BEGIN RSA PRIVATE KEY-----
 965 MIICXQIBAAKBgQDiact/7HQJYoMo/k8tnzu3ZF5IMT8nlCgjlWETRtdpqF2E+tBM
 966 LbC86lP432fMSkj0BKH96NWRgaVzTec0pEvvPJUzVTIZ24TCxGywUyp/ImEjWn5W
 967 bEMxY2mV7HuYgCF4B2yQ+PenCLYI/hUgyM6PfrwBe9ci0/N4J8CFiERVowIDAQAB
 968 AoGAQYTl+8XcKl8Un4dAOG6M5FwqIHAH25c3Klzu85obehrbvUCriG/sZi7VT/6u
 969 VeLlS6APlJ+NNgczbrOLhaNJyYzjICSt8BI96PldFUzCEkVlgE+29pO7RNoZmDYB
 970 dSGyIDrWdVYfdzpir6kC0KDcrpA16Sc+/bK6Q8ALLRpC7QECQQD7F7fhIQ03CKSk
 971 lS4mgDuBQrB/52jXgBumtjp71ANNeaWR6+06KDPTLysM+olsh97Q7YOGORbrBnBg
 972 Y2HPnOgjAkEA5taZaMfdFa8V1SPcX7mgCLykYIujqss0AmauZN/24oLdNE8HtTBF
 973 OLaxE6PnQ0JWfx9KGIy3E0V3aFk5FWb0gQJBAO4KFEaXgOG1jfCBhNj3JHJseMso
 974 5Nm4F366r0MJQYBHXNGzqphB2K/Svat2MKX1QSUspk2u/a0d05dtYCLki6UCQHWS
 975 sChyQ+UbfF9HGKOZBC3vBzo1ZXNEdIUUj5bJjBHq3YgbCK38nAU66A482TmkvDGb
 976 Wj4OzeB+7Ua0yyJfggECQQDVlAa8HqdAcrbEwI/YfPydFsavBJ0KtcIGK2owQ+dk
 977 dhlDnpXDud/AtX4Ft2LaquQ15fteRrYjjwI9SFGytjtp
 978 -----END RSA PRIVATE KEY-----
 979 """, #9
 980 """-----BEGIN CERTIFICATE-----
 981 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 982 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 983 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAueLfowPT
 984 kXXtHeU2FZSz2mJhHmjqeyI1oMoyyggonccx65vMxaRfljnz2dOjVVYpCOn/LrdP
 985 wVxHO8KNDsmQeWPRjnnBa2dFqqOnp/8gEJFJBW7K/gI9se6o+xe9QIWBq6d/fKVR
 986 BURJe5TycLogzZuxQn1xHHILa3XleYuHAbMCAwEAATANBgkqhkiG9w0BAQQFAAOB
 987 gQBEC1lfC3XK0galQC96B7faLpnQmhn5lX2FUUoFIQQtBTetoE+gTqnLSOIZcOK4
 988 pkT3YvxUvgOV0LOLClryo2IknMMGWRSAcXtVUBBLRHVTSSuVUyyLr5kdRU7B4E+l
 989 OU0j8Md/dzlkm//K1bzLyUaPq204ofH8su2IEX4b3IGmAQ==
 990 -----END CERTIFICATE-----
 991 -----BEGIN RSA PRIVATE KEY-----
 992 MIICWwIBAAKBgQC54t+jA9ORde0d5TYVlLPaYmEeaOp7IjWgyjLKCCidxzHrm8zF
 993 pF+WOfPZ06NVVikI6f8ut0/BXEc7wo0OyZB5Y9GOecFrZ0Wqo6en/yAQkUkFbsr+
 994 Aj2x7qj7F71AhYGrp398pVEFREl7lPJwuiDNm7FCfXEccgtrdeV5i4cBswIDAQAB
 995 AoGAO4PnJHNaLs16AMNdgKVevEIZZDolMQ1v7C4w+ryH/JRFaHE2q+UH8bpWV9zK
 996 A82VT9RTrqpkb71S1VBiB2UDyz263XdAI/N2HcIVMmfKb72oV4gCI1KOv4DfFwZv
 997 tVVcIdVEDBOZ2TgqK4opGOgWMDqgIAl2z3PbsIoNylZHEJECQQDtQeJFhEJGH4Qz
 998 BGpdND0j2nnnJyhOFHJqikJNdul3uBwmxTK8FPEUUH/rtpyUan3VMOyDx3kX4OQg
 999 GDNSb32rAkEAyJIZIJ0EMRHVedyWsfqR0zTGKRQ+qsc3sCfyUhFksWms9jsSS0DT
1000 tVeTdC3F6EIAdpKOGhSyfBTU4jxwbFc0GQJADI4L9znEeAl66Wg2aLA2/Aq3oK/F
1001 xjv2wgSG9apxOFCZzMNqp+FD0Jth6YtEReZMuldYbLDFi6nu6HPfY2Fa+QJAdpm1
1002 lAxk6yMxiZK/5VRWoH6HYske2Vtd+aNVbePtF992ME/z3F3kEkpL3hom+dT1cyfs
1003 MU3l0Ot8ip7Ul6vlGQJAegNzpcfl2GFSdWQMxQ+nN3woKnPqpR1M3jgnqvo7L4Xe
1004 JW3vRxvfdrUuzdlvZ/Pbsu/vOd+cuIa4h0yD5q3N+g==
1005 -----END RSA PRIVATE KEY-----
1006 """, #10
1007 """-----BEGIN CERTIFICATE-----
1008 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
1009 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
1010 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAruBhwk+J
1011 XdlwfKXXN8K+43JyEYCV7Fp7ZiES4t4AEJuQuBqJVMxpzeZzu2t/vVb59ThaxxtY
1012 NGD3Xy6Og5dTv//ztWng8P7HwwvfbrUICU6zo6JAhg7kfaNa116krCYOkC/cdJWt
1013 o5W+zsDmI1jUVGH0D73h29atc1gn6wLpAsMCAwEAATANBgkqhkiG9w0BAQQFAAOB
1014 gQAEJ/ITGJ9lK/rk0yHcenW8SHsaSTlZMuJ4yEiIgrJ2t71Rd6mtCC/ljx9USvvK
1015 bF500whTiZlnWgKi02boBEKa44z/DytF6pljeNPefBQSqZyUByGEb/8Mn58Idyls
1016 q4/d9iKXMPvbpQdcesOzgOffFZevLQSWyPRaIdYBOOiYUA==
1017 -----END CERTIFICATE-----
1018 -----BEGIN RSA PRIVATE KEY-----
1019 MIICXQIBAAKBgQCu4GHCT4ld2XB8pdc3wr7jcnIRgJXsWntmIRLi3gAQm5C4GolU
1020 zGnN5nO7a3+9Vvn1OFrHG1g0YPdfLo6Dl1O///O1aeDw/sfDC99utQgJTrOjokCG
1021 DuR9o1rXXqSsJg6QL9x0la2jlb7OwOYjWNRUYfQPveHb1q1zWCfrAukCwwIDAQAB
1022 AoGAcZAXC/dYrlBpIxkTRQu7qLqGZuVI9t7fabgqqpceFargdR4Odrn0L5jrKRer
1023 MYrM8bjyAoC4a/NYUUBLnhrkcCQWO9q5fSQuFKFVWHY53SM63Qdqk8Y9Fmy/h/4c
1024 UtwZ5BWkUWItvnTMgb9bFcvSiIhEcNQauypnMpgNknopu7kCQQDlSQT10LkX2IGT
1025 bTUhPcManx92gucaKsPONKq2mP+1sIciThevRTZWZsxyIuoBBY43NcKKi8NlZCtj
1026 hhSbtzYdAkEAw0B93CXfso8g2QIMj/HJJz/wNTLtg+rriXp6jh5HWe6lKWRVrce+
1027 1w8Qz6OI/ZP6xuQ9HNeZxJ/W6rZPW6BGXwJAHcTuRPA1p/fvUvHh7Q/0zfcNAbkb
1028 QlV9GL/TzmNtB+0EjpqvDo2g8XTlZIhN85YCEf8D5DMjSn3H+GMHN/SArQJBAJlW
1029 MIGPjNoh5V4Hae4xqBOW9wIQeM880rUo5s5toQNTk4mqLk9Hquwh/MXUXGUora08
1030 2XGpMC1midXSTwhaGmkCQQCdivptFEYl33PrVbxY9nzHynpp4Mi89vQF0cjCmaYY
1031 N8L+bvLd4BU9g6hRS8b59lQ6GNjryx2bUnCVtLcey4Jd
1032 -----END RSA PRIVATE KEY-----
1033 """, #11
1034 ]
1035
1036 # To disable the pre-computed tub certs, uncomment this line.
1037 #SYSTEM_TEST_CERTS = []
1038
1039 TEST_DATA="\x02"*(immutable.upload.Uploader.URI_LIT_SIZE_THRESHOLD+1)
1040
1041 class ShouldFailMixin:
1042     def shouldFail(self, expected_failure, which, substring,
1043                    callable, *args, **kwargs):
1044         """Assert that a function call raises some exception. This is a
1045         Deferred-friendly version of TestCase.assertRaises() .
1046
1047         Suppose you want to verify the following function:
1048
1049          def broken(a, b, c):
1050              if a < 0:
1051                  raise TypeError('a must not be negative')
1052              return defer.succeed(b+c)
1053
1054         You can use:
1055             d = self.shouldFail(TypeError, 'test name',
1056                                 'a must not be negative',
1057                                 broken, -4, 5, c=12)
1058         in your test method. The 'test name' string will be included in the
1059         error message, if any, because Deferred chains frequently make it
1060         difficult to tell which assertion was tripped.
1061
1062         The substring= argument, if not None, must appear in the 'repr'
1063         of the message wrapped by this Failure, or the test will fail.
1064         """
1065
1066         assert substring is None or isinstance(substring, str)
1067         d = defer.maybeDeferred(callable, *args, **kwargs)
1068         def done(res):
1069             if isinstance(res, failure.Failure):
1070                 res.trap(expected_failure)
1071                 if substring:
1072                     message = repr(res.value.args[0])
1073                     self.failUnless(substring in message,
1074                                     "substring '%s' not in '%s'"
1075                                     % (substring, message))
1076             else:
1077                 self.fail("%s was supposed to raise %s, not get '%s'" %
1078                           (which, expected_failure, res))
1079         d.addBoth(done)
1080         return d
1081
1082 class WebErrorMixin:
1083     def explain_web_error(self, f):
1084         # an error on the server side causes the client-side getPage() to
1085         # return a failure(t.web.error.Error), and its str() doesn't show the
1086         # response body, which is where the useful information lives. Attach
1087         # this method as an errback handler, and it will reveal the hidden
1088         # message.
1089         f.trap(WebError)
1090         print "Web Error:", f.value, ":", f.value.response
1091         return f
1092
1093     def _shouldHTTPError(self, res, which, validator):
1094         if isinstance(res, failure.Failure):
1095             res.trap(WebError)
1096             return validator(res)
1097         else:
1098             self.fail("%s was supposed to Error, not get '%s'" % (which, res))
1099
1100     def shouldHTTPError(self, which,
1101                         code=None, substring=None, response_substring=None,
1102                         callable=None, *args, **kwargs):
1103         # returns a Deferred with the response body
1104         assert substring is None or isinstance(substring, str)
1105         assert callable
1106         def _validate(f):
1107             if code is not None:
1108                 self.failUnlessEqual(f.value.status, str(code))
1109             if substring:
1110                 code_string = str(f)
1111                 self.failUnless(substring in code_string,
1112                                 "substring '%s' not in '%s'"
1113                                 % (substring, code_string))
1114             response_body = f.value.response
1115             if response_substring:
1116                 self.failUnless(response_substring in response_body,
1117                                 "response substring '%s' not in '%s'"
1118                                 % (response_substring, response_body))
1119             return response_body
1120         d = defer.maybeDeferred(callable, *args, **kwargs)
1121         d.addBoth(self._shouldHTTPError, which, _validate)
1122         return d
1123
1124 class ErrorMixin(WebErrorMixin):
1125     def explain_error(self, f):
1126         if f.check(defer.FirstError):
1127             print "First Error:", f.value.subFailure
1128         return f
1129
1130 def corrupt_field(data, offset, size, debug=False):
1131     if random.random() < 0.5:
1132         newdata = testutil.flip_one_bit(data, offset, size)
1133         if debug:
1134             log.msg("testing: corrupting offset %d, size %d flipping one bit orig: %r, newdata: %r" % (offset, size, data[offset:offset+size], newdata[offset:offset+size]))
1135         return newdata
1136     else:
1137         newval = testutil.insecurerandstr(size)
1138         if debug:
1139             log.msg("testing: corrupting offset %d, size %d randomizing field, orig: %r, newval: %r" % (offset, size, data[offset:offset+size], newval))
1140         return data[:offset]+newval+data[offset+size:]
1141
1142 def _corrupt_nothing(data, debug=False):
1143     """Leave the data pristine. """
1144     return data
1145
1146 def _corrupt_file_version_number(data, debug=False):
1147     """Scramble the file data -- the share file version number have one bit
1148     flipped or else will be changed to a random value."""
1149     return corrupt_field(data, 0x00, 4)
1150
1151 def _corrupt_size_of_file_data(data, debug=False):
1152     """Scramble the file data -- the field showing the size of the share data
1153     within the file will be set to one smaller."""
1154     return corrupt_field(data, 0x04, 4)
1155
1156 def _corrupt_sharedata_version_number(data, debug=False):
1157     """Scramble the file data -- the share data version number will have one
1158     bit flipped or else will be changed to a random value, but not 1 or 2."""
1159     return corrupt_field(data, 0x0c, 4)
1160     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1161     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1162     newsharevernum = sharevernum
1163     while newsharevernum in (1, 2):
1164         newsharevernum = random.randrange(0, 2**32)
1165     newsharevernumbytes = struct.pack(">L", newsharevernum)
1166     return data[:0x0c] + newsharevernumbytes + data[0x0c+4:]
1167
1168 def _corrupt_sharedata_version_number_to_plausible_version(data, debug=False):
1169     """Scramble the file data -- the share data version number will be
1170     changed to 2 if it is 1 or else to 1 if it is 2."""
1171     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1172     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1173     if sharevernum == 1:
1174         newsharevernum = 2
1175     else:
1176         newsharevernum = 1
1177     newsharevernumbytes = struct.pack(">L", newsharevernum)
1178     return data[:0x0c] + newsharevernumbytes + data[0x0c+4:]
1179
1180 def _corrupt_segment_size(data, debug=False):
1181     """Scramble the file data -- the field showing the size of the segment
1182     will have one bit flipped or else be changed to a random value."""
1183     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1184     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1185     if sharevernum == 1:
1186         return corrupt_field(data, 0x0c+0x04, 4, debug=False)
1187     else:
1188         return corrupt_field(data, 0x0c+0x04, 8, debug=False)
1189
1190 def _corrupt_size_of_sharedata(data, debug=False):
1191     """Scramble the file data -- the field showing the size of the data
1192     within the share data will have one bit flipped or else will be changed
1193     to a random value."""
1194     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1195     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1196     if sharevernum == 1:
1197         return corrupt_field(data, 0x0c+0x08, 4)
1198     else:
1199         return corrupt_field(data, 0x0c+0x0c, 8)
1200
1201 def _corrupt_offset_of_sharedata(data, debug=False):
1202     """Scramble the file data -- the field showing the offset of the data
1203     within the share data will have one bit flipped or else be changed to a
1204     random value."""
1205     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1206     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1207     if sharevernum == 1:
1208         return corrupt_field(data, 0x0c+0x0c, 4)
1209     else:
1210         return corrupt_field(data, 0x0c+0x14, 8)
1211
1212 def _corrupt_offset_of_ciphertext_hash_tree(data, debug=False):
1213     """Scramble the file data -- the field showing the offset of the
1214     ciphertext hash tree within the share data will have one bit flipped or
1215     else be changed to a random value.
1216     """
1217     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1218     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1219     if sharevernum == 1:
1220         return corrupt_field(data, 0x0c+0x14, 4, debug=False)
1221     else:
1222         return corrupt_field(data, 0x0c+0x24, 8, debug=False)
1223
1224 def _corrupt_offset_of_block_hashes(data, debug=False):
1225     """Scramble the file data -- the field showing the offset of the block
1226     hash tree within the share data will have one bit flipped or else will be
1227     changed to a random value."""
1228     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1229     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1230     if sharevernum == 1:
1231         return corrupt_field(data, 0x0c+0x18, 4)
1232     else:
1233         return corrupt_field(data, 0x0c+0x2c, 8)
1234
1235 def _corrupt_offset_of_block_hashes_to_truncate_crypttext_hashes(data, debug=False):
1236     """Scramble the file data -- the field showing the offset of the block
1237     hash tree within the share data will have a multiple of hash size
1238     subtracted from it, thus causing the downloader to download an incomplete
1239     crypttext hash tree."""
1240     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1241     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1242     if sharevernum == 1:
1243         curval = struct.unpack(">L", data[0x0c+0x18:0x0c+0x18+4])[0]
1244         newval = random.randrange(0, max(1, (curval/hashutil.CRYPTO_VAL_SIZE)/2))*hashutil.CRYPTO_VAL_SIZE
1245         newvalstr = struct.pack(">L", newval)
1246         return data[:0x0c+0x18]+newvalstr+data[0x0c+0x18+4:]
1247     else:
1248         curval = struct.unpack(">Q", data[0x0c+0x2c:0x0c+0x2c+8])[0]
1249         newval = random.randrange(0, max(1, (curval/hashutil.CRYPTO_VAL_SIZE)/2))*hashutil.CRYPTO_VAL_SIZE
1250         newvalstr = struct.pack(">Q", newval)
1251         return data[:0x0c+0x2c]+newvalstr+data[0x0c+0x2c+8:]
1252
1253 def _corrupt_offset_of_share_hashes(data, debug=False):
1254     """Scramble the file data -- the field showing the offset of the share
1255     hash tree within the share data will have one bit flipped or else will be
1256     changed to a random value."""
1257     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1258     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1259     if sharevernum == 1:
1260         return corrupt_field(data, 0x0c+0x1c, 4)
1261     else:
1262         return corrupt_field(data, 0x0c+0x34, 8)
1263
1264 def _corrupt_offset_of_uri_extension(data, debug=False):
1265     """Scramble the file data -- the field showing the offset of the uri
1266     extension will have one bit flipped or else will be changed to a random
1267     value."""
1268     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1269     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1270     if sharevernum == 1:
1271         return corrupt_field(data, 0x0c+0x20, 4)
1272     else:
1273         return corrupt_field(data, 0x0c+0x3c, 8)
1274
1275 def _corrupt_offset_of_uri_extension_to_force_short_read(data, debug=False):
1276     """Scramble the file data -- the field showing the offset of the uri
1277     extension will be set to the size of the file minus 3. This means when
1278     the client tries to read the length field from that location it will get
1279     a short read -- the result string will be only 3 bytes long, not the 4 or
1280     8 bytes necessary to do a successful struct.unpack."""
1281     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1282     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1283     # The "-0x0c" in here is to skip the server-side header in the share
1284     # file, which the client doesn't see when seeking and reading.
1285     if sharevernum == 1:
1286         if debug:
1287             log.msg("testing: corrupting offset %d, size %d, changing %d to %d (len(data) == %d)" % (0x2c, 4, struct.unpack(">L", data[0x2c:0x2c+4])[0], len(data)-0x0c-3, len(data)))
1288         return data[:0x2c] + struct.pack(">L", len(data)-0x0c-3) + data[0x2c+4:]
1289     else:
1290         if debug:
1291             log.msg("testing: corrupting offset %d, size %d, changing %d to %d (len(data) == %d)" % (0x48, 8, struct.unpack(">Q", data[0x48:0x48+8])[0], len(data)-0x0c-3, len(data)))
1292         return data[:0x48] + struct.pack(">Q", len(data)-0x0c-3) + data[0x48+8:]
1293
1294 def _corrupt_mutable_share_data(data, debug=False):
1295     prefix = data[:32]
1296     assert prefix == MutableShareFile.MAGIC, "This function is designed to corrupt mutable shares of v1, and the magic number doesn't look right: %r vs %r" % (prefix, MutableShareFile.MAGIC)
1297     data_offset = MutableShareFile.DATA_OFFSET
1298     sharetype = data[data_offset:data_offset+1]
1299     assert sharetype == "\x00", "non-SDMF mutable shares not supported"
1300     (version, ig_seqnum, ig_roothash, ig_IV, ig_k, ig_N, ig_segsize,
1301      ig_datalen, offsets) = unpack_header(data[data_offset:])
1302     assert version == 0, "this function only handles v0 SDMF files"
1303     start = data_offset + offsets["share_data"]
1304     length = data_offset + offsets["enc_privkey"] - start
1305     return corrupt_field(data, start, length)
1306
1307 def _corrupt_share_data(data, debug=False):
1308     """Scramble the file data -- the field containing the share data itself
1309     will have one bit flipped or else will be changed to a random value."""
1310     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1311     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways, not v%d." % sharevernum
1312     if sharevernum == 1:
1313         sharedatasize = struct.unpack(">L", data[0x0c+0x08:0x0c+0x08+4])[0]
1314
1315         return corrupt_field(data, 0x0c+0x24, sharedatasize)
1316     else:
1317         sharedatasize = struct.unpack(">Q", data[0x0c+0x08:0x0c+0x0c+8])[0]
1318
1319         return corrupt_field(data, 0x0c+0x44, sharedatasize)
1320
1321 def _corrupt_share_data_last_byte(data, debug=False):
1322     """Scramble the file data -- flip all bits of the last byte."""
1323     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1324     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways, not v%d." % sharevernum
1325     if sharevernum == 1:
1326         sharedatasize = struct.unpack(">L", data[0x0c+0x08:0x0c+0x08+4])[0]
1327         offset = 0x0c+0x24+sharedatasize-1
1328     else:
1329         sharedatasize = struct.unpack(">Q", data[0x0c+0x08:0x0c+0x0c+8])[0]
1330         offset = 0x0c+0x44+sharedatasize-1
1331
1332     newdata = data[:offset] + chr(ord(data[offset])^0xFF) + data[offset+1:]
1333     if debug:
1334         log.msg("testing: flipping all bits of byte at offset %d: %r, newdata: %r" % (offset, data[offset], newdata[offset]))
1335     return newdata
1336
1337 def _corrupt_crypttext_hash_tree(data, debug=False):
1338     """Scramble the file data -- the field containing the crypttext hash tree
1339     will have one bit flipped or else will be changed to a random value.
1340     """
1341     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1342     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1343     if sharevernum == 1:
1344         crypttexthashtreeoffset = struct.unpack(">L", data[0x0c+0x14:0x0c+0x14+4])[0]
1345         blockhashesoffset = struct.unpack(">L", data[0x0c+0x18:0x0c+0x18+4])[0]
1346     else:
1347         crypttexthashtreeoffset = struct.unpack(">Q", data[0x0c+0x24:0x0c+0x24+8])[0]
1348         blockhashesoffset = struct.unpack(">Q", data[0x0c+0x2c:0x0c+0x2c+8])[0]
1349
1350     return corrupt_field(data, 0x0c+crypttexthashtreeoffset, blockhashesoffset-crypttexthashtreeoffset, debug=debug)
1351
1352 def _corrupt_crypttext_hash_tree_byte_x221(data, debug=False):
1353     """Scramble the file data -- the byte at offset 0x221 will have its 7th
1354     (b1) bit flipped.
1355     """
1356     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1357     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1358     if debug:
1359         log.msg("original data: %r" % (data,))
1360     return data[:0x0c+0x221] + chr(ord(data[0x0c+0x221])^0x02) + data[0x0c+0x2210+1:]
1361
1362 def _corrupt_block_hashes(data, debug=False):
1363     """Scramble the file data -- the field containing the block hash tree
1364     will have one bit flipped or else will be changed to a random value.
1365     """
1366     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1367     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1368     if sharevernum == 1:
1369         blockhashesoffset = struct.unpack(">L", data[0x0c+0x18:0x0c+0x18+4])[0]
1370         sharehashesoffset = struct.unpack(">L", data[0x0c+0x1c:0x0c+0x1c+4])[0]
1371     else:
1372         blockhashesoffset = struct.unpack(">Q", data[0x0c+0x2c:0x0c+0x2c+8])[0]
1373         sharehashesoffset = struct.unpack(">Q", data[0x0c+0x34:0x0c+0x34+8])[0]
1374
1375     return corrupt_field(data, 0x0c+blockhashesoffset, sharehashesoffset-blockhashesoffset)
1376
1377 def _corrupt_share_hashes(data, debug=False):
1378     """Scramble the file data -- the field containing the share hash chain
1379     will have one bit flipped or else will be changed to a random value.
1380     """
1381     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1382     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1383     if sharevernum == 1:
1384         sharehashesoffset = struct.unpack(">L", data[0x0c+0x1c:0x0c+0x1c+4])[0]
1385         uriextoffset = struct.unpack(">L", data[0x0c+0x20:0x0c+0x20+4])[0]
1386     else:
1387         sharehashesoffset = struct.unpack(">Q", data[0x0c+0x34:0x0c+0x34+8])[0]
1388         uriextoffset = struct.unpack(">Q", data[0x0c+0x3c:0x0c+0x3c+8])[0]
1389
1390     return corrupt_field(data, 0x0c+sharehashesoffset, uriextoffset-sharehashesoffset)
1391
1392 def _corrupt_length_of_uri_extension(data, debug=False):
1393     """Scramble the file data -- the field showing the length of the uri
1394     extension will have one bit flipped or else will be changed to a random
1395     value."""
1396     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1397     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1398     if sharevernum == 1:
1399         uriextoffset = struct.unpack(">L", data[0x0c+0x20:0x0c+0x20+4])[0]
1400         return corrupt_field(data, uriextoffset, 4)
1401     else:
1402         uriextoffset = struct.unpack(">Q", data[0x0c+0x3c:0x0c+0x3c+8])[0]
1403         return corrupt_field(data, 0x0c+uriextoffset, 8)
1404
1405 def _corrupt_uri_extension(data, debug=False):
1406     """Scramble the file data -- the field containing the uri extension will
1407     have one bit flipped or else will be changed to a random value."""
1408     sharevernum = struct.unpack(">L", data[0x0c:0x0c+4])[0]
1409     assert sharevernum in (1, 2), "This test is designed to corrupt immutable shares of v1 or v2 in specific ways."
1410     if sharevernum == 1:
1411         uriextoffset = struct.unpack(">L", data[0x0c+0x20:0x0c+0x20+4])[0]
1412         uriextlen = struct.unpack(">L", data[0x0c+uriextoffset:0x0c+uriextoffset+4])[0]
1413     else:
1414         uriextoffset = struct.unpack(">Q", data[0x0c+0x3c:0x0c+0x3c+8])[0]
1415         uriextlen = struct.unpack(">Q", data[0x0c+uriextoffset:0x0c+uriextoffset+8])[0]
1416
1417     return corrupt_field(data, 0x0c+uriextoffset, uriextlen)