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