src/allmydata/test/common.py

   1
   2 import os
   3 from zope.interface import implements
   4 from twisted.internet import defer
   5 from twisted.internet.interfaces import IConsumer
   6 from twisted.python import failure
   7 from twisted.application import service
   8 from twisted.web.error import Error as WebError
   9 from foolscap.eventual import flushEventualQueue, fireEventually
  10 from allmydata import uri, dirnode, client
  11 from allmydata.introducer.server import IntroducerNode
  12 from allmydata.interfaces import IURI, IMutableFileNode, IFileNode, \
  13      FileTooLargeError, NotEnoughSharesError, ICheckable
  14 from allmydata.checker_results import CheckerResults, CheckAndRepairResults, \
  15      DeepCheckResults, DeepCheckAndRepairResults
  16 from allmydata.mutable.common import CorruptShareError
  17 from allmydata.storage import storage_index_to_dir
  18 from allmydata.util import log, fileutil, pollmixin
  19 from allmydata.util.assertutil import precondition
  20 from allmydata.stats import StatsGathererService
  21 from allmydata.key_generator import KeyGeneratorService
  22 import common_util as testutil
  23
  24
  25 def flush_but_dont_ignore(res):
  26     d = flushEventualQueue()
  27     def _done(ignored):
  28         return res
  29     d.addCallback(_done)
  30     return d
  31
  32 class FakeCHKFileNode:
  33     """I provide IFileNode, but all of my data is stored in a class-level
  34     dictionary."""
  35     implements(IFileNode)
  36     all_contents = {}
  37     bad_shares = {}
  38
  39     def __init__(self, u, client):
  40         precondition(IURI.providedBy(u), u)
  41         self.client = client
  42         self.my_uri = u
  43         self.storage_index = u.storage_index
  44
  45     def get_uri(self):
  46         return self.my_uri.to_string()
  47     def get_readonly_uri(self):
  48         return self.my_uri.to_string()
  49     def get_verify_cap(self):
  50         return self.my_uri.get_verify_cap()
  51     def get_storage_index(self):
  52         return self.storage_index
  53
  54     def check(self, monitor, verify=False):
  55         r = CheckerResults(self.my_uri, self.storage_index)
  56         is_bad = self.bad_shares.get(self.storage_index, None)
  57         data = {}
  58         data["count-shares-needed"] = 3
  59         data["count-shares-expected"] = 10
  60         data["count-good-share-hosts"] = 10
  61         data["count-wrong-shares"] = 0
  62         nodeid = "\x00"*20
  63         data["list-corrupt-shares"] = []
  64         data["sharemap"] = {1: [nodeid]}
  65         data["servers-responding"] = [nodeid]
  66         data["count-recoverable-versions"] = 1
  67         data["count-unrecoverable-versions"] = 0
  68         if is_bad:
  69              r.set_healthy(False)
  70              r.set_recoverable(True)
  71              data["count-shares-good"] = 9
  72              data["list-corrupt-shares"] = [(nodeid, self.storage_index, 0)]
  73              r.problems = failure.Failure(CorruptShareError(is_bad))
  74         else:
  75              r.set_healthy(True)
  76              r.set_recoverable(True)
  77              data["count-shares-good"] = 10
  78              r.problems = []
  79         r.set_data(data)
  80         r.set_needs_rebalancing(False)
  81         return defer.succeed(r)
  82     def check_and_repair(self, monitor, verify=False):
  83         d = self.check(verify)
  84         def _got(cr):
  85             r = CheckAndRepairResults(self.storage_index)
  86             r.pre_repair_results = r.post_repair_results = cr
  87             return r
  88         d.addCallback(_got)
  89         return d
  90
  91     def is_mutable(self):
  92         return False
  93     def is_readonly(self):
  94         return True
  95
  96     def download(self, target):
  97         if self.my_uri.to_string() not in self.all_contents:
  98             f = failure.Failure(NotEnoughSharesError())
  99             target.fail(f)
 100             return defer.fail(f)
 101         data = self.all_contents[self.my_uri.to_string()]
 102         target.open(len(data))
 103         target.write(data)
 104         target.close()
 105         return defer.maybeDeferred(target.finish)
 106     def download_to_data(self):
 107         if self.my_uri.to_string() not in self.all_contents:
 108             return defer.fail(NotEnoughSharesError())
 109         data = self.all_contents[self.my_uri.to_string()]
 110         return defer.succeed(data)
 111     def get_size(self):
 112         try:
 113             data = self.all_contents[self.my_uri.to_string()]
 114         except KeyError, le:
 115             raise NotEnoughSharesError(le)
 116         return len(data)
 117     def read(self, consumer, offset=0, size=None):
 118         d = self.download_to_data()
 119         def _got(data):
 120             start = offset
 121             if size is not None:
 122                 end = offset + size
 123             else:
 124                 end = len(data)
 125             consumer.write(data[start:end])
 126             return consumer
 127         d.addCallback(_got)
 128         return d
 129
 130 def make_chk_file_uri(size):
 131     return uri.CHKFileURI(key=os.urandom(16),
 132                           uri_extension_hash=os.urandom(32),
 133                           needed_shares=3,
 134                           total_shares=10,
 135                           size=size)
 136
 137 def create_chk_filenode(client, contents):
 138     u = make_chk_file_uri(len(contents))
 139     n = FakeCHKFileNode(u, client)
 140     FakeCHKFileNode.all_contents[u.to_string()] = contents
 141     return n
 142
 143
 144 class FakeMutableFileNode:
 145     """I provide IMutableFileNode, but all of my data is stored in a
 146     class-level dictionary."""
 147
 148     implements(IMutableFileNode, ICheckable)
 149     MUTABLE_SIZELIMIT = 10000
 150     all_contents = {}
 151     bad_shares = {}
 152
 153     def __init__(self, client):
 154         self.client = client
 155         self.my_uri = make_mutable_file_uri()
 156         self.storage_index = self.my_uri.storage_index
 157     def create(self, initial_contents, key_generator=None):
 158         if len(initial_contents) > self.MUTABLE_SIZELIMIT:
 159             raise FileTooLargeError("SDMF is limited to one segment, and "
 160                                     "%d > %d" % (len(initial_contents),
 161                                                  self.MUTABLE_SIZELIMIT))
 162         self.all_contents[self.storage_index] = initial_contents
 163         return defer.succeed(self)
 164     def init_from_uri(self, myuri):
 165         self.my_uri = IURI(myuri)
 166         self.storage_index = self.my_uri.storage_index
 167         return self
 168     def get_uri(self):
 169         return self.my_uri.to_string()
 170     def get_readonly(self):
 171         return self.my_uri.get_readonly()
 172     def get_readonly_uri(self):
 173         return self.my_uri.get_readonly().to_string()
 174     def is_readonly(self):
 175         return self.my_uri.is_readonly()
 176     def is_mutable(self):
 177         return self.my_uri.is_mutable()
 178     def get_writekey(self):
 179         return "\x00"*16
 180     def get_size(self):
 181         return "?" # TODO: see mutable.MutableFileNode.get_size
 182     def get_size_of_best_version(self):
 183         return defer.succeed(len(self.all_contents[self.storage_index]))
 184
 185     def get_storage_index(self):
 186         return self.storage_index
 187
 188     def check(self, monitor, verify=False):
 189         r = CheckerResults(self.my_uri, self.storage_index)
 190         is_bad = self.bad_shares.get(self.storage_index, None)
 191         data = {}
 192         data["count-shares-needed"] = 3
 193         data["count-shares-expected"] = 10
 194         data["count-good-share-hosts"] = 10
 195         data["count-wrong-shares"] = 0
 196         data["list-corrupt-shares"] = []
 197         nodeid = "\x00"*20
 198         data["sharemap"] = {"seq1-abcd-sh0": [nodeid]}
 199         data["servers-responding"] = [nodeid]
 200         data["count-recoverable-versions"] = 1
 201         data["count-unrecoverable-versions"] = 0
 202         if is_bad:
 203              r.set_healthy(False)
 204              r.set_recoverable(True)
 205              data["count-shares-good"] = 9
 206              r.problems = failure.Failure(CorruptShareError("peerid",
 207                                                             0, # shnum
 208                                                             is_bad))
 209         else:
 210              r.set_healthy(True)
 211              r.set_recoverable(True)
 212              data["count-shares-good"] = 10
 213              r.problems = []
 214         r.set_data(data)
 215         r.set_needs_rebalancing(False)
 216         return defer.succeed(r)
 217
 218     def check_and_repair(self, monitor, verify=False):
 219         d = self.check(verify)
 220         def _got(cr):
 221             r = CheckAndRepairResults(self.storage_index)
 222             r.pre_repair_results = r.post_repair_results = cr
 223             return r
 224         d.addCallback(_got)
 225         return d
 226
 227     def deep_check(self, verify=False):
 228         d = self.check(verify)
 229         def _done(r):
 230             dr = DeepCheckResults(self.storage_index)
 231             dr.add_check(r, [])
 232             return dr
 233         d.addCallback(_done)
 234         return d
 235
 236     def deep_check_and_repair(self, verify=False):
 237         d = self.check_and_repair(verify)
 238         def _done(r):
 239             dr = DeepCheckAndRepairResults(self.storage_index)
 240             dr.add_check(r, [])
 241             return dr
 242         d.addCallback(_done)
 243         return d
 244
 245     def download_best_version(self):
 246         return defer.succeed(self.all_contents[self.storage_index])
 247     def overwrite(self, new_contents):
 248         if len(new_contents) > self.MUTABLE_SIZELIMIT:
 249             raise FileTooLargeError("SDMF is limited to one segment, and "
 250                                     "%d > %d" % (len(new_contents),
 251                                                  self.MUTABLE_SIZELIMIT))
 252         assert not self.is_readonly()
 253         self.all_contents[self.storage_index] = new_contents
 254         return defer.succeed(None)
 255     def modify(self, modifier):
 256         # this does not implement FileTooLargeError, but the real one does
 257         return defer.maybeDeferred(self._modify, modifier)
 258     def _modify(self, modifier):
 259         assert not self.is_readonly()
 260         old_contents = self.all_contents[self.storage_index]
 261         self.all_contents[self.storage_index] = modifier(old_contents, None, True)
 262         return None
 263
 264     def download(self, target):
 265         if self.storage_index not in self.all_contents:
 266             f = failure.Failure(NotEnoughSharesError())
 267             target.fail(f)
 268             return defer.fail(f)
 269         data = self.all_contents[self.storage_index]
 270         target.open(len(data))
 271         target.write(data)
 272         target.close()
 273         return defer.maybeDeferred(target.finish)
 274     def download_to_data(self):
 275         if self.storage_index not in self.all_contents:
 276             return defer.fail(NotEnoughSharesError())
 277         data = self.all_contents[self.storage_index]
 278         return defer.succeed(data)
 279
 280 def make_mutable_file_uri():
 281     return uri.WriteableSSKFileURI(writekey=os.urandom(16),
 282                                    fingerprint=os.urandom(32))
 283 def make_verifier_uri():
 284     return uri.SSKVerifierURI(storage_index=os.urandom(16),
 285                               fingerprint=os.urandom(32))
 286
 287 class FakeDirectoryNode(dirnode.NewDirectoryNode):
 288     """This offers IDirectoryNode, but uses a FakeMutableFileNode for the
 289     backing store, so it doesn't go to the grid. The child data is still
 290     encrypted and serialized, so this isn't useful for tests that want to
 291     look inside the dirnodes and check their contents.
 292     """
 293     filenode_class = FakeMutableFileNode
 294
 295 class LoggingServiceParent(service.MultiService):
 296     def log(self, *args, **kwargs):
 297         return log.msg(*args, **kwargs)
 298
 299
 300 class SystemTestMixin(pollmixin.PollMixin, testutil.StallMixin):
 301
 302     def setUp(self):
 303         self.sparent = service.MultiService()
 304         self.sparent.startService()
 305
 306         self.stats_gatherer = None
 307         self.stats_gatherer_furl = None
 308         self.key_generator_svc = None
 309         self.key_generator_furl = None
 310
 311     def tearDown(self):
 312         log.msg("shutting down SystemTest services")
 313         d = self.sparent.stopService()
 314         d.addBoth(flush_but_dont_ignore)
 315         return d
 316
 317     def getdir(self, subdir):
 318         return os.path.join(self.basedir, subdir)
 319
 320     def add_service(self, s):
 321         s.setServiceParent(self.sparent)
 322         return s
 323
 324     def set_up_nodes(self, NUMCLIENTS=5,
 325                      use_stats_gatherer=False, use_key_generator=False):
 326         self.numclients = NUMCLIENTS
 327         iv_dir = self.getdir("introducer")
 328         if not os.path.isdir(iv_dir):
 329             fileutil.make_dirs(iv_dir)
 330             f = open(os.path.join(iv_dir, "webport"), "w")
 331             f.write("tcp:0:interface=127.0.0.1\n")
 332             f.close()
 333             if SYSTEM_TEST_CERTS:
 334                 os.mkdir(os.path.join(iv_dir, "private"))
 335                 f = open(os.path.join(iv_dir, "private", "node.pem"), "w")
 336                 f.write(SYSTEM_TEST_CERTS[0])
 337                 f.close()
 338         iv = IntroducerNode(basedir=iv_dir)
 339         self.introducer = self.add_service(iv)
 340         d = self.introducer.when_tub_ready()
 341         d.addCallback(self._get_introducer_web)
 342         if use_stats_gatherer:
 343             d.addCallback(self._set_up_stats_gatherer)
 344         if use_key_generator:
 345             d.addCallback(self._set_up_key_generator)
 346         d.addCallback(self._set_up_nodes_2)
 347         if use_stats_gatherer:
 348             d.addCallback(self._grab_stats)
 349         return d
 350
 351     def _get_introducer_web(self, res):
 352         f = open(os.path.join(self.getdir("introducer"), "node.url"), "r")
 353         self.introweb_url = f.read().strip()
 354         f.close()
 355
 356     def _set_up_stats_gatherer(self, res):
 357         statsdir = self.getdir("stats_gatherer")
 358         fileutil.make_dirs(statsdir)
 359         self.stats_gatherer_svc = StatsGathererService(statsdir)
 360         self.stats_gatherer = self.stats_gatherer_svc.stats_gatherer
 361         self.add_service(self.stats_gatherer_svc)
 362
 363         d = fireEventually()
 364         sgf = os.path.join(statsdir, 'stats_gatherer.furl')
 365         def check_for_furl():
 366             return os.path.exists(sgf)
 367         d.addCallback(lambda junk: self.poll(check_for_furl, timeout=30))
 368         def get_furl(junk):
 369             self.stats_gatherer_furl = file(sgf, 'rb').read().strip()
 370         d.addCallback(get_furl)
 371         return d
 372
 373     def _set_up_key_generator(self, res):
 374         kgsdir = self.getdir("key_generator")
 375         fileutil.make_dirs(kgsdir)
 376
 377         self.key_generator_svc = KeyGeneratorService(kgsdir, display_furl=False)
 378         self.key_generator_svc.key_generator.pool_size = 4
 379         self.key_generator_svc.key_generator.pool_refresh_delay = 60
 380         self.add_service(self.key_generator_svc)
 381
 382         d = fireEventually()
 383         def check_for_furl():
 384             return os.path.exists(os.path.join(kgsdir, 'key_generator.furl'))
 385         d.addCallback(lambda junk: self.poll(check_for_furl, timeout=30))
 386         def get_furl(junk):
 387             kgf = os.path.join(kgsdir, 'key_generator.furl')
 388             self.key_generator_furl = file(kgf, 'rb').read().strip()
 389         d.addCallback(get_furl)
 390         return d
 391
 392     def _set_up_nodes_2(self, res):
 393         q = self.introducer
 394         self.introducer_furl = q.introducer_url
 395         self.clients = []
 396         basedirs = []
 397         for i in range(self.numclients):
 398             basedir = self.getdir("client%d" % i)
 399             basedirs.append(basedir)
 400             fileutil.make_dirs(os.path.join(basedir, "private"))
 401             if len(SYSTEM_TEST_CERTS) > (i+1):
 402                 f = open(os.path.join(basedir, "private", "node.pem"), "w")
 403                 f.write(SYSTEM_TEST_CERTS[i+1])
 404                 f.close()
 405
 406             def write(name, value):
 407                 open(os.path.join(basedir, name), "w").write(value+"\n")
 408             if i == 0:
 409                 # client[0] runs a webserver and a helper, no key_generator
 410                 write("webport", "tcp:0:interface=127.0.0.1")
 411                 write("run_helper", "yes")
 412                 write("keepalive_timeout", "600")
 413             if i == 3:
 414                 # client[3] runs a webserver and uses a helper, uses
 415                 # key_generator
 416                 write("webport", "tcp:0:interface=127.0.0.1")
 417                 write("disconnect_timeout", "1800")
 418                 if self.key_generator_furl:
 419                     kgf = "%s\n" % (self.key_generator_furl,)
 420                     write("key_generator.furl", kgf)
 421             write("introducer.furl", self.introducer_furl)
 422             if self.stats_gatherer_furl:
 423                 write("stats_gatherer.furl", self.stats_gatherer_furl)
 424
 425         # give subclasses a chance to append liens to the node's tahoe.cfg
 426         # files before they are launched.
 427         self._set_up_nodes_extra_config()
 428
 429         # start client[0], wait for it's tub to be ready (at which point it
 430         # will have registered the helper furl).
 431         c = self.add_service(client.Client(basedir=basedirs[0]))
 432         self.clients.append(c)
 433         d = c.when_tub_ready()
 434         def _ready(res):
 435             f = open(os.path.join(basedirs[0],"private","helper.furl"), "r")
 436             helper_furl = f.read()
 437             f.close()
 438             self.helper_furl = helper_furl
 439             f = open(os.path.join(basedirs[3],"helper.furl"), "w")
 440             f.write(helper_furl)
 441             f.close()
 442
 443             # this starts the rest of the clients
 444             for i in range(1, self.numclients):
 445                 c = self.add_service(client.Client(basedir=basedirs[i]))
 446                 self.clients.append(c)
 447             log.msg("STARTING")
 448             return self.wait_for_connections()
 449         d.addCallback(_ready)
 450         def _connected(res):
 451             log.msg("CONNECTED")
 452             # now find out where the web port was
 453             l = self.clients[0].getServiceNamed("webish").listener
 454             port = l._port.getHost().port
 455             self.webish_url = "http://localhost:%d/" % port
 456             # and the helper-using webport
 457             l = self.clients[3].getServiceNamed("webish").listener
 458             port = l._port.getHost().port
 459             self.helper_webish_url = "http://localhost:%d/" % port
 460         d.addCallback(_connected)
 461         return d
 462
 463     def _set_up_nodes_extra_config(self):
 464         # for overriding by subclasses
 465         pass
 466
 467     def _grab_stats(self, res):
 468         d = self.stats_gatherer.poll()
 469         return d
 470
 471     def bounce_client(self, num):
 472         c = self.clients[num]
 473         d = c.disownServiceParent()
 474         # I think windows requires a moment to let the connection really stop
 475         # and the port number made available for re-use. TODO: examine the
 476         # behavior, see if this is really the problem, see if we can do
 477         # better than blindly waiting for a second.
 478         d.addCallback(self.stall, 1.0)
 479         def _stopped(res):
 480             new_c = client.Client(basedir=self.getdir("client%d" % num))
 481             self.clients[num] = new_c
 482             self.add_service(new_c)
 483             return new_c.when_tub_ready()
 484         d.addCallback(_stopped)
 485         d.addCallback(lambda res: self.wait_for_connections())
 486         def _maybe_get_webport(res):
 487             if num == 0:
 488                 # now find out where the web port was
 489                 l = self.clients[0].getServiceNamed("webish").listener
 490                 port = l._port.getHost().port
 491                 self.webish_url = "http://localhost:%d/" % port
 492         d.addCallback(_maybe_get_webport)
 493         return d
 494
 495     def add_extra_node(self, client_num, helper_furl=None,
 496                        add_to_sparent=False):
 497         # usually this node is *not* parented to our self.sparent, so we can
 498         # shut it down separately from the rest, to exercise the
 499         # connection-lost code
 500         basedir = self.getdir("client%d" % client_num)
 501         if not os.path.isdir(basedir):
 502             fileutil.make_dirs(basedir)
 503         open(os.path.join(basedir, "introducer.furl"), "w").write(self.introducer_furl)
 504         if helper_furl:
 505             f = open(os.path.join(basedir, "helper.furl") ,"w")
 506             f.write(helper_furl+"\n")
 507             f.close()
 508
 509         c = client.Client(basedir=basedir)
 510         self.clients.append(c)
 511         self.numclients += 1
 512         if add_to_sparent:
 513             c.setServiceParent(self.sparent)
 514         else:
 515             c.startService()
 516         d = self.wait_for_connections()
 517         d.addCallback(lambda res: c)
 518         return d
 519
 520     def _check_connections(self):
 521         for c in self.clients:
 522             ic = c.introducer_client
 523             if not ic.connected_to_introducer():
 524                 return False
 525             if len(ic.get_all_peerids()) != self.numclients:
 526                 return False
 527         return True
 528
 529     def wait_for_connections(self, ignored=None):
 530         # TODO: replace this with something that takes a list of peerids and
 531         # fires when they've all been heard from, instead of using a count
 532         # and a threshold
 533         return self.poll(self._check_connections, timeout=200)
 534
 535
 536 # our system test uses the same Tub certificates each time, to avoid the
 537 # overhead of key generation
 538 SYSTEM_TEST_CERTS = [
 539 """-----BEGIN CERTIFICATE-----
 540 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 541 aW5neTAeFw0wODA3MjUyMjQyMDVaFw0wOTA3MjUyMjQyMDVaMBcxFTATBgNVBAMU
 542 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAxHCWajrR
 543 2h/iurw8k93m8WUdE3xypJiiAITw7GkKlKbCLD+dEce2MXwVVYca0n/MZZsj89Cu
 544 Ko0lLjksMseoSDoj98iEmVpaY5mc2ntpQ+FXdoEmPP234XRWEg2HQ+EaK6+WkGQg
 545 DDXQvFJCVCQk/n1MdAwZZ6vqf2ITzSuD44kCAwEAATANBgkqhkiG9w0BAQQFAAOB
 546 gQBn6qPKGdFjWJy7sOOTUFfm/THhHQqAh1pBDLkjR+OtzuobCoP8n8J1LNG3Yxds
 547 Jj7NWQL7X5TfOlfoi7e9jK0ujGgWh3yYU6PnHzJLkDiDT3LCSywQuGXCjh0tOStS
 548 2gaCmmAK2cfxSStKzNcewl2Zs8wHMygq8TLFoZ6ozN1+xQ==
 549 -----END CERTIFICATE-----
 550 -----BEGIN RSA PRIVATE KEY-----
 551 MIICXQIBAAKBgQDEcJZqOtHaH+K6vDyT3ebxZR0TfHKkmKIAhPDsaQqUpsIsP50R
 552 x7YxfBVVhxrSf8xlmyPz0K4qjSUuOSwyx6hIOiP3yISZWlpjmZzae2lD4Vd2gSY8
 553 /bfhdFYSDYdD4Rorr5aQZCAMNdC8UkJUJCT+fUx0DBlnq+p/YhPNK4PjiQIDAQAB
 554 AoGAZyDMdrymiyMOPwavrtlicvyohSBid3MCKc+hRBvpSB0790r2RO1aAySndp1V
 555 QYmCXx1RhKDbrs8m49t0Dryu5T+sQrFl0E3usAP3vvXWeh4jwJ9GyiRWy4xOEuEQ
 556 3ewjbEItHqA/bRJF0TNtbOmZTDC7v9FRPf2bTAyFfTZep5kCQQD33q1RA8WUYtmQ
 557 IArgHqt69i421lpXlOgqotFHwTx4FiGgVzDQCDuXU6txB9EeKRM340poissav/n6
 558 bkLZ7/VDAkEAyuIPkeI59sE5NnmW+N47NbCfdM1Smy1YxZpv942EmP9Veub5N0dw
 559 iK5bLAgEguUIjpTsh3BRmsE9Xd+ItmnRQwJBAMZhbg19G1EbnE0BmDKv2UbcaThy
 560 bnPSNc6J6T2opqDl9ZvCrMqTDD6dNIWOYAvni/4a556sFsoeBBAu10peBskCQE6S
 561 cB86cuJagLLVMh/dySaI6ahNoFFSpY+ZuQUxfInYUR2Q+DFtbGqyw8JwtHaRBthZ
 562 WqU1XZVGg2KooISsxIsCQQD1PS7//xHLumBb0jnpL7n6W8gmiTyzblT+0otaCisP
 563 fN6rTlwV1o8VsOUAz0rmKO5RArCbkmb01WtMgPCDBYkk
 564 -----END RSA PRIVATE KEY-----
 565 """, # 0
 566 """-----BEGIN CERTIFICATE-----
 567 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 568 aW5neTAeFw0wODA3MjUyMjQyMDVaFw0wOTA3MjUyMjQyMDVaMBcxFTATBgNVBAMU
 569 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAs9CALdmW
 570 kJ6r0KPSLdGCA8rzQKxWayrMckT22ZtbRv3aw6VA96dWclpY+T2maV0LrAzmMSL8
 571 n61ydJHM33iYDOyWbwHWN45XCjY/e20PL54XUl/DmbBHEhQVQLIfCldcRcnWEfoO
 572 iOhDJfWpDO1dmP/aOYLdkZCZvBtPAfyUqRcCAwEAATANBgkqhkiG9w0BAQQFAAOB
 573 gQAN9eaCREkzzk4yPIaWYkWHg3Igs1vnOR/iDw3OjyxO/xJFP2lkA2WtrwL2RTRq
 574 dxA8gwdPyrWgdiZElwZH8mzTJ4OdUXLSMclLOg9kvH6gtSvhLztfEDwDP1wRhikh
 575 OeWWu2GIC+uqFCI1ftoGgU+aIa6yrHswf66rrQvBSSvJPQ==
 576 -----END CERTIFICATE-----
 577 -----BEGIN RSA PRIVATE KEY-----
 578 MIICXQIBAAKBgQCz0IAt2ZaQnqvQo9It0YIDyvNArFZrKsxyRPbZm1tG/drDpUD3
 579 p1ZyWlj5PaZpXQusDOYxIvyfrXJ0kczfeJgM7JZvAdY3jlcKNj97bQ8vnhdSX8OZ
 580 sEcSFBVAsh8KV1xFydYR+g6I6EMl9akM7V2Y/9o5gt2RkJm8G08B/JSpFwIDAQAB
 581 AoGBAIUy5zCPpSP+FeJY6CG+t6Pdm/IFd4KtUoM3KPCrT6M3+uzApm6Ny9Crsor2
 582 qyYTocjSSVaOxzn1fvpw4qWLrH1veUf8ozMs8Z0VuPHD1GYUGjOXaBPXb5o1fQL9
 583 h7pS5/HrDDPN6wwDNTsxRf/fP58CnfwQUhwdoxcx8TnVmDQxAkEA6N3jBXt/Lh0z
 584 UbXHhv3QBOcqLZA2I4tY7wQzvUvKvVmCJoW1tfhBdYQWeQv0jzjL5PzrrNY8hC4l
 585 8+sFM3h5TwJBAMWtbFIEZfRSG1JhHK3evYHDTZnr/j+CdoWuhzP5RkjkIKsiLEH7
 586 2ZhA7CdFQLZF14oXy+g1uVCzzfB2WELtUbkCQQDKrb1XWzrBlzbAipfkXWs9qTmj
 587 uJ32Z+V6+0xRGPOXxJ0sDDqw7CeFMfchWg98zLFiV+SEZV78qPHtkAPR3ayvAkB+
 588 hUMhM4N13t9x2IoclsXAOhp++9bdG0l0woHyuAdOPATUw6iECwf4NQVxFRgYEZek
 589 4Ro3Y7taddrHn1dabr6xAkAic47OoLOROYLpljmJJO0eRe3Z5IFe+0D2LfhAW3LQ
 590 JU+oGq5pCjfnoaDElRRZn0+GmunnWeQEYKoflTi/lI9d
 591 -----END RSA PRIVATE KEY-----
 592 """, # 1
 593 """-----BEGIN CERTIFICATE-----
 594 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 595 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 596 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAsxG7LTrz
 597 DF+9wegOR/BRJhjSumPUbYQnNAUKtPraFsGjAJILP44AHdnHt1MONLgTeX1ynapo
 598 q6O/q5cdKtBB7uEh7FpkLCCwpZt/m0y79cynn8AmWoQVgl8oS0567UmPeJnTzFPv
 599 dmT5dlaQALeX5YGceAsEvhmAsdOMttaor38CAwEAATANBgkqhkiG9w0BAQQFAAOB
 600 gQA345rxotfvh2kfgrmRzAyGewVBV4r23Go30GSZir8X2GoH3qKNwO4SekAohuSw
 601 AiXzLUbwIdSRSqaLFxSC7Duqc9eIeFDAWjeEmpfFLBNiw3K8SLA00QrHCUXnECTD
 602 b/Kk6OGuvPOiuuONVjEuEcRdCH3/Li30D0AhJaMynjhQJQ==
 603 -----END CERTIFICATE-----
 604 -----BEGIN RSA PRIVATE KEY-----
 605 MIICXQIBAAKBgQCzEbstOvMMX73B6A5H8FEmGNK6Y9RthCc0BQq0+toWwaMAkgs/
 606 jgAd2ce3Uw40uBN5fXKdqmiro7+rlx0q0EHu4SHsWmQsILClm3+bTLv1zKefwCZa
 607 hBWCXyhLTnrtSY94mdPMU+92ZPl2VpAAt5flgZx4CwS+GYCx04y21qivfwIDAQAB
 608 AoGBAIlhFg/aRPL+VM9539LzHN60dp8GzceDdqwjHhbAySZiQlLCuJx2rcI4/U65
 609 CpIJku9G/fLV9N2RkA/trDPXeGyqCTJfnNzyZcvvMscRMFqSGyc21Y0a+GS8bIxt
 610 1R2B18epSVMsWSWWMypeEgsfv29LV7oSWG8UKaqQ9+0h63DhAkEA4i2L/rori/Fb
 611 wpIBfA+xbXL/GmWR7xPW+3nG3LdLQpVzxz4rIsmtO9hIXzvYpcufQbwgVACyMmRf
 612 TMABeSDM7wJBAMquEdTaVXjGfH0EJ7z95Ys2rYTiCXjBfyEOi6RXXReqV9SXNKlN
 613 aKsO22zYecpkAjY1EdUdXWP/mNVEybjpZnECQQCcuh0JPS5RwcTo9c2rjyBOjGIz
 614 g3B1b5UIG2FurmCrWe6pgO3ZJFEzZ/L2cvz0Hj5UCa2JKBZTDvRutZoPumfnAkAb
 615 nSW+y1Rz1Q8m9Ub4v9rjYbq4bRd/RVWtyk6KQIDldYbr5wH8wxgsniSVKtVFFuUa
 616 P5bDY3HS6wMGo42cTOhxAkAcdweQSQ3j7mfc5vh71HeAC1v/VAKGehGOUdeEIQNl
 617 Sb2WuzpZkbfsrVzW6MdlgY6eE7ufRswhDPLWPC8MP0d1
 618 -----END RSA PRIVATE KEY-----
 619 """, # 2
 620 """-----BEGIN CERTIFICATE-----
 621 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 622 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 623 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAxnH+pbOS
 624 qlJlsHpKUQtV0oN1Mv+ESG+yUDxStFFGjkJv/UIRzpxqFqY/6nJ3D03kZsDdcXyi
 625 CfV9hPYQaVNMn6z+puPmIagfBQ0aOyuI+nUhCttZIYD9071BjW5bCMX5NZWL/CZm
 626 E0HdAZ77H6UrRckJ7VR8wAFpihBxD5WliZcCAwEAATANBgkqhkiG9w0BAQQFAAOB
 627 gQAwXqY1Sjvp9JSTHKklu7s0T6YmH/BKSXrHpS2xO69svK+ze5/+5td3jPn4Qe50
 628 xwRNZSFmSLuJLfCO32QJSJTB7Vs5D3dNTZ2i8umsaodm97t8hit7L75nXRGHKH//
 629 xDVWAFB9sSgCQyPMRkL4wB4YSfRhoSKVwMvaz+XRZDUU0A==
 630 -----END CERTIFICATE-----
 631 -----BEGIN RSA PRIVATE KEY-----
 632 MIICXAIBAAKBgQDGcf6ls5KqUmWwekpRC1XSg3Uy/4RIb7JQPFK0UUaOQm/9QhHO
 633 nGoWpj/qcncPTeRmwN1xfKIJ9X2E9hBpU0yfrP6m4+YhqB8FDRo7K4j6dSEK21kh
 634 gP3TvUGNblsIxfk1lYv8JmYTQd0BnvsfpStFyQntVHzAAWmKEHEPlaWJlwIDAQAB
 635 AoGAdHNMlXwtItm7ZrY8ihZ2xFP0IHsk60TwhHkBp2LSXoTKJvnwbSgIcUYZ18BX
 636 8Zkp4MpoqEIU7HcssyuaMdR572huV2w0D/2gYJQLQ5JapaR3hMox3YG4wjXasN1U
 637 1iZt7JkhKlOy+ElL5T9mKTE1jDsX2RAv4WALzMpYFo7vs4ECQQDxqrPaqRQ5uYS/
 638 ejmIk05nM3Q1zmoLtMDrfRqrjBhaf/W3hqGihiqN2kL3PIIYcxSRWiyNlYXjElsR
 639 2sllBTe3AkEA0jcMHVThwKt1+Ce5VcE7N6hFfbsgISTjfJ+Q3K2NkvJkmtE8ZRX5
 640 XprssnPN8owkfF5yuKbcSZL3uvaaSGN9IQJAfTVnN9wwOXQwHhDSbDt9/KRBCnum
 641 n+gHqDrKLaVJHOJ9SZf8eLswoww5c+UqtkYxmtlwie61Tp+9BXQosilQ4wJBAIZ1
 642 XVNZmriBM4jR59L5MOZtxF0ilu98R+HLsn3kqLyIPF9mXCoQPxwLHkEan213xFKk
 643 mt6PJDIPRlOZLqAEuuECQFQMCrn0VUwPg8E40pxMwgMETvVflPs/oZK1Iu+b7+WY
 644 vBptAyhMu31fHQFnJpiUOyHqSZnOZyEn1Qu2lszNvUg=
 645 -----END RSA PRIVATE KEY-----
 646 """, # 3
 647 """-----BEGIN CERTIFICATE-----
 648 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 649 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 650 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAnjiOwipn
 651 jigDuNMfNG/tBJhPwYUHhSbQdvrTubhsxw1oOq5XpNqUwRtC8hktOKM3hghyqExP
 652 62EOi0aJBkRhtwtPSLBCINptArZLfkog/nTIqVv4eLEzJ19nTi/llHHWKcgA6XTI
 653 sU/snUhGlySA3RpETvXqIJTauQRZz0kToSUCAwEAATANBgkqhkiG9w0BAQQFAAOB
 654 gQCQ+u/CsX5WC5m0cLrpyIS6qZa62lrB3mj9H1aIQhisT5kRsMz3FJ1aOaS8zPRz
 655 w0jhyRmamCcSsWf5WK539iOtsXbKMdAyjNtkQO3g+fnsLgmznAjjst24jfr+XU59
 656 0amiy1U6TY93gtEBZHtiLldPdUMsTuFbBlqbcMBQ50x9rA==
 657 -----END CERTIFICATE-----
 658 -----BEGIN RSA PRIVATE KEY-----
 659 MIICXAIBAAKBgQCeOI7CKmeOKAO40x80b+0EmE/BhQeFJtB2+tO5uGzHDWg6rlek
 660 2pTBG0LyGS04ozeGCHKoTE/rYQ6LRokGRGG3C09IsEIg2m0Ctkt+SiD+dMipW/h4
 661 sTMnX2dOL+WUcdYpyADpdMixT+ydSEaXJIDdGkRO9eoglNq5BFnPSROhJQIDAQAB
 662 AoGAAPrst3s3xQOucjismtCOsVaYN+SxFTwWUoZfRWlFEz6cBLELzfOktEWM9p79
 663 TrqEH4px22UNobGqO2amdql5yXwEFVhYQkRB8uDA8uVaqpL8NLWTGPRXxZ2DSU+n
 664 7/FLf/TWT3ti/ZtXaPVRj6E2/Mq9AVEVOjUYzkNjM02OxcECQQDKEqmPbdZq2URU
 665 7RbUxkq5aTp8nzAgbpUsgBGQ9PDAymhj60BDEP0q28Ssa7tU70pRnQ3AZs9txgmL
 666 kK2g97FNAkEAyHH9cIb6qXOAJPIr/xamFGr5uuYw9TJPz/hfVkVimW/aZnBB+e6Q
 667 oALJBDKJWeYPzdNbouJYg8MeU0qWdZ5DOQJADUk+1sxc/bd9U6wnBSRog1pU2x7I
 668 VkmPC1b8ULCaJ8LnLDKqjf5O9wNuIfwPXB1DoKwX3F+mIcyUkhWYJO5EPQJAUj5D
 669 KMqZSrGzYHVlC/M1Daee88rDR7fu+3wDUhiCDkbQq7tftrbl7GF4LRq3NIWq8l7I
 670 eJq6isWiSbaO6Y+YMQJBAJFBpVhlY5Px2BX5+Hsfq6dSP3sVVc0eHkdsoZFFxq37
 671 fksL/q2vlPczvBihgcxt+UzW/UrNkelOuX3i57PDvFs=
 672 -----END RSA PRIVATE KEY-----
 673 """, # 4
 674 """-----BEGIN CERTIFICATE-----
 675 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 676 aW5neTAeFw0wODA3MjUyMjQyMDZaFw0wOTA3MjUyMjQyMDZaMBcxFTATBgNVBAMU
 677 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAsCQuudDF
 678 zgmY5tDpT0TkUo8fpJ5JcvgCkLFpSDD8REpXhLFkHWhTmTj3CAxfv4lA3sQzHZxe
 679 4S9YCb5c/VTbFEdgwc/wlxMmJiz2jYghdmWPBb8pBEk31YihIhC+u4kex6gJBH5y
 680 ixiZ3PPRRMaOBBo+ZfM50XIyWbFOOM/7FwcCAwEAATANBgkqhkiG9w0BAQQFAAOB
 681 gQB4cFURaiiUx6n8eS4j4Vxrii5PtsaNEI4acANFSYknGd0xTP4vnmoivNmo5fWE
 682 Q4hYtGezNu4a9MnNhcQmI20KzXmvhLJtkwWCgGOVJtMem8hDWXSALV1Ih8hmVkGS
 683 CI1elfr9eyguunGp9eMMQfKhWH52WHFA0NYa0Kpv5BY33A==
 684 -----END CERTIFICATE-----
 685 -----BEGIN RSA PRIVATE KEY-----
 686 MIICWwIBAAKBgQCwJC650MXOCZjm0OlPRORSjx+knkly+AKQsWlIMPxESleEsWQd
 687 aFOZOPcIDF+/iUDexDMdnF7hL1gJvlz9VNsUR2DBz/CXEyYmLPaNiCF2ZY8FvykE
 688 STfViKEiEL67iR7HqAkEfnKLGJnc89FExo4EGj5l8znRcjJZsU44z/sXBwIDAQAB
 689 AoGABA7xXKqoxBSIh1js5zypHhXaHsre2l1Igdj0mgs25MPpvE7yBZNvyan8Vx0h
 690 36Hj8r4Gh3og3YNfvem67sNTwNwONY0ep+Xho/3vG0jFATGduSXdcT04DusgZNqg
 691 UJqW75cqxrD6o/nya5wUoN9NL5pcd5AgVMdOYvJGbrwQuaECQQDiCs/5dsUkUkeC
 692 Tlur1wh0wJpW4Y2ctO3ncRdnAoAA9y8dELHXMqwKE4HtlyzHY7Bxds/BDh373EVK
 693 rsdl+v9JAkEAx3xTmsOQvWa1tf/O30sdItVpGogKDvYqkLCNthUzPaL85BWB03E2
 694 xunHcVVlqAOE5tFuw0/UEyEkOaGlNTJTzwJAPIVel9FoCUiKYuYt/z1swy3KZRaw
 695 /tMmm4AZHvh5Y0jLcYHFy/OCQpRkhkOitqQHWunPyEXKW2PnnY5cTv68GQJAHG7H
 696 B88KCUTjb25nkQIGxBlA4swzCtDhXkAb4rEA3a8mdmfuWjHPyeg2ShwO4jSmM7P0
 697 Iph1NMjLff9hKcTjlwJARpItOFkYEdtSODC7FMm7KRKQnNB27gFAizsOYWD4D2b7
 698 w1FTEZ/kSA9wSNhyNGt7dgUo6zFhm2u973HBCUb3dg==
 699 -----END RSA PRIVATE KEY-----
 700 """, # 5
 701 """-----BEGIN CERTIFICATE-----
 702 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 703 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 704 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAvhTRj1dA
 705 NOfse/UBeTfMekZKxZHsNPr+qBYaveWAHDded/BMyMgaMV2n6HQdiDaRjJkzjHCF
 706 3xBtpIJeEGUqfrF0ob8BIZXy3qk68eX/0CVUbgmjSBN44ahlo63NshyXmZtEAkRV
 707 VE/+cRKw3N2wtuTed5xwfNcL6dg4KTOEYEkCAwEAATANBgkqhkiG9w0BAQQFAAOB
 708 gQCN+CLuVwLeWjSdVbdizYyrOVckqtwiIHG9BbGMlcIdm0qpvD7V7/sN2csk5LaT
 709 BNiHi1t5628/4UHqqodYmFw8ri8ItFwB+MmTJi11CX6dIP9OUhS0qO8Z/BKtot7H
 710 j04oNwl+WqZZfHIYwTIEL0HBn60nOvCQPDtnWG2BhpUxMA==
 711 -----END CERTIFICATE-----
 712 -----BEGIN RSA PRIVATE KEY-----
 713 MIICXQIBAAKBgQC+FNGPV0A05+x79QF5N8x6RkrFkew0+v6oFhq95YAcN1538EzI
 714 yBoxXafodB2INpGMmTOMcIXfEG2kgl4QZSp+sXShvwEhlfLeqTrx5f/QJVRuCaNI
 715 E3jhqGWjrc2yHJeZm0QCRFVUT/5xErDc3bC25N53nHB81wvp2DgpM4RgSQIDAQAB
 716 AoGALl2BqIdN4Bnac3oV++2CcSkIQB0SEvJOf820hDGhCEDxSCxTbn5w9S21MVxx
 717 f7Jf2n3cNxuTbA/jzscGDtW+gXCs+WAbAr5aOqHLUPGEobhKQrQT2hrxQHyv3UFp
 718 0tIl9eXFknOyVAaUJ3athK5tyjSiCZQQHLGzeLaDSKVAPqECQQD1GK7DkTcLaSvw
 719 hoTJ3dBK3JoKT2HHLitfEE0QV58mkqFMjofpe+nyeKWvEb/oB4WBp/cfTvtf7DJK
 720 zl1OSf11AkEAxomWmJeub0xpqksCmnVI1Jt1mvmcE4xpIcXq8sxzLHRc2QOv0kTw
 721 IcFl4QcN6EQBmE+8kl7Tx8SPAVKfJMoZBQJAGsUFYYrczjxAdlba7glyFJsfn/yn
 722 m0+poQpwwFYxpc7iGzB+G7xTAw62WfbAVSFtLYog7aR8xC9SFuWPP1vJeQJBAILo
 723 xBj3ovgWTXIRJbVM8mnl28UFI0msgsHXK9VOw/6i93nMuYkPFbtcN14KdbwZ42dX
 724 5EIrLr+BNr4riW4LqDUCQQCbsEEpTmj3upKUOONPt+6CH/OOMjazUzYHZ/3ORHGp
 725 Q3Wt+I4IrR/OsiACSIQAhS4kBfk/LGggnj56DrWt+oBl
 726 -----END RSA PRIVATE KEY-----
 727 """, #6
 728 """-----BEGIN CERTIFICATE-----
 729 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 730 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 731 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAtKhx6sEA
 732 jn6HWc6T2klwlPn0quyHtATIw8V3ezP46v6g2rRS7dTywo4GTP4vX58l+sC9z9Je
 733 qhQ1rWSwMK4FmnDMZCu7AVO7oMIXpXdSz7l0bgCnNjvbpkA2pOfbB1Z8oj8iebff
 734 J33ID5DdkmCzqYVtKpII1o/5z7Jo292JYy8CAwEAATANBgkqhkiG9w0BAQQFAAOB
 735 gQA0PYMA07wo9kEH4fv9TCfo+zz42Px6lUxrQBPxBvDiGYhk2kME/wX0IcoZPKTV
 736 WyBGmDAYWvFaHWbrbbTOfzlLWfYrDD913hCi9cO8iF8oBqRjIlkKcxAoe7vVg5Az
 737 ydVcrY+zqULJovWwyNmH1QNIQfMat0rj7fylwjiS1y/YsA==
 738 -----END CERTIFICATE-----
 739 -----BEGIN RSA PRIVATE KEY-----
 740 MIICXAIBAAKBgQC0qHHqwQCOfodZzpPaSXCU+fSq7Ie0BMjDxXd7M/jq/qDatFLt
 741 1PLCjgZM/i9fnyX6wL3P0l6qFDWtZLAwrgWacMxkK7sBU7ugwheld1LPuXRuAKc2
 742 O9umQDak59sHVnyiPyJ5t98nfcgPkN2SYLOphW0qkgjWj/nPsmjb3YljLwIDAQAB
 743 AoGAU4CYRv22mCZ7wVLunDLdyr5ODMMPZnHfqj2XoGbBYz0WdIBs5GlNXAfxeZzz
 744 oKsbDvAPzANcphh5RxAHMDj/dT8rZOez+eJrs1GEV+crl1T9p83iUkAuOJFtgUgf
 745 TtQBL9vHaj7DfvCEXcBPmN/teDFmAAOyUNbtuhTkRa3PbuECQQDwaqZ45Kr0natH
 746 V312dqlf9ms8I6e873pAu+RvA3BAWczk65eGcRjEBxVpTvNEcYKFrV8O5ZYtolrr
 747 VJl97AfdAkEAwF4w4KJ32fLPVoPnrYlgLw86NejMpAkixblm8cn51avPQmwbtahb
 748 BZUuca22IpgDpjeEk5SpEMixKe/UjzxMewJBALy4q2cY8U3F+u6sshLtAPYQZIs3
 749 3fNE9W2dUKsIQvRwyZMlkLN7UhqHCPq6e+HNTM0MlCMIfAPkf4Rdy4N6ZY0CQCKE
 750 BAMaQ6TwgzFDw5sIjiCDe+9WUPmRxhJyHL1/fvtOs4Z4fVRP290ZklbFU2vLmMQH
 751 LBuKzfb7+4XJyXrV1+cCQBqfPFQQZLr5UgccABYQ2jnWVbJPISJ5h2b0cwXt+pz/
 752 8ODEYLjqWr9K8dtbgwdpzwbkaGhQYpyvsguMvNPMohs=
 753 -----END RSA PRIVATE KEY-----
 754 """, #7
 755 """-----BEGIN CERTIFICATE-----
 756 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 757 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 758 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAnBfNHycn
 759 5RnYzDN4EWTk2q1BBxA6ZYtlG1WPkj5iKeaYKzUk58zBL7mNOA0ucq+yTwh9C4IC
 760 EutWPaKBSKY5XI+Rdebh+Efq+urtOLgfJHlfcCraEx7hYN+tqqMVgEgnO/MqIsn1
 761 I1Fvnp89mSYbQ9tmvhSH4Hm+nbeK6iL2tIsCAwEAATANBgkqhkiG9w0BAQQFAAOB
 762 gQBt9zxfsKWoyyV764rRb6XThuTDMNSDaVofqePEWjudAbDu6tp0pHcrL0XpIrnT
 763 3iPgD47pdlwQNbGJ7xXwZu2QTOq+Lv62E6PCL8FljDVoYqR3WwJFFUigNvBT2Zzu
 764 Pxx7KUfOlm/M4XUSMu31sNJ0kQniBwpkW43YmHVNFb/R7g==
 765 -----END CERTIFICATE-----
 766 -----BEGIN RSA PRIVATE KEY-----
 767 MIICXQIBAAKBgQCcF80fJyflGdjMM3gRZOTarUEHEDpli2UbVY+SPmIp5pgrNSTn
 768 zMEvuY04DS5yr7JPCH0LggIS61Y9ooFIpjlcj5F15uH4R+r66u04uB8keV9wKtoT
 769 HuFg362qoxWASCc78yoiyfUjUW+enz2ZJhtD22a+FIfgeb6dt4rqIva0iwIDAQAB
 770 AoGBAIHstcnWd7iUeQYPWUNxLaRvTY8pjNH04yWLZEOgNWkXDVX5mExw++RTmB4t
 771 qpm/cLWkJSEtB7jjthb7ao0j/t2ljqfr6kAbClDv3zByAEDhOu8xB/5ne6Ioo+k2
 772 dygC+GcVcobhv8qRU+z0fpeXSP8yS1bQQHOaa17bSGsncvHRAkEAzwsn8jBTOqaW
 773 6Iymvr7Aql++LiwEBrqMMRVyBZlkux4hiKa2P7XXEL6/mOPR0aI2LuCqE2COrO7R
 774 0wAFZ54bjwJBAMEAe6cs0zI3p3STHwA3LoSZB81lzLhGUnYBvOq1yoDSlJCOYpld
 775 YM1y3eC0vwiOnEu3GG1bhkW+h6Kx0I/qyUUCQBiH9NqwORxI4rZ4+8S76y4EnA7y
 776 biOx9KxYIyNgslutTUHYpt1TmUDFqQPfclvJQWw6eExFc4Iv5bJ/XSSSyicCQGyY
 777 5PrwEfYTsrm5fpwUcKxTnzxHp6WYjBWybKZ0m/lYhBfCxmAdVrbDh21Exqj99Zv0
 778 7l26PhdIWfGFtCEGrzECQQCtPyXa3ostSceR7zEKxyn9QBCNXKARfNNTBja6+VRE
 779 qDC6jLqzu/SoOYaqa13QzCsttO2iZk8Ygfy3Yz0n37GE
 780 -----END RSA PRIVATE KEY-----
 781 """, #8
 782 """-----BEGIN CERTIFICATE-----
 783 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 784 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 785 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA4mnLf+x0
 786 CWKDKP5PLZ87t2ReSDE/J5QoI5VhE0bXaahdhPrQTC2wvOpT+N9nzEpI9ASh/ejV
 787 kYGlc03nNKRL7zyVM1UyGduEwsRssFMqfyJhI1p+VmxDMWNplex7mIAheAdskPj3
 788 pwi2CP4VIMjOj368AXvXItPzeCfAhYhEVaMCAwEAATANBgkqhkiG9w0BAQQFAAOB
 789 gQAEzmwq5JFI5Z0dX20m9rq7NKgwRyAH3h5aE8bdjO8nEc69qscfDRx79Lws3kK8
 790 A0LG0DhxKB8cTNu3u+jy81tjcC4pLNQ5IKap9ksmP7RtIHfTA55G8M3fPl2ZgDYQ
 791 ZzsWAZvTNXd/eme0SgOzD10rfntA6ZIgJTWHx3E0RkdwKw==
 792 -----END CERTIFICATE-----
 793 -----BEGIN RSA PRIVATE KEY-----
 794 MIICXQIBAAKBgQDiact/7HQJYoMo/k8tnzu3ZF5IMT8nlCgjlWETRtdpqF2E+tBM
 795 LbC86lP432fMSkj0BKH96NWRgaVzTec0pEvvPJUzVTIZ24TCxGywUyp/ImEjWn5W
 796 bEMxY2mV7HuYgCF4B2yQ+PenCLYI/hUgyM6PfrwBe9ci0/N4J8CFiERVowIDAQAB
 797 AoGAQYTl+8XcKl8Un4dAOG6M5FwqIHAH25c3Klzu85obehrbvUCriG/sZi7VT/6u
 798 VeLlS6APlJ+NNgczbrOLhaNJyYzjICSt8BI96PldFUzCEkVlgE+29pO7RNoZmDYB
 799 dSGyIDrWdVYfdzpir6kC0KDcrpA16Sc+/bK6Q8ALLRpC7QECQQD7F7fhIQ03CKSk
 800 lS4mgDuBQrB/52jXgBumtjp71ANNeaWR6+06KDPTLysM+olsh97Q7YOGORbrBnBg
 801 Y2HPnOgjAkEA5taZaMfdFa8V1SPcX7mgCLykYIujqss0AmauZN/24oLdNE8HtTBF
 802 OLaxE6PnQ0JWfx9KGIy3E0V3aFk5FWb0gQJBAO4KFEaXgOG1jfCBhNj3JHJseMso
 803 5Nm4F366r0MJQYBHXNGzqphB2K/Svat2MKX1QSUspk2u/a0d05dtYCLki6UCQHWS
 804 sChyQ+UbfF9HGKOZBC3vBzo1ZXNEdIUUj5bJjBHq3YgbCK38nAU66A482TmkvDGb
 805 Wj4OzeB+7Ua0yyJfggECQQDVlAa8HqdAcrbEwI/YfPydFsavBJ0KtcIGK2owQ+dk
 806 dhlDnpXDud/AtX4Ft2LaquQ15fteRrYjjwI9SFGytjtp
 807 -----END RSA PRIVATE KEY-----
 808 """, #9
 809 """-----BEGIN CERTIFICATE-----
 810 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 811 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 812 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAueLfowPT
 813 kXXtHeU2FZSz2mJhHmjqeyI1oMoyyggonccx65vMxaRfljnz2dOjVVYpCOn/LrdP
 814 wVxHO8KNDsmQeWPRjnnBa2dFqqOnp/8gEJFJBW7K/gI9se6o+xe9QIWBq6d/fKVR
 815 BURJe5TycLogzZuxQn1xHHILa3XleYuHAbMCAwEAATANBgkqhkiG9w0BAQQFAAOB
 816 gQBEC1lfC3XK0galQC96B7faLpnQmhn5lX2FUUoFIQQtBTetoE+gTqnLSOIZcOK4
 817 pkT3YvxUvgOV0LOLClryo2IknMMGWRSAcXtVUBBLRHVTSSuVUyyLr5kdRU7B4E+l
 818 OU0j8Md/dzlkm//K1bzLyUaPq204ofH8su2IEX4b3IGmAQ==
 819 -----END CERTIFICATE-----
 820 -----BEGIN RSA PRIVATE KEY-----
 821 MIICWwIBAAKBgQC54t+jA9ORde0d5TYVlLPaYmEeaOp7IjWgyjLKCCidxzHrm8zF
 822 pF+WOfPZ06NVVikI6f8ut0/BXEc7wo0OyZB5Y9GOecFrZ0Wqo6en/yAQkUkFbsr+
 823 Aj2x7qj7F71AhYGrp398pVEFREl7lPJwuiDNm7FCfXEccgtrdeV5i4cBswIDAQAB
 824 AoGAO4PnJHNaLs16AMNdgKVevEIZZDolMQ1v7C4w+ryH/JRFaHE2q+UH8bpWV9zK
 825 A82VT9RTrqpkb71S1VBiB2UDyz263XdAI/N2HcIVMmfKb72oV4gCI1KOv4DfFwZv
 826 tVVcIdVEDBOZ2TgqK4opGOgWMDqgIAl2z3PbsIoNylZHEJECQQDtQeJFhEJGH4Qz
 827 BGpdND0j2nnnJyhOFHJqikJNdul3uBwmxTK8FPEUUH/rtpyUan3VMOyDx3kX4OQg
 828 GDNSb32rAkEAyJIZIJ0EMRHVedyWsfqR0zTGKRQ+qsc3sCfyUhFksWms9jsSS0DT
 829 tVeTdC3F6EIAdpKOGhSyfBTU4jxwbFc0GQJADI4L9znEeAl66Wg2aLA2/Aq3oK/F
 830 xjv2wgSG9apxOFCZzMNqp+FD0Jth6YtEReZMuldYbLDFi6nu6HPfY2Fa+QJAdpm1
 831 lAxk6yMxiZK/5VRWoH6HYske2Vtd+aNVbePtF992ME/z3F3kEkpL3hom+dT1cyfs
 832 MU3l0Ot8ip7Ul6vlGQJAegNzpcfl2GFSdWQMxQ+nN3woKnPqpR1M3jgnqvo7L4Xe
 833 JW3vRxvfdrUuzdlvZ/Pbsu/vOd+cuIa4h0yD5q3N+g==
 834 -----END RSA PRIVATE KEY-----
 835 """, #10
 836 """-----BEGIN CERTIFICATE-----
 837 MIIBnjCCAQcCAgCEMA0GCSqGSIb3DQEBBAUAMBcxFTATBgNVBAMUDG5ld3BiX3Ro
 838 aW5neTAeFw0wODA3MjUyMjQ3NThaFw0wOTA3MjUyMjQ3NThaMBcxFTATBgNVBAMU
 839 DG5ld3BiX3RoaW5neTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAruBhwk+J
 840 XdlwfKXXN8K+43JyEYCV7Fp7ZiES4t4AEJuQuBqJVMxpzeZzu2t/vVb59ThaxxtY
 841 NGD3Xy6Og5dTv//ztWng8P7HwwvfbrUICU6zo6JAhg7kfaNa116krCYOkC/cdJWt
 842 o5W+zsDmI1jUVGH0D73h29atc1gn6wLpAsMCAwEAATANBgkqhkiG9w0BAQQFAAOB
 843 gQAEJ/ITGJ9lK/rk0yHcenW8SHsaSTlZMuJ4yEiIgrJ2t71Rd6mtCC/ljx9USvvK
 844 bF500whTiZlnWgKi02boBEKa44z/DytF6pljeNPefBQSqZyUByGEb/8Mn58Idyls
 845 q4/d9iKXMPvbpQdcesOzgOffFZevLQSWyPRaIdYBOOiYUA==
 846 -----END CERTIFICATE-----
 847 -----BEGIN RSA PRIVATE KEY-----
 848 MIICXQIBAAKBgQCu4GHCT4ld2XB8pdc3wr7jcnIRgJXsWntmIRLi3gAQm5C4GolU
 849 zGnN5nO7a3+9Vvn1OFrHG1g0YPdfLo6Dl1O///O1aeDw/sfDC99utQgJTrOjokCG
 850 DuR9o1rXXqSsJg6QL9x0la2jlb7OwOYjWNRUYfQPveHb1q1zWCfrAukCwwIDAQAB
 851 AoGAcZAXC/dYrlBpIxkTRQu7qLqGZuVI9t7fabgqqpceFargdR4Odrn0L5jrKRer
 852 MYrM8bjyAoC4a/NYUUBLnhrkcCQWO9q5fSQuFKFVWHY53SM63Qdqk8Y9Fmy/h/4c
 853 UtwZ5BWkUWItvnTMgb9bFcvSiIhEcNQauypnMpgNknopu7kCQQDlSQT10LkX2IGT
 854 bTUhPcManx92gucaKsPONKq2mP+1sIciThevRTZWZsxyIuoBBY43NcKKi8NlZCtj
 855 hhSbtzYdAkEAw0B93CXfso8g2QIMj/HJJz/wNTLtg+rriXp6jh5HWe6lKWRVrce+
 856 1w8Qz6OI/ZP6xuQ9HNeZxJ/W6rZPW6BGXwJAHcTuRPA1p/fvUvHh7Q/0zfcNAbkb
 857 QlV9GL/TzmNtB+0EjpqvDo2g8XTlZIhN85YCEf8D5DMjSn3H+GMHN/SArQJBAJlW
 858 MIGPjNoh5V4Hae4xqBOW9wIQeM880rUo5s5toQNTk4mqLk9Hquwh/MXUXGUora08
 859 2XGpMC1midXSTwhaGmkCQQCdivptFEYl33PrVbxY9nzHynpp4Mi89vQF0cjCmaYY
 860 N8L+bvLd4BU9g6hRS8b59lQ6GNjryx2bUnCVtLcey4Jd
 861 -----END RSA PRIVATE KEY-----
 862 """, #11
 863 ]
 864
 865 # To disable the pre-computed tub certs, uncomment this line.
 866 #SYSTEM_TEST_CERTS = []
 867
 868 class ShareManglingMixin(SystemTestMixin):
 869
 870     def find_shares(self, unused=None):
 871         """Locate shares on disk. Returns a dict that maps
 872         (clientnum,sharenum) to a string that contains the share container
 873         (copied directly from the disk, containing leases etc). You can
 874         modify this dict and then call replace_shares() to modify the shares.
 875         """
 876         shares = {} # k: (i, sharenum), v: data
 877
 878         for i, c in enumerate(self.clients):
 879             sharedir = c.getServiceNamed("storage").sharedir
 880             for (dirp, dirns, fns) in os.walk(sharedir):
 881                 for fn in fns:
 882                     try:
 883                         sharenum = int(fn)
 884                     except TypeError:
 885                         # Whoops, I guess that's not a share file then.
 886                         pass
 887                     else:
 888                         data = open(os.path.join(sharedir, dirp, fn), "r").read()
 889                         shares[(i, sharenum)] = data
 890
 891         return shares
 892
 893     def replace_shares(self, newshares, storage_index):
 894         """Replace shares on disk. Takes a dictionary in the same form
 895         as find_shares() returns."""
 896
 897         for i, c in enumerate(self.clients):
 898             sharedir = c.getServiceNamed("storage").sharedir
 899             for (dirp, dirns, fns) in os.walk(sharedir):
 900                 for fn in fns:
 901                     try:
 902                         sharenum = int(fn)
 903                     except TypeError:
 904                         # Whoops, I guess that's not a share file then.
 905                         pass
 906                     else:
 907                         pathtosharefile = os.path.join(sharedir, dirp, fn)
 908                         os.unlink(pathtosharefile)
 909             for ((clientnum, sharenum), newdata) in newshares.iteritems():
 910                 if clientnum == i:
 911                     fullsharedirp=os.path.join(sharedir, storage_index_to_dir(storage_index))
 912                     fileutil.make_dirs(fullsharedirp)
 913                     wf = open(os.path.join(fullsharedirp, str(sharenum)), "w")
 914                     wf.write(newdata)
 915
 916 class ShouldFailMixin:
 917     def shouldFail(self, expected_failure, which, substring,
 918                    callable, *args, **kwargs):
 919         """Assert that a function call raises some exception. This is a
 920         Deferred-friendly version of TestCase.assertRaises() .
 921
 922         Suppose you want to verify the following function:
 923
 924          def broken(a, b, c):
 925              if a < 0:
 926                  raise TypeError('a must not be negative')
 927              return defer.succeed(b+c)
 928
 929         You can use:
 930             d = self.shouldFail(TypeError, 'test name',
 931                                 'a must not be negative',
 932                                 broken, -4, 5, c=12)
 933         in your test method. The 'test name' string will be included in the
 934         error message, if any, because Deferred chains frequently make it
 935         difficult to tell which assertion was tripped.
 936
 937         The substring= argument, if not None, must appear inside the
 938         stringified Failure, or the test will fail.
 939         """
 940
 941         assert substring is None or isinstance(substring, str)
 942         d = defer.maybeDeferred(callable, *args, **kwargs)
 943         def done(res):
 944             if isinstance(res, failure.Failure):
 945                 res.trap(expected_failure)
 946                 if substring:
 947                     self.failUnless(substring in str(res),
 948                                     "substring '%s' not in '%s'"
 949                                     % (substring, str(res)))
 950             else:
 951                 self.fail("%s was supposed to raise %s, not get '%s'" %
 952                           (which, expected_failure, res))
 953         d.addBoth(done)
 954         return d
 955
 956 class WebErrorMixin:
 957     def explain_web_error(self, f):
 958         # an error on the server side causes the client-side getPage() to
 959         # return a failure(t.web.error.Error), and its str() doesn't show the
 960         # response body, which is where the useful information lives. Attach
 961         # this method as an errback handler, and it will reveal the hidden
 962         # message.
 963         f.trap(WebError)
 964         print "Web Error:", f.value, ":", f.value.response
 965         return f
 966 class ErrorMixin(WebErrorMixin):
 967     def explain_error(self, f):
 968         if f.check(defer.FirstError):
 969             print "First Error:", f.value.subFailure
 970         return f
 971
 972 class MemoryConsumer:
 973     implements(IConsumer)
 974     def __init__(self):
 975         self.chunks = []
 976         self.done = False
 977     def registerProducer(self, p, streaming):
 978         if streaming:
 979             # call resumeProducing once to start things off
 980             p.resumeProducing()
 981         else:
 982             while not self.done:
 983                 p.resumeProducing()
 984     def write(self, data):
 985         self.chunks.append(data)
 986     def unregisterProducer(self):
 987         self.done = True
 988
 989 def download_to_data(n, offset=0, size=None):
 990     d = n.read(MemoryConsumer(), offset, size)
 991     d.addCallback(lambda mc: "".join(mc.chunks))
 992     return d