[MERGE] HTTP smart server
Andrew Bennetts
andrew at canonical.com
Fri Sep 29 07:51:53 BST 2006
The attached bundle implements the "smart" protocol from HTTP. It includes the
client, and a testing server. It won't actually be used by "http://" URLs yet.
The basic mechanism is that smart requests are POSTed to base_url +
'.bzr/smart', and replies read from the body of the HTTP response.
Part of this work has been to seperate the protocol from the "medium" (I would
have used the term transport, much like Twisted does, but this term already has
a quite different meaning in bzrlib). The resulting code in smart.py is
generally cleaner and more flexible.
-Andrew.
-------------- next part --------------
# Bazaar revision bundle v0.8
#
# message:
# Clean up SmartServerStreamMedium implementations, including removing unnecessary flushes.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Fri 2006-09-29 16:28:58.743000031 +1000
=== modified file BRANCH.TODO
--- BRANCH.TODO
+++ BRANCH.TODO
@@ -1,3 +1,4 @@
# This file is for listing TODOs for branches that are being worked on.
# It should ALWAYS be empty in the mainline or in integration branches.
#
+
=== modified file bzrlib/builtins.py // last-changed:andrew.bennetts at canonical.
... com-20060928080615-d7bc2a8e393ce711
--- bzrlib/builtins.py
+++ bzrlib/builtins.py
@@ -2853,7 +2853,7 @@
url = 'readonly+' + url
t = get_transport(url)
if inet:
- server = smart.SmartStreamServer(sys.stdin, sys.stdout, t)
+ server = smart.SmartServerPipeStreamMedium(sys.stdin, sys.stdout, t)
elif port is not None:
if ':' in port:
host, port = port.split(':')
=== modified file bzrlib/errors.py // last-changed:andrew.bennetts at canonical.co
... m-20060928040135-c2c58bbb690acc08
--- bzrlib/errors.py
+++ bzrlib/errors.py
@@ -270,6 +270,14 @@
"""Directory not empty: %(path)r%(extra)s"""
+class ReadingCompleted(BzrNewError):
+ """The MediumRequest '%(request)s' has already had finish_reading called upon it - the request has been completed and no more data may be read."""
+
+ def __init__(self, request):
+ BzrNewError.__init__(self)
+ self.request = request
+
+
class ResourceBusy(PathError):
"""Device or resource busy: %(path)r%(extra)s"""
@@ -802,11 +810,21 @@
class NoSuchExportFormat(BzrNewError):
"""Export format %(format)r not supported"""
+
def __init__(self, format):
BzrNewError.__init__(self)
self.format = format
+
+class TooManyConcurrentRequests(BzrNewError):
+ """The medium '%(medium)s' has reached its concurrent request limit. Be sure to finish_writing and finish_reading on the current request that is open."""
+
+ def __init__(self, medium):
+ BzrNewError.__init__(self)
+ self.medium = medium
+
+
class TransportError(BzrNewError):
"""Transport error: %(msg)s %(orig_error)s"""
@@ -903,6 +921,22 @@
" unchanged." % tree.basedir)
+class WritingCompleted(BzrNewError):
+ """The MediumRequest '%(request)s' has already had finish_writing called upon it - accept bytes may not be called anymore."""
+
+ def __init__(self, request):
+ BzrNewError.__init__(self)
+ self.request = request
+
+
+class WritingNotComplete(BzrNewError):
+ """The MediumRequest '%(request)s' has not has finish_writing called upon it - until the write phase is complete no data may be read."""
+
+ def __init__(self, request):
+ BzrNewError.__init__(self)
+ self.request = request
+
+
class CantReprocessAndShowBase(BzrNewError):
"""Can't reprocess and show base.
Reprocessing obscures relationship of conflicting lines to base."""
@@ -923,6 +957,14 @@
self.filename = filename
+class MediumNotConnected(BzrNewError):
+ """The medium '%(medium)s' is not connected."""
+
+ def __init__(self, medium):
+ BzrNewError.__init__(self)
+ self.medium = medium
+
+
class MustUseDecorated(Exception):
"""A decorating function has requested its original command be used.
@@ -1216,6 +1258,14 @@
BadInventoryFormat.__init__(self, msg=msg)
+class NoSmartMedium(BzrNewError):
+ """The transport '%(transport)s' cannot tunnel the smart protocol."""
+
+ def __init__(self, transport):
+ BzrNewError.__init__(self)
+ self.transport = transport
+
+
class NoSmartServer(NotBranchError):
"""No smart server available at %(url)s"""
=== modified file bzrlib/tests/blackbox/test_serve.py // last-changed:andrew.be
... nnetts at canonical.com-20060921091520-673c55c101a86614
--- bzrlib/tests/blackbox/test_serve.py
+++ bzrlib/tests/blackbox/test_serve.py
@@ -30,31 +30,13 @@
from bzrlib.transport import get_transport, smart
-class DoesNotCloseStdOutClient(smart.SmartStreamClient):
- """A client that doesn't close stdout upon disconnect().
-
- We wish to let stdout remain open so that we can see if the server writes
- anything to stdout during its shutdown.
- """
-
- def disconnect(self):
- if self._connected:
- self._connected = False
- # The client's out is the server's in.
- self._out.close()
-
-
class TestBzrServe(TestCaseWithTransport):
- def assertInetServerShutsdownCleanly(self, client, process):
+ def assertInetServerShutsdownCleanly(self, process):
"""Shutdown the server process looking for errors."""
- # Disconnect the client forcefully JUST IN CASE because of __del__'s use
- # in the smart module.
- client.disconnect()
-
- # Shutdown the server: the client should have disconnected cleanly and
- # closed stdin, so the server process should shut itself down.
- self.assertTrue(process.stdin.closed)
+ # Shutdown the server: the server should shut down when it cannot read
+ # from stdin anymore.
+ process.stdin.close()
# Hide stdin from the subprocess module, so it won't fail to close it.
process.stdin = None
result = self.finish_bzr_subprocess(process, retcode=0)
@@ -82,10 +64,10 @@
# Connect to the server
# We use this url because while this is no valid URL to connect to this
# server instance, the transport needs a URL.
- client = DoesNotCloseStdOutClient(
- lambda: (process.stdout, process.stdin))
- transport = smart.SmartTransport('bzr://localhost/', client=client)
- return process, client, transport
+ medium = smart.SmartSimplePipesClientMedium(
+ process.stdout, process.stdin)
+ transport = smart.SmartTransport('bzr://localhost/', medium=medium)
+ return process, transport
def start_server_port(self, extra_options=()):
"""Start a bzr server subprocess.
@@ -106,27 +88,21 @@
def test_bzr_serve_inet_readonly(self):
"""bzr server should provide a read only filesystem by default."""
- process, client, transport = self.start_server_inet()
+ process, transport = self.start_server_inet()
self.assertRaises(errors.TransportNotPossible, transport.mkdir, 'adir')
- # finish with the transport
- del transport
- self.assertInetServerShutsdownCleanly(client, process)
+ self.assertInetServerShutsdownCleanly(process)
def test_bzr_serve_inet_readwrite(self):
# Make a branch
self.make_branch('.')
- process, client, transport = self.start_server_inet(['--allow-writes'])
+ process, transport = self.start_server_inet(['--allow-writes'])
# We get a working branch
branch = BzrDir.open_from_transport(transport).open_branch()
branch.repository.get_revision_graph()
self.assertEqual(None, branch.last_revision())
-
- # finish with the transport
- del transport
-
- self.assertInetServerShutsdownCleanly(client, process)
+ self.assertInetServerShutsdownCleanly(process)
def test_bzr_serve_port_readonly(self):
"""bzr server should provide a read only filesystem by default."""
=== modified file bzrlib/tests/test_errors.py // last-changed:andrew.bennetts at c
... anonical.com-20060928040135-c2c58bbb690acc08
--- bzrlib/tests/test_errors.py
+++ bzrlib/tests/test_errors.py
@@ -26,18 +26,36 @@
class TestErrors(TestCaseWithTransport):
+ def test_medium_not_connected(self):
+ error = errors.MediumNotConnected("a medium")
+ self.assertEqualDiff(
+ "The medium 'a medium' is not connected.", str(error))
+
def test_no_repo(self):
dir = bzrdir.BzrDir.create(self.get_url())
error = errors.NoRepositoryPresent(dir)
self.assertNotEqual(-1, str(error).find((dir.transport.clone('..').base)))
self.assertEqual(-1, str(error).find((dir.transport.base)))
+ def test_no_smart_medium(self):
+ error = errors.NoSmartMedium("a transport")
+ self.assertEqualDiff("The transport 'a transport' cannot tunnel the "
+ "smart protocol.",
+ str(error))
+
def test_no_such_id(self):
error = errors.NoSuchId("atree", "anid")
self.assertEqualDiff("The file id anid is not present in the tree "
"atree.",
str(error))
+ def test_too_many_concurrent_requests(self):
+ error = errors.TooManyConcurrentRequests("a medium")
+ self.assertEqualDiff("The medium 'a medium' has reached its concurrent "
+ "request limit. Be sure to finish_writing and finish_reading on "
+ "the current request that is open.",
+ str(error))
+
def test_up_to_date(self):
error = errors.UpToDateFormat(bzrdir.BzrDirFormat4())
self.assertEqualDiff("The branch format Bazaar-NG branch, "
@@ -53,6 +71,27 @@
repo.bzrdir.root_transport.base,
str(error))
+ def test_reading_completed(self):
+ error = errors.ReadingCompleted("a request")
+ self.assertEqualDiff("The MediumRequest 'a request' has already had "
+ "finish_reading called upon it - the request has been completed and"
+ " no more data may be read.",
+ str(error))
+
+ def test_writing_completed(self):
+ error = errors.WritingCompleted("a request")
+ self.assertEqualDiff("The MediumRequest 'a request' has already had "
+ "finish_writing called upon it - accept bytes may not be called "
+ "anymore.",
+ str(error))
+
+ def test_writing_not_completed(self):
+ error = errors.WritingNotComplete("a request")
+ self.assertEqualDiff("The MediumRequest 'a request' has not has "
+ "finish_writing called upon it - until the write phase is complete"
+ " no data may be read.",
+ str(error))
+
class PassThroughError(errors.BzrNewError):
"""Pass through %(foo)s and %(bar)s"""
=== modified file bzrlib/tests/test_http.py // last-changed:andrew.bennetts at can
... onical.com-20060926054631-7d63ee5c801fb098
--- bzrlib/tests/test_http.py
+++ bzrlib/tests/test_http.py
@@ -19,18 +19,21 @@
# TODO: Should be renamed to bzrlib.transport.http.tests?
+import errno
+import select
import socket
+import threading
import bzrlib
-from bzrlib.errors import DependencyNotPresent
+from bzrlib.errors import DependencyNotPresent, UnsupportedProtocol
from bzrlib.tests import TestCase, TestSkipped
-from bzrlib.transport import Transport
+from bzrlib.transport import get_transport, Transport
from bzrlib.transport.http import extract_auth, HttpTransportBase
from bzrlib.transport.http._urllib import HttpTransport_urllib
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
-class FakeManager (object):
+class FakeManager(object):
def __init__(self):
self.credentials = []
@@ -39,6 +42,54 @@
self.credentials.append([realm, host, username, password])
+class RecordingServer(object):
+ """A fake HTTP server.
+
+ It records the bytes sent to it, and replies with a 200.
+ """
+
+ def __init__(self, expect_body_tail=None):
+ self._expect_body_tail = expect_body_tail
+ self.host = None
+ self.port = None
+ self.received_bytes = ''
+
+ def setUp(self):
+ self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ self._sock.bind(('127.0.0.1', 0))
+ self.host, self.port = self._sock.getsockname()
+ self._ready = threading.Event()
+ self._thread = threading.Thread(target=self._accept_read_and_reply)
+ self._thread.setDaemon(True)
+ self._thread.start()
+ self._ready.wait(5)
+
+ def _accept_read_and_reply(self):
+ self._sock.listen(1)
+ self._ready.set()
+ self._sock.settimeout(5)
+ try:
+ conn, address = self._sock.accept()
+ # On win32, the accepted connection will be non-blocking to start
+ # with because we're using settimeout.
+ conn.setblocking(True)
+ while not self.received_bytes.endswith(self._expect_body_tail):
+ self.received_bytes += conn.recv(4096)
+ conn.sendall('HTTP/1.1 200 OK\r\n')
+ except socket.timeout:
+ # Make sure the client isn't stuck waiting for us to e.g. accept.
+ self._sock.close()
+
+ def tearDown(self):
+ try:
+ self._sock.close()
+ except socket.error:
+ # We might have already closed it. We don't care.
+ pass
+ self.host = None
+ self.port = None
+
+
class TestHttpUrls(TestCase):
def test_url_parsing(self):
@@ -125,6 +176,13 @@
self.assertTrue(server.logs[0].find(
'"GET /foo/bar HTTP/1.1" 200 - "-" "bzr/%s' % bzrlib.__version__) > -1)
+ def test_get_smart_medium(self):
+ # For HTTP, get_smart_medium should return the transport object.
+ server = self.get_readonly_server()
+ http_transport = self._transport(server.get_url())
+ medium = http_transport.get_smart_medium()
+ self.assertTrue(medium is http_transport)
+
class TestHttpConnections_urllib(TestCaseWithWebserver, TestHttpMixins):
@@ -160,7 +218,6 @@
self._prep_tree()
-
class TestHttpTransportRegistration(TestCase):
"""Test registrations of various http implementations"""
@@ -197,6 +254,34 @@
self.assertEqual([[10, 12], [22, 26]], ranges)
+class TestPost(TestCase):
+
+ def _test_post_body_is_received(self, scheme):
+ server = RecordingServer(expect_body_tail='end-of-body')
+ server.setUp()
+ self.addCleanup(server.tearDown)
+ url = '%s://%s:%s/' % (scheme, server.host, server.port)
+ try:
+ http_transport = get_transport(url)
+ except UnsupportedProtocol:
+ raise TestSkipped('%s not available' % scheme)
+ code, response = http_transport._post('abc def end-of-body')
+ self.assertTrue(
+ server.received_bytes.startswith('POST /.bzr/smart HTTP/1.'))
+ self.assertTrue('content-length: 19\r' in server.received_bytes.lower())
+ # The transport should not be assuming that the server can accept
+ # chunked encoding the first time it connects, because HTTP/1.1, so we
+ # check for the literal string.
+ self.assertTrue(
+ server.received_bytes.endswith('\r\n\r\nabc def end-of-body'))
+
+ def test_post_body_is_received_urllib(self):
+ self._test_post_body_is_received('http+urllib')
+
+ def test_post_body_is_received_pycurl(self):
+ self._test_post_body_is_received('http+pycurl')
+
+
class TestRangeHeader(TestCase):
"""Test range_header method"""
@@ -220,3 +305,34 @@
self.check_header('0-9,300-5000,-50',
ranges=[(0,9), (300,5000)],
tail=50)
+
+
+class TestRecordingServer(TestCase):
+
+ def test_create(self):
+ server = RecordingServer(expect_body_tail=None)
+ self.assertEqual('', server.received_bytes)
+ self.assertEqual(None, server.host)
+ self.assertEqual(None, server.port)
+
+ def test_setUp_and_tearDown(self):
+ server = RecordingServer(expect_body_tail=None)
+ server.setUp()
+ try:
+ self.assertNotEqual(None, server.host)
+ self.assertNotEqual(None, server.port)
+ finally:
+ server.tearDown()
+ self.assertEqual(None, server.host)
+ self.assertEqual(None, server.port)
+
+ def test_send_receive_bytes(self):
+ server = RecordingServer(expect_body_tail='c')
+ server.setUp()
+ self.addCleanup(server.tearDown)
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ sock.connect((server.host, server.port))
+ sock.sendall('abc')
+ self.assertEqual('HTTP/1.1 200 OK\r\n',
+ sock.recv(4096, socket.MSG_WAITALL))
+ self.assertEqual('abc', server.received_bytes)
=== modified file bzrlib/tests/test_smart_transport.py
--- bzrlib/tests/test_smart_transport.py
+++ bzrlib/tests/test_smart_transport.py
@@ -18,13 +18,15 @@
# all of this deals with byte strings so this is safe
from cStringIO import StringIO
-import subprocess
-import sys
+import os
+import socket
+import threading
+import urllib2
-import bzrlib
from bzrlib import (
bzrdir,
errors,
+ osutils,
tests,
)
from bzrlib.transport import (
@@ -33,20 +35,486 @@
memory,
smart,
)
-
-
-class SmartClientTests(tests.TestCase):
-
- def test_construct_smart_stream_client(self):
- # make a new client; this really wants a connector function that returns
- # two fifos or sockets but the constructor should not do any IO
- client = smart.SmartStreamClient(None)
-
-
-class TCPClientTests(tests.TestCaseWithTransport):
+from bzrlib.transport.http import (
+ HTTPServerWithSmarts,
+ SmartClientHTTPMediumRequest,
+ SmartRequestHandler,
+ )
+
+
+class StringIOSSHVendor(object):
+ """A SSH vendor that uses StringIO to buffer writes and answer reads."""
+
+ def __init__(self, read_from, write_to):
+ self.read_from = read_from
+ self.write_to = write_to
+ self.calls = []
+
+ def connect_ssh(self, username, password, host, port, command):
+ self.calls.append(('connect_ssh', username, password, host, port,
+ command))
+ return StringIOSSHConnection(self)
+
+
+class StringIOSSHConnection(object):
+ """A SSH connection that uses StringIO to buffer writes and answer reads."""
+
+ def __init__(self, vendor):
+ self.vendor = vendor
+
+ def close(self):
+ self.vendor.calls.append(('close', ))
+
+ def get_filelike_channels(self):
+ return self.vendor.read_from, self.vendor.write_to
+
+
+
+class SmartClientMediumTests(tests.TestCase):
+ """Tests for SmartClientMedium.
+
+ We should create a test scenario for this: we need a server module that
+ construct the test-servers (like make_loopsocket_and_medium), and the list
+ of SmartClientMedium classes to test.
+ """
+
+ def make_loopsocket_and_medium(self):
+ """Create a loopback socket for testing, and a medium aimed at it."""
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ sock.bind(('127.0.0.1', 0))
+ sock.listen(1)
+ port = sock.getsockname()[1]
+ medium = smart.SmartTCPClientMedium('127.0.0.1', port)
+ return sock, medium
+
+ def receive_bytes_on_server(self, sock, bytes):
+ """Accept a connection on sock and read 3 bytes.
+
+ The bytes are appended to the list bytes.
+
+ :return: a Thread which is running to do the accept and recv.
+ """
+ def _receive_bytes_on_server():
+ connection, address = sock.accept()
+ bytes.append(connection.recv(3, socket.MSG_WAITALL))
+ connection.close()
+ t = threading.Thread(target=_receive_bytes_on_server)
+ t.start()
+ return t
+
+ def test_construct_smart_stream_medium_client(self):
+ # make a new instance of the common base for Stream-like Mediums.
+ # this just ensures that the constructor stays parameter-free which
+ # is important for reuse : some subclasses will dynamically connect,
+ # others are always on, etc.
+ medium = smart.SmartClientStreamMedium()
+
+ def test_construct_smart_client_medium(self):
+ # the base client medium takes no parameters
+ medium = smart.SmartClientMedium()
+
+ def test_construct_smart_simple_pipes_client_medium(self):
+ # the SimplePipes client medium takes two pipes:
+ # readable pipe, writeable pipe.
+ # Constructing one should just save these and do nothing.
+ # We test this by passing in None.
+ medium = smart.SmartSimplePipesClientMedium(None, None)
+
+ def test_simple_pipes_client_request_type(self):
+ # SimplePipesClient should use SmartClientStreamMediumRequest's.
+ medium = smart.SmartSimplePipesClientMedium(None, None)
+ request = medium.get_request()
+ self.assertIsInstance(request, smart.SmartClientStreamMediumRequest)
+
+ def test_simple_pipes_client_get_concurrent_requests(self):
+ # the simple_pipes client does not support pipelined requests:
+ # but it does support serial requests: we construct one after
+ # another is finished. This is a smoke test testing the integration
+ # of the SmartClientStreamMediumRequest and the SmartClientStreamMedium
+ # classes - as the sibling classes share this logic, they do not have
+ # explicit tests for this.
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(None, output)
+ request = medium.get_request()
+ request.finished_writing()
+ request.finished_reading()
+ request2 = medium.get_request()
+ request2.finished_writing()
+ request2.finished_reading()
+
+ def test_simple_pipes_client__accept_bytes_writes_to_writable(self):
+ # accept_bytes writes to the writeable pipe.
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(None, output)
+ medium._accept_bytes('abc')
+ self.assertEqual('abc', output.getvalue())
+
+ def test_simple_pipes_client_disconnect_does_nothing(self):
+ # calling disconnect does nothing.
+ input = StringIO()
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ # send some bytes to ensure disconnecting after activity still does not
+ # close.
+ medium._accept_bytes('abc')
+ medium.disconnect()
+ self.assertFalse(input.closed)
+ self.assertFalse(output.closed)
+
+ def test_simple_pipes_client_accept_bytes_after_disconnect(self):
+ # calling disconnect on the client does not alter the pipe that
+ # accept_bytes writes to.
+ input = StringIO()
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ medium._accept_bytes('abc')
+ medium.disconnect()
+ medium._accept_bytes('abc')
+ self.assertFalse(input.closed)
+ self.assertFalse(output.closed)
+ self.assertEqual('abcabc', output.getvalue())
+
+ def test_simple_pipes_client_ignores_disconnect_when_not_connected(self):
+ # Doing a disconnect on a new (and thus unconnected) SimplePipes medium
+ # does nothing.
+ medium = smart.SmartSimplePipesClientMedium(None, None)
+ medium.disconnect()
+
+ def test_simple_pipes_client_can_always_read(self):
+ # SmartSimplePipesClientMedium is never disconnected, so read_bytes
+ # always tries to read from the underlying pipe.
+ input = StringIO('abcdef')
+ medium = smart.SmartSimplePipesClientMedium(input, None)
+ self.assertEqual('abc', medium.read_bytes(3))
+ medium.disconnect()
+ self.assertEqual('def', medium.read_bytes(3))
+
+ def test_simple_pipes_client_supports__flush(self):
+ # invoking _flush on a SimplePipesClient should flush the output
+ # pipe. We test this by creating an output pipe that records
+ # flush calls made to it.
+ from StringIO import StringIO # get regular StringIO
+ input = StringIO()
+ output = StringIO()
+ flush_calls = []
+ def _flush(): flush_calls.append('flush')
+ output.flush = _flush
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ # this call is here to ensure we only flush once, not on every
+ # _accept_bytes call.
+ medium._accept_bytes('abc')
+ medium._flush()
+ medium.disconnect()
+ self.assertEqual(['flush'], flush_calls)
+
+ def test_construct_smart_ssh_client_medium(self):
+ # the SSH client medium takes:
+ # host, port, username, password, vendor
+ # Constructing one should just save these and do nothing.
+ # we test this by creating a empty bound socket and constructing
+ # a medium.
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ sock.bind(('127.0.0.1', 0))
+ unopen_port = sock.getsockname()[1]
+ # having vendor be invalid means that if it tries to connect via the
+ # vendor it will blow up.
+ medium = smart.SmartSSHClientMedium('127.0.0.1', unopen_port,
+ username=None, password=None, vendor="not a vendor")
+ sock.close()
+
+ def test_ssh_client_connects_on_first_use(self):
+ # The only thing that initiates a connection from the medium is giving
+ # it bytes.
+ output = StringIO()
+ vendor = StringIOSSHVendor(StringIO(), output)
+ medium = smart.SmartSSHClientMedium('a hostname', 'a port', 'a username',
+ 'a password', vendor)
+ medium._accept_bytes('abc')
+ self.assertEqual('abc', output.getvalue())
+ self.assertEqual([('connect_ssh', 'a username', 'a password',
+ 'a hostname', 'a port',
+ ['bzr', 'serve', '--inet', '--directory=/', '--allow-writes'])],
+ vendor.calls)
+
+ def test_ssh_client_changes_command_when_BZR_REMOTE_PATH_is_set(self):
+ # The only thing that initiates a connection from the medium is giving
+ # it bytes.
+ output = StringIO()
+ vendor = StringIOSSHVendor(StringIO(), output)
+ orig_bzr_remote_path = os.environ.get('BZR_REMOTE_PATH')
+ def cleanup_environ():
+ osutils.set_or_unset_env('BZR_REMOTE_PATH', orig_bzr_remote_path)
+ self.addCleanup(cleanup_environ)
+ os.environ['BZR_REMOTE_PATH'] = 'fugly'
+ medium = smart.SmartSSHClientMedium('a hostname', 'a port', 'a username',
+ 'a password', vendor)
+ medium._accept_bytes('abc')
+ self.assertEqual('abc', output.getvalue())
+ self.assertEqual([('connect_ssh', 'a username', 'a password',
+ 'a hostname', 'a port',
+ ['fugly', 'serve', '--inet', '--directory=/', '--allow-writes'])],
+ vendor.calls)
+
+ def test_ssh_client_disconnect_does_so(self):
+ # calling disconnect should disconnect both the read_from and write_to
+ # file-like object it from the ssh connection.
+ input = StringIO()
+ output = StringIO()
+ vendor = StringIOSSHVendor(input, output)
+ medium = smart.SmartSSHClientMedium('a hostname', vendor=vendor)
+ medium._accept_bytes('abc')
+ medium.disconnect()
+ self.assertTrue(input.closed)
+ self.assertTrue(output.closed)
+ self.assertEqual([
+ ('connect_ssh', None, None, 'a hostname', None,
+ ['bzr', 'serve', '--inet', '--directory=/', '--allow-writes']),
+ ('close', ),
+ ],
+ vendor.calls)
+
+ def test_ssh_client_disconnect_allows_reconnection(self):
+ # calling disconnect on the client terminates the connection, but should
+ # not prevent additional connections occuring.
+ # we test this by initiating a second connection after doing a
+ # disconnect.
+ input = StringIO()
+ output = StringIO()
+ vendor = StringIOSSHVendor(input, output)
+ medium = smart.SmartSSHClientMedium('a hostname', vendor=vendor)
+ medium._accept_bytes('abc')
+ medium.disconnect()
+ # the disconnect has closed output, so we need a new output for the
+ # new connection to write to.
+ input2 = StringIO()
+ output2 = StringIO()
+ vendor.read_from = input2
+ vendor.write_to = output2
+ medium._accept_bytes('abc')
+ medium.disconnect()
+ self.assertTrue(input.closed)
+ self.assertTrue(output.closed)
+ self.assertTrue(input2.closed)
+ self.assertTrue(output2.closed)
+ self.assertEqual([
+ ('connect_ssh', None, None, 'a hostname', None,
+ ['bzr', 'serve', '--inet', '--directory=/', '--allow-writes']),
+ ('close', ),
+ ('connect_ssh', None, None, 'a hostname', None,
+ ['bzr', 'serve', '--inet', '--directory=/', '--allow-writes']),
+ ('close', ),
+ ],
+ vendor.calls)
+
+ def test_ssh_client_ignores_disconnect_when_not_connected(self):
+ # Doing a disconnect on a new (and thus unconnected) SSH medium
+ # does nothing.
+ medium = smart.SmartSSHClientMedium(None)
+ medium.disconnect()
+
+ def test_ssh_client_raises_on_read_when_not_connected(self):
+ # Doing a read on a new (and thus unconnected) SSH medium raises
+ # MediumNotConnected.
+ medium = smart.SmartSSHClientMedium(None)
+ self.assertRaises(errors.MediumNotConnected, medium.read_bytes, 0)
+ self.assertRaises(errors.MediumNotConnected, medium.read_bytes, 1)
+
+ def test_ssh_client_supports__flush(self):
+ # invoking _flush on a SSHClientMedium should flush the output
+ # pipe. We test this by creating an output pipe that records
+ # flush calls made to it.
+ from StringIO import StringIO # get regular StringIO
+ input = StringIO()
+ output = StringIO()
+ flush_calls = []
+ def _flush(): flush_calls.append('flush')
+ output.flush = _flush
+ vendor = StringIOSSHVendor(input, output)
+ medium = smart.SmartSSHClientMedium('a hostname', vendor=vendor)
+ # this call is here to ensure we only flush once, not on every
+ # _accept_bytes call.
+ medium._accept_bytes('abc')
+ medium._flush()
+ medium.disconnect()
+ self.assertEqual(['flush'], flush_calls)
+
+ def test_construct_smart_tcp_client_medium(self):
+ # the TCP client medium takes a host and a port. Constructing it won't
+ # connect to anything.
+ sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ sock.bind(('127.0.0.1', 0))
+ unopen_port = sock.getsockname()[1]
+ medium = smart.SmartTCPClientMedium('127.0.0.1', unopen_port)
+ sock.close()
+
+ def test_tcp_client_connects_on_first_use(self):
+ # The only thing that initiates a connection from the medium is giving
+ # it bytes.
+ sock, medium = self.make_loopsocket_and_medium()
+ bytes = []
+ t = self.receive_bytes_on_server(sock, bytes)
+ medium._accept_bytes('abc')
+ t.join()
+ sock.close()
+ self.assertEqual(['abc'], bytes)
+
+ def test_tcp_client_disconnect_does_so(self):
+ # calling disconnect on the client terminates the connection.
+ # we test this by forcing a short read during a socket.MSG_WAITALL
+ # call : write 2 bytes, try to read 3, and then the client disconnects.
+ sock, medium = self.make_loopsocket_and_medium()
+ bytes = []
+ t = self.receive_bytes_on_server(sock, bytes)
+ medium._accept_bytes('ab')
+ medium.disconnect()
+ t.join()
+ sock.close()
+ self.assertEqual(['ab'], bytes)
+ # now disconnect again : this should not do anything, if disconnection
+ # really did disconnect.
+ medium.disconnect()
+
+ def test_tcp_client_ignores_disconnect_when_not_connected(self):
+ # Doing a disconnect on a new (and thus unconnected) TCP medium
+ # does nothing.
+ medium = smart.SmartTCPClientMedium(None, None)
+ medium.disconnect()
+
+ def test_tcp_client_raises_on_read_when_not_connected(self):
+ # Doing a read on a new (and thus unconnected) TCP medium raises
+ # MediumNotConnected.
+ medium = smart.SmartTCPClientMedium(None, None)
+ self.assertRaises(errors.MediumNotConnected, medium.read_bytes, 0)
+ self.assertRaises(errors.MediumNotConnected, medium.read_bytes, 1)
+
+ def test_tcp_client_supports__flush(self):
+ # invoking _flush on a TCPClientMedium should do something useful.
+ # RBC 20060922 not sure how to test/tell in this case.
+ sock, medium = self.make_loopsocket_and_medium()
+ bytes = []
+ t = self.receive_bytes_on_server(sock, bytes)
+ # try with nothing buffered
+ medium._flush()
+ medium._accept_bytes('ab')
+ # and with something sent.
+ medium._flush()
+ medium.disconnect()
+ t.join()
+ sock.close()
+ self.assertEqual(['ab'], bytes)
+ # now disconnect again : this should not do anything, if disconnection
+ # really did disconnect.
+ medium.disconnect()
+
+
+class TestSmartClientStreamMediumRequest(tests.TestCase):
+ """Tests the for SmartClientStreamMediumRequest.
+
+ SmartClientStreamMediumRequest is a helper for the three stream based
+ mediums: TCP, SSH, SimplePipes, so we only test it once, and then test that
+ those three mediums implement the interface it expects.
+ """
+
+ def test_accept_bytes_after_finished_writing_errors(self):
+ # calling accept_bytes after calling finished_writing raises
+ # WritingCompleted to prevent bad assumptions on stream environments
+ # breaking the needs of message-based environments.
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(None, output)
+ request = smart.SmartClientStreamMediumRequest(medium)
+ request.finished_writing()
+ self.assertRaises(errors.WritingCompleted, request.accept_bytes, None)
+
+ def test_accept_bytes(self):
+ # accept bytes should invoke _accept_bytes on the stream medium.
+ # we test this by using the SimplePipes medium - the most trivial one
+ # and checking that the pipes get the data.
+ input = StringIO()
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ request = smart.SmartClientStreamMediumRequest(medium)
+ request.accept_bytes('123')
+ request.finished_writing()
+ request.finished_reading()
+ self.assertEqual('', input.getvalue())
+ self.assertEqual('123', output.getvalue())
+
+ def test_construct_sets_stream_request(self):
+ # constructing a SmartClientStreamMediumRequest on a StreamMedium sets
+ # the current request to the new SmartClientStreamMediumRequest
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(None, output)
+ request = smart.SmartClientStreamMediumRequest(medium)
+ self.assertTrue(medium._current_request is request)
+
+ def test_construct_while_another_request_active_throws(self):
+ # constructing a SmartClientStreamMediumRequest on a StreamMedium with
+ # a non-None _current_request raises TooManyConcurrentRequests.
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(None, output)
+ medium._current_request = "a"
+ self.assertRaises(errors.TooManyConcurrentRequests,
+ smart.SmartClientStreamMediumRequest, medium)
+
+ def test_finished_read_clears_current_request(self):
+ # calling finished_reading clears the current request from the requests
+ # medium
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(None, output)
+ request = smart.SmartClientStreamMediumRequest(medium)
+ request.finished_writing()
+ request.finished_reading()
+ self.assertEqual(None, medium._current_request)
+
+ def test_finished_read_before_finished_write_errors(self):
+ # calling finished_reading before calling finished_writing triggers a
+ # WritingNotComplete error.
+ medium = smart.SmartSimplePipesClientMedium(None, None)
+ request = smart.SmartClientStreamMediumRequest(medium)
+ self.assertRaises(errors.WritingNotComplete, request.finished_reading)
+
+ def test_read_bytes(self):
+ # read bytes should invoke _read_bytes on the stream medium.
+ # we test this by using the SimplePipes medium - the most trivial one
+ # and checking that the data is supplied. Its possible that a
+ # faulty implementation could poke at the pipe variables them selves,
+ # but we trust that this will be caught as it will break the integration
+ # smoke tests.
+ input = StringIO('321')
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ request = smart.SmartClientStreamMediumRequest(medium)
+ request.finished_writing()
+ self.assertEqual('321', request.read_bytes(3))
+ request.finished_reading()
+ self.assertEqual('', input.read())
+ self.assertEqual('', output.getvalue())
+
+ def test_read_bytes_before_finished_write_errors(self):
+ # calling read_bytes before calling finished_writing triggers a
+ # WritingNotComplete error because the Smart protocol is designed to be
+ # compatible with strict message based protocols like HTTP where the
+ # request cannot be submitted until the writing has completed.
+ medium = smart.SmartSimplePipesClientMedium(None, None)
+ request = smart.SmartClientStreamMediumRequest(medium)
+ self.assertRaises(errors.WritingNotComplete, request.read_bytes, None)
+
+ def test_read_bytes_after_finished_reading_errors(self):
+ # calling read_bytes after calling finished_reading raises
+ # ReadingCompleted to prevent bad assumptions on stream environments
+ # breaking the needs of message-based environments.
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(None, output)
+ request = smart.SmartClientStreamMediumRequest(medium)
+ request.finished_writing()
+ request.finished_reading()
+ self.assertRaises(errors.ReadingCompleted, request.read_bytes, None)
+
+
+class RemoteTransportTests(tests.TestCaseWithTransport):
def setUp(self):
- super(TCPClientTests, self).setUp()
+ super(RemoteTransportTests, self).setUp()
# We're allowed to set the transport class here, so that we don't use
# the default or a parameterized class, but rather use the
# TestCaseWithTransport infrastructure to set up a smart server and
@@ -60,20 +528,70 @@
t = self.get_transport()
self.assertIsInstance(t, smart.SmartTransport)
- def test_get_client_from_transport(self):
+ def test_get_medium_from_transport(self):
+ """Remote transport has a medium always, which it can return."""
t = self.get_transport()
- client = t.get_smart_client()
- self.assertIsInstance(client, smart.SmartStreamClient)
-
-
-class BasicSmartTests(tests.TestCase):
+ medium = t.get_smart_medium()
+ self.assertIsInstance(medium, smart.SmartClientMedium)
+
+
+class ErrorRaisingProtocol(object):
+
+ def __init__(self, exception):
+ self.exception = exception
+
+ def next_read_size(self):
+ raise self.exception
+
+
+class SampleRequest(object):
+
+ def __init__(self, expected_bytes):
+ self.accepted_bytes = ''
+ self._finished_reading = False
+ self.expected_bytes = expected_bytes
+ self.excess_buffer = ''
+
+ def accept_bytes(self, bytes):
+ self.accepted_bytes += bytes
+ if self.accepted_bytes.startswith(self.expected_bytes):
+ self._finished_reading = True
+ self.excess_buffer = self.accepted_bytes[len(self.expected_bytes):]
+
+ def next_read_size(self):
+ if self._finished_reading:
+ return 0
+ else:
+ return 1
+
+
+class TestSmartServerStreamMedium(tests.TestCase):
+
+ def portable_socket_pair(self):
+ """Return a pair of TCP sockets connected to each other.
+
+ Unlike socket.socketpair, this should work on Windows.
+ """
+ listen_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ listen_sock.bind(('127.0.0.1', 0))
+ listen_sock.listen(1)
+ client_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ client_sock.connect(listen_sock.getsockname())
+ server_sock, addr = listen_sock.accept()
+ listen_sock.close()
+ return server_sock, client_sock
def test_smart_query_version(self):
"""Feed a canned query version to a server"""
+ # wire-to-wire, using the whole stack
to_server = StringIO('hello\n')
from_server = StringIO()
- server = smart.SmartStreamServer(to_server, from_server, local.LocalTransport('file:///'))
- server._serve_one_request()
+ transport = local.LocalTransport('file:///')
+ server = smart.SmartServerPipeStreamMedium(
+ to_server, from_server, transport)
+ protocol = smart.SmartServerRequestProtocolOne(transport,
+ from_server.write)
+ server._serve_one_request(protocol)
self.assertEqual('ok\0011\n',
from_server.getvalue())
@@ -82,14 +600,155 @@
transport.put_bytes('testfile', 'contents\nof\nfile\n')
to_server = StringIO('get\001./testfile\n')
from_server = StringIO()
- server = smart.SmartStreamServer(to_server, from_server, transport)
- server._serve_one_request()
+ server = smart.SmartServerPipeStreamMedium(
+ to_server, from_server, transport)
+ protocol = smart.SmartServerRequestProtocolOne(transport,
+ from_server.write)
+ server._serve_one_request(protocol)
self.assertEqual('ok\n'
'17\n'
'contents\nof\nfile\n'
'done\n',
from_server.getvalue())
+ def test_pipe_like_stream_with_bulk_data(self):
+ sample_request_bytes = 'command\n9\nbulk datadone\n'
+ to_server = StringIO(sample_request_bytes)
+ from_server = StringIO()
+ server = smart.SmartServerPipeStreamMedium(to_server, from_server, None)
+ sample_protocol = SampleRequest(expected_bytes=sample_request_bytes)
+ server._serve_one_request(sample_protocol)
+ self.assertEqual('', from_server.getvalue())
+ self.assertEqual(sample_request_bytes, sample_protocol.accepted_bytes)
+ self.assertFalse(server.finished)
+
+ def test_socket_stream_with_bulk_data(self):
+ sample_request_bytes = 'command\n9\nbulk datadone\n'
+ server_sock, client_sock = self.portable_socket_pair()
+ server = smart.SmartServerSocketStreamMedium(
+ server_sock, None)
+ sample_protocol = SampleRequest(expected_bytes=sample_request_bytes)
+ client_sock.sendall(sample_request_bytes)
+ server._serve_one_request(sample_protocol)
+ server_sock.close()
+ self.assertEqual('', client_sock.recv(1))
+ self.assertEqual(sample_request_bytes, sample_protocol.accepted_bytes)
+ self.assertFalse(server.finished)
+
+ def test_pipe_like_stream_shutdown_detection(self):
+ to_server = StringIO('')
+ from_server = StringIO()
+ server = smart.SmartServerPipeStreamMedium(to_server, from_server, None)
+ server._serve_one_request(SampleRequest('x'))
+ self.assertTrue(server.finished)
+
+ def test_socket_stream_shutdown_detection(self):
+ server_sock, client_sock = self.portable_socket_pair()
+ client_sock.close()
+ server = smart.SmartServerSocketStreamMedium(
+ server_sock, None)
+ server._serve_one_request(SampleRequest('x'))
+ self.assertTrue(server.finished)
+
+ def test_pipe_like_stream_with_two_requests(self):
+ # If two requests are read in one go, then two calls to
+ # _serve_one_request should still process both of them as if they had
+ # been received seperately.
+ sample_request_bytes = 'command\n'
+ to_server = StringIO(sample_request_bytes * 2)
+ from_server = StringIO()
+ server = smart.SmartServerPipeStreamMedium(to_server, from_server, None)
+ first_protocol = SampleRequest(expected_bytes=sample_request_bytes)
+ server._serve_one_request(first_protocol)
+ self.assertEqual(0, first_protocol.next_read_size())
+ self.assertEqual('', from_server.getvalue())
+ self.assertFalse(server.finished)
+ # Make a new protocol, call _serve_one_request with it to collect the
+ # second request.
+ second_protocol = SampleRequest(expected_bytes=sample_request_bytes)
+ server._serve_one_request(second_protocol)
+ self.assertEqual('', from_server.getvalue())
+ self.assertEqual(sample_request_bytes, second_protocol.accepted_bytes)
+ self.assertFalse(server.finished)
+
+ def test_socket_stream_with_two_requests(self):
+ # If two requests are read in one go, then two calls to
+ # _serve_one_request should still process both of them as if they had
+ # been received seperately.
+ sample_request_bytes = 'command\n'
+ server_sock, client_sock = self.portable_socket_pair()
+ server = smart.SmartServerSocketStreamMedium(
+ server_sock, None)
+ first_protocol = SampleRequest(expected_bytes=sample_request_bytes)
+ # Put two whole requests on the wire.
+ client_sock.sendall(sample_request_bytes * 2)
+ server._serve_one_request(first_protocol)
+ self.assertEqual(0, first_protocol.next_read_size())
+ self.assertFalse(server.finished)
+ # Make a new protocol, call _serve_one_request with it to collect the
+ # second request.
+ second_protocol = SampleRequest(expected_bytes=sample_request_bytes)
+ stream_still_open = server._serve_one_request(second_protocol)
+ self.assertEqual(sample_request_bytes, second_protocol.accepted_bytes)
+ self.assertFalse(server.finished)
+ server_sock.close()
+ self.assertEqual('', client_sock.recv(1))
+
+ def test_pipe_like_stream_error_handling(self):
+ # Use plain python StringIO so we can monkey-patch the close method to
+ # not discard the contents.
+ from StringIO import StringIO
+ to_server = StringIO('')
+ from_server = StringIO()
+ self.closed = False
+ def close():
+ self.closed = True
+ from_server.close = close
+ server = smart.SmartServerPipeStreamMedium(to_server, from_server, None)
+ fake_protocol = ErrorRaisingProtocol(Exception('boom'))
+ server._serve_one_request(fake_protocol)
+ self.assertEqual('', from_server.getvalue())
+ self.assertTrue(self.closed)
+ self.assertTrue(server.finished)
+
+ def test_socket_stream_error_handling(self):
+ # Use plain python StringIO so we can monkey-patch the close method to
+ # not discard the contents.
+ from StringIO import StringIO
+ server_sock, client_sock = self.portable_socket_pair()
+ server = smart.SmartServerSocketStreamMedium(
+ server_sock, None)
+ fake_protocol = ErrorRaisingProtocol(Exception('boom'))
+ server._serve_one_request(fake_protocol)
+ # recv should not block, because the other end of the socket has been
+ # closed.
+ self.assertEqual('', client_sock.recv(1))
+ self.assertTrue(server.finished)
+
+ def test_pipe_like_stream_keyboard_interrupt_handling(self):
+ # Use plain python StringIO so we can monkey-patch the close method to
+ # not discard the contents.
+ to_server = StringIO('')
+ from_server = StringIO()
+ server = smart.SmartServerPipeStreamMedium(to_server, from_server, None)
+ fake_protocol = ErrorRaisingProtocol(KeyboardInterrupt('boom'))
+ self.assertRaises(
+ KeyboardInterrupt, server._serve_one_request, fake_protocol)
+ self.assertEqual('', from_server.getvalue())
+
+ def test_socket_stream_keyboard_interrupt_handling(self):
+ server_sock, client_sock = self.portable_socket_pair()
+ server = smart.SmartServerSocketStreamMedium(
+ server_sock, None)
+ fake_protocol = ErrorRaisingProtocol(KeyboardInterrupt('boom'))
+ self.assertRaises(
+ KeyboardInterrupt, server._serve_one_request, fake_protocol)
+ server_sock.close()
+ self.assertEqual('', client_sock.recv(1))
+
+
+class TestSmartTCPServer(tests.TestCase):
+
def test_get_error_unexpected(self):
"""Error reported by server with no specific representation"""
class FlakyTransport(object):
@@ -108,22 +767,6 @@
finally:
server.stop_background_thread()
- def test_server_subprocess(self):
- """Talk to a server started as a subprocess
-
- This is similar to running it over ssh, except that it runs in the same machine
- without ssh intermediating.
- """
- args = [sys.executable, sys.argv[0], 'serve', '--inet']
- child = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
- close_fds=True)
- conn = smart.SmartStreamClient(lambda: (child.stdout, child.stdin))
- conn.query_version()
- conn.query_version()
- conn.disconnect()
- returncode = child.wait()
- self.assertEquals(0, returncode)
-
class SmartTCPTests(tests.TestCase):
"""Tests for connection/end to end behaviour using the TCP server.
@@ -195,7 +838,7 @@
# we create a real connection not a loopback one, but it will use the
# same server and pipes
conn2 = self.transport.clone('.')
- self.assertTrue(self.transport._client is conn2._client)
+ self.assertTrue(self.transport._medium is conn2._medium)
def test__remote_path(self):
self.assertEquals('/foo/bar',
@@ -241,14 +884,19 @@
'foo')
-class SmartServerTests(tests.TestCaseWithTransport):
- """Test that call directly into the server logic, bypassing the network."""
+class SmartServerRequestHandlerTests(tests.TestCaseWithTransport):
+ """Test that call directly into the handler logic, bypassing the network."""
+
+ def test_construct_request_handler(self):
+ """Constructing a request handler should be easy and set defaults."""
+ handler = smart.SmartServerRequestHandler(None)
+ self.assertFalse(handler.finished_reading)
def test_hello(self):
- server = smart.SmartServer(None)
- response = server.dispatch_command('hello', ())
- self.assertEqual(('ok', '1'), response.args)
- self.assertEqual(None, response.body)
+ handler = smart.SmartServerRequestHandler(None)
+ handler.dispatch_command('hello', ())
+ self.assertEqual(('ok', '1'), handler.response.args)
+ self.assertEqual(None, handler.response.body)
def test_get_bundle(self):
from bzrlib.bundle import serializer
@@ -257,22 +905,71 @@
wt.add('hello')
rev_id = wt.commit('add hello')
- server = smart.SmartServer(self.get_transport())
- response = server.dispatch_command('get_bundle', ('.', rev_id))
- bundle = serializer.read_bundle(StringIO(response.body))
+ handler = smart.SmartServerRequestHandler(self.get_transport())
+ handler.dispatch_command('get_bundle', ('.', rev_id))
+ bundle = serializer.read_bundle(StringIO(handler.response.body))
+ self.assertEqual((), handler.response.args)
def test_readonly_exception_becomes_transport_not_possible(self):
"""The response for a read-only error is ('ReadOnlyError')."""
- server = smart.SmartServer(self.get_readonly_transport())
+ handler = smart.SmartServerRequestHandler(self.get_readonly_transport())
# send a mkdir for foo, with no explicit mode - should fail.
- response = server.dispatch_command('mkdir', ('foo', ''))
+ handler.dispatch_command('mkdir', ('foo', ''))
# and the failure should be an explicit ReadOnlyError
- self.assertEqual(("ReadOnlyError", ), response.args)
+ self.assertEqual(("ReadOnlyError", ), handler.response.args)
# XXX: TODO: test that other TransportNotPossible errors are
# presented as TransportNotPossible - not possible to do that
# until I figure out how to trigger that relatively cleanly via
# the api. RBC 20060918
+ def test_hello_has_finished_body_on_dispatch(self):
+ """The 'hello' command should set finished_reading."""
+ handler = smart.SmartServerRequestHandler(None)
+ handler.dispatch_command('hello', ())
+ self.assertTrue(handler.finished_reading)
+ self.assertNotEqual(None, handler.response)
+
+ def test_put_bytes_non_atomic(self):
+ """'put_...' should set finished_reading after reading the bytes."""
+ handler = smart.SmartServerRequestHandler(self.get_transport())
+ handler.dispatch_command('put_non_atomic', ('a-file', '', 'F', ''))
+ self.assertFalse(handler.finished_reading)
+ handler.accept_body('1234')
+ self.assertFalse(handler.finished_reading)
+ handler.accept_body('5678')
+ handler.end_of_body()
+ self.assertTrue(handler.finished_reading)
+ self.assertEqual(('ok', ), handler.response.args)
+ self.assertEqual(None, handler.response.body)
+
+ def test_readv_accept_body(self):
+ """'readv' should set finished_reading after reading offsets."""
+ self.build_tree(['a-file'])
+ handler = smart.SmartServerRequestHandler(self.get_readonly_transport())
+ handler.dispatch_command('readv', ('a-file', ))
+ self.assertFalse(handler.finished_reading)
+ handler.accept_body('2,')
+ self.assertFalse(handler.finished_reading)
+ handler.accept_body('3')
+ handler.end_of_body()
+ self.assertTrue(handler.finished_reading)
+ self.assertEqual(('readv', ), handler.response.args)
+ # co - nte - nt of a-file is the file contents we are extracting from.
+ self.assertEqual('nte', handler.response.body)
+
+ def test_readv_short_read_response_contents(self):
+ """'readv' when a short read occurs sets the response appropriately."""
+ self.build_tree(['a-file'])
+ handler = smart.SmartServerRequestHandler(self.get_readonly_transport())
+ handler.dispatch_command('readv', ('a-file', ))
+ # read beyond the end of the file.
+ handler.accept_body('100,1')
+ handler.end_of_body()
+ self.assertTrue(handler.finished_reading)
+ self.assertEqual(('ShortReadvError', 'a-file', '100', '1', '0'),
+ handler.response.args)
+ self.assertEqual(None, handler.response.body)
+
class SmartTransportRegistration(tests.TestCase):
@@ -282,65 +979,42 @@
self.assertEqual('example.com', t._host)
-class FakeClient(smart.SmartStreamClient):
- """Emulate a client for testing a transport's use of the client."""
-
- def __init__(self):
- smart.SmartStreamClient.__init__(self, None)
- self._calls = []
-
- def _call(self, *args):
- self._calls.append(('_call', args))
- return ('ok', )
-
- def _recv_bulk(self):
- return 'bar'
-
-
class TestSmartTransport(tests.TestCase):
def test_use_connection_factory(self):
# We want to be able to pass a client as a parameter to SmartTransport.
- client = FakeClient()
- transport = smart.SmartTransport('bzr://localhost/', client=client)
+ input = StringIO("ok\n3\nbardone\n")
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ transport = smart.SmartTransport('bzr://localhost/', medium=medium)
# We want to make sure the client is used when the first remote
- # method is called. No method should have been called yet.
- self.assertEqual([], client._calls)
+ # method is called. No data should have been sent, or read.
+ self.assertEqual(0, input.tell())
+ self.assertEqual('', output.getvalue())
- # Now call a method that should result in a single request.
+ # Now call a method that should result in a single request : as the
+ # transport makes its own protocol instances, we check on the wire.
+ # XXX: TODO: give the transport a protocol factory, which can make
+ # an instrumented protocol for us.
self.assertEqual('bar', transport.get_bytes('foo'))
- # The only call to _call should have been to get /foo.
- self.assertEqual([('_call', ('get', '/foo'))], client._calls)
+ # only the needed data should have been sent/received.
+ self.assertEqual(13, input.tell())
+ self.assertEqual('get\x01/foo\n', output.getvalue())
def test__translate_error_readonly(self):
"""Sending a ReadOnlyError to _translate_error raises TransportNotPossible."""
- client = FakeClient()
- transport = smart.SmartTransport('bzr://localhost/', client=client)
+ medium = smart.SmartClientMedium()
+ transport = smart.SmartTransport('bzr://localhost/', medium=medium)
self.assertRaises(errors.TransportNotPossible,
transport._translate_error, ("ReadOnlyError", ))
-class InstrumentedClient(smart.SmartStreamClient):
- """A smart client whose writes are stored to a supplied list."""
-
- def __init__(self, write_output_list):
- smart.SmartStreamClient.__init__(self, None)
- self._write_output_list = write_output_list
-
- def _ensure_connection(self):
- """We are never strictly connected."""
-
- def _write_and_flush(self, bytes):
- self._write_output_list.append(bytes)
-
-
-class InstrumentedServerProtocol(smart.SmartStreamServer):
+class InstrumentedServerProtocol(smart.SmartServerStreamMedium):
"""A smart server which is backed by memory and saves its write requests."""
def __init__(self, write_output_list):
- smart.SmartStreamServer.__init__(self, None, None,
- memory.MemoryTransport())
+ smart.SmartServerStreamMedium.__init__(self, memory.MemoryTransport())
self._write_output_list = write_output_list
def _write_and_flush(self, bytes):
@@ -362,13 +1036,18 @@
def setUp(self):
super(TestSmartProtocol, self).setUp()
- self.to_server = []
- self.to_client = []
- self.smart_client = InstrumentedClient(self.to_server)
- self.smart_server = InstrumentedServerProtocol(self.to_client)
+ self.server_to_client = []
+ self.to_server = StringIO()
+ self.to_client = StringIO()
+ self.client_medium = smart.SmartSimplePipesClientMedium(self.to_client,
+ self.to_server)
+ self.client_protocol = smart.SmartClientRequestProtocolOne(
+ self.client_medium)
+ self.smart_server = InstrumentedServerProtocol(self.server_to_client)
+ self.smart_server_request = smart.SmartServerRequestHandler(None)
def assertOffsetSerialisation(self, expected_offsets, expected_serialised,
- client, server_protocol):
+ client, smart_server_request):
"""Check that smart (de)serialises offsets as expected.
We check both serialisation and deserialisation at the same time
@@ -377,14 +1056,49 @@
:param expected_offsets: a readv offset list.
:param expected_seralised: an expected serial form of the offsets.
- :param server: a SmartServer instance.
+ :param smart_server_request: a SmartServerRequestHandler instance.
"""
- offsets = server_protocol.smart_server._deserialise_offsets(
- expected_serialised)
+ # XXX: 'smart_server_request' should be a SmartServerRequestProtocol in
+ # future.
+ offsets = smart_server_request._deserialise_offsets(expected_serialised)
self.assertEqual(expected_offsets, offsets)
serialised = client._serialise_offsets(offsets)
self.assertEqual(expected_serialised, serialised)
+ def build_protocol_waiting_for_body(self):
+ out_stream = StringIO()
+ protocol = smart.SmartServerRequestProtocolOne(None, out_stream.write)
+ protocol.has_dispatched = True
+ protocol.request = smart.SmartServerRequestHandler(None)
+ def handle_end_of_bytes():
+ self.end_received = True
+ self.assertEqual('abcdefg', protocol.request._body_bytes)
+ protocol.request.response = smart.SmartServerResponse(('ok', ))
+ protocol.request._end_of_body_handler = handle_end_of_bytes
+ # Call accept_bytes to make sure that internal state like _body_decoder
+ # is initialised. This test should probably be given a clearer
+ # interface to work with that will not cause this inconsistency.
+ # -- Andrew Bennetts, 2006-09-28
+ protocol.accept_bytes('')
+ return protocol
+
+ def test_construct_version_one_server_protocol(self):
+ protocol = smart.SmartServerRequestProtocolOne(None, None)
+ self.assertEqual('', protocol.excess_buffer)
+ self.assertEqual('', protocol.in_buffer)
+ self.assertFalse(protocol.has_dispatched)
+ # Once refactoring is complete, we don't need these assertions
+ self.assertFalse(hasattr(protocol, '_in'))
+ self.assertFalse(hasattr(protocol, '_out'))
+ self.assertEqual(1, protocol.next_read_size())
+
+ def test_construct_version_one_client_protocol(self):
+ # we can construct a client protocol from a client medium request
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(None, output)
+ request = medium.get_request()
+ client_protocol = smart.SmartClientRequestProtocolOne(request)
+
def test_server_offset_serialisation(self):
"""The Smart protocol serialises offsets as a comma and \n string.
@@ -393,15 +1107,392 @@
one that should coalesce.
"""
self.assertOffsetSerialisation([], '',
- self.smart_client, self.smart_server)
+ self.client_protocol, self.smart_server_request)
self.assertOffsetSerialisation([(1,2)], '1,2',
- self.smart_client, self.smart_server)
+ self.client_protocol, self.smart_server_request)
self.assertOffsetSerialisation([(10,40), (0,5)], '10,40\n0,5',
- self.smart_client, self.smart_server)
+ self.client_protocol, self.smart_server_request)
self.assertOffsetSerialisation([(1,2), (3,4), (100, 200)],
- '1,2\n3,4\n100,200', self.smart_client, self.smart_server)
-
-
+ '1,2\n3,4\n100,200', self.client_protocol, self.smart_server_request)
+
+ def test_accept_bytes_to_protocol(self):
+ out_stream = StringIO()
+ protocol = smart.SmartServerRequestProtocolOne(None, out_stream.write)
+ protocol.accept_bytes('abc')
+ self.assertEqual('abc', protocol.in_buffer)
+ protocol.accept_bytes('\n')
+ self.assertEqual("error\x01Generic bzr smart protocol error: bad request"
+ " u'abc'\n", out_stream.getvalue())
+ self.assertTrue(protocol.has_dispatched)
+ self.assertEqual(1, protocol.next_read_size())
+
+ def test_accept_body_bytes_to_protocol(self):
+ protocol = self.build_protocol_waiting_for_body()
+ self.assertEqual(6, protocol.next_read_size())
+ protocol.accept_bytes('7\nabc')
+ self.assertEqual(9, protocol.next_read_size())
+ protocol.accept_bytes('defgd')
+ protocol.accept_bytes('one\n')
+ self.assertEqual(0, protocol.next_read_size())
+ self.assertTrue(self.end_received)
+
+ def test_accept_request_and_body_all_at_once(self):
+ mem_transport = memory.MemoryTransport()
+ mem_transport.put_bytes('foo', 'abcdefghij')
+ out_stream = StringIO()
+ protocol = smart.SmartServerRequestProtocolOne(mem_transport,
+ out_stream.write)
+ protocol.accept_bytes('readv\x01foo\n3\n3,3done\n')
+ self.assertEqual(0, protocol.next_read_size())
+ self.assertEqual('readv\n3\ndefdone\n', out_stream.getvalue())
+ self.assertEqual('', protocol.excess_buffer)
+ self.assertEqual('', protocol.in_buffer)
+
+ def test_accept_excess_bytes_are_preserved(self):
+ out_stream = StringIO()
+ protocol = smart.SmartServerRequestProtocolOne(None, out_stream.write)
+ protocol.accept_bytes('hello\nhello\n')
+ self.assertEqual("ok\x011\n", out_stream.getvalue())
+ self.assertEqual("hello\n", protocol.excess_buffer)
+ self.assertEqual("", protocol.in_buffer)
+
+ def test_accept_excess_bytes_after_body(self):
+ protocol = self.build_protocol_waiting_for_body()
+ protocol.accept_bytes('7\nabcdefgdone\nX')
+ self.assertTrue(self.end_received)
+ self.assertEqual("X", protocol.excess_buffer)
+ self.assertEqual("", protocol.in_buffer)
+ protocol.accept_bytes('Y')
+ self.assertEqual("XY", protocol.excess_buffer)
+ self.assertEqual("", protocol.in_buffer)
+
+ def test_accept_excess_bytes_after_dispatch(self):
+ out_stream = StringIO()
+ protocol = smart.SmartServerRequestProtocolOne(None, out_stream.write)
+ protocol.accept_bytes('hello\n')
+ self.assertEqual("ok\x011\n", out_stream.getvalue())
+ protocol.accept_bytes('hel')
+ self.assertEqual("hel", protocol.excess_buffer)
+ protocol.accept_bytes('lo\n')
+ self.assertEqual("hello\n", protocol.excess_buffer)
+ self.assertEqual("", protocol.in_buffer)
+
+ def test_sync_with_request_sets_finished_reading(self):
+ protocol = smart.SmartServerRequestProtocolOne(None, None)
+ request = smart.SmartServerRequestHandler(None)
+ protocol.sync_with_request(request)
+ self.assertEqual(1, protocol.next_read_size())
+ request.finished_reading = True
+ protocol.sync_with_request(request)
+ self.assertEqual(0, protocol.next_read_size())
+
+ def test_query_version(self):
+ """query_version on a SmartClientProtocolOne should return a number.
+
+ The protocol provides the query_version because the domain level clients
+ may all need to be able to probe for capabilities.
+ """
+ # What we really want to test here is that SmartClientProtocolOne calls
+ # accept_bytes(tuple_based_encoding_of_hello) and reads and parses the
+ # response of tuple-encoded (ok, 1). Also, seperately we should test
+ # the error if the response is a non-understood version.
+ input = StringIO('ok\x011\n')
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ protocol = smart.SmartClientRequestProtocolOne(medium.get_request())
+ self.assertEqual(1, protocol.query_version())
+
+ def assertServerToClientEncoding(self, expected_bytes, expected_tuple,
+ input_tuples):
+ """Assert that each input_tuple serialises as expected_bytes, and the
+ bytes deserialise as expected_tuple.
+ """
+ # check the encoding of the server for all input_tuples matches
+ # expected bytes
+ for input_tuple in input_tuples:
+ server_output = StringIO()
+ server_protocol = smart.SmartServerRequestProtocolOne(
+ None, server_output.write)
+ server_protocol._send_response(input_tuple)
+ self.assertEqual(expected_bytes, server_output.getvalue())
+ # check the decoding of the client protocol from expected_bytes:
+ input = StringIO(expected_bytes)
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ protocol = smart.SmartClientRequestProtocolOne(medium.get_request())
+ protocol.call('foo')
+ self.assertEqual(expected_tuple, protocol.read_response_tuple())
+
+ def test_client_call_empty_response(self):
+ # protocol.call() can get back an empty tuple as a response. This occurs
+ # when the parsed line is an empty line, and results in a tuple with
+ # one element - an empty string.
+ self.assertServerToClientEncoding('\n', ('', ), [(), ('', )])
+
+ def test_client_call_three_element_response(self):
+ # protocol.call() can get back tuples of other lengths. A three element
+ # tuple should be unpacked as three strings.
+ self.assertServerToClientEncoding('a\x01b\x0134\n', ('a', 'b', '34'),
+ [('a', 'b', '34')])
+
+ def test_client_call_with_body_bytes_uploads(self):
+ # protocol.call_with_upload should length-prefix the bytes onto the
+ # wire.
+ expected_bytes = "foo\n7\nabcdefgdone\n"
+ input = StringIO("\n")
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ protocol = smart.SmartClientRequestProtocolOne(medium.get_request())
+ protocol.call_with_body_bytes(('foo', ), "abcdefg")
+ self.assertEqual(expected_bytes, output.getvalue())
+
+ def test_client_call_with_body_readv_array(self):
+ # protocol.call_with_upload should encode the readv array and then
+ # length-prefix the bytes onto the wire.
+ expected_bytes = "foo\n7\n1,2\n5,6done\n"
+ input = StringIO("\n")
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ protocol = smart.SmartClientRequestProtocolOne(medium.get_request())
+ protocol.call_with_body_readv_array(('foo', ), [(1,2),(5,6)])
+ self.assertEqual(expected_bytes, output.getvalue())
+
+ def test_client_read_body_bytes_all(self):
+ # read_body_bytes should decode the body bytes from the wire into
+ # a response.
+ expected_bytes = "1234567"
+ server_bytes = "ok\n7\n1234567done\n"
+ input = StringIO(server_bytes)
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ protocol = smart.SmartClientRequestProtocolOne(medium.get_request())
+ protocol.call('foo')
+ protocol.read_response_tuple(True)
+ self.assertEqual(expected_bytes, protocol.read_body_bytes())
+
+ def test_client_read_body_bytes_incremental(self):
+ # test reading a few bytes at a time from the body
+ # XXX: possibly we should test dribbling the bytes into the stringio
+ # to make the state machine work harder: however, as we use the
+ # LengthPrefixedBodyDecoder that is already well tested - we can skip
+ # that.
+ expected_bytes = "1234567"
+ server_bytes = "ok\n7\n1234567done\n"
+ input = StringIO(server_bytes)
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ protocol = smart.SmartClientRequestProtocolOne(medium.get_request())
+ protocol.call('foo')
+ protocol.read_response_tuple(True)
+ self.assertEqual(expected_bytes[0:2], protocol.read_body_bytes(2))
+ self.assertEqual(expected_bytes[2:4], protocol.read_body_bytes(2))
+ self.assertEqual(expected_bytes[4:6], protocol.read_body_bytes(2))
+ self.assertEqual(expected_bytes[6], protocol.read_body_bytes())
+
+ def test_client_cancel_read_body_does_not_eat_body_bytes(self):
+ # cancelling the expected body needs to finish the request, but not
+ # read any more bytes.
+ expected_bytes = "1234567"
+ server_bytes = "ok\n7\n1234567done\n"
+ input = StringIO(server_bytes)
+ output = StringIO()
+ medium = smart.SmartSimplePipesClientMedium(input, output)
+ protocol = smart.SmartClientRequestProtocolOne(medium.get_request())
+ protocol.call('foo')
+ protocol.read_response_tuple(True)
+ protocol.cancel_read_body()
+ self.assertEqual(3, input.tell())
+ self.assertRaises(errors.ReadingCompleted, protocol.read_body_bytes)
+
+
+class LengthPrefixedBodyDecoder(tests.TestCase):
+
+ # XXX: TODO: make accept_reading_trailer invoke translate_response or
+ # something similar to the ProtocolBase method.
+
+ def test_construct(self):
+ decoder = smart.LengthPrefixedBodyDecoder()
+ self.assertFalse(decoder.finished_reading)
+ self.assertEqual(6, decoder.next_read_size())
+ self.assertEqual('', decoder.read_pending_data())
+ self.assertEqual('', decoder.unused_data)
+
+ def test_accept_bytes(self):
+ decoder = smart.LengthPrefixedBodyDecoder()
+ decoder.accept_bytes('')
+ self.assertFalse(decoder.finished_reading)
+ self.assertEqual(6, decoder.next_read_size())
+ self.assertEqual('', decoder.read_pending_data())
+ self.assertEqual('', decoder.unused_data)
+ decoder.accept_bytes('7')
+ self.assertFalse(decoder.finished_reading)
+ self.assertEqual(6, decoder.next_read_size())
+ self.assertEqual('', decoder.read_pending_data())
+ self.assertEqual('', decoder.unused_data)
+ decoder.accept_bytes('\na')
+ self.assertFalse(decoder.finished_reading)
+ self.assertEqual(11, decoder.next_read_size())
+ self.assertEqual('a', decoder.read_pending_data())
+ self.assertEqual('', decoder.unused_data)
+ decoder.accept_bytes('bcdefgd')
+ self.assertFalse(decoder.finished_reading)
+ self.assertEqual(4, decoder.next_read_size())
+ self.assertEqual('bcdefg', decoder.read_pending_data())
+ self.assertEqual('', decoder.unused_data)
+ decoder.accept_bytes('one')
+ self.assertFalse(decoder.finished_reading)
+ self.assertEqual(1, decoder.next_read_size())
+ self.assertEqual('', decoder.read_pending_data())
+ self.assertEqual('', decoder.unused_data)
+ decoder.accept_bytes('\nblarg')
+ self.assertTrue(decoder.finished_reading)
+ self.assertEqual(1, decoder.next_read_size())
+ self.assertEqual('', decoder.read_pending_data())
+ self.assertEqual('blarg', decoder.unused_data)
+
+ def test_accept_bytes_all_at_once_with_excess(self):
+ decoder = smart.LengthPrefixedBodyDecoder()
+ decoder.accept_bytes('1\nadone\nunused')
+ self.assertTrue(decoder.finished_reading)
+ self.assertEqual(1, decoder.next_read_size())
+ self.assertEqual('a', decoder.read_pending_data())
+ self.assertEqual('unused', decoder.unused_data)
+
+ def test_accept_bytes_exact_end_of_body(self):
+ decoder = smart.LengthPrefixedBodyDecoder()
+ decoder.accept_bytes('1\na')
+ self.assertFalse(decoder.finished_reading)
+ self.assertEqual(5, decoder.next_read_size())
+ self.assertEqual('a', decoder.read_pending_data())
+ self.assertEqual('', decoder.unused_data)
+ decoder.accept_bytes('done\n')
+ self.assertTrue(decoder.finished_reading)
+ self.assertEqual(1, decoder.next_read_size())
+ self.assertEqual('', decoder.read_pending_data())
+ self.assertEqual('', decoder.unused_data)
+
+
+class FakeHTTPMedium(object):
+ def __init__(self):
+ self.written_request = None
+ self._current_request = None
+ def send_http_smart_request(self, bytes):
+ self.written_request = bytes
+ return None
+
+
+class HTTPTunnellingSmokeTest(tests.TestCaseWithTransport):
+
+ def _test_bulk_data(self, url_protocol):
+ # We should be able to send and receive bulk data in a single message.
+ # The 'readv' command in the smart protocol both sends and receives bulk
+ # data, so we use that.
+ self.build_tree(['data-file'])
+ http_server = HTTPServerWithSmarts()
+ http_server._url_protocol = url_protocol
+ http_server.setUp()
+ self.addCleanup(http_server.tearDown)
+
+ http_transport = get_transport(http_server.get_url())
+
+ medium = http_transport.get_smart_medium()
+ #remote_transport = RemoteTransport('fake_url', medium)
+ remote_transport = smart.SmartTransport('/', medium=medium)
+ self.assertEqual(
+ [(0, "c")], list(remote_transport.readv("data-file", [(0,1)])))
+
+ def test_bulk_data_pycurl(self):
+ self._test_bulk_data('http+pycurl')
+
+ def test_bulk_data_urllib(self):
+ self._test_bulk_data('http+urllib')
+
+ def test_smart_http_medium_request_accept_bytes(self):
+ medium = FakeHTTPMedium()
+ request = SmartClientHTTPMediumRequest(medium)
+ request.accept_bytes('abc')
+ request.accept_bytes('def')
+ self.assertEqual(None, medium.written_request)
+ request.finished_writing()
+ self.assertEqual('abcdef', medium.written_request)
+
+ def _test_http_send_smart_request(self, url_protocol):
+ http_server = HTTPServerWithSmarts()
+ http_server._url_protocol = url_protocol
+ http_server.setUp()
+ self.addCleanup(http_server.tearDown)
+
+ post_body = 'hello\n'
+ expected_reply_body = 'ok\x011\n'
+
+ http_transport = get_transport(http_server.get_url())
+ medium = http_transport.get_smart_medium()
+ response = medium.send_http_smart_request(post_body)
+ reply_body = response.read()
+ self.assertEqual(expected_reply_body, reply_body)
+
+ def test_http_send_smart_request_pycurl(self):
+ self._test_http_send_smart_request('http+pycurl')
+
+ def test_http_send_smart_request_urllib(self):
+ self._test_http_send_smart_request('http+urllib')
+
+ def test_http_server_with_smarts(self):
+ http_server = HTTPServerWithSmarts()
+ http_server.setUp()
+ self.addCleanup(http_server.tearDown)
+
+ post_body = 'hello\n'
+ expected_reply_body = 'ok\x011\n'
+
+ smart_server_url = http_server.get_url() + '.bzr/smart'
+ reply = urllib2.urlopen(smart_server_url, post_body).read()
+
+ self.assertEqual(expected_reply_body, reply)
+
+ def test_smart_http_server_post_request_handler(self):
+ http_server = HTTPServerWithSmarts()
+ http_server.setUp()
+ self.addCleanup(http_server.tearDown)
+ httpd = http_server._get_httpd()
+
+ socket = SampleSocket(
+ 'POST /.bzr/smart HTTP/1.0\r\n'
+ # HTTP/1.0 posts must have a Content-Length.
+ 'Content-Length: 6\r\n'
+ '\r\n'
+ 'hello\n')
+ request_handler = SmartRequestHandler(
+ socket, ('localhost', 80), httpd)
+ response = socket.writefile.getvalue()
+ self.assertStartsWith(response, 'HTTP/1.0 200 ')
+ # This includes the end of the HTTP headers, and all the body.
+ expected_end_of_response = '\r\n\r\nok\x011\n'
+ self.assertEndsWith(response, expected_end_of_response)
+
+
+class SampleSocket(object):
+ """A socket-like object for use in testing the HTTP request handler."""
+
+ def __init__(self, socket_read_content):
+ """Constructs a sample socket.
+
+ :param socket_read_content: a byte sequence
+ """
+ # Use plain python StringIO so we can monkey-patch the close method to
+ # not discard the contents.
+ from StringIO import StringIO
+ self.readfile = StringIO(socket_read_content)
+ self.writefile = StringIO()
+ self.writefile.close = lambda: None
+
+ def makefile(self, mode='r', bufsize=None):
+ if 'r' in mode:
+ return self.readfile
+ else:
+ return self.writefile
+
+
# TODO: Client feature that does get_bundle and then installs that into a
# branch; this can be used in place of the regular pull/fetch operation when
# coming from a smart server.
=== modified file bzrlib/tests/test_transport_implementations.py // last-change
... d:robertc at robertcollins.net-20060922043958-628ce589a155a56e
--- bzrlib/tests/test_transport_implementations.py
+++ bzrlib/tests/test_transport_implementations.py
@@ -897,6 +897,8 @@
except NotImplementedError:
raise TestSkipped("Transport %s has no bogus URL support." %
self._server.__class__)
+ # This should be: but SSH still connects on construction. No COOKIE!
+ # self.assertRaises((ConnectionError, NoSuchFile), t.get, '.bzr/branch')
try:
t = bzrlib.transport.get_transport(url)
t.get('.bzr/branch')
@@ -1309,19 +1311,14 @@
self.assertEqual(d[2], (0, '0'))
self.assertEqual(d[3], (3, '34'))
- def test_get_smart_client(self):
- """All transports must either give a smart client, or know they can't.
-
- For some transports such as http this might depend on probing to see
- what's actually present on the other end. (But we can adjust for that
- in the future.)
+ def test_get_smart_medium(self):
+ """All transports must either give a smart medium, or know they can't.
"""
transport = self.get_transport()
try:
- client = transport.get_smart_client()
- # XXX: should be a more general class
- self.assertIsInstance(client, smart.SmartStreamClient)
- except NoSmartServer:
+ medium = transport.get_smart_medium()
+ self.assertIsInstance(medium, smart.SmartClientMedium)
+ except errors.NoSmartMedium:
# as long as we got it we're fine
pass
=== modified file bzrlib/transport/__init__.py // last-changed:andrew.bennetts@
... canonical.com-20060921091520-673c55c101a86614
--- bzrlib/transport/__init__.py
+++ bzrlib/transport/__init__.py
@@ -444,10 +444,23 @@
def get_smart_client(self):
"""Return a smart client for this transport if possible.
+ A smart client doesn't imply the presence of a smart server: it implies
+ that the smart protocol can be tunnelled via this transport.
+
:raises NoSmartServer: if no smart server client is available.
"""
raise errors.NoSmartServer(self.base)
+ def get_smart_medium(self):
+ """Return a smart client medium for this transport if possible.
+
+ A smart medium doesn't imply the presence of a smart server: it implies
+ that the smart protocol can be tunnelled via this transport.
+
+ :raises NoSmartMedium: if no smart server medium is available.
+ """
+ raise errors.NoSmartMedium(self)
+
def readv(self, relpath, offsets):
"""Get parts of the file at the given relative path.
=== modified file bzrlib/transport/http/__init__.py
--- bzrlib/transport/http/__init__.py
+++ bzrlib/transport/http/__init__.py
@@ -39,7 +39,13 @@
TransportError, ConnectionError, InvalidURL)
from bzrlib.branch import Branch
from bzrlib.trace import mutter
-from bzrlib.transport import Transport, register_transport, Server
+from bzrlib.transport import (
+ get_transport,
+ register_transport,
+ Server,
+ smart,
+ Transport,
+ )
from bzrlib.transport.http.response import (HttpMultipartRangeResponse,
HttpRangeResponse)
from bzrlib.ui import ui_factory
@@ -119,7 +125,7 @@
return m
-class HttpTransportBase(Transport):
+class HttpTransportBase(Transport, smart.SmartClientMedium):
"""Base class for http implementations.
Does URL parsing, etc, but not any network IO.
@@ -238,6 +244,17 @@
"""
raise NotImplementedError(self._get)
+ def get_request(self):
+ return SmartClientHTTPMediumRequest(self)
+
+ def get_smart_medium(self):
+ """See Transport.get_smart_medium.
+
+ HttpTransportBase directly implements the minimal interface of
+ SmartMediumClient, so this returns self.
+ """
+ return self
+
def readv(self, relpath, offsets):
"""Get parts of the file at the given relative path.
@@ -284,6 +301,17 @@
return combined
+ def _post(self, body_bytes):
+ """POST body_bytes to .bzr/smart on this transport.
+
+ :returns: (response code, response body file-like object).
+ """
+ # TODO: Requiring all the body_bytes to be available at the beginning of
+ # the POST may require large client buffers. It would be nice to have
+ # an interface that allows streaming via POST when possible (and
+ # degrades to a local buffer when not).
+ raise NotImplementedError(self._post)
+
def put_file(self, relpath, f, mode=None):
"""Copy the file-like object into the location.
@@ -397,6 +425,33 @@
return ','.join(strings)
+ def send_http_smart_request(self, bytes):
+ code, body_filelike = self._post(bytes)
+ assert code == 200, 'unexpected HTTP response code %r' % (code,)
+ return body_filelike
+
+
+class SmartClientHTTPMediumRequest(smart.SmartClientMediumRequest):
+ """A SmartClientMediumRequest that works with an HTTP medium."""
+
+ def __init__(self, medium):
+ smart.SmartClientMediumRequest.__init__(self, medium)
+ self._buffer = ''
+
+ def _accept_bytes(self, bytes):
+ self._buffer += bytes
+
+ def _finished_writing(self):
+ data = self._medium.send_http_smart_request(self._buffer)
+ self._response_body = data
+
+ def _read_bytes(self, count):
+ return self._response_body.read(count)
+
+ def _finished_reading(self):
+ """See SmartClientMediumRequest._finished_reading."""
+ pass
+
#---------------- test server facilities ----------------
# TODO: load these only when running tests
@@ -502,11 +557,13 @@
Server.__init__(self)
self.request_handler = request_handler
- def _http_start(self):
- httpd = None
- httpd = TestingHTTPServer(('localhost', 0),
+ def _get_httpd(self):
+ return TestingHTTPServer(('localhost', 0),
self.request_handler,
self)
+
+ def _http_start(self):
+ httpd = self._get_httpd()
host, port = httpd.socket.getsockname()
self._http_base_url = '%s://localhost:%s/' % (self._url_protocol, port)
self._http_starting.release()
@@ -570,3 +627,45 @@
# etc
return 'http://127.0.0.1:1/'
+
+class HTTPServerWithSmarts(HttpServer):
+ """HTTPServerWithSmarts extends the HttpServer with POST methods that will
+ trigger a smart server to execute with a transport rooted at the rootdir of
+ the HTTP server.
+ """
+
+ def __init__(self):
+ HttpServer.__init__(self, SmartRequestHandler)
+
+
+class SmartRequestHandler(TestingHTTPRequestHandler):
+ """Extend TestingHTTPRequestHandler to support smart client POSTs."""
+
+ def do_POST(self):
+ """Hand the request off to a smart server instance."""
+ self.send_response(200)
+ self.send_header("Content-type", "application/octet-stream")
+ transport = get_transport(self.server.test_case._home_dir)
+ # TODO: We might like to support streaming responses. 1.0 allows no
+ # Content-length in this case, so for integrity we should perform our
+ # own chunking within the stream.
+ # 1.1 allows chunked responses, and in this case we could chunk using
+ # the HTTP chunking as this will allow HTTP persistence safely, even if
+ # we have to stop early due to error, but we would also have to use the
+ # HTTP trailer facility which may not be widely available.
+ out_buffer = StringIO()
+ smart_protocol_request = smart.SmartServerRequestProtocolOne(
+ transport, out_buffer.write)
+ # if this fails, we should return 400 bad request, but failure is
+ # failure for now - RBC 20060919
+ data_length = int(self.headers['Content-Length'])
+ # Perhaps there should be a SmartServerHTTPMedium that takes care of
+ # feeding the bytes in the http request to the smart_protocol_request,
+ # but for now it's simpler to just feed the bytes directly.
+ smart_protocol_request.accept_bytes(self.rfile.read(data_length))
+ assert smart_protocol_request.next_read_size() == 0, (
+ "not finished reading, but all data sent to protocol.")
+ self.send_header("Content-Length", str(len(out_buffer.getvalue())))
+ self.end_headers()
+ self.wfile.write(out_buffer.getvalue())
+
=== modified file bzrlib/transport/http/_pycurl.py // last-changed:andrew.benne
... tts at canonical.com-20060926054631-7d63ee5c801fb098
--- bzrlib/transport/http/_pycurl.py
+++ bzrlib/transport/http/_pycurl.py
@@ -77,10 +77,12 @@
if from_transport is not None:
self._base_curl = from_transport._base_curl
self._range_curl = from_transport._range_curl
+ self._post_curl = from_transport._post_curl
else:
mutter('using pycurl %s' % pycurl.version)
self._base_curl = pycurl.Curl()
self._range_curl = pycurl.Curl()
+ self._post_curl = pycurl.Curl()
def should_cache(self):
"""Return True if the data pulled across should be cached locally.
@@ -115,6 +117,14 @@
return self._get_full(relpath)
def _setup_get_request(self, curl, relpath):
+ # Make sure we do a GET request. versions > 7.14.1 also set the
+ # NO BODY flag, but we'll do it ourselves in case it is an older
+ # pycurl version
+ curl.setopt(pycurl.NOBODY, 0)
+ curl.setopt(pycurl.HTTPGET, 1)
+ return self._setup_request(curl, relpath)
+
+ def _setup_request(self, curl, relpath):
"""Do the common setup stuff for making a request
:param curl: The curl object to place the request on
@@ -127,11 +137,6 @@
abspath = self._real_abspath(relpath)
curl.setopt(pycurl.URL, abspath)
self._set_curl_options(curl)
- # Make sure we do a GET request. versions > 7.14.1 also set the
- # NO BODY flag, but we'll do it ourselves in case it is an older
- # pycurl version
- curl.setopt(pycurl.NOBODY, 0)
- curl.setopt(pycurl.HTTPGET, 1)
data = StringIO()
header = StringIO()
@@ -179,6 +184,19 @@
# handle_response will raise NoSuchFile, etc based on the response code
return code, response.handle_response(abspath, code, headers, data)
+ def _post(self, body_bytes):
+ fake_file = StringIO(body_bytes)
+ curl = self._post_curl
+ curl.setopt(pycurl.POST, 1)
+ curl.setopt(pycurl.POSTFIELDSIZE, len(body_bytes))
+ curl.setopt(pycurl.READFUNCTION, fake_file.read)
+ abspath, data, header = self._setup_request(curl, '.bzr/smart')
+ self._curl_perform(curl)
+ data.seek(0)
+ code = curl.getinfo(pycurl.HTTP_CODE)
+ headers = _extract_headers(header.getvalue(), abspath)
+ return code, response.handle_response(abspath, code, headers, data)
+
def _raise_curl_connection_error(self, curl):
curl_errno = curl.getinfo(pycurl.OS_ERRNO)
url = curl.getinfo(pycurl.EFFECTIVE_URL)
@@ -200,9 +218,12 @@
# There's no way in http/1.0 to say "must revalidate"; we don't want
# to force it to always retrieve. so just turn off the default Pragma
# provided by Curl.
+ # Also, we override the Expect: header so that pycurl will send the POST
+ # body immediately.
headers = ['Cache-control: max-age=0',
'Pragma: no-cache',
- 'Connection: Keep-Alive']
+ 'Connection: Keep-Alive',
+ 'Expect: ',]
## curl.setopt(pycurl.VERBOSE, 1)
# TODO: maybe include a summary of the pycurl version
ua_str = 'bzr/%s (pycurl)' % (bzrlib.__version__,)
=== modified file bzrlib/transport/http/_urllib.py // last-changed:andrew.benne
... tts at canonical.com-20060925164146-200a3de7084173eb
--- bzrlib/transport/http/_urllib.py
+++ bzrlib/transport/http/_urllib.py
@@ -54,11 +54,14 @@
# so nothing to do with from_transport
def _get(self, relpath, ranges, tail_amount=0):
+ return self._request(relpath, 'GET', ranges, tail_amount=tail_amount)
+
+ def _request(self, relpath, method, ranges, tail_amount=0, body=None):
path = relpath
try:
path = self._real_abspath(relpath)
- resp = self._get_url_impl(path, method='GET', ranges=ranges,
- tail_amount=tail_amount)
+ resp = self._get_url_impl(path, method=method, ranges=ranges,
+ tail_amount=tail_amount, body=body)
return resp.code, response.handle_response(path,
resp.code, resp.headers, resp)
except urllib2.HTTPError, e:
@@ -76,7 +79,7 @@
% (self.abspath(relpath), str(e)),
orig_error=e)
- def _get_url_impl(self, url, method, ranges, tail_amount=0):
+ def _get_url_impl(self, url, method, ranges, tail_amount=0, body=None):
"""Actually pass get request into urllib
:returns: urllib Response object
@@ -87,6 +90,8 @@
opener = urllib2.build_opener(auth_handler)
request = Request(url)
request.method = method
+ if body is not None:
+ request.add_data(body)
request.add_header('Pragma', 'no-cache')
request.add_header('Cache-control', 'max-age=0')
request.add_header('User-Agent',
@@ -97,6 +102,9 @@
response = opener.open(request)
return response
+ def _post(self, body_bytes):
+ return self._request('.bzr/smart', 'POST', [], body=body_bytes)
+
def should_cache(self):
"""Return True if the data pulled across should be cached locally.
"""
=== modified file bzrlib/transport/smart.py
--- bzrlib/transport/smart.py
+++ bzrlib/transport/smart.py
@@ -46,6 +46,66 @@
URLs that include ~ should probably be passed across to the server verbatim
and the server can expand them. This will proably not be meaningful when
limited to a directory?
+
+At the bottom level socket, pipes, HTTP server. For sockets, we have the
+idea that you have multiple requests and get have a read error because the
+other side did shutdown sd send. For pipes we have read pipe which will have a
+zero read which marks end-of-file. For HTTP server environment there is not
+end-of-stream because each request coming into the server is independent.
+
+So we need a wrapper around pipes and sockets to seperate out reqeusts from
+substrate and this will give us a single model which is consist for HTTP,
+sockets and pipes.
+
+Server-side
+-----------
+
+ MEDIUM (factory for protocol, reads bytes & pushes to protocol,
+ uses protocol to detect end-of-request, sends written
+ bytes to client) e.g. socket, pipe, HTTP request handler.
+ ^
+ | bytes.
+ v
+
+PROTOCOL (serialisation, deserialisation) accepts bytes for one
+ request, decodes according to internal state, pushes
+ structured data to handler. accepts structured data from
+ handler and encodes and writes to the medium. factory for
+ handler.
+ ^
+ | structured data
+ v
+
+HANDLER (domain logic) accepts structured data, operates state
+ machine until the request can be satisfied,
+ sends structured data to the protocol.
+
+
+Client-side
+-----------
+
+ CLIENT domain logic, accepts domain requests, generated structured
+ data, reads structured data from responses and turns into
+ domain data. Sends structured data to the protocol.
+ Operates state machines until the request can be delivered
+ (e.g. reading from a bundle generated in bzrlib to deliver a
+ complete request).
+
+ Possibly this should just be RemoteBzrDir, RemoteTransport,
+ ...
+ ^
+ | structured data
+ v
+
+PROTOCOL (serialisation, deserialisation) accepts structured data for one
+ request, encodes and writes to the medium. Reads bytes from the
+ medium, decodes and allows the client to read structured data.
+ ^
+ | bytes.
+ v
+
+ MEDIUM (accepts bytes from the protocol & delivers to the remote server.
+ Allows the potocol to read bytes e.g. socket, pipe, HTTP request.
"""
@@ -137,14 +197,13 @@
# the socket, and it assumes everything is UTF8 sections separated
# by \001. Which means a request like '\002' Will abort the connection
# because of a UnicodeDecodeError. It does look like invalid data will
-# kill the SmartStreamServer, but only with an abort + exception, and
+# kill the SmartServerStreamMedium, but only with an abort + exception, and
# the overall server shouldn't die.
from cStringIO import StringIO
-import errno
import os
+import select
import socket
-import sys
import tempfile
import threading
import urllib
@@ -159,8 +218,6 @@
urlutils,
)
from bzrlib.bundle.serializer import write_bundle
-from bzrlib.trace import mutter
-from bzrlib.transport import local
# must do this otherwise urllib can't parse the urls properly :(
for scheme in ['ssh', 'bzr', 'bzr+loopback', 'bzr+ssh']:
@@ -189,35 +246,11 @@
class SmartProtocolBase(object):
"""Methods common to client and server"""
- def _send_bulk_data(self, body):
- """Send chunked body data"""
- assert isinstance(body, str)
- bytes = ''.join(('%d\n' % len(body), body, 'done\n'))
- self._write_and_flush(bytes)
-
# TODO: this only actually accomodates a single block; possibly should support
# multiple chunks?
- def _recv_bulk(self):
- chunk_len = self._in.readline()
- try:
- chunk_len = int(chunk_len)
- except ValueError:
- raise errors.SmartProtocolError("bad chunk length line %r" % chunk_len)
- bulk = self._in.read(chunk_len)
- if len(bulk) != chunk_len:
- raise errors.SmartProtocolError("short read fetching bulk data chunk")
- self._recv_trailer()
- return bulk
-
- def _recv_tuple(self):
- return _recv_tuple(self._in)
-
- def _recv_trailer(self):
- resp = self._recv_tuple()
- if resp == ('done', ):
- return
- else:
- self._translate_error(resp)
+ def _encode_bulk_data(self, body):
+ """Encode body as a bulk data chunk."""
+ return ''.join(('%d\n' % len(body), body, 'done\n'))
def _serialise_offsets(self, offsets):
"""Serialise a readv offset list."""
@@ -226,14 +259,209 @@
txt.append('%d,%d' % (start, length))
return '\n'.join(txt)
- def _write_and_flush(self, bytes):
+ def _send_bulk_data(self, body, a_file=None):
+ """Send chunked body data"""
+ assert isinstance(body, str)
+ bytes = self._encode_bulk_data(body)
+ self._write_and_flush(bytes, a_file)
+
+ def _write_and_flush(self, bytes, a_file=None):
"""Write bytes to self._out and flush it."""
# XXX: this will be inefficient. Just ask Robert.
- self._out.write(bytes)
- self._out.flush()
-
-
-class SmartStreamServer(SmartProtocolBase):
+ if a_file is None:
+ a_file = self._out
+ a_file.write(bytes)
+ a_file.flush()
+
+
+class SmartServerRequestProtocolOne(SmartProtocolBase):
+ """Server-side encoding and decoding logic for smart version 1."""
+
+ def __init__(self, backing_transport, write_func):
+ self._backing_transport = backing_transport
+ self.excess_buffer = ''
+ self._finished_reading = False
+ self.in_buffer = ''
+ self.has_dispatched = False
+ self.request = None
+ self._body_decoder = None
+ self._write_func = write_func
+
+ def accept_bytes(self, bytes):
+ """Take bytes, and advance the internal state machine appropriately.
+
+ :param bytes: must be a byte string
+ """
+ assert isinstance(bytes, str)
+ self.in_buffer += bytes
+ if not self.has_dispatched:
+ if '\n' not in self.in_buffer:
+ # no command line yet
+ return
+ self.has_dispatched = True
+ # XXX if in_buffer not \n-terminated this will do the wrong
+ # thing.
+ try:
+ first_line, self.in_buffer = self.in_buffer.split('\n', 1)
+ first_line += '\n'
+ req_args = _decode_tuple(first_line)
+ self.request = SmartServerRequestHandler(
+ self._backing_transport)
+ self.request.dispatch_command(req_args[0], req_args[1:])
+ if self.request.finished_reading:
+ # trivial request
+ self.excess_buffer = self.in_buffer
+ self.in_buffer = ''
+ self._send_response(self.request.response.args,
+ self.request.response.body)
+ self.sync_with_request(self.request)
+ except KeyboardInterrupt:
+ raise
+ except Exception, exception:
+ # everything else: pass to client, flush, and quit
+ self._send_response(('error', str(exception)))
+ return None
+
+ if self.has_dispatched:
+ if self._finished_reading:
+ # nothing to do.XXX: this routine should be a single state
+ # machine too.
+ self.excess_buffer += self.in_buffer
+ self.in_buffer = ''
+ return
+ if self._body_decoder is None:
+ self._body_decoder = LengthPrefixedBodyDecoder()
+ self._body_decoder.accept_bytes(self.in_buffer)
+ self.in_buffer = self._body_decoder.unused_data
+ body_data = self._body_decoder.read_pending_data()
+ self.request.accept_body(body_data)
+ if self._body_decoder.finished_reading:
+ self.request.end_of_body()
+ assert self.request.finished_reading, \
+ "no more body, request not finished"
+ self.sync_with_request(self.request)
+ if self.request.response is not None:
+ self._send_response(self.request.response.args,
+ self.request.response.body)
+ self.excess_buffer = self.in_buffer
+ self.in_buffer = ''
+ else:
+ assert not self.request.finished_reading, \
+ "no response and we have finished reading."
+
+ def _send_response(self, args, body=None):
+ """Send a smart server response down the output stream."""
+ self._write_func(_encode_tuple(args))
+ if body is not None:
+ assert isinstance(body, str), 'body must be a str'
+ bytes = self._encode_bulk_data(body)
+ self._write_func(bytes)
+ #self._send_bulk_data(body, self._out_stream)
+
+ def sync_with_request(self, request):
+ self._finished_reading = request.finished_reading
+
+ def next_read_size(self):
+ if self._finished_reading:
+ return 0
+ if self._body_decoder is None:
+ return 1
+ else:
+ return self._body_decoder.next_read_size()
+
+
+class LengthPrefixedBodyDecoder(object):
+ """Decodes the length-prefixed bulk data."""
+
+ def __init__(self):
+ self.bytes_left = None
+ self.finished_reading = False
+ self.unused_data = ''
+ self.state_accept = self._state_accept_expecting_length
+ self.state_read = self._state_read_no_data
+ self._in_buffer = ''
+ self._trailer_buffer = ''
+
+ def accept_bytes(self, bytes):
+ """Decode as much of bytes as possible.
+
+ If 'bytes' contains too much data it will be appended to
+ self.unused_data.
+
+ finished_reading will be set when no more data is required. Further
+ data will be appended to self.unused_data.
+ """
+ # accept_bytes is allowed to change the state
+ current_state = self.state_accept
+ self.state_accept(bytes)
+ while current_state != self.state_accept:
+ current_state = self.state_accept
+ self.state_accept('')
+
+ def next_read_size(self):
+ if self.bytes_left is not None:
+ # Ideally we want to read all the remainder of the body and the
+ # trailer in one go.
+ return self.bytes_left + 5
+ elif self.state_accept == self._state_accept_reading_trailer:
+ # Just the trailer left
+ return 5 - len(self._trailer_buffer)
+ elif self.state_accept == self._state_accept_expecting_length:
+ # There's still at least 6 bytes left ('\n' to end the length, plus
+ # 'done\n').
+ return 6
+ else:
+ # Reading excess data. Either way, 1 byte at a time is fine.
+ return 1
+
+ def read_pending_data(self):
+ """Return any pending data that has been decoded."""
+ return self.state_read()
+
+ def _state_accept_expecting_length(self, bytes):
+ self._in_buffer += bytes
+ pos = self._in_buffer.find('\n')
+ if pos == -1:
+ return
+ self.bytes_left = int(self._in_buffer[:pos])
+ self._in_buffer = self._in_buffer[pos+1:]
+ self.bytes_left -= len(self._in_buffer)
+ self.state_accept = self._state_accept_reading_body
+ self.state_read = self._state_read_in_buffer
+
+ def _state_accept_reading_body(self, bytes):
+ self._in_buffer += bytes
+ self.bytes_left -= len(bytes)
+ if self.bytes_left <= 0:
+ # Finished with body
+ if self.bytes_left != 0:
+ self._trailer_buffer = self._in_buffer[self.bytes_left:]
+ self._in_buffer = self._in_buffer[:self.bytes_left]
+ self.bytes_left = None
+ self.state_accept = self._state_accept_reading_trailer
+
+ def _state_accept_reading_trailer(self, bytes):
+ self._trailer_buffer += bytes
+ # TODO: what if the trailer does not match "done\n"? Should this raise
+ # a ProtocolViolation exception?
+ if self._trailer_buffer.startswith('done\n'):
+ self.unused_data = self._trailer_buffer[len('done\n'):]
+ self.state_accept = self._state_accept_reading_unused
+ self.finished_reading = True
+
+ def _state_accept_reading_unused(self, bytes):
+ self.unused_data += bytes
+
+ def _state_read_no_data(self):
+ return ''
+
+ def _state_read_in_buffer(self):
+ result = self._in_buffer
+ self._in_buffer = ''
+ return result
+
+
+class SmartServerStreamMedium(object):
"""Handles smart commands coming over a stream.
The stream may be a pipe connected to sshd, or a tcp socket, or an
@@ -246,6 +474,86 @@
which will typically be a LocalTransport looking at the server's filesystem.
"""
+ def __init__(self, backing_transport):
+ """Construct new server.
+
+ :param backing_transport: Transport for the directory served.
+ """
+ # backing_transport could be passed to serve instead of __init__
+ self.backing_transport = backing_transport
+ self.finished = False
+
+ def serve(self):
+ """Serve requests until the client disconnects."""
+ # Keep a reference to stderr because the sys module's globals get set to
+ # None during interpreter shutdown.
+ from sys import stderr
+ try:
+ while not self.finished:
+ protocol = SmartServerRequestProtocolOne(self.backing_transport,
+ self._write_out)
+ self._serve_one_request(protocol)
+ except Exception, e:
+ stderr.write("%s terminating on exception %s\n" % (self, e))
+ raise
+
+ def _serve_one_request(self, protocol):
+ """Read one request from input, process, send back a response.
+
+ :param protocol: a SmartServerRequestProtocol.
+ """
+ try:
+ self._serve_one_request_unguarded(protocol)
+ except KeyboardInterrupt:
+ raise
+ except Exception, e:
+ self.terminate_due_to_error()
+
+ def terminate_due_to_error(self):
+ """Called when an unhandled exception from the protocol occurs."""
+ raise NotImplementedError(self.terminate_due_to_error)
+
+
+class SmartServerSocketStreamMedium(SmartServerStreamMedium):
+
+ def __init__(self, sock, backing_transport):
+ """Constructor.
+
+ :param sock: the socket the server will read from. It will be put
+ into blocking mode.
+ """
+ SmartServerStreamMedium.__init__(self, backing_transport)
+ self.push_back = ''
+ sock.setblocking(True)
+ self.socket = sock
+
+ def _serve_one_request_unguarded(self, protocol):
+ while protocol.next_read_size():
+ if self.push_back:
+ protocol.accept_bytes(self.push_back)
+ self.push_back = ''
+ else:
+ bytes = self.socket.recv(4096)
+ if bytes == '':
+ self.finished = True
+ return
+ protocol.accept_bytes(bytes)
+
+ self.push_back = protocol.excess_buffer
+
+ def terminate_due_to_error(self):
+ """Called when an unhandled exception from the protocol occurs."""
+ # TODO: This should log to a server log file, but no such thing
+ # exists yet. Andrew Bennetts 2006-09-29.
+ self.socket.close()
+ self.finished = True
+
+ def _write_out(self, bytes):
+ self.socket.sendall(bytes)
+
+
+class SmartServerPipeStreamMedium(SmartServerStreamMedium):
+
def __init__(self, in_file, out_file, backing_transport):
"""Construct new server.
@@ -253,95 +561,88 @@
:param out_file: Python file to write responses.
:param backing_transport: Transport for the directory served.
"""
+ SmartServerStreamMedium.__init__(self, backing_transport)
self._in = in_file
self._out = out_file
- self.smart_server = SmartServer(backing_transport)
- # server can call back to us to get bulk data - this is not really
- # ideal, they should get it per request instead
- self.smart_server._recv_body = self._recv_bulk
-
- def _recv_tuple(self):
- """Read a request from the client and return as a tuple.
-
- Returns None at end of file (if the client closed the connection.)
- """
- return _recv_tuple(self._in)
-
- def _send_tuple(self, args):
- """Send response header"""
- return self._write_and_flush(_encode_tuple(args))
-
- def _send_error_and_disconnect(self, exception):
- self._send_tuple(('error', str(exception)))
- ## self._out.close()
- ## self._in.close()
-
- def _serve_one_request(self):
- """Read one request from input, process, send back a response.
-
- :return: False if the server should terminate, otherwise None.
- """
- req_args = self._recv_tuple()
- if req_args == None:
- # client closed connection
- return False # shutdown server
- try:
- response = self.smart_server.dispatch_command(req_args[0], req_args[1:])
- self._send_tuple(response.args)
- if response.body is not None:
- self._send_bulk_data(response.body)
- except KeyboardInterrupt:
- raise
- except Exception, e:
- # everything else: pass to client, flush, and quit
- self._send_error_and_disconnect(e)
- return False
-
- def serve(self):
- """Serve requests until the client disconnects."""
- # Keep a reference to stderr because the sys module's globals get set to
- # None during interpreter shutdown.
- from sys import stderr
- try:
- while self._serve_one_request() != False:
- pass
- except Exception, e:
- stderr.write("%s terminating on exception %s\n" % (self, e))
- raise
+
+ def _serve_one_request_unguarded(self, protocol):
+ while True:
+ bytes_to_read = protocol.next_read_size()
+ if bytes_to_read == 0:
+ # Finished serving this request.
+ self._out.flush()
+ return
+ bytes = self._in.read(bytes_to_read)
+ if bytes == '':
+ # Connection has been closed.
+ self.finished = True
+ self._out.flush()
+ return
+ protocol.accept_bytes(bytes)
+
+ def terminate_due_to_error(self):
+ # TODO: This should log to a server log file, but no such thing
+ # exists yet. Andrew Bennetts 2006-09-29.
+ self._out.close()
+ self.finished = True
+
+ def _write_out(self, bytes):
+ self._out.write(bytes)
class SmartServerResponse(object):
- """Response generated by SmartServer."""
+ """Response generated by SmartServerRequestHandler."""
def __init__(self, args, body=None):
self.args = args
self.body = body
-# XXX: TODO: Create a SmartServerRequest which will take the responsibility
+# XXX: TODO: Create a SmartServerRequestHandler which will take the responsibility
# for delivering the data for a request. This could be done with as the
# StreamServer, though that would create conflation between request and response
# which may be undesirable.
-class SmartServer(object):
+class SmartServerRequestHandler(object):
"""Protocol logic for smart server.
This doesn't handle serialization at all, it just processes requests and
creates responses.
"""
- # IMPORTANT FOR IMPLEMENTORS: It is important that SmartServer not contain
- # encoding or decoding logic to allow the wire protocol to vary from the
- # object protocol: we will want to tweak the wire protocol separate from
- # the object model, and ideally we will be able to do that without having
- # a SmartServer subclass for each wire protocol, rather just a Protocol
- # subclass.
+ # IMPORTANT FOR IMPLEMENTORS: It is important that SmartServerRequestHandler
+ # not contain encoding or decoding logic to allow the wire protocol to vary
+ # from the object protocol: we will want to tweak the wire protocol separate
+ # from the object model, and ideally we will be able to do that without
+ # having a SmartServerRequestHandler subclass for each wire protocol, rather
+ # just a Protocol subclass.
# TODO: Better way of representing the body for commands that take it,
# and allow it to be streamed into the server.
def __init__(self, backing_transport):
self._backing_transport = backing_transport
+ self._converted_command = False
+ self.finished_reading = False
+ self._body_bytes = ''
+ self.response = None
+
+ def accept_body(self, bytes):
+ """Accept body data.
+
+ This should be overriden for each command that desired body data to
+ handle the right format of that data. I.e. plain bytes, a bundle etc.
+
+ The deserialisation into that format should be done in the Protocol
+ object. Set self.desired_body_format to the format your method will
+ handle.
+ """
+ # default fallback is to accumulate bytes.
+ self._body_bytes += bytes
+
+ def _end_of_body_handler(self):
+ """An unimplemented end of body handler."""
+ raise NotImplementedError(self._end_of_body_handler)
def do_hello(self):
"""Answer a version request with my version."""
@@ -363,9 +664,15 @@
return int(mode)
def do_append(self, relpath, mode):
+ self._converted_command = True
+ self._relpath = relpath
+ self._mode = self._deserialise_optional_mode(mode)
+ self._end_of_body_handler = self._handle_do_append_end
+
+ def _handle_do_append_end(self):
old_length = self._backing_transport.append_bytes(
- relpath, self._recv_body(), self._deserialise_optional_mode(mode))
- return SmartServerResponse(('appended', '%d' % old_length))
+ self._relpath, self._body_bytes, self._mode)
+ self.response = SmartServerResponse(('appended', '%d' % old_length))
def do_delete(self, relpath):
self._backing_transport.delete(relpath)
@@ -389,9 +696,15 @@
self._backing_transport.move(rel_from, rel_to)
def do_put(self, relpath, mode):
- self._backing_transport.put_bytes(relpath,
- self._recv_body(),
- self._deserialise_optional_mode(mode))
+ self._converted_command = True
+ self._relpath = relpath
+ self._mode = self._deserialise_optional_mode(mode)
+ self._end_of_body_handler = self._handle_do_put
+
+ def _handle_do_put(self):
+ self._backing_transport.put_bytes(self._relpath,
+ self._body_bytes, self._mode)
+ self.response = SmartServerResponse(('ok',))
def _deserialise_offsets(self, text):
# XXX: FIXME this should be on the protocol object.
@@ -404,18 +717,39 @@
return offsets
def do_put_non_atomic(self, relpath, mode, create_parent, dir_mode):
- create_parent_dir = (create_parent == 'T')
- self._backing_transport.put_bytes_non_atomic(relpath,
- self._recv_body(),
- mode=self._deserialise_optional_mode(mode),
- create_parent_dir=create_parent_dir,
- dir_mode=self._deserialise_optional_mode(dir_mode))
+ self._converted_command = True
+ self._end_of_body_handler = self._handle_put_non_atomic
+ self._relpath = relpath
+ self._dir_mode = self._deserialise_optional_mode(dir_mode)
+ self._mode = self._deserialise_optional_mode(mode)
+ # a boolean would be nicer XXX
+ self._create_parent = (create_parent == 'T')
+
+ def _handle_put_non_atomic(self):
+ self._backing_transport.put_bytes_non_atomic(self._relpath,
+ self._body_bytes,
+ mode=self._mode,
+ create_parent_dir=self._create_parent,
+ dir_mode=self._dir_mode)
+ self.response = SmartServerResponse(('ok',))
def do_readv(self, relpath):
- offsets = self._deserialise_offsets(self._recv_body())
+ self._converted_command = True
+ self._end_of_body_handler = self._handle_readv_offsets
+ self._relpath = relpath
+
+ def end_of_body(self):
+ """No more body data will be received."""
+ self._run_handler_code(self._end_of_body_handler, (), {})
+ # cannot read after this.
+ self.finished_reading = True
+
+ def _handle_readv_offsets(self):
+ """accept offsets for a readv request."""
+ offsets = self._deserialise_offsets(self._body_bytes)
backing_bytes = ''.join(bytes for offset, bytes in
- self._backing_transport.readv(relpath, offsets))
- return SmartServerResponse(('readv',), backing_bytes)
+ self._backing_transport.readv(self._relpath, offsets))
+ self.response = SmartServerResponse(('readv',), backing_bytes)
def do_rename(self, rel_from, rel_to):
self._backing_transport.rename(rel_from, rel_to)
@@ -439,14 +773,35 @@
return SmartServerResponse((), tmpf.read())
def dispatch_command(self, cmd, args):
+ """Deprecated compatibility method.""" # XXX XXX
func = getattr(self, 'do_' + cmd, None)
if func is None:
raise errors.SmartProtocolError("bad request %r" % (cmd,))
+ self._run_handler_code(func, args, {})
+
+ def _run_handler_code(self, callable, args, kwargs):
+ """Run some handler specific code 'callable'.
+
+ If a result is returned, it is considered to be the commands response,
+ and finished_reading is set true, and its assigned to self.response.
+
+ Any exceptions caught are translated and a response object created
+ from them.
+ """
+ result = self._call_converting_errors(callable, args, kwargs)
+ if result is not None:
+ self.response = result
+ self.finished_reading = True
+ # handle unconverted commands
+ if not self._converted_command:
+ self.finished_reading = True
+ if result is None:
+ self.response = SmartServerResponse(('ok',))
+
+ def _call_converting_errors(self, callable, args, kwargs):
+ """Call callable converting errors to Response objects."""
try:
- result = func(*args)
- if result is None:
- result = SmartServerResponse(('ok',))
- return result
+ return callable(*args, **kwargs)
except errors.NoSuchFile, e:
return SmartServerResponse(('NoSuchFile', e.path))
except errors.FileExists, e:
@@ -477,7 +832,7 @@
class SmartTCPServer(object):
"""Listens on a TCP socket and accepts connections from smart clients"""
- def __init__(self, backing_transport=None, host='127.0.0.1', port=0):
+ def __init__(self, backing_transport, host='127.0.0.1', port=0):
"""Construct a new server.
To actually start it running, call either start_background_thread or
@@ -486,8 +841,6 @@
:param host: Name of the interface to listen on.
:param port: TCP port to listen on, or 0 to allocate a transient port.
"""
- if backing_transport is None:
- backing_transport = memory.MemoryTransport()
self._server_socket = socket.socket()
self._server_socket.bind((host, port))
self.port = self._server_socket.getsockname()[1]
@@ -522,10 +875,7 @@
# propogates to the newly accepted socket.
conn.setblocking(True)
conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
- from_client = conn.makefile('r')
- to_client = conn.makefile('w')
- handler = SmartStreamServer(from_client, to_client,
- self.backing_transport)
+ handler = SmartServerSocketStreamMedium(conn, self.backing_transport)
connection_thread = threading.Thread(None, handler.serve, name='smart-server-child')
connection_thread.setDaemon(True)
connection_thread.start()
@@ -610,10 +960,11 @@
# SmartTransport is an adapter from the Transport object model to the
# SmartClient model, not an encoder.
- def __init__(self, url, clone_from=None, client=None):
+ def __init__(self, url, clone_from=None, medium=None):
"""Constructor.
- :param client: ignored when clone_from is not None.
+ :param medium: The medium to use for this RemoteTransport. This must be
+ supplied if clone_from is None.
"""
### Technically super() here is faulty because Transport's __init__
### fails to take 2 parameters, and if super were to choose a silly
@@ -624,16 +975,14 @@
self._scheme, self._username, self._password, self._host, self._port, self._path = \
transport.split_url(url)
if clone_from is None:
- if client is None:
- self._client = SmartStreamClient(self._connect_to_server)
- else:
- self._client = client
+ self._medium = medium
else:
# credentials may be stripped from the base in some circumstances
# as yet to be clearly defined or documented, so copy them.
self._username = clone_from._username
# reuse same connection
- self._client = clone_from._client
+ self._medium = clone_from._medium
+ assert self._medium is not None
def abspath(self, relpath):
"""Return the full url to the given relative path.
@@ -649,16 +998,19 @@
This essentially opens a handle on a different remote directory.
"""
if relative_url is None:
- return self.__class__(self.base, self)
+ return SmartTransport(self.base, self)
else:
- return self.__class__(self.abspath(relative_url), self)
+ return SmartTransport(self.abspath(relative_url), self)
def is_readonly(self):
"""Smart server transport can do read/write file operations."""
return False
def get_smart_client(self):
- return self._client
+ return self._medium
+
+ def get_smart_medium(self):
+ return self._medium
def _unparse_url(self, path):
"""Return URL for a path.
@@ -681,12 +1033,28 @@
"""Returns the Unicode version of the absolute path for relpath."""
return self._combine_paths(self._path, relpath)
+ def _call(self, method, *args):
+ resp = self._call2(method, *args)
+ self._translate_error(resp)
+
+ def _call2(self, method, *args):
+ """Call a method on the remote server."""
+ protocol = SmartClientRequestProtocolOne(self._medium.get_request())
+ protocol.call(method, *args)
+ return protocol.read_response_tuple()
+
+ def _call_with_body_bytes(self, method, args, body):
+ """Call a method on the remote server with body bytes."""
+ protocol = SmartClientRequestProtocolOne(self._medium.get_request())
+ protocol.call_with_body_bytes((method, ) + args, body)
+ return protocol.read_response_tuple()
+
def has(self, relpath):
"""Indicate whether a remote file of the given name exists or not.
:see: Transport.has()
"""
- resp = self._client._call('has', self._remote_path(relpath))
+ resp = self._call2('has', self._remote_path(relpath))
if resp == ('yes', ):
return True
elif resp == ('no', ):
@@ -699,11 +1067,17 @@
:see: Transport.get_bytes()/get_file()
"""
+ return StringIO(self.get_bytes(relpath))
+
+ def get_bytes(self, relpath):
remote = self._remote_path(relpath)
- resp = self._client._call('get', remote)
+ protocol = SmartClientRequestProtocolOne(self._medium.get_request())
+ protocol.call('get', remote)
+ resp = protocol.read_response_tuple(True)
if resp != ('ok', ):
+ protocol.cancel_read_body()
self._translate_error(resp, relpath)
- return StringIO(self._client._recv_bulk())
+ return protocol.read_body_bytes()
def _serialise_optional_mode(self, mode):
if mode is None:
@@ -712,17 +1086,15 @@
return '%d' % mode
def mkdir(self, relpath, mode=None):
- resp = self._client._call('mkdir',
- self._remote_path(relpath),
- self._serialise_optional_mode(mode))
+ resp = self._call2('mkdir', self._remote_path(relpath),
+ self._serialise_optional_mode(mode))
self._translate_error(resp)
def put_bytes(self, relpath, upload_contents, mode=None):
# FIXME: upload_file is probably not safe for non-ascii characters -
# should probably just pass all parameters as length-delimited
# strings?
- resp = self._client._call_with_upload(
- 'put',
+ resp = self._call_with_body_bytes('put',
(self._remote_path(relpath), self._serialise_optional_mode(mode)),
upload_contents)
self._translate_error(resp)
@@ -736,7 +1108,7 @@
if create_parent_dir:
create_parent_str = 'T'
- resp = self._client._call_with_upload(
+ resp = self._call_with_body_bytes(
'put_non_atomic',
(self._remote_path(relpath), self._serialise_optional_mode(mode),
create_parent_str, self._serialise_optional_mode(dir_mode)),
@@ -765,7 +1137,7 @@
return self.append_bytes(relpath, from_file.read(), mode)
def append_bytes(self, relpath, bytes, mode=None):
- resp = self._client._call_with_upload(
+ resp = self._call_with_body_bytes(
'append',
(self._remote_path(relpath), self._serialise_optional_mode(mode)),
bytes)
@@ -774,7 +1146,7 @@
self._translate_error(resp)
def delete(self, relpath):
- resp = self._client._call('delete', self._remote_path(relpath))
+ resp = self._call2('delete', self._remote_path(relpath))
self._translate_error(resp)
def readv(self, relpath, offsets):
@@ -791,18 +1163,20 @@
limit=self._max_readv_combine,
fudge_factor=self._bytes_to_read_before_seek))
-
- resp = self._client._call_with_upload(
- 'readv',
- (self._remote_path(relpath),),
- self._client._serialise_offsets((c.start, c.length) for c in coalesced))
+ protocol = SmartClientRequestProtocolOne(self._medium.get_request())
+ protocol.call_with_body_readv_array(
+ ('readv', self._remote_path(relpath)),
+ [(c.start, c.length) for c in coalesced])
+ resp = protocol.read_response_tuple(True)
if resp[0] != 'readv':
# This should raise an exception
+ protocol.cancel_read_body()
self._translate_error(resp)
return
- data = self._client._recv_bulk()
+ # FIXME: this should know how many bytes are needed, for clarity.
+ data = protocol.read_body_bytes()
# Cache the results, but only until they have been fulfilled
data_map = {}
for c_offset in coalesced:
@@ -821,22 +1195,18 @@
cur_offset_and_size = offset_stack.next()
def rename(self, rel_from, rel_to):
- self._call('rename',
+ self._call('rename',
self._remote_path(rel_from),
self._remote_path(rel_to))
def move(self, rel_from, rel_to):
- self._call('move',
+ self._call('move',
self._remote_path(rel_from),
self._remote_path(rel_to))
def rmdir(self, relpath):
resp = self._call('rmdir', self._remote_path(relpath))
- def _call(self, method, *args):
- resp = self._client._call(method, *args)
- self._translate_error(resp)
-
def _translate_error(self, resp, orig_path=None):
"""Raise an exception from a response"""
if resp is None:
@@ -879,20 +1249,14 @@
else:
raise errors.SmartProtocolError('unexpected smart server error: %r' % (resp,))
- def _send_tuple(self, args):
- self._client._send_tuple(args)
-
- def _recv_tuple(self):
- return self._client._recv_tuple()
-
def disconnect(self):
- self._client.disconnect()
+ self._medium.disconnect()
def delete_tree(self, relpath):
raise errors.TransportNotPossible('readonly transport')
def stat(self, relpath):
- resp = self._client._call('stat', self._remote_path(relpath))
+ resp = self._call2('stat', self._remote_path(relpath))
if resp[0] == 'stat':
return SmartStat(int(resp[1]), int(resp[2], 8))
else:
@@ -915,152 +1279,516 @@
return True
def list_dir(self, relpath):
- resp = self._client._call('list_dir',
- self._remote_path(relpath))
+ resp = self._call2('list_dir', self._remote_path(relpath))
if resp[0] == 'names':
return [name.encode('ascii') for name in resp[1:]]
else:
self._translate_error(resp)
def iter_files_recursive(self):
- resp = self._client._call('iter_files_recursive',
- self._remote_path(''))
+ resp = self._call2('iter_files_recursive', self._remote_path(''))
if resp[0] == 'names':
return resp[1:]
else:
self._translate_error(resp)
-class SmartStreamClient(SmartProtocolBase):
- """Connection to smart server over two streams"""
-
- def __init__(self, connect_func):
- self._connect_func = connect_func
- self._connected = False
-
- def __del__(self):
- self.disconnect()
-
- def _ensure_connection(self):
- if not self._connected:
- self._in, self._out = self._connect_func()
- self._connected = True
-
- def _send_tuple(self, args):
- self._ensure_connection()
- return self._write_and_flush(_encode_tuple(args))
-
- def _send_bulk_data(self, body):
- self._ensure_connection()
- SmartProtocolBase._send_bulk_data(self, body)
-
- def _recv_bulk(self):
- self._ensure_connection()
- return SmartProtocolBase._recv_bulk(self)
+class SmartClientMediumRequest(object):
+ """A request on a SmartClientMedium.
+
+ Each request allows bytes to be provided to it via accept_bytes, and then
+ the response bytes to be read via read_bytes.
+
+ For instance:
+ request.accept_bytes('123')
+ request.finished_writing()
+ result = request.read_bytes(3)
+ request.finished_reading()
+
+ It is up to the individual SmartClientMedium whether multiple concurrent
+ requests can exist. See SmartClientMedium.get_request to obtain instances
+ of SmartClientMediumRequest, and the concrete Medium you are using for
+ details on concurrency and pipelining.
+ """
+
+ def __init__(self, medium):
+ """Construct a SmartClientMediumRequest for the medium medium."""
+ self._medium = medium
+ # we track state by constants - we may want to use the same
+ # pattern as BodyReader if it gets more complex.
+ # valid states are: "writing", "reading", "done"
+ self._state = "writing"
+
+ def accept_bytes(self, bytes):
+ """Accept bytes for inclusion in this request.
+
+ This method may not be be called after finished_writing() has been
+ called. It depends upon the Medium whether or not the bytes will be
+ immediately transmitted. Message based Mediums will tend to buffer the
+ bytes until finished_writing() is called.
+
+ :param bytes: A bytestring.
+ """
+ if self._state != "writing":
+ raise errors.WritingCompleted(self)
+ self._accept_bytes(bytes)
+
+ def _accept_bytes(self, bytes):
+ """Helper for accept_bytes.
+
+ Accept_bytes checks the state of the request to determing if bytes
+ should be accepted. After that it hands off to _accept_bytes to do the
+ actual acceptance.
+ """
+ raise NotImplementedError(self._accept_bytes)
+
+ def finished_reading(self):
+ """Inform the request that all desired data has been read.
+
+ This will remove the request from the pipeline for its medium (if the
+ medium supports pipelining) and any further calls to methods on the
+ request will raise ReadingCompleted.
+ """
+ if self._state == "writing":
+ raise errors.WritingNotComplete(self)
+ if self._state != "reading":
+ raise errors.ReadingCompleted(self)
+ self._state = "done"
+ self._finished_reading()
+
+ def _finished_reading(self):
+ """Helper for finished_reading.
+
+ finished_reading checks the state of the request to determine if
+ finished_reading is allowed, and if it is hands off to _finished_reading
+ to perform the action.
+ """
+ raise NotImplementedError(self._finished_reading)
+
+ def finished_writing(self):
+ """Finish the writing phase of this request.
+
+ This will flush all pending data for this request along the medium.
+ After calling finished_writing, you may not call accept_bytes anymore.
+ """
+ if self._state != "writing":
+ raise errors.WritingCompleted(self)
+ self._state = "reading"
+ self._finished_writing()
+
+ def _finished_writing(self):
+ """Helper for finished_writing.
+
+ finished_writing checks the state of the request to determine if
+ finished_writing is allowed, and if it is hands off to _finished_writing
+ to perform the action.
+ """
+ raise NotImplementedError(self._finished_writing)
+
+ def read_bytes(self, count):
+ """Read bytes from this requests response.
+
+ This method will block and wait for count bytes to be read. It may not
+ be invoked until finished_writing() has been called - this is to ensure
+ a message-based approach to requests, for compatability with message
+ based mediums like HTTP.
+ """
+ if self._state == "writing":
+ raise errors.WritingNotComplete(self)
+ if self._state != "reading":
+ raise errors.ReadingCompleted(self)
+ return self._read_bytes(count)
+
+ def _read_bytes(self, count):
+ """Helper for read_bytes.
+
+ read_bytes checks the state of the request to determing if bytes
+ should be read. After that it hands off to _read_bytes to do the
+ actual read.
+ """
+ raise NotImplementedError(self._read_bytes)
+
+
+class SmartClientStreamMediumRequest(SmartClientMediumRequest):
+ """A SmartClientMediumRequest that works with an SmartClientStreamMedium."""
+
+ def __init__(self, medium):
+ SmartClientMediumRequest.__init__(self, medium)
+ # check that we are safe concurrency wise. If some streams start
+ # allowing concurrent requests - i.e. via multiplexing - then this
+ # assert should be moved to SmartClientStreamMedium.get_request,
+ # and the setting/unsetting of _current_request likewise moved into
+ # that class : but its unneeded overhead for now. RBC 20060922
+ if self._medium._current_request is not None:
+ raise errors.TooManyConcurrentRequests(self._medium)
+ self._medium._current_request = self
+
+ def _accept_bytes(self, bytes):
+ """See SmartClientMediumRequest._accept_bytes.
+
+ This forwards to self._medium._accept_bytes because we are operating
+ on the mediums stream.
+ """
+ self._medium._accept_bytes(bytes)
+
+ def _finished_reading(self):
+ """See SmartClientMediumRequest._finished_reading.
+
+ This clears the _current_request on self._medium to allow a new
+ request to be created.
+ """
+ assert self._medium._current_request is self
+ self._medium._current_request = None
+
+ def _finished_writing(self):
+ """See SmartClientMediumRequest._finished_writing.
+
+ This invokes self._medium._flush to ensure all bytes are transmitted.
+ """
+ self._medium._flush()
+
+ def _read_bytes(self, count):
+ """See SmartClientMediumRequest._read_bytes.
+
+ This forwards to self._medium._read_bytes because we are operating
+ on the mediums stream.
+ """
+ return self._medium._read_bytes(count)
+
+
+class SmartClientRequestProtocolOne(SmartProtocolBase):
+ """The client-side protocol for smart version 1."""
+
+ def __init__(self, request):
+ """Construct a SmartClientRequestProtocolOne.
+
+ :param request: A SmartClientMediumRequest to serialise onto and
+ deserialise from.
+ """
+ self._request = request
+ self._body_buffer = None
+
+ def call(self, *args):
+ bytes = _encode_tuple(args)
+ self._request.accept_bytes(bytes)
+ self._request.finished_writing()
+
+ def call_with_body_bytes(self, args, body):
+ """Make a remote call of args with body bytes 'body'.
+
+ After calling this, call read_response_tuple to find the result out.
+ """
+ bytes = _encode_tuple(args)
+ self._request.accept_bytes(bytes)
+ bytes = self._encode_bulk_data(body)
+ self._request.accept_bytes(bytes)
+ self._request.finished_writing()
+
+ def call_with_body_readv_array(self, args, body):
+ """Make a remote call with a readv array.
+
+ The body is encoded with one line per readv offset pair. The numbers in
+ each pair are separated by a comma, and no trailing \n is emitted.
+ """
+ bytes = _encode_tuple(args)
+ self._request.accept_bytes(bytes)
+ readv_bytes = self._serialise_offsets(body)
+ bytes = self._encode_bulk_data(readv_bytes)
+ self._request.accept_bytes(bytes)
+ self._request.finished_writing()
+
+ def cancel_read_body(self):
+ """After expecting a body, a response code may indicate one otherwise.
+
+ This method lets the domain client inform the protocol that no body
+ will be transmitted. This is a terminal method: after calling it the
+ protocol is not able to be used further.
+ """
+ self._request.finished_reading()
+
+ def read_response_tuple(self, expect_body=False):
+ """Read a response tuple from the wire.
+
+ This should only be called once.
+ """
+ result = self._recv_tuple()
+ if not expect_body:
+ self._request.finished_reading()
+ return result
+
+ def read_body_bytes(self, count=-1):
+ """Read bytes from the body, decoding into a byte stream.
+
+ We read all bytes at once to ensure we've checked the trailer for
+ errors, and then feed the buffer back as read_body_bytes is called.
+ """
+ if self._body_buffer is not None:
+ return self._body_buffer.read(count)
+ _body_decoder = LengthPrefixedBodyDecoder()
+
+ while not _body_decoder.finished_reading:
+ bytes_wanted = _body_decoder.next_read_size()
+ bytes = self._request.read_bytes(bytes_wanted)
+ _body_decoder.accept_bytes(bytes)
+ self._request.finished_reading()
+ self._body_buffer = StringIO(_body_decoder.read_pending_data())
+ # XXX: TODO check the trailer result.
+ return self._body_buffer.read(count)
def _recv_tuple(self):
- self._ensure_connection()
- return SmartProtocolBase._recv_tuple(self)
-
- def _recv_trailer(self):
- self._ensure_connection()
- return SmartProtocolBase._recv_trailer(self)
-
- def disconnect(self):
- """Close connection to the server"""
- if self._connected:
- self._out.close()
- self._in.close()
-
- def _call(self, *args):
- self._send_tuple(args)
- return self._recv_tuple()
-
- def _call_with_upload(self, method, args, body):
- """Call an rpc, supplying bulk upload data.
-
- :param method: method name to call
- :param args: parameter args tuple
- :param body: upload body as a byte string
- """
- self._send_tuple((method,) + args)
- self._send_bulk_data(body)
- return self._recv_tuple()
+ """Receive a tuple from the medium request."""
+ line = ''
+ while not line or line[-1] != '\n':
+ # TODO: this is inefficient - but tuples are short.
+ new_char = self._request.read_bytes(1)
+ line += new_char
+ assert new_char != '', "end of file reading from server."
+ return _decode_tuple(line)
def query_version(self):
"""Return protocol version number of the server."""
- # XXX: should make sure it's empty
- self._send_tuple(('hello',))
- resp = self._recv_tuple()
+ self.call('hello')
+ resp = self.read_response_tuple()
if resp == ('ok', '1'):
return 1
else:
raise errors.SmartProtocolError("bad response %r" % (resp,))
-class SmartTCPTransport(SmartTransport):
- """Connection to smart server over plain tcp"""
-
- def __init__(self, url, clone_from=None):
- super(SmartTCPTransport, self).__init__(url, clone_from)
- try:
- self._port = int(self._port)
- except (ValueError, TypeError), e:
- raise errors.InvalidURL(path=url, extra="invalid port %s" % self._port)
- self._socket = None
-
- def _connect_to_server(self):
+class SmartClientMedium(object):
+ """Smart client is a medium for sending smart protocol requests over."""
+
+ def disconnect(self):
+ """If this medium maintains a persistent connection, close it.
+
+ The default implementation does nothing.
+ """
+
+
+class SmartClientStreamMedium(SmartClientMedium):
+ """Stream based medium common class.
+
+ SmartClientStreamMediums operate on a stream. All subclasses use a common
+ SmartClientStreamMediumRequest for their requests, and should implement
+ _accept_bytes and _read_bytes to allow the request objects to send and
+ receive bytes.
+ """
+
+ def __init__(self):
+ self._current_request = None
+
+ def accept_bytes(self, bytes):
+ self._accept_bytes(bytes)
+
+ def __del__(self):
+ """The SmartClientStreamMedium knows how to close the stream when it is
+ finished with it.
+ """
+ self.disconnect()
+
+ def _flush(self):
+ """Flush the output stream.
+
+ This method is used by the SmartClientStreamMediumRequest to ensure that
+ all data for a request is sent, to avoid long timeouts or deadlocks.
+ """
+ raise NotImplementedError(self._flush)
+
+ def get_request(self):
+ """See SmartClientMedium.get_request().
+
+ SmartClientStreamMedium always returns a SmartClientStreamMediumRequest
+ for get_request.
+ """
+ return SmartClientStreamMediumRequest(self)
+
+ def read_bytes(self, count):
+ return self._read_bytes(count)
+
+
+class SmartSimplePipesClientMedium(SmartClientStreamMedium):
+ """A client medium using simple pipes.
+
+ This client does not manage the pipes: it assumes they will always be open.
+ """
+
+ def __init__(self, readable_pipe, writeable_pipe):
+ SmartClientStreamMedium.__init__(self)
+ self._readable_pipe = readable_pipe
+ self._writeable_pipe = writeable_pipe
+
+ def _accept_bytes(self, bytes):
+ """See SmartClientStreamMedium.accept_bytes."""
+ self._writeable_pipe.write(bytes)
+
+ def _flush(self):
+ """See SmartClientStreamMedium._flush()."""
+ self._writeable_pipe.flush()
+
+ def _read_bytes(self, count):
+ """See SmartClientStreamMedium._read_bytes."""
+ return self._readable_pipe.read(count)
+
+
+class SmartSSHClientMedium(SmartClientStreamMedium):
+ """A client medium using SSH."""
+
+ def __init__(self, host, port=None, username=None, password=None,
+ vendor=None):
+ """Creates a client that will connect on the first use.
+
+ :param vendor: An optional override for the ssh vendor to use. See
+ bzrlib.transport.ssh for details on ssh vendors.
+ """
+ SmartClientStreamMedium.__init__(self)
+ self._connected = False
+ self._host = host
+ self._password = password
+ self._port = port
+ self._username = username
+ self._read_from = None
+ self._ssh_connection = None
+ self._vendor = vendor
+ self._write_to = None
+
+ def _accept_bytes(self, bytes):
+ """See SmartClientStreamMedium.accept_bytes."""
+ self._ensure_connection()
+ self._write_to.write(bytes)
+
+ def disconnect(self):
+ """See SmartClientMedium.disconnect()."""
+ if not self._connected:
+ return
+ self._read_from.close()
+ self._write_to.close()
+ self._ssh_connection.close()
+ self._connected = False
+
+ def _ensure_connection(self):
+ """Connect this medium if not already connected."""
+ if self._connected:
+ return
+ executable = os.environ.get('BZR_REMOTE_PATH', 'bzr')
+ if self._vendor is None:
+ vendor = ssh._get_ssh_vendor()
+ else:
+ vendor = self._vendor
+ self._ssh_connection = vendor.connect_ssh(self._username,
+ self._password, self._host, self._port,
+ command=[executable, 'serve', '--inet', '--directory=/',
+ '--allow-writes'])
+ self._read_from, self._write_to = \
+ self._ssh_connection.get_filelike_channels()
+ self._connected = True
+
+ def _flush(self):
+ """See SmartClientStreamMedium._flush()."""
+ self._write_to.flush()
+
+ def _read_bytes(self, count):
+ """See SmartClientStreamMedium.read_bytes."""
+ if not self._connected:
+ raise errors.MediumNotConnected(self)
+ return self._read_from.read(count)
+
+
+class SmartTCPClientMedium(SmartClientStreamMedium):
+ """A client medium using TCP."""
+
+ def __init__(self, host, port):
+ """Creates a client that will connect on the first use."""
+ SmartClientStreamMedium.__init__(self)
+ self._connected = False
+ self._host = host
+ self._port = port
+ self._socket = None
+
+ def _accept_bytes(self, bytes):
+ """See SmartClientMedium.accept_bytes."""
+ self._ensure_connection()
+ self._socket.sendall(bytes)
+
+ def disconnect(self):
+ """See SmartClientMedium.disconnect()."""
+ if not self._connected:
+ return
+ self._socket.close()
+ self._socket = None
+ self._connected = False
+
+ def _ensure_connection(self):
+ """Connect this medium if not already connected."""
+ if self._connected:
+ return
self._socket = socket.socket()
self._socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
result = self._socket.connect_ex((self._host, int(self._port)))
if result:
raise errors.ConnectionError("failed to connect to %s:%d: %s" %
(self._host, self._port, os.strerror(result)))
- # TODO: May be more efficient to just treat them as sockets
- # throughout? But what about pipes to ssh?...
- to_server = self._socket.makefile('w')
- from_server = self._socket.makefile('r')
- return from_server, to_server
-
- def disconnect(self):
- super(SmartTCPTransport, self).disconnect()
- # XXX: Is closing the socket as well as closing the files really
- # necessary?
- if self._socket is not None:
- self._socket.close()
+ self._connected = True
+
+ def _flush(self):
+ """See SmartClientStreamMedium._flush().
+
+ For TCP we do no flushing. We may want to turn off TCP_NODELAY and
+ add a means to do a flush, but that can be done in the future.
+ """
+
+ def _read_bytes(self, count):
+ """See SmartClientMedium.read_bytes."""
+ if not self._connected:
+ raise errors.MediumNotConnected(self)
+ return self._socket.recv(count)
+
+
+class SmartTCPTransport(SmartTransport):
+ """Connection to smart server over plain tcp.
+
+ This is essentially just a factory to get 'RemoteTransport(url,
+ SmartTCPClientMedium).
+ """
+
+ def __init__(self, url):
+ _scheme, _username, _password, _host, _port, _path = \
+ transport.split_url(url)
+ try:
+ _port = int(_port)
+ except (ValueError, TypeError), e:
+ raise errors.InvalidURL(path=url, extra="invalid port %s" % _port)
+ medium = SmartTCPClientMedium(_host, _port)
+ super(SmartTCPTransport, self).__init__(url, medium=medium)
+
try:
- from bzrlib.transport import sftp, ssh
+ from bzrlib.transport import ssh
except errors.ParamikoNotPresent:
# no paramiko, no SSHTransport.
pass
else:
class SmartSSHTransport(SmartTransport):
- """Connection to smart server over SSH."""
-
- def __init__(self, url, clone_from=None):
- # TODO: all this probably belongs in the parent class.
- super(SmartSSHTransport, self).__init__(url, clone_from)
+ """Connection to smart server over SSH.
+
+ This is essentially just a factory to get 'RemoteTransport(url,
+ SmartSSHClientMedium).
+ """
+
+ def __init__(self, url):
+ _scheme, _username, _password, _host, _port, _path = \
+ transport.split_url(url)
try:
- if self._port is not None:
- self._port = int(self._port)
+ if _port is not None:
+ _port = int(_port)
except (ValueError, TypeError), e:
- raise errors.InvalidURL(path=url, extra="invalid port %s" % self._port)
-
- def _connect_to_server(self):
- executable = os.environ.get('BZR_REMOTE_PATH', 'bzr')
- vendor = ssh._get_ssh_vendor()
- self._ssh_connection = vendor.connect_ssh(self._username,
- self._password, self._host, self._port,
- command=[executable, 'serve', '--inet', '--directory=/',
- '--allow-writes'])
- return self._ssh_connection.get_filelike_channels()
-
- def disconnect(self):
- super(SmartSSHTransport, self).disconnect()
- self._ssh_connection.close()
+ raise errors.InvalidURL(path=url, extra="invalid port %s" %
+ _port)
+ medium = SmartSSHClientMedium(_host, _port, _username, _password)
+ super(SmartSSHTransport, self).__init__(url, medium=medium)
def get_test_permutations():
- """Return (transport, server) permutations for testing"""
+ """Return (transport, server) permutations for testing."""
+ ### We may need a little more test framework support to construct an
+ ### appropriate RemoteTransport in the future.
return [(SmartTCPTransport, SmartTCPServer_for_testing)]
# revision id: andrew.bennetts at canonical.com-20060929062858-4516689dc8de55ec
# sha1: f8e40fb06b12110ccefd186758720bebe661ac5c
# inventory sha1: 33154351e68d82ca371ad6746243273743598094
# parent ids:
# andrew.bennetts at canonical.com-20060929050436-08c49958f1752c88
# base id: pqm at pqm.ubuntu.com-20060927204431-5871ab3ef6affaf3
# properties:
# branch-nick: hpss HTTP support
# message:
# Remove commented cruft.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Fri 2006-09-29 15:04:36.720999956 +1000
=== modified file bzrlib/transport/smart.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQucHkKKysrIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQu
cHkKQEAgLTM1Niw3ICszNTYsNiBAQAogICAgICAgICAgICAgc2VsZi5fb3V0X3N0cmVhbS5mbHVz
aCgpCiAgICAgICAgIGVsc2U6CiAgICAgICAgICAgICBzZWxmLl9zZW5kX2J1bGtfZGF0YShib2R5
LCBzZWxmLl9vdXRfc3RyZWFtKQotICAgICAgICAgICAgI3NlbGYuX291dF9zdHJlYW0ud3JpdGUo
J0JMQVJHSCcpCiAKICAgICBkZWYgc3luY193aXRoX3JlcXVlc3Qoc2VsZiwgcmVxdWVzdCk6CiAg
ICAgICAgIHNlbGYuX2ZpbmlzaGVkX3JlYWRpbmcgPSByZXF1ZXN0LmZpbmlzaGVkX3JlYWRpbmcK
Cg==
# revision id: andrew.bennetts at canonical.com-20060929050436-08c49958f1752c88
# sha1: b094ff59222c852dabfbed092986b00bb36fb431
# inventory sha1: 125e985a0e6097550a90ca3057885414a747e60b
# parent ids:
# andrew.bennetts at canonical.com-20060929050153-ded347722daa93c8
# properties:
# branch-nick: hpss HTTP support
# message:
# Simplify do_POST, and add a comment.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Fri 2006-09-29 15:01:53.269000053 +1000
=== modified file bzrlib/transport/http/__init__.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvaHR0cC9fX2luaXRfXy5weQorKysgYnpybGliL3RyYW5zcG9y
dC9odHRwL19faW5pdF9fLnB5CkBAIC02NTksMTAgKzY1OSwxMCBAQAogICAgICAgICAjIGlmIHRo
aXMgZmFpbHMsIHdlIHNob3VsZCByZXR1cm4gNDAwIGJhZCByZXF1ZXN0LCBidXQgZmFpbHVyZSBp
cwogICAgICAgICAjIGZhaWx1cmUgZm9yIG5vdyAtIFJCQyAyMDA2MDkxOQogICAgICAgICBkYXRh
X2xlbmd0aCA9IGludChzZWxmLmhlYWRlcnNbJ0NvbnRlbnQtTGVuZ3RoJ10pCi0gICAgICAgIGZp
cnN0X2xpbmUgPSBzZWxmLnJmaWxlLnJlYWRsaW5lKCkKLSAgICAgICAgZGF0YSA9IHNlbGYucmZp
bGUucmVhZChkYXRhX2xlbmd0aCAtIGxlbihmaXJzdF9saW5lKSkKLSAgICAgICAgc21hcnRfcHJv
dG9jb2xfcmVxdWVzdC5hY2NlcHRfYnl0ZXMoZmlyc3RfbGluZSkKLSAgICAgICAgc21hcnRfcHJv
dG9jb2xfcmVxdWVzdC5hY2NlcHRfYnl0ZXMoZGF0YSkKKyAgICAgICAgIyBQZXJoYXBzIHRoZXJl
IHNob3VsZCBiZSBhIFNtYXJ0U2VydmVySFRUUE1lZGl1bSB0aGF0IHRha2VzIGNhcmUgb2YKKyAg
ICAgICAgIyBmZWVkaW5nIHRoZSBieXRlcyBpbiB0aGUgaHR0cCByZXF1ZXN0IHRvIHRoZSBzbWFy
dF9wcm90b2NvbF9yZXF1ZXN0LAorICAgICAgICAjIGJ1dCBmb3Igbm93IGl0J3Mgc2ltcGxlciB0
byBqdXN0IGZlZWQgdGhlIGJ5dGVzIGRpcmVjdGx5LgorICAgICAgICBzbWFydF9wcm90b2NvbF9y
ZXF1ZXN0LmFjY2VwdF9ieXRlcyhzZWxmLnJmaWxlLnJlYWQoZGF0YV9sZW5ndGgpKQogICAgICAg
ICBhc3NlcnQgc21hcnRfcHJvdG9jb2xfcmVxdWVzdC5uZXh0X3JlYWRfc2l6ZSgpID09IDAsICgK
ICAgICAgICAgICAgICJub3QgZmluaXNoZWQgcmVhZGluZywgYnV0IGFsbCBkYXRhIHNlbnQgdG8g
cHJvdG9jb2wuIikKICAgICAgICAgc2VsZi5zZW5kX2hlYWRlcigiQ29udGVudC1MZW5ndGgiLCBz
dHIobGVuKG91dF9idWZmZXIuZ2V0dmFsdWUoKSkpKQoK
# revision id: andrew.bennetts at canonical.com-20060929050153-ded347722daa93c8
# sha1: 893357d42ee18088a0f76aa224e0a99d263fbafc
# inventory sha1: 8eb04f014b514dbe79e66f1a3a68bf53d601f3d8
# parent ids:
# andrew.bennetts at canonical.com-20060929043519-3eb896e184213815
# properties:
# branch-nick: hpss HTTP support
# message:
# Tidy up _serve_one_request.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Fri 2006-09-29 14:35:19.869999886 +1000
=== modified file BRANCH.TODO // encoding:base64
LS0tIEJSQU5DSC5UT0RPCisrKyBCUkFOQ0guVE9ETwpAQCAtMiw2ICsyLDggQEAKICMgSXQgc2hv
dWxkIEFMV0FZUyBiZSBlbXB0eSBpbiB0aGUgbWFpbmxpbmUgb3IgaW4gaW50ZWdyYXRpb24gYnJh
bmNoZXMuCiAjIAogCi1GaXggdGhyZWUgY2FzZXMgb2YgcmVhZCgxKS1saWtlIHByb2JsZW1zOgot
ICAqIFNtYXJ0U2VydmVyU3RyZWFtTWVkaXVtLl9zZXJ2ZV9vbmVfcmVxdWVzdAorTWFrZSBTbWFy
dFNlcnZlclNvY2tldFN0cmVhbU1lZGl1bSBubyBsb25nZXIgdGFrZSBvdXRfZmlsZS4KKworVGVz
dCB0aGUgSFRUUCBtZWRpdW0gZm9yIHRoZSBzYW1lIGJlaGF2aW91cnMgdGhhdCB3ZSB0ZXN0IHRo
ZSBzb2NrZXQgYW5kIHBpcGUKK21lZGl1bXMgZm9yLCB3aGVyZSBhcHBsaWNhYmxlLgogCgo=
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/transport/smart.py // encoding:base64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# revision id: andrew.bennetts at canonical.com-20060929043519-3eb896e184213815
# sha1: 62ac86124645c79526c923dcd78c44a9544fe486
# inventory sha1: c79e642f538cd2248705880bcd7f11a377b19ee4
# parent ids:
# andrew.bennetts at canonical.com-20060929035741-0e33d90cd7229efb
# properties:
# branch-nick: hpss HTTP support
# message:
# Add TODOs about logging server exceptions.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Fri 2006-09-29 13:57:41.191999912 +1000
=== modified file bzrlib/transport/smart.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQucHkKKysrIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQu
cHkKQEAgLTU0MSw2ICs1NDEsOCBAQAogICAgICAgICBleGNlcHQgS2V5Ym9hcmRJbnRlcnJ1cHQ6
CiAgICAgICAgICAgICByYWlzZQogICAgICAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgorICAgICAg
ICAgICAgIyBUT0RPOiBUaGlzIHNob3VsZCBsb2cgdG8gYSBzZXJ2ZXIgbG9nIGZpbGUsIGJ1dCBu
byBzdWNoIHRoaW5nCisgICAgICAgICAgICAjIGV4aXN0cyB5ZXQuICBBbmRyZXcgQmVubmV0dHMg
MjAwNi0wOS0yOS4KICAgICAgICAgICAgIHNlbGYuX291dC5jbG9zZSgpCiAgICAgICAgICAgICBy
ZXR1cm4gRmFsc2UKICAgICAKQEAgLTU3OCw2ICs1ODAsOCBAQAogICAgICAgICBleGNlcHQgS2V5
Ym9hcmRJbnRlcnJ1cHQ6CiAgICAgICAgICAgICByYWlzZQogICAgICAgICBleGNlcHQgRXhjZXB0
aW9uLCBlOgorICAgICAgICAgICAgIyBUT0RPOiBUaGlzIHNob3VsZCBsb2cgdG8gYSBzZXJ2ZXIg
bG9nIGZpbGUsIGJ1dCBubyBzdWNoIHRoaW5nCisgICAgICAgICAgICAjIGV4aXN0cyB5ZXQuICBB
bmRyZXcgQmVubmV0dHMgMjAwNi0wOS0yOS4KICAgICAgICAgICAgIHNlbGYuX291dC5jbG9zZSgp
CiAgICAgICAgICAgICByZXR1cm4gRmFsc2UKIAoK
# revision id: andrew.bennetts at canonical.com-20060929035741-0e33d90cd7229efb
# sha1: c6dfafed66307ef27797c0c4dedf102e7fe99bbc
# inventory sha1: 5e8c21d18617c29fc31628adf5a9a0e5aa139c7d
# parent ids:
# andrew.bennetts at canonical.com-20060929035223-7f1f1e4534d423dc
# properties:
# branch-nick: hpss HTTP support
# message:
# Just close the pipe/socket if the medium catches an error, and add tests for medium exception handling.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Fri 2006-09-29 13:52:23.081000090 +1000
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3NtYXJ0X3RyYW5zcG9ydC5weQorKysgYnpybGliL3Rlc3Rz
L3Rlc3Rfc21hcnRfdHJhbnNwb3J0LnB5CkBAIC01MzUsNiArNTM1LDE1IEBACiAgICAgICAgIHNl
bGYuYXNzZXJ0SXNJbnN0YW5jZShtZWRpdW0sIHNtYXJ0LlNtYXJ0Q2xpZW50TWVkaXVtKQogCiAK
K2NsYXNzIEVycm9yUmFpc2luZ1Byb3RvY29sKG9iamVjdCk6CisKKyAgICBkZWYgX19pbml0X18o
c2VsZiwgZXhjZXB0aW9uKToKKyAgICAgICAgc2VsZi5leGNlcHRpb24gPSBleGNlcHRpb24KKwor
ICAgIGRlZiBuZXh0X3JlYWRfc2l6ZShzZWxmKToKKyAgICAgICAgcmFpc2Ugc2VsZi5leGNlcHRp
b24KKworCiBjbGFzcyBTYW1wbGVSZXF1ZXN0KG9iamVjdCk6CiAgICAgCiAgICAgZGVmIF9faW5p
dF9fKHNlbGYsIGV4cGVjdGVkX2J5dGVzKToKQEAgLTYyOCw3ICs2MzcsNyBAQAogICAgICAgICB0
b19zZXJ2ZXIgPSBTdHJpbmdJTygnJykKICAgICAgICAgZnJvbV9zZXJ2ZXIgPSBTdHJpbmdJTygp
CiAgICAgICAgIHNlcnZlciA9IHNtYXJ0LlNtYXJ0U2VydmVyUGlwZVN0cmVhbU1lZGl1bSh0b19z
ZXJ2ZXIsIGZyb21fc2VydmVyLCBOb25lKQotICAgICAgICBzdHJlYW1fc3RpbGxfb3BlbiA9IHNl
cnZlci5fc2VydmVfb25lX3JlcXVlc3QoTm9uZSkKKyAgICAgICAgc3RyZWFtX3N0aWxsX29wZW4g
PSBzZXJ2ZXIuX3NlcnZlX29uZV9yZXF1ZXN0KFNhbXBsZVJlcXVlc3QoJ3gnKSkKICAgICAgICAg
c2VsZi5hc3NlcnRFcXVhbChGYWxzZSwgc3RyZWFtX3N0aWxsX29wZW4pCiAgICAgICAgIAogICAg
IGRlZiB0ZXN0X3NvY2tldF9zdHJlYW1fc2h1dGRvd25fZGV0ZWN0aW9uKHNlbGYpOgpAQCAtNjg0
LDYgKzY5Myw2MiBAQAogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCcnLCBmcm9tX3NlcnZlci5n
ZXR2YWx1ZSgpKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKHNhbXBsZV9yZXF1ZXN0X2J5dGVz
LCBzZWNvbmRfcHJvdG9jb2wuYWNjZXB0ZWRfYnl0ZXMpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1
YWwoTm9uZSwgc3RyZWFtX3N0aWxsX29wZW4pCisKKyAgICBkZWYgdGVzdF9waXBlX2xpa2Vfc3Ry
ZWFtX2Vycm9yX2hhbmRsaW5nKHNlbGYpOgorICAgICAgICAjIFVzZSBwbGFpbiBweXRob24gU3Ry
aW5nSU8gc28gd2UgY2FuIG1vbmtleS1wYXRjaCB0aGUgY2xvc2UgbWV0aG9kIHRvCisgICAgICAg
ICMgbm90IGRpc2NhcmQgdGhlIGNvbnRlbnRzLgorICAgICAgICBmcm9tIFN0cmluZ0lPIGltcG9y
dCBTdHJpbmdJTworICAgICAgICB0b19zZXJ2ZXIgPSBTdHJpbmdJTygnJykKKyAgICAgICAgZnJv
bV9zZXJ2ZXIgPSBTdHJpbmdJTygpCisgICAgICAgIHNlbGYuY2xvc2VkID0gRmFsc2UKKyAgICAg
ICAgZGVmIGNsb3NlKCk6CisgICAgICAgICAgICBzZWxmLmNsb3NlZCA9IFRydWUKKyAgICAgICAg
ZnJvbV9zZXJ2ZXIuY2xvc2UgPSBjbG9zZQorICAgICAgICBzZXJ2ZXIgPSBzbWFydC5TbWFydFNl
cnZlclBpcGVTdHJlYW1NZWRpdW0odG9fc2VydmVyLCBmcm9tX3NlcnZlciwgTm9uZSkKKyAgICAg
ICAgZmFrZV9wcm90b2NvbCA9IEVycm9yUmFpc2luZ1Byb3RvY29sKEV4Y2VwdGlvbignYm9vbScp
KQorICAgICAgICBzdHJlYW1fc3RpbGxfb3BlbiA9IHNlcnZlci5fc2VydmVfb25lX3JlcXVlc3Qo
ZmFrZV9wcm90b2NvbCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnJywgZnJvbV9zZXJ2ZXIu
Z2V0dmFsdWUoKSkKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHNlbGYuY2xvc2VkKQorICAgICAg
ICBzZWxmLmFzc2VydEVxdWFsKEZhbHNlLCBzdHJlYW1fc3RpbGxfb3BlbikKKyAgICAgICAgCisg
ICAgZGVmIHRlc3Rfc29ja2V0X3N0cmVhbV9lcnJvcl9oYW5kbGluZyhzZWxmKToKKyAgICAgICAg
IyBVc2UgcGxhaW4gcHl0aG9uIFN0cmluZ0lPIHNvIHdlIGNhbiBtb25rZXktcGF0Y2ggdGhlIGNs
b3NlIG1ldGhvZCB0bworICAgICAgICAjIG5vdCBkaXNjYXJkIHRoZSBjb250ZW50cy4KKyAgICAg
ICAgZnJvbSBTdHJpbmdJTyBpbXBvcnQgU3RyaW5nSU8KKyAgICAgICAgc2VydmVyX3NvY2ssIGNs
aWVudF9zb2NrID0gc2VsZi5wb3J0YWJsZV9zb2NrZXRfcGFpcigpCisgICAgICAgIGZyb21fc2Vy
dmVyID0gU3RyaW5nSU8oKSAjIFhYWDogdGhhdCdzIG5vdCBhIHNvY2tldAorICAgICAgICBzZWxm
LmNsb3NlZCA9IEZhbHNlCisgICAgICAgIGRlZiBjbG9zZSgpOgorICAgICAgICAgICAgc2VsZi5j
bG9zZWQgPSBUcnVlCisgICAgICAgIGZyb21fc2VydmVyLmNsb3NlID0gY2xvc2UKKyAgICAgICAg
c2VydmVyID0gc21hcnQuU21hcnRTZXJ2ZXJTb2NrZXRTdHJlYW1NZWRpdW0oCisgICAgICAgICAg
ICBzZXJ2ZXJfc29jaywgZnJvbV9zZXJ2ZXIsIE5vbmUpCisgICAgICAgIGZha2VfcHJvdG9jb2wg
PSBFcnJvclJhaXNpbmdQcm90b2NvbChFeGNlcHRpb24oJ2Jvb20nKSkKKyAgICAgICAgc3RyZWFt
X3N0aWxsX29wZW4gPSBzZXJ2ZXIuX3NlcnZlX29uZV9yZXF1ZXN0KGZha2VfcHJvdG9jb2wpCisg
ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJycsIGZyb21fc2VydmVyLmdldHZhbHVlKCkpCisgICAg
ICAgIHNlbGYuYXNzZXJ0VHJ1ZShzZWxmLmNsb3NlZCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVh
bChGYWxzZSwgc3RyZWFtX3N0aWxsX29wZW4pCisgICAgICAgIAorICAgIGRlZiB0ZXN0X3BpcGVf
bGlrZV9zdHJlYW1fa2V5Ym9hcmRfaW50ZXJydXB0X2hhbmRsaW5nKHNlbGYpOgorICAgICAgICAj
IFVzZSBwbGFpbiBweXRob24gU3RyaW5nSU8gc28gd2UgY2FuIG1vbmtleS1wYXRjaCB0aGUgY2xv
c2UgbWV0aG9kIHRvCisgICAgICAgICMgbm90IGRpc2NhcmQgdGhlIGNvbnRlbnRzLgorICAgICAg
ICB0b19zZXJ2ZXIgPSBTdHJpbmdJTygnJykKKyAgICAgICAgZnJvbV9zZXJ2ZXIgPSBTdHJpbmdJ
TygpCisgICAgICAgIHNlcnZlciA9IHNtYXJ0LlNtYXJ0U2VydmVyUGlwZVN0cmVhbU1lZGl1bSh0
b19zZXJ2ZXIsIGZyb21fc2VydmVyLCBOb25lKQorICAgICAgICBmYWtlX3Byb3RvY29sID0gRXJy
b3JSYWlzaW5nUHJvdG9jb2woS2V5Ym9hcmRJbnRlcnJ1cHQoJ2Jvb20nKSkKKyAgICAgICAgc2Vs
Zi5hc3NlcnRSYWlzZXMoCisgICAgICAgICAgICBLZXlib2FyZEludGVycnVwdCwgc2VydmVyLl9z
ZXJ2ZV9vbmVfcmVxdWVzdCwgZmFrZV9wcm90b2NvbCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVh
bCgnJywgZnJvbV9zZXJ2ZXIuZ2V0dmFsdWUoKSkKKworICAgIGRlZiB0ZXN0X3NvY2tldF9zdHJl
YW1fa2V5Ym9hcmRfaW50ZXJydXB0X2hhbmRsaW5nKHNlbGYpOgorICAgICAgICBzZXJ2ZXJfc29j
aywgY2xpZW50X3NvY2sgPSBzZWxmLnBvcnRhYmxlX3NvY2tldF9wYWlyKCkKKyAgICAgICAgZnJv
bV9zZXJ2ZXIgPSBTdHJpbmdJTygpICMgWFhYOiB0aGF0J3Mgbm90IGEgc29ja2V0CisgICAgICAg
IHNlcnZlciA9IHNtYXJ0LlNtYXJ0U2VydmVyU29ja2V0U3RyZWFtTWVkaXVtKAorICAgICAgICAg
ICAgc2VydmVyX3NvY2ssIGZyb21fc2VydmVyLCBOb25lKQorICAgICAgICBmYWtlX3Byb3RvY29s
ID0gRXJyb3JSYWlzaW5nUHJvdG9jb2woS2V5Ym9hcmRJbnRlcnJ1cHQoJ2Jvb20nKSkKKyAgICAg
ICAgc2VsZi5hc3NlcnRSYWlzZXMoCisgICAgICAgICAgICBLZXlib2FyZEludGVycnVwdCwgc2Vy
dmVyLl9zZXJ2ZV9vbmVfcmVxdWVzdCwgZmFrZV9wcm90b2NvbCkKKyAgICAgICAgc2VsZi5hc3Nl
cnRFcXVhbCgnJywgZnJvbV9zZXJ2ZXIuZ2V0dmFsdWUoKSkKICAgICAgICAgCiAgICAgICAgIAog
Y2xhc3MgVGVzdFNtYXJ0VENQU2VydmVyKHRlc3RzLlRlc3RDYXNlKToKCg==
=== modified file bzrlib/transport/smart.py // encoding:base64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==
# revision id: andrew.bennetts at canonical.com-20060929035223-7f1f1e4534d423dc
# sha1: bc8a893bcee305f8bceab246c4190b6330e4fc27
# inventory sha1: 990a5bdf7cecfc197cdcd11250f71887a53b5a80
# parent ids:
# andrew.bennetts at canonical.com-20060929021737-e4b97746c53a3dcc
# properties:
# branch-nick: hpss HTTP support
# message:
# Remove old comments.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Fri 2006-09-29 12:17:37.342000008 +1000
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3NtYXJ0X3RyYW5zcG9ydC5weQorKysgYnpybGliL3Rlc3Rz
L3Rlc3Rfc21hcnRfdHJhbnNwb3J0LnB5CkBAIC02ODUsMzEgKzY4NSw3IEBACiAgICAgICAgIHNl
bGYuYXNzZXJ0RXF1YWwoc2FtcGxlX3JlcXVlc3RfYnl0ZXMsIHNlY29uZF9wcm90b2NvbC5hY2Nl
cHRlZF9ieXRlcykKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChOb25lLCBzdHJlYW1fc3RpbGxf
b3BlbikKICAgICAgICAgCi0gICAgI2RlZiB0ZXN0X3BpcGVfbGlrZV9zdHJlYW1fdXNlc19yZWFk
X3NpemVfaGludF9mcm9tX3Byb3RvY29sKHNlbGYpOgotCi0gICAgICAgIAotCi0gICAgICAgICMg
dGVzdCBmb3IgU21hcnRTZXJ2ZXJTdHJlYW1NZWRpdW0gd2l0aCBhIFN0cmluZ0lPIChwaXBlLWxp
a2UpIHdpdGggYnVsawotICAgICAgICAjIGRhdGEuICBXZSBjYW4gdXNlIGEgY3VzdG9tIHByb3Rv
Y29sLgotCi0gICAgICAgICMgdGVzdCBmb3IgU1NTTSAoc3RyaW5nSU8pIHNodXRkb3duIGRldGVj
dGlvbgotCi0gICAgICAgICMgdGVzdCBmb3IgU1NTTSB3aXRoIFRDUC4KLSAgICAgICAgCi0gICAg
ICAgICMgdGVzdCBmb3IgU1NTTSAoVENQKSBzaHV0ZG93biBkZXRlY3Rpb24KLQotICAgICAgICAj
IHRlc3QgZm9yIFNTU00gKFRDUCkgbm8gZGF0YSB0byByZWFkIGRvZXNuJ3QgdHJpZ2dlciBzaHV0
ZG93bgotCi0gICAgICAgICMgdHdvIHN1YmNsYXNzZXMgb2YgU1NTTSwgY2hhbmdlIGNhbGxlcnMg
dG8gdXNlIHRoZSByaWdodCBzdWJjbGFzcywKLSAgICAgICAgIyBjaGFuZ2UgdGhlIFRDUCBzdWJj
bGFzcyB0byB1c2UgcmVjdiArIHNlbGVjdCAoc28gaXQncyBub3QgYSBidXN5Ci0gICAgICAgICMg
bG9vcCkKLQotICAgICAgICAjIG9uIHRoZSBTbWFydFNlcnZlclJlcXVlc3RQcm90b2NvbE9uZSBl
eHBvc2UgYSByZWFkIHNpemUgaGludCAoc2VlCi0gICAgICAgICMgbmV4dF9yZWFkX3NpemUpLgot
Ci0gICAgICAgICMgY2hhbmdlIHRoZSBTU1NNIHBpcGUtbGlrZSB0byB1c2UgdGhlIHNpemUgaGlu
dCBmcm9tIHRoZSBwcm90b2NvbC4KLQotCisgICAgICAgIAogY2xhc3MgVGVzdFNtYXJ0VENQU2Vy
dmVyKHRlc3RzLlRlc3RDYXNlKToKIAogICAgIGRlZiB0ZXN0X2dldF9lcnJvcl91bmV4cGVjdGVk
KHNlbGYpOgoK
# revision id: andrew.bennetts at canonical.com-20060929021737-e4b97746c53a3dcc
# sha1: a2338d6e9b0f73178beea06db862e83a3f44dd8f
# inventory sha1: a430a10e3041633133a171f53cf71eab1951e65d
# parent ids:
# andrew.bennetts at canonical.com-20060929021708-921ba155bb431d52
# properties:
# branch-nick: hpss HTTP support
# message:
# Simplify SmartServerPipeStreamMedium._serve_one_request, and remove _recv_bulk, _recv_trailer and a _recv_tuple.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Fri 2006-09-29 12:17:08.105999947 +1000
=== modified file bzrlib/transport/smart.py // encoding:base64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# revision id: andrew.bennetts at canonical.com-20060929021708-921ba155bb431d52
# sha1: e28f74378b83d8a27d37fccd683b3122ac53b217
# inventory sha1: e2be8e5ef08d73f4b6e80108738dd218bb15e118
# parent ids:
# andrew.bennetts at canonical.com-20060929020944-928dfe5361c8c7ad
# properties:
# branch-nick: hpss HTTP support
# message:
# Remove SmartServerRequestProtocolOne.finished_reading attribute, replace with next_read_size method.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Fri 2006-09-29 12:09:44.496000051 +1000
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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==
=== modified file bzrlib/transport/http/__init__.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvaHR0cC9fX2luaXRfXy5weQorKysgYnpybGliL3RyYW5zcG9y
dC9odHRwL19faW5pdF9fLnB5CkBAIC02NjMsOCArNjYzLDggQEAKICAgICAgICAgZGF0YSA9IHNl
bGYucmZpbGUucmVhZChkYXRhX2xlbmd0aCAtIGxlbihmaXJzdF9saW5lKSkKICAgICAgICAgc21h
cnRfcHJvdG9jb2xfcmVxdWVzdC5hY2NlcHRfYnl0ZXMoZmlyc3RfbGluZSkKICAgICAgICAgc21h
cnRfcHJvdG9jb2xfcmVxdWVzdC5hY2NlcHRfYnl0ZXMoZGF0YSkKLSAgICAgICAgYXNzZXJ0IHNt
YXJ0X3Byb3RvY29sX3JlcXVlc3QuZmluaXNoZWRfcmVhZGluZywgXAotICAgICAgICAgICAgIm5v
dCBmaW5pc2hlZCByZWFkaW5nLCBidXQgYWxsIGRhdGEgc2VudCB0byBwcm90b2NvbC4iCisgICAg
ICAgIGFzc2VydCBzbWFydF9wcm90b2NvbF9yZXF1ZXN0Lm5leHRfcmVhZF9zaXplKCkgPT0gMCwg
KAorICAgICAgICAgICAgIm5vdCBmaW5pc2hlZCByZWFkaW5nLCBidXQgYWxsIGRhdGEgc2VudCB0
byBwcm90b2NvbC4iKQogICAgICAgICBzZWxmLnNlbmRfaGVhZGVyKCJDb250ZW50LUxlbmd0aCIs
IHN0cihsZW4ob3V0X2J1ZmZlci5nZXR2YWx1ZSgpKSkpCiAgICAgICAgIHNlbGYuZW5kX2hlYWRl
cnMoKQogICAgICAgICBzZWxmLndmaWxlLndyaXRlKG91dF9idWZmZXIuZ2V0dmFsdWUoKSkKCg==
=== modified file bzrlib/transport/smart.py // encoding:base64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==
# revision id: andrew.bennetts at canonical.com-20060929020944-928dfe5361c8c7ad
# sha1: f32eaf3ad63d468df8ed5eb8629531ae77c7e335
# inventory sha1: 8c982b2ea9605d0c69ef6e1fcbf761255e6c13f7
# parent ids:
# andrew.bennetts at canonical.com-20060928080615-d7bc2a8e393ce711
# properties:
# branch-nick: hpss HTTP support
# message:
# Seperate SmartServer{Pipe,Socket}StreamMedium out of SmartServerStreamMedium. Use recv to make the socket server medium better.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Thu 2006-09-28 18:06:15.463999987 +1000
=== modified file BRANCH.TODO // encoding:base64
LS0tIEJSQU5DSC5UT0RPCisrKyBCUkFOQ0guVE9ETwpAQCAtMyw3ICszLDUgQEAKICMgCiAKIEZp
eCB0aHJlZSBjYXNlcyBvZiByZWFkKDEpLWxpa2UgcHJvYmxlbXM6Ci0gICogU21hcnRDbGllbnRS
ZXF1ZXN0UHJvdG9jb2xPbmUucmVhZF9ib2R5X2J5dGVzIChET05FKQotICAqIFNtYXJ0Q2xpZW50
UmVxdWVzdFByb3RvY29sT25lLl9yZWN2X3R1cGxlCiAgICogU21hcnRTZXJ2ZXJTdHJlYW1NZWRp
dW0uX3NlcnZlX29uZV9yZXF1ZXN0CiAKCg==
=== modified file bzrlib/builtins.py // encoding:base64
LS0tIGJ6cmxpYi9idWlsdGlucy5weQorKysgYnpybGliL2J1aWx0aW5zLnB5CkBAIC0yODUzLDcg
KzI4NTMsNyBAQAogICAgICAgICAgICAgdXJsID0gJ3JlYWRvbmx5KycgKyB1cmwKICAgICAgICAg
dCA9IGdldF90cmFuc3BvcnQodXJsKQogICAgICAgICBpZiBpbmV0OgotICAgICAgICAgICAgc2Vy
dmVyID0gc21hcnQuU21hcnRTZXJ2ZXJTdHJlYW1NZWRpdW0oc3lzLnN0ZGluLCBzeXMuc3Rkb3V0
LCB0KQorICAgICAgICAgICAgc2VydmVyID0gc21hcnQuU21hcnRTZXJ2ZXJQaXBlU3RyZWFtTWVk
aXVtKHN5cy5zdGRpbiwgc3lzLnN0ZG91dCwgdCkKICAgICAgICAgZWxpZiBwb3J0IGlzIG5vdCBO
b25lOgogICAgICAgICAgICAgaWYgJzonIGluIHBvcnQ6CiAgICAgICAgICAgICAgICAgaG9zdCwg
cG9ydCA9IHBvcnQuc3BsaXQoJzonKQoK
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/transport/smart.py // encoding:base64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# revision id: andrew.bennetts at canonical.com-20060928080615-d7bc2a8e393ce711
# sha1: b6b82173fca5dcbfddbd46017a031a36583d790a
# inventory sha1: 7423e7c7f2fdb8dc8f590ae96a925537aff0a4e4
# parent ids:
# andrew.bennetts at canonical.com-20060928050227-021df4f75bca5f88
# properties:
# branch-nick: hpss HTTP support
# message:
# Update SmartClientRequestProtocolOne.read_body_bytes to use next_read_size.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Thu 2006-09-28 15:02:27.290999889 +1000
=== modified file bzrlib/transport/smart.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQucHkKKysrIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQu
cHkKQEAgLTE1MDQsOSArMTUwNCw3IEBACiAgICAgICAgIF9ib2R5X2RlY29kZXIgPSBMZW5ndGhQ
cmVmaXhlZEJvZHlEZWNvZGVyKCkKIAogICAgICAgICB3aGlsZSBub3QgX2JvZHlfZGVjb2Rlci5m
aW5pc2hlZF9yZWFkaW5nOgotICAgICAgICAgICAgYnl0ZXNfd2FudGVkID0gX2JvZHlfZGVjb2Rl
ci5ieXRlc19sZWZ0Ci0gICAgICAgICAgICBpZiBieXRlc193YW50ZWQgaXMgTm9uZToKLSAgICAg
ICAgICAgICAgICBieXRlc193YW50ZWQgPSAxCisgICAgICAgICAgICBieXRlc193YW50ZWQgPSBf
Ym9keV9kZWNvZGVyLm5leHRfcmVhZF9zaXplKCkKICAgICAgICAgICAgIGJ5dGVzID0gc2VsZi5f
cmVxdWVzdC5yZWFkX2J5dGVzKGJ5dGVzX3dhbnRlZCkKICAgICAgICAgICAgIF9ib2R5X2RlY29k
ZXIuYWNjZXB0X2J5dGVzKGJ5dGVzKQogICAgICAgICBzZWxmLl9yZXF1ZXN0LmZpbmlzaGVkX3Jl
YWRpbmcoKQoK
# revision id: andrew.bennetts at canonical.com-20060928050227-021df4f75bca5f88
# sha1: 3fba8f12e19f753298f00d35590f99d94a2f7cfc
# inventory sha1: ace18bb063ec1c413fdd2239f4ec114d3cb2c229
# parent ids:
# andrew.bennetts at canonical.com-20060928040135-c2c58bbb690acc08
# properties:
# branch-nick: hpss HTTP support
# message:
# Merge from bzr.dev
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Thu 2006-09-28 14:01:35.219000101 +1000
=== modified file BRANCH.TODO // encoding:base64
LS0tIEJSQU5DSC5UT0RPCisrKyBCUkFOQ0guVE9ETwpAQCAtMSwzICsxLDkgQEAKICMgVGhpcyBm
aWxlIGlzIGZvciBsaXN0aW5nIFRPRE9zIGZvciBicmFuY2hlcyB0aGF0IGFyZSBiZWluZyB3b3Jr
ZWQgb24uCiAjIEl0IHNob3VsZCBBTFdBWVMgYmUgZW1wdHkgaW4gdGhlIG1haW5saW5lIG9yIGlu
IGludGVncmF0aW9uIGJyYW5jaGVzLgogIyAKKworRml4IHRocmVlIGNhc2VzIG9mIHJlYWQoMSkt
bGlrZSBwcm9ibGVtczoKKyAgKiBTbWFydENsaWVudFJlcXVlc3RQcm90b2NvbE9uZS5yZWFkX2Jv
ZHlfYnl0ZXMgKERPTkUpCisgICogU21hcnRDbGllbnRSZXF1ZXN0UHJvdG9jb2xPbmUuX3JlY3Zf
dHVwbGUKKyAgKiBTbWFydFNlcnZlclN0cmVhbU1lZGl1bS5fc2VydmVfb25lX3JlcXVlc3QKKwoK
=== modified file bzrlib/builtins.py // encoding:base64
LS0tIGJ6cmxpYi9idWlsdGlucy5weQorKysgYnpybGliL2J1aWx0aW5zLnB5CkBAIC0yODUzLDcg
KzI4NTMsNyBAQAogICAgICAgICAgICAgdXJsID0gJ3JlYWRvbmx5KycgKyB1cmwKICAgICAgICAg
dCA9IGdldF90cmFuc3BvcnQodXJsKQogICAgICAgICBpZiBpbmV0OgotICAgICAgICAgICAgc2Vy
dmVyID0gc21hcnQuU21hcnRTdHJlYW1TZXJ2ZXIoc3lzLnN0ZGluLCBzeXMuc3Rkb3V0LCB0KQor
ICAgICAgICAgICAgc2VydmVyID0gc21hcnQuU21hcnRTZXJ2ZXJTdHJlYW1NZWRpdW0oc3lzLnN0
ZGluLCBzeXMuc3Rkb3V0LCB0KQogICAgICAgICBlbGlmIHBvcnQgaXMgbm90IE5vbmU6CiAgICAg
ICAgICAgICBpZiAnOicgaW4gcG9ydDoKICAgICAgICAgICAgICAgICBob3N0LCBwb3J0ID0gcG9y
dC5zcGxpdCgnOicpCgo=
=== modified file bzrlib/errors.py // encoding:base64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=== modified file bzrlib/tests/blackbox/test_serve.py // last-changed:andrew.be
... nnetts at canonical.com-20060921091520-673c55c101a86614 // encoding:base64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=== modified file bzrlib/tests/test_errors.py // encoding:base64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=== modified file bzrlib/tests/test_http.py // last-changed:andrew.bennetts at can
... onical.com-20060926054631-7d63ee5c801fb098 // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X2h0dHAucHkKKysrIGJ6cmxpYi90ZXN0cy90ZXN0X2h0dHAu
cHkKQEAgLTE5LDE4ICsxOSwyMSBAQAogCiAjIFRPRE86IFNob3VsZCBiZSByZW5hbWVkIHRvIGJ6
cmxpYi50cmFuc3BvcnQuaHR0cC50ZXN0cz8KIAoraW1wb3J0IGVycm5vCitpbXBvcnQgc2VsZWN0
CiBpbXBvcnQgc29ja2V0CitpbXBvcnQgdGhyZWFkaW5nCiAKIGltcG9ydCBienJsaWIKLWZyb20g
YnpybGliLmVycm9ycyBpbXBvcnQgRGVwZW5kZW5jeU5vdFByZXNlbnQKK2Zyb20gYnpybGliLmVy
cm9ycyBpbXBvcnQgRGVwZW5kZW5jeU5vdFByZXNlbnQsIFVuc3VwcG9ydGVkUHJvdG9jb2wKIGZy
b20gYnpybGliLnRlc3RzIGltcG9ydCBUZXN0Q2FzZSwgVGVzdFNraXBwZWQKLWZyb20gYnpybGli
LnRyYW5zcG9ydCBpbXBvcnQgVHJhbnNwb3J0Citmcm9tIGJ6cmxpYi50cmFuc3BvcnQgaW1wb3J0
IGdldF90cmFuc3BvcnQsIFRyYW5zcG9ydAogZnJvbSBienJsaWIudHJhbnNwb3J0Lmh0dHAgaW1w
b3J0IGV4dHJhY3RfYXV0aCwgSHR0cFRyYW5zcG9ydEJhc2UKIGZyb20gYnpybGliLnRyYW5zcG9y
dC5odHRwLl91cmxsaWIgaW1wb3J0IEh0dHBUcmFuc3BvcnRfdXJsbGliCiBmcm9tIGJ6cmxpYi50
ZXN0cy5IVFRQVGVzdFV0aWwgaW1wb3J0IFRlc3RDYXNlV2l0aFdlYnNlcnZlcgogCiAKLWNsYXNz
IEZha2VNYW5hZ2VyIChvYmplY3QpOgorY2xhc3MgRmFrZU1hbmFnZXIob2JqZWN0KToKIAogICAg
IGRlZiBfX2luaXRfXyhzZWxmKToKICAgICAgICAgc2VsZi5jcmVkZW50aWFscyA9IFtdCkBAIC0z
OSw2ICs0Miw1NCBAQAogICAgICAgICBzZWxmLmNyZWRlbnRpYWxzLmFwcGVuZChbcmVhbG0sIGhv
c3QsIHVzZXJuYW1lLCBwYXNzd29yZF0pCiAKIAorY2xhc3MgUmVjb3JkaW5nU2VydmVyKG9iamVj
dCk6CisgICAgIiIiQSBmYWtlIEhUVFAgc2VydmVyLgorICAgIAorICAgIEl0IHJlY29yZHMgdGhl
IGJ5dGVzIHNlbnQgdG8gaXQsIGFuZCByZXBsaWVzIHdpdGggYSAyMDAuCisgICAgIiIiCisKKyAg
ICBkZWYgX19pbml0X18oc2VsZiwgZXhwZWN0X2JvZHlfdGFpbD1Ob25lKToKKyAgICAgICAgc2Vs
Zi5fZXhwZWN0X2JvZHlfdGFpbCA9IGV4cGVjdF9ib2R5X3RhaWwKKyAgICAgICAgc2VsZi5ob3N0
ID0gTm9uZQorICAgICAgICBzZWxmLnBvcnQgPSBOb25lCisgICAgICAgIHNlbGYucmVjZWl2ZWRf
Ynl0ZXMgPSAnJworCisgICAgZGVmIHNldFVwKHNlbGYpOgorICAgICAgICBzZWxmLl9zb2NrID0g
c29ja2V0LnNvY2tldChzb2NrZXQuQUZfSU5FVCwgc29ja2V0LlNPQ0tfU1RSRUFNKQorICAgICAg
ICBzZWxmLl9zb2NrLmJpbmQoKCcxMjcuMC4wLjEnLCAwKSkKKyAgICAgICAgc2VsZi5ob3N0LCBz
ZWxmLnBvcnQgPSBzZWxmLl9zb2NrLmdldHNvY2tuYW1lKCkKKyAgICAgICAgc2VsZi5fcmVhZHkg
PSB0aHJlYWRpbmcuRXZlbnQoKQorICAgICAgICBzZWxmLl90aHJlYWQgPSB0aHJlYWRpbmcuVGhy
ZWFkKHRhcmdldD1zZWxmLl9hY2NlcHRfcmVhZF9hbmRfcmVwbHkpCisgICAgICAgIHNlbGYuX3Ro
cmVhZC5zZXREYWVtb24oVHJ1ZSkKKyAgICAgICAgc2VsZi5fdGhyZWFkLnN0YXJ0KCkKKyAgICAg
ICAgc2VsZi5fcmVhZHkud2FpdCg1KQorCisgICAgZGVmIF9hY2NlcHRfcmVhZF9hbmRfcmVwbHko
c2VsZik6CisgICAgICAgIHNlbGYuX3NvY2subGlzdGVuKDEpCisgICAgICAgIHNlbGYuX3JlYWR5
LnNldCgpCisgICAgICAgIHNlbGYuX3NvY2suc2V0dGltZW91dCg1KQorICAgICAgICB0cnk6Cisg
ICAgICAgICAgICBjb25uLCBhZGRyZXNzID0gc2VsZi5fc29jay5hY2NlcHQoKQorICAgICAgICAg
ICAgIyBPbiB3aW4zMiwgdGhlIGFjY2VwdGVkIGNvbm5lY3Rpb24gd2lsbCBiZSBub24tYmxvY2tp
bmcgdG8gc3RhcnQKKyAgICAgICAgICAgICMgd2l0aCBiZWNhdXNlIHdlJ3JlIHVzaW5nIHNldHRp
bWVvdXQuCisgICAgICAgICAgICBjb25uLnNldGJsb2NraW5nKFRydWUpCisgICAgICAgICAgICB3
aGlsZSBub3Qgc2VsZi5yZWNlaXZlZF9ieXRlcy5lbmRzd2l0aChzZWxmLl9leHBlY3RfYm9keV90
YWlsKToKKyAgICAgICAgICAgICAgICBzZWxmLnJlY2VpdmVkX2J5dGVzICs9IGNvbm4ucmVjdig0
MDk2KQorICAgICAgICAgICAgY29ubi5zZW5kYWxsKCdIVFRQLzEuMSAyMDAgT0tcclxuJykKKyAg
ICAgICAgZXhjZXB0IHNvY2tldC50aW1lb3V0OgorICAgICAgICAgICAgIyBNYWtlIHN1cmUgdGhl
IGNsaWVudCBpc24ndCBzdHVjayB3YWl0aW5nIGZvciB1cyB0byBlLmcuIGFjY2VwdC4KKyAgICAg
ICAgICAgIHNlbGYuX3NvY2suY2xvc2UoKQorCisgICAgZGVmIHRlYXJEb3duKHNlbGYpOgorICAg
ICAgICB0cnk6CisgICAgICAgICAgICBzZWxmLl9zb2NrLmNsb3NlKCkKKyAgICAgICAgZXhjZXB0
IHNvY2tldC5lcnJvcjoKKyAgICAgICAgICAgICMgV2UgbWlnaHQgaGF2ZSBhbHJlYWR5IGNsb3Nl
ZCBpdC4gIFdlIGRvbid0IGNhcmUuCisgICAgICAgICAgICBwYXNzCisgICAgICAgIHNlbGYuaG9z
dCA9IE5vbmUKKyAgICAgICAgc2VsZi5wb3J0ID0gTm9uZQorCisKIGNsYXNzIFRlc3RIdHRwVXJs
cyhUZXN0Q2FzZSk6CiAKICAgICBkZWYgdGVzdF91cmxfcGFyc2luZyhzZWxmKToKQEAgLTEyNSw2
ICsxNzYsMTMgQEAKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHNlcnZlci5sb2dzWzBdLmZpbmQo
CiAgICAgICAgICAgICAnIkdFVCAvZm9vL2JhciBIVFRQLzEuMSIgMjAwIC0gIi0iICJienIvJXMn
ICUgYnpybGliLl9fdmVyc2lvbl9fKSA+IC0xKQogCisgICAgZGVmIHRlc3RfZ2V0X3NtYXJ0X21l
ZGl1bShzZWxmKToKKyAgICAgICAgIyBGb3IgSFRUUCwgZ2V0X3NtYXJ0X21lZGl1bSBzaG91bGQg
cmV0dXJuIHRoZSB0cmFuc3BvcnQgb2JqZWN0LgorICAgICAgICBzZXJ2ZXIgPSBzZWxmLmdldF9y
ZWFkb25seV9zZXJ2ZXIoKQorICAgICAgICBodHRwX3RyYW5zcG9ydCA9IHNlbGYuX3RyYW5zcG9y
dChzZXJ2ZXIuZ2V0X3VybCgpKQorICAgICAgICBtZWRpdW0gPSBodHRwX3RyYW5zcG9ydC5nZXRf
c21hcnRfbWVkaXVtKCkKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKG1lZGl1bSBpcyBodHRwX3Ry
YW5zcG9ydCkKKyAgICAgICAgCiAKIGNsYXNzIFRlc3RIdHRwQ29ubmVjdGlvbnNfdXJsbGliKFRl
c3RDYXNlV2l0aFdlYnNlcnZlciwgVGVzdEh0dHBNaXhpbnMpOgogCkBAIC0xNjAsNyArMjE4LDYg
QEAKICAgICAgICAgc2VsZi5fcHJlcF90cmVlKCkKIAogCi0KIGNsYXNzIFRlc3RIdHRwVHJhbnNw
b3J0UmVnaXN0cmF0aW9uKFRlc3RDYXNlKToKICAgICAiIiJUZXN0IHJlZ2lzdHJhdGlvbnMgb2Yg
dmFyaW91cyBodHRwIGltcGxlbWVudGF0aW9ucyIiIgogCkBAIC0xOTcsNiArMjU0LDM0IEBACiAg
ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoW1sxMCwgMTJdLCBbMjIsIDI2XV0sIHJhbmdlcykKIAog
CitjbGFzcyBUZXN0UG9zdChUZXN0Q2FzZSk6CisKKyAgICBkZWYgX3Rlc3RfcG9zdF9ib2R5X2lz
X3JlY2VpdmVkKHNlbGYsIHNjaGVtZSk6CisgICAgICAgIHNlcnZlciA9IFJlY29yZGluZ1NlcnZl
cihleHBlY3RfYm9keV90YWlsPSdlbmQtb2YtYm9keScpCisgICAgICAgIHNlcnZlci5zZXRVcCgp
CisgICAgICAgIHNlbGYuYWRkQ2xlYW51cChzZXJ2ZXIudGVhckRvd24pCisgICAgICAgIHVybCA9
ICclczovLyVzOiVzLycgJSAoc2NoZW1lLCBzZXJ2ZXIuaG9zdCwgc2VydmVyLnBvcnQpCisgICAg
ICAgIHRyeToKKyAgICAgICAgICAgIGh0dHBfdHJhbnNwb3J0ID0gZ2V0X3RyYW5zcG9ydCh1cmwp
CisgICAgICAgIGV4Y2VwdCBVbnN1cHBvcnRlZFByb3RvY29sOgorICAgICAgICAgICAgcmFpc2Ug
VGVzdFNraXBwZWQoJyVzIG5vdCBhdmFpbGFibGUnICUgc2NoZW1lKQorICAgICAgICBjb2RlLCBy
ZXNwb25zZSA9IGh0dHBfdHJhbnNwb3J0Ll9wb3N0KCdhYmMgZGVmIGVuZC1vZi1ib2R5JykKKyAg
ICAgICAgc2VsZi5hc3NlcnRUcnVlKAorICAgICAgICAgICAgc2VydmVyLnJlY2VpdmVkX2J5dGVz
LnN0YXJ0c3dpdGgoJ1BPU1QgLy5ienIvc21hcnQgSFRUUC8xLicpKQorICAgICAgICBzZWxmLmFz
c2VydFRydWUoJ2NvbnRlbnQtbGVuZ3RoOiAxOVxyJyBpbiBzZXJ2ZXIucmVjZWl2ZWRfYnl0ZXMu
bG93ZXIoKSkKKyAgICAgICAgIyBUaGUgdHJhbnNwb3J0IHNob3VsZCBub3QgYmUgYXNzdW1pbmcg
dGhhdCB0aGUgc2VydmVyIGNhbiBhY2NlcHQKKyAgICAgICAgIyBjaHVua2VkIGVuY29kaW5nIHRo
ZSBmaXJzdCB0aW1lIGl0IGNvbm5lY3RzLCBiZWNhdXNlIEhUVFAvMS4xLCBzbyB3ZQorICAgICAg
ICAjIGNoZWNrIGZvciB0aGUgbGl0ZXJhbCBzdHJpbmcuCisgICAgICAgIHNlbGYuYXNzZXJ0VHJ1
ZSgKKyAgICAgICAgICAgIHNlcnZlci5yZWNlaXZlZF9ieXRlcy5lbmRzd2l0aCgnXHJcblxyXG5h
YmMgZGVmIGVuZC1vZi1ib2R5JykpCisKKyAgICBkZWYgdGVzdF9wb3N0X2JvZHlfaXNfcmVjZWl2
ZWRfdXJsbGliKHNlbGYpOgorICAgICAgICBzZWxmLl90ZXN0X3Bvc3RfYm9keV9pc19yZWNlaXZl
ZCgnaHR0cCt1cmxsaWInKQorCisgICAgZGVmIHRlc3RfcG9zdF9ib2R5X2lzX3JlY2VpdmVkX3B5
Y3VybChzZWxmKToKKyAgICAgICAgc2VsZi5fdGVzdF9wb3N0X2JvZHlfaXNfcmVjZWl2ZWQoJ2h0
dHArcHljdXJsJykKKworCiBjbGFzcyBUZXN0UmFuZ2VIZWFkZXIoVGVzdENhc2UpOgogICAgICIi
IlRlc3QgcmFuZ2VfaGVhZGVyIG1ldGhvZCIiIgogCkBAIC0yMjAsMyArMzA1LDM0IEBACiAgICAg
ICAgIHNlbGYuY2hlY2tfaGVhZGVyKCcwLTksMzAwLTUwMDAsLTUwJywKICAgICAgICAgICAgICAg
ICAgICAgICAgICAgcmFuZ2VzPVsoMCw5KSwgKDMwMCw1MDAwKV0sCiAgICAgICAgICAgICAgICAg
ICAgICAgICAgIHRhaWw9NTApCisKKyAgICAgICAgCitjbGFzcyBUZXN0UmVjb3JkaW5nU2VydmVy
KFRlc3RDYXNlKToKKworICAgIGRlZiB0ZXN0X2NyZWF0ZShzZWxmKToKKyAgICAgICAgc2VydmVy
ID0gUmVjb3JkaW5nU2VydmVyKGV4cGVjdF9ib2R5X3RhaWw9Tm9uZSkKKyAgICAgICAgc2VsZi5h
c3NlcnRFcXVhbCgnJywgc2VydmVyLnJlY2VpdmVkX2J5dGVzKQorICAgICAgICBzZWxmLmFzc2Vy
dEVxdWFsKE5vbmUsIHNlcnZlci5ob3N0KQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKE5vbmUs
IHNlcnZlci5wb3J0KQorCisgICAgZGVmIHRlc3Rfc2V0VXBfYW5kX3RlYXJEb3duKHNlbGYpOgor
ICAgICAgICBzZXJ2ZXIgPSBSZWNvcmRpbmdTZXJ2ZXIoZXhwZWN0X2JvZHlfdGFpbD1Ob25lKQor
ICAgICAgICBzZXJ2ZXIuc2V0VXAoKQorICAgICAgICB0cnk6CisgICAgICAgICAgICBzZWxmLmFz
c2VydE5vdEVxdWFsKE5vbmUsIHNlcnZlci5ob3N0KQorICAgICAgICAgICAgc2VsZi5hc3NlcnRO
b3RFcXVhbChOb25lLCBzZXJ2ZXIucG9ydCkKKyAgICAgICAgZmluYWxseToKKyAgICAgICAgICAg
IHNlcnZlci50ZWFyRG93bigpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoTm9uZSwgc2VydmVy
Lmhvc3QpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoTm9uZSwgc2VydmVyLnBvcnQpCisKKyAg
ICBkZWYgdGVzdF9zZW5kX3JlY2VpdmVfYnl0ZXMoc2VsZik6CisgICAgICAgIHNlcnZlciA9IFJl
Y29yZGluZ1NlcnZlcihleHBlY3RfYm9keV90YWlsPSdjJykKKyAgICAgICAgc2VydmVyLnNldFVw
KCkKKyAgICAgICAgc2VsZi5hZGRDbGVhbnVwKHNlcnZlci50ZWFyRG93bikKKyAgICAgICAgc29j
ayA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkKKyAg
ICAgICAgc29jay5jb25uZWN0KChzZXJ2ZXIuaG9zdCwgc2VydmVyLnBvcnQpKQorICAgICAgICBz
b2NrLnNlbmRhbGwoJ2FiYycpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ0hUVFAvMS4xIDIw
MCBPS1xyXG4nLAorICAgICAgICAgICAgICAgICAgICAgICAgIHNvY2sucmVjdig0MDk2LCBzb2Nr
ZXQuTVNHX1dBSVRBTEwpKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCdhYmMnLCBzZXJ2ZXIu
cmVjZWl2ZWRfYnl0ZXMpCgo=
=== modified file bzrlib/tests/test_smart_transport.py // last-changed:andrew.b
... ennetts at canonical.com-20060928034548-7d0a4e39d595ff17 // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3NtYXJ0X3RyYW5zcG9ydC5weQorKysgYnpybGliL3Rlc3Rz
L3Rlc3Rfc21hcnRfdHJhbnNwb3J0LnB5CkBAIC0xOCwxMyArMTgsMTUgQEAKIAogIyBhbGwgb2Yg
dGhpcyBkZWFscyB3aXRoIGJ5dGUgc3RyaW5ncyBzbyB0aGlzIGlzIHNhZmUKIGZyb20gY1N0cmlu
Z0lPIGltcG9ydCBTdHJpbmdJTwotaW1wb3J0IHN1YnByb2Nlc3MKLWltcG9ydCBzeXMKK2ltcG9y
dCBvcworaW1wb3J0IHNvY2tldAoraW1wb3J0IHRocmVhZGluZworaW1wb3J0IHVybGxpYjIKIAot
aW1wb3J0IGJ6cmxpYgogZnJvbSBienJsaWIgaW1wb3J0ICgKICAgICAgICAgYnpyZGlyLAogICAg
ICAgICBlcnJvcnMsCisgICAgICAgIG9zdXRpbHMsCiAgICAgICAgIHRlc3RzLAogICAgICAgICAp
CiBmcm9tIGJ6cmxpYi50cmFuc3BvcnQgaW1wb3J0ICgKQEAgLTMzLDIwICszNSw0ODYgQEAKICAg
ICAgICAgbWVtb3J5LAogICAgICAgICBzbWFydCwKICAgICAgICAgKQotCi0KLWNsYXNzIFNtYXJ0
Q2xpZW50VGVzdHModGVzdHMuVGVzdENhc2UpOgotCi0gICAgZGVmIHRlc3RfY29uc3RydWN0X3Nt
YXJ0X3N0cmVhbV9jbGllbnQoc2VsZik6Ci0gICAgICAgICMgbWFrZSBhIG5ldyBjbGllbnQ7IHRo
aXMgcmVhbGx5IHdhbnRzIGEgY29ubmVjdG9yIGZ1bmN0aW9uIHRoYXQgcmV0dXJucwotICAgICAg
ICAjIHR3byBmaWZvcyBvciBzb2NrZXRzIGJ1dCB0aGUgY29uc3RydWN0b3Igc2hvdWxkIG5vdCBk
byBhbnkgSU8KLSAgICAgICAgY2xpZW50ID0gc21hcnQuU21hcnRTdHJlYW1DbGllbnQoTm9uZSkK
LQotCi1jbGFzcyBUQ1BDbGllbnRUZXN0cyh0ZXN0cy5UZXN0Q2FzZVdpdGhUcmFuc3BvcnQpOgor
ZnJvbSBienJsaWIudHJhbnNwb3J0Lmh0dHAgaW1wb3J0ICgKKyAgICAgICAgSFRUUFNlcnZlcldp
dGhTbWFydHMsCisgICAgICAgIFNtYXJ0Q2xpZW50SFRUUE1lZGl1bVJlcXVlc3QsCisgICAgICAg
IFNtYXJ0UmVxdWVzdEhhbmRsZXIsCisgICAgICAgICkKKworCitjbGFzcyBTdHJpbmdJT1NTSFZl
bmRvcihvYmplY3QpOgorICAgICIiIkEgU1NIIHZlbmRvciB0aGF0IHVzZXMgU3RyaW5nSU8gdG8g
YnVmZmVyIHdyaXRlcyBhbmQgYW5zd2VyIHJlYWRzLiIiIgorCisgICAgZGVmIF9faW5pdF9fKHNl
bGYsIHJlYWRfZnJvbSwgd3JpdGVfdG8pOgorICAgICAgICBzZWxmLnJlYWRfZnJvbSA9IHJlYWRf
ZnJvbQorICAgICAgICBzZWxmLndyaXRlX3RvID0gd3JpdGVfdG8KKyAgICAgICAgc2VsZi5jYWxs
cyA9IFtdCisKKyAgICBkZWYgY29ubmVjdF9zc2goc2VsZiwgdXNlcm5hbWUsIHBhc3N3b3JkLCBo
b3N0LCBwb3J0LCBjb21tYW5kKToKKyAgICAgICAgc2VsZi5jYWxscy5hcHBlbmQoKCdjb25uZWN0
X3NzaCcsIHVzZXJuYW1lLCBwYXNzd29yZCwgaG9zdCwgcG9ydCwKKyAgICAgICAgICAgIGNvbW1h
bmQpKQorICAgICAgICByZXR1cm4gU3RyaW5nSU9TU0hDb25uZWN0aW9uKHNlbGYpCisKKworY2xh
c3MgU3RyaW5nSU9TU0hDb25uZWN0aW9uKG9iamVjdCk6CisgICAgIiIiQSBTU0ggY29ubmVjdGlv
biB0aGF0IHVzZXMgU3RyaW5nSU8gdG8gYnVmZmVyIHdyaXRlcyBhbmQgYW5zd2VyIHJlYWRzLiIi
IgorCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHZlbmRvcik6CisgICAgICAgIHNlbGYudmVuZG9y
ID0gdmVuZG9yCisgICAgCisgICAgZGVmIGNsb3NlKHNlbGYpOgorICAgICAgICBzZWxmLnZlbmRv
ci5jYWxscy5hcHBlbmQoKCdjbG9zZScsICkpCisgICAgICAgIAorICAgIGRlZiBnZXRfZmlsZWxp
a2VfY2hhbm5lbHMoc2VsZik6CisgICAgICAgIHJldHVybiBzZWxmLnZlbmRvci5yZWFkX2Zyb20s
IHNlbGYudmVuZG9yLndyaXRlX3RvCisKKworCitjbGFzcyBTbWFydENsaWVudE1lZGl1bVRlc3Rz
KHRlc3RzLlRlc3RDYXNlKToKKyAgICAiIiJUZXN0cyBmb3IgU21hcnRDbGllbnRNZWRpdW0uCisK
KyAgICBXZSBzaG91bGQgY3JlYXRlIGEgdGVzdCBzY2VuYXJpbyBmb3IgdGhpczogd2UgbmVlZCBh
IHNlcnZlciBtb2R1bGUgdGhhdAorICAgIGNvbnN0cnVjdCB0aGUgdGVzdC1zZXJ2ZXJzIChsaWtl
IG1ha2VfbG9vcHNvY2tldF9hbmRfbWVkaXVtKSwgYW5kIHRoZSBsaXN0CisgICAgb2YgU21hcnRD
bGllbnRNZWRpdW0gY2xhc3NlcyB0byB0ZXN0LgorICAgICIiIgorCisgICAgZGVmIG1ha2VfbG9v
cHNvY2tldF9hbmRfbWVkaXVtKHNlbGYpOgorICAgICAgICAiIiJDcmVhdGUgYSBsb29wYmFjayBz
b2NrZXQgZm9yIHRlc3RpbmcsIGFuZCBhIG1lZGl1bSBhaW1lZCBhdCBpdC4iIiIKKyAgICAgICAg
c29jayA9IHNvY2tldC5zb2NrZXQoc29ja2V0LkFGX0lORVQsIHNvY2tldC5TT0NLX1NUUkVBTSkK
KyAgICAgICAgc29jay5iaW5kKCgnMTI3LjAuMC4xJywgMCkpCisgICAgICAgIHNvY2subGlzdGVu
KDEpCisgICAgICAgIHBvcnQgPSBzb2NrLmdldHNvY2tuYW1lKClbMV0KKyAgICAgICAgbWVkaXVt
ID0gc21hcnQuU21hcnRUQ1BDbGllbnRNZWRpdW0oJzEyNy4wLjAuMScsIHBvcnQpCisgICAgICAg
IHJldHVybiBzb2NrLCBtZWRpdW0KKworICAgIGRlZiByZWNlaXZlX2J5dGVzX29uX3NlcnZlcihz
ZWxmLCBzb2NrLCBieXRlcyk6CisgICAgICAgICIiIkFjY2VwdCBhIGNvbm5lY3Rpb24gb24gc29j
ayBhbmQgcmVhZCAzIGJ5dGVzLgorCisgICAgICAgIFRoZSBieXRlcyBhcmUgYXBwZW5kZWQgdG8g
dGhlIGxpc3QgYnl0ZXMuCisKKyAgICAgICAgOnJldHVybjogYSBUaHJlYWQgd2hpY2ggaXMgcnVu
bmluZyB0byBkbyB0aGUgYWNjZXB0IGFuZCByZWN2LgorICAgICAgICAiIiIKKyAgICAgICAgZGVm
IF9yZWNlaXZlX2J5dGVzX29uX3NlcnZlcigpOgorICAgICAgICAgICAgY29ubmVjdGlvbiwgYWRk
cmVzcyA9IHNvY2suYWNjZXB0KCkKKyAgICAgICAgICAgIGJ5dGVzLmFwcGVuZChjb25uZWN0aW9u
LnJlY3YoMywgc29ja2V0Lk1TR19XQUlUQUxMKSkKKyAgICAgICAgICAgIGNvbm5lY3Rpb24uY2xv
c2UoKQorICAgICAgICB0ID0gdGhyZWFkaW5nLlRocmVhZCh0YXJnZXQ9X3JlY2VpdmVfYnl0ZXNf
b25fc2VydmVyKQorICAgICAgICB0LnN0YXJ0KCkKKyAgICAgICAgcmV0dXJuIHQKKyAgICAKKyAg
ICBkZWYgdGVzdF9jb25zdHJ1Y3Rfc21hcnRfc3RyZWFtX21lZGl1bV9jbGllbnQoc2VsZik6Cisg
ICAgICAgICMgbWFrZSBhIG5ldyBpbnN0YW5jZSBvZiB0aGUgY29tbW9uIGJhc2UgZm9yIFN0cmVh
bS1saWtlIE1lZGl1bXMuCisgICAgICAgICMgdGhpcyBqdXN0IGVuc3VyZXMgdGhhdCB0aGUgY29u
c3RydWN0b3Igc3RheXMgcGFyYW1ldGVyLWZyZWUgd2hpY2gKKyAgICAgICAgIyBpcyBpbXBvcnRh
bnQgZm9yIHJldXNlIDogc29tZSBzdWJjbGFzc2VzIHdpbGwgZHluYW1pY2FsbHkgY29ubmVjdCwK
KyAgICAgICAgIyBvdGhlcnMgYXJlIGFsd2F5cyBvbiwgZXRjLgorICAgICAgICBtZWRpdW0gPSBz
bWFydC5TbWFydENsaWVudFN0cmVhbU1lZGl1bSgpCisKKyAgICBkZWYgdGVzdF9jb25zdHJ1Y3Rf
c21hcnRfY2xpZW50X21lZGl1bShzZWxmKToKKyAgICAgICAgIyB0aGUgYmFzZSBjbGllbnQgbWVk
aXVtIHRha2VzIG5vIHBhcmFtZXRlcnMKKyAgICAgICAgbWVkaXVtID0gc21hcnQuU21hcnRDbGll
bnRNZWRpdW0oKQorICAgIAorICAgIGRlZiB0ZXN0X2NvbnN0cnVjdF9zbWFydF9zaW1wbGVfcGlw
ZXNfY2xpZW50X21lZGl1bShzZWxmKToKKyAgICAgICAgIyB0aGUgU2ltcGxlUGlwZXMgY2xpZW50
IG1lZGl1bSB0YWtlcyB0d28gcGlwZXM6CisgICAgICAgICMgcmVhZGFibGUgcGlwZSwgd3JpdGVh
YmxlIHBpcGUuCisgICAgICAgICMgQ29uc3RydWN0aW5nIG9uZSBzaG91bGQganVzdCBzYXZlIHRo
ZXNlIGFuZCBkbyBub3RoaW5nLgorICAgICAgICAjIFdlIHRlc3QgdGhpcyBieSBwYXNzaW5nIGlu
IE5vbmUuCisgICAgICAgIG1lZGl1bSA9IHNtYXJ0LlNtYXJ0U2ltcGxlUGlwZXNDbGllbnRNZWRp
dW0oTm9uZSwgTm9uZSkKKyAgICAgICAgCisgICAgZGVmIHRlc3Rfc2ltcGxlX3BpcGVzX2NsaWVu
dF9yZXF1ZXN0X3R5cGUoc2VsZik6CisgICAgICAgICMgU2ltcGxlUGlwZXNDbGllbnQgc2hvdWxk
IHVzZSBTbWFydENsaWVudFN0cmVhbU1lZGl1bVJlcXVlc3Qncy4KKyAgICAgICAgbWVkaXVtID0g
c21hcnQuU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShOb25lLCBOb25lKQorICAgICAgICBy
ZXF1ZXN0ID0gbWVkaXVtLmdldF9yZXF1ZXN0KCkKKyAgICAgICAgc2VsZi5hc3NlcnRJc0luc3Rh
bmNlKHJlcXVlc3QsIHNtYXJ0LlNtYXJ0Q2xpZW50U3RyZWFtTWVkaXVtUmVxdWVzdCkKKworICAg
IGRlZiB0ZXN0X3NpbXBsZV9waXBlc19jbGllbnRfZ2V0X2NvbmN1cnJlbnRfcmVxdWVzdHMoc2Vs
Zik6CisgICAgICAgICMgdGhlIHNpbXBsZV9waXBlcyBjbGllbnQgZG9lcyBub3Qgc3VwcG9ydCBw
aXBlbGluZWQgcmVxdWVzdHM6CisgICAgICAgICMgYnV0IGl0IGRvZXMgc3VwcG9ydCBzZXJpYWwg
cmVxdWVzdHM6IHdlIGNvbnN0cnVjdCBvbmUgYWZ0ZXIgCisgICAgICAgICMgYW5vdGhlciBpcyBm
aW5pc2hlZC4gVGhpcyBpcyBhIHNtb2tlIHRlc3QgdGVzdGluZyB0aGUgaW50ZWdyYXRpb24KKyAg
ICAgICAgIyBvZiB0aGUgU21hcnRDbGllbnRTdHJlYW1NZWRpdW1SZXF1ZXN0IGFuZCB0aGUgU21h
cnRDbGllbnRTdHJlYW1NZWRpdW0KKyAgICAgICAgIyBjbGFzc2VzIC0gYXMgdGhlIHNpYmxpbmcg
Y2xhc3NlcyBzaGFyZSB0aGlzIGxvZ2ljLCB0aGV5IGRvIG5vdCBoYXZlCisgICAgICAgICMgZXhw
bGljaXQgdGVzdHMgZm9yIHRoaXMuCisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAg
ICAgbWVkaXVtID0gc21hcnQuU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShOb25lLCBvdXRw
dXQpCisgICAgICAgIHJlcXVlc3QgPSBtZWRpdW0uZ2V0X3JlcXVlc3QoKQorICAgICAgICByZXF1
ZXN0LmZpbmlzaGVkX3dyaXRpbmcoKQorICAgICAgICByZXF1ZXN0LmZpbmlzaGVkX3JlYWRpbmco
KQorICAgICAgICByZXF1ZXN0MiA9IG1lZGl1bS5nZXRfcmVxdWVzdCgpCisgICAgICAgIHJlcXVl
c3QyLmZpbmlzaGVkX3dyaXRpbmcoKQorICAgICAgICByZXF1ZXN0Mi5maW5pc2hlZF9yZWFkaW5n
KCkKKworICAgIGRlZiB0ZXN0X3NpbXBsZV9waXBlc19jbGllbnRfX2FjY2VwdF9ieXRlc193cml0
ZXNfdG9fd3JpdGFibGUoc2VsZik6CisgICAgICAgICMgYWNjZXB0X2J5dGVzIHdyaXRlcyB0byB0
aGUgd3JpdGVhYmxlIHBpcGUuCisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAgICAg
bWVkaXVtID0gc21hcnQuU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShOb25lLCBvdXRwdXQp
CisgICAgICAgIG1lZGl1bS5fYWNjZXB0X2J5dGVzKCdhYmMnKQorICAgICAgICBzZWxmLmFzc2Vy
dEVxdWFsKCdhYmMnLCBvdXRwdXQuZ2V0dmFsdWUoKSkKKyAgICAKKyAgICBkZWYgdGVzdF9zaW1w
bGVfcGlwZXNfY2xpZW50X2Rpc2Nvbm5lY3RfZG9lc19ub3RoaW5nKHNlbGYpOgorICAgICAgICAj
IGNhbGxpbmcgZGlzY29ubmVjdCBkb2VzIG5vdGhpbmcuCisgICAgICAgIGlucHV0ID0gU3RyaW5n
SU8oKQorICAgICAgICBvdXRwdXQgPSBTdHJpbmdJTygpCisgICAgICAgIG1lZGl1bSA9IHNtYXJ0
LlNtYXJ0U2ltcGxlUGlwZXNDbGllbnRNZWRpdW0oaW5wdXQsIG91dHB1dCkKKyAgICAgICAgIyBz
ZW5kIHNvbWUgYnl0ZXMgdG8gZW5zdXJlIGRpc2Nvbm5lY3RpbmcgYWZ0ZXIgYWN0aXZpdHkgc3Rp
bGwgZG9lcyBub3QKKyAgICAgICAgIyBjbG9zZS4KKyAgICAgICAgbWVkaXVtLl9hY2NlcHRfYnl0
ZXMoJ2FiYycpCisgICAgICAgIG1lZGl1bS5kaXNjb25uZWN0KCkKKyAgICAgICAgc2VsZi5hc3Nl
cnRGYWxzZShpbnB1dC5jbG9zZWQpCisgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2Uob3V0cHV0LmNs
b3NlZCkKKworICAgIGRlZiB0ZXN0X3NpbXBsZV9waXBlc19jbGllbnRfYWNjZXB0X2J5dGVzX2Fm
dGVyX2Rpc2Nvbm5lY3Qoc2VsZik6CisgICAgICAgICMgY2FsbGluZyBkaXNjb25uZWN0IG9uIHRo
ZSBjbGllbnQgZG9lcyBub3QgYWx0ZXIgdGhlIHBpcGUgdGhhdAorICAgICAgICAjIGFjY2VwdF9i
eXRlcyB3cml0ZXMgdG8uCisgICAgICAgIGlucHV0ID0gU3RyaW5nSU8oKQorICAgICAgICBvdXRw
dXQgPSBTdHJpbmdJTygpCisgICAgICAgIG1lZGl1bSA9IHNtYXJ0LlNtYXJ0U2ltcGxlUGlwZXND
bGllbnRNZWRpdW0oaW5wdXQsIG91dHB1dCkKKyAgICAgICAgbWVkaXVtLl9hY2NlcHRfYnl0ZXMo
J2FiYycpCisgICAgICAgIG1lZGl1bS5kaXNjb25uZWN0KCkKKyAgICAgICAgbWVkaXVtLl9hY2Nl
cHRfYnl0ZXMoJ2FiYycpCisgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2UoaW5wdXQuY2xvc2VkKQor
ICAgICAgICBzZWxmLmFzc2VydEZhbHNlKG91dHB1dC5jbG9zZWQpCisgICAgICAgIHNlbGYuYXNz
ZXJ0RXF1YWwoJ2FiY2FiYycsIG91dHB1dC5nZXR2YWx1ZSgpKQorICAgIAorICAgIGRlZiB0ZXN0
X3NpbXBsZV9waXBlc19jbGllbnRfaWdub3Jlc19kaXNjb25uZWN0X3doZW5fbm90X2Nvbm5lY3Rl
ZChzZWxmKToKKyAgICAgICAgIyBEb2luZyBhIGRpc2Nvbm5lY3Qgb24gYSBuZXcgKGFuZCB0aHVz
IHVuY29ubmVjdGVkKSBTaW1wbGVQaXBlcyBtZWRpdW0KKyAgICAgICAgIyBkb2VzIG5vdGhpbmcu
CisgICAgICAgIG1lZGl1bSA9IHNtYXJ0LlNtYXJ0U2ltcGxlUGlwZXNDbGllbnRNZWRpdW0oTm9u
ZSwgTm9uZSkKKyAgICAgICAgbWVkaXVtLmRpc2Nvbm5lY3QoKQorCisgICAgZGVmIHRlc3Rfc2lt
cGxlX3BpcGVzX2NsaWVudF9jYW5fYWx3YXlzX3JlYWQoc2VsZik6CisgICAgICAgICMgU21hcnRT
aW1wbGVQaXBlc0NsaWVudE1lZGl1bSBpcyBuZXZlciBkaXNjb25uZWN0ZWQsIHNvIHJlYWRfYnl0
ZXMKKyAgICAgICAgIyBhbHdheXMgdHJpZXMgdG8gcmVhZCBmcm9tIHRoZSB1bmRlcmx5aW5nIHBp
cGUuCisgICAgICAgIGlucHV0ID0gU3RyaW5nSU8oJ2FiY2RlZicpCisgICAgICAgIG1lZGl1bSA9
IHNtYXJ0LlNtYXJ0U2ltcGxlUGlwZXNDbGllbnRNZWRpdW0oaW5wdXQsIE5vbmUpCisgICAgICAg
IHNlbGYuYXNzZXJ0RXF1YWwoJ2FiYycsIG1lZGl1bS5yZWFkX2J5dGVzKDMpKQorICAgICAgICBt
ZWRpdW0uZGlzY29ubmVjdCgpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ2RlZicsIG1lZGl1
bS5yZWFkX2J5dGVzKDMpKQorICAgICAgICAKKyAgICBkZWYgdGVzdF9zaW1wbGVfcGlwZXNfY2xp
ZW50X3N1cHBvcnRzX19mbHVzaChzZWxmKToKKyAgICAgICAgIyBpbnZva2luZyBfZmx1c2ggb24g
YSBTaW1wbGVQaXBlc0NsaWVudCBzaG91bGQgZmx1c2ggdGhlIG91dHB1dCAKKyAgICAgICAgIyBw
aXBlLiBXZSB0ZXN0IHRoaXMgYnkgY3JlYXRpbmcgYW4gb3V0cHV0IHBpcGUgdGhhdCByZWNvcmRz
CisgICAgICAgICMgZmx1c2ggY2FsbHMgbWFkZSB0byBpdC4KKyAgICAgICAgZnJvbSBTdHJpbmdJ
TyBpbXBvcnQgU3RyaW5nSU8gIyBnZXQgcmVndWxhciBTdHJpbmdJTworICAgICAgICBpbnB1dCA9
IFN0cmluZ0lPKCkKKyAgICAgICAgb3V0cHV0ID0gU3RyaW5nSU8oKQorICAgICAgICBmbHVzaF9j
YWxscyA9IFtdCisgICAgICAgIGRlZiBfZmx1c2goKTogZmx1c2hfY2FsbHMuYXBwZW5kKCdmbHVz
aCcpCisgICAgICAgIG91dHB1dC5mbHVzaCA9IF9mbHVzaAorICAgICAgICBtZWRpdW0gPSBzbWFy
dC5TbWFydFNpbXBsZVBpcGVzQ2xpZW50TWVkaXVtKGlucHV0LCBvdXRwdXQpCisgICAgICAgICMg
dGhpcyBjYWxsIGlzIGhlcmUgdG8gZW5zdXJlIHdlIG9ubHkgZmx1c2ggb25jZSwgbm90IG9uIGV2
ZXJ5CisgICAgICAgICMgX2FjY2VwdF9ieXRlcyBjYWxsLgorICAgICAgICBtZWRpdW0uX2FjY2Vw
dF9ieXRlcygnYWJjJykKKyAgICAgICAgbWVkaXVtLl9mbHVzaCgpCisgICAgICAgIG1lZGl1bS5k
aXNjb25uZWN0KCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChbJ2ZsdXNoJ10sIGZsdXNoX2Nh
bGxzKQorCisgICAgZGVmIHRlc3RfY29uc3RydWN0X3NtYXJ0X3NzaF9jbGllbnRfbWVkaXVtKHNl
bGYpOgorICAgICAgICAjIHRoZSBTU0ggY2xpZW50IG1lZGl1bSB0YWtlczoKKyAgICAgICAgIyBo
b3N0LCBwb3J0LCB1c2VybmFtZSwgcGFzc3dvcmQsIHZlbmRvcgorICAgICAgICAjIENvbnN0cnVj
dGluZyBvbmUgc2hvdWxkIGp1c3Qgc2F2ZSB0aGVzZSBhbmQgZG8gbm90aGluZy4KKyAgICAgICAg
IyB3ZSB0ZXN0IHRoaXMgYnkgY3JlYXRpbmcgYSBlbXB0eSBib3VuZCBzb2NrZXQgYW5kIGNvbnN0
cnVjdGluZworICAgICAgICAjIGEgbWVkaXVtLgorICAgICAgICBzb2NrID0gc29ja2V0LnNvY2tl
dChzb2NrZXQuQUZfSU5FVCwgc29ja2V0LlNPQ0tfU1RSRUFNKQorICAgICAgICBzb2NrLmJpbmQo
KCcxMjcuMC4wLjEnLCAwKSkKKyAgICAgICAgdW5vcGVuX3BvcnQgPSBzb2NrLmdldHNvY2tuYW1l
KClbMV0KKyAgICAgICAgIyBoYXZpbmcgdmVuZG9yIGJlIGludmFsaWQgbWVhbnMgdGhhdCBpZiBp
dCB0cmllcyB0byBjb25uZWN0IHZpYSB0aGUKKyAgICAgICAgIyB2ZW5kb3IgaXQgd2lsbCBibG93
IHVwLgorICAgICAgICBtZWRpdW0gPSBzbWFydC5TbWFydFNTSENsaWVudE1lZGl1bSgnMTI3LjAu
MC4xJywgdW5vcGVuX3BvcnQsCisgICAgICAgICAgICB1c2VybmFtZT1Ob25lLCBwYXNzd29yZD1O
b25lLCB2ZW5kb3I9Im5vdCBhIHZlbmRvciIpCisgICAgICAgIHNvY2suY2xvc2UoKQorCisgICAg
ZGVmIHRlc3Rfc3NoX2NsaWVudF9jb25uZWN0c19vbl9maXJzdF91c2Uoc2VsZik6CisgICAgICAg
ICMgVGhlIG9ubHkgdGhpbmcgdGhhdCBpbml0aWF0ZXMgYSBjb25uZWN0aW9uIGZyb20gdGhlIG1l
ZGl1bSBpcyBnaXZpbmcKKyAgICAgICAgIyBpdCBieXRlcy4KKyAgICAgICAgb3V0cHV0ID0gU3Ry
aW5nSU8oKQorICAgICAgICB2ZW5kb3IgPSBTdHJpbmdJT1NTSFZlbmRvcihTdHJpbmdJTygpLCBv
dXRwdXQpCisgICAgICAgIG1lZGl1bSA9IHNtYXJ0LlNtYXJ0U1NIQ2xpZW50TWVkaXVtKCdhIGhv
c3RuYW1lJywgJ2EgcG9ydCcsICdhIHVzZXJuYW1lJywKKyAgICAgICAgICAgICdhIHBhc3N3b3Jk
JywgdmVuZG9yKQorICAgICAgICBtZWRpdW0uX2FjY2VwdF9ieXRlcygnYWJjJykKKyAgICAgICAg
c2VsZi5hc3NlcnRFcXVhbCgnYWJjJywgb3V0cHV0LmdldHZhbHVlKCkpCisgICAgICAgIHNlbGYu
YXNzZXJ0RXF1YWwoWygnY29ubmVjdF9zc2gnLCAnYSB1c2VybmFtZScsICdhIHBhc3N3b3JkJywK
KyAgICAgICAgICAgICdhIGhvc3RuYW1lJywgJ2EgcG9ydCcsCisgICAgICAgICAgICBbJ2J6cics
ICdzZXJ2ZScsICctLWluZXQnLCAnLS1kaXJlY3Rvcnk9LycsICctLWFsbG93LXdyaXRlcyddKV0s
CisgICAgICAgICAgICB2ZW5kb3IuY2FsbHMpCisgICAgCisgICAgZGVmIHRlc3Rfc3NoX2NsaWVu
dF9jaGFuZ2VzX2NvbW1hbmRfd2hlbl9CWlJfUkVNT1RFX1BBVEhfaXNfc2V0KHNlbGYpOgorICAg
ICAgICAjIFRoZSBvbmx5IHRoaW5nIHRoYXQgaW5pdGlhdGVzIGEgY29ubmVjdGlvbiBmcm9tIHRo
ZSBtZWRpdW0gaXMgZ2l2aW5nCisgICAgICAgICMgaXQgYnl0ZXMuCisgICAgICAgIG91dHB1dCA9
IFN0cmluZ0lPKCkKKyAgICAgICAgdmVuZG9yID0gU3RyaW5nSU9TU0hWZW5kb3IoU3RyaW5nSU8o
KSwgb3V0cHV0KQorICAgICAgICBvcmlnX2J6cl9yZW1vdGVfcGF0aCA9IG9zLmVudmlyb24uZ2V0
KCdCWlJfUkVNT1RFX1BBVEgnKQorICAgICAgICBkZWYgY2xlYW51cF9lbnZpcm9uKCk6CisgICAg
ICAgICAgICBvc3V0aWxzLnNldF9vcl91bnNldF9lbnYoJ0JaUl9SRU1PVEVfUEFUSCcsIG9yaWdf
YnpyX3JlbW90ZV9wYXRoKQorICAgICAgICBzZWxmLmFkZENsZWFudXAoY2xlYW51cF9lbnZpcm9u
KQorICAgICAgICBvcy5lbnZpcm9uWydCWlJfUkVNT1RFX1BBVEgnXSA9ICdmdWdseScKKyAgICAg
ICAgbWVkaXVtID0gc21hcnQuU21hcnRTU0hDbGllbnRNZWRpdW0oJ2EgaG9zdG5hbWUnLCAnYSBw
b3J0JywgJ2EgdXNlcm5hbWUnLAorICAgICAgICAgICAgJ2EgcGFzc3dvcmQnLCB2ZW5kb3IpCisg
ICAgICAgIG1lZGl1bS5fYWNjZXB0X2J5dGVzKCdhYmMnKQorICAgICAgICBzZWxmLmFzc2VydEVx
dWFsKCdhYmMnLCBvdXRwdXQuZ2V0dmFsdWUoKSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChb
KCdjb25uZWN0X3NzaCcsICdhIHVzZXJuYW1lJywgJ2EgcGFzc3dvcmQnLAorICAgICAgICAgICAg
J2EgaG9zdG5hbWUnLCAnYSBwb3J0JywKKyAgICAgICAgICAgIFsnZnVnbHknLCAnc2VydmUnLCAn
LS1pbmV0JywgJy0tZGlyZWN0b3J5PS8nLCAnLS1hbGxvdy13cml0ZXMnXSldLAorICAgICAgICAg
ICAgdmVuZG9yLmNhbGxzKQorICAgIAorICAgIGRlZiB0ZXN0X3NzaF9jbGllbnRfZGlzY29ubmVj
dF9kb2VzX3NvKHNlbGYpOgorICAgICAgICAjIGNhbGxpbmcgZGlzY29ubmVjdCBzaG91bGQgZGlz
Y29ubmVjdCBib3RoIHRoZSByZWFkX2Zyb20gYW5kIHdyaXRlX3RvCisgICAgICAgICMgZmlsZS1s
aWtlIG9iamVjdCBpdCBmcm9tIHRoZSBzc2ggY29ubmVjdGlvbi4KKyAgICAgICAgaW5wdXQgPSBT
dHJpbmdJTygpCisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAgICAgdmVuZG9yID0g
U3RyaW5nSU9TU0hWZW5kb3IoaW5wdXQsIG91dHB1dCkKKyAgICAgICAgbWVkaXVtID0gc21hcnQu
U21hcnRTU0hDbGllbnRNZWRpdW0oJ2EgaG9zdG5hbWUnLCB2ZW5kb3I9dmVuZG9yKQorICAgICAg
ICBtZWRpdW0uX2FjY2VwdF9ieXRlcygnYWJjJykKKyAgICAgICAgbWVkaXVtLmRpc2Nvbm5lY3Qo
KQorICAgICAgICBzZWxmLmFzc2VydFRydWUoaW5wdXQuY2xvc2VkKQorICAgICAgICBzZWxmLmFz
c2VydFRydWUob3V0cHV0LmNsb3NlZCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChbCisgICAg
ICAgICAgICAoJ2Nvbm5lY3Rfc3NoJywgTm9uZSwgTm9uZSwgJ2EgaG9zdG5hbWUnLCBOb25lLAor
ICAgICAgICAgICAgWydienInLCAnc2VydmUnLCAnLS1pbmV0JywgJy0tZGlyZWN0b3J5PS8nLCAn
LS1hbGxvdy13cml0ZXMnXSksCisgICAgICAgICAgICAoJ2Nsb3NlJywgKSwKKyAgICAgICAgICAg
IF0sCisgICAgICAgICAgICB2ZW5kb3IuY2FsbHMpCisKKyAgICBkZWYgdGVzdF9zc2hfY2xpZW50
X2Rpc2Nvbm5lY3RfYWxsb3dzX3JlY29ubmVjdGlvbihzZWxmKToKKyAgICAgICAgIyBjYWxsaW5n
IGRpc2Nvbm5lY3Qgb24gdGhlIGNsaWVudCB0ZXJtaW5hdGVzIHRoZSBjb25uZWN0aW9uLCBidXQg
c2hvdWxkCisgICAgICAgICMgbm90IHByZXZlbnQgYWRkaXRpb25hbCBjb25uZWN0aW9ucyBvY2N1
cmluZy4KKyAgICAgICAgIyB3ZSB0ZXN0IHRoaXMgYnkgaW5pdGlhdGluZyBhIHNlY29uZCBjb25u
ZWN0aW9uIGFmdGVyIGRvaW5nIGEKKyAgICAgICAgIyBkaXNjb25uZWN0LgorICAgICAgICBpbnB1
dCA9IFN0cmluZ0lPKCkKKyAgICAgICAgb3V0cHV0ID0gU3RyaW5nSU8oKQorICAgICAgICB2ZW5k
b3IgPSBTdHJpbmdJT1NTSFZlbmRvcihpbnB1dCwgb3V0cHV0KQorICAgICAgICBtZWRpdW0gPSBz
bWFydC5TbWFydFNTSENsaWVudE1lZGl1bSgnYSBob3N0bmFtZScsIHZlbmRvcj12ZW5kb3IpCisg
ICAgICAgIG1lZGl1bS5fYWNjZXB0X2J5dGVzKCdhYmMnKQorICAgICAgICBtZWRpdW0uZGlzY29u
bmVjdCgpCisgICAgICAgICMgdGhlIGRpc2Nvbm5lY3QgaGFzIGNsb3NlZCBvdXRwdXQsIHNvIHdl
IG5lZWQgYSBuZXcgb3V0cHV0IGZvciB0aGUKKyAgICAgICAgIyBuZXcgY29ubmVjdGlvbiB0byB3
cml0ZSB0by4KKyAgICAgICAgaW5wdXQyID0gU3RyaW5nSU8oKQorICAgICAgICBvdXRwdXQyID0g
U3RyaW5nSU8oKQorICAgICAgICB2ZW5kb3IucmVhZF9mcm9tID0gaW5wdXQyCisgICAgICAgIHZl
bmRvci53cml0ZV90byA9IG91dHB1dDIKKyAgICAgICAgbWVkaXVtLl9hY2NlcHRfYnl0ZXMoJ2Fi
YycpCisgICAgICAgIG1lZGl1bS5kaXNjb25uZWN0KCkKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVl
KGlucHV0LmNsb3NlZCkKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKG91dHB1dC5jbG9zZWQpCisg
ICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShpbnB1dDIuY2xvc2VkKQorICAgICAgICBzZWxmLmFzc2Vy
dFRydWUob3V0cHV0Mi5jbG9zZWQpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoWworICAgICAg
ICAgICAgKCdjb25uZWN0X3NzaCcsIE5vbmUsIE5vbmUsICdhIGhvc3RuYW1lJywgTm9uZSwKKyAg
ICAgICAgICAgIFsnYnpyJywgJ3NlcnZlJywgJy0taW5ldCcsICctLWRpcmVjdG9yeT0vJywgJy0t
YWxsb3ctd3JpdGVzJ10pLAorICAgICAgICAgICAgKCdjbG9zZScsICksCisgICAgICAgICAgICAo
J2Nvbm5lY3Rfc3NoJywgTm9uZSwgTm9uZSwgJ2EgaG9zdG5hbWUnLCBOb25lLAorICAgICAgICAg
ICAgWydienInLCAnc2VydmUnLCAnLS1pbmV0JywgJy0tZGlyZWN0b3J5PS8nLCAnLS1hbGxvdy13
cml0ZXMnXSksCisgICAgICAgICAgICAoJ2Nsb3NlJywgKSwKKyAgICAgICAgICAgIF0sCisgICAg
ICAgICAgICB2ZW5kb3IuY2FsbHMpCisgICAgCisgICAgZGVmIHRlc3Rfc3NoX2NsaWVudF9pZ25v
cmVzX2Rpc2Nvbm5lY3Rfd2hlbl9ub3RfY29ubmVjdGVkKHNlbGYpOgorICAgICAgICAjIERvaW5n
IGEgZGlzY29ubmVjdCBvbiBhIG5ldyAoYW5kIHRodXMgdW5jb25uZWN0ZWQpIFNTSCBtZWRpdW0K
KyAgICAgICAgIyBkb2VzIG5vdGhpbmcuCisgICAgICAgIG1lZGl1bSA9IHNtYXJ0LlNtYXJ0U1NI
Q2xpZW50TWVkaXVtKE5vbmUpCisgICAgICAgIG1lZGl1bS5kaXNjb25uZWN0KCkKKworICAgIGRl
ZiB0ZXN0X3NzaF9jbGllbnRfcmFpc2VzX29uX3JlYWRfd2hlbl9ub3RfY29ubmVjdGVkKHNlbGYp
OgorICAgICAgICAjIERvaW5nIGEgcmVhZCBvbiBhIG5ldyAoYW5kIHRodXMgdW5jb25uZWN0ZWQp
IFNTSCBtZWRpdW0gcmFpc2VzCisgICAgICAgICMgTWVkaXVtTm90Q29ubmVjdGVkLgorICAgICAg
ICBtZWRpdW0gPSBzbWFydC5TbWFydFNTSENsaWVudE1lZGl1bShOb25lKQorICAgICAgICBzZWxm
LmFzc2VydFJhaXNlcyhlcnJvcnMuTWVkaXVtTm90Q29ubmVjdGVkLCBtZWRpdW0ucmVhZF9ieXRl
cywgMCkKKyAgICAgICAgc2VsZi5hc3NlcnRSYWlzZXMoZXJyb3JzLk1lZGl1bU5vdENvbm5lY3Rl
ZCwgbWVkaXVtLnJlYWRfYnl0ZXMsIDEpCisKKyAgICBkZWYgdGVzdF9zc2hfY2xpZW50X3N1cHBv
cnRzX19mbHVzaChzZWxmKToKKyAgICAgICAgIyBpbnZva2luZyBfZmx1c2ggb24gYSBTU0hDbGll
bnRNZWRpdW0gc2hvdWxkIGZsdXNoIHRoZSBvdXRwdXQgCisgICAgICAgICMgcGlwZS4gV2UgdGVz
dCB0aGlzIGJ5IGNyZWF0aW5nIGFuIG91dHB1dCBwaXBlIHRoYXQgcmVjb3JkcworICAgICAgICAj
IGZsdXNoIGNhbGxzIG1hZGUgdG8gaXQuCisgICAgICAgIGZyb20gU3RyaW5nSU8gaW1wb3J0IFN0
cmluZ0lPICMgZ2V0IHJlZ3VsYXIgU3RyaW5nSU8KKyAgICAgICAgaW5wdXQgPSBTdHJpbmdJTygp
CisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAgICAgZmx1c2hfY2FsbHMgPSBbXQor
ICAgICAgICBkZWYgX2ZsdXNoKCk6IGZsdXNoX2NhbGxzLmFwcGVuZCgnZmx1c2gnKQorICAgICAg
ICBvdXRwdXQuZmx1c2ggPSBfZmx1c2gKKyAgICAgICAgdmVuZG9yID0gU3RyaW5nSU9TU0hWZW5k
b3IoaW5wdXQsIG91dHB1dCkKKyAgICAgICAgbWVkaXVtID0gc21hcnQuU21hcnRTU0hDbGllbnRN
ZWRpdW0oJ2EgaG9zdG5hbWUnLCB2ZW5kb3I9dmVuZG9yKQorICAgICAgICAjIHRoaXMgY2FsbCBp
cyBoZXJlIHRvIGVuc3VyZSB3ZSBvbmx5IGZsdXNoIG9uY2UsIG5vdCBvbiBldmVyeQorICAgICAg
ICAjIF9hY2NlcHRfYnl0ZXMgY2FsbC4KKyAgICAgICAgbWVkaXVtLl9hY2NlcHRfYnl0ZXMoJ2Fi
YycpCisgICAgICAgIG1lZGl1bS5fZmx1c2goKQorICAgICAgICBtZWRpdW0uZGlzY29ubmVjdCgp
CisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoWydmbHVzaCddLCBmbHVzaF9jYWxscykKKyAgICAg
ICAgCisgICAgZGVmIHRlc3RfY29uc3RydWN0X3NtYXJ0X3RjcF9jbGllbnRfbWVkaXVtKHNlbGYp
OgorICAgICAgICAjIHRoZSBUQ1AgY2xpZW50IG1lZGl1bSB0YWtlcyBhIGhvc3QgYW5kIGEgcG9y
dC4gIENvbnN0cnVjdGluZyBpdCB3b24ndAorICAgICAgICAjIGNvbm5lY3QgdG8gYW55dGhpbmcu
CisgICAgICAgIHNvY2sgPSBzb2NrZXQuc29ja2V0KHNvY2tldC5BRl9JTkVULCBzb2NrZXQuU09D
S19TVFJFQU0pCisgICAgICAgIHNvY2suYmluZCgoJzEyNy4wLjAuMScsIDApKQorICAgICAgICB1
bm9wZW5fcG9ydCA9IHNvY2suZ2V0c29ja25hbWUoKVsxXQorICAgICAgICBtZWRpdW0gPSBzbWFy
dC5TbWFydFRDUENsaWVudE1lZGl1bSgnMTI3LjAuMC4xJywgdW5vcGVuX3BvcnQpCisgICAgICAg
IHNvY2suY2xvc2UoKQorCisgICAgZGVmIHRlc3RfdGNwX2NsaWVudF9jb25uZWN0c19vbl9maXJz
dF91c2Uoc2VsZik6CisgICAgICAgICMgVGhlIG9ubHkgdGhpbmcgdGhhdCBpbml0aWF0ZXMgYSBj
b25uZWN0aW9uIGZyb20gdGhlIG1lZGl1bSBpcyBnaXZpbmcKKyAgICAgICAgIyBpdCBieXRlcy4K
KyAgICAgICAgc29jaywgbWVkaXVtID0gc2VsZi5tYWtlX2xvb3Bzb2NrZXRfYW5kX21lZGl1bSgp
CisgICAgICAgIGJ5dGVzID0gW10KKyAgICAgICAgdCA9IHNlbGYucmVjZWl2ZV9ieXRlc19vbl9z
ZXJ2ZXIoc29jaywgYnl0ZXMpCisgICAgICAgIG1lZGl1bS5fYWNjZXB0X2J5dGVzKCdhYmMnKQor
ICAgICAgICB0LmpvaW4oKQorICAgICAgICBzb2NrLmNsb3NlKCkKKyAgICAgICAgc2VsZi5hc3Nl
cnRFcXVhbChbJ2FiYyddLCBieXRlcykKKyAgICAKKyAgICBkZWYgdGVzdF90Y3BfY2xpZW50X2Rp
c2Nvbm5lY3RfZG9lc19zbyhzZWxmKToKKyAgICAgICAgIyBjYWxsaW5nIGRpc2Nvbm5lY3Qgb24g
dGhlIGNsaWVudCB0ZXJtaW5hdGVzIHRoZSBjb25uZWN0aW9uLgorICAgICAgICAjIHdlIHRlc3Qg
dGhpcyBieSBmb3JjaW5nIGEgc2hvcnQgcmVhZCBkdXJpbmcgYSBzb2NrZXQuTVNHX1dBSVRBTEwK
KyAgICAgICAgIyBjYWxsIDogd3JpdGUgMiBieXRlcywgdHJ5IHRvIHJlYWQgMywgYW5kIHRoZW4g
dGhlIGNsaWVudCBkaXNjb25uZWN0cy4KKyAgICAgICAgc29jaywgbWVkaXVtID0gc2VsZi5tYWtl
X2xvb3Bzb2NrZXRfYW5kX21lZGl1bSgpCisgICAgICAgIGJ5dGVzID0gW10KKyAgICAgICAgdCA9
IHNlbGYucmVjZWl2ZV9ieXRlc19vbl9zZXJ2ZXIoc29jaywgYnl0ZXMpCisgICAgICAgIG1lZGl1
bS5fYWNjZXB0X2J5dGVzKCdhYicpCisgICAgICAgIG1lZGl1bS5kaXNjb25uZWN0KCkKKyAgICAg
ICAgdC5qb2luKCkKKyAgICAgICAgc29jay5jbG9zZSgpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1
YWwoWydhYiddLCBieXRlcykKKyAgICAgICAgIyBub3cgZGlzY29ubmVjdCBhZ2FpbiA6IHRoaXMg
c2hvdWxkIG5vdCBkbyBhbnl0aGluZywgaWYgZGlzY29ubmVjdGlvbgorICAgICAgICAjIHJlYWxs
eSBkaWQgZGlzY29ubmVjdC4KKyAgICAgICAgbWVkaXVtLmRpc2Nvbm5lY3QoKQorICAgIAorICAg
IGRlZiB0ZXN0X3RjcF9jbGllbnRfaWdub3Jlc19kaXNjb25uZWN0X3doZW5fbm90X2Nvbm5lY3Rl
ZChzZWxmKToKKyAgICAgICAgIyBEb2luZyBhIGRpc2Nvbm5lY3Qgb24gYSBuZXcgKGFuZCB0aHVz
IHVuY29ubmVjdGVkKSBUQ1AgbWVkaXVtCisgICAgICAgICMgZG9lcyBub3RoaW5nLgorICAgICAg
ICBtZWRpdW0gPSBzbWFydC5TbWFydFRDUENsaWVudE1lZGl1bShOb25lLCBOb25lKQorICAgICAg
ICBtZWRpdW0uZGlzY29ubmVjdCgpCisKKyAgICBkZWYgdGVzdF90Y3BfY2xpZW50X3JhaXNlc19v
bl9yZWFkX3doZW5fbm90X2Nvbm5lY3RlZChzZWxmKToKKyAgICAgICAgIyBEb2luZyBhIHJlYWQg
b24gYSBuZXcgKGFuZCB0aHVzIHVuY29ubmVjdGVkKSBUQ1AgbWVkaXVtIHJhaXNlcworICAgICAg
ICAjIE1lZGl1bU5vdENvbm5lY3RlZC4KKyAgICAgICAgbWVkaXVtID0gc21hcnQuU21hcnRUQ1BD
bGllbnRNZWRpdW0oTm9uZSwgTm9uZSkKKyAgICAgICAgc2VsZi5hc3NlcnRSYWlzZXMoZXJyb3Jz
Lk1lZGl1bU5vdENvbm5lY3RlZCwgbWVkaXVtLnJlYWRfYnl0ZXMsIDApCisgICAgICAgIHNlbGYu
YXNzZXJ0UmFpc2VzKGVycm9ycy5NZWRpdW1Ob3RDb25uZWN0ZWQsIG1lZGl1bS5yZWFkX2J5dGVz
LCAxKQorCisgICAgZGVmIHRlc3RfdGNwX2NsaWVudF9zdXBwb3J0c19fZmx1c2goc2VsZik6Cisg
ICAgICAgICMgaW52b2tpbmcgX2ZsdXNoIG9uIGEgVENQQ2xpZW50TWVkaXVtIHNob3VsZCBkbyBz
b21ldGhpbmcgdXNlZnVsLgorICAgICAgICAjIFJCQyAyMDA2MDkyMiBub3Qgc3VyZSBob3cgdG8g
dGVzdC90ZWxsIGluIHRoaXMgY2FzZS4KKyAgICAgICAgc29jaywgbWVkaXVtID0gc2VsZi5tYWtl
X2xvb3Bzb2NrZXRfYW5kX21lZGl1bSgpCisgICAgICAgIGJ5dGVzID0gW10KKyAgICAgICAgdCA9
IHNlbGYucmVjZWl2ZV9ieXRlc19vbl9zZXJ2ZXIoc29jaywgYnl0ZXMpCisgICAgICAgICMgdHJ5
IHdpdGggbm90aGluZyBidWZmZXJlZAorICAgICAgICBtZWRpdW0uX2ZsdXNoKCkKKyAgICAgICAg
bWVkaXVtLl9hY2NlcHRfYnl0ZXMoJ2FiJykKKyAgICAgICAgIyBhbmQgd2l0aCBzb21ldGhpbmcg
c2VudC4KKyAgICAgICAgbWVkaXVtLl9mbHVzaCgpCisgICAgICAgIG1lZGl1bS5kaXNjb25uZWN0
KCkKKyAgICAgICAgdC5qb2luKCkKKyAgICAgICAgc29jay5jbG9zZSgpCisgICAgICAgIHNlbGYu
YXNzZXJ0RXF1YWwoWydhYiddLCBieXRlcykKKyAgICAgICAgIyBub3cgZGlzY29ubmVjdCBhZ2Fp
biA6IHRoaXMgc2hvdWxkIG5vdCBkbyBhbnl0aGluZywgaWYgZGlzY29ubmVjdGlvbgorICAgICAg
ICAjIHJlYWxseSBkaWQgZGlzY29ubmVjdC4KKyAgICAgICAgbWVkaXVtLmRpc2Nvbm5lY3QoKQor
CisKK2NsYXNzIFRlc3RTbWFydENsaWVudFN0cmVhbU1lZGl1bVJlcXVlc3QodGVzdHMuVGVzdENh
c2UpOgorICAgICIiIlRlc3RzIHRoZSBmb3IgU21hcnRDbGllbnRTdHJlYW1NZWRpdW1SZXF1ZXN0
LgorICAgIAorICAgIFNtYXJ0Q2xpZW50U3RyZWFtTWVkaXVtUmVxdWVzdCBpcyBhIGhlbHBlciBm
b3IgdGhlIHRocmVlIHN0cmVhbSBiYXNlZCAKKyAgICBtZWRpdW1zOiBUQ1AsIFNTSCwgU2ltcGxl
UGlwZXMsIHNvIHdlIG9ubHkgdGVzdCBpdCBvbmNlLCBhbmQgdGhlbiB0ZXN0IHRoYXQKKyAgICB0
aG9zZSB0aHJlZSBtZWRpdW1zIGltcGxlbWVudCB0aGUgaW50ZXJmYWNlIGl0IGV4cGVjdHMuCisg
ICAgIiIiCisKKyAgICBkZWYgdGVzdF9hY2NlcHRfYnl0ZXNfYWZ0ZXJfZmluaXNoZWRfd3JpdGlu
Z19lcnJvcnMoc2VsZik6CisgICAgICAgICMgY2FsbGluZyBhY2NlcHRfYnl0ZXMgYWZ0ZXIgY2Fs
bGluZyBmaW5pc2hlZF93cml0aW5nIHJhaXNlcyAKKyAgICAgICAgIyBXcml0aW5nQ29tcGxldGVk
IHRvIHByZXZlbnQgYmFkIGFzc3VtcHRpb25zIG9uIHN0cmVhbSBlbnZpcm9ubWVudHMKKyAgICAg
ICAgIyBicmVha2luZyB0aGUgbmVlZHMgb2YgbWVzc2FnZS1iYXNlZCBlbnZpcm9ubWVudHMuCisg
ICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAgICAgbWVkaXVtID0gc21hcnQuU21hcnRT
aW1wbGVQaXBlc0NsaWVudE1lZGl1bShOb25lLCBvdXRwdXQpCisgICAgICAgIHJlcXVlc3QgPSBz
bWFydC5TbWFydENsaWVudFN0cmVhbU1lZGl1bVJlcXVlc3QobWVkaXVtKQorICAgICAgICByZXF1
ZXN0LmZpbmlzaGVkX3dyaXRpbmcoKQorICAgICAgICBzZWxmLmFzc2VydFJhaXNlcyhlcnJvcnMu
V3JpdGluZ0NvbXBsZXRlZCwgcmVxdWVzdC5hY2NlcHRfYnl0ZXMsIE5vbmUpCisKKyAgICBkZWYg
dGVzdF9hY2NlcHRfYnl0ZXMoc2VsZik6CisgICAgICAgICMgYWNjZXB0IGJ5dGVzIHNob3VsZCBp
bnZva2UgX2FjY2VwdF9ieXRlcyBvbiB0aGUgc3RyZWFtIG1lZGl1bS4KKyAgICAgICAgIyB3ZSB0
ZXN0IHRoaXMgYnkgdXNpbmcgdGhlIFNpbXBsZVBpcGVzIG1lZGl1bSAtIHRoZSBtb3N0IHRyaXZp
YWwgb25lCisgICAgICAgICMgYW5kIGNoZWNraW5nIHRoYXQgdGhlIHBpcGVzIGdldCB0aGUgZGF0
YS4KKyAgICAgICAgaW5wdXQgPSBTdHJpbmdJTygpCisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lP
KCkKKyAgICAgICAgbWVkaXVtID0gc21hcnQuU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShp
bnB1dCwgb3V0cHV0KQorICAgICAgICByZXF1ZXN0ID0gc21hcnQuU21hcnRDbGllbnRTdHJlYW1N
ZWRpdW1SZXF1ZXN0KG1lZGl1bSkKKyAgICAgICAgcmVxdWVzdC5hY2NlcHRfYnl0ZXMoJzEyMycp
CisgICAgICAgIHJlcXVlc3QuZmluaXNoZWRfd3JpdGluZygpCisgICAgICAgIHJlcXVlc3QuZmlu
aXNoZWRfcmVhZGluZygpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJycsIGlucHV0LmdldHZh
bHVlKCkpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJzEyMycsIG91dHB1dC5nZXR2YWx1ZSgp
KQorCisgICAgZGVmIHRlc3RfY29uc3RydWN0X3NldHNfc3RyZWFtX3JlcXVlc3Qoc2VsZik6Cisg
ICAgICAgICMgY29uc3RydWN0aW5nIGEgU21hcnRDbGllbnRTdHJlYW1NZWRpdW1SZXF1ZXN0IG9u
IGEgU3RyZWFtTWVkaXVtIHNldHMKKyAgICAgICAgIyB0aGUgY3VycmVudCByZXF1ZXN0IHRvIHRo
ZSBuZXcgU21hcnRDbGllbnRTdHJlYW1NZWRpdW1SZXF1ZXN0CisgICAgICAgIG91dHB1dCA9IFN0
cmluZ0lPKCkKKyAgICAgICAgbWVkaXVtID0gc21hcnQuU21hcnRTaW1wbGVQaXBlc0NsaWVudE1l
ZGl1bShOb25lLCBvdXRwdXQpCisgICAgICAgIHJlcXVlc3QgPSBzbWFydC5TbWFydENsaWVudFN0
cmVhbU1lZGl1bVJlcXVlc3QobWVkaXVtKQorICAgICAgICBzZWxmLmFzc2VydFRydWUobWVkaXVt
Ll9jdXJyZW50X3JlcXVlc3QgaXMgcmVxdWVzdCkKKworICAgIGRlZiB0ZXN0X2NvbnN0cnVjdF93
aGlsZV9hbm90aGVyX3JlcXVlc3RfYWN0aXZlX3Rocm93cyhzZWxmKToKKyAgICAgICAgIyBjb25z
dHJ1Y3RpbmcgYSBTbWFydENsaWVudFN0cmVhbU1lZGl1bVJlcXVlc3Qgb24gYSBTdHJlYW1NZWRp
dW0gd2l0aAorICAgICAgICAjIGEgbm9uLU5vbmUgX2N1cnJlbnRfcmVxdWVzdCByYWlzZXMgVG9v
TWFueUNvbmN1cnJlbnRSZXF1ZXN0cy4KKyAgICAgICAgb3V0cHV0ID0gU3RyaW5nSU8oKQorICAg
ICAgICBtZWRpdW0gPSBzbWFydC5TbWFydFNpbXBsZVBpcGVzQ2xpZW50TWVkaXVtKE5vbmUsIG91
dHB1dCkKKyAgICAgICAgbWVkaXVtLl9jdXJyZW50X3JlcXVlc3QgPSAiYSIKKyAgICAgICAgc2Vs
Zi5hc3NlcnRSYWlzZXMoZXJyb3JzLlRvb01hbnlDb25jdXJyZW50UmVxdWVzdHMsCisgICAgICAg
ICAgICBzbWFydC5TbWFydENsaWVudFN0cmVhbU1lZGl1bVJlcXVlc3QsIG1lZGl1bSkKKworICAg
IGRlZiB0ZXN0X2ZpbmlzaGVkX3JlYWRfY2xlYXJzX2N1cnJlbnRfcmVxdWVzdChzZWxmKToKKyAg
ICAgICAgIyBjYWxsaW5nIGZpbmlzaGVkX3JlYWRpbmcgY2xlYXJzIHRoZSBjdXJyZW50IHJlcXVl
c3QgZnJvbSB0aGUgcmVxdWVzdHMKKyAgICAgICAgIyBtZWRpdW0KKyAgICAgICAgb3V0cHV0ID0g
U3RyaW5nSU8oKQorICAgICAgICBtZWRpdW0gPSBzbWFydC5TbWFydFNpbXBsZVBpcGVzQ2xpZW50
TWVkaXVtKE5vbmUsIG91dHB1dCkKKyAgICAgICAgcmVxdWVzdCA9IHNtYXJ0LlNtYXJ0Q2xpZW50
U3RyZWFtTWVkaXVtUmVxdWVzdChtZWRpdW0pCisgICAgICAgIHJlcXVlc3QuZmluaXNoZWRfd3Jp
dGluZygpCisgICAgICAgIHJlcXVlc3QuZmluaXNoZWRfcmVhZGluZygpCisgICAgICAgIHNlbGYu
YXNzZXJ0RXF1YWwoTm9uZSwgbWVkaXVtLl9jdXJyZW50X3JlcXVlc3QpCisKKyAgICBkZWYgdGVz
dF9maW5pc2hlZF9yZWFkX2JlZm9yZV9maW5pc2hlZF93cml0ZV9lcnJvcnMoc2VsZik6CisgICAg
ICAgICMgY2FsbGluZyBmaW5pc2hlZF9yZWFkaW5nIGJlZm9yZSBjYWxsaW5nIGZpbmlzaGVkX3dy
aXRpbmcgdHJpZ2dlcnMgYQorICAgICAgICAjIFdyaXRpbmdOb3RDb21wbGV0ZSBlcnJvci4KKyAg
ICAgICAgbWVkaXVtID0gc21hcnQuU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShOb25lLCBO
b25lKQorICAgICAgICByZXF1ZXN0ID0gc21hcnQuU21hcnRDbGllbnRTdHJlYW1NZWRpdW1SZXF1
ZXN0KG1lZGl1bSkKKyAgICAgICAgc2VsZi5hc3NlcnRSYWlzZXMoZXJyb3JzLldyaXRpbmdOb3RD
b21wbGV0ZSwgcmVxdWVzdC5maW5pc2hlZF9yZWFkaW5nKQorICAgICAgICAKKyAgICBkZWYgdGVz
dF9yZWFkX2J5dGVzKHNlbGYpOgorICAgICAgICAjIHJlYWQgYnl0ZXMgc2hvdWxkIGludm9rZSBf
cmVhZF9ieXRlcyBvbiB0aGUgc3RyZWFtIG1lZGl1bS4KKyAgICAgICAgIyB3ZSB0ZXN0IHRoaXMg
YnkgdXNpbmcgdGhlIFNpbXBsZVBpcGVzIG1lZGl1bSAtIHRoZSBtb3N0IHRyaXZpYWwgb25lCisg
ICAgICAgICMgYW5kIGNoZWNraW5nIHRoYXQgdGhlIGRhdGEgaXMgc3VwcGxpZWQuIEl0cyBwb3Nz
aWJsZSB0aGF0IGEgCisgICAgICAgICMgZmF1bHR5IGltcGxlbWVudGF0aW9uIGNvdWxkIHBva2Ug
YXQgdGhlIHBpcGUgdmFyaWFibGVzIHRoZW0gc2VsdmVzLAorICAgICAgICAjIGJ1dCB3ZSB0cnVz
dCB0aGF0IHRoaXMgd2lsbCBiZSBjYXVnaHQgYXMgaXQgd2lsbCBicmVhayB0aGUgaW50ZWdyYXRp
b24KKyAgICAgICAgIyBzbW9rZSB0ZXN0cy4KKyAgICAgICAgaW5wdXQgPSBTdHJpbmdJTygnMzIx
JykKKyAgICAgICAgb3V0cHV0ID0gU3RyaW5nSU8oKQorICAgICAgICBtZWRpdW0gPSBzbWFydC5T
bWFydFNpbXBsZVBpcGVzQ2xpZW50TWVkaXVtKGlucHV0LCBvdXRwdXQpCisgICAgICAgIHJlcXVl
c3QgPSBzbWFydC5TbWFydENsaWVudFN0cmVhbU1lZGl1bVJlcXVlc3QobWVkaXVtKQorICAgICAg
ICByZXF1ZXN0LmZpbmlzaGVkX3dyaXRpbmcoKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCcz
MjEnLCByZXF1ZXN0LnJlYWRfYnl0ZXMoMykpCisgICAgICAgIHJlcXVlc3QuZmluaXNoZWRfcmVh
ZGluZygpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJycsIGlucHV0LnJlYWQoKSkKKyAgICAg
ICAgc2VsZi5hc3NlcnRFcXVhbCgnJywgb3V0cHV0LmdldHZhbHVlKCkpCisKKyAgICBkZWYgdGVz
dF9yZWFkX2J5dGVzX2JlZm9yZV9maW5pc2hlZF93cml0ZV9lcnJvcnMoc2VsZik6CisgICAgICAg
ICMgY2FsbGluZyByZWFkX2J5dGVzIGJlZm9yZSBjYWxsaW5nIGZpbmlzaGVkX3dyaXRpbmcgdHJp
Z2dlcnMgYQorICAgICAgICAjIFdyaXRpbmdOb3RDb21wbGV0ZSBlcnJvciBiZWNhdXNlIHRoZSBT
bWFydCBwcm90b2NvbCBpcyBkZXNpZ25lZCB0byBiZQorICAgICAgICAjIGNvbXBhdGlibGUgd2l0
aCBzdHJpY3QgbWVzc2FnZSBiYXNlZCBwcm90b2NvbHMgbGlrZSBIVFRQIHdoZXJlIHRoZQorICAg
ICAgICAjIHJlcXVlc3QgY2Fubm90IGJlIHN1Ym1pdHRlZCB1bnRpbCB0aGUgd3JpdGluZyBoYXMg
Y29tcGxldGVkLgorICAgICAgICBtZWRpdW0gPSBzbWFydC5TbWFydFNpbXBsZVBpcGVzQ2xpZW50
TWVkaXVtKE5vbmUsIE5vbmUpCisgICAgICAgIHJlcXVlc3QgPSBzbWFydC5TbWFydENsaWVudFN0
cmVhbU1lZGl1bVJlcXVlc3QobWVkaXVtKQorICAgICAgICBzZWxmLmFzc2VydFJhaXNlcyhlcnJv
cnMuV3JpdGluZ05vdENvbXBsZXRlLCByZXF1ZXN0LnJlYWRfYnl0ZXMsIE5vbmUpCisKKyAgICBk
ZWYgdGVzdF9yZWFkX2J5dGVzX2FmdGVyX2ZpbmlzaGVkX3JlYWRpbmdfZXJyb3JzKHNlbGYpOgor
ICAgICAgICAjIGNhbGxpbmcgcmVhZF9ieXRlcyBhZnRlciBjYWxsaW5nIGZpbmlzaGVkX3JlYWRp
bmcgcmFpc2VzIAorICAgICAgICAjIFJlYWRpbmdDb21wbGV0ZWQgdG8gcHJldmVudCBiYWQgYXNz
dW1wdGlvbnMgb24gc3RyZWFtIGVudmlyb25tZW50cworICAgICAgICAjIGJyZWFraW5nIHRoZSBu
ZWVkcyBvZiBtZXNzYWdlLWJhc2VkIGVudmlyb25tZW50cy4KKyAgICAgICAgb3V0cHV0ID0gU3Ry
aW5nSU8oKQorICAgICAgICBtZWRpdW0gPSBzbWFydC5TbWFydFNpbXBsZVBpcGVzQ2xpZW50TWVk
aXVtKE5vbmUsIG91dHB1dCkKKyAgICAgICAgcmVxdWVzdCA9IHNtYXJ0LlNtYXJ0Q2xpZW50U3Ry
ZWFtTWVkaXVtUmVxdWVzdChtZWRpdW0pCisgICAgICAgIHJlcXVlc3QuZmluaXNoZWRfd3JpdGlu
ZygpCisgICAgICAgIHJlcXVlc3QuZmluaXNoZWRfcmVhZGluZygpCisgICAgICAgIHNlbGYuYXNz
ZXJ0UmFpc2VzKGVycm9ycy5SZWFkaW5nQ29tcGxldGVkLCByZXF1ZXN0LnJlYWRfYnl0ZXMsIE5v
bmUpCisKKworY2xhc3MgUmVtb3RlVHJhbnNwb3J0VGVzdHModGVzdHMuVGVzdENhc2VXaXRoVHJh
bnNwb3J0KToKIAogICAgIGRlZiBzZXRVcChzZWxmKToKLSAgICAgICAgc3VwZXIoVENQQ2xpZW50
VGVzdHMsIHNlbGYpLnNldFVwKCkKKyAgICAgICAgc3VwZXIoUmVtb3RlVHJhbnNwb3J0VGVzdHMs
IHNlbGYpLnNldFVwKCkKICAgICAgICAgIyBXZSdyZSBhbGxvd2VkIHRvIHNldCAgdGhlIHRyYW5z
cG9ydCBjbGFzcyBoZXJlLCBzbyB0aGF0IHdlIGRvbid0IHVzZQogICAgICAgICAjIHRoZSBkZWZh
dWx0IG9yIGEgcGFyYW1ldGVyaXplZCBjbGFzcywgYnV0IHJhdGhlciB1c2UgdGhlCiAgICAgICAg
ICMgVGVzdENhc2VXaXRoVHJhbnNwb3J0IGluZnJhc3RydWN0dXJlIHRvIHNldCB1cCBhIHNtYXJ0
IHNlcnZlciBhbmQKQEAgLTYwLDE5ICs1MjgsMjEgQEAKICAgICAgICAgdCA9IHNlbGYuZ2V0X3Ry
YW5zcG9ydCgpCiAgICAgICAgIHNlbGYuYXNzZXJ0SXNJbnN0YW5jZSh0LCBzbWFydC5TbWFydFRy
YW5zcG9ydCkKIAotICAgIGRlZiB0ZXN0X2dldF9jbGllbnRfZnJvbV90cmFuc3BvcnQoc2VsZik6
CisgICAgZGVmIHRlc3RfZ2V0X21lZGl1bV9mcm9tX3RyYW5zcG9ydChzZWxmKToKKyAgICAgICAg
IiIiUmVtb3RlIHRyYW5zcG9ydCBoYXMgYSBtZWRpdW0gYWx3YXlzLCB3aGljaCBpdCBjYW4gcmV0
dXJuLiIiIgogICAgICAgICB0ID0gc2VsZi5nZXRfdHJhbnNwb3J0KCkKLSAgICAgICAgY2xpZW50
ID0gdC5nZXRfc21hcnRfY2xpZW50KCkKLSAgICAgICAgc2VsZi5hc3NlcnRJc0luc3RhbmNlKGNs
aWVudCwgc21hcnQuU21hcnRTdHJlYW1DbGllbnQpCisgICAgICAgIG1lZGl1bSA9IHQuZ2V0X3Nt
YXJ0X21lZGl1bSgpCisgICAgICAgIHNlbGYuYXNzZXJ0SXNJbnN0YW5jZShtZWRpdW0sIHNtYXJ0
LlNtYXJ0Q2xpZW50TWVkaXVtKQogCiAKIGNsYXNzIEJhc2ljU21hcnRUZXN0cyh0ZXN0cy5UZXN0
Q2FzZSk6CiAgICAgCiAgICAgZGVmIHRlc3Rfc21hcnRfcXVlcnlfdmVyc2lvbihzZWxmKToKICAg
ICAgICAgIiIiRmVlZCBhIGNhbm5lZCBxdWVyeSB2ZXJzaW9uIHRvIGEgc2VydmVyIiIiCisgICAg
ICAgICMgd2lyZS10by13aXJlLCB1c2luZyB0aGUgd2hvbGUgc3RhY2sKICAgICAgICAgdG9fc2Vy
dmVyID0gU3RyaW5nSU8oJ2hlbGxvXG4nKQogICAgICAgICBmcm9tX3NlcnZlciA9IFN0cmluZ0lP
KCkKLSAgICAgICAgc2VydmVyID0gc21hcnQuU21hcnRTdHJlYW1TZXJ2ZXIodG9fc2VydmVyLCBm
cm9tX3NlcnZlciwgbG9jYWwuTG9jYWxUcmFuc3BvcnQoJ2ZpbGU6Ly8vJykpCisgICAgICAgIHNl
cnZlciA9IHNtYXJ0LlNtYXJ0U2VydmVyU3RyZWFtTWVkaXVtKHRvX3NlcnZlciwgZnJvbV9zZXJ2
ZXIsIGxvY2FsLkxvY2FsVHJhbnNwb3J0KCdmaWxlOi8vLycpKQogICAgICAgICBzZXJ2ZXIuX3Nl
cnZlX29uZV9yZXF1ZXN0KCkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnb2tcMDAxMVxuJywK
ICAgICAgICAgICAgICAgICAgICAgICAgICBmcm9tX3NlcnZlci5nZXR2YWx1ZSgpKQpAQCAtODIs
NyArNTUyLDcgQEAKICAgICAgICAgdHJhbnNwb3J0LnB1dF9ieXRlcygndGVzdGZpbGUnLCAnY29u
dGVudHNcbm9mXG5maWxlXG4nKQogICAgICAgICB0b19zZXJ2ZXIgPSBTdHJpbmdJTygnZ2V0XDAw
MS4vdGVzdGZpbGVcbicpCiAgICAgICAgIGZyb21fc2VydmVyID0gU3RyaW5nSU8oKQotICAgICAg
ICBzZXJ2ZXIgPSBzbWFydC5TbWFydFN0cmVhbVNlcnZlcih0b19zZXJ2ZXIsIGZyb21fc2VydmVy
LCB0cmFuc3BvcnQpCisgICAgICAgIHNlcnZlciA9IHNtYXJ0LlNtYXJ0U2VydmVyU3RyZWFtTWVk
aXVtKHRvX3NlcnZlciwgZnJvbV9zZXJ2ZXIsIHRyYW5zcG9ydCkKICAgICAgICAgc2VydmVyLl9z
ZXJ2ZV9vbmVfcmVxdWVzdCgpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ29rXG4nCiAgICAg
ICAgICAgICAgICAgICAgICAgICAgJzE3XG4nCkBAIC0xMDgsMjIgKzU3OCw2IEBACiAgICAgICAg
IGZpbmFsbHk6CiAgICAgICAgICAgICBzZXJ2ZXIuc3RvcF9iYWNrZ3JvdW5kX3RocmVhZCgpCiAK
LSAgICBkZWYgdGVzdF9zZXJ2ZXJfc3VicHJvY2VzcyhzZWxmKToKLSAgICAgICAgIiIiVGFsayB0
byBhIHNlcnZlciBzdGFydGVkIGFzIGEgc3VicHJvY2VzcwotICAgICAgICAKLSAgICAgICAgVGhp
cyBpcyBzaW1pbGFyIHRvIHJ1bm5pbmcgaXQgb3ZlciBzc2gsIGV4Y2VwdCB0aGF0IGl0IHJ1bnMg
aW4gdGhlIHNhbWUgbWFjaGluZSAKLSAgICAgICAgd2l0aG91dCBzc2ggaW50ZXJtZWRpYXRpbmcu
Ci0gICAgICAgICIiIgotICAgICAgICBhcmdzID0gW3N5cy5leGVjdXRhYmxlLCBzeXMuYXJndlsw
XSwgJ3NlcnZlJywgJy0taW5ldCddCi0gICAgICAgIGNoaWxkID0gc3VicHJvY2Vzcy5Qb3Blbihh
cmdzLCBzdGRpbj1zdWJwcm9jZXNzLlBJUEUsIHN0ZG91dD1zdWJwcm9jZXNzLlBJUEUsCi0gICAg
ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjbG9zZV9mZHM9VHJ1ZSkKLSAgICAgICAgY29u
biA9IHNtYXJ0LlNtYXJ0U3RyZWFtQ2xpZW50KGxhbWJkYTogKGNoaWxkLnN0ZG91dCwgY2hpbGQu
c3RkaW4pKQotICAgICAgICBjb25uLnF1ZXJ5X3ZlcnNpb24oKQotICAgICAgICBjb25uLnF1ZXJ5
X3ZlcnNpb24oKQotICAgICAgICBjb25uLmRpc2Nvbm5lY3QoKQotICAgICAgICByZXR1cm5jb2Rl
ID0gY2hpbGQud2FpdCgpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWxzKDAsIHJldHVybmNvZGUp
Ci0KIAogY2xhc3MgU21hcnRUQ1BUZXN0cyh0ZXN0cy5UZXN0Q2FzZSk6CiAgICAgIiIiVGVzdHMg
Zm9yIGNvbm5lY3Rpb24vZW5kIHRvIGVuZCBiZWhhdmlvdXIgdXNpbmcgdGhlIFRDUCBzZXJ2ZXIu
CkBAIC0xOTUsNyArNjQ5LDcgQEAKICAgICAgICAgIyB3ZSBjcmVhdGUgYSByZWFsIGNvbm5lY3Rp
b24gbm90IGEgbG9vcGJhY2sgb25lLCBidXQgaXQgd2lsbCB1c2UgdGhlCiAgICAgICAgICMgc2Ft
ZSBzZXJ2ZXIgYW5kIHBpcGVzCiAgICAgICAgIGNvbm4yID0gc2VsZi50cmFuc3BvcnQuY2xvbmUo
Jy4nKQotICAgICAgICBzZWxmLmFzc2VydFRydWUoc2VsZi50cmFuc3BvcnQuX2NsaWVudCBpcyBj
b25uMi5fY2xpZW50KQorICAgICAgICBzZWxmLmFzc2VydFRydWUoc2VsZi50cmFuc3BvcnQuX21l
ZGl1bSBpcyBjb25uMi5fbWVkaXVtKQogCiAgICAgZGVmIHRlc3RfX3JlbW90ZV9wYXRoKHNlbGYp
OgogICAgICAgICBzZWxmLmFzc2VydEVxdWFscygnL2Zvby9iYXInLApAQCAtMjQxLDE0ICs2OTUs
MTkgQEAKICAgICAgICAgICAgICdmb28nKQogICAgICAgICAKIAotY2xhc3MgU21hcnRTZXJ2ZXJU
ZXN0cyh0ZXN0cy5UZXN0Q2FzZVdpdGhUcmFuc3BvcnQpOgotICAgICIiIlRlc3QgdGhhdCBjYWxs
IGRpcmVjdGx5IGludG8gdGhlIHNlcnZlciBsb2dpYywgYnlwYXNzaW5nIHRoZSBuZXR3b3JrLiIi
IgorY2xhc3MgU21hcnRTZXJ2ZXJSZXF1ZXN0SGFuZGxlclRlc3RzKHRlc3RzLlRlc3RDYXNlV2l0
aFRyYW5zcG9ydCk6CisgICAgIiIiVGVzdCB0aGF0IGNhbGwgZGlyZWN0bHkgaW50byB0aGUgaGFu
ZGxlciBsb2dpYywgYnlwYXNzaW5nIHRoZSBuZXR3b3JrLiIiIgorCisgICAgZGVmIHRlc3RfY29u
c3RydWN0X3JlcXVlc3RfaGFuZGxlcihzZWxmKToKKyAgICAgICAgIiIiQ29uc3RydWN0aW5nIGEg
cmVxdWVzdCBoYW5kbGVyIHNob3VsZCBiZSBlYXN5IGFuZCBzZXQgZGVmYXVsdHMuIiIiCisgICAg
ICAgIGhhbmRsZXIgPSBzbWFydC5TbWFydFNlcnZlclJlcXVlc3RIYW5kbGVyKE5vbmUpCisgICAg
ICAgIHNlbGYuYXNzZXJ0RmFsc2UoaGFuZGxlci5maW5pc2hlZF9yZWFkaW5nKQogCiAgICAgZGVm
IHRlc3RfaGVsbG8oc2VsZik6Ci0gICAgICAgIHNlcnZlciA9IHNtYXJ0LlNtYXJ0U2VydmVyKE5v
bmUpCi0gICAgICAgIHJlc3BvbnNlID0gc2VydmVyLmRpc3BhdGNoX2NvbW1hbmQoJ2hlbGxvJywg
KCkpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoKCdvaycsICcxJyksIHJlc3BvbnNlLmFyZ3Mp
Ci0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoTm9uZSwgcmVzcG9uc2UuYm9keSkKKyAgICAgICAg
aGFuZGxlciA9IHNtYXJ0LlNtYXJ0U2VydmVyUmVxdWVzdEhhbmRsZXIoTm9uZSkKKyAgICAgICAg
aGFuZGxlci5kaXNwYXRjaF9jb21tYW5kKCdoZWxsbycsICgpKQorICAgICAgICBzZWxmLmFzc2Vy
dEVxdWFsKCgnb2snLCAnMScpLCBoYW5kbGVyLnJlc3BvbnNlLmFyZ3MpCisgICAgICAgIHNlbGYu
YXNzZXJ0RXF1YWwoTm9uZSwgaGFuZGxlci5yZXNwb25zZS5ib2R5KQogICAgICAgICAKICAgICBk
ZWYgdGVzdF9nZXRfYnVuZGxlKHNlbGYpOgogICAgICAgICBmcm9tIGJ6cmxpYi5idW5kbGUgaW1w
b3J0IHNlcmlhbGl6ZXIKQEAgLTI1NywyMiArNzE2LDcxIEBACiAgICAgICAgIHd0LmFkZCgnaGVs
bG8nKQogICAgICAgICByZXZfaWQgPSB3dC5jb21taXQoJ2FkZCBoZWxsbycpCiAgICAgICAgIAot
ICAgICAgICBzZXJ2ZXIgPSBzbWFydC5TbWFydFNlcnZlcihzZWxmLmdldF90cmFuc3BvcnQoKSkK
LSAgICAgICAgcmVzcG9uc2UgPSBzZXJ2ZXIuZGlzcGF0Y2hfY29tbWFuZCgnZ2V0X2J1bmRsZScs
ICgnLicsIHJldl9pZCkpCi0gICAgICAgIGJ1bmRsZSA9IHNlcmlhbGl6ZXIucmVhZF9idW5kbGUo
U3RyaW5nSU8ocmVzcG9uc2UuYm9keSkpCisgICAgICAgIGhhbmRsZXIgPSBzbWFydC5TbWFydFNl
cnZlclJlcXVlc3RIYW5kbGVyKHNlbGYuZ2V0X3RyYW5zcG9ydCgpKQorICAgICAgICBoYW5kbGVy
LmRpc3BhdGNoX2NvbW1hbmQoJ2dldF9idW5kbGUnLCAoJy4nLCByZXZfaWQpKQorICAgICAgICBi
dW5kbGUgPSBzZXJpYWxpemVyLnJlYWRfYnVuZGxlKFN0cmluZ0lPKGhhbmRsZXIucmVzcG9uc2Uu
Ym9keSkpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoKCksIGhhbmRsZXIucmVzcG9uc2UuYXJn
cykKIAogICAgIGRlZiB0ZXN0X3JlYWRvbmx5X2V4Y2VwdGlvbl9iZWNvbWVzX3RyYW5zcG9ydF9u
b3RfcG9zc2libGUoc2VsZik6CiAgICAgICAgICIiIlRoZSByZXNwb25zZSBmb3IgYSByZWFkLW9u
bHkgZXJyb3IgaXMgKCdSZWFkT25seUVycm9yJykuIiIiCi0gICAgICAgIHNlcnZlciA9IHNtYXJ0
LlNtYXJ0U2VydmVyKHNlbGYuZ2V0X3JlYWRvbmx5X3RyYW5zcG9ydCgpKQorICAgICAgICBoYW5k
bGVyID0gc21hcnQuU21hcnRTZXJ2ZXJSZXF1ZXN0SGFuZGxlcihzZWxmLmdldF9yZWFkb25seV90
cmFuc3BvcnQoKSkKICAgICAgICAgIyBzZW5kIGEgbWtkaXIgZm9yIGZvbywgd2l0aCBubyBleHBs
aWNpdCBtb2RlIC0gc2hvdWxkIGZhaWwuCi0gICAgICAgIHJlc3BvbnNlID0gc2VydmVyLmRpc3Bh
dGNoX2NvbW1hbmQoJ21rZGlyJywgKCdmb28nLCAnJykpCisgICAgICAgIGhhbmRsZXIuZGlzcGF0
Y2hfY29tbWFuZCgnbWtkaXInLCAoJ2ZvbycsICcnKSkKICAgICAgICAgIyBhbmQgdGhlIGZhaWx1
cmUgc2hvdWxkIGJlIGFuIGV4cGxpY2l0IFJlYWRPbmx5RXJyb3IKLSAgICAgICAgc2VsZi5hc3Nl
cnRFcXVhbCgoIlJlYWRPbmx5RXJyb3IiLCApLCByZXNwb25zZS5hcmdzKQorICAgICAgICBzZWxm
LmFzc2VydEVxdWFsKCgiUmVhZE9ubHlFcnJvciIsICksIGhhbmRsZXIucmVzcG9uc2UuYXJncykK
ICAgICAgICAgIyBYWFg6IFRPRE86IHRlc3QgdGhhdCBvdGhlciBUcmFuc3BvcnROb3RQb3NzaWJs
ZSBlcnJvcnMgYXJlCiAgICAgICAgICMgcHJlc2VudGVkIGFzIFRyYW5zcG9ydE5vdFBvc3NpYmxl
IC0gbm90IHBvc3NpYmxlIHRvIGRvIHRoYXQKICAgICAgICAgIyB1bnRpbCBJIGZpZ3VyZSBvdXQg
aG93IHRvIHRyaWdnZXIgdGhhdCByZWxhdGl2ZWx5IGNsZWFubHkgdmlhCiAgICAgICAgICMgdGhl
IGFwaS4gUkJDIDIwMDYwOTE4CiAKKyAgICBkZWYgdGVzdF9oZWxsb19oYXNfZmluaXNoZWRfYm9k
eV9vbl9kaXNwYXRjaChzZWxmKToKKyAgICAgICAgIiIiVGhlICdoZWxsbycgY29tbWFuZCBzaG91
bGQgc2V0IGZpbmlzaGVkX3JlYWRpbmcuIiIiCisgICAgICAgIGhhbmRsZXIgPSBzbWFydC5TbWFy
dFNlcnZlclJlcXVlc3RIYW5kbGVyKE5vbmUpCisgICAgICAgIGhhbmRsZXIuZGlzcGF0Y2hfY29t
bWFuZCgnaGVsbG8nLCAoKSkKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKGhhbmRsZXIuZmluaXNo
ZWRfcmVhZGluZykKKyAgICAgICAgc2VsZi5hc3NlcnROb3RFcXVhbChOb25lLCBoYW5kbGVyLnJl
c3BvbnNlKQorCisgICAgZGVmIHRlc3RfcHV0X2J5dGVzX25vbl9hdG9taWMoc2VsZik6CisgICAg
ICAgICIiIidwdXRfLi4uJyBzaG91bGQgc2V0IGZpbmlzaGVkX3JlYWRpbmcgYWZ0ZXIgcmVhZGlu
ZyB0aGUgYnl0ZXMuIiIiCisgICAgICAgIGhhbmRsZXIgPSBzbWFydC5TbWFydFNlcnZlclJlcXVl
c3RIYW5kbGVyKHNlbGYuZ2V0X3RyYW5zcG9ydCgpKQorICAgICAgICBoYW5kbGVyLmRpc3BhdGNo
X2NvbW1hbmQoJ3B1dF9ub25fYXRvbWljJywgKCdhLWZpbGUnLCAnJywgJ0YnLCAnJykpCisgICAg
ICAgIHNlbGYuYXNzZXJ0RmFsc2UoaGFuZGxlci5maW5pc2hlZF9yZWFkaW5nKQorICAgICAgICBo
YW5kbGVyLmFjY2VwdF9ib2R5KCcxMjM0JykKKyAgICAgICAgc2VsZi5hc3NlcnRGYWxzZShoYW5k
bGVyLmZpbmlzaGVkX3JlYWRpbmcpCisgICAgICAgIGhhbmRsZXIuYWNjZXB0X2JvZHkoJzU2Nzgn
KQorICAgICAgICBoYW5kbGVyLmVuZF9vZl9ib2R5KCkKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVl
KGhhbmRsZXIuZmluaXNoZWRfcmVhZGluZykKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgoJ29r
JywgKSwgaGFuZGxlci5yZXNwb25zZS5hcmdzKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKE5v
bmUsIGhhbmRsZXIucmVzcG9uc2UuYm9keSkKKyAgICAgICAgCisgICAgZGVmIHRlc3RfcmVhZHZf
YWNjZXB0X2JvZHkoc2VsZik6CisgICAgICAgICIiIidyZWFkdicgc2hvdWxkIHNldCBmaW5pc2hl
ZF9yZWFkaW5nIGFmdGVyIHJlYWRpbmcgb2Zmc2V0cy4iIiIKKyAgICAgICAgc2VsZi5idWlsZF90
cmVlKFsnYS1maWxlJ10pCisgICAgICAgIGhhbmRsZXIgPSBzbWFydC5TbWFydFNlcnZlclJlcXVl
c3RIYW5kbGVyKHNlbGYuZ2V0X3JlYWRvbmx5X3RyYW5zcG9ydCgpKQorICAgICAgICBoYW5kbGVy
LmRpc3BhdGNoX2NvbW1hbmQoJ3JlYWR2JywgKCdhLWZpbGUnLCApKQorICAgICAgICBzZWxmLmFz
c2VydEZhbHNlKGhhbmRsZXIuZmluaXNoZWRfcmVhZGluZykKKyAgICAgICAgaGFuZGxlci5hY2Nl
cHRfYm9keSgnMiwnKQorICAgICAgICBzZWxmLmFzc2VydEZhbHNlKGhhbmRsZXIuZmluaXNoZWRf
cmVhZGluZykKKyAgICAgICAgaGFuZGxlci5hY2NlcHRfYm9keSgnMycpCisgICAgICAgIGhhbmRs
ZXIuZW5kX29mX2JvZHkoKQorICAgICAgICBzZWxmLmFzc2VydFRydWUoaGFuZGxlci5maW5pc2hl
ZF9yZWFkaW5nKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCgncmVhZHYnLCApLCBoYW5kbGVy
LnJlc3BvbnNlLmFyZ3MpCisgICAgICAgICMgY28gLSBudGUgLSBudCBvZiBhLWZpbGUgaXMgdGhl
IGZpbGUgY29udGVudHMgd2UgYXJlIGV4dHJhY3RpbmcgZnJvbS4KKyAgICAgICAgc2VsZi5hc3Nl
cnRFcXVhbCgnbnRlJywgaGFuZGxlci5yZXNwb25zZS5ib2R5KQorCisgICAgZGVmIHRlc3RfcmVh
ZHZfc2hvcnRfcmVhZF9yZXNwb25zZV9jb250ZW50cyhzZWxmKToKKyAgICAgICAgIiIiJ3JlYWR2
JyB3aGVuIGEgc2hvcnQgcmVhZCBvY2N1cnMgc2V0cyB0aGUgcmVzcG9uc2UgYXBwcm9wcmlhdGVs
eS4iIiIKKyAgICAgICAgc2VsZi5idWlsZF90cmVlKFsnYS1maWxlJ10pCisgICAgICAgIGhhbmRs
ZXIgPSBzbWFydC5TbWFydFNlcnZlclJlcXVlc3RIYW5kbGVyKHNlbGYuZ2V0X3JlYWRvbmx5X3Ry
YW5zcG9ydCgpKQorICAgICAgICBoYW5kbGVyLmRpc3BhdGNoX2NvbW1hbmQoJ3JlYWR2JywgKCdh
LWZpbGUnLCApKQorICAgICAgICAjIHJlYWQgYmV5b25kIHRoZSBlbmQgb2YgdGhlIGZpbGUuCisg
ICAgICAgIGhhbmRsZXIuYWNjZXB0X2JvZHkoJzEwMCwxJykKKyAgICAgICAgaGFuZGxlci5lbmRf
b2ZfYm9keSgpCisgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShoYW5kbGVyLmZpbmlzaGVkX3JlYWRp
bmcpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoKCdTaG9ydFJlYWR2RXJyb3InLCAnYS1maWxl
JywgJzEwMCcsICcxJywgJzAnKSwKKyAgICAgICAgICAgIGhhbmRsZXIucmVzcG9uc2UuYXJncykK
KyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChOb25lLCBoYW5kbGVyLnJlc3BvbnNlLmJvZHkpCisK
IAogY2xhc3MgU21hcnRUcmFuc3BvcnRSZWdpc3RyYXRpb24odGVzdHMuVGVzdENhc2UpOgogCkBA
IC0yODIsNjQgKzc5MCw0MiBAQAogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCdleGFtcGxlLmNv
bScsIHQuX2hvc3QpCiAKIAotY2xhc3MgRmFrZUNsaWVudChzbWFydC5TbWFydFN0cmVhbUNsaWVu
dCk6Ci0gICAgIiIiRW11bGF0ZSBhIGNsaWVudCBmb3IgdGVzdGluZyBhIHRyYW5zcG9ydCdzIHVz
ZSBvZiB0aGUgY2xpZW50LiIiIgotCi0gICAgZGVmIF9faW5pdF9fKHNlbGYpOgotICAgICAgICBz
bWFydC5TbWFydFN0cmVhbUNsaWVudC5fX2luaXRfXyhzZWxmLCBOb25lKQotICAgICAgICBzZWxm
Ll9jYWxscyA9IFtdCi0KLSAgICBkZWYgX2NhbGwoc2VsZiwgKmFyZ3MpOgotICAgICAgICBzZWxm
Ll9jYWxscy5hcHBlbmQoKCdfY2FsbCcsIGFyZ3MpKQotICAgICAgICByZXR1cm4gKCdvaycsICkK
LQotICAgIGRlZiBfcmVjdl9idWxrKHNlbGYpOgotICAgICAgICByZXR1cm4gJ2JhcicKLQotCiBj
bGFzcyBUZXN0U21hcnRUcmFuc3BvcnQodGVzdHMuVGVzdENhc2UpOgogICAgICAgICAKICAgICBk
ZWYgdGVzdF91c2VfY29ubmVjdGlvbl9mYWN0b3J5KHNlbGYpOgogICAgICAgICAjIFdlIHdhbnQg
dG8gYmUgYWJsZSB0byBwYXNzIGEgY2xpZW50IGFzIGEgcGFyYW1ldGVyIHRvIFNtYXJ0VHJhbnNw
b3J0LgotICAgICAgICBjbGllbnQgPSBGYWtlQ2xpZW50KCkKLSAgICAgICAgdHJhbnNwb3J0ID0g
c21hcnQuU21hcnRUcmFuc3BvcnQoJ2J6cjovL2xvY2FsaG9zdC8nLCBjbGllbnQ9Y2xpZW50KQor
ICAgICAgICBpbnB1dCA9IFN0cmluZ0lPKCJva1xuM1xuYmFyZG9uZVxuIikKKyAgICAgICAgb3V0
cHV0ID0gU3RyaW5nSU8oKQorICAgICAgICBtZWRpdW0gPSBzbWFydC5TbWFydFNpbXBsZVBpcGVz
Q2xpZW50TWVkaXVtKGlucHV0LCBvdXRwdXQpCisgICAgICAgIHRyYW5zcG9ydCA9IHNtYXJ0LlNt
YXJ0VHJhbnNwb3J0KCdienI6Ly9sb2NhbGhvc3QvJywgbWVkaXVtPW1lZGl1bSkKIAogICAgICAg
ICAjIFdlIHdhbnQgdG8gbWFrZSBzdXJlIHRoZSBjbGllbnQgaXMgdXNlZCB3aGVuIHRoZSBmaXJz
dCByZW1vdGUKLSAgICAgICAgIyBtZXRob2QgaXMgY2FsbGVkLiAgTm8gbWV0aG9kIHNob3VsZCBo
YXZlIGJlZW4gY2FsbGVkIHlldC4KLSAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChbXSwgY2xpZW50
Ll9jYWxscykKKyAgICAgICAgIyBtZXRob2QgaXMgY2FsbGVkLiAgTm8gZGF0YSBzaG91bGQgaGF2
ZSBiZWVuIHNlbnQsIG9yIHJlYWQuCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoMCwgaW5wdXQu
dGVsbCgpKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCcnLCBvdXRwdXQuZ2V0dmFsdWUoKSkK
IAotICAgICAgICAjIE5vdyBjYWxsIGEgbWV0aG9kIHRoYXQgc2hvdWxkIHJlc3VsdCBpbiBhIHNp
bmdsZSByZXF1ZXN0LgorICAgICAgICAjIE5vdyBjYWxsIGEgbWV0aG9kIHRoYXQgc2hvdWxkIHJl
c3VsdCBpbiBhIHNpbmdsZSByZXF1ZXN0IDogYXMgdGhlCisgICAgICAgICMgdHJhbnNwb3J0IG1h
a2VzIGl0cyBvd24gcHJvdG9jb2wgaW5zdGFuY2VzLCB3ZSBjaGVjayBvbiB0aGUgd2lyZS4KKyAg
ICAgICAgIyBYWFg6IFRPRE86IGdpdmUgdGhlIHRyYW5zcG9ydCBhIHByb3RvY29sIGZhY3Rvcnks
IHdoaWNoIGNhbiBtYWtlCisgICAgICAgICMgYW4gaW5zdHJ1bWVudGVkIHByb3RvY29sIGZvciB1
cy4KICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnYmFyJywgdHJhbnNwb3J0LmdldF9ieXRlcygn
Zm9vJykpCi0gICAgICAgICMgVGhlIG9ubHkgY2FsbCB0byBfY2FsbCBzaG91bGQgaGF2ZSBiZWVu
IHRvIGdldCAvZm9vLgotICAgICAgICBzZWxmLmFzc2VydEVxdWFsKFsoJ19jYWxsJywgKCdnZXQn
LCAnL2ZvbycpKV0sIGNsaWVudC5fY2FsbHMpCisgICAgICAgICMgb25seSB0aGUgbmVlZGVkIGRh
dGEgc2hvdWxkIGhhdmUgYmVlbiBzZW50L3JlY2VpdmVkLgorICAgICAgICBzZWxmLmFzc2VydEVx
dWFsKDEzLCBpbnB1dC50ZWxsKCkpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ2dldFx4MDEv
Zm9vXG4nLCBvdXRwdXQuZ2V0dmFsdWUoKSkKIAogICAgIGRlZiB0ZXN0X190cmFuc2xhdGVfZXJy
b3JfcmVhZG9ubHkoc2VsZik6CiAgICAgICAgICIiIlNlbmRpbmcgYSBSZWFkT25seUVycm9yIHRv
IF90cmFuc2xhdGVfZXJyb3IgcmFpc2VzIFRyYW5zcG9ydE5vdFBvc3NpYmxlLiIiIgotICAgICAg
ICBjbGllbnQgPSBGYWtlQ2xpZW50KCkKLSAgICAgICAgdHJhbnNwb3J0ID0gc21hcnQuU21hcnRU
cmFuc3BvcnQoJ2J6cjovL2xvY2FsaG9zdC8nLCBjbGllbnQ9Y2xpZW50KQorICAgICAgICBtZWRp
dW0gPSBzbWFydC5TbWFydENsaWVudE1lZGl1bSgpCisgICAgICAgIHRyYW5zcG9ydCA9IHNtYXJ0
LlNtYXJ0VHJhbnNwb3J0KCdienI6Ly9sb2NhbGhvc3QvJywgbWVkaXVtPW1lZGl1bSkKICAgICAg
ICAgc2VsZi5hc3NlcnRSYWlzZXMoZXJyb3JzLlRyYW5zcG9ydE5vdFBvc3NpYmxlLAogICAgICAg
ICAgICAgdHJhbnNwb3J0Ll90cmFuc2xhdGVfZXJyb3IsICgiUmVhZE9ubHlFcnJvciIsICkpCiAK
IAotY2xhc3MgSW5zdHJ1bWVudGVkQ2xpZW50KHNtYXJ0LlNtYXJ0U3RyZWFtQ2xpZW50KToKLSAg
ICAiIiJBIHNtYXJ0IGNsaWVudCB3aG9zZSB3cml0ZXMgYXJlIHN0b3JlZCB0byBhIHN1cHBsaWVk
IGxpc3QuIiIiCi0KLSAgICBkZWYgX19pbml0X18oc2VsZiwgd3JpdGVfb3V0cHV0X2xpc3QpOgot
ICAgICAgICBzbWFydC5TbWFydFN0cmVhbUNsaWVudC5fX2luaXRfXyhzZWxmLCBOb25lKQotICAg
ICAgICBzZWxmLl93cml0ZV9vdXRwdXRfbGlzdCA9IHdyaXRlX291dHB1dF9saXN0Ci0KLSAgICBk
ZWYgX2Vuc3VyZV9jb25uZWN0aW9uKHNlbGYpOgotICAgICAgICAiIiJXZSBhcmUgbmV2ZXIgc3Ry
aWN0bHkgY29ubmVjdGVkLiIiIgotCi0gICAgZGVmIF93cml0ZV9hbmRfZmx1c2goc2VsZiwgYnl0
ZXMpOgotICAgICAgICBzZWxmLl93cml0ZV9vdXRwdXRfbGlzdC5hcHBlbmQoYnl0ZXMpCi0KLQot
Y2xhc3MgSW5zdHJ1bWVudGVkU2VydmVyUHJvdG9jb2woc21hcnQuU21hcnRTdHJlYW1TZXJ2ZXIp
OgorY2xhc3MgSW5zdHJ1bWVudGVkU2VydmVyUHJvdG9jb2woc21hcnQuU21hcnRTZXJ2ZXJTdHJl
YW1NZWRpdW0pOgogICAgICIiIkEgc21hcnQgc2VydmVyIHdoaWNoIGlzIGJhY2tlZCBieSBtZW1v
cnkgYW5kIHNhdmVzIGl0cyB3cml0ZSByZXF1ZXN0cy4iIiIKIAogICAgIGRlZiBfX2luaXRfXyhz
ZWxmLCB3cml0ZV9vdXRwdXRfbGlzdCk6Ci0gICAgICAgIHNtYXJ0LlNtYXJ0U3RyZWFtU2VydmVy
Ll9faW5pdF9fKHNlbGYsIE5vbmUsIE5vbmUsCisgICAgICAgIHNtYXJ0LlNtYXJ0U2VydmVyU3Ry
ZWFtTWVkaXVtLl9faW5pdF9fKHNlbGYsIE5vbmUsIE5vbmUsCiAgICAgICAgICAgICBtZW1vcnku
TWVtb3J5VHJhbnNwb3J0KCkpCiAgICAgICAgIHNlbGYuX3dyaXRlX291dHB1dF9saXN0ID0gd3Jp
dGVfb3V0cHV0X2xpc3QKIApAQCAtMzYyLDEzICs4NDgsMTggQEAKIAogICAgIGRlZiBzZXRVcChz
ZWxmKToKICAgICAgICAgc3VwZXIoVGVzdFNtYXJ0UHJvdG9jb2wsIHNlbGYpLnNldFVwKCkKLSAg
ICAgICAgc2VsZi50b19zZXJ2ZXIgPSBbXQotICAgICAgICBzZWxmLnRvX2NsaWVudCA9IFtdCi0g
ICAgICAgIHNlbGYuc21hcnRfY2xpZW50ID0gSW5zdHJ1bWVudGVkQ2xpZW50KHNlbGYudG9fc2Vy
dmVyKQotICAgICAgICBzZWxmLnNtYXJ0X3NlcnZlciA9IEluc3RydW1lbnRlZFNlcnZlclByb3Rv
Y29sKHNlbGYudG9fY2xpZW50KQorICAgICAgICBzZWxmLnNlcnZlcl90b19jbGllbnQgPSBbXQor
ICAgICAgICBzZWxmLnRvX3NlcnZlciA9IFN0cmluZ0lPKCkKKyAgICAgICAgc2VsZi50b19jbGll
bnQgPSBTdHJpbmdJTygpCisgICAgICAgIHNlbGYuY2xpZW50X21lZGl1bSA9IHNtYXJ0LlNtYXJ0
U2ltcGxlUGlwZXNDbGllbnRNZWRpdW0oc2VsZi50b19jbGllbnQsCisgICAgICAgICAgICBzZWxm
LnRvX3NlcnZlcikKKyAgICAgICAgc2VsZi5jbGllbnRfcHJvdG9jb2wgPSBzbWFydC5TbWFydENs
aWVudFJlcXVlc3RQcm90b2NvbE9uZSgKKyAgICAgICAgICAgIHNlbGYuY2xpZW50X21lZGl1bSkK
KyAgICAgICAgc2VsZi5zbWFydF9zZXJ2ZXIgPSBJbnN0cnVtZW50ZWRTZXJ2ZXJQcm90b2NvbChz
ZWxmLnNlcnZlcl90b19jbGllbnQpCisgICAgICAgIHNlbGYuc21hcnRfc2VydmVyX3JlcXVlc3Qg
PSBzbWFydC5TbWFydFNlcnZlclJlcXVlc3RIYW5kbGVyKE5vbmUpCiAKICAgICBkZWYgYXNzZXJ0
T2Zmc2V0U2VyaWFsaXNhdGlvbihzZWxmLCBleHBlY3RlZF9vZmZzZXRzLCBleHBlY3RlZF9zZXJp
YWxpc2VkLAotICAgICAgICBjbGllbnQsIHNlcnZlcl9wcm90b2NvbCk6CisgICAgICAgIGNsaWVu
dCwgc21hcnRfc2VydmVyX3JlcXVlc3QpOgogICAgICAgICAiIiJDaGVjayB0aGF0IHNtYXJ0IChk
ZSlzZXJpYWxpc2VzIG9mZnNldHMgYXMgZXhwZWN0ZWQuCiAgICAgICAgIAogICAgICAgICBXZSBj
aGVjayBib3RoIHNlcmlhbGlzYXRpb24gYW5kIGRlc2VyaWFsaXNhdGlvbiBhdCB0aGUgc2FtZSB0
aW1lCkBAIC0zNzcsMTQgKzg2OCw0MyBAQAogICAgICAgICAKICAgICAgICAgOnBhcmFtIGV4cGVj
dGVkX29mZnNldHM6IGEgcmVhZHYgb2Zmc2V0IGxpc3QuCiAgICAgICAgIDpwYXJhbSBleHBlY3Rl
ZF9zZXJhbGlzZWQ6IGFuIGV4cGVjdGVkIHNlcmlhbCBmb3JtIG9mIHRoZSBvZmZzZXRzLgotICAg
ICAgICA6cGFyYW0gc2VydmVyOiBhIFNtYXJ0U2VydmVyIGluc3RhbmNlLgorICAgICAgICA6cGFy
YW0gc21hcnRfc2VydmVyX3JlcXVlc3Q6IGEgU21hcnRTZXJ2ZXJSZXF1ZXN0SGFuZGxlciBpbnN0
YW5jZS4KICAgICAgICAgIiIiCi0gICAgICAgIG9mZnNldHMgPSBzZXJ2ZXJfcHJvdG9jb2wuc21h
cnRfc2VydmVyLl9kZXNlcmlhbGlzZV9vZmZzZXRzKAotICAgICAgICAgICAgZXhwZWN0ZWRfc2Vy
aWFsaXNlZCkKKyAgICAgICAgIyBYWFg6ICdzbWFydF9zZXJ2ZXJfcmVxdWVzdCcgc2hvdWxkIGJl
IGEgU21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2wgaW4KKyAgICAgICAgIyBmdXR1cmUuCisgICAg
ICAgIG9mZnNldHMgPSBzbWFydF9zZXJ2ZXJfcmVxdWVzdC5fZGVzZXJpYWxpc2Vfb2Zmc2V0cyhl
eHBlY3RlZF9zZXJpYWxpc2VkKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX29m
ZnNldHMsIG9mZnNldHMpCiAgICAgICAgIHNlcmlhbGlzZWQgPSBjbGllbnQuX3NlcmlhbGlzZV9v
ZmZzZXRzKG9mZnNldHMpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoZXhwZWN0ZWRfc2VyaWFs
aXNlZCwgc2VyaWFsaXNlZCkKIAorICAgIGRlZiBidWlsZF9wcm90b2NvbF93YWl0aW5nX2Zvcl9i
b2R5KHNlbGYpOgorICAgICAgICBvdXRfc3RyZWFtID0gU3RyaW5nSU8oKQorICAgICAgICBwcm90
b2NvbCA9IHNtYXJ0LlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29sT25lKG91dF9zdHJlYW0sIE5v
bmUpCisgICAgICAgIHByb3RvY29sLmhhc19kaXNwYXRjaGVkID0gVHJ1ZQorICAgICAgICBwcm90
b2NvbC5yZXF1ZXN0ID0gc21hcnQuU21hcnRTZXJ2ZXJSZXF1ZXN0SGFuZGxlcihOb25lKQorICAg
ICAgICBkZWYgaGFuZGxlX2VuZF9vZl9ieXRlcygpOgorICAgICAgICAgICAgc2VsZi5lbmRfcmVj
ZWl2ZWQgPSBUcnVlCisgICAgICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCdhYmNkZWZnJywgcHJv
dG9jb2wucmVxdWVzdC5fYm9keV9ieXRlcykKKyAgICAgICAgICAgIHByb3RvY29sLnJlcXVlc3Qu
cmVzcG9uc2UgPSBzbWFydC5TbWFydFNlcnZlclJlc3BvbnNlKCgnb2snLCApKQorICAgICAgICBw
cm90b2NvbC5yZXF1ZXN0Ll9lbmRfb2ZfYm9keV9oYW5kbGVyID0gaGFuZGxlX2VuZF9vZl9ieXRl
cworICAgICAgICByZXR1cm4gcHJvdG9jb2wKKworICAgIGRlZiB0ZXN0X2NvbnN0cnVjdF92ZXJz
aW9uX29uZV9zZXJ2ZXJfcHJvdG9jb2woc2VsZik6CisgICAgICAgIHByb3RvY29sID0gc21hcnQu
U21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xPbmUoTm9uZSwgTm9uZSkKKyAgICAgICAgc2VsZi5h
c3NlcnRFcXVhbCgnJywgcHJvdG9jb2wuZXhjZXNzX2J1ZmZlcikKKyAgICAgICAgc2VsZi5hc3Nl
cnRFcXVhbCgnJywgcHJvdG9jb2wuaW5fYnVmZmVyKQorICAgICAgICBzZWxmLmFzc2VydEZhbHNl
KHByb3RvY29sLmhhc19kaXNwYXRjaGVkKQorICAgICAgICAjIE9uY2UgcmVmYWN0b3JpbmcgaXMg
Y29tcGxldGUsIHdlIGRvbid0IG5lZWQgdGhlc2UgYXNzZXJ0aW9ucworICAgICAgICBzZWxmLmFz
c2VydEZhbHNlKGhhc2F0dHIocHJvdG9jb2wsICdfaW4nKSkKKyAgICAgICAgc2VsZi5hc3NlcnRG
YWxzZShoYXNhdHRyKHByb3RvY29sLCAnX291dCcpKQorCisgICAgZGVmIHRlc3RfY29uc3RydWN0
X3ZlcnNpb25fb25lX2NsaWVudF9wcm90b2NvbChzZWxmKToKKyAgICAgICAgIyB3ZSBjYW4gY29u
c3RydWN0IGEgY2xpZW50IHByb3RvY29sIGZyb20gYSBjbGllbnQgbWVkaXVtIHJlcXVlc3QKKyAg
ICAgICAgb3V0cHV0ID0gU3RyaW5nSU8oKQorICAgICAgICBtZWRpdW0gPSBzbWFydC5TbWFydFNp
bXBsZVBpcGVzQ2xpZW50TWVkaXVtKE5vbmUsIG91dHB1dCkKKyAgICAgICAgcmVxdWVzdCA9IG1l
ZGl1bS5nZXRfcmVxdWVzdCgpCisgICAgICAgIGNsaWVudF9wcm90b2NvbCA9IHNtYXJ0LlNtYXJ0
Q2xpZW50UmVxdWVzdFByb3RvY29sT25lKHJlcXVlc3QpCisKICAgICBkZWYgdGVzdF9zZXJ2ZXJf
b2Zmc2V0X3NlcmlhbGlzYXRpb24oc2VsZik6CiAgICAgICAgICIiIlRoZSBTbWFydCBwcm90b2Nv
bCBzZXJpYWxpc2VzIG9mZnNldHMgYXMgYSBjb21tYSBhbmQgXG4gc3RyaW5nLgogCkBAIC0zOTMs
MTUgKzkxMywzNzUgQEAKICAgICAgICAgb25lIHRoYXQgc2hvdWxkIGNvYWxlc2NlLgogICAgICAg
ICAiIiIKICAgICAgICAgc2VsZi5hc3NlcnRPZmZzZXRTZXJpYWxpc2F0aW9uKFtdLCAnJywKLSAg
ICAgICAgICAgIHNlbGYuc21hcnRfY2xpZW50LCBzZWxmLnNtYXJ0X3NlcnZlcikKKyAgICAgICAg
ICAgIHNlbGYuY2xpZW50X3Byb3RvY29sLCBzZWxmLnNtYXJ0X3NlcnZlcl9yZXF1ZXN0KQogICAg
ICAgICBzZWxmLmFzc2VydE9mZnNldFNlcmlhbGlzYXRpb24oWygxLDIpXSwgJzEsMicsCi0gICAg
ICAgICAgICBzZWxmLnNtYXJ0X2NsaWVudCwgc2VsZi5zbWFydF9zZXJ2ZXIpCisgICAgICAgICAg
ICBzZWxmLmNsaWVudF9wcm90b2NvbCwgc2VsZi5zbWFydF9zZXJ2ZXJfcmVxdWVzdCkKICAgICAg
ICAgc2VsZi5hc3NlcnRPZmZzZXRTZXJpYWxpc2F0aW9uKFsoMTAsNDApLCAoMCw1KV0sICcxMCw0
MFxuMCw1JywKLSAgICAgICAgICAgIHNlbGYuc21hcnRfY2xpZW50LCBzZWxmLnNtYXJ0X3NlcnZl
cikKKyAgICAgICAgICAgIHNlbGYuY2xpZW50X3Byb3RvY29sLCBzZWxmLnNtYXJ0X3NlcnZlcl9y
ZXF1ZXN0KQogICAgICAgICBzZWxmLmFzc2VydE9mZnNldFNlcmlhbGlzYXRpb24oWygxLDIpLCAo
Myw0KSwgKDEwMCwgMjAwKV0sCi0gICAgICAgICAgICAnMSwyXG4zLDRcbjEwMCwyMDAnLCBzZWxm
LnNtYXJ0X2NsaWVudCwgc2VsZi5zbWFydF9zZXJ2ZXIpCi0KLQorICAgICAgICAgICAgJzEsMlxu
Myw0XG4xMDAsMjAwJywgc2VsZi5jbGllbnRfcHJvdG9jb2wsIHNlbGYuc21hcnRfc2VydmVyX3Jl
cXVlc3QpCisKKyAgICBkZWYgdGVzdF9hY2NlcHRfYnl0ZXNfdG9fcHJvdG9jb2woc2VsZik6Cisg
ICAgICAgIG91dF9zdHJlYW0gPSBTdHJpbmdJTygpCisgICAgICAgIHByb3RvY29sID0gc21hcnQu
U21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xPbmUob3V0X3N0cmVhbSwgTm9uZSkKKyAgICAgICAg
cHJvdG9jb2wuYWNjZXB0X2J5dGVzKCdhYmMnKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCdh
YmMnLCBwcm90b2NvbC5pbl9idWZmZXIpCisgICAgICAgIHByb3RvY29sLmFjY2VwdF9ieXRlcygn
XG4nKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCJlcnJvclx4MDFHZW5lcmljIGJ6ciBzbWFy
dCBwcm90b2NvbCBlcnJvcjogYmFkIHJlcXVlc3QiCisgICAgICAgICAgICAiIHUnYWJjJ1xuIiwg
b3V0X3N0cmVhbS5nZXR2YWx1ZSgpKQorICAgICAgICBzZWxmLmFzc2VydFRydWUocHJvdG9jb2wu
aGFzX2Rpc3BhdGNoZWQpCisKKyAgICBkZWYgdGVzdF9hY2NlcHRfYm9keV9ieXRlc190b19wcm90
b2NvbChzZWxmKToKKyAgICAgICAgcHJvdG9jb2wgPSBzZWxmLmJ1aWxkX3Byb3RvY29sX3dhaXRp
bmdfZm9yX2JvZHkoKQorICAgICAgICBwcm90b2NvbC5hY2NlcHRfYnl0ZXMoJzdcbmFiYycpCisg
ICAgICAgIHByb3RvY29sLmFjY2VwdF9ieXRlcygnZGVmZ2QnKQorICAgICAgICBwcm90b2NvbC5h
Y2NlcHRfYnl0ZXMoJ29uZVxuJykKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHNlbGYuZW5kX3Jl
Y2VpdmVkKQorCisgICAgZGVmIHRlc3RfYWNjZXB0X2V4Y2Vzc19ieXRlc19hcmVfcHJlc2VydmVk
KHNlbGYpOgorICAgICAgICBvdXRfc3RyZWFtID0gU3RyaW5nSU8oKQorICAgICAgICBwcm90b2Nv
bCA9IHNtYXJ0LlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29sT25lKG91dF9zdHJlYW0sIE5vbmUp
CisgICAgICAgIHByb3RvY29sLmFjY2VwdF9ieXRlcygnaGVsbG9cbmhlbGxvXG4nKQorICAgICAg
ICBzZWxmLmFzc2VydEVxdWFsKCJva1x4MDExXG4iLCBvdXRfc3RyZWFtLmdldHZhbHVlKCkpCisg
ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoImhlbGxvXG4iLCBwcm90b2NvbC5leGNlc3NfYnVmZmVy
KQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCIiLCBwcm90b2NvbC5pbl9idWZmZXIpCisKKyAg
ICBkZWYgdGVzdF9hY2NlcHRfZXhjZXNzX2J5dGVzX2FmdGVyX2JvZHkoc2VsZik6CisgICAgICAg
IHByb3RvY29sID0gc2VsZi5idWlsZF9wcm90b2NvbF93YWl0aW5nX2Zvcl9ib2R5KCkKKyAgICAg
ICAgcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCc3XG5hYmNkZWZnZG9uZVxuWCcpCisgICAgICAgIHNl
bGYuYXNzZXJ0VHJ1ZShzZWxmLmVuZF9yZWNlaXZlZCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVh
bCgiWCIsIHByb3RvY29sLmV4Y2Vzc19idWZmZXIpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwo
IiIsIHByb3RvY29sLmluX2J1ZmZlcikKKyAgICAgICAgcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCdZ
JykKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgiWFkiLCBwcm90b2NvbC5leGNlc3NfYnVmZmVy
KQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCIiLCBwcm90b2NvbC5pbl9idWZmZXIpCisKKyAg
ICBkZWYgdGVzdF9hY2NlcHRfZXhjZXNzX2J5dGVzX2FmdGVyX2Rpc3BhdGNoKHNlbGYpOgorICAg
ICAgICBvdXRfc3RyZWFtID0gU3RyaW5nSU8oKQorICAgICAgICBwcm90b2NvbCA9IHNtYXJ0LlNt
YXJ0U2VydmVyUmVxdWVzdFByb3RvY29sT25lKG91dF9zdHJlYW0sIE5vbmUpCisgICAgICAgIHBy
b3RvY29sLmFjY2VwdF9ieXRlcygnaGVsbG9cbicpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwo
Im9rXHgwMTFcbiIsIG91dF9zdHJlYW0uZ2V0dmFsdWUoKSkKKyAgICAgICAgcHJvdG9jb2wuYWNj
ZXB0X2J5dGVzKCdoZWwnKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCJoZWwiLCBwcm90b2Nv
bC5leGNlc3NfYnVmZmVyKQorICAgICAgICBwcm90b2NvbC5hY2NlcHRfYnl0ZXMoJ2xvXG4nKQor
ICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCJoZWxsb1xuIiwgcHJvdG9jb2wuZXhjZXNzX2J1ZmZl
cikKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgiIiwgcHJvdG9jb2wuaW5fYnVmZmVyKQorCisg
ICAgZGVmIHRlc3Rfc3luY193aXRoX3JlcXVlc3Rfc2V0c19maW5pc2hlZF9yZWFkaW5nKHNlbGYp
OgorICAgICAgICBwcm90b2NvbCA9IHNtYXJ0LlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29sT25l
KE5vbmUsIE5vbmUpCisgICAgICAgIHJlcXVlc3QgPSBzbWFydC5TbWFydFNlcnZlclJlcXVlc3RI
YW5kbGVyKE5vbmUpCisgICAgICAgIHByb3RvY29sLnN5bmNfd2l0aF9yZXF1ZXN0KHJlcXVlc3Qp
CisgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2UocHJvdG9jb2wuZmluaXNoZWRfcmVhZGluZykKKyAg
ICAgICAgcmVxdWVzdC5maW5pc2hlZF9yZWFkaW5nID0gVHJ1ZQorICAgICAgICBwcm90b2NvbC5z
eW5jX3dpdGhfcmVxdWVzdChyZXF1ZXN0KQorICAgICAgICBzZWxmLmFzc2VydFRydWUocHJvdG9j
b2wuZmluaXNoZWRfcmVhZGluZykKKworICAgIGRlZiB0ZXN0X3F1ZXJ5X3ZlcnNpb24oc2VsZik6
CisgICAgICAgICIiInF1ZXJ5X3ZlcnNpb24gb24gYSBTbWFydENsaWVudFByb3RvY29sT25lIHNo
b3VsZCByZXR1cm4gYSBudW1iZXIuCisgICAgICAgIAorICAgICAgICBUaGUgcHJvdG9jb2wgcHJv
dmlkZXMgdGhlIHF1ZXJ5X3ZlcnNpb24gYmVjYXVzZSB0aGUgZG9tYWluIGxldmVsIGNsaWVudHMK
KyAgICAgICAgbWF5IGFsbCBuZWVkIHRvIGJlIGFibGUgdG8gcHJvYmUgZm9yIGNhcGFiaWxpdGll
cy4KKyAgICAgICAgIiIiCisgICAgICAgICMgV2hhdCB3ZSByZWFsbHkgd2FudCB0byB0ZXN0IGhl
cmUgaXMgdGhhdCBTbWFydENsaWVudFByb3RvY29sT25lIGNhbGxzCisgICAgICAgICMgYWNjZXB0
X2J5dGVzKHR1cGxlX2Jhc2VkX2VuY29kaW5nX29mX2hlbGxvKSBhbmQgcmVhZHMgYW5kIHBhcnNl
cyB0aGUKKyAgICAgICAgIyByZXNwb25zZSBvZiB0dXBsZS1lbmNvZGVkIChvaywgMSkuICBBbHNv
LCBzZXBlcmF0ZWx5IHdlIHNob3VsZCB0ZXN0CisgICAgICAgICMgdGhlIGVycm9yIGlmIHRoZSBy
ZXNwb25zZSBpcyBhIG5vbi11bmRlcnN0b29kIHZlcnNpb24uCisgICAgICAgIGlucHV0ID0gU3Ry
aW5nSU8oJ29rXHgwMTFcbicpCisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAgICAg
bWVkaXVtID0gc21hcnQuU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShpbnB1dCwgb3V0cHV0
KQorICAgICAgICBwcm90b2NvbCA9IHNtYXJ0LlNtYXJ0Q2xpZW50UmVxdWVzdFByb3RvY29sT25l
KG1lZGl1bS5nZXRfcmVxdWVzdCgpKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKDEsIHByb3Rv
Y29sLnF1ZXJ5X3ZlcnNpb24oKSkKKworICAgIGRlZiBhc3NlcnRTZXJ2ZXJUb0NsaWVudEVuY29k
aW5nKHNlbGYsIGV4cGVjdGVkX2J5dGVzLCBleHBlY3RlZF90dXBsZSwKKyAgICAgICAgICAgIGlu
cHV0X3R1cGxlcyk6CisgICAgICAgICIiIkFzc2VydCB0aGF0IGVhY2ggaW5wdXRfdHVwbGUgc2Vy
aWFsaXNlcyBhcyBleHBlY3RlZF9ieXRlcywgYW5kIHRoZQorICAgICAgICBieXRlcyBkZXNlcmlh
bGlzZSBhcyBleHBlY3RlZF90dXBsZS4KKyAgICAgICAgIiIiCisgICAgICAgICMgY2hlY2sgdGhl
IGVuY29kaW5nIG9mIHRoZSBzZXJ2ZXIgZm9yIGFsbCBpbnB1dF90dXBsZXMgbWF0Y2hlcworICAg
ICAgICAjIGV4cGVjdGVkIGJ5dGVzCisgICAgICAgIGZvciBpbnB1dF90dXBsZSBpbiBpbnB1dF90
dXBsZXM6CisgICAgICAgICAgICBzZXJ2ZXJfb3V0cHV0ID0gU3RyaW5nSU8oKQorICAgICAgICAg
ICAgc2VydmVyX3Byb3RvY29sID0gc21hcnQuU21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xPbmUo
c2VydmVyX291dHB1dCwKKyAgICAgICAgICAgICAgICBOb25lKQorICAgICAgICAgICAgc2VydmVy
X3Byb3RvY29sLl9zZW5kX3Jlc3BvbnNlKGlucHV0X3R1cGxlKQorICAgICAgICAgICAgc2VsZi5h
c3NlcnRFcXVhbChleHBlY3RlZF9ieXRlcywgc2VydmVyX291dHB1dC5nZXR2YWx1ZSgpKQorICAg
ICAgICAjIGNoZWNrIHRoZSBkZWNvZGluZyBvZiB0aGUgY2xpZW50IHByb3RvY29sIGZyb20gZXhw
ZWN0ZWRfYnl0ZXM6CisgICAgICAgIGlucHV0ID0gU3RyaW5nSU8oZXhwZWN0ZWRfYnl0ZXMpCisg
ICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAgICAgbWVkaXVtID0gc21hcnQuU21hcnRT
aW1wbGVQaXBlc0NsaWVudE1lZGl1bShpbnB1dCwgb3V0cHV0KQorICAgICAgICBwcm90b2NvbCA9
IHNtYXJ0LlNtYXJ0Q2xpZW50UmVxdWVzdFByb3RvY29sT25lKG1lZGl1bS5nZXRfcmVxdWVzdCgp
KQorICAgICAgICBwcm90b2NvbC5jYWxsKCdmb28nKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFs
KGV4cGVjdGVkX3R1cGxlLCBwcm90b2NvbC5yZWFkX3Jlc3BvbnNlX3R1cGxlKCkpCisKKyAgICBk
ZWYgdGVzdF9jbGllbnRfY2FsbF9lbXB0eV9yZXNwb25zZShzZWxmKToKKyAgICAgICAgIyBwcm90
b2NvbC5jYWxsKCkgY2FuIGdldCBiYWNrIGFuIGVtcHR5IHR1cGxlIGFzIGEgcmVzcG9uc2UuIFRo
aXMgb2NjdXJzCisgICAgICAgICMgd2hlbiB0aGUgcGFyc2VkIGxpbmUgaXMgYW4gZW1wdHkgbGlu
ZSwgYW5kIHJlc3VsdHMgaW4gYSB0dXBsZSB3aXRoCisgICAgICAgICMgb25lIGVsZW1lbnQgLSBh
biBlbXB0eSBzdHJpbmcuCisgICAgICAgIHNlbGYuYXNzZXJ0U2VydmVyVG9DbGllbnRFbmNvZGlu
ZygnXG4nLCAoJycsICksIFsoKSwgKCcnLCApXSkKKworICAgIGRlZiB0ZXN0X2NsaWVudF9jYWxs
X3RocmVlX2VsZW1lbnRfcmVzcG9uc2Uoc2VsZik6CisgICAgICAgICMgcHJvdG9jb2wuY2FsbCgp
IGNhbiBnZXQgYmFjayB0dXBsZXMgb2Ygb3RoZXIgbGVuZ3Rocy4gQSB0aHJlZSBlbGVtZW50Cisg
ICAgICAgICMgdHVwbGUgc2hvdWxkIGJlIHVucGFja2VkIGFzIHRocmVlIHN0cmluZ3MuCisgICAg
ICAgIHNlbGYuYXNzZXJ0U2VydmVyVG9DbGllbnRFbmNvZGluZygnYVx4MDFiXHgwMTM0XG4nLCAo
J2EnLCAnYicsICczNCcpLAorICAgICAgICAgICAgWygnYScsICdiJywgJzM0JyldKQorCisgICAg
ZGVmIHRlc3RfY2xpZW50X2NhbGxfd2l0aF9ib2R5X2J5dGVzX3VwbG9hZHMoc2VsZik6CisgICAg
ICAgICMgcHJvdG9jb2wuY2FsbF93aXRoX3VwbG9hZCBzaG91bGQgbGVuZ3RoLXByZWZpeCB0aGUg
Ynl0ZXMgb250byB0aGUgCisgICAgICAgICMgd2lyZS4KKyAgICAgICAgZXhwZWN0ZWRfYnl0ZXMg
PSAiZm9vXG43XG5hYmNkZWZnZG9uZVxuIgorICAgICAgICBpbnB1dCA9IFN0cmluZ0lPKCJcbiIp
CisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAgICAgbWVkaXVtID0gc21hcnQuU21h
cnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShpbnB1dCwgb3V0cHV0KQorICAgICAgICBwcm90b2Nv
bCA9IHNtYXJ0LlNtYXJ0Q2xpZW50UmVxdWVzdFByb3RvY29sT25lKG1lZGl1bS5nZXRfcmVxdWVz
dCgpKQorICAgICAgICBwcm90b2NvbC5jYWxsX3dpdGhfYm9keV9ieXRlcygoJ2ZvbycsICksICJh
YmNkZWZnIikKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChleHBlY3RlZF9ieXRlcywgb3V0cHV0
LmdldHZhbHVlKCkpCisKKyAgICBkZWYgdGVzdF9jbGllbnRfY2FsbF93aXRoX2JvZHlfcmVhZHZf
YXJyYXkoc2VsZik6CisgICAgICAgICMgcHJvdG9jb2wuY2FsbF93aXRoX3VwbG9hZCBzaG91bGQg
ZW5jb2RlIHRoZSByZWFkdiBhcnJheSBhbmQgdGhlbgorICAgICAgICAjIGxlbmd0aC1wcmVmaXgg
dGhlIGJ5dGVzIG9udG8gdGhlIHdpcmUuCisgICAgICAgIGV4cGVjdGVkX2J5dGVzID0gImZvb1xu
N1xuMSwyXG41LDZkb25lXG4iCisgICAgICAgIGlucHV0ID0gU3RyaW5nSU8oIlxuIikKKyAgICAg
ICAgb3V0cHV0ID0gU3RyaW5nSU8oKQorICAgICAgICBtZWRpdW0gPSBzbWFydC5TbWFydFNpbXBs
ZVBpcGVzQ2xpZW50TWVkaXVtKGlucHV0LCBvdXRwdXQpCisgICAgICAgIHByb3RvY29sID0gc21h
cnQuU21hcnRDbGllbnRSZXF1ZXN0UHJvdG9jb2xPbmUobWVkaXVtLmdldF9yZXF1ZXN0KCkpCisg
ICAgICAgIHByb3RvY29sLmNhbGxfd2l0aF9ib2R5X3JlYWR2X2FycmF5KCgnZm9vJywgKSwgWygx
LDIpLCg1LDYpXSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChleHBlY3RlZF9ieXRlcywgb3V0
cHV0LmdldHZhbHVlKCkpCisKKyAgICBkZWYgdGVzdF9jbGllbnRfcmVhZF9ib2R5X2J5dGVzX2Fs
bChzZWxmKToKKyAgICAgICAgIyByZWFkX2JvZHlfYnl0ZXMgc2hvdWxkIGRlY29kZSB0aGUgYm9k
eSBieXRlcyBmcm9tIHRoZSB3aXJlIGludG8KKyAgICAgICAgIyBhIHJlc3BvbnNlLgorICAgICAg
ICBleHBlY3RlZF9ieXRlcyA9ICIxMjM0NTY3IgorICAgICAgICBzZXJ2ZXJfYnl0ZXMgPSAib2tc
bjdcbjEyMzQ1Njdkb25lXG4iCisgICAgICAgIGlucHV0ID0gU3RyaW5nSU8oc2VydmVyX2J5dGVz
KQorICAgICAgICBvdXRwdXQgPSBTdHJpbmdJTygpCisgICAgICAgIG1lZGl1bSA9IHNtYXJ0LlNt
YXJ0U2ltcGxlUGlwZXNDbGllbnRNZWRpdW0oaW5wdXQsIG91dHB1dCkKKyAgICAgICAgcHJvdG9j
b2wgPSBzbWFydC5TbWFydENsaWVudFJlcXVlc3RQcm90b2NvbE9uZShtZWRpdW0uZ2V0X3JlcXVl
c3QoKSkKKyAgICAgICAgcHJvdG9jb2wuY2FsbCgnZm9vJykKKyAgICAgICAgcHJvdG9jb2wucmVh
ZF9yZXNwb25zZV90dXBsZShUcnVlKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVk
X2J5dGVzLCBwcm90b2NvbC5yZWFkX2JvZHlfYnl0ZXMoKSkKKworICAgIGRlZiB0ZXN0X2NsaWVu
dF9yZWFkX2JvZHlfYnl0ZXNfaW5jcmVtZW50YWwoc2VsZik6CisgICAgICAgICMgdGVzdCByZWFk
aW5nIGEgZmV3IGJ5dGVzIGF0IGEgdGltZSBmcm9tIHRoZSBib2R5CisgICAgICAgICMgWFhYOiBw
b3NzaWJseSB3ZSBzaG91bGQgdGVzdCBkcmliYmxpbmcgdGhlIGJ5dGVzIGludG8gdGhlIHN0cmlu
Z2lvCisgICAgICAgICMgdG8gbWFrZSB0aGUgc3RhdGUgbWFjaGluZSB3b3JrIGhhcmRlcjogaG93
ZXZlciwgYXMgd2UgdXNlIHRoZSAgCisgICAgICAgICMgTGVuZ3RoUHJlZml4ZWRCb2R5RGVjb2Rl
ciB0aGF0IGlzIGFscmVhZHkgd2VsbCB0ZXN0ZWQgLSB3ZSBjYW4gc2tpcAorICAgICAgICAjIHRo
YXQuCisgICAgICAgIGV4cGVjdGVkX2J5dGVzID0gIjEyMzQ1NjciCisgICAgICAgIHNlcnZlcl9i
eXRlcyA9ICJva1xuN1xuMTIzNDU2N2RvbmVcbiIKKyAgICAgICAgaW5wdXQgPSBTdHJpbmdJTyhz
ZXJ2ZXJfYnl0ZXMpCisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAgICAgbWVkaXVt
ID0gc21hcnQuU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShpbnB1dCwgb3V0cHV0KQorICAg
ICAgICBwcm90b2NvbCA9IHNtYXJ0LlNtYXJ0Q2xpZW50UmVxdWVzdFByb3RvY29sT25lKG1lZGl1
bS5nZXRfcmVxdWVzdCgpKQorICAgICAgICBwcm90b2NvbC5jYWxsKCdmb28nKQorICAgICAgICBw
cm90b2NvbC5yZWFkX3Jlc3BvbnNlX3R1cGxlKFRydWUpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1
YWwoZXhwZWN0ZWRfYnl0ZXNbMDoyXSwgcHJvdG9jb2wucmVhZF9ib2R5X2J5dGVzKDIpKQorICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX2J5dGVzWzI6NF0sIHByb3RvY29sLnJlYWRf
Ym9keV9ieXRlcygyKSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChleHBlY3RlZF9ieXRlc1s0
OjZdLCBwcm90b2NvbC5yZWFkX2JvZHlfYnl0ZXMoMikpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1
YWwoZXhwZWN0ZWRfYnl0ZXNbNl0sIHByb3RvY29sLnJlYWRfYm9keV9ieXRlcygpKQorCisgICAg
ZGVmIHRlc3RfY2xpZW50X2NhbmNlbF9yZWFkX2JvZHlfZG9lc19ub3RfZWF0X2JvZHlfYnl0ZXMo
c2VsZik6CisgICAgICAgICMgY2FuY2VsbGluZyB0aGUgZXhwZWN0ZWQgYm9keSBuZWVkcyB0byBm
aW5pc2ggdGhlIHJlcXVlc3QsIGJ1dCBub3QKKyAgICAgICAgIyByZWFkIGFueSBtb3JlIGJ5dGVz
LgorICAgICAgICBleHBlY3RlZF9ieXRlcyA9ICIxMjM0NTY3IgorICAgICAgICBzZXJ2ZXJfYnl0
ZXMgPSAib2tcbjdcbjEyMzQ1Njdkb25lXG4iCisgICAgICAgIGlucHV0ID0gU3RyaW5nSU8oc2Vy
dmVyX2J5dGVzKQorICAgICAgICBvdXRwdXQgPSBTdHJpbmdJTygpCisgICAgICAgIG1lZGl1bSA9
IHNtYXJ0LlNtYXJ0U2ltcGxlUGlwZXNDbGllbnRNZWRpdW0oaW5wdXQsIG91dHB1dCkKKyAgICAg
ICAgcHJvdG9jb2wgPSBzbWFydC5TbWFydENsaWVudFJlcXVlc3RQcm90b2NvbE9uZShtZWRpdW0u
Z2V0X3JlcXVlc3QoKSkKKyAgICAgICAgcHJvdG9jb2wuY2FsbCgnZm9vJykKKyAgICAgICAgcHJv
dG9jb2wucmVhZF9yZXNwb25zZV90dXBsZShUcnVlKQorICAgICAgICBwcm90b2NvbC5jYW5jZWxf
cmVhZF9ib2R5KCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgzLCBpbnB1dC50ZWxsKCkpCisg
ICAgICAgIHNlbGYuYXNzZXJ0UmFpc2VzKGVycm9ycy5SZWFkaW5nQ29tcGxldGVkLCBwcm90b2Nv
bC5yZWFkX2JvZHlfYnl0ZXMpCisKK2NsYXNzIExlbmd0aFByZWZpeGVkQm9keURlY29kZXIodGVz
dHMuVGVzdENhc2UpOgorCisgICAgIyBYWFg6IFRPRE86IG1ha2UgYWNjZXB0X3JlYWRpbmdfdHJh
aWxlciBpbnZva2UgdHJhbnNsYXRlX3Jlc3BvbnNlIG9yIAorICAgICMgc29tZXRoaW5nIHNpbWls
YXIgdG8gdGhlIFByb3RvY29sQmFzZSBtZXRob2QuCisKKyAgICBkZWYgdGVzdF9jb25zdHJ1Y3Qo
c2VsZik6CisgICAgICAgIGRlY29kZXIgPSBzbWFydC5MZW5ndGhQcmVmaXhlZEJvZHlEZWNvZGVy
KCkKKyAgICAgICAgc2VsZi5hc3NlcnRGYWxzZShkZWNvZGVyLmZpbmlzaGVkX3JlYWRpbmcpCisg
ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoNiwgZGVjb2Rlci5uZXh0X3JlYWRfc2l6ZSgpKQorICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKCcnLCBkZWNvZGVyLnJlYWRfcGVuZGluZ19kYXRhKCkpCisg
ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJycsIGRlY29kZXIudW51c2VkX2RhdGEpCisKKyAgICBk
ZWYgdGVzdF9hY2NlcHRfYnl0ZXMoc2VsZik6CisgICAgICAgIGRlY29kZXIgPSBzbWFydC5MZW5n
dGhQcmVmaXhlZEJvZHlEZWNvZGVyKCkKKyAgICAgICAgZGVjb2Rlci5hY2NlcHRfYnl0ZXMoJycp
CisgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2UoZGVjb2Rlci5maW5pc2hlZF9yZWFkaW5nKQorICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKDYsIGRlY29kZXIubmV4dF9yZWFkX3NpemUoKSkKKyAgICAg
ICAgc2VsZi5hc3NlcnRFcXVhbCgnJywgZGVjb2Rlci5yZWFkX3BlbmRpbmdfZGF0YSgpKQorICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKCcnLCBkZWNvZGVyLnVudXNlZF9kYXRhKQorICAgICAgICBk
ZWNvZGVyLmFjY2VwdF9ieXRlcygnNycpCisgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2UoZGVjb2Rl
ci5maW5pc2hlZF9yZWFkaW5nKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKDYsIGRlY29kZXIu
bmV4dF9yZWFkX3NpemUoKSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnJywgZGVjb2Rlci5y
ZWFkX3BlbmRpbmdfZGF0YSgpKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCcnLCBkZWNvZGVy
LnVudXNlZF9kYXRhKQorICAgICAgICBkZWNvZGVyLmFjY2VwdF9ieXRlcygnXG5hJykKKyAgICAg
ICAgc2VsZi5hc3NlcnRGYWxzZShkZWNvZGVyLmZpbmlzaGVkX3JlYWRpbmcpCisgICAgICAgIHNl
bGYuYXNzZXJ0RXF1YWwoMTEsIGRlY29kZXIubmV4dF9yZWFkX3NpemUoKSkKKyAgICAgICAgc2Vs
Zi5hc3NlcnRFcXVhbCgnYScsIGRlY29kZXIucmVhZF9wZW5kaW5nX2RhdGEoKSkKKyAgICAgICAg
c2VsZi5hc3NlcnRFcXVhbCgnJywgZGVjb2Rlci51bnVzZWRfZGF0YSkKKyAgICAgICAgZGVjb2Rl
ci5hY2NlcHRfYnl0ZXMoJ2JjZGVmZ2QnKQorICAgICAgICBzZWxmLmFzc2VydEZhbHNlKGRlY29k
ZXIuZmluaXNoZWRfcmVhZGluZykKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCg0LCBkZWNvZGVy
Lm5leHRfcmVhZF9zaXplKCkpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ2JjZGVmZycsIGRl
Y29kZXIucmVhZF9wZW5kaW5nX2RhdGEoKSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnJywg
ZGVjb2Rlci51bnVzZWRfZGF0YSkKKyAgICAgICAgZGVjb2Rlci5hY2NlcHRfYnl0ZXMoJ29uZScp
CisgICAgICAgIHNlbGYuYXNzZXJ0RmFsc2UoZGVjb2Rlci5maW5pc2hlZF9yZWFkaW5nKQorICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKDEsIGRlY29kZXIubmV4dF9yZWFkX3NpemUoKSkKKyAgICAg
ICAgc2VsZi5hc3NlcnRFcXVhbCgnJywgZGVjb2Rlci5yZWFkX3BlbmRpbmdfZGF0YSgpKQorICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKCcnLCBkZWNvZGVyLnVudXNlZF9kYXRhKQorICAgICAgICBk
ZWNvZGVyLmFjY2VwdF9ieXRlcygnXG5ibGFyZycpCisgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShk
ZWNvZGVyLmZpbmlzaGVkX3JlYWRpbmcpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoMSwgZGVj
b2Rlci5uZXh0X3JlYWRfc2l6ZSgpKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCcnLCBkZWNv
ZGVyLnJlYWRfcGVuZGluZ19kYXRhKCkpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ2JsYXJn
JywgZGVjb2Rlci51bnVzZWRfZGF0YSkKKyAgICAgICAgCisgICAgZGVmIHRlc3RfYWNjZXB0X2J5
dGVzX2FsbF9hdF9vbmNlX3dpdGhfZXhjZXNzKHNlbGYpOgorICAgICAgICBkZWNvZGVyID0gc21h
cnQuTGVuZ3RoUHJlZml4ZWRCb2R5RGVjb2RlcigpCisgICAgICAgIGRlY29kZXIuYWNjZXB0X2J5
dGVzKCcxXG5hZG9uZVxudW51c2VkJykKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKGRlY29kZXIu
ZmluaXNoZWRfcmVhZGluZykKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgxLCBkZWNvZGVyLm5l
eHRfcmVhZF9zaXplKCkpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ2EnLCBkZWNvZGVyLnJl
YWRfcGVuZGluZ19kYXRhKCkpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ3VudXNlZCcsIGRl
Y29kZXIudW51c2VkX2RhdGEpCisKKyAgICBkZWYgdGVzdF9hY2NlcHRfYnl0ZXNfZXhhY3RfZW5k
X29mX2JvZHkoc2VsZik6CisgICAgICAgIGRlY29kZXIgPSBzbWFydC5MZW5ndGhQcmVmaXhlZEJv
ZHlEZWNvZGVyKCkKKyAgICAgICAgZGVjb2Rlci5hY2NlcHRfYnl0ZXMoJzFcbmEnKQorICAgICAg
ICBzZWxmLmFzc2VydEZhbHNlKGRlY29kZXIuZmluaXNoZWRfcmVhZGluZykKKyAgICAgICAgc2Vs
Zi5hc3NlcnRFcXVhbCg1LCBkZWNvZGVyLm5leHRfcmVhZF9zaXplKCkpCisgICAgICAgIHNlbGYu
YXNzZXJ0RXF1YWwoJ2EnLCBkZWNvZGVyLnJlYWRfcGVuZGluZ19kYXRhKCkpCisgICAgICAgIHNl
bGYuYXNzZXJ0RXF1YWwoJycsIGRlY29kZXIudW51c2VkX2RhdGEpCisgICAgICAgIGRlY29kZXIu
YWNjZXB0X2J5dGVzKCdkb25lXG4nKQorICAgICAgICBzZWxmLmFzc2VydFRydWUoZGVjb2Rlci5m
aW5pc2hlZF9yZWFkaW5nKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKDEsIGRlY29kZXIubmV4
dF9yZWFkX3NpemUoKSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnJywgZGVjb2Rlci5yZWFk
X3BlbmRpbmdfZGF0YSgpKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCcnLCBkZWNvZGVyLnVu
dXNlZF9kYXRhKQorCisKK2NsYXNzIEZha2VIVFRQTWVkaXVtKG9iamVjdCk6CisgICAgZGVmIF9f
aW5pdF9fKHNlbGYpOgorICAgICAgICBzZWxmLndyaXR0ZW5fcmVxdWVzdCA9IE5vbmUKKyAgICAg
ICAgc2VsZi5fY3VycmVudF9yZXF1ZXN0ID0gTm9uZQorICAgIGRlZiBzZW5kX2h0dHBfc21hcnRf
cmVxdWVzdChzZWxmLCBieXRlcyk6CisgICAgICAgIHNlbGYud3JpdHRlbl9yZXF1ZXN0ID0gYnl0
ZXMKKyAgICAgICAgcmV0dXJuIE5vbmUKKworCitjbGFzcyBIVFRQVHVubmVsbGluZ1Ntb2tlVGVz
dCh0ZXN0cy5UZXN0Q2FzZVdpdGhUcmFuc3BvcnQpOgorICAgIAorICAgIGRlZiBfdGVzdF9idWxr
X2RhdGEoc2VsZiwgdXJsX3Byb3RvY29sKToKKyAgICAgICAgIyBXZSBzaG91bGQgYmUgYWJsZSB0
byBzZW5kIGFuZCByZWNlaXZlIGJ1bGsgZGF0YSBpbiBhIHNpbmdsZSBtZXNzYWdlLgorICAgICAg
ICAjIFRoZSAncmVhZHYnIGNvbW1hbmQgaW4gdGhlIHNtYXJ0IHByb3RvY29sIGJvdGggc2VuZHMg
YW5kIHJlY2VpdmVzIGJ1bGsKKyAgICAgICAgIyBkYXRhLCBzbyB3ZSB1c2UgdGhhdC4KKyAgICAg
ICAgc2VsZi5idWlsZF90cmVlKFsnZGF0YS1maWxlJ10pCisgICAgICAgIGh0dHBfc2VydmVyID0g
SFRUUFNlcnZlcldpdGhTbWFydHMoKQorICAgICAgICBodHRwX3NlcnZlci5fdXJsX3Byb3RvY29s
ID0gdXJsX3Byb3RvY29sCisgICAgICAgIGh0dHBfc2VydmVyLnNldFVwKCkKKyAgICAgICAgc2Vs
Zi5hZGRDbGVhbnVwKGh0dHBfc2VydmVyLnRlYXJEb3duKQorCisgICAgICAgIGh0dHBfdHJhbnNw
b3J0ID0gZ2V0X3RyYW5zcG9ydChodHRwX3NlcnZlci5nZXRfdXJsKCkpCisKKyAgICAgICAgbWVk
aXVtID0gaHR0cF90cmFuc3BvcnQuZ2V0X3NtYXJ0X21lZGl1bSgpCisgICAgICAgICNyZW1vdGVf
dHJhbnNwb3J0ID0gUmVtb3RlVHJhbnNwb3J0KCdmYWtlX3VybCcsIG1lZGl1bSkKKyAgICAgICAg
cmVtb3RlX3RyYW5zcG9ydCA9IHNtYXJ0LlNtYXJ0VHJhbnNwb3J0KCcvJywgbWVkaXVtPW1lZGl1
bSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgKKyAgICAgICAgICAgIFsoMCwgImMiKV0sIGxp
c3QocmVtb3RlX3RyYW5zcG9ydC5yZWFkdigiZGF0YS1maWxlIiwgWygwLDEpXSkpKQorCisgICAg
ZGVmIHRlc3RfYnVsa19kYXRhX3B5Y3VybChzZWxmKToKKyAgICAgICAgc2VsZi5fdGVzdF9idWxr
X2RhdGEoJ2h0dHArcHljdXJsJykKKyAgICAKKyAgICBkZWYgdGVzdF9idWxrX2RhdGFfdXJsbGli
KHNlbGYpOgorICAgICAgICBzZWxmLl90ZXN0X2J1bGtfZGF0YSgnaHR0cCt1cmxsaWInKQorCisg
ICAgZGVmIHRlc3Rfc21hcnRfaHR0cF9tZWRpdW1fcmVxdWVzdF9hY2NlcHRfYnl0ZXMoc2VsZik6
CisgICAgICAgIG1lZGl1bSA9IEZha2VIVFRQTWVkaXVtKCkKKyAgICAgICAgcmVxdWVzdCA9IFNt
YXJ0Q2xpZW50SFRUUE1lZGl1bVJlcXVlc3QobWVkaXVtKQorICAgICAgICByZXF1ZXN0LmFjY2Vw
dF9ieXRlcygnYWJjJykKKyAgICAgICAgcmVxdWVzdC5hY2NlcHRfYnl0ZXMoJ2RlZicpCisgICAg
ICAgIHNlbGYuYXNzZXJ0RXF1YWwoTm9uZSwgbWVkaXVtLndyaXR0ZW5fcmVxdWVzdCkKKyAgICAg
ICAgcmVxdWVzdC5maW5pc2hlZF93cml0aW5nKCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgn
YWJjZGVmJywgbWVkaXVtLndyaXR0ZW5fcmVxdWVzdCkKKworICAgIGRlZiBfdGVzdF9odHRwX3Nl
bmRfc21hcnRfcmVxdWVzdChzZWxmLCB1cmxfcHJvdG9jb2wpOgorICAgICAgICBodHRwX3NlcnZl
ciA9IEhUVFBTZXJ2ZXJXaXRoU21hcnRzKCkKKyAgICAgICAgaHR0cF9zZXJ2ZXIuX3VybF9wcm90
b2NvbCA9IHVybF9wcm90b2NvbAorICAgICAgICBodHRwX3NlcnZlci5zZXRVcCgpCisgICAgICAg
IHNlbGYuYWRkQ2xlYW51cChodHRwX3NlcnZlci50ZWFyRG93bikKKworICAgICAgICBwb3N0X2Jv
ZHkgPSAnaGVsbG9cbicKKyAgICAgICAgZXhwZWN0ZWRfcmVwbHlfYm9keSA9ICdva1x4MDExXG4n
CisKKyAgICAgICAgaHR0cF90cmFuc3BvcnQgPSBnZXRfdHJhbnNwb3J0KGh0dHBfc2VydmVyLmdl
dF91cmwoKSkKKyAgICAgICAgbWVkaXVtID0gaHR0cF90cmFuc3BvcnQuZ2V0X3NtYXJ0X21lZGl1
bSgpCisgICAgICAgIHJlc3BvbnNlID0gbWVkaXVtLnNlbmRfaHR0cF9zbWFydF9yZXF1ZXN0KHBv
c3RfYm9keSkKKyAgICAgICAgcmVwbHlfYm9keSA9IHJlc3BvbnNlLnJlYWQoKQorICAgICAgICBz
ZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX3JlcGx5X2JvZHksIHJlcGx5X2JvZHkpCisKKyAgICBk
ZWYgdGVzdF9odHRwX3NlbmRfc21hcnRfcmVxdWVzdF9weWN1cmwoc2VsZik6CisgICAgICAgIHNl
bGYuX3Rlc3RfaHR0cF9zZW5kX3NtYXJ0X3JlcXVlc3QoJ2h0dHArcHljdXJsJykKKworICAgIGRl
ZiB0ZXN0X2h0dHBfc2VuZF9zbWFydF9yZXF1ZXN0X3VybGxpYihzZWxmKToKKyAgICAgICAgc2Vs
Zi5fdGVzdF9odHRwX3NlbmRfc21hcnRfcmVxdWVzdCgnaHR0cCt1cmxsaWInKQorCisgICAgZGVm
IHRlc3RfaHR0cF9zZXJ2ZXJfd2l0aF9zbWFydHMoc2VsZik6CisgICAgICAgIGh0dHBfc2VydmVy
ID0gSFRUUFNlcnZlcldpdGhTbWFydHMoKQorICAgICAgICBodHRwX3NlcnZlci5zZXRVcCgpCisg
ICAgICAgIHNlbGYuYWRkQ2xlYW51cChodHRwX3NlcnZlci50ZWFyRG93bikKKworICAgICAgICBw
b3N0X2JvZHkgPSAnaGVsbG9cbicKKyAgICAgICAgZXhwZWN0ZWRfcmVwbHlfYm9keSA9ICdva1x4
MDExXG4nCisKKyAgICAgICAgc21hcnRfc2VydmVyX3VybCA9IGh0dHBfc2VydmVyLmdldF91cmwo
KSArICcuYnpyL3NtYXJ0JworICAgICAgICByZXBseSA9IHVybGxpYjIudXJsb3BlbihzbWFydF9z
ZXJ2ZXJfdXJsLCBwb3N0X2JvZHkpLnJlYWQoKQorCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwo
ZXhwZWN0ZWRfcmVwbHlfYm9keSwgcmVwbHkpCisKKyAgICBkZWYgdGVzdF9zbWFydF9odHRwX3Nl
cnZlcl9wb3N0X3JlcXVlc3RfaGFuZGxlcihzZWxmKToKKyAgICAgICAgaHR0cF9zZXJ2ZXIgPSBI
VFRQU2VydmVyV2l0aFNtYXJ0cygpCisgICAgICAgIGh0dHBfc2VydmVyLnNldFVwKCkKKyAgICAg
ICAgc2VsZi5hZGRDbGVhbnVwKGh0dHBfc2VydmVyLnRlYXJEb3duKQorICAgICAgICBodHRwZCA9
IGh0dHBfc2VydmVyLl9nZXRfaHR0cGQoKQorCisgICAgICAgIHNvY2tldCA9IFNhbXBsZVNvY2tl
dCgKKyAgICAgICAgICAgICdQT1NUIC8uYnpyL3NtYXJ0IEhUVFAvMS4wXHJcbicKKyAgICAgICAg
ICAgICMgSFRUUC8xLjAgcG9zdHMgbXVzdCBoYXZlIGEgQ29udGVudC1MZW5ndGguCisgICAgICAg
ICAgICAnQ29udGVudC1MZW5ndGg6IDZcclxuJworICAgICAgICAgICAgJ1xyXG4nCisgICAgICAg
ICAgICAnaGVsbG9cbicpCisgICAgICAgIHJlcXVlc3RfaGFuZGxlciA9IFNtYXJ0UmVxdWVzdEhh
bmRsZXIoCisgICAgICAgICAgICBzb2NrZXQsICgnbG9jYWxob3N0JywgODApLCBodHRwZCkKKyAg
ICAgICAgcmVzcG9uc2UgPSBzb2NrZXQud3JpdGVmaWxlLmdldHZhbHVlKCkKKyAgICAgICAgc2Vs
Zi5hc3NlcnRTdGFydHNXaXRoKHJlc3BvbnNlLCAnSFRUUC8xLjAgMjAwICcpCisgICAgICAgICMg
VGhpcyBpbmNsdWRlcyB0aGUgZW5kIG9mIHRoZSBIVFRQIGhlYWRlcnMsIGFuZCBhbGwgdGhlIGJv
ZHkuCisgICAgICAgIGV4cGVjdGVkX2VuZF9vZl9yZXNwb25zZSA9ICdcclxuXHJcbm9rXHgwMTFc
bicKKyAgICAgICAgc2VsZi5hc3NlcnRFbmRzV2l0aChyZXNwb25zZSwgZXhwZWN0ZWRfZW5kX29m
X3Jlc3BvbnNlKQorCisKK2NsYXNzIFNhbXBsZVNvY2tldChvYmplY3QpOgorICAgICIiIkEgc29j
a2V0LWxpa2Ugb2JqZWN0IGZvciB1c2UgaW4gdGVzdGluZyB0aGUgSFRUUCByZXF1ZXN0IGhhbmRs
ZXIuIiIiCisgICAgCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHNvY2tldF9yZWFkX2NvbnRlbnQp
OgorICAgICAgICAiIiJDb25zdHJ1Y3RzIGEgc2FtcGxlIHNvY2tldC4KKworICAgICAgICA6cGFy
YW0gc29ja2V0X3JlYWRfY29udGVudDogYSBieXRlIHNlcXVlbmNlCisgICAgICAgICIiIgorICAg
ICAgICAjIFVzZSBwbGFpbiBweXRob24gU3RyaW5nSU8gc28gd2UgY2FuIG1vbmtleS1wYXRjaCB0
aGUgY2xvc2UgbWV0aG9kIHRvCisgICAgICAgICMgbm90IGRpc2NhcmQgdGhlIGNvbnRlbnRzLgor
ICAgICAgICBmcm9tIFN0cmluZ0lPIGltcG9ydCBTdHJpbmdJTworICAgICAgICBzZWxmLnJlYWRm
aWxlID0gU3RyaW5nSU8oc29ja2V0X3JlYWRfY29udGVudCkKKyAgICAgICAgc2VsZi53cml0ZWZp
bGUgPSBTdHJpbmdJTygpCisgICAgICAgIHNlbGYud3JpdGVmaWxlLmNsb3NlID0gbGFtYmRhOiBO
b25lCisgICAgICAgIAorICAgIGRlZiBtYWtlZmlsZShzZWxmLCBtb2RlPSdyJywgYnVmc2l6ZT1O
b25lKToKKyAgICAgICAgaWYgJ3InIGluIG1vZGU6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5y
ZWFkZmlsZQorICAgICAgICBlbHNlOgorICAgICAgICAgICAgcmV0dXJuIHNlbGYud3JpdGVmaWxl
CisKKyAgICAgICAgCiAjIFRPRE86IENsaWVudCBmZWF0dXJlIHRoYXQgZG9lcyBnZXRfYnVuZGxl
IGFuZCB0aGVuIGluc3RhbGxzIHRoYXQgaW50byBhCiAjIGJyYW5jaDsgdGhpcyBjYW4gYmUgdXNl
ZCBpbiBwbGFjZSBvZiB0aGUgcmVndWxhciBwdWxsL2ZldGNoIG9wZXJhdGlvbiB3aGVuCiAjIGNv
bWluZyBmcm9tIGEgc21hcnQgc2VydmVyLgoK
=== modified file bzrlib/tests/test_transport_implementations.py // last-change
... d:robertc at robertcollins.net-20060922043958-628ce589a155a56e // encoding:bas
... e64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=== modified file bzrlib/transport/__init__.py // last-changed:andrew.bennetts@
... canonical.com-20060921091520-673c55c101a86614 // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvX19pbml0X18ucHkKKysrIGJ6cmxpYi90cmFuc3BvcnQvX19p
bml0X18ucHkKQEAgLTQ0NCwxMCArNDQ0LDIzIEBACiAgICAgZGVmIGdldF9zbWFydF9jbGllbnQo
c2VsZik6CiAgICAgICAgICIiIlJldHVybiBhIHNtYXJ0IGNsaWVudCBmb3IgdGhpcyB0cmFuc3Bv
cnQgaWYgcG9zc2libGUuCiAKKyAgICAgICAgQSBzbWFydCBjbGllbnQgZG9lc24ndCBpbXBseSB0
aGUgcHJlc2VuY2Ugb2YgYSBzbWFydCBzZXJ2ZXI6IGl0IGltcGxpZXMKKyAgICAgICAgdGhhdCB0
aGUgc21hcnQgcHJvdG9jb2wgY2FuIGJlIHR1bm5lbGxlZCB2aWEgdGhpcyB0cmFuc3BvcnQuCisK
ICAgICAgICAgOnJhaXNlcyBOb1NtYXJ0U2VydmVyOiBpZiBubyBzbWFydCBzZXJ2ZXIgY2xpZW50
IGlzIGF2YWlsYWJsZS4KICAgICAgICAgIiIiCiAgICAgICAgIHJhaXNlIGVycm9ycy5Ob1NtYXJ0
U2VydmVyKHNlbGYuYmFzZSkKIAorICAgIGRlZiBnZXRfc21hcnRfbWVkaXVtKHNlbGYpOgorICAg
ICAgICAiIiJSZXR1cm4gYSBzbWFydCBjbGllbnQgbWVkaXVtIGZvciB0aGlzIHRyYW5zcG9ydCBp
ZiBwb3NzaWJsZS4KKworICAgICAgICBBIHNtYXJ0IG1lZGl1bSBkb2Vzbid0IGltcGx5IHRoZSBw
cmVzZW5jZSBvZiBhIHNtYXJ0IHNlcnZlcjogaXQgaW1wbGllcworICAgICAgICB0aGF0IHRoZSBz
bWFydCBwcm90b2NvbCBjYW4gYmUgdHVubmVsbGVkIHZpYSB0aGlzIHRyYW5zcG9ydC4KKworICAg
ICAgICA6cmFpc2VzIE5vU21hcnRNZWRpdW06IGlmIG5vIHNtYXJ0IHNlcnZlciBtZWRpdW0gaXMg
YXZhaWxhYmxlLgorICAgICAgICAiIiIKKyAgICAgICAgcmFpc2UgZXJyb3JzLk5vU21hcnRNZWRp
dW0oc2VsZikKKwogICAgIGRlZiByZWFkdihzZWxmLCByZWxwYXRoLCBvZmZzZXRzKToKICAgICAg
ICAgIiIiR2V0IHBhcnRzIG9mIHRoZSBmaWxlIGF0IHRoZSBnaXZlbiByZWxhdGl2ZSBwYXRoLgog
Cgo=
=== modified file bzrlib/transport/http/__init__.py // last-changed:andrew.benn
... etts at canonical.com-20060927052002-5d722be0a289aa4c // encoding:base64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==
=== modified file bzrlib/transport/http/_pycurl.py // last-changed:andrew.benne
... tts at canonical.com-20060926054631-7d63ee5c801fb098 // encoding:base64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=== modified file bzrlib/transport/http/_urllib.py // last-changed:andrew.benne
... tts at canonical.com-20060925164146-200a3de7084173eb // encoding:base64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=== modified file bzrlib/transport/smart.py // encoding:base64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# revision id: andrew.bennetts at canonical.com-20060928040135-c2c58bbb690acc08
# sha1: b1d90ca25371c2040af5368d474dc8a20860a07a
# inventory sha1: e50a4d7e6a6065b0fb67de5151fb11b248335ba2
# parent ids:
# andrew.bennetts at canonical.com-20060928034548-7d0a4e39d595ff17
# pqm at pqm.ubuntu.com-20060927204431-5871ab3ef6affaf3
# properties:
# branch-nick: hpss HTTP support
# message:
# Remove commented cruft, add a TODO comment.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Thu 2006-09-28 13:45:48.849999905 +1000
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3NtYXJ0X3RyYW5zcG9ydC5weQorKysgYnpybGliL3Rlc3Rz
L3Rlc3Rfc21hcnRfdHJhbnNwb3J0LnB5CkBAIC0xMjI2LDEwICsxMjI2LDYgQEAKICAgICBkZWYg
dGVzdF9odHRwX3NlbmRfc21hcnRfcmVxdWVzdF91cmxsaWIoc2VsZik6CiAgICAgICAgIHNlbGYu
X3Rlc3RfaHR0cF9zZW5kX3NtYXJ0X3JlcXVlc3QoJ2h0dHArdXJsbGliJykKIAotICAgICNkZWYg
dGVzdF9zbWFydF9jbGllbnRfaHR0cF9tZWRpdW1fc2VuZF9zbWFydF9yZXF1ZXN0KHNlbGYpOgot
ICAgICMgICAgbWVkaXVtID0gc21hcnQuU21hcnRDbGllbnRIVFRQTWVkaXVtKCkKLSAgICAjICAg
IG1lZGl1bS5zZW5kX3NtYXJ0X3JlcXVlc3QoCi0KICAgICBkZWYgdGVzdF9odHRwX3NlcnZlcl93
aXRoX3NtYXJ0cyhzZWxmKToKICAgICAgICAgaHR0cF9zZXJ2ZXIgPSBIVFRQU2VydmVyV2l0aFNt
YXJ0cygpCiAgICAgICAgIGh0dHBfc2VydmVyLnNldFVwKCkKCg==
=== modified file bzrlib/transport/smart.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQucHkKKysrIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQu
cHkKQEAgLTQ1NSw2ICs0NTUsOCBAQAogICAgICAgICAKICAgICBkZWYgX3N0YXRlX2FjY2VwdF9y
ZWFkaW5nX3RyYWlsZXIoc2VsZiwgYnl0ZXMpOgogICAgICAgICBzZWxmLl90cmFpbGVyX2J1ZmZl
ciArPSBieXRlcworICAgICAgICAjIFRPRE86IHdoYXQgaWYgdGhlIHRyYWlsZXIgZG9lcyBub3Qg
bWF0Y2ggImRvbmVcbiI/ICBTaG91bGQgdGhpcyByYWlzZQorICAgICAgICAjIGEgUHJvdG9jb2xW
aW9sYXRpb24gZXhjZXB0aW9uPwogICAgICAgICBpZiBzZWxmLl90cmFpbGVyX2J1ZmZlci5zdGFy
dHN3aXRoKCdkb25lXG4nKToKICAgICAgICAgICAgIHNlbGYudW51c2VkX2RhdGEgPSBzZWxmLl90
cmFpbGVyX2J1ZmZlcltsZW4oJ2RvbmVcbicpOl0KICAgICAgICAgICAgIHNlbGYuc3RhdGVfYWNj
ZXB0ID0gc2VsZi5fc3RhdGVfYWNjZXB0X3JlYWRpbmdfdW51c2VkCgo=
# revision id: andrew.bennetts at canonical.com-20060928034548-7d0a4e39d595ff17
# sha1: 0ed5b94017289524458ab166586440b17565ebeb
# inventory sha1: 0effa04e3bc3cb5d07d2cef461696c0eeec0236b
# parent ids:
# andrew.bennetts at canonical.com-20060927052002-5d722be0a289aa4c
# properties:
# branch-nick: hpss HTTP support
# message:
# Tidy up TODOs, further testing and fixes for SmartServerRequestProtocolOne, and remove a read_bytes(1) call.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Wed 2006-09-27 15:20:02.368000031 +1000
=== modified file BRANCH.TODO // encoding:base64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=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/transport/http/__init__.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvaHR0cC9fX2luaXRfXy5weQorKysgYnpybGliL3RyYW5zcG9y
dC9odHRwL19faW5pdF9fLnB5CkBAIC0zMDEsNiArMzAxLDE3IEBACiAKICAgICAgICAgcmV0dXJu
IGNvbWJpbmVkCiAKKyAgICBkZWYgX3Bvc3Qoc2VsZiwgYm9keV9ieXRlcyk6CisgICAgICAgICIi
IlBPU1QgYm9keV9ieXRlcyB0byAuYnpyL3NtYXJ0IG9uIHRoaXMgdHJhbnNwb3J0LgorICAgICAg
ICAKKyAgICAgICAgOnJldHVybnM6IChyZXNwb25zZSBjb2RlLCByZXNwb25zZSBib2R5IGZpbGUt
bGlrZSBvYmplY3QpLgorICAgICAgICAiIiIKKyAgICAgICAgIyBUT0RPOiBSZXF1aXJpbmcgYWxs
IHRoZSBib2R5X2J5dGVzIHRvIGJlIGF2YWlsYWJsZSBhdCB0aGUgYmVnaW5uaW5nIG9mCisgICAg
ICAgICMgdGhlIFBPU1QgbWF5IHJlcXVpcmUgbGFyZ2UgY2xpZW50IGJ1ZmZlcnMuICBJdCB3b3Vs
ZCBiZSBuaWNlIHRvIGhhdmUKKyAgICAgICAgIyBhbiBpbnRlcmZhY2UgdGhhdCBhbGxvd3Mgc3Ry
ZWFtaW5nIHZpYSBQT1NUIHdoZW4gcG9zc2libGUgKGFuZAorICAgICAgICAjIGRlZ3JhZGVzIHRv
IGEgbG9jYWwgYnVmZmVyIHdoZW4gbm90KS4KKyAgICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRF
cnJvcihzZWxmLl9wb3N0KQorCiAgICAgZGVmIHB1dF9maWxlKHNlbGYsIHJlbHBhdGgsIGYsIG1v
ZGU9Tm9uZSk6CiAgICAgICAgICIiIkNvcHkgdGhlIGZpbGUtbGlrZSBvYmplY3QgaW50byB0aGUg
bG9jYXRpb24uCiAKQEAgLTYzNSw2ICs2NDYsMTMgQEAKICAgICAgICAgc2VsZi5zZW5kX3Jlc3Bv
bnNlKDIwMCkKICAgICAgICAgc2VsZi5zZW5kX2hlYWRlcigiQ29udGVudC10eXBlIiwgImFwcGxp
Y2F0aW9uL29jdGV0LXN0cmVhbSIpCiAgICAgICAgIHRyYW5zcG9ydCA9IGdldF90cmFuc3BvcnQo
c2VsZi5zZXJ2ZXIudGVzdF9jYXNlLl9ob21lX2RpcikKKyAgICAgICAgIyBUT0RPOiBXZSBtaWdo
dCBsaWtlIHRvIHN1cHBvcnQgc3RyZWFtaW5nIHJlc3BvbnNlcy4gIDEuMCBhbGxvd3Mgbm8KKyAg
ICAgICAgIyBDb250ZW50LWxlbmd0aCBpbiB0aGlzIGNhc2UsIHNvIGZvciBpbnRlZ3JpdHkgd2Ug
c2hvdWxkIHBlcmZvcm0gb3VyCisgICAgICAgICMgb3duIGNodW5raW5nIHdpdGhpbiB0aGUgc3Ry
ZWFtLgorICAgICAgICAjIDEuMSBhbGxvd3MgY2h1bmtlZCByZXNwb25zZXMsIGFuZCBpbiB0aGlz
IGNhc2Ugd2UgY291bGQgY2h1bmsgdXNpbmcKKyAgICAgICAgIyB0aGUgSFRUUCBjaHVua2luZyBh
cyB0aGlzIHdpbGwgYWxsb3cgSFRUUCBwZXJzaXN0ZW5jZSBzYWZlbHksIGV2ZW4gaWYKKyAgICAg
ICAgIyB3ZSBoYXZlIHRvIHN0b3AgZWFybHkgZHVlIHRvIGVycm9yLCBidXQgd2Ugd291bGQgYWxz
byBoYXZlIHRvIHVzZSB0aGUKKyAgICAgICAgIyBIVFRQIHRyYWlsZXIgZmFjaWxpdHkgd2hpY2gg
bWF5IG5vdCBiZSB3aWRlbHkgYXZhaWxhYmxlLgogICAgICAgICBvdXRfYnVmZmVyID0gU3RyaW5n
SU8oKQogICAgICAgICBzbWFydF9wcm90b2NvbF9yZXF1ZXN0ID0gc21hcnQuU21hcnRTZXJ2ZXJS
ZXF1ZXN0UHJvdG9jb2xPbmUob3V0X2J1ZmZlciwKICAgICAgICAgICAgICAgICB0cmFuc3BvcnQp
Cgo=
=== modified file bzrlib/transport/smart.py // encoding:base64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=
# revision id: andrew.bennetts at canonical.com-20060927052002-5d722be0a289aa4c
# sha1: a3a23fe0ea9dc08a7ac7020e30d55a81c30b2ffc
# inventory sha1: 6fcb0f30f1ac021f1b124e84e2e65ab7cc31933c
# parent ids:
# andrew.bennetts at canonical.com-20060926054631-7d63ee5c801fb098
# properties:
# branch-nick: hpss HTTP support
# message:
# (Andrew Bennetts, Robert Collins) Add test_http.RecordingServer, and use it to
# test HttpTransport._post.
#
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2006-09-26 15:46:31.167000055 +1000
=== modified file bzrlib/tests/test_http.py // encoding:base64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=== modified file bzrlib/transport/http/_pycurl.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvaHR0cC9fcHljdXJsLnB5CisrKyBienJsaWIvdHJhbnNwb3J0
L2h0dHAvX3B5Y3VybC5weQpAQCAtMjE4LDkgKzIxOCwxMiBAQAogICAgICAgICAjIFRoZXJlJ3Mg
bm8gd2F5IGluIGh0dHAvMS4wIHRvIHNheSAibXVzdCByZXZhbGlkYXRlIjsgd2UgZG9uJ3Qgd2Fu
dAogICAgICAgICAjIHRvIGZvcmNlIGl0IHRvIGFsd2F5cyByZXRyaWV2ZS4gIHNvIGp1c3QgdHVy
biBvZmYgdGhlIGRlZmF1bHQgUHJhZ21hCiAgICAgICAgICMgcHJvdmlkZWQgYnkgQ3VybC4KKyAg
ICAgICAgIyBBbHNvLCB3ZSBvdmVycmlkZSB0aGUgRXhwZWN0OiBoZWFkZXIgc28gdGhhdCBweWN1
cmwgd2lsbCBzZW5kIHRoZSBQT1NUCisgICAgICAgICMgYm9keSBpbW1lZGlhdGVseS4KICAgICAg
ICAgaGVhZGVycyA9IFsnQ2FjaGUtY29udHJvbDogbWF4LWFnZT0wJywKICAgICAgICAgICAgICAg
ICAgICAnUHJhZ21hOiBuby1jYWNoZScsCi0gICAgICAgICAgICAgICAgICAgJ0Nvbm5lY3Rpb246
IEtlZXAtQWxpdmUnXQorICAgICAgICAgICAgICAgICAgICdDb25uZWN0aW9uOiBLZWVwLUFsaXZl
JywKKyAgICAgICAgICAgICAgICAgICAnRXhwZWN0OiAnLF0KICAgICAgICAgIyMgY3VybC5zZXRv
cHQocHljdXJsLlZFUkJPU0UsIDEpCiAgICAgICAgICMgVE9ETzogbWF5YmUgaW5jbHVkZSBhIHN1
bW1hcnkgb2YgdGhlIHB5Y3VybCB2ZXJzaW9uCiAgICAgICAgIHVhX3N0ciA9ICdienIvJXMgKHB5
Y3VybCknICUgKGJ6cmxpYi5fX3ZlcnNpb25fXywpCgo=
# revision id: andrew.bennetts at canonical.com-20060926054631-7d63ee5c801fb098
# sha1: 1058b65f9e563f8f8df6eb80eabd354167b41a67
# inventory sha1: 448261118ddaa487569b2ff7c49856c0a23ccfe1
# parent ids:
# andrew.bennetts at canonical.com-20060926022414-111422842abffe36
# properties:
# branch-nick: hpss HTTP support
# message:
# Make HttpTransportBase.get_smart_client return self again.
#
# Move HTTP smart client code into http.py from smart.py.
#
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2006-09-26 12:24:14.750999928 +1000
=== modified file bzrlib/tests/test_http.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X2h0dHAucHkKKysrIGJ6cmxpYi90ZXN0cy90ZXN0X2h0dHAu
cHkKQEAgLTEzMCwxMiArMTMwLDcgQEAKICAgICAgICAgc2VydmVyID0gc2VsZi5nZXRfcmVhZG9u
bHlfc2VydmVyKCkKICAgICAgICAgaHR0cF90cmFuc3BvcnQgPSBzZWxmLl90cmFuc3BvcnQoc2Vy
dmVyLmdldF91cmwoKSkKICAgICAgICAgbWVkaXVtID0gaHR0cF90cmFuc3BvcnQuZ2V0X3NtYXJ0
X21lZGl1bSgpCi0gICAgICAgICMgWFhYOiB0aGlzIGFzc2VydCB0ZW1wb3JhcmlseSBkaXNhYmxl
ZCB3aGlsZSBpbiBkZXZlbG9wbWVudC4uLiBzbwotICAgICAgICAjIHVzZSBhIHdlYWtlciBhc3Nl
cnRpb24gaW5zdGVhZC4gLS0gQW5kcmV3Ci0gICAgICAgICNzZWxmLmFzc2VydFRydWUobWVkaXVt
IGlzIGh0dHBfdHJhbnNwb3J0KQotICAgICAgICBmcm9tIGJ6cmxpYi50cmFuc3BvcnQgaW1wb3J0
IHNtYXJ0Ci0gICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShpc2luc3RhbmNlKG1lZGl1bSwgc21hcnQu
U21hcnRDbGllbnRNZWRpdW0pKQotICAgICAgICAKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKG1l
ZGl1bSBpcyBodHRwX3RyYW5zcG9ydCkKICAgICAgICAgCiAKIGNsYXNzIFRlc3RIdHRwQ29ubmVj
dGlvbnNfdXJsbGliKFRlc3RDYXNlV2l0aFdlYnNlcnZlciwgVGVzdEh0dHBNaXhpbnMpOgoK
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3NtYXJ0X3RyYW5zcG9ydC5weQorKysgYnpybGliL3Rlc3Rz
L3Rlc3Rfc21hcnRfdHJhbnNwb3J0LnB5CkBAIC0zNSw3ICszNSwxMSBAQAogICAgICAgICBtZW1v
cnksCiAgICAgICAgIHNtYXJ0LAogICAgICAgICApCi1mcm9tIGJ6cmxpYi50cmFuc3BvcnQuaHR0
cCBpbXBvcnQgSFRUUFNlcnZlcldpdGhTbWFydHMsIFNtYXJ0UmVxdWVzdEhhbmRsZXIKK2Zyb20g
YnpybGliLnRyYW5zcG9ydC5odHRwIGltcG9ydCAoCisgICAgICAgIEhUVFBTZXJ2ZXJXaXRoU21h
cnRzLAorICAgICAgICBTbWFydENsaWVudEhUVFBNZWRpdW1SZXF1ZXN0LAorICAgICAgICBTbWFy
dFJlcXVlc3RIYW5kbGVyLAorICAgICAgICApCiAKIAogY2xhc3MgU3RyaW5nSU9TU0hWZW5kb3Io
b2JqZWN0KToKQEAgLTExMTcsNyArMTEyMSw3IEBACiAgICAgZGVmIF9faW5pdF9fKHNlbGYpOgog
ICAgICAgICBzZWxmLndyaXR0ZW5fcmVxdWVzdCA9IE5vbmUKICAgICAgICAgc2VsZi5fY3VycmVu
dF9yZXF1ZXN0ID0gTm9uZQotICAgIGRlZiBzZW5kX3NtYXJ0X3JlcXVlc3Qoc2VsZiwgYnl0ZXMp
OgorICAgIGRlZiBzZW5kX2h0dHBfc21hcnRfcmVxdWVzdChzZWxmLCBieXRlcyk6CiAgICAgICAg
IHNlbGYud3JpdHRlbl9yZXF1ZXN0ID0gYnl0ZXMKICAgICAgICAgcmV0dXJuIE5vbmUKIApAQCAt
MTE1MCw3ICsxMTU0LDcgQEAKIAogICAgIGRlZiB0ZXN0X3NtYXJ0X2h0dHBfbWVkaXVtX3JlcXVl
c3RfYWNjZXB0X2J5dGVzKHNlbGYpOgogICAgICAgICBtZWRpdW0gPSBGYWtlSFRUUE1lZGl1bSgp
Ci0gICAgICAgIHJlcXVlc3QgPSBzbWFydC5TbWFydENsaWVudEhUVFBNZWRpdW1SZXF1ZXN0KG1l
ZGl1bSkKKyAgICAgICAgcmVxdWVzdCA9IFNtYXJ0Q2xpZW50SFRUUE1lZGl1bVJlcXVlc3QobWVk
aXVtKQogICAgICAgICByZXF1ZXN0LmFjY2VwdF9ieXRlcygnYWJjJykKICAgICAgICAgcmVxdWVz
dC5hY2NlcHRfYnl0ZXMoJ2RlZicpCiAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoTm9uZSwgbWVk
aXVtLndyaXR0ZW5fcmVxdWVzdCkKQEAgLTExNjgsNyArMTE3Miw3IEBACiAKICAgICAgICAgaHR0
cF90cmFuc3BvcnQgPSBnZXRfdHJhbnNwb3J0KGh0dHBfc2VydmVyLmdldF91cmwoKSkKICAgICAg
ICAgbWVkaXVtID0gaHR0cF90cmFuc3BvcnQuZ2V0X3NtYXJ0X21lZGl1bSgpCi0gICAgICAgIHJl
c3BvbnNlID0gbWVkaXVtLnNlbmRfc21hcnRfcmVxdWVzdChwb3N0X2JvZHkpCisgICAgICAgIHJl
c3BvbnNlID0gbWVkaXVtLnNlbmRfaHR0cF9zbWFydF9yZXF1ZXN0KHBvc3RfYm9keSkKICAgICAg
ICAgcmVwbHlfYm9keSA9IHJlc3BvbnNlLnJlYWQoKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFs
KGV4cGVjdGVkX3JlcGx5X2JvZHksIHJlcGx5X2JvZHkpCiAKCg==
=== modified file bzrlib/transport/http/__init__.py // encoding:base64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=== modified file bzrlib/transport/smart.py // encoding:base64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# revision id: andrew.bennetts at canonical.com-20060926022414-111422842abffe36
# sha1: e87c2cc73c3309acf0a1e001106d291978199ba0
# inventory sha1: dfc3d491444ac0e51c94062e3c1ba03d27bb7b9d
# parent ids:
# andrew.bennetts at canonical.com-20060925164146-200a3de7084173eb
# properties:
# branch-nick: hpss HTTP support
# message:
# Implement _post on HttpTransport_urllib.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2006-09-26 02:41:46.371999979 +1000
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/transport/http/_urllib.py // encoding:base64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# revision id: andrew.bennetts at canonical.com-20060925164146-200a3de7084173eb
# sha1: 71e8bcd98b693846885718ff028cf06bc2b1467c
# inventory sha1: 2abd0d7409c9ed48eb57e74098eeee6a1bedb94a
# parent ids:
# andrew.bennetts at canonical.com-20060925095600-c4f9252728a1f51b
# properties:
# branch-nick: hpss HTTP support
# message:
# HTTP client starting to work (pycurl for the moment).
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Mon 2006-09-25 19:56:00.006999969 +1000
=== modified file bzrlib/tests/test_http.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X2h0dHAucHkKKysrIGJ6cmxpYi90ZXN0cy90ZXN0X2h0dHAu
cHkKQEAgLTEzMCw4ICsxMzAsMTMgQEAKICAgICAgICAgc2VydmVyID0gc2VsZi5nZXRfcmVhZG9u
bHlfc2VydmVyKCkKICAgICAgICAgaHR0cF90cmFuc3BvcnQgPSBzZWxmLl90cmFuc3BvcnQoc2Vy
dmVyLmdldF91cmwoKSkKICAgICAgICAgbWVkaXVtID0gaHR0cF90cmFuc3BvcnQuZ2V0X3NtYXJ0
X21lZGl1bSgpCi0gICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShtZWRpdW0gaXMgaHR0cF90cmFuc3Bv
cnQpCi0KKyAgICAgICAgIyBYWFg6IHRoaXMgYXNzZXJ0IHRlbXBvcmFyaWx5IGRpc2FibGVkIHdo
aWxlIGluIGRldmVsb3BtZW50Li4uIHNvCisgICAgICAgICMgdXNlIGEgd2Vha2VyIGFzc2VydGlv
biBpbnN0ZWFkLiAtLSBBbmRyZXcKKyAgICAgICAgI3NlbGYuYXNzZXJ0VHJ1ZShtZWRpdW0gaXMg
aHR0cF90cmFuc3BvcnQpCisgICAgICAgIGZyb20gYnpybGliLnRyYW5zcG9ydCBpbXBvcnQgc21h
cnQKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKGlzaW5zdGFuY2UobWVkaXVtLCBzbWFydC5TbWFy
dENsaWVudE1lZGl1bSkpCisgICAgICAgIAorICAgICAgICAKIAogY2xhc3MgVGVzdEh0dHBDb25u
ZWN0aW9uc191cmxsaWIoVGVzdENhc2VXaXRoV2Vic2VydmVyLCBUZXN0SHR0cE1peGlucyk6CiAK
Cg==
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/transport/http/__init__.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvaHR0cC9fX2luaXRfXy5weQorKysgYnpybGliL3RyYW5zcG9y
dC9odHRwL19faW5pdF9fLnB5CkBAIC0yNDQsMTMgKzI0NCwxNiBAQAogICAgICAgICAiIiIKICAg
ICAgICAgcmFpc2UgTm90SW1wbGVtZW50ZWRFcnJvcihzZWxmLl9nZXQpCiAKKyAgICBkZWYgZ2V0
X3JlcXVlc3Qoc2VsZik6CisgICAgICAgIHJldHVybiBzbWFydC5TbWFydENsaWVudE1lZGl1bVJl
cXVlc3Qoc2VsZikKKwogICAgIGRlZiBnZXRfc21hcnRfbWVkaXVtKHNlbGYpOgogICAgICAgICAi
IiJTZWUgVHJhbnNwb3J0LmdldF9zbWFydF9tZWRpdW0uCiAKICAgICAgICAgSHR0cFRyYW5zcG9y
dEJhc2UgZGlyZWN0bHkgaW1wbGVtZW50cyB0aGUgbWluaW1hbCBpbnRlcmZhY2Ugb2YKICAgICAg
ICAgU21hcnRNZWRpdW1DbGllbnQsIHNvIHRoaXMgcmV0dXJucyBzZWxmLgogICAgICAgICAiIiIK
LSAgICAgICAgcmV0dXJuIHNlbGYKKyAgICAgICAgcmV0dXJuIHNtYXJ0LlNtYXJ0Q2xpZW50SFRU
UE1lZGl1bShzZWxmKQogCiAgICAgZGVmIHJlYWR2KHNlbGYsIHJlbHBhdGgsIG9mZnNldHMpOgog
ICAgICAgICAiIiJHZXQgcGFydHMgb2YgdGhlIGZpbGUgYXQgdGhlIGdpdmVuIHJlbGF0aXZlIHBh
dGguCgo=
=== modified file bzrlib/transport/http/_pycurl.py // encoding:base64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=== modified file bzrlib/transport/smart.py // encoding:base64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# revision id: andrew.bennetts at canonical.com-20060925095600-c4f9252728a1f51b
# sha1: b06a7ccdd65d8a9c734f93b749e0a85ac214c185
# inventory sha1: 882066df004557e8ff9bacb5f977f67c9e537c5f
# parent ids:
# andrew.bennetts at canonical.com-20060925064320-d3a8f0493f1e29ff
# properties:
# branch-nick: hpss HTTP support
# message:
# Clean up some pyflakes warnings, including making 'backing_transport' a required argument of SmartTCPServer.__init__.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Mon 2006-09-25 16:43:20.197000027 +1000
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3NtYXJ0X3RyYW5zcG9ydC5weQorKysgYnpybGliL3Rlc3Rz
L3Rlc3Rfc21hcnRfdHJhbnNwb3J0LnB5CkBAIC0yMCwxMiArMjAsOSBAQAogZnJvbSBjU3RyaW5n
SU8gaW1wb3J0IFN0cmluZ0lPCiBpbXBvcnQgb3MKIGltcG9ydCBzb2NrZXQKLWltcG9ydCBzdWJw
cm9jZXNzCi1pbXBvcnQgc3lzCiBpbXBvcnQgdGhyZWFkaW5nCiBpbXBvcnQgdXJsbGliMgogCi1p
bXBvcnQgYnpybGliCiBmcm9tIGJ6cmxpYiBpbXBvcnQgKAogICAgICAgICBienJkaXIsCiAgICAg
ICAgIGVycm9ycywKCg==
=== modified file bzrlib/transport/smart.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQucHkKKysrIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQu
cHkKQEAgLTIwMSwxMCArMjAxLDggQEAKICMgICAgICAgdGhlIG92ZXJhbGwgc2VydmVyIHNob3Vs
ZG4ndCBkaWUuCiAKIGZyb20gY1N0cmluZ0lPIGltcG9ydCBTdHJpbmdJTwotaW1wb3J0IGVycm5v
CiBpbXBvcnQgb3MKIGltcG9ydCBzb2NrZXQKLWltcG9ydCBzeXMKIGltcG9ydCB0ZW1wZmlsZQog
aW1wb3J0IHRocmVhZGluZwogaW1wb3J0IHVybGxpYgpAQCAtMjE5LDggKzIxNyw2IEBACiAgICAg
dXJsdXRpbHMsCiAgICAgKQogZnJvbSBienJsaWIuYnVuZGxlLnNlcmlhbGl6ZXIgaW1wb3J0IHdy
aXRlX2J1bmRsZQotZnJvbSBienJsaWIudHJhY2UgaW1wb3J0IG11dHRlcgotZnJvbSBienJsaWIu
dHJhbnNwb3J0IGltcG9ydCBsb2NhbAogCiAjIG11c3QgZG8gdGhpcyBvdGhlcndpc2UgdXJsbGli
IGNhbid0IHBhcnNlIHRoZSB1cmxzIHByb3Blcmx5IDooCiBmb3Igc2NoZW1lIGluIFsnc3NoJywg
J2J6cicsICdienIrbG9vcGJhY2snLCAnYnpyK3NzaCddOgpAQCAtNzgzLDcgKzc3OSw3IEBACiBj
bGFzcyBTbWFydFRDUFNlcnZlcihvYmplY3QpOgogICAgICIiIkxpc3RlbnMgb24gYSBUQ1Agc29j
a2V0IGFuZCBhY2NlcHRzIGNvbm5lY3Rpb25zIGZyb20gc21hcnQgY2xpZW50cyIiIgogCi0gICAg
ZGVmIF9faW5pdF9fKHNlbGYsIGJhY2tpbmdfdHJhbnNwb3J0PU5vbmUsIGhvc3Q9JzEyNy4wLjAu
MScsIHBvcnQ9MCk6CisgICAgZGVmIF9faW5pdF9fKHNlbGYsIGJhY2tpbmdfdHJhbnNwb3J0LCBo
b3N0PScxMjcuMC4wLjEnLCBwb3J0PTApOgogICAgICAgICAiIiJDb25zdHJ1Y3QgYSBuZXcgc2Vy
dmVyLgogCiAgICAgICAgIFRvIGFjdHVhbGx5IHN0YXJ0IGl0IHJ1bm5pbmcsIGNhbGwgZWl0aGVy
IHN0YXJ0X2JhY2tncm91bmRfdGhyZWFkIG9yCkBAIC03OTIsOCArNzg4LDYgQEAKICAgICAgICAg
OnBhcmFtIGhvc3Q6IE5hbWUgb2YgdGhlIGludGVyZmFjZSB0byBsaXN0ZW4gb24uCiAgICAgICAg
IDpwYXJhbSBwb3J0OiBUQ1AgcG9ydCB0byBsaXN0ZW4gb24sIG9yIDAgdG8gYWxsb2NhdGUgYSB0
cmFuc2llbnQgcG9ydC4KICAgICAgICAgIiIiCi0gICAgICAgIGlmIGJhY2tpbmdfdHJhbnNwb3J0
IGlzIE5vbmU6Ci0gICAgICAgICAgICBiYWNraW5nX3RyYW5zcG9ydCA9IG1lbW9yeS5NZW1vcnlU
cmFuc3BvcnQoKQogICAgICAgICBzZWxmLl9zZXJ2ZXJfc29ja2V0ID0gc29ja2V0LnNvY2tldCgp
CiAgICAgICAgIHNlbGYuX3NlcnZlcl9zb2NrZXQuYmluZCgoaG9zdCwgcG9ydCkpCiAgICAgICAg
IHNlbGYucG9ydCA9IHNlbGYuX3NlcnZlcl9zb2NrZXQuZ2V0c29ja25hbWUoKVsxXQpAQCAtMTcx
Nyw3ICsxNzExLDcgQEAKIAogCiB0cnk6Ci0gICAgZnJvbSBienJsaWIudHJhbnNwb3J0IGltcG9y
dCBzZnRwLCBzc2gKKyAgICBmcm9tIGJ6cmxpYi50cmFuc3BvcnQgaW1wb3J0IHNzaAogZXhjZXB0
IGVycm9ycy5QYXJhbWlrb05vdFByZXNlbnQ6CiAgICAgIyBubyBwYXJhbWlrbywgbm8gU1NIVHJh
bnNwb3J0LgogICAgIHBhc3MKCg==
# revision id: andrew.bennetts at canonical.com-20060925064320-d3a8f0493f1e29ff
# sha1: c2877faa37808262470b6454aec112304132d97d
# inventory sha1: 9f71adec995fac48b55b552e99fd8fac695e78b7
# parent ids:
# robertc at robertcollins.net-20060922043958-628ce589a155a56e
# properties:
# branch-nick: hpss HTTP support
# message:
# separate out the client medium from the client encoding protocol for the smart server.
# committer: Robert Collins <robertc at robertcollins.net>
# date: Fri 2006-09-22 14:39:58.168999910 +1000
=== modified file bzrlib/errors.py // encoding:base64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=
=== modified file bzrlib/tests/test_errors.py // encoding:base64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=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/tests/test_transport_implementations.py // encoding:ba
... se64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3RyYW5zcG9ydF9pbXBsZW1lbnRhdGlvbnMucHkKKysrIGJ6
cmxpYi90ZXN0cy90ZXN0X3RyYW5zcG9ydF9pbXBsZW1lbnRhdGlvbnMucHkKQEAgLTEzMTEsMjIg
KzEzMTEsNiBAQAogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGRbMl0sICgwLCAnMCcpKQogICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKGRbM10sICgzLCAnMzQnKSkKIAotICAgIGRlZiB0ZXN0X2dl
dF9zbWFydF9jbGllbnQoc2VsZik6Ci0gICAgICAgICIiIkFsbCB0cmFuc3BvcnRzIG11c3QgZWl0
aGVyIGdpdmUgYSBzbWFydCBjbGllbnQsIG9yIGtub3cgdGhleSBjYW4ndC4KLQotICAgICAgICBG
b3Igc29tZSB0cmFuc3BvcnRzIHN1Y2ggYXMgaHR0cCB0aGlzIG1pZ2h0IGRlcGVuZCBvbiBwcm9i
aW5nIHRvIHNlZSAKLSAgICAgICAgd2hhdCdzIGFjdHVhbGx5IHByZXNlbnQgb24gdGhlIG90aGVy
IGVuZC4gIChCdXQgd2UgY2FuIGFkanVzdCBmb3IgdGhhdCAKLSAgICAgICAgaW4gdGhlIGZ1dHVy
ZS4pCi0gICAgICAgICIiIgotICAgICAgICB0cmFuc3BvcnQgPSBzZWxmLmdldF90cmFuc3BvcnQo
KQotICAgICAgICB0cnk6Ci0gICAgICAgICAgICBjbGllbnQgPSB0cmFuc3BvcnQuZ2V0X3NtYXJ0
X2NsaWVudCgpCi0gICAgICAgICAgICAjIFhYWDogc2hvdWxkIGJlIGEgbW9yZSBnZW5lcmFsIGNs
YXNzCi0gICAgICAgICAgICBzZWxmLmFzc2VydElzSW5zdGFuY2UoY2xpZW50LCBzbWFydC5TbWFy
dFN0cmVhbUNsaWVudCkKLSAgICAgICAgZXhjZXB0IE5vU21hcnRTZXJ2ZXI6Ci0gICAgICAgICAg
ICAjIGFzIGxvbmcgYXMgd2UgZ290IGl0IHdlJ3JlIGZpbmUKLSAgICAgICAgICAgIHBhc3MKLQog
ICAgIGRlZiB0ZXN0X2dldF9zbWFydF9tZWRpdW0oc2VsZik6CiAgICAgICAgICIiIkFsbCB0cmFu
c3BvcnRzIG11c3QgZWl0aGVyIGdpdmUgYSBzbWFydCBtZWRpdW0sIG9yIGtub3cgdGhleSBjYW4n
dC4KICAgICAgICAgIiIiCgo=
=== modified file bzrlib/transport/smart.py // encoding:base64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# revision id: robertc at robertcollins.net-20060922043958-628ce589a155a56e
# sha1: 95bee706329ca5ddbbe37c666640036241815f11
# inventory sha1: a23778964c1242cdb7cff3ce26fd7ebbaa5d92f9
# parent ids:
# andrew.bennetts at canonical.com-20060921091520-673c55c101a86614
# properties:
# branch-nick: http-smart
# message:
# Starting factoring out the smart server client "medium" from the protocol.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Thu 2006-09-21 19:15:20.700999975 +1000
=== modified file bzrlib/errors.py // encoding:base64
LS0tIGJ6cmxpYi9lcnJvcnMucHkKKysrIGJ6cmxpYi9lcnJvcnMucHkKQEAgLTkxMiw2ICs5MTIs
MTQgQEAKICAgICAgICAgc2VsZi5maWxlbmFtZSA9IGZpbGVuYW1lCiAKIAorY2xhc3MgTWVkaXVt
Tm90Q29ubmVjdGVkKEJ6ck5ld0Vycm9yKToKKyAgICAiIiJUaGUgbWVkaXVtICclKG1lZGl1bSlz
JyBpcyBub3QgY29ubmVjdGVkLiIiIgorCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIG1lZGl1bSk6
CisgICAgICAgIEJ6ck5ld0Vycm9yLl9faW5pdF9fKHNlbGYpCisgICAgICAgIHNlbGYubWVkaXVt
ID0gbWVkaXVtCisKKwogY2xhc3MgTXVzdFVzZURlY29yYXRlZChFeGNlcHRpb24pOgogICAgICIi
IkEgZGVjb3JhdGluZyBmdW5jdGlvbiBoYXMgcmVxdWVzdGVkIGl0cyBvcmlnaW5hbCBjb21tYW5k
IGJlIHVzZWQuCiAgICAgCkBAIC0xMTk2LDYgKzEyMDQsMTQgQEAKICAgICAgICAgQmFkSW52ZW50
b3J5Rm9ybWF0Ll9faW5pdF9fKHNlbGYsIG1zZz1tc2cpCiAKIAorY2xhc3MgTm9TbWFydE1lZGl1
bShCenJOZXdFcnJvcik6CisgICAgIiIiVGhlIHRyYW5zcG9ydCAnJSh0cmFuc3BvcnQpcycgY2Fu
bm90IHR1bm5lbCB0aGUgc21hcnQgcHJvdG9jb2wuIiIiCisKKyAgICBkZWYgX19pbml0X18oc2Vs
ZiwgdHJhbnNwb3J0KToKKyAgICAgICAgQnpyTmV3RXJyb3IuX19pbml0X18oc2VsZikKKyAgICAg
ICAgc2VsZi50cmFuc3BvcnQgPSB0cmFuc3BvcnQKKworCiBjbGFzcyBOb1NtYXJ0U2VydmVyKE5v
dEJyYW5jaEVycm9yKToKICAgICAiIiJObyBzbWFydCBzZXJ2ZXIgYXZhaWxhYmxlIGF0ICUodXJs
KXMiIiIKIAoK
=== modified file bzrlib/tests/blackbox/test_serve.py // encoding:base64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=== modified file bzrlib/tests/test_errors.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X2Vycm9ycy5weQorKysgYnpybGliL3Rlc3RzL3Rlc3RfZXJy
b3JzLnB5CkBAIC0yNiwxMiArMjYsMjMgQEAKIAogY2xhc3MgVGVzdEVycm9ycyhUZXN0Q2FzZVdp
dGhUcmFuc3BvcnQpOgogCisgICAgZGVmIHRlc3RfbWVkaXVtX25vdF9jb25uZWN0ZWQoc2VsZik6
CisgICAgICAgIGVycm9yID0gZXJyb3JzLk1lZGl1bU5vdENvbm5lY3RlZCgiYSBtZWRpdW0iKQor
ICAgICAgICBzZWxmLmFzc2VydEVxdWFsRGlmZigKKyAgICAgICAgICAgICJUaGUgbWVkaXVtICdh
IG1lZGl1bScgaXMgbm90IGNvbm5lY3RlZC4iLCBzdHIoZXJyb3IpKQorICAgICAgICAKICAgICBk
ZWYgdGVzdF9ub19yZXBvKHNlbGYpOgogICAgICAgICBkaXIgPSBienJkaXIuQnpyRGlyLmNyZWF0
ZShzZWxmLmdldF91cmwoKSkKICAgICAgICAgZXJyb3IgPSBlcnJvcnMuTm9SZXBvc2l0b3J5UHJl
c2VudChkaXIpCiAgICAgICAgIHNlbGYuYXNzZXJ0Tm90RXF1YWwoLTEsIHN0cihlcnJvcikuZmlu
ZCgoZGlyLnRyYW5zcG9ydC5jbG9uZSgnLi4nKS5iYXNlKSkpCiAgICAgICAgIHNlbGYuYXNzZXJ0
RXF1YWwoLTEsIHN0cihlcnJvcikuZmluZCgoZGlyLnRyYW5zcG9ydC5iYXNlKSkpCiAgICAgICAg
IAorICAgIGRlZiB0ZXN0X25vX3NtYXJ0X21lZGl1bShzZWxmKToKKyAgICAgICAgZXJyb3IgPSBl
cnJvcnMuTm9TbWFydE1lZGl1bSgiYSB0cmFuc3BvcnQiKQorICAgICAgICBzZWxmLmFzc2VydEVx
dWFsRGlmZigiVGhlIHRyYW5zcG9ydCAnYSB0cmFuc3BvcnQnIGNhbm5vdCB0dW5uZWwgdGhlICIK
KyAgICAgICAgICAgICJzbWFydCBwcm90b2NvbC4iLAorICAgICAgICAgICAgc3RyKGVycm9yKSkK
KwogICAgIGRlZiB0ZXN0X25vX3N1Y2hfaWQoc2VsZik6CiAgICAgICAgIGVycm9yID0gZXJyb3Jz
Lk5vU3VjaElkKCJhdHJlZSIsICJhbmlkIikKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbERpZmYo
IlRoZSBmaWxlIGlkIGFuaWQgaXMgbm90IHByZXNlbnQgaW4gdGhlIHRyZWUgIgoK
=== modified file bzrlib/tests/test_http.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X2h0dHAucHkKKysrIGJ6cmxpYi90ZXN0cy90ZXN0X2h0dHAu
cHkKQEAgLTEyNSw2ICsxMjUsMTMgQEAKICAgICAgICAgc2VsZi5hc3NlcnRUcnVlKHNlcnZlci5s
b2dzWzBdLmZpbmQoCiAgICAgICAgICAgICAnIkdFVCAvZm9vL2JhciBIVFRQLzEuMSIgMjAwIC0g
Ii0iICJienIvJXMnICUgYnpybGliLl9fdmVyc2lvbl9fKSA+IC0xKQogCisgICAgZGVmIHRlc3Rf
Z2V0X3NtYXJ0X21lZGl1bShzZWxmKToKKyAgICAgICAgIyBGb3IgSFRUUCwgZ2V0X3NtYXJ0X21l
ZGl1bSBzaG91bGQgcmV0dXJuIHRoZSB0cmFuc3BvcnQgb2JqZWN0LgorICAgICAgICBzZXJ2ZXIg
PSBzZWxmLmdldF9yZWFkb25seV9zZXJ2ZXIoKQorICAgICAgICBodHRwX3RyYW5zcG9ydCA9IHNl
bGYuX3RyYW5zcG9ydChzZXJ2ZXIuZ2V0X3VybCgpKQorICAgICAgICBtZWRpdW0gPSBodHRwX3Ry
YW5zcG9ydC5nZXRfc21hcnRfbWVkaXVtKCkKKyAgICAgICAgc2VsZi5hc3NlcnRUcnVlKG1lZGl1
bSBpcyBodHRwX3RyYW5zcG9ydCkKKwogCiBjbGFzcyBUZXN0SHR0cENvbm5lY3Rpb25zX3VybGxp
YihUZXN0Q2FzZVdpdGhXZWJzZXJ2ZXIsIFRlc3RIdHRwTWl4aW5zKToKIAoK
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/tests/test_transport_implementations.py // encoding:ba
... se64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3RyYW5zcG9ydF9pbXBsZW1lbnRhdGlvbnMucHkKKysrIGJ6
cmxpYi90ZXN0cy90ZXN0X3RyYW5zcG9ydF9pbXBsZW1lbnRhdGlvbnMucHkKQEAgLTg5Nyw2ICs4
OTcsOCBAQAogICAgICAgICBleGNlcHQgTm90SW1wbGVtZW50ZWRFcnJvcjoKICAgICAgICAgICAg
IHJhaXNlIFRlc3RTa2lwcGVkKCJUcmFuc3BvcnQgJXMgaGFzIG5vIGJvZ3VzIFVSTCBzdXBwb3J0
LiIgJQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2VsZi5fc2VydmVyLl9fY2xhc3Nf
XykKKyAgICAgICAgIyBUaGlzIHNob3VsZCBiZTogIGJ1dCBTU0ggc3RpbGwgY29ubmVjdHMgb24g
Y29uc3RydWN0aW9uLiBObyBDT09LSUUhCisgICAgICAgICMgc2VsZi5hc3NlcnRSYWlzZXMoKENv
bm5lY3Rpb25FcnJvciwgTm9TdWNoRmlsZSksIHQuZ2V0LCAnLmJ6ci9icmFuY2gnKQogICAgICAg
ICB0cnk6CiAgICAgICAgICAgICB0ID0gYnpybGliLnRyYW5zcG9ydC5nZXRfdHJhbnNwb3J0KHVy
bCkKICAgICAgICAgICAgIHQuZ2V0KCcuYnpyL2JyYW5jaCcpCkBAIC0xMzI1LDYgKzEzMjcsMTcg
QEAKICAgICAgICAgICAgICMgYXMgbG9uZyBhcyB3ZSBnb3QgaXQgd2UncmUgZmluZQogICAgICAg
ICAgICAgcGFzcwogCisgICAgZGVmIHRlc3RfZ2V0X3NtYXJ0X21lZGl1bShzZWxmKToKKyAgICAg
ICAgIiIiQWxsIHRyYW5zcG9ydHMgbXVzdCBlaXRoZXIgZ2l2ZSBhIHNtYXJ0IG1lZGl1bSwgb3Ig
a25vdyB0aGV5IGNhbid0LgorICAgICAgICAiIiIKKyAgICAgICAgdHJhbnNwb3J0ID0gc2VsZi5n
ZXRfdHJhbnNwb3J0KCkKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgbWVkaXVtID0gdHJhbnNw
b3J0LmdldF9zbWFydF9tZWRpdW0oKQorICAgICAgICAgICAgc2VsZi5hc3NlcnRJc0luc3RhbmNl
KG1lZGl1bSwgc21hcnQuU21hcnRDbGllbnRNZWRpdW0pCisgICAgICAgIGV4Y2VwdCBlcnJvcnMu
Tm9TbWFydE1lZGl1bToKKyAgICAgICAgICAgICMgYXMgbG9uZyBhcyB3ZSBnb3QgaXQgd2UncmUg
ZmluZQorICAgICAgICAgICAgcGFzcworCiAgICAgZGVmIHRlc3RfcmVhZHZfc2hvcnRfcmVhZChz
ZWxmKToKICAgICAgICAgdHJhbnNwb3J0ID0gc2VsZi5nZXRfdHJhbnNwb3J0KCkKICAgICAgICAg
aWYgdHJhbnNwb3J0LmlzX3JlYWRvbmx5KCk6Cgo=
=== modified file bzrlib/transport/__init__.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvX19pbml0X18ucHkKKysrIGJ6cmxpYi90cmFuc3BvcnQvX19p
bml0X18ucHkKQEAgLTQ0NCwxMCArNDQ0LDIzIEBACiAgICAgZGVmIGdldF9zbWFydF9jbGllbnQo
c2VsZik6CiAgICAgICAgICIiIlJldHVybiBhIHNtYXJ0IGNsaWVudCBmb3IgdGhpcyB0cmFuc3Bv
cnQgaWYgcG9zc2libGUuCiAKKyAgICAgICAgQSBzbWFydCBjbGllbnQgZG9lc24ndCBpbXBseSB0
aGUgcHJlc2VuY2Ugb2YgYSBzbWFydCBzZXJ2ZXI6IGl0IGltcGxpZXMKKyAgICAgICAgdGhhdCB0
aGUgc21hcnQgcHJvdG9jb2wgY2FuIGJlIHR1bm5lbGxlZCB2aWEgdGhpcyB0cmFuc3BvcnQuCisK
ICAgICAgICAgOnJhaXNlcyBOb1NtYXJ0U2VydmVyOiBpZiBubyBzbWFydCBzZXJ2ZXIgY2xpZW50
IGlzIGF2YWlsYWJsZS4KICAgICAgICAgIiIiCiAgICAgICAgIHJhaXNlIGVycm9ycy5Ob1NtYXJ0
U2VydmVyKHNlbGYuYmFzZSkKIAorICAgIGRlZiBnZXRfc21hcnRfbWVkaXVtKHNlbGYpOgorICAg
ICAgICAiIiJSZXR1cm4gYSBzbWFydCBjbGllbnQgbWVkaXVtIGZvciB0aGlzIHRyYW5zcG9ydCBp
ZiBwb3NzaWJsZS4KKworICAgICAgICBBIHNtYXJ0IG1lZGl1bSBkb2Vzbid0IGltcGx5IHRoZSBw
cmVzZW5jZSBvZiBhIHNtYXJ0IHNlcnZlcjogaXQgaW1wbGllcworICAgICAgICB0aGF0IHRoZSBz
bWFydCBwcm90b2NvbCBjYW4gYmUgdHVubmVsbGVkIHZpYSB0aGlzIHRyYW5zcG9ydC4KKworICAg
ICAgICA6cmFpc2VzIE5vU21hcnRNZWRpdW06IGlmIG5vIHNtYXJ0IHNlcnZlciBtZWRpdW0gaXMg
YXZhaWxhYmxlLgorICAgICAgICAiIiIKKyAgICAgICAgcmFpc2UgZXJyb3JzLk5vU21hcnRNZWRp
dW0oc2VsZikKKwogICAgIGRlZiByZWFkdihzZWxmLCByZWxwYXRoLCBvZmZzZXRzKToKICAgICAg
ICAgIiIiR2V0IHBhcnRzIG9mIHRoZSBmaWxlIGF0IHRoZSBnaXZlbiByZWxhdGl2ZSBwYXRoLgog
Cgo=
=== modified file bzrlib/transport/http/__init__.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvaHR0cC9fX2luaXRfXy5weQorKysgYnpybGliL3RyYW5zcG9y
dC9odHRwL19faW5pdF9fLnB5CkBAIC0xMjUsNyArMTI1LDcgQEAKICAgICByZXR1cm4gbQogCiAK
LWNsYXNzIEh0dHBUcmFuc3BvcnRCYXNlKFRyYW5zcG9ydCk6CitjbGFzcyBIdHRwVHJhbnNwb3J0
QmFzZShUcmFuc3BvcnQsIHNtYXJ0LlNtYXJ0Q2xpZW50TWVkaXVtKToKICAgICAiIiJCYXNlIGNs
YXNzIGZvciBodHRwIGltcGxlbWVudGF0aW9ucy4KIAogICAgIERvZXMgVVJMIHBhcnNpbmcsIGV0
YywgYnV0IG5vdCBhbnkgbmV0d29yayBJTy4KQEAgLTI0NCw2ICsyNDQsMTQgQEAKICAgICAgICAg
IiIiCiAgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3Ioc2VsZi5fZ2V0KQogCisgICAg
ZGVmIGdldF9zbWFydF9tZWRpdW0oc2VsZik6CisgICAgICAgICIiIlNlZSBUcmFuc3BvcnQuZ2V0
X3NtYXJ0X21lZGl1bS4KKworICAgICAgICBIdHRwVHJhbnNwb3J0QmFzZSBkaXJlY3RseSBpbXBs
ZW1lbnRzIHRoZSBtaW5pbWFsIGludGVyZmFjZSBvZgorICAgICAgICBTbWFydE1lZGl1bUNsaWVu
dCwgc28gdGhpcyByZXR1cm5zIHNlbGYuCisgICAgICAgICIiIgorICAgICAgICByZXR1cm4gc2Vs
ZgorCiAgICAgZGVmIHJlYWR2KHNlbGYsIHJlbHBhdGgsIG9mZnNldHMpOgogICAgICAgICAiIiJH
ZXQgcGFydHMgb2YgdGhlIGZpbGUgYXQgdGhlIGdpdmVuIHJlbGF0aXZlIHBhdGguCiAKCg==
=== modified file bzrlib/transport/smart.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQucHkKKysrIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQu
cHkKQEAgLTU3LDcgKzU3LDEwIEBACiBzdWJzdHJhdGUgYW5kIHRoaXMgd2lsbCBnaXZlIHVzIGEg
c2luZ2xlIG1vZGVsIHdoaWNoIGlzIGNvbnNpc3QgZm9yIEhUVFAsCiBzb2NrZXRzIGFuZCBwaXBl
cy4KIAotIFdJUkUgICAgKGZhY3RvcnkgZm9yIHByb3RvY29sLCByZWFkcyBieXRlcyAmIHB1c2hl
cyB0byBwcm90b2NvbCwKK1NlcnZlci1zaWRlCistLS0tLS0tLS0tLQorCisgTUVESVVNICAoZmFj
dG9yeSBmb3IgcHJvdG9jb2wsIHJlYWRzIGJ5dGVzICYgcHVzaGVzIHRvIHByb3RvY29sLAogICAg
ICAgICAgIHVzZXMgcHJvdG9jb2wgdG8gZGV0ZWN0IGVuZC1vZi1yZXF1ZXN0LCBzZW5kcyB3cml0
dGVuCiAgICAgICAgICAgYnl0ZXMgdG8gY2xpZW50KSBlLmcuIHNvY2tldCwgcGlwZSwgSFRUUCBy
ZXF1ZXN0IGhhbmRsZXIuCiAgIF4KQEAgLTY3LDcgKzcwLDcgQEAKIFBST1RPQ09MICAoc2VyaWFs
aXNhdGlvbiwgZGVzZXJpYWxpc2F0aW9uKSAgYWNjZXB0cyBieXRlcyBmb3Igb25lCiAgICAgICAg
ICAgcmVxdWVzdCwgZGVjb2RlcyBhY2NvcmRpbmcgdG8gaW50ZXJuYWwgc3RhdGUsIHB1c2hlcwog
ICAgICAgICAgIHN0cnVjdHVyZWQgZGF0YSB0byBoYW5kbGVyLiAgYWNjZXB0cyBzdHJ1Y3R1cmVk
IGRhdGEgZnJvbQotICAgICAgICAgIGhhbmRsZXIgYW5kIGVuY29kZXMgYW5kIHdyaXRlcyB0byB0
aGUgd2lyZS4gIGZhY3RvcnkgZm9yCisgICAgICAgICAgaGFuZGxlciBhbmQgZW5jb2RlcyBhbmQg
d3JpdGVzIHRvIHRoZSBtZWRpdW0uICBmYWN0b3J5IGZvcgogICAgICAgICAgIGhhbmRsZXIuCiAg
IF4KICAgfCBzdHJ1Y3R1cmVkIGRhdGEKQEAgLTc2LDYgKzc5LDMzIEBACiBIQU5ETEVSICAgKGRv
bWFpbiBsb2dpYykgYWNjZXB0cyBzdHJ1Y3R1cmVkIGRhdGEsIG9wZXJhdGVzIHN0YXRlCiAgICAg
ICAgICAgbWFjaGluZSB1bnRpbCB0aGUgcmVxdWVzdCBjYW4gYmUgc2F0aXNmaWVkLAogICAgICAg
ICAgIHNlbmRzIHN0cnVjdHVyZWQgZGF0YSB0byB0aGUgcHJvdG9jb2wuCisKKworQ2xpZW50LXNp
ZGUKKy0tLS0tLS0tLS0tCisKKyBDTElFTlQgICAgICAgICAgICAgZG9tYWluIGxvZ2ljLCBhY2Nl
cHRzIGRvbWFpbiByZXF1ZXN0cywgZ2VuZXJhdGVkIHN0cnVjdHVyZWQKKyAgICAgICAgICAgICAg
ICAgICAgZGF0YSwgcmVhZHMgc3RydWN0dXJlZCBkYXRhIGZyb20gcmVzcG9uc2VzIGFuZCB0dXJu
cyBpbnRvCisgICAgICAgICAgICAgICAgICAgIGRvbWFpbiBkYXRhLiAgU2VuZHMgc3RydWN0dXJl
ZCBkYXRhIHRvIHRoZSBwcm90b2NvbC4KKyAgICAgICAgICAgICAgICAgICAgT3BlcmF0ZXMgc3Rh
dGUgbWFjaGluZXMgdW50aWwgdGhlIHJlcXVlc3QgY2FuIGJlIGRlbGl2ZXJlZAorICAgICAgICAg
ICAgICAgICAgICAoZS5nLiByZWFkaW5nIGZyb20gYSBidW5kbGUgZ2VuZXJhdGVkIGluIGJ6cmxp
YiB0byBkZWxpdmVyIGEKKyAgICAgICAgICAgICAgICAgICAgY29tcGxldGUgcmVxdWVzdCkuCisK
KyAgICAgICAgICAgICAgICAgICAgUG9zc2libHkgdGhpcyBzaG91bGQganVzdCBiZSBSZW1vdGVC
enJEaXIsIFJlbW90ZVRyYW5zcG9ydCwKKyAgICAgICAgICAgICAgICAgICAgLi4uCisgIF4KKyAg
fCBzdHJ1Y3R1cmVkIGRhdGEKKyAgdgorCitQUk9UT0NPTCAgKHNlcmlhbGlzYXRpb24sIGRlc2Vy
aWFsaXNhdGlvbikgIGFjY2VwdHMgc3RydWN0dXJlZCBkYXRhIGZvciBvbmUKKyAgICAgICAgICBy
ZXF1ZXN0LCBlbmNvZGVzIGFuZCB3cml0ZXMgdG8gdGhlIG1lZGl1bS4gIFJlYWRzIGJ5dGVzIGZy
b20gdGhlCisgICAgICAgICAgbWVkaXVtLCBkZWNvZGVzIGFuZCBhbGxvd3MgdGhlIGNsaWVudCB0
byByZWFkIHN0cnVjdHVyZWQgZGF0YS4KKyAgXgorICB8IGJ5dGVzLgorICB2CisKKyBNRURJVU0g
IChhY2NlcHRzIGJ5dGVzIGZyb20gdGhlIHByb3RvY29sICYgZGVsaXZlcnMgdG8gdGhlIHJlbW90
ZSBzZXJ2ZXIuCisgICAgICAgICAgQWxsb3dzIHRoZSBwb3RvY29sIHRvIHJlYWQgYnl0ZXMgZS5n
LiBzb2NrZXQsIHBpcGUsIEhUVFAgcmVxdWVzdC4KICIiIgogCiAKQEAgLTIyMiw5ICsyNTIsMTMg
QEAKICAgICBkZWYgX3NlbmRfYnVsa19kYXRhKHNlbGYsIGJvZHksIGFfZmlsZT1Ob25lKToKICAg
ICAgICAgIiIiU2VuZCBjaHVua2VkIGJvZHkgZGF0YSIiIgogICAgICAgICBhc3NlcnQgaXNpbnN0
YW5jZShib2R5LCBzdHIpCi0gICAgICAgIGJ5dGVzID0gJycuam9pbigoJyVkXG4nICUgbGVuKGJv
ZHkpLCBib2R5LCAnZG9uZVxuJykpCisgICAgICAgIGJ5dGVzID0gc2VsZi5fZW5jb2RlX2J1bGtf
ZGF0YShib2R5KQogICAgICAgICBzZWxmLl93cml0ZV9hbmRfZmx1c2goYnl0ZXMsIGFfZmlsZSkK
IAorICAgIGRlZiBfZW5jb2RlX2J1bGtfZGF0YShzZWxmLCBib2R5KToKKyAgICAgICAgIiIiRW5j
b2RlIGJvZHkgYXMgYSBidWxrIGRhdGEgY2h1bmsuIiIiCisgICAgICAgIHJldHVybiAnJy5qb2lu
KCgnJWRcbicgJSBsZW4oYm9keSksIGJvZHksICdkb25lXG4nKSkKKwogICAgICMgVE9ETzogdGhp
cyBvbmx5IGFjdHVhbGx5IGFjY29tb2RhdGVzIGEgc2luZ2xlIGJsb2NrOyBwb3NzaWJseSBzaG91
bGQgc3VwcG9ydAogICAgICMgbXVsdGlwbGUgY2h1bmtzPwogICAgIGRlZiBfcmVjdl9idWxrKHNl
bGYpOgpAQCAtODgzLDEwICs5MTcsMTEgQEAKICAgICAjIFNtYXJ0VHJhbnNwb3J0IGlzIGFuIGFk
YXB0ZXIgZnJvbSB0aGUgVHJhbnNwb3J0IG9iamVjdCBtb2RlbCB0byB0aGUgCiAgICAgIyBTbWFy
dENsaWVudCBtb2RlbCwgbm90IGFuIGVuY29kZXIuCiAKLSAgICBkZWYgX19pbml0X18oc2VsZiwg
dXJsLCBjbG9uZV9mcm9tPU5vbmUsIGNsaWVudD1Ob25lKToKKyAgICBkZWYgX19pbml0X18oc2Vs
ZiwgdXJsLCBjbG9uZV9mcm9tPU5vbmUsIG1lZGl1bT1Ob25lKToKICAgICAgICAgIiIiQ29uc3Ry
dWN0b3IuCiAKLSAgICAgICAgOnBhcmFtIGNsaWVudDogaWdub3JlZCB3aGVuIGNsb25lX2Zyb20g
aXMgbm90IE5vbmUuCisgICAgICAgIDpwYXJhbSBtZWRpdW06IFRoZSBtZWRpdW0gdG8gdXNlIGZv
ciB0aGlzIFJlbW90ZVRyYW5zcG9ydC4gVGhpcyBtdXN0IGJlCisgICAgICAgICAgICBzdXBwbGll
ZCBpZiBjbG9uZV9mcm9tIGlzIE5vbmUuCiAgICAgICAgICIiIgogICAgICAgICAjIyMgVGVjaG5p
Y2FsbHkgc3VwZXIoKSBoZXJlIGlzIGZhdWx0eSBiZWNhdXNlIFRyYW5zcG9ydCdzIF9faW5pdF9f
CiAgICAgICAgICMjIyBmYWlscyB0byB0YWtlIDIgcGFyYW1ldGVycywgYW5kIGlmIHN1cGVyIHdl
cmUgdG8gY2hvb3NlIGEgc2lsbHkKQEAgLTg5NywxNiArOTMyLDE0IEBACiAgICAgICAgIHNlbGYu
X3NjaGVtZSwgc2VsZi5fdXNlcm5hbWUsIHNlbGYuX3Bhc3N3b3JkLCBzZWxmLl9ob3N0LCBzZWxm
Ll9wb3J0LCBzZWxmLl9wYXRoID0gXAogICAgICAgICAgICAgICAgIHRyYW5zcG9ydC5zcGxpdF91
cmwodXJsKQogICAgICAgICBpZiBjbG9uZV9mcm9tIGlzIE5vbmU6Ci0gICAgICAgICAgICBpZiBj
bGllbnQgaXMgTm9uZToKLSAgICAgICAgICAgICAgICBzZWxmLl9jbGllbnQgPSBTbWFydFN0cmVh
bUNsaWVudChzZWxmLl9jb25uZWN0X3RvX3NlcnZlcikKLSAgICAgICAgICAgIGVsc2U6Ci0gICAg
ICAgICAgICAgICAgc2VsZi5fY2xpZW50ID0gY2xpZW50CisgICAgICAgICAgICBzZWxmLl9jbGll
bnQgPSBtZWRpdW0KICAgICAgICAgZWxzZToKICAgICAgICAgICAgICMgY3JlZGVudGlhbHMgbWF5
IGJlIHN0cmlwcGVkIGZyb20gdGhlIGJhc2UgaW4gc29tZSBjaXJjdW1zdGFuY2VzCiAgICAgICAg
ICAgICAjIGFzIHlldCB0byBiZSBjbGVhcmx5IGRlZmluZWQgb3IgZG9jdW1lbnRlZCwgc28gY29w
eSB0aGVtLgogICAgICAgICAgICAgc2VsZi5fdXNlcm5hbWUgPSBjbG9uZV9mcm9tLl91c2VybmFt
ZQogICAgICAgICAgICAgIyByZXVzZSBzYW1lIGNvbm5lY3Rpb24KICAgICAgICAgICAgIHNlbGYu
X2NsaWVudCA9IGNsb25lX2Zyb20uX2NsaWVudAorICAgICAgICBhc3NlcnQgc2VsZi5fY2xpZW50
IGlzIG5vdCBOb25lCiAKICAgICBkZWYgYWJzcGF0aChzZWxmLCByZWxwYXRoKToKICAgICAgICAg
IiIiUmV0dXJuIHRoZSBmdWxsIHVybCB0byB0aGUgZ2l2ZW4gcmVsYXRpdmUgcGF0aC4KQEAgLTky
Miw5ICs5NTUsOSBAQAogICAgICAgICBUaGlzIGVzc2VudGlhbGx5IG9wZW5zIGEgaGFuZGxlIG9u
IGEgZGlmZmVyZW50IHJlbW90ZSBkaXJlY3RvcnkuCiAgICAgICAgICIiIgogICAgICAgICBpZiBy
ZWxhdGl2ZV91cmwgaXMgTm9uZToKLSAgICAgICAgICAgIHJldHVybiBzZWxmLl9fY2xhc3NfXyhz
ZWxmLmJhc2UsIHNlbGYpCisgICAgICAgICAgICByZXR1cm4gU21hcnRUcmFuc3BvcnQoc2VsZi5i
YXNlLCBzZWxmKQogICAgICAgICBlbHNlOgotICAgICAgICAgICAgcmV0dXJuIHNlbGYuX19jbGFz
c19fKHNlbGYuYWJzcGF0aChyZWxhdGl2ZV91cmwpLCBzZWxmKQorICAgICAgICAgICAgcmV0dXJu
IFNtYXJ0VHJhbnNwb3J0KHNlbGYuYWJzcGF0aChyZWxhdGl2ZV91cmwpLCBzZWxmKQogCiAgICAg
ZGVmIGlzX3JlYWRvbmx5KHNlbGYpOgogICAgICAgICAiIiJTbWFydCBzZXJ2ZXIgdHJhbnNwb3J0
IGNhbiBkbyByZWFkL3dyaXRlIGZpbGUgb3BlcmF0aW9ucy4iIiIKQEAgLTkzMiw2ICs5NjUsOSBA
QAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAg
ICAgZGVmIGdldF9zbWFydF9jbGllbnQoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9jbGll
bnQKKworICAgIGRlZiBnZXRfc21hcnRfbWVkaXVtKHNlbGYpOgorICAgICAgICByZXR1cm4gc2Vs
Zi5fY2xpZW50CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg
ICAgICAKICAgICBkZWYgX3VucGFyc2VfdXJsKHNlbGYsIHBhdGgpOgogICAgICAgICAiIiJSZXR1
cm4gVVJMIGZvciBhIHBhdGguCkBAIC0xMTUzLDcgKzExODksNyBAQAogICAgICAgICAgICAgcmFp
c2UgZXJyb3JzLlNtYXJ0UHJvdG9jb2xFcnJvcigndW5leHBlY3RlZCBzbWFydCBzZXJ2ZXIgZXJy
b3I6ICVyJyAlIChyZXNwLCkpCiAKICAgICBkZWYgX3NlbmRfdHVwbGUoc2VsZiwgYXJncyk6Ci0g
ICAgICAgIHNlbGYuX2NsaWVudC5fc2VuZF90dXBsZShhcmdzKQorICAgICAgICBzZWxmLl9jbGll
bnQuYWNjZXB0X2J5dGVzKF9lbmNvZGVfdHVwbGUoYXJncykpCiAKICAgICBkZWYgX3JlY3ZfdHVw
bGUoc2VsZik6CiAgICAgICAgIHJldHVybiBzZWxmLl9jbGllbnQuX3JlY3ZfdHVwbGUoKQpAQCAt
MTIwNyw0NiArMTI0MywyMCBAQAogY2xhc3MgU21hcnRTdHJlYW1DbGllbnQoU21hcnRQcm90b2Nv
bEJhc2UpOgogICAgICIiIkNvbm5lY3Rpb24gdG8gc21hcnQgc2VydmVyIG92ZXIgdHdvIHN0cmVh
bXMiIiIKIAotICAgIGRlZiBfX2luaXRfXyhzZWxmLCBjb25uZWN0X2Z1bmMpOgotICAgICAgICBz
ZWxmLl9jb25uZWN0X2Z1bmMgPSBjb25uZWN0X2Z1bmMKLSAgICAgICAgc2VsZi5fY29ubmVjdGVk
ID0gRmFsc2UKLQotICAgIGRlZiBfX2RlbF9fKHNlbGYpOgotICAgICAgICBzZWxmLmRpc2Nvbm5l
Y3QoKQotCi0gICAgZGVmIF9lbnN1cmVfY29ubmVjdGlvbihzZWxmKToKLSAgICAgICAgaWYgbm90
IHNlbGYuX2Nvbm5lY3RlZDoKLSAgICAgICAgICAgIHNlbGYuX2luLCBzZWxmLl9vdXQgPSBzZWxm
Ll9jb25uZWN0X2Z1bmMoKQotICAgICAgICAgICAgc2VsZi5fY29ubmVjdGVkID0gVHJ1ZQotCi0g
ICAgZGVmIF9zZW5kX3R1cGxlKHNlbGYsIGFyZ3MpOgotICAgICAgICBzZWxmLl9lbnN1cmVfY29u
bmVjdGlvbigpCi0gICAgICAgIHJldHVybiBzZWxmLl93cml0ZV9hbmRfZmx1c2goX2VuY29kZV90
dXBsZShhcmdzKSkKLQogICAgIGRlZiBfc2VuZF9idWxrX2RhdGEoc2VsZiwgYm9keSk6CiAgICAg
ICAgIHNlbGYuX2Vuc3VyZV9jb25uZWN0aW9uKCkKICAgICAgICAgU21hcnRQcm90b2NvbEJhc2Uu
X3NlbmRfYnVsa19kYXRhKHNlbGYsIGJvZHkpCiAgICAgICAgIAotICAgIGRlZiBfcmVjdl9idWxr
KHNlbGYpOgotICAgICAgICBzZWxmLl9lbnN1cmVfY29ubmVjdGlvbigpCi0gICAgICAgIHJldHVy
biBTbWFydFByb3RvY29sQmFzZS5fcmVjdl9idWxrKHNlbGYpCi0KLSAgICBkZWYgX3JlY3ZfdHVw
bGUoc2VsZik6Ci0gICAgICAgIHNlbGYuX2Vuc3VyZV9jb25uZWN0aW9uKCkKLSAgICAgICAgcmV0
dXJuIFNtYXJ0UHJvdG9jb2xCYXNlLl9yZWN2X3R1cGxlKHNlbGYpCi0KLSAgICBkZWYgX3JlY3Zf
dHJhaWxlcihzZWxmKToKLSAgICAgICAgc2VsZi5fZW5zdXJlX2Nvbm5lY3Rpb24oKQotICAgICAg
ICByZXR1cm4gU21hcnRQcm90b2NvbEJhc2UuX3JlY3ZfdHJhaWxlcihzZWxmKQotCiAgICAgZGVm
IGRpc2Nvbm5lY3Qoc2VsZik6Ci0gICAgICAgICIiIkNsb3NlIGNvbm5lY3Rpb24gdG8gdGhlIHNl
cnZlciIiIgotICAgICAgICBpZiBzZWxmLl9jb25uZWN0ZWQ6Ci0gICAgICAgICAgICBzZWxmLl9v
dXQuY2xvc2UoKQotICAgICAgICAgICAgc2VsZi5faW4uY2xvc2UoKQotCisgICAgICAgICIiIklm
IHRoaXMgbWVkaXVtIG1haW50YWlucyBhIHBlcnNpc3RlbnQgY29ubmVjdGlvbiwgY2xvc2UgaXQu
CisgICAgICAgIAorICAgICAgICBUaGUgZGVmYXVsdCBpbXBsZW1lbnRhdGlvbiBkb2VzIG5vdGhp
bmcuCisgICAgICAgICIiIgorICAgICAgICAKICAgICBkZWYgX2NhbGwoc2VsZiwgKmFyZ3MpOgot
ICAgICAgICBzZWxmLl9zZW5kX3R1cGxlKGFyZ3MpCisgICAgICAgIGJ5dGVzID0gX2VuY29kZV90
dXBsZShhcmdzKQorICAgICAgICAjIHNob3VsZCBiZSBzZWxmLm1lZGl1bS5hY2NlcHRfYnl0ZXMo
Ynl0ZXMpIFhYWAorICAgICAgICBzZWxmLmFjY2VwdF9ieXRlcyhieXRlcykKICAgICAgICAgcmV0
dXJuIHNlbGYuX3JlY3ZfdHVwbGUoKQogCiAgICAgZGVmIF9jYWxsX3dpdGhfdXBsb2FkKHNlbGYs
IG1ldGhvZCwgYXJncywgYm9keSk6CkBAIC0xMjU2LDUxICsxMjY2LDIyMSBAQAogICAgICAgICA6
cGFyYW0gYXJnczogcGFyYW1ldGVyIGFyZ3MgdHVwbGUKICAgICAgICAgOnBhcmFtIGJvZHk6IHVw
bG9hZCBib2R5IGFzIGEgYnl0ZSBzdHJpbmcKICAgICAgICAgIiIiCi0gICAgICAgIHNlbGYuX3Nl
bmRfdHVwbGUoKG1ldGhvZCwpICsgYXJncykKLSAgICAgICAgc2VsZi5fc2VuZF9idWxrX2RhdGEo
Ym9keSkKKyAgICAgICAgYnl0ZXMgPSBfZW5jb2RlX3R1cGxlKChtZXRob2QsKSArIGFyZ3MpCisg
ICAgICAgIGJ5dGVzICs9IHNlbGYuX2VuY29kZV9idWxrX2RhdGEoYm9keSkKKyAgICAgICAgIyBz
aG91bGQgYmUgc2VsZi5tZWRpdW0uYWNjZXB0X2J5dGVzIFhYWAorICAgICAgICBzZWxmLmFjY2Vw
dF9ieXRlcyhieXRlcykKICAgICAgICAgcmV0dXJuIHNlbGYuX3JlY3ZfdHVwbGUoKQogCiAgICAg
ZGVmIHF1ZXJ5X3ZlcnNpb24oc2VsZik6CiAgICAgICAgICIiIlJldHVybiBwcm90b2NvbCB2ZXJz
aW9uIG51bWJlciBvZiB0aGUgc2VydmVyLiIiIgotICAgICAgICAjIFhYWDogc2hvdWxkIG1ha2Ug
c3VyZSBpdCdzIGVtcHR5Ci0gICAgICAgIHNlbGYuX3NlbmRfdHVwbGUoKCdoZWxsbycsKSkKLSAg
ICAgICAgcmVzcCA9IHNlbGYuX3JlY3ZfdHVwbGUoKQorICAgICAgICByZXNwID0gc2VsZi5fY2Fs
bCgnaGVsbG8nKQogICAgICAgICBpZiByZXNwID09ICgnb2snLCAnMScpOgogICAgICAgICAgICAg
cmV0dXJuIDEKICAgICAgICAgZWxzZToKICAgICAgICAgICAgIHJhaXNlIGVycm9ycy5TbWFydFBy
b3RvY29sRXJyb3IoImJhZCByZXNwb25zZSAlciIgJSAocmVzcCwpKQogCiAKLWNsYXNzIFNtYXJ0
VENQVHJhbnNwb3J0KFNtYXJ0VHJhbnNwb3J0KToKLSAgICAiIiJDb25uZWN0aW9uIHRvIHNtYXJ0
IHNlcnZlciBvdmVyIHBsYWluIHRjcCIiIgotCi0gICAgZGVmIF9faW5pdF9fKHNlbGYsIHVybCwg
Y2xvbmVfZnJvbT1Ob25lKToKLSAgICAgICAgc3VwZXIoU21hcnRUQ1BUcmFuc3BvcnQsIHNlbGYp
Ll9faW5pdF9fKHVybCwgY2xvbmVfZnJvbSkKLSAgICAgICAgdHJ5OgotICAgICAgICAgICAgc2Vs
Zi5fcG9ydCA9IGludChzZWxmLl9wb3J0KQotICAgICAgICBleGNlcHQgKFZhbHVlRXJyb3IsIFR5
cGVFcnJvciksIGU6Ci0gICAgICAgICAgICByYWlzZSBlcnJvcnMuSW52YWxpZFVSTChwYXRoPXVy
bCwgZXh0cmE9ImludmFsaWQgcG9ydCAlcyIgJSBzZWxmLl9wb3J0KQotICAgICAgICBzZWxmLl9z
b2NrZXQgPSBOb25lCi0KLSAgICBkZWYgX2Nvbm5lY3RfdG9fc2VydmVyKHNlbGYpOgorY2xhc3Mg
U21hcnRDbGllbnRNZWRpdW0oU21hcnRTdHJlYW1DbGllbnQpOgorICAgICIiIlNtYXJ0IGNsaWVu
dCBpcyBhIG1lZGl1bSBmb3Igc2VuZGluZyBzbWFydCBwcm90b2NvbCByZXF1ZXN0cyBvdmVyLgor
CisgICAgWFhYOiB3ZSB3YW50IGV4cGxpY2l0IGZpbmFsaXNhdGlvbgorICAgICIiIgorCisKK2Ns
YXNzIFNtYXJ0U3RyZWFtTWVkaXVtQ2xpZW50KFNtYXJ0Q2xpZW50TWVkaXVtKToKKyAgICAiIiJU
aGUgU21hcnRTdHJlYW1NZWRpdW1DbGllbnQga25vd3MgaG93IHRvIGNsb3NlIHRoZSBzdHJlYW0g
d2hlbiBpdCBpcworICAgIGZpbmlzaGVkIHdpdGggaXQuCisgICAgIiIiCisKKyAgICBkZWYgX19k
ZWxfXyhzZWxmKToKKyAgICAgICAgc2VsZi5kaXNjb25uZWN0KCkKKworCitjbGFzcyBTbWFydFNp
bXBsZVBpcGVzQ2xpZW50TWVkaXVtKFNtYXJ0Q2xpZW50TWVkaXVtKToKKyAgICAiIiJBIGNsaWVu
dCBtZWRpdW0gdXNpbmcgc2ltcGxlIHBpcGVzLgorICAgIAorICAgIFRoaXMgY2xpZW50IGRvZXMg
bm90IG1hbmFnZSB0aGUgcGlwZXM6IGl0IGFzc3VtZXMgdGhleSB3aWxsIGFsd2F5cyBiZSBvcGVu
LgorICAgICIiIgorCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHJlYWRhYmxlX3BpcGUsIHdyaXRl
YWJsZV9waXBlKToKKyAgICAgICAgc2VsZi5fcmVhZGFibGVfcGlwZSA9IHJlYWRhYmxlX3BpcGUK
KyAgICAgICAgc2VsZi5fd3JpdGVhYmxlX3BpcGUgPSB3cml0ZWFibGVfcGlwZQorCisgICAgZGVm
IGFjY2VwdF9ieXRlcyhzZWxmLCBieXRlcyk6CisgICAgICAgICIiIlNlZSBTbWFydENsaWVudE1l
ZGl1bS5hY2NlcHRfYnl0ZXMuIiIiCisgICAgICAgIHNlbGYuX3dyaXRlYWJsZV9waXBlLndyaXRl
KGJ5dGVzKQorCisgICAgZGVmIHJlYWRfYnl0ZXMoc2VsZiwgY291bnQpOgorICAgICAgICAiIiJT
ZWUgU21hcnRDbGllbnRNZWRpdW0ucmVhZF9ieXRlcy4iIiIKKyAgICAgICAgcmV0dXJuIHNlbGYu
X3JlYWRhYmxlX3BpcGUucmVhZChjb3VudCkKKworICAgIGRlZiBfcmVjdl9idWxrKHNlbGYpOgor
ICAgICAgICAiIiJ0cmFuc2l0aW9uYWwgYXBpIGZyb20gJ2NsaWVudCcgdG8gJ21lZGl1bScuIiIi
CisgICAgICAgIHNlbGYuX2luID0gc2VsZi5fcmVhZGFibGVfcGlwZQorICAgICAgICB0cnk6Cisg
ICAgICAgICAgICByZXR1cm4gU21hcnRDbGllbnRNZWRpdW0uX3JlY3ZfYnVsayhzZWxmKQorICAg
ICAgICBmaW5hbGx5OgorICAgICAgICAgICAgc2VsZi5faW4gPSBOb25lCisKKyAgICBkZWYgX3Jl
Y3ZfdHVwbGUoc2VsZik6CisgICAgICAgICIiInRyYW5zaXRpb25hbCBhcGkgZnJvbSAnY2xpZW50
JyB0byAnbWVkaXVtJy4iIiIKKyAgICAgICAgcmV0dXJuIF9yZWN2X3R1cGxlKHNlbGYuX3JlYWRh
YmxlX3BpcGUpCisKKyAgICBkZWYgX3dyaXRlX2FuZF9mbHVzaChzZWxmLCBieXRlcywgZmlsZT1O
b25lKToKKyAgICAgICAgIiIiVGh1bmsgZnJvbSB0aGUgJ2NsaWVudCcgYXBpIHRvIHRoZSAnTWVk
aXVtJyBhcGkuIiIiCisgICAgICAgIGFzc2VydCBmaWxlIGlzIE5vbmUKKyAgICAgICAgc2VsZi5h
Y2NlcHRfYnl0ZXMoYnl0ZXMpCisKKworY2xhc3MgU21hcnRTU0hDbGllbnRNZWRpdW0oU21hcnRT
dHJlYW1NZWRpdW1DbGllbnQpOgorICAgICIiIkEgY2xpZW50IG1lZGl1bSB1c2luZyBTU0guIiIi
CisgICAgCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIGhvc3QsIHBvcnQ9Tm9uZSwgdXNlcm5hbWU9
Tm9uZSwgcGFzc3dvcmQ9Tm9uZSwKKyAgICAgICAgICAgIHZlbmRvcj1Ob25lKToKKyAgICAgICAg
IiIiQ3JlYXRlcyBhIGNsaWVudCB0aGF0IHdpbGwgY29ubmVjdCBvbiB0aGUgZmlyc3QgdXNlLgor
ICAgICAgICAKKyAgICAgICAgOnBhcmFtIHZlbmRvcjogQW4gb3B0aW9uYWwgb3ZlcnJpZGUgZm9y
IHRoZSBzc2ggdmVuZG9yIHRvIHVzZS4gU2VlCisgICAgICAgICAgICBienJsaWIudHJhbnNwb3J0
LnNzaCBmb3IgZGV0YWlscyBvbiBzc2ggdmVuZG9ycy4KKyAgICAgICAgIiIiCisgICAgICAgIHNl
bGYuX2Nvbm5lY3RlZCA9IEZhbHNlCisgICAgICAgIHNlbGYuX2hvc3QgPSBob3N0CisgICAgICAg
IHNlbGYuX3Bhc3N3b3JkID0gcGFzc3dvcmQKKyAgICAgICAgc2VsZi5fcG9ydCA9IHBvcnQKKyAg
ICAgICAgc2VsZi5fdXNlcm5hbWUgPSB1c2VybmFtZQorICAgICAgICBzZWxmLl9yZWFkX2Zyb20g
PSBOb25lCisgICAgICAgIHNlbGYuX3NzaF9jb25uZWN0aW9uID0gTm9uZQorICAgICAgICBzZWxm
Ll92ZW5kb3IgPSB2ZW5kb3IKKyAgICAgICAgc2VsZi5fd3JpdGVfdG8gPSBOb25lCisKKyAgICBk
ZWYgYWNjZXB0X2J5dGVzKHNlbGYsIGJ5dGVzKToKKyAgICAgICAgIiIiU2VlIFNtYXJ0Q2xpZW50
TWVkaXVtLmFjY2VwdF9ieXRlcy4iIiIKKyAgICAgICAgc2VsZi5fZW5zdXJlX2Nvbm5lY3Rpb24o
KQorICAgICAgICBzZWxmLl93cml0ZV90by53cml0ZShieXRlcykKKyAgICAgICAgc2VsZi5fd3Jp
dGVfdG8uZmx1c2goKQorCisgICAgZGVmIGRpc2Nvbm5lY3Qoc2VsZik6CisgICAgICAgICIiIlNl
ZSBTbWFydENsaWVudE1lZGl1bS5kaXNjb25uZWN0KCkuIiIiCisgICAgICAgIGlmIG5vdCBzZWxm
Ll9jb25uZWN0ZWQ6CisgICAgICAgICAgICByZXR1cm4KKyAgICAgICAgc2VsZi5fcmVhZF9mcm9t
LmNsb3NlKCkKKyAgICAgICAgc2VsZi5fd3JpdGVfdG8uY2xvc2UoKQorICAgICAgICBzZWxmLl9z
c2hfY29ubmVjdGlvbi5jbG9zZSgpCisgICAgICAgIHNlbGYuX2Nvbm5lY3RlZCA9IEZhbHNlCisK
KyAgICBkZWYgX2Vuc3VyZV9jb25uZWN0aW9uKHNlbGYpOgorICAgICAgICAiIiJDb25uZWN0IHRo
aXMgbWVkaXVtIGlmIG5vdCBhbHJlYWR5IGNvbm5lY3RlZC4iIiIKKyAgICAgICAgaWYgc2VsZi5f
Y29ubmVjdGVkOgorICAgICAgICAgICAgcmV0dXJuCisgICAgICAgIGV4ZWN1dGFibGUgPSBvcy5l
bnZpcm9uLmdldCgnQlpSX1JFTU9URV9QQVRIJywgJ2J6cicpCisgICAgICAgIGlmIHNlbGYuX3Zl
bmRvciBpcyBOb25lOgorICAgICAgICAgICAgdmVuZG9yID0gc3NoLl9nZXRfc3NoX3ZlbmRvcigp
CisgICAgICAgIGVsc2U6CisgICAgICAgICAgICB2ZW5kb3IgPSBzZWxmLl92ZW5kb3IKKyAgICAg
ICAgc2VsZi5fc3NoX2Nvbm5lY3Rpb24gPSB2ZW5kb3IuY29ubmVjdF9zc2goc2VsZi5fdXNlcm5h
bWUsCisgICAgICAgICAgICAgICAgc2VsZi5fcGFzc3dvcmQsIHNlbGYuX2hvc3QsIHNlbGYuX3Bv
cnQsCisgICAgICAgICAgICAgICAgY29tbWFuZD1bZXhlY3V0YWJsZSwgJ3NlcnZlJywgJy0taW5l
dCcsICctLWRpcmVjdG9yeT0vJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAnLS1hbGxvdy13
cml0ZXMnXSkKKyAgICAgICAgc2VsZi5fcmVhZF9mcm9tLCBzZWxmLl93cml0ZV90byA9IFwKKyAg
ICAgICAgICAgIHNlbGYuX3NzaF9jb25uZWN0aW9uLmdldF9maWxlbGlrZV9jaGFubmVscygpCisg
ICAgICAgIHNlbGYuX2Nvbm5lY3RlZCA9IFRydWUKKworICAgIGRlZiByZWFkX2J5dGVzKHNlbGYs
IGNvdW50KToKKyAgICAgICAgIiIiU2VlIFNtYXJ0Q2xpZW50TWVkaXVtLnJlYWRfYnl0ZXMuIiIi
CisgICAgICAgIHJhaXNlIGVycm9ycy5NZWRpdW1Ob3RDb25uZWN0ZWQoc2VsZikKKworICAgIGRl
ZiBfcmVjdl9idWxrKHNlbGYpOgorICAgICAgICAiIiJ0cmFuc2l0aW9uYWwgYXBpIGZyb20gJ2Ns
aWVudCcgdG8gJ21lZGl1bScuIiIiCisgICAgICAgIHNlbGYuX2luID0gc2VsZi5fcmVhZF9mcm9t
CisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHJldHVybiBTbWFydFN0cmVhbU1lZGl1bUNsaWVu
dC5fcmVjdl9idWxrKHNlbGYpCisgICAgICAgIGZpbmFsbHk6CisgICAgICAgICAgICBzZWxmLl9p
biA9IE5vbmUKKworICAgIGRlZiBfcmVjdl90dXBsZShzZWxmKToKKyAgICAgICAgIiIidHJhbnNp
dGlvbmFsIGFwaSBmcm9tICdjbGllbnQnIHRvICdtZWRpdW0nLiIiIgorICAgICAgICByZXR1cm4g
X3JlY3ZfdHVwbGUoc2VsZi5fcmVhZF9mcm9tKQorCisgICAgZGVmIF93cml0ZV9hbmRfZmx1c2go
c2VsZiwgYnl0ZXMsIGZpbGU9Tm9uZSk6CisgICAgICAgICIiIlRodW5rIGZyb20gdGhlICdjbGll
bnQnIGFwaSB0byB0aGUgJ01lZGl1bScgYXBpLiIiIgorICAgICAgICBhc3NlcnQgZmlsZSBpcyBO
b25lCisgICAgICAgIHNlbGYuYWNjZXB0X2J5dGVzKGJ5dGVzKQorCisKK2NsYXNzIFNtYXJ0VENQ
Q2xpZW50TWVkaXVtKFNtYXJ0U3RyZWFtTWVkaXVtQ2xpZW50KToKKyAgICAiIiJBIGNsaWVudCBt
ZWRpdW0gdXNpbmcgVENQLiIiIgorICAgIAorICAgIGRlZiBfX2luaXRfXyhzZWxmLCBob3N0LCBw
b3J0KToKKyAgICAgICAgIiIiQ3JlYXRlcyBhIGNsaWVudCB0aGF0IHdpbGwgY29ubmVjdCBvbiB0
aGUgZmlyc3QgdXNlLiIiIgorICAgICAgICBzZWxmLl9jb25uZWN0ZWQgPSBGYWxzZQorICAgICAg
ICBzZWxmLl9ob3N0ID0gaG9zdAorICAgICAgICBzZWxmLl9wb3J0ID0gcG9ydAorICAgICAgICBz
ZWxmLl9zb2NrZXQgPSBOb25lCisKKyAgICBkZWYgYWNjZXB0X2J5dGVzKHNlbGYsIGJ5dGVzKToK
KyAgICAgICAgIiIiU2VlIFNtYXJ0Q2xpZW50TWVkaXVtLmFjY2VwdF9ieXRlcy4iIiIKKyAgICAg
ICAgc2VsZi5fZW5zdXJlX2Nvbm5lY3Rpb24oKQorICAgICAgICBzZWxmLl9zb2NrZXQuc2VuZGFs
bChieXRlcykKKworICAgIGRlZiBkaXNjb25uZWN0KHNlbGYpOgorICAgICAgICAiIiJTZWUgU21h
cnRDbGllbnRNZWRpdW0uZGlzY29ubmVjdCgpLiIiIgorICAgICAgICBpZiBub3Qgc2VsZi5fY29u
bmVjdGVkOgorICAgICAgICAgICAgcmV0dXJuCisgICAgICAgIHNlbGYuX3NvY2tldC5jbG9zZSgp
CisgICAgICAgIHNlbGYuX3NvY2tldCA9IE5vbmUKKyAgICAgICAgc2VsZi5fY29ubmVjdGVkID0g
RmFsc2UKKworICAgIGRlZiBfZW5zdXJlX2Nvbm5lY3Rpb24oc2VsZik6CisgICAgICAgICIiIkNv
bm5lY3QgdGhpcyBtZWRpdW0gaWYgbm90IGFscmVhZHkgY29ubmVjdGVkLiIiIgorICAgICAgICBp
ZiBzZWxmLl9jb25uZWN0ZWQ6CisgICAgICAgICAgICByZXR1cm4KICAgICAgICAgc2VsZi5fc29j
a2V0ID0gc29ja2V0LnNvY2tldCgpCiAgICAgICAgIHNlbGYuX3NvY2tldC5zZXRzb2Nrb3B0KHNv
Y2tldC5JUFBST1RPX1RDUCwgc29ja2V0LlRDUF9OT0RFTEFZLCAxKQogICAgICAgICByZXN1bHQg
PSBzZWxmLl9zb2NrZXQuY29ubmVjdF9leCgoc2VsZi5faG9zdCwgaW50KHNlbGYuX3BvcnQpKSkK
ICAgICAgICAgaWYgcmVzdWx0OgogICAgICAgICAgICAgcmFpc2UgZXJyb3JzLkNvbm5lY3Rpb25F
cnJvcigiZmFpbGVkIHRvIGNvbm5lY3QgdG8gJXM6JWQ6ICVzIiAlCiAgICAgICAgICAgICAgICAg
ICAgIChzZWxmLl9ob3N0LCBzZWxmLl9wb3J0LCBvcy5zdHJlcnJvcihyZXN1bHQpKSkKLSAgICAg
ICAgIyBUT0RPOiBNYXkgYmUgbW9yZSBlZmZpY2llbnQgdG8ganVzdCB0cmVhdCB0aGVtIGFzIHNv
Y2tldHMKLSAgICAgICAgIyB0aHJvdWdob3V0PyAgQnV0IHdoYXQgYWJvdXQgcGlwZXMgdG8gc3No
Py4uLgotICAgICAgICB0b19zZXJ2ZXIgPSBzZWxmLl9zb2NrZXQubWFrZWZpbGUoJ3cnKQotICAg
ICAgICBmcm9tX3NlcnZlciA9IHNlbGYuX3NvY2tldC5tYWtlZmlsZSgncicpCi0gICAgICAgIHJl
dHVybiBmcm9tX3NlcnZlciwgdG9fc2VydmVyCi0KLSAgICBkZWYgZGlzY29ubmVjdChzZWxmKToK
LSAgICAgICAgc3VwZXIoU21hcnRUQ1BUcmFuc3BvcnQsIHNlbGYpLmRpc2Nvbm5lY3QoKQotICAg
ICAgICAjIFhYWDogSXMgY2xvc2luZyB0aGUgc29ja2V0IGFzIHdlbGwgYXMgY2xvc2luZyB0aGUg
ZmlsZXMgcmVhbGx5Ci0gICAgICAgICMgbmVjZXNzYXJ5PwotICAgICAgICBpZiBzZWxmLl9zb2Nr
ZXQgaXMgbm90IE5vbmU6Ci0gICAgICAgICAgICBzZWxmLl9zb2NrZXQuY2xvc2UoKQorICAgICAg
ICBzZWxmLl9jb25uZWN0ZWQgPSBUcnVlCisKKyAgICBkZWYgcmVhZF9ieXRlcyhzZWxmLCBjb3Vu
dCk6CisgICAgICAgICIiIlNlZSBTbWFydENsaWVudE1lZGl1bS5yZWFkX2J5dGVzLiIiIgorICAg
ICAgICByYWlzZSBlcnJvcnMuTWVkaXVtTm90Q29ubmVjdGVkKHNlbGYpCisKKyAgICBkZWYgX3Jl
Y3ZfYnVsayhzZWxmKToKKyAgICAgICAgIiIidHJhbnNpdGlvbmFsIGFwaSBmcm9tICdjbGllbnQn
IHRvICdtZWRpdW0nLiIiIgorICAgICAgICBzZWxmLl9pbiA9IHNlbGYuX3NvY2tldC5tYWtlZmls
ZSgncicsIDApCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHJldHVybiBTbWFydFN0cmVhbU1l
ZGl1bUNsaWVudC5fcmVjdl9idWxrKHNlbGYpCisgICAgICAgIGZpbmFsbHk6CisgICAgICAgICAg
ICBzZWxmLl9pbiA9IE5vbmUKKworICAgIGRlZiBfcmVjdl90dXBsZShzZWxmKToKKyAgICAgICAg
IiIidHJhbnNpdGlvbmFsIGFwaSBmcm9tICdjbGllbnQnIHRvICdtZWRpdW0nLiIiIgorICAgICAg
ICByZXR1cm4gX3JlY3ZfdHVwbGUoc2VsZi5fc29ja2V0Lm1ha2VmaWxlKCdyJywgMCkpCisKKyAg
ICBkZWYgX3dyaXRlX2FuZF9mbHVzaChzZWxmLCBieXRlcywgZmlsZT1Ob25lKToKKyAgICAgICAg
IiIiVGh1bmsgZnJvbSB0aGUgJ2NsaWVudCcgYXBpIHRvIHRoZSAnTWVkaXVtJyBhcGkuIiIiCisg
ICAgICAgIGFzc2VydCBmaWxlIGlzIE5vbmUKKyAgICAgICAgc2VsZi5hY2NlcHRfYnl0ZXMoYnl0
ZXMpCisKKworY2xhc3MgU21hcnRUQ1BUcmFuc3BvcnQoU21hcnRUcmFuc3BvcnQpOgorICAgICIi
IkNvbm5lY3Rpb24gdG8gc21hcnQgc2VydmVyIG92ZXIgcGxhaW4gdGNwLgorICAgIAorICAgIFRo
aXMgaXMgZXNzZW50aWFsbHkganVzdCBhIGZhY3RvcnkgdG8gZ2V0ICdSZW1vdGVUcmFuc3BvcnQo
dXJsLAorICAgICAgICBTbWFydFRDUENsaWVudE1lZGl1bSkuCisgICAgIiIiCisKKyAgICBkZWYg
X19pbml0X18oc2VsZiwgdXJsKToKKyAgICAgICAgX3NjaGVtZSwgX3VzZXJuYW1lLCBfcGFzc3dv
cmQsIF9ob3N0LCBfcG9ydCwgX3BhdGggPSBcCisgICAgICAgICAgICB0cmFuc3BvcnQuc3BsaXRf
dXJsKHVybCkKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgX3BvcnQgPSBpbnQoX3BvcnQpCisg
ICAgICAgIGV4Y2VwdCAoVmFsdWVFcnJvciwgVHlwZUVycm9yKSwgZToKKyAgICAgICAgICAgIHJh
aXNlIGVycm9ycy5JbnZhbGlkVVJMKHBhdGg9dXJsLCBleHRyYT0iaW52YWxpZCBwb3J0ICVzIiAl
IF9wb3J0KQorICAgICAgICBtZWRpdW0gPSBTbWFydFRDUENsaWVudE1lZGl1bShfaG9zdCwgX3Bv
cnQpCisgICAgICAgIHN1cGVyKFNtYXJ0VENQVHJhbnNwb3J0LCBzZWxmKS5fX2luaXRfXyh1cmws
IG1lZGl1bT1tZWRpdW0pCisKIAogdHJ5OgogICAgIGZyb20gYnpybGliLnRyYW5zcG9ydCBpbXBv
cnQgc2Z0cCwgc3NoCkBAIC0xMzA5LDMxICsxNDg5LDI3IEBACiAgICAgcGFzcwogZWxzZToKICAg
ICBjbGFzcyBTbWFydFNTSFRyYW5zcG9ydChTbWFydFRyYW5zcG9ydCk6Ci0gICAgICAgICIiIkNv
bm5lY3Rpb24gdG8gc21hcnQgc2VydmVyIG92ZXIgU1NILiIiIgotCi0gICAgICAgIGRlZiBfX2lu
aXRfXyhzZWxmLCB1cmwsIGNsb25lX2Zyb209Tm9uZSk6Ci0gICAgICAgICAgICAjIFRPRE86IGFs
bCB0aGlzIHByb2JhYmx5IGJlbG9uZ3MgaW4gdGhlIHBhcmVudCBjbGFzcy4KLSAgICAgICAgICAg
IHN1cGVyKFNtYXJ0U1NIVHJhbnNwb3J0LCBzZWxmKS5fX2luaXRfXyh1cmwsIGNsb25lX2Zyb20p
CisgICAgICAgICIiIkNvbm5lY3Rpb24gdG8gc21hcnQgc2VydmVyIG92ZXIgU1NILgorCisgICAg
ICAgIFRoaXMgaXMgZXNzZW50aWFsbHkganVzdCBhIGZhY3RvcnkgdG8gZ2V0ICdSZW1vdGVUcmFu
c3BvcnQodXJsLAorICAgICAgICAgICAgU21hcnRTU0hDbGllbnRNZWRpdW0pLgorICAgICAgICAi
IiIKKworICAgICAgICBkZWYgX19pbml0X18oc2VsZiwgdXJsKToKKyAgICAgICAgICAgIF9zY2hl
bWUsIF91c2VybmFtZSwgX3Bhc3N3b3JkLCBfaG9zdCwgX3BvcnQsIF9wYXRoID0gXAorICAgICAg
ICAgICAgICAgIHRyYW5zcG9ydC5zcGxpdF91cmwodXJsKQogICAgICAgICAgICAgdHJ5OgotICAg
ICAgICAgICAgICAgIGlmIHNlbGYuX3BvcnQgaXMgbm90IE5vbmU6Ci0gICAgICAgICAgICAgICAg
ICAgIHNlbGYuX3BvcnQgPSBpbnQoc2VsZi5fcG9ydCkKKyAgICAgICAgICAgICAgICBpZiBfcG9y
dCBpcyBub3QgTm9uZToKKyAgICAgICAgICAgICAgICAgICAgX3BvcnQgPSBpbnQoX3BvcnQpCiAg
ICAgICAgICAgICBleGNlcHQgKFZhbHVlRXJyb3IsIFR5cGVFcnJvciksIGU6Ci0gICAgICAgICAg
ICAgICAgcmFpc2UgZXJyb3JzLkludmFsaWRVUkwocGF0aD11cmwsIGV4dHJhPSJpbnZhbGlkIHBv
cnQgJXMiICUgc2VsZi5fcG9ydCkKLQotICAgICAgICBkZWYgX2Nvbm5lY3RfdG9fc2VydmVyKHNl
bGYpOgotICAgICAgICAgICAgZXhlY3V0YWJsZSA9IG9zLmVudmlyb24uZ2V0KCdCWlJfUkVNT1RF
X1BBVEgnLCAnYnpyJykKLSAgICAgICAgICAgIHZlbmRvciA9IHNzaC5fZ2V0X3NzaF92ZW5kb3Io
KQotICAgICAgICAgICAgc2VsZi5fc3NoX2Nvbm5lY3Rpb24gPSB2ZW5kb3IuY29ubmVjdF9zc2go
c2VsZi5fdXNlcm5hbWUsCi0gICAgICAgICAgICAgICAgICAgIHNlbGYuX3Bhc3N3b3JkLCBzZWxm
Ll9ob3N0LCBzZWxmLl9wb3J0LAotICAgICAgICAgICAgICAgICAgICBjb21tYW5kPVtleGVjdXRh
YmxlLCAnc2VydmUnLCAnLS1pbmV0JywgJy0tZGlyZWN0b3J5PS8nLAotICAgICAgICAgICAgICAg
ICAgICAgICAgICAgICAnLS1hbGxvdy13cml0ZXMnXSkKLSAgICAgICAgICAgIHJldHVybiBzZWxm
Ll9zc2hfY29ubmVjdGlvbi5nZXRfZmlsZWxpa2VfY2hhbm5lbHMoKQotCi0gICAgICAgIGRlZiBk
aXNjb25uZWN0KHNlbGYpOgotICAgICAgICAgICAgc3VwZXIoU21hcnRTU0hUcmFuc3BvcnQsIHNl
bGYpLmRpc2Nvbm5lY3QoKQotICAgICAgICAgICAgc2VsZi5fc3NoX2Nvbm5lY3Rpb24uY2xvc2Uo
KQorICAgICAgICAgICAgICAgIHJhaXNlIGVycm9ycy5JbnZhbGlkVVJMKHBhdGg9dXJsLCBleHRy
YT0iaW52YWxpZCBwb3J0ICVzIiAlIAorICAgICAgICAgICAgICAgICAgICBfcG9ydCkKKyAgICAg
ICAgICAgIG1lZGl1bSA9IFNtYXJ0U1NIQ2xpZW50TWVkaXVtKF9ob3N0LCBfcG9ydCwgX3VzZXJu
YW1lLCBfcGFzc3dvcmQpCisgICAgICAgICAgICBzdXBlcihTbWFydFNTSFRyYW5zcG9ydCwgc2Vs
ZikuX19pbml0X18odXJsLCBtZWRpdW09bWVkaXVtKQogCiAKIGRlZiBnZXRfdGVzdF9wZXJtdXRh
dGlvbnMoKToKLSAgICAiIiJSZXR1cm4gKHRyYW5zcG9ydCwgc2VydmVyKSBwZXJtdXRhdGlvbnMg
Zm9yIHRlc3RpbmciIiIKKyAgICAiIiJSZXR1cm4gKHRyYW5zcG9ydCwgc2VydmVyKSBwZXJtdXRh
dGlvbnMgZm9yIHRlc3RpbmcuIiIiCisgICAgIyMjIFdlIG1heSBuZWVkIGEgbGl0dGxlIG1vcmUg
dGVzdCBmcmFtZXdvcmsgc3VwcG9ydCB0byBjb25zdHJ1Y3QgYW4KKyAgICAjIyMgYXBwcm9wcmlh
dGUgUmVtb3RlVHJhbnNwb3J0IGluIHRoZSBmdXR1cmUuCiAgICAgcmV0dXJuIFsoU21hcnRUQ1BU
cmFuc3BvcnQsIFNtYXJ0VENQU2VydmVyX2Zvcl90ZXN0aW5nKV0KCg==
# revision id: andrew.bennetts at canonical.com-20060921091520-673c55c101a86614
# sha1: d8cfd37e2501a9d812b06bcfb204eb540b8daeee
# inventory sha1: bc0bd557b2017ba839bbd8c47117425984ca65fc
# parent ids:
# andrew.bennetts at canonical.com-20060919111846-9853422711c0d27c
# properties:
# branch-nick: hpss HTTP support
# message:
# Implement HTTP smart server.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2006-09-19 21:18:46.358999968 +1000
=== modified file BRANCH.TODO // encoding:base64
LS0tIEJSQU5DSC5UT0RPCisrKyBCUkFOQ0guVE9ETwpAQCAtMiwzICsyLDI3IEBACiAjIEl0IHNo
b3VsZCBBTFdBWVMgYmUgZW1wdHkgaW4gdGhlIG1haW5saW5lIG9yIGluIGludGVncmF0aW9uIGJy
YW5jaGVzLgogIyAKIAorV2FudCB0byBiZSBhYmxlIHRvIHR1bm5lbCBzbWFydCBjbGllbnQgcmVx
dWVzdHMgb3ZlciBIVFRQCisKK1dhbnQgdG8gYmUgYWJsZSB0byBnZXQgYSBzbWFydCBjbGllbnQg
Z2VuZXJpY2FsbHkgdG8gdHJ5IHVwZ3JhZGUgYSByZWFkLW9ubHkKK3RyYW5zcG9ydCB0byByZWFk
LXdyaXRlLgorCitXZSBzaG91bGQgYmUgYWJsZSB0byBpbnN0YW50aWF0ZSBhIHNtYXJ0IHNlcnZl
ciBpbiBhIGRpcmVjdG9yeSB0aGF0IGRvZXMgbm90CitleGlzdCAob3ZlciBIVFRQKS4KKworV2Ug
c2hvdWxkIGJlIGFibGUgdG8gaGFuZGxlIGNodW5rZWQgdXBsb2Fkcy4gIEhUVFAgMS4wIG11c3Qg
aGF2ZSBDb250ZW50LWxlbmd0aC4gIDEuMQorbXVzdCBoYXZlIENvbnRlbnQtbGVuZ3RoIG9yIGJl
IGEgY2h1bmtlZCB1cGxvYWQuICBTbywgdG8gYWxsb3cgc3RyZWFtaW5nIGZyb20KK3RoZSBjbGll
bnQsIHdlIG11c3QgZG8gMS4xIHdpdGggY2h1bmtlZCBQT1NUIGJvZGllcy4gIFNwZWNpZmljIHRl
c3QgdG8gd3JpdGUgaXMKK3RoYXQgd2UgZG8gbm90IG92ZXItcmVhZCB3aGVuIHJlYWRpbmcgY2h1
bmtlZCByZXF1ZXN0cy4gIAorCitDaHVua2VkIGRvd25sb2Fkcy4gIDEuMCBhbGxvd3Mgbm8gQ29u
dGVudC1sZW5ndGgsIGJ1dCBmb3IgaW50ZWdyaXR5IHdlIHNob3VsZAorcGVyZm9ybSBvdXIgb3du
IGNodW5raW5nLiAgMS4xIGFsbG93cyBjaHVua2VkIHJlc3BvbnNlcywgYW5kIGluIHRoaXMgY2Fz
ZSB3ZQorc2hvdWxkIGNodW5rIHVzaW5nIHRoZSBIVFRQIGNodW5raW5nIGFzIHRoaXMgd2lsbCBh
bGxvdyBIVFRQIHBlcnNpc3RlbnQgc2FmZWx5LAorZXZlbiBpZiB3ZSBoYXZlIHRvIHN0b3AgZWFy
bHkgZHVlIHRvIGVycm9yLgorCitzbWFydCBzZXJ2ZXIgcmVxdWVzdCBwcm90b2NvbCBhY2NlcHQg
Ynl0ZXMgYWZ0ZXIgZmlyc3QgXG4gZXh0cmEgYnl0ZXMuCisKKworc21hcnQgc2VydmVyIHByb3Rv
Y29sIG5lZWRzIGFuIG9wdGlvbmFsIGVuZF9vZl9ieXRlcyBjYWxsIHRvIHRlbGwgaXQgdGhhdAor
c29tZXRoaW5nIGZpbmlzaGVkIGVhcmx5LiBJLmUuIGEgZ2V0IHVwbG9hZCB0aGF0IGZhaWxzIGJl
Y2F1c2UgdGhlIHRjcAorY29ubmVjdGlvbiByZXNldHMuCgo=
=== modified file bzrlib/builtins.py // encoding:base64
LS0tIGJ6cmxpYi9idWlsdGlucy5weQorKysgYnpybGliL2J1aWx0aW5zLnB5CkBAIC0yODE0LDcg
KzI4MTQsNyBAQAogICAgICAgICAgICAgdXJsID0gJ3JlYWRvbmx5KycgKyB1cmwKICAgICAgICAg
dCA9IGdldF90cmFuc3BvcnQodXJsKQogICAgICAgICBpZiBpbmV0OgotICAgICAgICAgICAgc2Vy
dmVyID0gc21hcnQuU21hcnRTdHJlYW1TZXJ2ZXIoc3lzLnN0ZGluLCBzeXMuc3Rkb3V0LCB0KQor
ICAgICAgICAgICAgc2VydmVyID0gc21hcnQuU21hcnRTZXJ2ZXJTdHJlYW1NZWRpdW0oc3lzLnN0
ZGluLCBzeXMuc3Rkb3V0LCB0KQogICAgICAgICBlbGlmIHBvcnQgaXMgbm90IE5vbmU6CiAgICAg
ICAgICAgICBpZiAnOicgaW4gcG9ydDoKICAgICAgICAgICAgICAgICBob3N0LCBwb3J0ID0gcG9y
dC5zcGxpdCgnOicpCgo=
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/transport/http/__init__.py // encoding:base64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=== modified file bzrlib/transport/smart.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQucHkKKysrIGJ6cmxpYi90cmFuc3BvcnQvc21hcnQu
cHkKQEAgLTQ2LDYgKzQ2LDM2IEBACiBVUkxzIHRoYXQgaW5jbHVkZSB+IHNob3VsZCBwcm9iYWJs
eSBiZSBwYXNzZWQgYWNyb3NzIHRvIHRoZSBzZXJ2ZXIgdmVyYmF0aW0KIGFuZCB0aGUgc2VydmVy
IGNhbiBleHBhbmQgdGhlbS4gIFRoaXMgd2lsbCBwcm9hYmx5IG5vdCBiZSBtZWFuaW5nZnVsIHdo
ZW4gCiBsaW1pdGVkIHRvIGEgZGlyZWN0b3J5PworCitBdCB0aGUgYm90dG9tIGxldmVsIHNvY2tl
dCwgcGlwZXMsIEhUVFAgc2VydmVyLiAgRm9yIHNvY2tldHMsIHdlIGhhdmUgdGhlCitpZGVhIHRo
YXQgeW91IGhhdmUgbXVsdGlwbGUgcmVxdWVzdHMgYW5kIGdldCBoYXZlIGEgcmVhZCBlcnJvciBi
ZWNhdXNlIHRoZQorb3RoZXIgc2lkZSBkaWQgc2h1dGRvd24gc2Qgc2VuZC4gIEZvciBwaXBlcyB3
ZSBoYXZlIHJlYWQgcGlwZSB3aGljaCB3aWxsIGhhdmUgYQoremVybyByZWFkIHdoaWNoIG1hcmtz
IGVuZC1vZi1maWxlLiAgRm9yIEhUVFAgc2VydmVyIGVudmlyb25tZW50IHRoZXJlIGlzIG5vdAor
ZW5kLW9mLXN0cmVhbSBiZWNhdXNlIGVhY2ggcmVxdWVzdCBjb21pbmcgaW50byB0aGUgc2VydmVy
IGlzIGluZGVwZW5kZW50LgorCitTbyB3ZSBuZWVkIGEgd3JhcHBlciBhcm91bmQgcGlwZXMgYW5k
IHNvY2tldHMgdG8gc2VwZXJhdGUgb3V0IHJlcWV1c3RzIGZyb20KK3N1YnN0cmF0ZSBhbmQgdGhp
cyB3aWxsIGdpdmUgdXMgYSBzaW5nbGUgbW9kZWwgd2hpY2ggaXMgY29uc2lzdCBmb3IgSFRUUCwK
K3NvY2tldHMgYW5kIHBpcGVzLgorCisgV0lSRSAgICAoZmFjdG9yeSBmb3IgcHJvdG9jb2wsIHJl
YWRzIGJ5dGVzICYgcHVzaGVzIHRvIHByb3RvY29sLAorICAgICAgICAgIHVzZXMgcHJvdG9jb2wg
dG8gZGV0ZWN0IGVuZC1vZi1yZXF1ZXN0LCBzZW5kcyB3cml0dGVuCisgICAgICAgICAgYnl0ZXMg
dG8gY2xpZW50KSBlLmcuIHNvY2tldCwgcGlwZSwgSFRUUCByZXF1ZXN0IGhhbmRsZXIuCisgIF4K
KyAgfCBieXRlcy4KKyAgdgorCitQUk9UT0NPTCAgKHNlcmlhbGlzYXRpb24sIGRlc2VyaWFsaXNh
dGlvbikgIGFjY2VwdHMgYnl0ZXMgZm9yIG9uZQorICAgICAgICAgIHJlcXVlc3QsIGRlY29kZXMg
YWNjb3JkaW5nIHRvIGludGVybmFsIHN0YXRlLCBwdXNoZXMKKyAgICAgICAgICBzdHJ1Y3R1cmVk
IGRhdGEgdG8gaGFuZGxlci4gIGFjY2VwdHMgc3RydWN0dXJlZCBkYXRhIGZyb20KKyAgICAgICAg
ICBoYW5kbGVyIGFuZCBlbmNvZGVzIGFuZCB3cml0ZXMgdG8gdGhlIHdpcmUuICBmYWN0b3J5IGZv
cgorICAgICAgICAgIGhhbmRsZXIuCisgIF4KKyAgfCBzdHJ1Y3R1cmVkIGRhdGEKKyAgdgorCitI
QU5ETEVSICAgKGRvbWFpbiBsb2dpYykgYWNjZXB0cyBzdHJ1Y3R1cmVkIGRhdGEsIG9wZXJhdGVz
IHN0YXRlCisgICAgICAgICAgbWFjaGluZSB1bnRpbCB0aGUgcmVxdWVzdCBjYW4gYmUgc2F0aXNm
aWVkLAorICAgICAgICAgIHNlbmRzIHN0cnVjdHVyZWQgZGF0YSB0byB0aGUgcHJvdG9jb2wuCiAi
IiIKIAogCkBAIC0xMzcsNyArMTY3LDcgQEAKICMgICAgICAgdGhlIHNvY2tldCwgYW5kIGl0IGFz
c3VtZXMgZXZlcnl0aGluZyBpcyBVVEY4IHNlY3Rpb25zIHNlcGFyYXRlZAogIyAgICAgICBieSBc
MDAxLiBXaGljaCBtZWFucyBhIHJlcXVlc3QgbGlrZSAnXDAwMicgV2lsbCBhYm9ydCB0aGUgY29u
bmVjdGlvbgogIyAgICAgICBiZWNhdXNlIG9mIGEgVW5pY29kZURlY29kZUVycm9yLiBJdCBkb2Vz
IGxvb2sgbGlrZSBpbnZhbGlkIGRhdGEgd2lsbAotIyAgICAgICBraWxsIHRoZSBTbWFydFN0cmVh
bVNlcnZlciwgYnV0IG9ubHkgd2l0aCBhbiBhYm9ydCArIGV4Y2VwdGlvbiwgYW5kIAorIyAgICAg
ICBraWxsIHRoZSBTbWFydFNlcnZlclN0cmVhbU1lZGl1bSwgYnV0IG9ubHkgd2l0aCBhbiBhYm9y
dCArIGV4Y2VwdGlvbiwgYW5kIAogIyAgICAgICB0aGUgb3ZlcmFsbCBzZXJ2ZXIgc2hvdWxkbid0
IGRpZS4KIAogZnJvbSBjU3RyaW5nSU8gaW1wb3J0IFN0cmluZ0lPCkBAIC0xODksMTEgKzIxOSwx
MSBAQAogY2xhc3MgU21hcnRQcm90b2NvbEJhc2Uob2JqZWN0KToKICAgICAiIiJNZXRob2RzIGNv
bW1vbiB0byBjbGllbnQgYW5kIHNlcnZlciIiIgogCi0gICAgZGVmIF9zZW5kX2J1bGtfZGF0YShz
ZWxmLCBib2R5KToKKyAgICBkZWYgX3NlbmRfYnVsa19kYXRhKHNlbGYsIGJvZHksIGFfZmlsZT1O
b25lKToKICAgICAgICAgIiIiU2VuZCBjaHVua2VkIGJvZHkgZGF0YSIiIgogICAgICAgICBhc3Nl
cnQgaXNpbnN0YW5jZShib2R5LCBzdHIpCiAgICAgICAgIGJ5dGVzID0gJycuam9pbigoJyVkXG4n
ICUgbGVuKGJvZHkpLCBib2R5LCAnZG9uZVxuJykpCi0gICAgICAgIHNlbGYuX3dyaXRlX2FuZF9m
bHVzaChieXRlcykKKyAgICAgICAgc2VsZi5fd3JpdGVfYW5kX2ZsdXNoKGJ5dGVzLCBhX2ZpbGUp
CiAKICAgICAjIFRPRE86IHRoaXMgb25seSBhY3R1YWxseSBhY2NvbW9kYXRlcyBhIHNpbmdsZSBi
bG9jazsgcG9zc2libHkgc2hvdWxkIHN1cHBvcnQKICAgICAjIG11bHRpcGxlIGNodW5rcz8KQEAg
LTIyNiwxNCArMjU2LDE3MiBAQAogICAgICAgICAgICAgdHh0LmFwcGVuZCgnJWQsJWQnICUgKHN0
YXJ0LCBsZW5ndGgpKQogICAgICAgICByZXR1cm4gJ1xuJy5qb2luKHR4dCkKIAotICAgIGRlZiBf
d3JpdGVfYW5kX2ZsdXNoKHNlbGYsIGJ5dGVzKToKKyAgICBkZWYgX3dyaXRlX2FuZF9mbHVzaChz
ZWxmLCBieXRlcywgYV9maWxlPU5vbmUpOgogICAgICAgICAiIiJXcml0ZSBieXRlcyB0byBzZWxm
Ll9vdXQgYW5kIGZsdXNoIGl0LiIiIgogICAgICAgICAjIFhYWDogdGhpcyB3aWxsIGJlIGluZWZm
aWNpZW50LiAgSnVzdCBhc2sgUm9iZXJ0LgotICAgICAgICBzZWxmLl9vdXQud3JpdGUoYnl0ZXMp
Ci0gICAgICAgIHNlbGYuX291dC5mbHVzaCgpCi0KLQotY2xhc3MgU21hcnRTdHJlYW1TZXJ2ZXIo
U21hcnRQcm90b2NvbEJhc2UpOgorICAgICAgICBpZiBhX2ZpbGUgaXMgTm9uZToKKyAgICAgICAg
ICAgIGFfZmlsZSA9IHNlbGYuX291dAorICAgICAgICBhX2ZpbGUud3JpdGUoYnl0ZXMpCisgICAg
ICAgIGFfZmlsZS5mbHVzaCgpCisKKworY2xhc3MgU21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xP
bmUoU21hcnRQcm90b2NvbEJhc2UpOgorICAgICIiIlNlcnZlci1zaWRlIGVuY29kaW5nIGFuZCBk
ZWNvZGluZyBsb2dpYyBmb3Igc21hcnQgdmVyc2lvbiAxLiIiIgorICAgIAorICAgIGRlZiBfX2lu
aXRfXyhzZWxmLCBvdXRwdXRfc3RyZWFtLCBiYWNraW5nX3RyYW5zcG9ydCk6CisgICAgICAgIHNl
bGYuX291dF9zdHJlYW0gPSBvdXRwdXRfc3RyZWFtCisgICAgICAgIHNlbGYuX2JhY2tpbmdfdHJh
bnNwb3J0ID0gYmFja2luZ190cmFuc3BvcnQKKyAgICAgICAgc2VsZi5maW5pc2hlZF9yZWFkaW5n
ID0gRmFsc2UKKyAgICAgICAgc2VsZi5pbl9idWZmZXIgPSAnJworICAgICAgICBzZWxmLmhhc19k
aXNwYXRjaGVkID0gRmFsc2UKKyAgICAgICAgc2VsZi5yZXF1ZXN0ID0gTm9uZQorICAgICAgICBz
ZWxmLl9ib2R5X2RlY29kZXIgPSBOb25lCisKKyAgICBkZWYgYWNjZXB0X2J5dGVzKHNlbGYsIGJ5
dGVzKToKKyAgICAgICAgIiIiVGFrZSBieXRlcywgYW5kIGFkdmFuY2UgdGhlIGludGVybmFsIHN0
YXRlIG1hY2hpbmUgYXBwcm9wcmlhdGVseS4KKyAgICAgICAgCisgICAgICAgIDpwYXJhbSBieXRl
czogbXVzdCBiZSBhIGJ5dGUgc3RyaW5nCisgICAgICAgICIiIgorICAgICAgICBhc3NlcnQgaXNp
bnN0YW5jZShieXRlcywgc3RyKQorICAgICAgICBzZWxmLmluX2J1ZmZlciArPSBieXRlcworICAg
ICAgICBpZiBub3Qgc2VsZi5oYXNfZGlzcGF0Y2hlZDoKKyAgICAgICAgICAgIGlmICdcbicgbm90
IGluIHNlbGYuaW5fYnVmZmVyOgorICAgICAgICAgICAgICAgICMgbm8gY29tbWFuZCBsaW5lIHll
dAorICAgICAgICAgICAgICAgIHJldHVybgorICAgICAgICAgICAgc2VsZi5oYXNfZGlzcGF0Y2hl
ZCA9IFRydWUKKyAgICAgICAgICAgICMgWFhYIGlmIGluX2J1ZmZlciBub3QgXG4tdGVybWluYXRl
ZCB0aGlzIHdpbGwgZG8gdGhlIHdyb25nCisgICAgICAgICAgICAjIHRoaW5nLgorICAgICAgICAg
ICAgdHJ5OgorICAgICAgICAgICAgICAgIGFzc2VydCBzZWxmLmluX2J1ZmZlci5lbmRzd2l0aCgn
XG4nKQorICAgICAgICAgICAgICAgIHJlcV9hcmdzID0gX2RlY29kZV90dXBsZShzZWxmLmluX2J1
ZmZlcikKKyAgICAgICAgICAgICAgICBzZWxmLmluX2J1ZmZlciA9ICcnCisgICAgICAgICAgICAg
ICAgc2VsZi5yZXF1ZXN0ID0gU21hcnRTZXJ2ZXJSZXF1ZXN0SGFuZGxlcigKKyAgICAgICAgICAg
ICAgICAgICAgc2VsZi5fYmFja2luZ190cmFuc3BvcnQpCisgICAgICAgICAgICAgICAgc2VsZi5y
ZXF1ZXN0LmRpc3BhdGNoX2NvbW1hbmQocmVxX2FyZ3NbMF0sIHJlcV9hcmdzWzE6XSkKKyAgICAg
ICAgICAgICAgICBpZiBzZWxmLnJlcXVlc3QuZmluaXNoZWRfcmVhZGluZzoKKyAgICAgICAgICAg
ICAgICAgICAgIyB0cml2aWFsIHJlcXVlc3QKKyAgICAgICAgICAgICAgICAgICAgc2VsZi5fc2Vu
ZF9yZXNwb25zZShzZWxmLnJlcXVlc3QucmVzcG9uc2UuYXJncywKKyAgICAgICAgICAgICAgICAg
ICAgICAgIHNlbGYucmVxdWVzdC5yZXNwb25zZS5ib2R5KQorICAgICAgICAgICAgICAgIHNlbGYu
c3luY193aXRoX3JlcXVlc3Qoc2VsZi5yZXF1ZXN0KQorICAgICAgICAgICAgICAgIHJldHVybiBz
ZWxmLnJlcXVlc3QKKyAgICAgICAgICAgIGV4Y2VwdCBLZXlib2FyZEludGVycnVwdDoKKyAgICAg
ICAgICAgICAgICByYWlzZQorICAgICAgICAgICAgZXhjZXB0IEV4Y2VwdGlvbiwgZXhjZXB0aW9u
OgorICAgICAgICAgICAgICAgICMgZXZlcnl0aGluZyBlbHNlOiBwYXNzIHRvIGNsaWVudCwgZmx1
c2gsIGFuZCBxdWl0CisgICAgICAgICAgICAgICAgc2VsZi5fc2VuZF9yZXNwb25zZSgoJ2Vycm9y
Jywgc3RyKGV4Y2VwdGlvbikpKQorICAgICAgICAgICAgICAgIHJldHVybiBOb25lCisKKyAgICAg
ICAgZWxzZToKKyAgICAgICAgICAgIGlmIHNlbGYuZmluaXNoZWRfcmVhZGluZzoKKyAgICAgICAg
ICAgICAgICAjIG5vdGhpbmcgdG8gZG8uWFhYOiB0aGlzIHJvdXRpbmUgc2hvdWxkIGJlIGEgc2lu
Z2xlIHN0YXRlIAorICAgICAgICAgICAgICAgICMgbWFjaGluZSB0b28uCisgICAgICAgICAgICAg
ICAgcmV0dXJuCisgICAgICAgICAgICBpZiBzZWxmLl9ib2R5X2RlY29kZXIgaXMgTm9uZToKKyAg
ICAgICAgICAgICAgICBzZWxmLl9ib2R5X2RlY29kZXIgPSBMZW5ndGhQcmVmaXhlZEJvZHlEZWNv
ZGVyKCkKKyAgICAgICAgICAgIHNlbGYuX2JvZHlfZGVjb2Rlci5hY2NlcHRfYnl0ZXMoc2VsZi5p
bl9idWZmZXIpCisgICAgICAgICAgICBzZWxmLmluX2J1ZmZlciA9IHNlbGYuX2JvZHlfZGVjb2Rl
ci51bnVzZWRfZGF0YQorICAgICAgICAgICAgYm9keV9kYXRhID0gc2VsZi5fYm9keV9kZWNvZGVy
LnJlYWRfcGVuZGluZ19kYXRhKCkKKyAgICAgICAgICAgIHNlbGYucmVxdWVzdC5hY2NlcHRfYm9k
eShib2R5X2RhdGEpCisgICAgICAgICAgICBpZiBzZWxmLl9ib2R5X2RlY29kZXIuZmluaXNoZWRf
cmVhZGluZzoKKyAgICAgICAgICAgICAgICBzZWxmLnJlcXVlc3QuZW5kX29mX2JvZHkoKQorICAg
ICAgICAgICAgICAgIGFzc2VydCBzZWxmLnJlcXVlc3QuZmluaXNoZWRfcmVhZGluZywgXAorICAg
ICAgICAgICAgICAgICAgICAibm8gbW9yZSBib2R5LCByZXF1ZXN0IG5vdCBmaW5pc2hlZCIKKyAg
ICAgICAgICAgIHNlbGYuc3luY193aXRoX3JlcXVlc3Qoc2VsZi5yZXF1ZXN0KQorICAgICAgICAg
ICAgaWYgc2VsZi5yZXF1ZXN0LnJlc3BvbnNlIGlzIG5vdCBOb25lOgorICAgICAgICAgICAgICAg
IHNlbGYuX3NlbmRfcmVzcG9uc2Uoc2VsZi5yZXF1ZXN0LnJlc3BvbnNlLmFyZ3MsCisgICAgICAg
ICAgICAgICAgICAgIHNlbGYucmVxdWVzdC5yZXNwb25zZS5ib2R5KQorICAgICAgICAgICAgZWxz
ZToKKyAgICAgICAgICAgICAgICBhc3NlcnQgbm90IHNlbGYucmVxdWVzdC5maW5pc2hlZF9yZWFk
aW5nLCBcCisgICAgICAgICAgICAgICAgICAgICJubyByZXNwb25zZSBhbmQgd2UgaGF2ZSBmaW5p
c2hlZCByZWFkaW5nLiIKKworICAgIGRlZiBfc2VuZF9yZXNwb25zZShzZWxmLCBhcmdzLCBib2R5
PU5vbmUpOgorICAgICAgICAiIiJTZW5kIGEgc21hcnQgc2VydmVyIHJlc3BvbnNlIGRvd24gdGhl
IG91dHB1dCBzdHJlYW0uIiIiCisgICAgICAgIHNlbGYuX291dF9zdHJlYW0ud3JpdGUoX2VuY29k
ZV90dXBsZShhcmdzKSkKKyAgICAgICAgaWYgYm9keSBpcyBOb25lOgorICAgICAgICAgICAgc2Vs
Zi5fb3V0X3N0cmVhbS5mbHVzaCgpCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBzZWxmLl9z
ZW5kX2J1bGtfZGF0YShib2R5LCBzZWxmLl9vdXRfc3RyZWFtKQorICAgICAgICAgICAgI3NlbGYu
X291dF9zdHJlYW0ud3JpdGUoJ0JMQVJHSCcpCisKKyAgICBkZWYgc3luY193aXRoX3JlcXVlc3Qo
c2VsZiwgcmVxdWVzdCk6CisgICAgICAgIHNlbGYuZmluaXNoZWRfcmVhZGluZyA9IHJlcXVlc3Qu
ZmluaXNoZWRfcmVhZGluZworICAgICAgICAKKyAgICAgICAgCitjbGFzcyBMZW5ndGhQcmVmaXhl
ZEJvZHlEZWNvZGVyKG9iamVjdCk6CisgICAgIiIiRGVjb2RlcyB0aGUgbGVuZ3RoLXByZWZpeGVk
IGJ1bGsgZGF0YS4iIiIKKyAgICAKKyAgICBkZWYgX19pbml0X18oc2VsZik6CisgICAgICAgIHNl
bGYuZmluaXNoZWRfcmVhZGluZyA9IEZhbHNlCisgICAgICAgIHNlbGYudW51c2VkX2RhdGEgPSAn
JworICAgICAgICBzZWxmLnN0YXRlX2FjY2VwdCA9IHNlbGYuX3N0YXRlX2FjY2VwdF9leHBlY3Rp
bmdfbGVuZ3RoCisgICAgICAgIHNlbGYuc3RhdGVfcmVhZCA9IHNlbGYuX3N0YXRlX3JlYWRfbm9f
ZGF0YQorICAgICAgICBzZWxmLl9pbl9idWZmZXIgPSAnJworICAgICAgICBzZWxmLl90cmFpbGVy
X2J1ZmZlciA9ICcnCisgICAgCisgICAgZGVmIGFjY2VwdF9ieXRlcyhzZWxmLCBieXRlcyk6Cisg
ICAgICAgICIiIkRlY29kZSBhcyBtdWNoIG9mIGJ5dGVzIGFzIHBvc3NpYmxlLgorCisgICAgICAg
IElmICdieXRlcycgY29udGFpbnMgdG9vIG11Y2ggZGF0YSBpdCB3aWxsIGJlIGFwcGVuZGVkIHRv
CisgICAgICAgIHNlbGYudW51c2VkX2RhdGEuCisKKyAgICAgICAgZmluaXNoZWRfcmVhZGluZyB3
aWxsIGJlIHNldCB3aGVuIG5vIG1vcmUgZGF0YSBpcyByZXF1aXJlZC4gIEZ1cnRoZXIKKyAgICAg
ICAgZGF0YSB3aWxsIGJlIGFwcGVuZGVkIHRvIHNlbGYudW51c2VkX2RhdGEuCisgICAgICAgICIi
IgorICAgICAgICAjIGFjY2VwdF9ieXRlcyBpcyBhbGxvd2VkIHRvIGNoYW5nZSB0aGUgc3RhdGUK
KyAgICAgICAgY3VycmVudF9zdGF0ZSA9IHNlbGYuc3RhdGVfYWNjZXB0CisgICAgICAgIHNlbGYu
c3RhdGVfYWNjZXB0KGJ5dGVzKQorICAgICAgICB3aGlsZSBjdXJyZW50X3N0YXRlICE9IHNlbGYu
c3RhdGVfYWNjZXB0OgorICAgICAgICAgICAgY3VycmVudF9zdGF0ZSA9IHNlbGYuc3RhdGVfYWNj
ZXB0CisgICAgICAgICAgICBzZWxmLnN0YXRlX2FjY2VwdCgnJykKKworICAgIGRlZiByZWFkX3Bl
bmRpbmdfZGF0YShzZWxmKToKKyAgICAgICAgIiIiUmV0dXJuIGFueSBwZW5kaW5nIGRhdGEgdGhh
dCBoYXMgYmVlbiBkZWNvZGVkLiIiIgorICAgICAgICByZXR1cm4gc2VsZi5zdGF0ZV9yZWFkKCkK
KworICAgIGRlZiBfc3RhdGVfYWNjZXB0X2V4cGVjdGluZ19sZW5ndGgoc2VsZiwgYnl0ZXMpOgor
ICAgICAgICBzZWxmLl9pbl9idWZmZXIgKz0gYnl0ZXMKKyAgICAgICAgcG9zID0gc2VsZi5faW5f
YnVmZmVyLmZpbmQoJ1xuJykKKyAgICAgICAgaWYgcG9zID09IC0xOgorICAgICAgICAgICAgcmV0
dXJuCisgICAgICAgIHNlbGYuYnl0ZXNfbGVmdCA9IGludChzZWxmLl9pbl9idWZmZXJbOnBvc10p
CisgICAgICAgIHNlbGYuX2luX2J1ZmZlciA9IHNlbGYuX2luX2J1ZmZlcltwb3MrMTpdCisgICAg
ICAgIHNlbGYuYnl0ZXNfbGVmdCAtPSBsZW4oc2VsZi5faW5fYnVmZmVyKQorICAgICAgICBzZWxm
LnN0YXRlX2FjY2VwdCA9IHNlbGYuX3N0YXRlX2FjY2VwdF9yZWFkaW5nX2JvZHkKKyAgICAgICAg
c2VsZi5zdGF0ZV9yZWFkID0gc2VsZi5fc3RhdGVfcmVhZF9pbl9idWZmZXIKKworICAgIGRlZiBf
c3RhdGVfYWNjZXB0X3JlYWRpbmdfYm9keShzZWxmLCBieXRlcyk6CisgICAgICAgIHNlbGYuX2lu
X2J1ZmZlciArPSBieXRlcworICAgICAgICBzZWxmLmJ5dGVzX2xlZnQgLT0gbGVuKGJ5dGVzKQor
ICAgICAgICBpZiBzZWxmLmJ5dGVzX2xlZnQgPD0gMDoKKyAgICAgICAgICAgICMgRmluaXNoZWQg
d2l0aCBib2R5CisgICAgICAgICAgICBpZiBzZWxmLmJ5dGVzX2xlZnQgIT0gMDoKKyAgICAgICAg
ICAgICAgICBzZWxmLl90cmFpbGVyX2J1ZmZlciA9IHNlbGYuX2luX2J1ZmZlcltzZWxmLmJ5dGVz
X2xlZnQ6XQorICAgICAgICAgICAgICAgIHNlbGYuX2luX2J1ZmZlciA9IHNlbGYuX2luX2J1ZmZl
cls6c2VsZi5ieXRlc19sZWZ0XQorICAgICAgICAgICAgc2VsZi5zdGF0ZV9hY2NlcHQgPSBzZWxm
Ll9zdGF0ZV9hY2NlcHRfcmVhZGluZ190cmFpbGVyCisgICAgICAgIAorICAgIGRlZiBfc3RhdGVf
YWNjZXB0X3JlYWRpbmdfdHJhaWxlcihzZWxmLCBieXRlcyk6CisgICAgICAgIHNlbGYuX3RyYWls
ZXJfYnVmZmVyICs9IGJ5dGVzCisgICAgICAgIGlmIHNlbGYuX3RyYWlsZXJfYnVmZmVyLnN0YXJ0
c3dpdGgoJ2RvbmVcbicpOgorICAgICAgICAgICAgc2VsZi51bnVzZWRfZGF0YSA9IHNlbGYuX3Ry
YWlsZXJfYnVmZmVyW2xlbignZG9uZVxuJyk6XQorICAgICAgICAgICAgc2VsZi5zdGF0ZV9hY2Nl
cHQgPSBzZWxmLl9zdGF0ZV9hY2NlcHRfcmVhZGluZ191bnVzZWQKKyAgICAgICAgICAgIHNlbGYu
ZmluaXNoZWRfcmVhZGluZyA9IFRydWUKKyAgICAKKyAgICBkZWYgX3N0YXRlX2FjY2VwdF9yZWFk
aW5nX3VudXNlZChzZWxmLCBieXRlcyk6CisgICAgICAgIHNlbGYudW51c2VkX2RhdGEgKz0gYnl0
ZXMKKworICAgIGRlZiBfc3RhdGVfcmVhZF9ub19kYXRhKHNlbGYpOgorICAgICAgICByZXR1cm4g
JycKKworICAgIGRlZiBfc3RhdGVfcmVhZF9pbl9idWZmZXIoc2VsZik6CisgICAgICAgIHJlc3Vs
dCA9IHNlbGYuX2luX2J1ZmZlcgorICAgICAgICBzZWxmLl9pbl9idWZmZXIgPSAnJworICAgICAg
ICByZXR1cm4gcmVzdWx0CisgICAgICAgICAgICAKKyAgICAgICAgCisKKyAgICAgICAgCisKK2Ns
YXNzIFNtYXJ0U2VydmVyU3RyZWFtTWVkaXVtKFNtYXJ0UHJvdG9jb2xCYXNlKToKICAgICAiIiJI
YW5kbGVzIHNtYXJ0IGNvbW1hbmRzIGNvbWluZyBvdmVyIGEgc3RyZWFtLgogCiAgICAgVGhlIHN0
cmVhbSBtYXkgYmUgYSBwaXBlIGNvbm5lY3RlZCB0byBzc2hkLCBvciBhIHRjcCBzb2NrZXQsIG9y
IGFuCkBAIC0yNTUsMjMgKzQ0MywyMyBAQAogICAgICAgICAiIiIKICAgICAgICAgc2VsZi5faW4g
PSBpbl9maWxlCiAgICAgICAgIHNlbGYuX291dCA9IG91dF9maWxlCi0gICAgICAgIHNlbGYuc21h
cnRfc2VydmVyID0gU21hcnRTZXJ2ZXIoYmFja2luZ190cmFuc3BvcnQpCi0gICAgICAgICMgc2Vy
dmVyIGNhbiBjYWxsIGJhY2sgdG8gdXMgdG8gZ2V0IGJ1bGsgZGF0YSAtIHRoaXMgaXMgbm90IHJl
YWxseQotICAgICAgICAjIGlkZWFsLCB0aGV5IHNob3VsZCBnZXQgaXQgcGVyIHJlcXVlc3QgaW5z
dGVhZAotICAgICAgICBzZWxmLnNtYXJ0X3NlcnZlci5fcmVjdl9ib2R5ID0gc2VsZi5fcmVjdl9i
dWxrCisgICAgICAgIHNlbGYuYmFja2luZ190cmFuc3BvcnQgPSBiYWNraW5nX3RyYW5zcG9ydAog
CiAgICAgZGVmIF9yZWN2X3R1cGxlKHNlbGYpOgogICAgICAgICAiIiJSZWFkIGEgcmVxdWVzdCBm
cm9tIHRoZSBjbGllbnQgYW5kIHJldHVybiBhcyBhIHR1cGxlLgogICAgICAgICAKICAgICAgICAg
UmV0dXJucyBOb25lIGF0IGVuZCBvZiBmaWxlIChpZiB0aGUgY2xpZW50IGNsb3NlZCB0aGUgY29u
bmVjdGlvbi4pCiAgICAgICAgICIiIgorICAgICAgICAjICoqIERlc2VyaWFsaXNlIGFuZCByZWFk
IGJ5dGVzCiAgICAgICAgIHJldHVybiBfcmVjdl90dXBsZShzZWxmLl9pbikKIAogICAgIGRlZiBf
c2VuZF90dXBsZShzZWxmLCBhcmdzKToKICAgICAgICAgIiIiU2VuZCByZXNwb25zZSBoZWFkZXIi
IiIKKyAgICAgICAgIyAqKiBzZXJpYWxpc2UgYW5kIHdyaXRlIGJ5dGVzCiAgICAgICAgIHJldHVy
biBzZWxmLl93cml0ZV9hbmRfZmx1c2goX2VuY29kZV90dXBsZShhcmdzKSkKIAogICAgIGRlZiBf
c2VuZF9lcnJvcl9hbmRfZGlzY29ubmVjdChzZWxmLCBleGNlcHRpb24pOgorICAgICAgICAjICoq
IHNlcmlhbGlzZSBhbmQgd3JpdGUgYnl0ZXMKICAgICAgICAgc2VsZi5fc2VuZF90dXBsZSgoJ2Vy
cm9yJywgc3RyKGV4Y2VwdGlvbikpKQogICAgICAgICAjIyBzZWxmLl9vdXQuY2xvc2UoKQogICAg
ICAgICAjIyBzZWxmLl9pbi5jbG9zZSgpCkBAIC0yODEsMTUgKzQ2OSwyOCBAQAogICAgICAgICAK
ICAgICAgICAgOnJldHVybjogRmFsc2UgaWYgdGhlIHNlcnZlciBzaG91bGQgdGVybWluYXRlLCBv
dGhlcndpc2UgTm9uZS4KICAgICAgICAgIiIiCi0gICAgICAgIHJlcV9hcmdzID0gc2VsZi5fcmVj
dl90dXBsZSgpCi0gICAgICAgIGlmIHJlcV9hcmdzID09IE5vbmU6CisgICAgICAgICMgKiogZGVz
ZXJpYWxpc2UsIHJlYWQgYnl0ZXMsIHNlcmlhbGlzZSBhbmQgd3JpdGUgYnl0ZXMKKyAgICAgICAg
cmVxX2xpbmUgPSBzZWxmLl9pbi5yZWFkbGluZSgpCisgICAgICAgICMgdGhpcyBzaG91bGQganVz
dCB0ZXN0ICJyZXFfbGluZSA9PSAnJyIsIHN1cmVseT8gIC0tIEFuZHJldyBCZW5uZXR0cworICAg
ICAgICBpZiByZXFfbGluZSBpbiAoJycsIE5vbmUpOgogICAgICAgICAgICAgIyBjbGllbnQgY2xv
c2VkIGNvbm5lY3Rpb24KICAgICAgICAgICAgIHJldHVybiBGYWxzZSAgIyBzaHV0ZG93biBzZXJ2
ZXIKICAgICAgICAgdHJ5OgotICAgICAgICAgICAgcmVzcG9uc2UgPSBzZWxmLnNtYXJ0X3NlcnZl
ci5kaXNwYXRjaF9jb21tYW5kKHJlcV9hcmdzWzBdLCByZXFfYXJnc1sxOl0pCi0gICAgICAgICAg
ICBzZWxmLl9zZW5kX3R1cGxlKHJlc3BvbnNlLmFyZ3MpCi0gICAgICAgICAgICBpZiByZXNwb25z
ZS5ib2R5IGlzIG5vdCBOb25lOgotICAgICAgICAgICAgICAgIHNlbGYuX3NlbmRfYnVsa19kYXRh
KHJlc3BvbnNlLmJvZHkpCisgICAgICAgICAgICBwcm90b2NvbCA9IFNtYXJ0U2VydmVyUmVxdWVz
dFByb3RvY29sT25lKHNlbGYuX291dCwKKyAgICAgICAgICAgICAgICBzZWxmLmJhY2tpbmdfdHJh
bnNwb3J0KQorICAgICAgICAgICAgcHJvdG9jb2wuYWNjZXB0X2J5dGVzKHJlcV9saW5lKQorICAg
ICAgICAgICAgaWYgbm90IHByb3RvY29sLmZpbmlzaGVkX3JlYWRpbmc6CisgICAgICAgICAgICAg
ICAgIyB0aGlzIGJvaWxzIGRvd24gdG8gcmVhZGxpbmUgd2hpY2ggd29udCBibG9jayBvbiBvcGVu
IHNvY2tldHMKKyAgICAgICAgICAgICAgICAjIHdpdGhvdXQgZGF0YS4gV2Ugc2hvdWxkIHJlYWxs
eSB0aG91Z2ggcmVhZCBhcyBtdWNoIGFzIGlzCisgICAgICAgICAgICAgICAgIyBhdmFpbGFibGUg
YW5kIHRoZW4gaGFuZCB0byB0aGF0IGFjY2VwdF9ieXRlcyB3aXRob3V0IHRoaXMKKyAgICAgICAg
ICAgICAgICAjIHNpbGx5IGRvdWJsZS1kZWNvZGUuCisgICAgICAgICAgICAgICAgYnVsayA9IHNl
bGYuX3JlY3ZfYnVsaygpCisgICAgICAgICAgICAgICAgYnVsa19ieXRlcyA9ICcnLmpvaW4oKCcl
ZFxuJyAlIGxlbihidWxrKSwgYnVsaywgJ2RvbmVcbicpKQorICAgICAgICAgICAgICAgIHByb3Rv
Y29sLmFjY2VwdF9ieXRlcyhidWxrX2J5dGVzKQorICAgICAgICAgICAgICAgICMgbWlnaHQgYmUg
bmljZSB0byBkbyBwcm90b2NvbC5lbmRfb2ZfYnl0ZXMoKQorICAgICAgICAgICAgICAgICMgYmVj
YXVzZSBzZWxmLl9yZWN2X2J1bGsgcmVhZHMgYWxsIHRoZSBieXRlcywgdGhpcyBtdXN0IGZpbmlz
aAorICAgICAgICAgICAgICAgICMgYWZ0ZXIgb25lIGRlbGl2ZXJ5IG9mIGRhdGEgcmF0aGVyIHRo
YW4gbG9vcGluZy4KKyAgICAgICAgICAgICAgICBhc3NlcnQgcHJvdG9jb2wuZmluaXNoZWRfcmVh
ZGluZwogICAgICAgICBleGNlcHQgS2V5Ym9hcmRJbnRlcnJ1cHQ6CiAgICAgICAgICAgICByYWlz
ZQogICAgICAgICBleGNlcHQgRXhjZXB0aW9uLCBlOgpAQCAtMzExLDM3ICs1MTIsNTggQEAKIAog
CiBjbGFzcyBTbWFydFNlcnZlclJlc3BvbnNlKG9iamVjdCk6Ci0gICAgIiIiUmVzcG9uc2UgZ2Vu
ZXJhdGVkIGJ5IFNtYXJ0U2VydmVyLiIiIgorICAgICIiIlJlc3BvbnNlIGdlbmVyYXRlZCBieSBT
bWFydFNlcnZlclJlcXVlc3RIYW5kbGVyLiIiIgogCiAgICAgZGVmIF9faW5pdF9fKHNlbGYsIGFy
Z3MsIGJvZHk9Tm9uZSk6CiAgICAgICAgIHNlbGYuYXJncyA9IGFyZ3MKICAgICAgICAgc2VsZi5i
b2R5ID0gYm9keQogCi0jIFhYWDogVE9ETzogQ3JlYXRlIGEgU21hcnRTZXJ2ZXJSZXF1ZXN0IHdo
aWNoIHdpbGwgdGFrZSB0aGUgcmVzcG9uc2liaWxpdHkKKyMgWFhYOiBUT0RPOiBDcmVhdGUgYSBT
bWFydFNlcnZlclJlcXVlc3RIYW5kbGVyIHdoaWNoIHdpbGwgdGFrZSB0aGUgcmVzcG9uc2liaWxp
dHkKICMgZm9yIGRlbGl2ZXJpbmcgdGhlIGRhdGEgZm9yIGEgcmVxdWVzdC4gVGhpcyBjb3VsZCBi
ZSBkb25lIHdpdGggYXMgdGhlCiAjIFN0cmVhbVNlcnZlciwgdGhvdWdoIHRoYXQgd291bGQgY3Jl
YXRlIGNvbmZsYXRpb24gYmV0d2VlbiByZXF1ZXN0IGFuZCByZXNwb25zZQogIyB3aGljaCBtYXkg
YmUgdW5kZXNpcmFibGUuCiAKIAotY2xhc3MgU21hcnRTZXJ2ZXIob2JqZWN0KToKK2NsYXNzIFNt
YXJ0U2VydmVyUmVxdWVzdEhhbmRsZXIob2JqZWN0KToKICAgICAiIiJQcm90b2NvbCBsb2dpYyBm
b3Igc21hcnQgc2VydmVyLgogICAgIAogICAgIFRoaXMgZG9lc24ndCBoYW5kbGUgc2VyaWFsaXph
dGlvbiBhdCBhbGwsIGl0IGp1c3QgcHJvY2Vzc2VzIHJlcXVlc3RzIGFuZAogICAgIGNyZWF0ZXMg
cmVzcG9uc2VzLgogICAgICIiIgogCi0gICAgIyBJTVBPUlRBTlQgRk9SIElNUExFTUVOVE9SUzog
SXQgaXMgaW1wb3J0YW50IHRoYXQgU21hcnRTZXJ2ZXIgbm90IGNvbnRhaW4KLSAgICAjIGVuY29k
aW5nIG9yIGRlY29kaW5nIGxvZ2ljIHRvIGFsbG93IHRoZSB3aXJlIHByb3RvY29sIHRvIHZhcnkg
ZnJvbSB0aGUKLSAgICAjIG9iamVjdCBwcm90b2NvbDogd2Ugd2lsbCB3YW50IHRvIHR3ZWFrIHRo
ZSB3aXJlIHByb3RvY29sIHNlcGFyYXRlIGZyb20KLSAgICAjIHRoZSBvYmplY3QgbW9kZWwsIGFu
ZCBpZGVhbGx5IHdlIHdpbGwgYmUgYWJsZSB0byBkbyB0aGF0IHdpdGhvdXQgaGF2aW5nCi0gICAg
IyBhIFNtYXJ0U2VydmVyIHN1YmNsYXNzIGZvciBlYWNoIHdpcmUgcHJvdG9jb2wsIHJhdGhlciBq
dXN0IGEgUHJvdG9jb2wKLSAgICAjIHN1YmNsYXNzLgorICAgICMgSU1QT1JUQU5UIEZPUiBJTVBM
RU1FTlRPUlM6IEl0IGlzIGltcG9ydGFudCB0aGF0IFNtYXJ0U2VydmVyUmVxdWVzdEhhbmRsZXIK
KyAgICAjIG5vdCBjb250YWluIGVuY29kaW5nIG9yIGRlY29kaW5nIGxvZ2ljIHRvIGFsbG93IHRo
ZSB3aXJlIHByb3RvY29sIHRvIHZhcnkKKyAgICAjIGZyb20gdGhlIG9iamVjdCBwcm90b2NvbDog
d2Ugd2lsbCB3YW50IHRvIHR3ZWFrIHRoZSB3aXJlIHByb3RvY29sIHNlcGFyYXRlCisgICAgIyBm
cm9tIHRoZSBvYmplY3QgbW9kZWwsIGFuZCBpZGVhbGx5IHdlIHdpbGwgYmUgYWJsZSB0byBkbyB0
aGF0IHdpdGhvdXQKKyAgICAjIGhhdmluZyBhIFNtYXJ0U2VydmVyUmVxdWVzdEhhbmRsZXIgc3Vi
Y2xhc3MgZm9yIGVhY2ggd2lyZSBwcm90b2NvbCwgcmF0aGVyCisgICAgIyBqdXN0IGEgUHJvdG9j
b2wgc3ViY2xhc3MuCiAKICAgICAjIFRPRE86IEJldHRlciB3YXkgb2YgcmVwcmVzZW50aW5nIHRo
ZSBib2R5IGZvciBjb21tYW5kcyB0aGF0IHRha2UgaXQsCiAgICAgIyBhbmQgYWxsb3cgaXQgdG8g
YmUgc3RyZWFtZWQgaW50byB0aGUgc2VydmVyLgogICAgIAogICAgIGRlZiBfX2luaXRfXyhzZWxm
LCBiYWNraW5nX3RyYW5zcG9ydCk6CiAgICAgICAgIHNlbGYuX2JhY2tpbmdfdHJhbnNwb3J0ID0g
YmFja2luZ190cmFuc3BvcnQKKyAgICAgICAgc2VsZi5fY29udmVydGVkX2NvbW1hbmQgPSBGYWxz
ZQorICAgICAgICBzZWxmLmZpbmlzaGVkX3JlYWRpbmcgPSBGYWxzZQorICAgICAgICBzZWxmLl9i
b2R5X2J5dGVzID0gJycKKyAgICAgICAgc2VsZi5yZXNwb25zZSA9IE5vbmUKKworICAgIGRlZiBh
Y2NlcHRfYm9keShzZWxmLCBieXRlcyk6CisgICAgICAgICIiIkFjY2VwdCBib2R5IGRhdGEuCisK
KyAgICAgICAgVGhpcyBzaG91bGQgYmUgb3ZlcnJpZGVuIGZvciBlYWNoIGNvbW1hbmQgdGhhdCBk
ZXNpcmVkIGJvZHkgZGF0YSB0bworICAgICAgICBoYW5kbGUgdGhlIHJpZ2h0IGZvcm1hdCBvZiB0
aGF0IGRhdGEuIEkuZS4gcGxhaW4gYnl0ZXMsIGEgYnVuZGxlIGV0Yy4KKworICAgICAgICBUaGUg
ZGVzZXJpYWxpc2F0aW9uIGludG8gdGhhdCBmb3JtYXQgc2hvdWxkIGJlIGRvbmUgaW4gdGhlIFBy
b3RvY29sCisgICAgICAgIG9iamVjdC4gU2V0IHNlbGYuZGVzaXJlZF9ib2R5X2Zvcm1hdCB0byB0
aGUgZm9ybWF0IHlvdXIgbWV0aG9kIHdpbGwKKyAgICAgICAgaGFuZGxlLgorICAgICAgICAiIiIK
KyAgICAgICAgIyBkZWZhdWx0IGZhbGxiYWNrIGlzIHRvIGFjY3VtdWxhdGUgYnl0ZXMuCisgICAg
ICAgIHNlbGYuX2JvZHlfYnl0ZXMgKz0gYnl0ZXMKKyAgICAgICAgCisgICAgZGVmIF9lbmRfb2Zf
Ym9keV9oYW5kbGVyKHNlbGYpOgorICAgICAgICAiIiJBbiB1bmltcGxlbWVudGVkIGVuZCBvZiBi
b2R5IGhhbmRsZXIuIiIiCisgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3Ioc2VsZi5f
ZW5kX29mX2JvZHlfaGFuZGxlcikKICAgICAgICAgCiAgICAgZGVmIGRvX2hlbGxvKHNlbGYpOgog
ICAgICAgICAiIiJBbnN3ZXIgYSB2ZXJzaW9uIHJlcXVlc3Qgd2l0aCBteSB2ZXJzaW9uLiIiIgpA
QCAtMzYzLDkgKzU4NSwxNSBAQAogICAgICAgICAgICAgcmV0dXJuIGludChtb2RlKQogCiAgICAg
ZGVmIGRvX2FwcGVuZChzZWxmLCByZWxwYXRoLCBtb2RlKToKKyAgICAgICAgc2VsZi5fY29udmVy
dGVkX2NvbW1hbmQgPSBUcnVlCisgICAgICAgIHNlbGYuX3JlbHBhdGggPSByZWxwYXRoCisgICAg
ICAgIHNlbGYuX21vZGUgPSBzZWxmLl9kZXNlcmlhbGlzZV9vcHRpb25hbF9tb2RlKG1vZGUpCisg
ICAgICAgIHNlbGYuX2VuZF9vZl9ib2R5X2hhbmRsZXIgPSBzZWxmLl9oYW5kbGVfZG9fYXBwZW5k
X2VuZAorICAgIAorICAgIGRlZiBfaGFuZGxlX2RvX2FwcGVuZF9lbmQoc2VsZik6CiAgICAgICAg
IG9sZF9sZW5ndGggPSBzZWxmLl9iYWNraW5nX3RyYW5zcG9ydC5hcHBlbmRfYnl0ZXMoCi0gICAg
ICAgICAgICByZWxwYXRoLCBzZWxmLl9yZWN2X2JvZHkoKSwgc2VsZi5fZGVzZXJpYWxpc2Vfb3B0
aW9uYWxfbW9kZShtb2RlKSkKLSAgICAgICAgcmV0dXJuIFNtYXJ0U2VydmVyUmVzcG9uc2UoKCdh
cHBlbmRlZCcsICclZCcgJSBvbGRfbGVuZ3RoKSkKKyAgICAgICAgICAgIHNlbGYuX3JlbHBhdGgs
IHNlbGYuX2JvZHlfYnl0ZXMsIHNlbGYuX21vZGUpCisgICAgICAgIHNlbGYucmVzcG9uc2UgPSBT
bWFydFNlcnZlclJlc3BvbnNlKCgnYXBwZW5kZWQnLCAnJWQnICUgb2xkX2xlbmd0aCkpCiAKICAg
ICBkZWYgZG9fZGVsZXRlKHNlbGYsIHJlbHBhdGgpOgogICAgICAgICBzZWxmLl9iYWNraW5nX3Ry
YW5zcG9ydC5kZWxldGUocmVscGF0aCkKQEAgLTM4OSw5ICs2MTcsMTUgQEAKICAgICAgICAgc2Vs
Zi5fYmFja2luZ190cmFuc3BvcnQubW92ZShyZWxfZnJvbSwgcmVsX3RvKQogCiAgICAgZGVmIGRv
X3B1dChzZWxmLCByZWxwYXRoLCBtb2RlKToKLSAgICAgICAgc2VsZi5fYmFja2luZ190cmFuc3Bv
cnQucHV0X2J5dGVzKHJlbHBhdGgsCi0gICAgICAgICAgICAgICAgc2VsZi5fcmVjdl9ib2R5KCks
Ci0gICAgICAgICAgICAgICAgc2VsZi5fZGVzZXJpYWxpc2Vfb3B0aW9uYWxfbW9kZShtb2RlKSkK
KyAgICAgICAgc2VsZi5fY29udmVydGVkX2NvbW1hbmQgPSBUcnVlCisgICAgICAgIHNlbGYuX3Jl
bHBhdGggPSByZWxwYXRoCisgICAgICAgIHNlbGYuX21vZGUgPSBzZWxmLl9kZXNlcmlhbGlzZV9v
cHRpb25hbF9tb2RlKG1vZGUpCisgICAgICAgIHNlbGYuX2VuZF9vZl9ib2R5X2hhbmRsZXIgPSBz
ZWxmLl9oYW5kbGVfZG9fcHV0CisKKyAgICBkZWYgX2hhbmRsZV9kb19wdXQoc2VsZik6CisgICAg
ICAgIHNlbGYuX2JhY2tpbmdfdHJhbnNwb3J0LnB1dF9ieXRlcyhzZWxmLl9yZWxwYXRoLAorICAg
ICAgICAgICAgICAgIHNlbGYuX2JvZHlfYnl0ZXMsIHNlbGYuX21vZGUpCisgICAgICAgIHNlbGYu
cmVzcG9uc2UgPSBTbWFydFNlcnZlclJlc3BvbnNlKCgnb2snLCkpCiAKICAgICBkZWYgX2Rlc2Vy
aWFsaXNlX29mZnNldHMoc2VsZiwgdGV4dCk6CiAgICAgICAgICMgWFhYOiBGSVhNRSB0aGlzIHNo
b3VsZCBiZSBvbiB0aGUgcHJvdG9jb2wgb2JqZWN0LgpAQCAtNDA0LDE4ICs2MzgsMzkgQEAKICAg
ICAgICAgcmV0dXJuIG9mZnNldHMKIAogICAgIGRlZiBkb19wdXRfbm9uX2F0b21pYyhzZWxmLCBy
ZWxwYXRoLCBtb2RlLCBjcmVhdGVfcGFyZW50LCBkaXJfbW9kZSk6Ci0gICAgICAgIGNyZWF0ZV9w
YXJlbnRfZGlyID0gKGNyZWF0ZV9wYXJlbnQgPT0gJ1QnKQotICAgICAgICBzZWxmLl9iYWNraW5n
X3RyYW5zcG9ydC5wdXRfYnl0ZXNfbm9uX2F0b21pYyhyZWxwYXRoLAotICAgICAgICAgICAgICAg
IHNlbGYuX3JlY3ZfYm9keSgpLAotICAgICAgICAgICAgICAgIG1vZGU9c2VsZi5fZGVzZXJpYWxp
c2Vfb3B0aW9uYWxfbW9kZShtb2RlKSwKLSAgICAgICAgICAgICAgICBjcmVhdGVfcGFyZW50X2Rp
cj1jcmVhdGVfcGFyZW50X2RpciwKLSAgICAgICAgICAgICAgICBkaXJfbW9kZT1zZWxmLl9kZXNl
cmlhbGlzZV9vcHRpb25hbF9tb2RlKGRpcl9tb2RlKSkKKyAgICAgICAgc2VsZi5fY29udmVydGVk
X2NvbW1hbmQgPSBUcnVlCisgICAgICAgIHNlbGYuX2VuZF9vZl9ib2R5X2hhbmRsZXIgPSBzZWxm
Ll9oYW5kbGVfcHV0X25vbl9hdG9taWMKKyAgICAgICAgc2VsZi5fcmVscGF0aCA9IHJlbHBhdGgK
KyAgICAgICAgc2VsZi5fZGlyX21vZGUgPSBzZWxmLl9kZXNlcmlhbGlzZV9vcHRpb25hbF9tb2Rl
KGRpcl9tb2RlKQorICAgICAgICBzZWxmLl9tb2RlID0gc2VsZi5fZGVzZXJpYWxpc2Vfb3B0aW9u
YWxfbW9kZShtb2RlKQorICAgICAgICAjIGEgYm9vbGVhbiB3b3VsZCBiZSBuaWNlciBYWFgKKyAg
ICAgICAgc2VsZi5fY3JlYXRlX3BhcmVudCA9IChjcmVhdGVfcGFyZW50ID09ICdUJykKKworICAg
IGRlZiBfaGFuZGxlX3B1dF9ub25fYXRvbWljKHNlbGYpOgorICAgICAgICBzZWxmLl9iYWNraW5n
X3RyYW5zcG9ydC5wdXRfYnl0ZXNfbm9uX2F0b21pYyhzZWxmLl9yZWxwYXRoLAorICAgICAgICAg
ICAgICAgIHNlbGYuX2JvZHlfYnl0ZXMsCisgICAgICAgICAgICAgICAgbW9kZT1zZWxmLl9tb2Rl
LAorICAgICAgICAgICAgICAgIGNyZWF0ZV9wYXJlbnRfZGlyPXNlbGYuX2NyZWF0ZV9wYXJlbnQs
CisgICAgICAgICAgICAgICAgZGlyX21vZGU9c2VsZi5fZGlyX21vZGUpCisgICAgICAgIHNlbGYu
cmVzcG9uc2UgPSBTbWFydFNlcnZlclJlc3BvbnNlKCgnb2snLCkpCiAKICAgICBkZWYgZG9fcmVh
ZHYoc2VsZiwgcmVscGF0aCk6Ci0gICAgICAgIG9mZnNldHMgPSBzZWxmLl9kZXNlcmlhbGlzZV9v
ZmZzZXRzKHNlbGYuX3JlY3ZfYm9keSgpKQorICAgICAgICBzZWxmLl9jb252ZXJ0ZWRfY29tbWFu
ZCA9IFRydWUKKyAgICAgICAgc2VsZi5fZW5kX29mX2JvZHlfaGFuZGxlciA9IHNlbGYuX2hhbmRs
ZV9yZWFkdl9vZmZzZXRzCisgICAgICAgIHNlbGYuX3JlbHBhdGggPSByZWxwYXRoCisKKyAgICBk
ZWYgZW5kX29mX2JvZHkoc2VsZik6CisgICAgICAgICIiIk5vIG1vcmUgYm9keSBkYXRhIHdpbGwg
YmUgcmVjZWl2ZWQuIiIiCisgICAgICAgIHNlbGYuX3J1bl9oYW5kbGVyX2NvZGUoc2VsZi5fZW5k
X29mX2JvZHlfaGFuZGxlciwgKCksIHt9KQorICAgICAgICAjIGNhbm5vdCByZWFkIGFmdGVyIHRo
aXMuCisgICAgICAgIHNlbGYuZmluaXNoZWRfcmVhZGluZyA9IFRydWUKKworICAgIGRlZiBfaGFu
ZGxlX3JlYWR2X29mZnNldHMoc2VsZik6CisgICAgICAgICIiImFjY2VwdCBvZmZzZXRzIGZvciBh
IHJlYWR2IHJlcXVlc3QuIiIiCisgICAgICAgIG9mZnNldHMgPSBzZWxmLl9kZXNlcmlhbGlzZV9v
ZmZzZXRzKHNlbGYuX2JvZHlfYnl0ZXMpCiAgICAgICAgIGJhY2tpbmdfYnl0ZXMgPSAnJy5qb2lu
KGJ5dGVzIGZvciBvZmZzZXQsIGJ5dGVzIGluCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg
IHNlbGYuX2JhY2tpbmdfdHJhbnNwb3J0LnJlYWR2KHJlbHBhdGgsIG9mZnNldHMpKQotICAgICAg
ICByZXR1cm4gU21hcnRTZXJ2ZXJSZXNwb25zZSgoJ3JlYWR2JywpLCBiYWNraW5nX2J5dGVzKQor
ICAgICAgICAgICAgc2VsZi5fYmFja2luZ190cmFuc3BvcnQucmVhZHYoc2VsZi5fcmVscGF0aCwg
b2Zmc2V0cykpCisgICAgICAgIHNlbGYucmVzcG9uc2UgPSBTbWFydFNlcnZlclJlc3BvbnNlKCgn
cmVhZHYnLCksIGJhY2tpbmdfYnl0ZXMpCiAgICAgICAgIAogICAgIGRlZiBkb19yZW5hbWUoc2Vs
ZiwgcmVsX2Zyb20sIHJlbF90byk6CiAgICAgICAgIHNlbGYuX2JhY2tpbmdfdHJhbnNwb3J0LnJl
bmFtZShyZWxfZnJvbSwgcmVsX3RvKQpAQCAtNDM5LDE0ICs2OTQsMzUgQEAKICAgICAgICAgcmV0
dXJuIFNtYXJ0U2VydmVyUmVzcG9uc2UoKCksIHRtcGYucmVhZCgpKQogCiAgICAgZGVmIGRpc3Bh
dGNoX2NvbW1hbmQoc2VsZiwgY21kLCBhcmdzKToKKyAgICAgICAgIiIiRGVwcmVjYXRlZCBjb21w
YXRpYmlsaXR5IG1ldGhvZC4iIiIgIyBYWFggWFhYCiAgICAgICAgIGZ1bmMgPSBnZXRhdHRyKHNl
bGYsICdkb18nICsgY21kLCBOb25lKQogICAgICAgICBpZiBmdW5jIGlzIE5vbmU6CiAgICAgICAg
ICAgICByYWlzZSBlcnJvcnMuU21hcnRQcm90b2NvbEVycm9yKCJiYWQgcmVxdWVzdCAlciIgJSAo
Y21kLCkpCisgICAgICAgIHNlbGYuX3J1bl9oYW5kbGVyX2NvZGUoZnVuYywgYXJncywge30pCisK
KyAgICBkZWYgX3J1bl9oYW5kbGVyX2NvZGUoc2VsZiwgY2FsbGFibGUsIGFyZ3MsIGt3YXJncyk6
CisgICAgICAgICIiIlJ1biBzb21lIGhhbmRsZXIgc3BlY2lmaWMgY29kZSAnY2FsbGFibGUnLgor
CisgICAgICAgIElmIGEgcmVzdWx0IGlzIHJldHVybmVkLCBpdCBpcyBjb25zaWRlcmVkIHRvIGJl
IHRoZSBjb21tYW5kcyByZXNwb25zZSwKKyAgICAgICAgYW5kIGZpbmlzaGVkX3JlYWRpbmcgaXMg
c2V0IHRydWUsIGFuZCBpdHMgYXNzaWduZWQgdG8gc2VsZi5yZXNwb25zZS4KKworICAgICAgICBB
bnkgZXhjZXB0aW9ucyBjYXVnaHQgYXJlIHRyYW5zbGF0ZWQgYW5kIGEgcmVzcG9uc2Ugb2JqZWN0
IGNyZWF0ZWQKKyAgICAgICAgZnJvbSB0aGVtLgorICAgICAgICAiIiIKKyAgICAgICAgcmVzdWx0
ID0gc2VsZi5fY2FsbF9jb252ZXJ0aW5nX2Vycm9ycyhjYWxsYWJsZSwgYXJncywga3dhcmdzKQor
ICAgICAgICBpZiByZXN1bHQgaXMgbm90IE5vbmU6CisgICAgICAgICAgICBzZWxmLnJlc3BvbnNl
ID0gcmVzdWx0CisgICAgICAgICAgICBzZWxmLmZpbmlzaGVkX3JlYWRpbmcgPSBUcnVlCisgICAg
ICAgICMgaGFuZGxlIHVuY29udmVydGVkIGNvbW1hbmRzCisgICAgICAgIGlmIG5vdCBzZWxmLl9j
b252ZXJ0ZWRfY29tbWFuZDoKKyAgICAgICAgICAgIHNlbGYuZmluaXNoZWRfcmVhZGluZyA9IFRy
dWUKKyAgICAgICAgICAgIGlmIHJlc3VsdCBpcyBOb25lOgorICAgICAgICAgICAgICAgIHNlbGYu
cmVzcG9uc2UgPSBTbWFydFNlcnZlclJlc3BvbnNlKCgnb2snLCkpCisKKyAgICBkZWYgX2NhbGxf
Y29udmVydGluZ19lcnJvcnMoc2VsZiwgY2FsbGFibGUsIGFyZ3MsIGt3YXJncyk6CisgICAgICAg
ICIiIkNhbGwgY2FsbGFibGUgY29udmVydGluZyBlcnJvcnMgdG8gUmVzcG9uc2Ugb2JqZWN0cy4i
IiIKICAgICAgICAgdHJ5OgotICAgICAgICAgICAgcmVzdWx0ID0gZnVuYygqYXJncykKLSAgICAg
ICAgICAgIGlmIHJlc3VsdCBpcyBOb25lOiAKLSAgICAgICAgICAgICAgICByZXN1bHQgPSBTbWFy
dFNlcnZlclJlc3BvbnNlKCgnb2snLCkpCi0gICAgICAgICAgICByZXR1cm4gcmVzdWx0CisgICAg
ICAgICAgICByZXR1cm4gY2FsbGFibGUoKmFyZ3MsICoqa3dhcmdzKQogICAgICAgICBleGNlcHQg
ZXJyb3JzLk5vU3VjaEZpbGUsIGU6CiAgICAgICAgICAgICByZXR1cm4gU21hcnRTZXJ2ZXJSZXNw
b25zZSgoJ05vU3VjaEZpbGUnLCBlLnBhdGgpKQogICAgICAgICBleGNlcHQgZXJyb3JzLkZpbGVF
eGlzdHMsIGU6CkBAIC01MjEsNyArNzk3LDcgQEAKICAgICAgICAgY29ubi5zZXRzb2Nrb3B0KHNv
Y2tldC5JUFBST1RPX1RDUCwgc29ja2V0LlRDUF9OT0RFTEFZLCAxKQogICAgICAgICBmcm9tX2Ns
aWVudCA9IGNvbm4ubWFrZWZpbGUoJ3InKQogICAgICAgICB0b19jbGllbnQgPSBjb25uLm1ha2Vm
aWxlKCd3JykKLSAgICAgICAgaGFuZGxlciA9IFNtYXJ0U3RyZWFtU2VydmVyKGZyb21fY2xpZW50
LCB0b19jbGllbnQsCisgICAgICAgIGhhbmRsZXIgPSBTbWFydFNlcnZlclN0cmVhbU1lZGl1bShm
cm9tX2NsaWVudCwgdG9fY2xpZW50LAogICAgICAgICAgICAgICAgIHNlbGYuYmFja2luZ190cmFu
c3BvcnQpCiAgICAgICAgIGNvbm5lY3Rpb25fdGhyZWFkID0gdGhyZWFkaW5nLlRocmVhZChOb25l
LCBoYW5kbGVyLnNlcnZlLCBuYW1lPSdzbWFydC1zZXJ2ZXItY2hpbGQnKQogICAgICAgICBjb25u
ZWN0aW9uX3RocmVhZC5zZXREYWVtb24oVHJ1ZSkKCg==
# revision id: andrew.bennetts at canonical.com-20060919111846-9853422711c0d27c
# sha1: 42293062c4f183b90606be76011fc9f865f65f4e
# inventory sha1: c47ef098d10316bc86eef447698b0b6b02f17d66
# parent ids:
# andrew.bennetts at canonical.com-20060919034701-9b801d527a1261f5
# properties:
# branch-nick: hpss HTTP support
# message:
# Empty BRANCH.TODO
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2006-09-19 13:47:01.931999922 +1000
=== modified file BRANCH.TODO // encoding:base64
LS0tIEJSQU5DSC5UT0RPCisrKyBCUkFOQ0guVE9ETwpAQCAtMiwxMCArMiwzIEBACiAjIEl0IHNo
b3VsZCBBTFdBWVMgYmUgZW1wdHkgaW4gdGhlIG1haW5saW5lIG9yIGluIGludGVncmF0aW9uIGJy
YW5jaGVzLgogIyAKIAotU3VwcG9ydCB1c2UgY2FzZXM6Ci0gMSkgYnpyIGxvZyBvdmVyIGJ6citz
c2ggdG8gYSBtYWNoaW5lIHdpdGhvdXQgYnpyIDAuMTEgaW5zdGFsbGVkLCB3aXRob3V0Ci1lZGl0
aW5nIHJlbW90ZSBiYXNocmMgZmlsZXMuCi0KLSAyKSBienIgbG9nIHRvIGEgaW5ldCBydW5uaW5n
IGJ6cjovLwotCi1QdXQgYm90aCBpbiB0aGUgdHV0b3JpYWwuCgo=
# revision id: andrew.bennetts at canonical.com-20060919034701-9b801d527a1261f5
# sha1: a3af33a8aeab08171b8ff4c4b2ce531ec24f3834
# inventory sha1: 38463e6b305fd691a9d5554e6ee9793deb578227
# parent ids:
# andrew.bennetts at canonical.com-20060919030924-df342f90b1527b3f
# properties:
# branch-nick: hpss HTTP support
More information about the bazaar
mailing list