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