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