[MERGE][0.16] Smart server protocol versioning
Andrew Bennetts
andrew at canonical.com
Tue Apr 24 10:04:54 BST 2007
This bundle adds a new version to the smart protocol that starts each request
and response with a protocol version identifier. So version two requests and
responses will be the same as version one, except for a "2\n" prefix.
The server is able to distinguish the different protocol versions so it can
handle both version one and two requests.
This is mainly interesting because it will make it smoother to make other
changes to the protocol later, e.g. standardised error encoding, chunked body
encoding, args tuple encoding that is 8-bit safe, etc.
I would like to get this merged for 0.16.
-Andrew.
-------------- next part --------------
# Bazaar revision bundle v0.9
#
# message:
# Improve HelloRequest's docstring.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2007-04-24 19:01:50.107000113 +1000
=== modified file bzrlib/smart/medium.py // last-changed:andrew.bennetts at canoni
... cal.com-20070424083632-f7kadff1wbp3eszn
--- bzrlib/smart/medium.py
+++ bzrlib/smart/medium.py
@@ -29,7 +29,11 @@
import sys
from bzrlib import errors
-from bzrlib.smart import protocol
+from bzrlib.smart.protocol import (
+ SmartServerRequestProtocolOne,
+ SmartServerRequestProtocolTwo,
+ )
+
try:
from bzrlib.transport import ssh
except errors.ParamikoNotPresent:
@@ -66,13 +70,24 @@
from sys import stderr
try:
while not self.finished:
- server_protocol = protocol.SmartServerRequestProtocolOne(
- self.backing_transport, self._write_out)
+ server_protocol = self._build_protocol()
self._serve_one_request(server_protocol)
except Exception, e:
stderr.write("%s terminating on exception %s\n" % (self, e))
raise
+ def _build_protocol(self):
+ # Identify the protocol version.
+ bytes = self._get_bytes(2)
+ if bytes.startswith('2\n'):
+ protocol_class = SmartServerRequestProtocolTwo
+ bytes = bytes[2:]
+ else:
+ protocol_class = SmartServerRequestProtocolOne
+ protocol = protocol_class(self.backing_transport, self._write_out)
+ protocol.accept_bytes(bytes)
+ return protocol
+
def _serve_one_request(self, protocol):
"""Read one request from input, process, send back a response.
@@ -89,6 +104,13 @@
"""Called when an unhandled exception from the protocol occurs."""
raise NotImplementedError(self.terminate_due_to_error)
+ def _get_bytes(self, desired_count):
+ """Get some bytes from the medium.
+
+ :param desired_count: number of bytes we want to read.
+ """
+ raise NotImplementedError(self._get_bytes)
+
class SmartServerSocketStreamMedium(SmartServerStreamMedium):
@@ -109,13 +131,18 @@
protocol.accept_bytes(self.push_back)
self.push_back = ''
else:
- bytes = self.socket.recv(4096)
+ bytes = self._get_bytes(4096)
if bytes == '':
self.finished = True
return
protocol.accept_bytes(bytes)
self.push_back = protocol.excess_buffer
+
+ def _get_bytes(self, desired_count):
+ # We ignore the desired_count because on sockets it's more efficient to
+ # read 4k at a time.
+ return self.socket.recv(4096)
def terminate_due_to_error(self):
"""Called when an unhandled exception from the protocol occurs."""
@@ -155,7 +182,7 @@
# Finished serving this request.
self._out.flush()
return
- bytes = self._in.read(bytes_to_read)
+ bytes = self._get_bytes(bytes_to_read)
if bytes == '':
# Connection has been closed.
self.finished = True
@@ -163,6 +190,9 @@
return
protocol.accept_bytes(bytes)
+ def _get_bytes(self, desired_count):
+ return self._in.read(desired_count)
+
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.
=== modified file bzrlib/smart/protocol.py // last-changed:andrew.bennetts at cano
... nical.com-20070424083632-f7kadff1wbp3eszn
--- bzrlib/smart/protocol.py
+++ bzrlib/smart/protocol.py
@@ -135,12 +135,19 @@
"""Send a smart server response down the output stream."""
assert not self._finished, 'response already sent'
self._finished = True
+ self._write_protocol_version()
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)
+ def _write_protocol_version(self):
+ """Write any prefixes this protocol requires.
+
+ Version one doesn't send protocol versions.
+ """
+
def next_read_size(self):
if self._finished:
return 0
@@ -150,6 +157,20 @@
return self._body_decoder.next_read_size()
+class SmartServerRequestProtocolTwo(SmartServerRequestProtocolOne):
+ r"""Version two of the server side of the smart protocol.
+
+ This prefixes responses with the protocol version: "2\n".
+ """
+
+ def _write_protocol_version(self):
+ r"""Write any prefixes this protocol requires.
+
+ Version two sends "2\n".
+ """
+ self._write_func('2\n')
+
+
class LengthPrefixedBodyDecoder(object):
"""Decodes the length-prefixed bulk data."""
@@ -254,8 +275,7 @@
self._body_buffer = None
def call(self, *args):
- bytes = _encode_tuple(args)
- self._request.accept_bytes(bytes)
+ self._write_args(args)
self._request.finished_writing()
def call_with_body_bytes(self, args, body):
@@ -263,8 +283,7 @@
After calling this, call read_response_tuple to find the result out.
"""
- bytes = _encode_tuple(args)
- self._request.accept_bytes(bytes)
+ self._write_args(args)
bytes = self._encode_bulk_data(body)
self._request.accept_bytes(bytes)
self._request.finished_writing()
@@ -275,8 +294,7 @@
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)
+ self._write_args(args)
readv_bytes = self._serialise_offsets(body)
bytes = self._encode_bulk_data(readv_bytes)
self._request.accept_bytes(bytes)
@@ -336,7 +354,45 @@
resp = self.read_response_tuple()
if resp == ('ok', '1'):
return 1
+ elif resp == ('ok', '2'):
+ return 2
else:
raise errors.SmartProtocolError("bad response %r" % (resp,))
+ def _write_args(self, args):
+ self._write_protocol_version()
+ bytes = _encode_tuple(args)
+ self._request.accept_bytes(bytes)
+
+ def _write_protocol_version(self):
+ """Write any prefixes this protocol requires.
+
+ Version one doesn't send protocol versions.
+ """
+
+
+class SmartClientRequestProtocolTwo(SmartClientRequestProtocolOne):
+ r"""Version two of the client side of the smart protocol.
+
+ This prefixes the request with the protocol version: "2\n".
+ """
+
+ _version_string = '2\n'
+
+ def read_response_tuple(self, expect_body=False):
+ """Read a response tuple from the wire.
+
+ This should only be called once.
+ """
+ version = self._request.read_bytes(2)
+ if version != SmartClientRequestProtocolTwo._version_string:
+ raise errors.SmartProtocolError('bad protocol marker %r' % version)
+ return SmartClientRequestProtocolOne.read_response_tuple(self, expect_body)
+
+ def _write_protocol_version(self):
+ r"""Write any prefixes this protocol requires.
+
+ Version two sends "2\n".
+ """
+ self._request.accept_bytes(SmartClientRequestProtocolTwo._version_string)
=== modified file bzrlib/smart/request.py
--- bzrlib/smart/request.py
+++ bzrlib/smart/request.py
@@ -200,10 +200,12 @@
class HelloRequest(SmartServerRequest):
- """Answer a version request with my version."""
+ """Answer a version request with the highest protocol version this server
+ supports.
+ """
def do(self):
- return SmartServerResponse(('ok', '1'))
+ return SmartServerResponse(('ok', '2'))
class GetBundleRequest(SmartServerRequest):
=== modified file bzrlib/tests/test_smart_transport.py // last-changed:andrew.b
... ennetts at canonical.com-20070424085029-0o6h7jj68i7sd8ea
--- bzrlib/tests/test_smart_transport.py
+++ bzrlib/tests/test_smart_transport.py
@@ -598,7 +598,7 @@
smart_protocol = protocol.SmartServerRequestProtocolOne(transport,
from_server.write)
server._serve_one_request(smart_protocol)
- self.assertEqual('ok\0011\n',
+ self.assertEqual('ok\0012\n',
from_server.getvalue())
def test_response_to_canned_get(self):
@@ -768,6 +768,62 @@
KeyboardInterrupt, server._serve_one_request, fake_protocol)
server_sock.close()
self.assertEqual('', client_sock.recv(1))
+
+ def build_protocol_pipe_like(self, bytes):
+ to_server = StringIO(bytes)
+ from_server = StringIO()
+ server = medium.SmartServerPipeStreamMedium(
+ to_server, from_server, None)
+ return server._build_protocol()
+
+ def build_protocol_socket(self, bytes):
+ server_sock, client_sock = self.portable_socket_pair()
+ server = medium.SmartServerSocketStreamMedium(
+ server_sock, None)
+ client_sock.sendall(bytes)
+ client_sock.close()
+ return server._build_protocol()
+
+ def assertProtocolOne(self, server_protocol):
+ # Use assertIs because assertIsInstance will wrongly pass
+ # SmartServerRequestProtocolTwo (because it subclasses
+ # SmartServerRequestProtocolOne).
+ self.assertIs(
+ type(server_protocol), protocol.SmartServerRequestProtocolOne)
+
+ def assertProtocolTwo(self, server_protocol):
+ self.assertIsInstance(
+ server_protocol, protocol.SmartServerRequestProtocolTwo)
+
+ def test_pipe_like_build_protocol_empty_bytes(self):
+ # Any empty request (i.e. no bytes) is detected as protocol version one.
+ server_protocol = self.build_protocol_pipe_like('')
+ self.assertProtocolOne(server_protocol)
+
+ def test_socket_like_build_protocol_empty_bytes(self):
+ # Any empty request (i.e. no bytes) is detected as protocol version one.
+ server_protocol = self.build_protocol_socket('')
+ self.assertProtocolOne(server_protocol)
+
+ def test_pipe_like_build_protocol_non_two(self):
+ # A request that doesn't start with "2\n" is version one.
+ server_protocol = self.build_protocol_pipe_like('2-')
+ self.assertProtocolOne(server_protocol)
+
+ def test_socket_build_protocol_non_two(self):
+ # A request that doesn't start with "2\n" is version one.
+ server_protocol = self.build_protocol_socket('2-')
+ self.assertProtocolOne(server_protocol)
+
+ def test_pipe_like_build_protocol_two(self):
+ # A request that starts with "2\n" is version two.
+ server_protocol = self.build_protocol_pipe_like('2\n')
+ self.assertProtocolTwo(server_protocol)
+
+ def test_socket_build_protocol_two(self):
+ # A request that starts with "2\n" is version two.
+ server_protocol = self.build_protocol_socket('2\n')
+ self.assertProtocolTwo(server_protocol)
class TestSmartTCPServer(tests.TestCase):
@@ -981,12 +1037,15 @@
class SmartServerCommandTests(tests.TestCaseWithTransport):
"""Tests that call directly into the command objects, bypassing the network
and the request dispatching.
+
+ Note: these tests are rudimentary versions of the command object tests in
+ test_remote.py.
"""
def test_hello(self):
cmd = request.HelloRequest(None)
response = cmd.execute()
- self.assertEqual(('ok', '1'), response.args)
+ self.assertEqual(('ok', '2'), response.args)
self.assertEqual(None, response.body)
def test_get_bundle(self):
@@ -1022,7 +1081,7 @@
def test_hello(self):
handler = self.build_handler(None)
handler.dispatch_command('hello', ())
- self.assertEqual(('ok', '1'), handler.response.args)
+ self.assertEqual(('ok', '2'), handler.response.args)
self.assertEqual(None, handler.response.body)
def test_disable_vfs_handler_classes_via_environment(self):
@@ -1148,7 +1207,7 @@
class TestSmartProtocol(tests.TestCase):
- """Tests for the smart protocol.
+ """Base class for smart protocol tests.
Each test case gets a smart_server and smart_client created during setUp().
@@ -1158,8 +1217,13 @@
serialised client request. Output done by the client or server for these
calls will be captured to self.to_server and self.to_client. Each element
in the list is a write call from the client or server respectively.
+
+ Subclasses can override client_protocol_class and server_protocol_class.
"""
+ client_protocol_class = None
+ server_protocol_class = None
+
def setUp(self):
super(TestSmartProtocol, self).setUp()
# XXX: self.server_to_client doesn't seem to be used. If so,
@@ -1169,8 +1233,7 @@
self.to_client = StringIO()
self.client_medium = medium.SmartSimplePipesClientMedium(self.to_client,
self.to_server)
- self.client_protocol = protocol.SmartClientRequestProtocolOne(
- self.client_medium)
+ self.client_protocol = self.client_protocol_class(self.client_medium)
self.smart_server = InstrumentedServerProtocol(self.server_to_client)
self.smart_server_request = request.SmartServerRequestHandler(
None, request.request_handlers)
@@ -1196,8 +1259,7 @@
def build_protocol_waiting_for_body(self):
out_stream = StringIO()
- smart_protocol = protocol.SmartServerRequestProtocolOne(None,
- out_stream.write)
+ smart_protocol = self.server_protocol_class(None, out_stream.write)
smart_protocol.has_dispatched = True
smart_protocol.request = self.smart_server_request
class FakeCommand(object):
@@ -1213,6 +1275,35 @@
smart_protocol.accept_bytes('')
return smart_protocol
+ 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 = self.server_protocol_class(
+ None, server_output.write)
+ server_protocol._send_response(input_tuple)
+ self.assertEqual(expected_bytes, server_output.getvalue())
+ # check the decoding of the client smart_protocol from expected_bytes:
+ input = StringIO(expected_bytes)
+ output = StringIO()
+ client_medium = medium.SmartSimplePipesClientMedium(input, output)
+ request = client_medium.get_request()
+ smart_protocol = self.client_protocol_class(request)
+ smart_protocol.call('foo')
+ self.assertEqual(expected_tuple, smart_protocol.read_response_tuple())
+
+
+class TestSmartProtocolOne(TestSmartProtocol):
+ """Tests for the smart protocol version one."""
+
+ client_protocol_class = protocol.SmartClientRequestProtocolOne
+ server_protocol_class = protocol.SmartServerRequestProtocolOne
+
def test_construct_version_one_server_protocol(self):
smart_protocol = protocol.SmartServerRequestProtocolOne(None, None)
self.assertEqual('', smart_protocol.excess_buffer)
@@ -1282,7 +1373,7 @@
smart_protocol = protocol.SmartServerRequestProtocolOne(
None, out_stream.write)
smart_protocol.accept_bytes('hello\nhello\n')
- self.assertEqual("ok\x011\n", out_stream.getvalue())
+ self.assertEqual("ok\x012\n", out_stream.getvalue())
self.assertEqual("hello\n", smart_protocol.excess_buffer)
self.assertEqual("", smart_protocol.in_buffer)
@@ -1301,7 +1392,7 @@
smart_protocol = protocol.SmartServerRequestProtocolOne(
None, out_stream.write)
smart_protocol.accept_bytes('hello\n')
- self.assertEqual("ok\x011\n", out_stream.getvalue())
+ self.assertEqual("ok\x012\n", out_stream.getvalue())
smart_protocol.accept_bytes('hel')
self.assertEqual("hel", smart_protocol.excess_buffer)
smart_protocol.accept_bytes('lo\n')
@@ -1325,34 +1416,12 @@
# 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()
- client_medium = medium.SmartSimplePipesClientMedium(input, output)
- request = client_medium.get_request()
- smart_protocol = protocol.SmartClientRequestProtocolOne(request)
- self.assertEqual(1, smart_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 = protocol.SmartServerRequestProtocolOne(
- None, server_output.write)
- server_protocol._send_response(input_tuple)
- self.assertEqual(expected_bytes, server_output.getvalue())
- # check the decoding of the client smart_protocol from expected_bytes:
- input = StringIO(expected_bytes)
- output = StringIO()
- client_medium = medium.SmartSimplePipesClientMedium(input, output)
- request = client_medium.get_request()
- smart_protocol = protocol.SmartClientRequestProtocolOne(request)
- smart_protocol.call('foo')
- self.assertEqual(expected_tuple, smart_protocol.read_response_tuple())
+ input = StringIO('ok\x012\n')
+ output = StringIO()
+ client_medium = medium.SmartSimplePipesClientMedium(input, output)
+ request = client_medium.get_request()
+ smart_protocol = protocol.SmartClientRequestProtocolOne(request)
+ self.assertEqual(2, smart_protocol.query_version())
def test_client_call_empty_response(self):
# protocol.call() can get back an empty tuple as a response. This occurs
@@ -1442,6 +1511,223 @@
errors.ReadingCompleted, smart_protocol.read_body_bytes)
+class TestSmartProtocolTwo(TestSmartProtocol):
+ """Tests for the smart protocol version two.
+
+ This test case is mostly the same as TestSmartProtocolOne.
+ """
+
+ client_protocol_class = protocol.SmartClientRequestProtocolTwo
+ server_protocol_class = protocol.SmartServerRequestProtocolTwo
+
+ def test_construct_version_two_server_protocol(self):
+ smart_protocol = protocol.SmartServerRequestProtocolTwo(None, None)
+ self.assertEqual('', smart_protocol.excess_buffer)
+ self.assertEqual('', smart_protocol.in_buffer)
+ self.assertFalse(smart_protocol.has_dispatched)
+ self.assertEqual(1, smart_protocol.next_read_size())
+
+ def test_construct_version_two_client_protocol(self):
+ # we can construct a client protocol from a client medium request
+ output = StringIO()
+ client_medium = medium.SmartSimplePipesClientMedium(None, output)
+ request = client_medium.get_request()
+ client_protocol = protocol.SmartClientRequestProtocolTwo(request)
+
+ def test_server_offset_serialisation(self):
+ """The Smart protocol serialises offsets as a comma and \n string.
+
+ We check a number of boundary cases are as expected: empty, one offset,
+ one with the order of reads not increasing (an out of order read), and
+ one that should coalesce.
+ """
+ self.assertOffsetSerialisation([], '', self.client_protocol)
+ self.assertOffsetSerialisation([(1,2)], '1,2', self.client_protocol)
+ self.assertOffsetSerialisation([(10,40), (0,5)], '10,40\n0,5',
+ self.client_protocol)
+ self.assertOffsetSerialisation([(1,2), (3,4), (100, 200)],
+ '1,2\n3,4\n100,200', self.client_protocol)
+
+ def test_accept_bytes_of_bad_request_to_protocol(self):
+ out_stream = StringIO()
+ smart_protocol = protocol.SmartServerRequestProtocolTwo(
+ None, out_stream.write)
+ smart_protocol.accept_bytes('abc')
+ self.assertEqual('abc', smart_protocol.in_buffer)
+ smart_protocol.accept_bytes('\n')
+ self.assertEqual(
+ "2\nerror\x01Generic bzr smart protocol error: bad request 'abc'\n",
+ out_stream.getvalue())
+ self.assertTrue(smart_protocol.has_dispatched)
+ self.assertEqual(0, smart_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):
+ self._captureVar('BZR_NO_SMART_VFS', None)
+ mem_transport = memory.MemoryTransport()
+ mem_transport.put_bytes('foo', 'abcdefghij')
+ out_stream = StringIO()
+ smart_protocol = protocol.SmartServerRequestProtocolTwo(mem_transport,
+ out_stream.write)
+ smart_protocol.accept_bytes('readv\x01foo\n3\n3,3done\n')
+ self.assertEqual(0, smart_protocol.next_read_size())
+ self.assertEqual('2\nreadv\n3\ndefdone\n', out_stream.getvalue())
+ self.assertEqual('', smart_protocol.excess_buffer)
+ self.assertEqual('', smart_protocol.in_buffer)
+
+ def test_accept_excess_bytes_are_preserved(self):
+ out_stream = StringIO()
+ smart_protocol = protocol.SmartServerRequestProtocolTwo(
+ None, out_stream.write)
+ smart_protocol.accept_bytes('hello\nhello\n')
+ self.assertEqual("2\nok\x012\n", out_stream.getvalue())
+ self.assertEqual("hello\n", smart_protocol.excess_buffer)
+ self.assertEqual("", smart_protocol.in_buffer)
+
+ def test_accept_excess_bytes_after_body(self):
+ # The excess bytes look like the start of another request.
+ protocol = self.build_protocol_waiting_for_body()
+ protocol.accept_bytes('7\nabcdefgdone\n2\n')
+ self.assertTrue(self.end_received)
+ self.assertEqual("2\n", protocol.excess_buffer)
+ self.assertEqual("", protocol.in_buffer)
+ protocol.accept_bytes('Y')
+ self.assertEqual("2\nY", protocol.excess_buffer)
+ self.assertEqual("", protocol.in_buffer)
+
+ def test_accept_excess_bytes_after_dispatch(self):
+ out_stream = StringIO()
+ smart_protocol = protocol.SmartServerRequestProtocolTwo(
+ None, out_stream.write)
+ smart_protocol.accept_bytes('hello\n')
+ self.assertEqual("2\nok\x012\n", out_stream.getvalue())
+ smart_protocol.accept_bytes('2\nhel')
+ self.assertEqual("2\nhel", smart_protocol.excess_buffer)
+ smart_protocol.accept_bytes('lo\n')
+ self.assertEqual("2\nhello\n", smart_protocol.excess_buffer)
+ self.assertEqual("", smart_protocol.in_buffer)
+
+ def test__send_response_sets_finished_reading(self):
+ smart_protocol = protocol.SmartServerRequestProtocolTwo(
+ None, lambda x: None)
+ self.assertEqual(1, smart_protocol.next_read_size())
+ smart_protocol._send_response(('x',))
+ self.assertEqual(0, smart_protocol.next_read_size())
+
+ def test_query_version(self):
+ """query_version on a SmartClientProtocolTwo 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 SmartClientProtocolTwo 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('2\nok\x012\n')
+ output = StringIO()
+ client_medium = medium.SmartSimplePipesClientMedium(input, output)
+ request = client_medium.get_request()
+ smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
+ self.assertEqual(2, smart_protocol.query_version())
+
+ 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('2\n\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('2\na\x01b\x0134\n', ('a', 'b', '34'),
+ [('a', 'b', '34')])
+
+ def test_client_call_with_body_bytes_uploads(self):
+ # protocol.call_with_body_bytes should length-prefix the bytes onto the
+ # wire.
+ expected_bytes = "2\nfoo\n7\nabcdefgdone\n"
+ input = StringIO("\n")
+ output = StringIO()
+ client_medium = medium.SmartSimplePipesClientMedium(input, output)
+ request = client_medium.get_request()
+ smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
+ smart_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 = "2\nfoo\n7\n1,2\n5,6done\n"
+ input = StringIO("\n")
+ output = StringIO()
+ client_medium = medium.SmartSimplePipesClientMedium(input, output)
+ request = client_medium.get_request()
+ smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
+ smart_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 = "2\nok\n7\n1234567done\n"
+ input = StringIO(server_bytes)
+ output = StringIO()
+ client_medium = medium.SmartSimplePipesClientMedium(input, output)
+ request = client_medium.get_request()
+ smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
+ smart_protocol.call('foo')
+ smart_protocol.read_response_tuple(True)
+ self.assertEqual(expected_bytes, smart_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 = "2\nok\n7\n1234567done\n"
+ input = StringIO(server_bytes)
+ output = StringIO()
+ client_medium = medium.SmartSimplePipesClientMedium(input, output)
+ request = client_medium.get_request()
+ smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
+ smart_protocol.call('foo')
+ smart_protocol.read_response_tuple(True)
+ self.assertEqual(expected_bytes[0:2], smart_protocol.read_body_bytes(2))
+ self.assertEqual(expected_bytes[2:4], smart_protocol.read_body_bytes(2))
+ self.assertEqual(expected_bytes[4:6], smart_protocol.read_body_bytes(2))
+ self.assertEqual(expected_bytes[6], smart_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 = "2\nok\n7\n1234567done\n"
+ input = StringIO(server_bytes)
+ output = StringIO()
+ client_medium = medium.SmartSimplePipesClientMedium(input, output)
+ request = client_medium.get_request()
+ smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
+ smart_protocol.call('foo')
+ smart_protocol.read_response_tuple(True)
+ smart_protocol.cancel_read_body()
+ self.assertEqual(5, input.tell())
+ self.assertRaises(
+ errors.ReadingCompleted, smart_protocol.read_body_bytes)
+
+
class TestSmartClientUnicode(tests.TestCase):
"""_SmartClient tests for unicode arguments.
@@ -1601,7 +1887,7 @@
self.addCleanup(http_server.tearDown)
post_body = 'hello\n'
- expected_reply_body = 'ok\x011\n'
+ expected_reply_body = 'ok\x012\n'
http_transport = get_transport(http_server.get_url())
medium = http_transport.get_smart_medium()
@@ -1622,7 +1908,7 @@
self.transport_readonly_server = HTTPServerWithSmarts
post_body = 'hello\n'
- expected_reply_body = 'ok\x011\n'
+ expected_reply_body = 'ok\x012\n'
smart_server_url = self.get_readonly_url('.bzr/smart')
reply = urllib2.urlopen(smart_server_url, post_body).read()
@@ -1648,7 +1934,7 @@
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'
+ expected_end_of_response = '\r\n\r\nok\x012\n'
self.assertEndsWith(response, expected_end_of_response)
=== modified file bzrlib/tests/test_wsgi.py // last-changed:andrew.bennetts at can
... onical.com-20070424083632-f7kadff1wbp3eszn
--- bzrlib/tests/test_wsgi.py
+++ bzrlib/tests/test_wsgi.py
@@ -82,6 +82,12 @@
self.assertEqual('405 Method not allowed', self.status)
self.assertTrue(('Allow', 'POST') in self.headers)
+ def _fake_make_request(self, transport, write_func, bytes):
+ request = FakeRequest(transport, write_func)
+ request.accept_bytes(bytes)
+ self.request = request
+ return request
+
def test_smart_wsgi_app_uses_given_relpath(self):
# The SmartWSGIApp should use the "bzrlib.relpath" field from the
# WSGI environ to clone from its backing transport to get a specific
@@ -89,11 +95,7 @@
transport = FakeTransport()
wsgi_app = wsgi.SmartWSGIApp(transport)
wsgi_app.backing_transport = transport
- def make_request(transport, write_func):
- request = FakeRequest(transport, write_func)
- self.request = request
- return request
- wsgi_app.make_request = make_request
+ wsgi_app.make_request = self._fake_make_request
fake_input = StringIO('fake request')
environ = self.build_environ({
'REQUEST_METHOD': 'POST',
@@ -112,11 +114,7 @@
transport = memory.MemoryTransport()
transport.put_bytes('foo', 'some bytes')
wsgi_app = wsgi.SmartWSGIApp(transport)
- def make_request(transport, write_func):
- request = FakeRequest(transport, write_func)
- self.request = request
- return request
- wsgi_app.make_request = make_request
+ wsgi_app.make_request = self._fake_make_request
fake_input = StringIO('fake request')
environ = self.build_environ({
'REQUEST_METHOD': 'POST',
@@ -186,8 +184,9 @@
def test_incomplete_request(self):
transport = FakeTransport()
wsgi_app = wsgi.SmartWSGIApp(transport)
- def make_request(transport, write_func):
+ def make_request(transport, write_func, bytes):
request = IncompleteRequest(transport, write_func)
+ request.accept_bytes(bytes)
self.request = request
return request
wsgi_app.make_request = make_request
@@ -204,6 +203,41 @@
self.assertEqual('200 OK', self.status)
self.assertEqual('error\x01incomplete request\n', response)
+ def test_protocol_version_detection_one(self):
+ # SmartWSGIApp detects requests that don't start with '2\n' as version
+ # one.
+ transport = memory.MemoryTransport()
+ wsgi_app = wsgi.SmartWSGIApp(transport)
+ fake_input = StringIO('hello\n')
+ environ = self.build_environ({
+ 'REQUEST_METHOD': 'POST',
+ 'CONTENT_LENGTH': len(fake_input.getvalue()),
+ 'wsgi.input': fake_input,
+ 'bzrlib.relpath': 'foo',
+ })
+ iterable = wsgi_app(environ, self.start_response)
+ response = self.read_response(iterable)
+ self.assertEqual('200 OK', self.status)
+ # Expect a version 1-encoded response.
+ self.assertEqual('ok\x012\n', response)
+
+ def test_protocol_version_detection_two(self):
+ # SmartWSGIApp detects requests that start with '2\n' as version two.
+ transport = memory.MemoryTransport()
+ wsgi_app = wsgi.SmartWSGIApp(transport)
+ fake_input = StringIO('2\nhello\n')
+ environ = self.build_environ({
+ 'REQUEST_METHOD': 'POST',
+ 'CONTENT_LENGTH': len(fake_input.getvalue()),
+ 'wsgi.input': fake_input,
+ 'bzrlib.relpath': 'foo',
+ })
+ iterable = wsgi_app(environ, self.start_response)
+ response = self.read_response(iterable)
+ self.assertEqual('200 OK', self.status)
+ # Expect a version 2-encoded response.
+ self.assertEqual('2\nok\x012\n', response)
+
class FakeRequest(object):
=== modified file bzrlib/transport/http/wsgi.py // last-changed:andrew.bennetts
... @canonical.com-20070424083632-f7kadff1wbp3eszn
--- bzrlib/transport/http/wsgi.py
+++ bzrlib/transport/http/wsgi.py
@@ -114,10 +114,10 @@
relpath = environ['bzrlib.relpath']
transport = self.backing_transport.clone(relpath)
out_buffer = StringIO()
- smart_protocol_request = self.make_request(transport, out_buffer.write)
request_data_length = int(environ['CONTENT_LENGTH'])
request_data_bytes = environ['wsgi.input'].read(request_data_length)
- smart_protocol_request.accept_bytes(request_data_bytes)
+ smart_protocol_request = self.make_request(
+ transport, out_buffer.write, request_data_bytes)
if smart_protocol_request.next_read_size() != 0:
# The request appears to be incomplete, or perhaps it's just a
# newer version we don't understand. Regardless, all we can do
@@ -131,5 +131,14 @@
start_response('200 OK', headers)
return [response_data]
- def make_request(self, transport, write_func):
- return protocol.SmartServerRequestProtocolOne(transport, write_func)
+ def make_request(self, transport, write_func, request_bytes):
+ # XXX: This duplicates the logic in
+ # SmartServerStreamMedium._build_protocol.
+ if request_bytes.startswith('2\n'):
+ protocol_class = protocol.SmartServerRequestProtocolTwo
+ request_bytes = request_bytes[2:]
+ else:
+ protocol_class = protocol.SmartServerRequestProtocolOne
+ server_protocol = protocol_class(transport, write_func)
+ server_protocol.accept_bytes(request_bytes)
+ return server_protocol
=== modified directory // last-changed:andrew.bennetts at canonical.com-200704240
... 90150-9buzrpi8lt6qv0tg
# revision id: andrew.bennetts at canonical.com-20070424090150-9buzrpi8lt6qv0tg
# sha1: 5bcf450bcf654da8715cc85faac2979b3c93dd6e
# inventory sha1: e4f31a7b4bfbd07cc4e878b0bdcf4f8518f29faf
# parent ids:
# andrew.bennetts at canonical.com-20070424085029-0o6h7jj68i7sd8ea
# base id: pqm at pqm.ubuntu.com-20070423170758-qd512ltqglzfo6w9
# properties:
# bugs:
# branch-nick: hpss-protocol2
# message:
# Reduce duplication in test_smart_transport.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2007-04-24 18:50:29.293999910 +1000
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3NtYXJ0X3RyYW5zcG9ydC5weQorKysgYnpybGliL3Rlc3Rz
L3Rlc3Rfc21hcnRfdHJhbnNwb3J0LnB5CkBAIC0xMjA2LDggKzEyMDYsOCBAQAogICAgICAgICBz
ZWxmLl93cml0ZV9vdXRwdXRfbGlzdCA9IHdyaXRlX291dHB1dF9saXN0CiAKIAotY2xhc3MgVGVz
dFNtYXJ0UHJvdG9jb2xPbmUodGVzdHMuVGVzdENhc2UpOgotICAgICIiIlRlc3RzIGZvciB0aGUg
c21hcnQgcHJvdG9jb2wuCitjbGFzcyBUZXN0U21hcnRQcm90b2NvbCh0ZXN0cy5UZXN0Q2FzZSk6
CisgICAgIiIiQmFzZSBjbGFzcyBmb3Igc21hcnQgcHJvdG9jb2wgdGVzdHMuCiAKICAgICBFYWNo
IHRlc3QgY2FzZSBnZXRzIGEgc21hcnRfc2VydmVyIGFuZCBzbWFydF9jbGllbnQgY3JlYXRlZCBk
dXJpbmcgc2V0VXAoKS4KIApAQCAtMTIxNywxMCArMTIxNywxNSBAQAogICAgIHNlcmlhbGlzZWQg
Y2xpZW50IHJlcXVlc3QuIE91dHB1dCBkb25lIGJ5IHRoZSBjbGllbnQgb3Igc2VydmVyIGZvciB0
aGVzZQogICAgIGNhbGxzIHdpbGwgYmUgY2FwdHVyZWQgdG8gc2VsZi50b19zZXJ2ZXIgYW5kIHNl
bGYudG9fY2xpZW50LiBFYWNoIGVsZW1lbnQKICAgICBpbiB0aGUgbGlzdCBpcyBhIHdyaXRlIGNh
bGwgZnJvbSB0aGUgY2xpZW50IG9yIHNlcnZlciByZXNwZWN0aXZlbHkuCisKKyAgICBTdWJjbGFz
c2VzIGNhbiBvdmVycmlkZSBjbGllbnRfcHJvdG9jb2xfY2xhc3MgYW5kIHNlcnZlcl9wcm90b2Nv
bF9jbGFzcy4KICAgICAiIiIKIAorICAgIGNsaWVudF9wcm90b2NvbF9jbGFzcyA9IE5vbmUKKyAg
ICBzZXJ2ZXJfcHJvdG9jb2xfY2xhc3MgPSBOb25lCisKICAgICBkZWYgc2V0VXAoc2VsZik6Ci0g
ICAgICAgIHN1cGVyKFRlc3RTbWFydFByb3RvY29sT25lLCBzZWxmKS5zZXRVcCgpCisgICAgICAg
IHN1cGVyKFRlc3RTbWFydFByb3RvY29sLCBzZWxmKS5zZXRVcCgpCiAgICAgICAgICMgWFhYOiBz
ZWxmLnNlcnZlcl90b19jbGllbnQgZG9lc24ndCBzZWVtIHRvIGJlIHVzZWQuICBJZiBzbywKICAg
ICAgICAgIyBJbnN0cnVtZW50ZWRTZXJ2ZXJQcm90b2NvbCBpcyByZWR1bmRhbnQgdG9vLgogICAg
ICAgICBzZWxmLnNlcnZlcl90b19jbGllbnQgPSBbXQpAQCAtMTIyOCw4ICsxMjMzLDcgQEAKICAg
ICAgICAgc2VsZi50b19jbGllbnQgPSBTdHJpbmdJTygpCiAgICAgICAgIHNlbGYuY2xpZW50X21l
ZGl1bSA9IG1lZGl1bS5TbWFydFNpbXBsZVBpcGVzQ2xpZW50TWVkaXVtKHNlbGYudG9fY2xpZW50
LAogICAgICAgICAgICAgc2VsZi50b19zZXJ2ZXIpCi0gICAgICAgIHNlbGYuY2xpZW50X3Byb3Rv
Y29sID0gcHJvdG9jb2wuU21hcnRDbGllbnRSZXF1ZXN0UHJvdG9jb2xPbmUoCi0gICAgICAgICAg
ICBzZWxmLmNsaWVudF9tZWRpdW0pCisgICAgICAgIHNlbGYuY2xpZW50X3Byb3RvY29sID0gc2Vs
Zi5jbGllbnRfcHJvdG9jb2xfY2xhc3Moc2VsZi5jbGllbnRfbWVkaXVtKQogICAgICAgICBzZWxm
LnNtYXJ0X3NlcnZlciA9IEluc3RydW1lbnRlZFNlcnZlclByb3RvY29sKHNlbGYuc2VydmVyX3Rv
X2NsaWVudCkKICAgICAgICAgc2VsZi5zbWFydF9zZXJ2ZXJfcmVxdWVzdCA9IHJlcXVlc3QuU21h
cnRTZXJ2ZXJSZXF1ZXN0SGFuZGxlcigKICAgICAgICAgICAgIE5vbmUsIHJlcXVlc3QucmVxdWVz
dF9oYW5kbGVycykKQEAgLTEyNTUsOCArMTI1OSw3IEBACiAKICAgICBkZWYgYnVpbGRfcHJvdG9j
b2xfd2FpdGluZ19mb3JfYm9keShzZWxmKToKICAgICAgICAgb3V0X3N0cmVhbSA9IFN0cmluZ0lP
KCkKLSAgICAgICAgc21hcnRfcHJvdG9jb2wgPSBwcm90b2NvbC5TbWFydFNlcnZlclJlcXVlc3RQ
cm90b2NvbE9uZShOb25lLAotICAgICAgICAgICAgICAgIG91dF9zdHJlYW0ud3JpdGUpCisgICAg
ICAgIHNtYXJ0X3Byb3RvY29sID0gc2VsZi5zZXJ2ZXJfcHJvdG9jb2xfY2xhc3MoTm9uZSwgb3V0
X3N0cmVhbS53cml0ZSkKICAgICAgICAgc21hcnRfcHJvdG9jb2wuaGFzX2Rpc3BhdGNoZWQgPSBU
cnVlCiAgICAgICAgIHNtYXJ0X3Byb3RvY29sLnJlcXVlc3QgPSBzZWxmLnNtYXJ0X3NlcnZlcl9y
ZXF1ZXN0CiAgICAgICAgIGNsYXNzIEZha2VDb21tYW5kKG9iamVjdCk6CkBAIC0xMjcyLDYgKzEy
NzUsMzUgQEAKICAgICAgICAgc21hcnRfcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCcnKQogICAgICAg
ICByZXR1cm4gc21hcnRfcHJvdG9jb2wKIAorICAgIGRlZiBhc3NlcnRTZXJ2ZXJUb0NsaWVudEVu
Y29kaW5nKHNlbGYsIGV4cGVjdGVkX2J5dGVzLCBleHBlY3RlZF90dXBsZSwKKyAgICAgICAgICAg
IGlucHV0X3R1cGxlcyk6CisgICAgICAgICIiIkFzc2VydCB0aGF0IGVhY2ggaW5wdXRfdHVwbGUg
c2VyaWFsaXNlcyBhcyBleHBlY3RlZF9ieXRlcywgYW5kIHRoZQorICAgICAgICBieXRlcyBkZXNl
cmlhbGlzZSBhcyBleHBlY3RlZF90dXBsZS4KKyAgICAgICAgIiIiCisgICAgICAgICMgY2hlY2sg
dGhlIGVuY29kaW5nIG9mIHRoZSBzZXJ2ZXIgZm9yIGFsbCBpbnB1dF90dXBsZXMgbWF0Y2hlcwor
ICAgICAgICAjIGV4cGVjdGVkIGJ5dGVzCisgICAgICAgIGZvciBpbnB1dF90dXBsZSBpbiBpbnB1
dF90dXBsZXM6CisgICAgICAgICAgICBzZXJ2ZXJfb3V0cHV0ID0gU3RyaW5nSU8oKQorICAgICAg
ICAgICAgc2VydmVyX3Byb3RvY29sID0gc2VsZi5zZXJ2ZXJfcHJvdG9jb2xfY2xhc3MoCisgICAg
ICAgICAgICAgICAgTm9uZSwgc2VydmVyX291dHB1dC53cml0ZSkKKyAgICAgICAgICAgIHNlcnZl
cl9wcm90b2NvbC5fc2VuZF9yZXNwb25zZShpbnB1dF90dXBsZSkKKyAgICAgICAgICAgIHNlbGYu
YXNzZXJ0RXF1YWwoZXhwZWN0ZWRfYnl0ZXMsIHNlcnZlcl9vdXRwdXQuZ2V0dmFsdWUoKSkKKyAg
ICAgICAgIyBjaGVjayB0aGUgZGVjb2Rpbmcgb2YgdGhlIGNsaWVudCBzbWFydF9wcm90b2NvbCBm
cm9tIGV4cGVjdGVkX2J5dGVzOgorICAgICAgICBpbnB1dCA9IFN0cmluZ0lPKGV4cGVjdGVkX2J5
dGVzKQorICAgICAgICBvdXRwdXQgPSBTdHJpbmdJTygpCisgICAgICAgIGNsaWVudF9tZWRpdW0g
PSBtZWRpdW0uU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShpbnB1dCwgb3V0cHV0KQorICAg
ICAgICByZXF1ZXN0ID0gY2xpZW50X21lZGl1bS5nZXRfcmVxdWVzdCgpCisgICAgICAgIHNtYXJ0
X3Byb3RvY29sID0gc2VsZi5jbGllbnRfcHJvdG9jb2xfY2xhc3MocmVxdWVzdCkKKyAgICAgICAg
c21hcnRfcHJvdG9jb2wuY2FsbCgnZm9vJykKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChleHBl
Y3RlZF90dXBsZSwgc21hcnRfcHJvdG9jb2wucmVhZF9yZXNwb25zZV90dXBsZSgpKQorCisKK2Ns
YXNzIFRlc3RTbWFydFByb3RvY29sT25lKFRlc3RTbWFydFByb3RvY29sKToKKyAgICAiIiJUZXN0
cyBmb3IgdGhlIHNtYXJ0IHByb3RvY29sIHZlcnNpb24gb25lLiIiIgorCisgICAgY2xpZW50X3By
b3RvY29sX2NsYXNzID0gcHJvdG9jb2wuU21hcnRDbGllbnRSZXF1ZXN0UHJvdG9jb2xPbmUKKyAg
ICBzZXJ2ZXJfcHJvdG9jb2xfY2xhc3MgPSBwcm90b2NvbC5TbWFydFNlcnZlclJlcXVlc3RQcm90
b2NvbE9uZQorCiAgICAgZGVmIHRlc3RfY29uc3RydWN0X3ZlcnNpb25fb25lX3NlcnZlcl9wcm90
b2NvbChzZWxmKToKICAgICAgICAgc21hcnRfcHJvdG9jb2wgPSBwcm90b2NvbC5TbWFydFNlcnZl
clJlcXVlc3RQcm90b2NvbE9uZShOb25lLCBOb25lKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFs
KCcnLCBzbWFydF9wcm90b2NvbC5leGNlc3NfYnVmZmVyKQpAQCAtMTM5MSwyOCArMTQyMyw2IEBA
CiAgICAgICAgIHNtYXJ0X3Byb3RvY29sID0gcHJvdG9jb2wuU21hcnRDbGllbnRSZXF1ZXN0UHJv
dG9jb2xPbmUocmVxdWVzdCkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgyLCBzbWFydF9wcm90
b2NvbC5xdWVyeV92ZXJzaW9uKCkpCiAKLSAgICBkZWYgYXNzZXJ0U2VydmVyVG9DbGllbnRFbmNv
ZGluZyhzZWxmLCBleHBlY3RlZF9ieXRlcywgZXhwZWN0ZWRfdHVwbGUsCi0gICAgICAgICAgICBp
bnB1dF90dXBsZXMpOgotICAgICAgICAiIiJBc3NlcnQgdGhhdCBlYWNoIGlucHV0X3R1cGxlIHNl
cmlhbGlzZXMgYXMgZXhwZWN0ZWRfYnl0ZXMsIGFuZCB0aGUKLSAgICAgICAgYnl0ZXMgZGVzZXJp
YWxpc2UgYXMgZXhwZWN0ZWRfdHVwbGUuCi0gICAgICAgICIiIgotICAgICAgICAjIGNoZWNrIHRo
ZSBlbmNvZGluZyBvZiB0aGUgc2VydmVyIGZvciBhbGwgaW5wdXRfdHVwbGVzIG1hdGNoZXMKLSAg
ICAgICAgIyBleHBlY3RlZCBieXRlcwotICAgICAgICBmb3IgaW5wdXRfdHVwbGUgaW4gaW5wdXRf
dHVwbGVzOgotICAgICAgICAgICAgc2VydmVyX291dHB1dCA9IFN0cmluZ0lPKCkKLSAgICAgICAg
ICAgIHNlcnZlcl9wcm90b2NvbCA9IHByb3RvY29sLlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29s
T25lKAotICAgICAgICAgICAgICAgIE5vbmUsIHNlcnZlcl9vdXRwdXQud3JpdGUpCi0gICAgICAg
ICAgICBzZXJ2ZXJfcHJvdG9jb2wuX3NlbmRfcmVzcG9uc2UoaW5wdXRfdHVwbGUpCi0gICAgICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX2J5dGVzLCBzZXJ2ZXJfb3V0cHV0LmdldHZh
bHVlKCkpCi0gICAgICAgICMgY2hlY2sgdGhlIGRlY29kaW5nIG9mIHRoZSBjbGllbnQgc21hcnRf
cHJvdG9jb2wgZnJvbSBleHBlY3RlZF9ieXRlczoKLSAgICAgICAgaW5wdXQgPSBTdHJpbmdJTyhl
eHBlY3RlZF9ieXRlcykKLSAgICAgICAgb3V0cHV0ID0gU3RyaW5nSU8oKQotICAgICAgICBjbGll
bnRfbWVkaXVtID0gbWVkaXVtLlNtYXJ0U2ltcGxlUGlwZXNDbGllbnRNZWRpdW0oaW5wdXQsIG91
dHB1dCkKLSAgICAgICAgcmVxdWVzdCA9IGNsaWVudF9tZWRpdW0uZ2V0X3JlcXVlc3QoKQotICAg
ICAgICBzbWFydF9wcm90b2NvbCA9IHByb3RvY29sLlNtYXJ0Q2xpZW50UmVxdWVzdFByb3RvY29s
T25lKHJlcXVlc3QpCi0gICAgICAgIHNtYXJ0X3Byb3RvY29sLmNhbGwoJ2ZvbycpCi0gICAgICAg
IHNlbGYuYXNzZXJ0RXF1YWwoZXhwZWN0ZWRfdHVwbGUsIHNtYXJ0X3Byb3RvY29sLnJlYWRfcmVz
cG9uc2VfdHVwbGUoKSkKLQogICAgIGRlZiB0ZXN0X2NsaWVudF9jYWxsX2VtcHR5X3Jlc3BvbnNl
KHNlbGYpOgogICAgICAgICAjIHByb3RvY29sLmNhbGwoKSBjYW4gZ2V0IGJhY2sgYW4gZW1wdHkg
dHVwbGUgYXMgYSByZXNwb25zZS4gVGhpcyBvY2N1cnMKICAgICAgICAgIyB3aGVuIHRoZSBwYXJz
ZWQgbGluZSBpcyBhbiBlbXB0eSBsaW5lLCBhbmQgcmVzdWx0cyBpbiBhIHR1cGxlIHdpdGgKQEAg
LTE1MDEsNzMgKzE1MTEsMTQgQEAKICAgICAgICAgICAgIGVycm9ycy5SZWFkaW5nQ29tcGxldGVk
LCBzbWFydF9wcm90b2NvbC5yZWFkX2JvZHlfYnl0ZXMpCiAKIAotY2xhc3MgVGVzdFNtYXJ0UHJv
dG9jb2xUd28odGVzdHMuVGVzdENhc2UpOgorY2xhc3MgVGVzdFNtYXJ0UHJvdG9jb2xUd28oVGVz
dFNtYXJ0UHJvdG9jb2wpOgogICAgICIiIlRlc3RzIGZvciB0aGUgc21hcnQgcHJvdG9jb2wgdmVy
c2lvbiB0d28uCiAKLSAgICBFYWNoIHRlc3QgY2FzZSBnZXRzIGEgc21hcnRfc2VydmVyIGFuZCBz
bWFydF9jbGllbnQgY3JlYXRlZCBkdXJpbmcgc2V0VXAoKS4KLQotICAgIEl0IGlzIHBsYW5uZWQg
dGhhdCB0aGUgY2xpZW50IGNhbiBiZSBjYWxsZWQgd2l0aCBzZWxmLmNhbGxfY2xpZW50KCkgZ2l2
aW5nCi0gICAgaXQgYW4gZXhwZWN0ZWQgc2VydmVyIHJlc3BvbnNlLCB3aGljaCB3aWxsIGJlIGZl
ZCBpbnRvIGl0IHdoZW4gaXQgdHJpZXMgdG8KLSAgICByZWFkLiBMaWtld2lzZSwgc2VsZi5jYWxs
X3NlcnZlciB3aWxsIGNhbGwgYSBzZXJ2ZXJzIG1ldGhvZCB3aXRoIGEgY2FubmVkCi0gICAgc2Vy
aWFsaXNlZCBjbGllbnQgcmVxdWVzdC4gT3V0cHV0IGRvbmUgYnkgdGhlIGNsaWVudCBvciBzZXJ2
ZXIgZm9yIHRoZXNlCi0gICAgY2FsbHMgd2lsbCBiZSBjYXB0dXJlZCB0byBzZWxmLnRvX3NlcnZl
ciBhbmQgc2VsZi50b19jbGllbnQuIEVhY2ggZWxlbWVudAotICAgIGluIHRoZSBsaXN0IGlzIGEg
d3JpdGUgY2FsbCBmcm9tIHRoZSBjbGllbnQgb3Igc2VydmVyIHJlc3BlY3RpdmVseS4KLQogICAg
IFRoaXMgdGVzdCBjYXNlIGlzIG1vc3RseSB0aGUgc2FtZSBhcyBUZXN0U21hcnRQcm90b2NvbE9u
ZS4KICAgICAiIiIKIAotICAgIGRlZiBzZXRVcChzZWxmKToKLSAgICAgICAgc3VwZXIoVGVzdFNt
YXJ0UHJvdG9jb2xUd28sIHNlbGYpLnNldFVwKCkKLSAgICAgICAgIyBYWFg6IHNlbGYuc2VydmVy
X3RvX2NsaWVudCBkb2Vzbid0IHNlZW0gdG8gYmUgdXNlZC4gIElmIHNvLAotICAgICAgICAjIElu
c3RydW1lbnRlZFNlcnZlclByb3RvY29sIGlzIHJlZHVuZGFudCB0b28uCi0gICAgICAgIHNlbGYu
c2VydmVyX3RvX2NsaWVudCA9IFtdCi0gICAgICAgIHNlbGYudG9fc2VydmVyID0gU3RyaW5nSU8o
KQotICAgICAgICBzZWxmLnRvX2NsaWVudCA9IFN0cmluZ0lPKCkKLSAgICAgICAgc2VsZi5jbGll
bnRfbWVkaXVtID0gbWVkaXVtLlNtYXJ0U2ltcGxlUGlwZXNDbGllbnRNZWRpdW0oc2VsZi50b19j
bGllbnQsCi0gICAgICAgICAgICBzZWxmLnRvX3NlcnZlcikKLSAgICAgICAgc2VsZi5jbGllbnRf
cHJvdG9jb2wgPSBwcm90b2NvbC5TbWFydENsaWVudFJlcXVlc3RQcm90b2NvbFR3bygKLSAgICAg
ICAgICAgIHNlbGYuY2xpZW50X21lZGl1bSkKLSAgICAgICAgc2VsZi5zbWFydF9zZXJ2ZXIgPSBJ
bnN0cnVtZW50ZWRTZXJ2ZXJQcm90b2NvbChzZWxmLnNlcnZlcl90b19jbGllbnQpCi0gICAgICAg
IHNlbGYuc21hcnRfc2VydmVyX3JlcXVlc3QgPSByZXF1ZXN0LlNtYXJ0U2VydmVyUmVxdWVzdEhh
bmRsZXIoCi0gICAgICAgICAgICBOb25lLCByZXF1ZXN0LnJlcXVlc3RfaGFuZGxlcnMpCi0KLSAg
ICBkZWYgYXNzZXJ0T2Zmc2V0U2VyaWFsaXNhdGlvbihzZWxmLCBleHBlY3RlZF9vZmZzZXRzLCBl
eHBlY3RlZF9zZXJpYWxpc2VkLAotICAgICAgICBjbGllbnQpOgotICAgICAgICAiIiJDaGVjayB0
aGF0IHNtYXJ0IChkZSlzZXJpYWxpc2VzIG9mZnNldHMgYXMgZXhwZWN0ZWQuCi0gICAgICAgIAot
ICAgICAgICBXZSBjaGVjayBib3RoIHNlcmlhbGlzYXRpb24gYW5kIGRlc2VyaWFsaXNhdGlvbiBh
dCB0aGUgc2FtZSB0aW1lCi0gICAgICAgIHRvIGVuc3VyZSB0aGF0IHRoZSByb3VuZCB0cmlwcGlu
ZyBjYW5ub3Qgc2tldzogYm90aCBkaXJlY3Rpb25zIHNob3VsZAotICAgICAgICBiZSBhcyBleHBl
Y3RlZC4KLSAgICAgICAgCi0gICAgICAgIDpwYXJhbSBleHBlY3RlZF9vZmZzZXRzOiBhIHJlYWR2
IG9mZnNldCBsaXN0LgotICAgICAgICA6cGFyYW0gZXhwZWN0ZWRfc2VyYWxpc2VkOiBhbiBleHBl
Y3RlZCBzZXJpYWwgZm9ybSBvZiB0aGUgb2Zmc2V0cy4KLSAgICAgICAgIiIiCi0gICAgICAgICMg
WFhYOiAnX2Rlc2VyaWFsaXNlX29mZnNldHMnIHNob3VsZCBiZSBhIG1ldGhvZCBvZiB0aGUKLSAg
ICAgICAgIyBTbWFydFNlcnZlclJlcXVlc3RQcm90b2NvbCBpbiBmdXR1cmUuCi0gICAgICAgIHJl
YWR2X2NtZCA9IHZmcy5SZWFkdlJlcXVlc3QoTm9uZSkKLSAgICAgICAgb2Zmc2V0cyA9IHJlYWR2
X2NtZC5fZGVzZXJpYWxpc2Vfb2Zmc2V0cyhleHBlY3RlZF9zZXJpYWxpc2VkKQotICAgICAgICBz
ZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX29mZnNldHMsIG9mZnNldHMpCi0gICAgICAgIHNlcmlh
bGlzZWQgPSBjbGllbnQuX3NlcmlhbGlzZV9vZmZzZXRzKG9mZnNldHMpCi0gICAgICAgIHNlbGYu
YXNzZXJ0RXF1YWwoZXhwZWN0ZWRfc2VyaWFsaXNlZCwgc2VyaWFsaXNlZCkKLQotICAgIGRlZiBi
dWlsZF9wcm90b2NvbF93YWl0aW5nX2Zvcl9ib2R5KHNlbGYpOgotICAgICAgICBvdXRfc3RyZWFt
ID0gU3RyaW5nSU8oKQotICAgICAgICBzbWFydF9wcm90b2NvbCA9IHByb3RvY29sLlNtYXJ0U2Vy
dmVyUmVxdWVzdFByb3RvY29sVHdvKE5vbmUsCi0gICAgICAgICAgICAgICAgb3V0X3N0cmVhbS53
cml0ZSkKLSAgICAgICAgc21hcnRfcHJvdG9jb2wuaGFzX2Rpc3BhdGNoZWQgPSBUcnVlCi0gICAg
ICAgIHNtYXJ0X3Byb3RvY29sLnJlcXVlc3QgPSBzZWxmLnNtYXJ0X3NlcnZlcl9yZXF1ZXN0Ci0g
ICAgICAgIGNsYXNzIEZha2VDb21tYW5kKG9iamVjdCk6Ci0gICAgICAgICAgICBkZWYgZG9fYm9k
eShjbWQsIGJvZHlfYnl0ZXMpOgotICAgICAgICAgICAgICAgIHNlbGYuZW5kX3JlY2VpdmVkID0g
VHJ1ZQotICAgICAgICAgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ2FiY2RlZmcnLCBib2R5X2J5
dGVzKQotICAgICAgICAgICAgICAgIHJldHVybiByZXF1ZXN0LlNtYXJ0U2VydmVyUmVzcG9uc2Uo
KCdvaycsICkpCi0gICAgICAgIHNtYXJ0X3Byb3RvY29sLnJlcXVlc3QuX2NvbW1hbmQgPSBGYWtl
Q29tbWFuZCgpCi0gICAgICAgICMgQ2FsbCBhY2NlcHRfYnl0ZXMgdG8gbWFrZSBzdXJlIHRoYXQg
aW50ZXJuYWwgc3RhdGUgbGlrZSBfYm9keV9kZWNvZGVyCi0gICAgICAgICMgaXMgaW5pdGlhbGlz
ZWQuICBUaGlzIHRlc3Qgc2hvdWxkIHByb2JhYmx5IGJlIGdpdmVuIGEgY2xlYXJlcgotICAgICAg
ICAjIGludGVyZmFjZSB0byB3b3JrIHdpdGggdGhhdCB3aWxsIG5vdCBjYXVzZSB0aGlzIGluY29u
c2lzdGVuY3kuCi0gICAgICAgICMgICAtLSBBbmRyZXcgQmVubmV0dHMsIDIwMDYtMDktMjgKLSAg
ICAgICAgc21hcnRfcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCcnKQotICAgICAgICByZXR1cm4gc21h
cnRfcHJvdG9jb2wKKyAgICBjbGllbnRfcHJvdG9jb2xfY2xhc3MgPSBwcm90b2NvbC5TbWFydENs
aWVudFJlcXVlc3RQcm90b2NvbFR3bworICAgIHNlcnZlcl9wcm90b2NvbF9jbGFzcyA9IHByb3Rv
Y29sLlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29sVHdvCiAKICAgICBkZWYgdGVzdF9jb25zdHJ1
Y3RfdmVyc2lvbl90d29fc2VydmVyX3Byb3RvY29sKHNlbGYpOgogICAgICAgICBzbWFydF9wcm90
b2NvbCA9IHByb3RvY29sLlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29sVHdvKE5vbmUsIE5vbmUp
CkBAIC0xNjg5LDM1ICsxNjQwLDEzIEBACiAgICAgICAgIHNtYXJ0X3Byb3RvY29sID0gcHJvdG9j
b2wuU21hcnRDbGllbnRSZXF1ZXN0UHJvdG9jb2xUd28ocmVxdWVzdCkKICAgICAgICAgc2VsZi5h
c3NlcnRFcXVhbCgyLCBzbWFydF9wcm90b2NvbC5xdWVyeV92ZXJzaW9uKCkpCiAKLSAgICBkZWYg
YXNzZXJ0U2VydmVyVG9DbGllbnRFbmNvZGluZyhzZWxmLCBleHBlY3RlZF9ieXRlcywgZXhwZWN0
ZWRfdHVwbGUsCi0gICAgICAgICAgICBpbnB1dF90dXBsZXMpOgotICAgICAgICAiIiJBc3NlcnQg
dGhhdCBlYWNoIGlucHV0X3R1cGxlIHNlcmlhbGlzZXMgYXMgZXhwZWN0ZWRfYnl0ZXMsIGFuZCB0
aGUKLSAgICAgICAgYnl0ZXMgZGVzZXJpYWxpc2UgYXMgZXhwZWN0ZWRfdHVwbGUuCi0gICAgICAg
ICIiIgotICAgICAgICAjIGNoZWNrIHRoZSBlbmNvZGluZyBvZiB0aGUgc2VydmVyIGZvciBhbGwg
aW5wdXRfdHVwbGVzIG1hdGNoZXMKLSAgICAgICAgIyBleHBlY3RlZCBieXRlcwotICAgICAgICBm
b3IgaW5wdXRfdHVwbGUgaW4gaW5wdXRfdHVwbGVzOgotICAgICAgICAgICAgc2VydmVyX291dHB1
dCA9IFN0cmluZ0lPKCkKLSAgICAgICAgICAgIHNlcnZlcl9wcm90b2NvbCA9IHByb3RvY29sLlNt
YXJ0U2VydmVyUmVxdWVzdFByb3RvY29sVHdvKAotICAgICAgICAgICAgICAgIE5vbmUsIHNlcnZl
cl9vdXRwdXQud3JpdGUpCi0gICAgICAgICAgICBzZXJ2ZXJfcHJvdG9jb2wuX3NlbmRfcmVzcG9u
c2UoaW5wdXRfdHVwbGUpCi0gICAgICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX2J5
dGVzLCBzZXJ2ZXJfb3V0cHV0LmdldHZhbHVlKCkpCi0gICAgICAgICMgY2hlY2sgdGhlIGRlY29k
aW5nIG9mIHRoZSBjbGllbnQgc21hcnRfcHJvdG9jb2wgZnJvbSBleHBlY3RlZF9ieXRlczoKLSAg
ICAgICAgaW5wdXQgPSBTdHJpbmdJTyhleHBlY3RlZF9ieXRlcykKLSAgICAgICAgb3V0cHV0ID0g
U3RyaW5nSU8oKQotICAgICAgICBjbGllbnRfbWVkaXVtID0gbWVkaXVtLlNtYXJ0U2ltcGxlUGlw
ZXNDbGllbnRNZWRpdW0oaW5wdXQsIG91dHB1dCkKLSAgICAgICAgcmVxdWVzdCA9IGNsaWVudF9t
ZWRpdW0uZ2V0X3JlcXVlc3QoKQotICAgICAgICBzbWFydF9wcm90b2NvbCA9IHByb3RvY29sLlNt
YXJ0Q2xpZW50UmVxdWVzdFByb3RvY29sVHdvKHJlcXVlc3QpCi0gICAgICAgIHNtYXJ0X3Byb3Rv
Y29sLmNhbGwoJ2ZvbycpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoZXhwZWN0ZWRfdHVwbGUs
IHNtYXJ0X3Byb3RvY29sLnJlYWRfcmVzcG9uc2VfdHVwbGUoKSkKLQogICAgIGRlZiB0ZXN0X2Ns
aWVudF9jYWxsX2VtcHR5X3Jlc3BvbnNlKHNlbGYpOgogICAgICAgICAjIHByb3RvY29sLmNhbGwo
KSBjYW4gZ2V0IGJhY2sgYW4gZW1wdHkgdHVwbGUgYXMgYSByZXNwb25zZS4gVGhpcyBvY2N1cnMK
ICAgICAgICAgIyB3aGVuIHRoZSBwYXJzZWQgbGluZSBpcyBhbiBlbXB0eSBsaW5lLCBhbmQgcmVz
dWx0cyBpbiBhIHR1cGxlIHdpdGgKICAgICAgICAgIyBvbmUgZWxlbWVudCAtIGFuIGVtcHR5IHN0
cmluZy4KICAgICAgICAgc2VsZi5hc3NlcnRTZXJ2ZXJUb0NsaWVudEVuY29kaW5nKCcyXG5cbics
ICgnJywgKSwgWygpLCAoJycsICldKQogCi0gICAgZGVmIHVudGVzdF9jbGllbnRfY2FsbF90aHJl
ZV9lbGVtZW50X3Jlc3BvbnNlKHNlbGYpOgorICAgIGRlZiB0ZXN0X2NsaWVudF9jYWxsX3RocmVl
X2VsZW1lbnRfcmVzcG9uc2Uoc2VsZik6CiAgICAgICAgICMgcHJvdG9jb2wuY2FsbCgpIGNhbiBn
ZXQgYmFjayB0dXBsZXMgb2Ygb3RoZXIgbGVuZ3Rocy4gQSB0aHJlZSBlbGVtZW50CiAgICAgICAg
ICMgdHVwbGUgc2hvdWxkIGJlIHVucGFja2VkIGFzIHRocmVlIHN0cmluZ3MuCiAgICAgICAgIHNl
bGYuYXNzZXJ0U2VydmVyVG9DbGllbnRFbmNvZGluZygnMlxuYVx4MDFiXHgwMTM0XG4nLCAoJ2En
LCAnYicsICczNCcpLAoK
=== modified directory // last-changed:andrew.bennetts at canonical.com-200704240
... 85029-0o6h7jj68i7sd8ea
# revision id: andrew.bennetts at canonical.com-20070424085029-0o6h7jj68i7sd8ea
# sha1: 110ad8f48869362eac197209483a029c0d8e571a
# inventory sha1: 2b73ef944dbec833d7bca8be3cfc24e14470c66c
# parent ids:
# andrew.bennetts at canonical.com-20070424083632-f7kadff1wbp3eszn
# properties:
# bugs:
# branch-nick: hpss-protocol2
# message:
# Change smart protocol version two prefix to '2\n'.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2007-04-24 18:36:32.831000090 +1000
=== modified file bzrlib/smart/medium.py // encoding:base64
LS0tIGJ6cmxpYi9zbWFydC9tZWRpdW0ucHkKKysrIGJ6cmxpYi9zbWFydC9tZWRpdW0ucHkKQEAg
LTc5LDcgKzc5LDcgQEAKICAgICBkZWYgX2J1aWxkX3Byb3RvY29sKHNlbGYpOgogICAgICAgICAj
IElkZW50aWZ5IHRoZSBwcm90b2NvbCB2ZXJzaW9uLgogICAgICAgICBieXRlcyA9IHNlbGYuX2dl
dF9ieXRlcygyKQotICAgICAgICBpZiBieXRlcy5zdGFydHN3aXRoKCcyXHgwMScpOgorICAgICAg
ICBpZiBieXRlcy5zdGFydHN3aXRoKCcyXG4nKToKICAgICAgICAgICAgIHByb3RvY29sX2NsYXNz
ID0gU21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xUd28KICAgICAgICAgICAgIGJ5dGVzID0gYnl0
ZXNbMjpdCiAgICAgICAgIGVsc2U6Cgo=
=== modified file bzrlib/smart/protocol.py // encoding:base64
LS0tIGJ6cmxpYi9zbWFydC9wcm90b2NvbC5weQorKysgYnpybGliL3NtYXJ0L3Byb3RvY29sLnB5
CkBAIC0xNjAsMTUgKzE2MCwxNSBAQAogY2xhc3MgU21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xU
d28oU21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xPbmUpOgogICAgIHIiIiJWZXJzaW9uIHR3byBv
ZiB0aGUgc2VydmVyIHNpZGUgb2YgdGhlIHNtYXJ0IHByb3RvY29sLgogICAgCi0gICAgVGhpcyBw
cmVmaXhlcyByZXNwb25zZXMgd2l0aCB0aGUgcHJvdG9jb2wgdmVyc2lvbjogIjJceDAxIi4KKyAg
ICBUaGlzIHByZWZpeGVzIHJlc3BvbnNlcyB3aXRoIHRoZSBwcm90b2NvbCB2ZXJzaW9uOiAiMlxu
Ii4KICAgICAiIiIKIAogICAgIGRlZiBfd3JpdGVfcHJvdG9jb2xfdmVyc2lvbihzZWxmKToKICAg
ICAgICAgciIiIldyaXRlIGFueSBwcmVmaXhlcyB0aGlzIHByb3RvY29sIHJlcXVpcmVzLgogICAg
ICAgICAKLSAgICAgICAgVmVyc2lvbiB0d28gc2VuZHMgIjJceDAxIi4KKyAgICAgICAgVmVyc2lv
biB0d28gc2VuZHMgIjJcbiIuCiAgICAgICAgICIiIgotICAgICAgICBzZWxmLl93cml0ZV9mdW5j
KCcyXHgwMScpCisgICAgICAgIHNlbGYuX3dyaXRlX2Z1bmMoJzJcbicpCiAKIAogY2xhc3MgTGVu
Z3RoUHJlZml4ZWRCb2R5RGVjb2RlcihvYmplY3QpOgpAQCAtMzc0LDEwICszNzQsMTAgQEAKIGNs
YXNzIFNtYXJ0Q2xpZW50UmVxdWVzdFByb3RvY29sVHdvKFNtYXJ0Q2xpZW50UmVxdWVzdFByb3Rv
Y29sT25lKToKICAgICByIiIiVmVyc2lvbiB0d28gb2YgdGhlIGNsaWVudCBzaWRlIG9mIHRoZSBz
bWFydCBwcm90b2NvbC4KICAgICAKLSAgICBUaGlzIHByZWZpeGVzIHRoZSByZXF1ZXN0IHdpdGgg
dGhlIHByb3RvY29sIHZlcnNpb246ICIyXHgwMSIuCisgICAgVGhpcyBwcmVmaXhlcyB0aGUgcmVx
dWVzdCB3aXRoIHRoZSBwcm90b2NvbCB2ZXJzaW9uOiAiMlxuIi4KICAgICAiIiIKIAotICAgIF92
ZXJzaW9uX3N0cmluZyA9ICcyXHgwMScKKyAgICBfdmVyc2lvbl9zdHJpbmcgPSAnMlxuJwogCiAg
ICAgZGVmIHJlYWRfcmVzcG9uc2VfdHVwbGUoc2VsZiwgZXhwZWN0X2JvZHk9RmFsc2UpOgogICAg
ICAgICAiIiJSZWFkIGEgcmVzcG9uc2UgdHVwbGUgZnJvbSB0aGUgd2lyZS4KQEAgLTM5Miw3ICsz
OTIsNyBAQAogICAgIGRlZiBfd3JpdGVfcHJvdG9jb2xfdmVyc2lvbihzZWxmKToKICAgICAgICAg
ciIiIldyaXRlIGFueSBwcmVmaXhlcyB0aGlzIHByb3RvY29sIHJlcXVpcmVzLgogICAgICAgICAK
LSAgICAgICAgVmVyc2lvbiB0d28gc2VuZHMgIjJceDAxIi4KKyAgICAgICAgVmVyc2lvbiB0d28g
c2VuZHMgIjJcbiIuCiAgICAgICAgICIiIgogICAgICAgICBzZWxmLl9yZXF1ZXN0LmFjY2VwdF9i
eXRlcyhTbWFydENsaWVudFJlcXVlc3RQcm90b2NvbFR3by5fdmVyc2lvbl9zdHJpbmcpCiAKCg==
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/tests/test_wsgi.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3dzZ2kucHkKKysrIGJ6cmxpYi90ZXN0cy90ZXN0X3dzZ2ku
cHkKQEAgLTIwNCw3ICsyMDQsNyBAQAogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCdlcnJvclx4
MDFpbmNvbXBsZXRlIHJlcXVlc3RcbicsIHJlc3BvbnNlKQogCiAgICAgZGVmIHRlc3RfcHJvdG9j
b2xfdmVyc2lvbl9kZXRlY3Rpb25fb25lKHNlbGYpOgotICAgICAgICAjIFNtYXJ0V1NHSUFwcCBk
ZXRlY3RzIHJlcXVlc3RzIHRoYXQgZG9uJ3Qgc3RhcnQgd2l0aCAnMlx4MDEnIGFzIHZlcnNpb24K
KyAgICAgICAgIyBTbWFydFdTR0lBcHAgZGV0ZWN0cyByZXF1ZXN0cyB0aGF0IGRvbid0IHN0YXJ0
IHdpdGggJzJcbicgYXMgdmVyc2lvbgogICAgICAgICAjIG9uZS4KICAgICAgICAgdHJhbnNwb3J0
ID0gbWVtb3J5Lk1lbW9yeVRyYW5zcG9ydCgpCiAgICAgICAgIHdzZ2lfYXBwID0gd3NnaS5TbWFy
dFdTR0lBcHAodHJhbnNwb3J0KQpAQCAtMjIyLDEwICsyMjIsMTAgQEAKICAgICAgICAgc2VsZi5h
c3NlcnRFcXVhbCgnb2tceDAxMlxuJywgcmVzcG9uc2UpCiAKICAgICBkZWYgdGVzdF9wcm90b2Nv
bF92ZXJzaW9uX2RldGVjdGlvbl90d28oc2VsZik6Ci0gICAgICAgICMgU21hcnRXU0dJQXBwIGRl
dGVjdHMgcmVxdWVzdHMgdGhhdCBzdGFydCB3aXRoICcyXHgwMScgYXMgdmVyc2lvbiB0d28uCisg
ICAgICAgICMgU21hcnRXU0dJQXBwIGRldGVjdHMgcmVxdWVzdHMgdGhhdCBzdGFydCB3aXRoICcy
XG4nIGFzIHZlcnNpb24gdHdvLgogICAgICAgICB0cmFuc3BvcnQgPSBtZW1vcnkuTWVtb3J5VHJh
bnNwb3J0KCkKICAgICAgICAgd3NnaV9hcHAgPSB3c2dpLlNtYXJ0V1NHSUFwcCh0cmFuc3BvcnQp
Ci0gICAgICAgIGZha2VfaW5wdXQgPSBTdHJpbmdJTygnMlx4MDFoZWxsb1xuJykKKyAgICAgICAg
ZmFrZV9pbnB1dCA9IFN0cmluZ0lPKCcyXG5oZWxsb1xuJykKICAgICAgICAgZW52aXJvbiA9IHNl
bGYuYnVpbGRfZW52aXJvbih7CiAgICAgICAgICAgICAnUkVRVUVTVF9NRVRIT0QnOiAnUE9TVCcs
CiAgICAgICAgICAgICAnQ09OVEVOVF9MRU5HVEgnOiBsZW4oZmFrZV9pbnB1dC5nZXR2YWx1ZSgp
KSwKQEAgLTIzNiw3ICsyMzYsNyBAQAogICAgICAgICByZXNwb25zZSA9IHNlbGYucmVhZF9yZXNw
b25zZShpdGVyYWJsZSkKICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnMjAwIE9LJywgc2VsZi5z
dGF0dXMpCiAgICAgICAgICMgRXhwZWN0IGEgdmVyc2lvbiAyLWVuY29kZWQgcmVzcG9uc2UuCi0g
ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJzJceDAxb2tceDAxMlxuJywgcmVzcG9uc2UpCisgICAg
ICAgIHNlbGYuYXNzZXJ0RXF1YWwoJzJcbm9rXHgwMTJcbicsIHJlc3BvbnNlKQogCiAKIGNsYXNz
IEZha2VSZXF1ZXN0KG9iamVjdCk6Cgo=
=== modified file bzrlib/transport/http/wsgi.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvaHR0cC93c2dpLnB5CisrKyBienJsaWIvdHJhbnNwb3J0L2h0
dHAvd3NnaS5weQpAQCAtMTM0LDcgKzEzNCw3IEBACiAgICAgZGVmIG1ha2VfcmVxdWVzdChzZWxm
LCB0cmFuc3BvcnQsIHdyaXRlX2Z1bmMsIHJlcXVlc3RfYnl0ZXMpOgogICAgICAgICAjIFhYWDog
VGhpcyBkdXBsaWNhdGVzIHRoZSBsb2dpYyBpbgogICAgICAgICAjIFNtYXJ0U2VydmVyU3RyZWFt
TWVkaXVtLl9idWlsZF9wcm90b2NvbC4KLSAgICAgICAgaWYgcmVxdWVzdF9ieXRlcy5zdGFydHN3
aXRoKCcyXHgwMScpOgorICAgICAgICBpZiByZXF1ZXN0X2J5dGVzLnN0YXJ0c3dpdGgoJzJcbicp
OgogICAgICAgICAgICAgcHJvdG9jb2xfY2xhc3MgPSBwcm90b2NvbC5TbWFydFNlcnZlclJlcXVl
c3RQcm90b2NvbFR3bwogICAgICAgICAgICAgcmVxdWVzdF9ieXRlcyA9IHJlcXVlc3RfYnl0ZXNb
MjpdCiAgICAgICAgIGVsc2U6Cgo=
=== modified directory // last-changed:andrew.bennetts at canonical.com-200704240
... 83632-f7kadff1wbp3eszn
# revision id: andrew.bennetts at canonical.com-20070424083632-f7kadff1wbp3eszn
# sha1: 94025999217e4cdf6e2f99d9f9ed08da0242301d
# inventory sha1: 4552dd25e35ff68ffa6ed9874d2115ade7845ffd
# parent ids:
# andrew.bennetts at canonical.com-20070424075513-ibtrd164miun08a8
# properties:
# bugs:
# branch-nick: hpss-protocol2
# message:
# Merge from bzr.dev.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2007-04-24 17:55:13.578000069 +1000
=== modified file bzrlib/smart/medium.py // encoding:base64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=== modified file bzrlib/smart/protocol.py // encoding:base64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==
=== modified file bzrlib/smart/request.py // encoding:base64
LS0tIGJ6cmxpYi9zbWFydC9yZXF1ZXN0LnB5CisrKyBienJsaWIvc21hcnQvcmVxdWVzdC5weQpA
QCAtMjAzLDcgKzIwMyw3IEBACiAgICAgIiIiQW5zd2VyIGEgdmVyc2lvbiByZXF1ZXN0IHdpdGgg
bXkgdmVyc2lvbi4iIiIKIAogICAgIGRlZiBkbyhzZWxmKToKLSAgICAgICAgcmV0dXJuIFNtYXJ0
U2VydmVyUmVzcG9uc2UoKCdvaycsICcxJykpCisgICAgICAgIHJldHVybiBTbWFydFNlcnZlclJl
c3BvbnNlKCgnb2snLCAnMicpKQogCiAKIGNsYXNzIEdldEJ1bmRsZVJlcXVlc3QoU21hcnRTZXJ2
ZXJSZXF1ZXN0KToKCg==
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64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=== modified file bzrlib/tests/test_wsgi.py // encoding:base64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=== modified file bzrlib/transport/http/wsgi.py // encoding:base64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=== modified directory // last-changed:andrew.bennetts at canonical.com-200704240
... 75513-ibtrd164miun08a8
# revision id: andrew.bennetts at canonical.com-20070424075513-ibtrd164miun08a8
# sha1: f17a2754a01ff0d768a7abbb3452e93c4060b28d
# inventory sha1: f62fb364b62d21b90a07037a72e4cfb1fb4f59b4
# parent ids:
# andrew.bennetts at canonical.com-20070424072048-tgbochqfr1n33bcy
# pqm at pqm.ubuntu.com-20070423170758-qd512ltqglzfo6w9
# properties:
# bugs:
# branch-nick: hpss-protocol2
# message:
# Smart server mediums now detect which protocol version a request is and dispatch accordingly.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2007-04-24 17:20:48.194999933 +1000
=== modified file bzrlib/smart/medium.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_wsgi.py // encoding:base64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=== modified file bzrlib/transport/http/wsgi.py // encoding:base64
LS0tIGJ6cmxpYi90cmFuc3BvcnQvaHR0cC93c2dpLnB5CisrKyBienJsaWIvdHJhbnNwb3J0L2h0
dHAvd3NnaS5weQpAQCAtMjIsNiArMjIsNyBAQAogCiBmcm9tIGNTdHJpbmdJTyBpbXBvcnQgU3Ry
aW5nSU8KIAorZnJvbSBienJsaWIuc21hcnQgaW1wb3J0IHByb3RvY29sCiBmcm9tIGJ6cmxpYi50
cmFuc3BvcnQgaW1wb3J0IGNocm9vdCwgZ2V0X3RyYW5zcG9ydCwgcmVtb3RlCiBmcm9tIGJ6cmxp
Yi51cmx1dGlscyBpbXBvcnQgbG9jYWxfcGF0aF90b191cmwKICAgICAKQEAgLTExMywxMCArMTE0
LDEwIEBACiAgICAgICAgIHJlbHBhdGggPSBlbnZpcm9uWydienJsaWIucmVscGF0aCddCiAgICAg
ICAgIHRyYW5zcG9ydCA9IHNlbGYuYmFja2luZ190cmFuc3BvcnQuY2xvbmUocmVscGF0aCkKICAg
ICAgICAgb3V0X2J1ZmZlciA9IFN0cmluZ0lPKCkKLSAgICAgICAgc21hcnRfcHJvdG9jb2xfcmVx
dWVzdCA9IHNlbGYubWFrZV9yZXF1ZXN0KHRyYW5zcG9ydCwgb3V0X2J1ZmZlci53cml0ZSkKICAg
ICAgICAgcmVxdWVzdF9kYXRhX2xlbmd0aCA9IGludChlbnZpcm9uWydDT05URU5UX0xFTkdUSCdd
KQogICAgICAgICByZXF1ZXN0X2RhdGFfYnl0ZXMgPSBlbnZpcm9uWyd3c2dpLmlucHV0J10ucmVh
ZChyZXF1ZXN0X2RhdGFfbGVuZ3RoKQotICAgICAgICBzbWFydF9wcm90b2NvbF9yZXF1ZXN0LmFj
Y2VwdF9ieXRlcyhyZXF1ZXN0X2RhdGFfYnl0ZXMpCisgICAgICAgIHNtYXJ0X3Byb3RvY29sX3Jl
cXVlc3QgPSBzZWxmLm1ha2VfcmVxdWVzdCgKKyAgICAgICAgICAgIHRyYW5zcG9ydCwgb3V0X2J1
ZmZlci53cml0ZSwgcmVxdWVzdF9kYXRhX2J5dGVzKQogICAgICAgICBpZiBzbWFydF9wcm90b2Nv
bF9yZXF1ZXN0Lm5leHRfcmVhZF9zaXplKCkgIT0gMDoKICAgICAgICAgICAgICMgVGhlIHJlcXVl
c3QgYXBwZWFycyB0byBiZSBpbmNvbXBsZXRlLCBvciBwZXJoYXBzIGl0J3MganVzdCBhCiAgICAg
ICAgICAgICAjIG5ld2VyIHZlcnNpb24gd2UgZG9uJ3QgdW5kZXJzdGFuZC4gIFJlZ2FyZGxlc3Ms
IGFsbCB3ZSBjYW4gZG8KQEAgLTEzMCw1ICsxMzEsMTQgQEAKICAgICAgICAgc3RhcnRfcmVzcG9u
c2UoJzIwMCBPSycsIGhlYWRlcnMpCiAgICAgICAgIHJldHVybiBbcmVzcG9uc2VfZGF0YV0KIAot
ICAgIGRlZiBtYWtlX3JlcXVlc3Qoc2VsZiwgdHJhbnNwb3J0LCB3cml0ZV9mdW5jKToKLSAgICAg
ICAgcmV0dXJuIHByb3RvY29sLlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29sT25lKHRyYW5zcG9y
dCwgd3JpdGVfZnVuYykKKyAgICBkZWYgbWFrZV9yZXF1ZXN0KHNlbGYsIHRyYW5zcG9ydCwgd3Jp
dGVfZnVuYywgcmVxdWVzdF9ieXRlcyk6CisgICAgICAgICMgWFhYOiBUaGlzIGR1cGxpY2F0ZXMg
dGhlIGxvZ2ljIGluCisgICAgICAgICMgU21hcnRTZXJ2ZXJTdHJlYW1NZWRpdW0uX2J1aWxkX3By
b3RvY29sLgorICAgICAgICBpZiByZXF1ZXN0X2J5dGVzLnN0YXJ0c3dpdGgoJzJceDAxJyk6Cisg
ICAgICAgICAgICBwcm90b2NvbF9jbGFzcyA9IHByb3RvY29sLlNtYXJ0U2VydmVyUmVxdWVzdFBy
b3RvY29sVHdvCisgICAgICAgICAgICByZXF1ZXN0X2J5dGVzID0gcmVxdWVzdF9ieXRlc1syOl0K
KyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIHByb3RvY29sX2NsYXNzID0gcHJvdG9jb2wuU21h
cnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xPbmUKKyAgICAgICAgc2VydmVyX3Byb3RvY29sID0gcHJv
dG9jb2xfY2xhc3ModHJhbnNwb3J0LCB3cml0ZV9mdW5jKQorICAgICAgICBzZXJ2ZXJfcHJvdG9j
b2wuYWNjZXB0X2J5dGVzKHJlcXVlc3RfYnl0ZXMpCisgICAgICAgIHJldHVybiBzZXJ2ZXJfcHJv
dG9jb2wKCg==
=== modified directory // last-changed:andrew.bennetts at canonical.com-200704240
... 72048-tgbochqfr1n33bcy
# revision id: andrew.bennetts at canonical.com-20070424072048-tgbochqfr1n33bcy
# sha1: b9395530caaf9b25c47b79e16f98927a69202dba
# inventory sha1: 72113b5196ec1f6a3e4fd5cd87a793417a273f03
# parent ids:
# andrew.bennetts at canonical.com-20070424051106-wwlidpflp1rwi3a7
# properties:
# bugs:
# branch-nick: hpss-protocol2
# message:
# Add Smart{Client,Server}RequestProtocolTwo, that prefix args tuples with a version marker.
# committer: Andrew Bennetts <andrew.bennetts at canonical.com>
# date: Tue 2007-04-24 15:11:06.890000105 +1000
=== modified file bzrlib/smart/protocol.py // encoding:base64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=== modified file bzrlib/smart/request.py // encoding:base64
LS0tIGJ6cmxpYi9zbWFydC9yZXF1ZXN0LnB5CisrKyBienJsaWIvc21hcnQvcmVxdWVzdC5weQpA
QCAtMjAzLDcgKzIwMyw3IEBACiAgICAgIiIiQW5zd2VyIGEgdmVyc2lvbiByZXF1ZXN0IHdpdGgg
bXkgdmVyc2lvbi4iIiIKIAogICAgIGRlZiBkbyhzZWxmKToKLSAgICAgICAgcmV0dXJuIFNtYXJ0
U2VydmVyUmVzcG9uc2UoKCdvaycsICcxJykpCisgICAgICAgIHJldHVybiBTbWFydFNlcnZlclJl
c3BvbnNlKCgnb2snLCAnMicpKQogCiAKIGNsYXNzIEdldEJ1bmRsZVJlcXVlc3QoU21hcnRTZXJ2
ZXJSZXF1ZXN0KToKCg==
=== modified file bzrlib/tests/test_smart_transport.py // encoding:base64
LS0tIGJ6cmxpYi90ZXN0cy90ZXN0X3NtYXJ0X3RyYW5zcG9ydC5weQorKysgYnpybGliL3Rlc3Rz
L3Rlc3Rfc21hcnRfdHJhbnNwb3J0LnB5CkBAIC02MDUsNyArNjA1LDcgQEAKICAgICAgICAgc21h
cnRfcHJvdG9jb2wgPSBwcm90b2NvbC5TbWFydFNlcnZlclJlcXVlc3RQcm90b2NvbE9uZSh0cmFu
c3BvcnQsCiAgICAgICAgICAgICAgICAgZnJvbV9zZXJ2ZXIud3JpdGUpCiAgICAgICAgIHNlcnZl
ci5fc2VydmVfb25lX3JlcXVlc3Qoc21hcnRfcHJvdG9jb2wpCi0gICAgICAgIHNlbGYuYXNzZXJ0
RXF1YWwoJ29rXDAwMTFcbicsCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ29rXDAwMTJcbics
CiAgICAgICAgICAgICAgICAgICAgICAgICAgZnJvbV9zZXJ2ZXIuZ2V0dmFsdWUoKSkKIAogICAg
IGRlZiB0ZXN0X3Jlc3BvbnNlX3RvX2Nhbm5lZF9nZXQoc2VsZik6CkBAIC05OTIsMTIgKzk5Miwx
NSBAQAogY2xhc3MgU21hcnRTZXJ2ZXJDb21tYW5kVGVzdHModGVzdHMuVGVzdENhc2VXaXRoVHJh
bnNwb3J0KToKICAgICAiIiJUZXN0cyB0aGF0IGNhbGwgZGlyZWN0bHkgaW50byB0aGUgY29tbWFu
ZCBvYmplY3RzLCBieXBhc3NpbmcgdGhlIG5ldHdvcmsKICAgICBhbmQgdGhlIHJlcXVlc3QgZGlz
cGF0Y2hpbmcuCisKKyAgICBOb3RlOiB0aGVzZSB0ZXN0cyBhcmUgcnVkaW1lbnRhcnkgdmVyc2lv
bnMgb2YgdGhlIGNvbW1hbmQgb2JqZWN0IHRlc3RzIGluCisgICAgdGVzdF9yZW1vdGUucHkuCiAg
ICAgIiIiCiAgICAgICAgIAogICAgIGRlZiB0ZXN0X2hlbGxvKHNlbGYpOgogICAgICAgICBjbWQg
PSByZXF1ZXN0LkhlbGxvUmVxdWVzdChOb25lKQogICAgICAgICByZXNwb25zZSA9IGNtZC5leGVj
dXRlKCkKLSAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgoJ29rJywgJzEnKSwgcmVzcG9uc2UuYXJn
cykKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgoJ29rJywgJzInKSwgcmVzcG9uc2UuYXJncykK
ICAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChOb25lLCByZXNwb25zZS5ib2R5KQogICAgICAgICAK
ICAgICBkZWYgdGVzdF9nZXRfYnVuZGxlKHNlbGYpOgpAQCAtMTAzMiw3ICsxMDM1LDcgQEAKICAg
ICBkZWYgdGVzdF9oZWxsbyhzZWxmKToKICAgICAgICAgaGFuZGxlciA9IHNlbGYuYnVpbGRfaGFu
ZGxlcihOb25lKQogICAgICAgICBoYW5kbGVyLmRpc3BhdGNoX2NvbW1hbmQoJ2hlbGxvJywgKCkp
Ci0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoKCdvaycsICcxJyksIGhhbmRsZXIucmVzcG9uc2Uu
YXJncykKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgoJ29rJywgJzInKSwgaGFuZGxlci5yZXNw
b25zZS5hcmdzKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKE5vbmUsIGhhbmRsZXIucmVzcG9u
c2UuYm9keSkKICAgICAgICAgCiAgICAgZGVmIHRlc3RfZGlzYWJsZV92ZnNfaGFuZGxlcl9jbGFz
c2VzX3ZpYV9lbnZpcm9ubWVudChzZWxmKToKQEAgLTExNTcsNyArMTE2MCw3IEBACiAgICAgICAg
IHNlbGYuX3dyaXRlX291dHB1dF9saXN0ID0gd3JpdGVfb3V0cHV0X2xpc3QKIAogCi1jbGFzcyBU
ZXN0U21hcnRQcm90b2NvbCh0ZXN0cy5UZXN0Q2FzZSk6CitjbGFzcyBUZXN0U21hcnRQcm90b2Nv
bE9uZSh0ZXN0cy5UZXN0Q2FzZSk6CiAgICAgIiIiVGVzdHMgZm9yIHRoZSBzbWFydCBwcm90b2Nv
bC4KIAogICAgIEVhY2ggdGVzdCBjYXNlIGdldHMgYSBzbWFydF9zZXJ2ZXIgYW5kIHNtYXJ0X2Ns
aWVudCBjcmVhdGVkIGR1cmluZyBzZXRVcCgpLgpAQCAtMTE3MSw3ICsxMTc0LDcgQEAKICAgICAi
IiIKIAogICAgIGRlZiBzZXRVcChzZWxmKToKLSAgICAgICAgc3VwZXIoVGVzdFNtYXJ0UHJvdG9j
b2wsIHNlbGYpLnNldFVwKCkKKyAgICAgICAgc3VwZXIoVGVzdFNtYXJ0UHJvdG9jb2xPbmUsIHNl
bGYpLnNldFVwKCkKICAgICAgICAgIyBYWFg6IHNlbGYuc2VydmVyX3RvX2NsaWVudCBkb2Vzbid0
IHNlZW0gdG8gYmUgdXNlZC4gIElmIHNvLAogICAgICAgICAjIEluc3RydW1lbnRlZFNlcnZlclBy
b3RvY29sIGlzIHJlZHVuZGFudCB0b28uCiAgICAgICAgIHNlbGYuc2VydmVyX3RvX2NsaWVudCA9
IFtdCkBAIC0xMjkyLDcgKzEyOTUsNyBAQAogICAgICAgICBzbWFydF9wcm90b2NvbCA9IHByb3Rv
Y29sLlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29sT25lKAogICAgICAgICAgICAgTm9uZSwgb3V0
X3N0cmVhbS53cml0ZSkKICAgICAgICAgc21hcnRfcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCdoZWxs
b1xuaGVsbG9cbicpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoIm9rXHgwMTFcbiIsIG91dF9z
dHJlYW0uZ2V0dmFsdWUoKSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgib2tceDAxMlxuIiwg
b3V0X3N0cmVhbS5nZXR2YWx1ZSgpKQogICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCJoZWxsb1xu
Iiwgc21hcnRfcHJvdG9jb2wuZXhjZXNzX2J1ZmZlcikKICAgICAgICAgc2VsZi5hc3NlcnRFcXVh
bCgiIiwgc21hcnRfcHJvdG9jb2wuaW5fYnVmZmVyKQogCkBAIC0xMzExLDcgKzEzMTQsNyBAQAog
ICAgICAgICBzbWFydF9wcm90b2NvbCA9IHByb3RvY29sLlNtYXJ0U2VydmVyUmVxdWVzdFByb3Rv
Y29sT25lKAogICAgICAgICAgICAgTm9uZSwgb3V0X3N0cmVhbS53cml0ZSkKICAgICAgICAgc21h
cnRfcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCdoZWxsb1xuJykKLSAgICAgICAgc2VsZi5hc3NlcnRF
cXVhbCgib2tceDAxMVxuIiwgb3V0X3N0cmVhbS5nZXR2YWx1ZSgpKQorICAgICAgICBzZWxmLmFz
c2VydEVxdWFsKCJva1x4MDEyXG4iLCBvdXRfc3RyZWFtLmdldHZhbHVlKCkpCiAgICAgICAgIHNt
YXJ0X3Byb3RvY29sLmFjY2VwdF9ieXRlcygnaGVsJykKICAgICAgICAgc2VsZi5hc3NlcnRFcXVh
bCgiaGVsIiwgc21hcnRfcHJvdG9jb2wuZXhjZXNzX2J1ZmZlcikKICAgICAgICAgc21hcnRfcHJv
dG9jb2wuYWNjZXB0X2J5dGVzKCdsb1xuJykKQEAgLTEzMzUsMTIgKzEzMzgsMTIgQEAKICAgICAg
ICAgIyBhY2NlcHRfYnl0ZXModHVwbGVfYmFzZWRfZW5jb2Rpbmdfb2ZfaGVsbG8pIGFuZCByZWFk
cyBhbmQgcGFyc2VzIHRoZQogICAgICAgICAjIHJlc3BvbnNlIG9mIHR1cGxlLWVuY29kZWQgKG9r
LCAxKS4gIEFsc28sIHNlcGVyYXRlbHkgd2Ugc2hvdWxkIHRlc3QKICAgICAgICAgIyB0aGUgZXJy
b3IgaWYgdGhlIHJlc3BvbnNlIGlzIGEgbm9uLXVuZGVyc3Rvb2QgdmVyc2lvbi4KLSAgICAgICAg
aW5wdXQgPSBTdHJpbmdJTygnb2tceDAxMVxuJykKKyAgICAgICAgaW5wdXQgPSBTdHJpbmdJTygn
b2tceDAxMlxuJykKICAgICAgICAgb3V0cHV0ID0gU3RyaW5nSU8oKQogICAgICAgICBjbGllbnRf
bWVkaXVtID0gbWVkaXVtLlNtYXJ0U2ltcGxlUGlwZXNDbGllbnRNZWRpdW0oaW5wdXQsIG91dHB1
dCkKICAgICAgICAgcmVxdWVzdCA9IGNsaWVudF9tZWRpdW0uZ2V0X3JlcXVlc3QoKQogICAgICAg
ICBzbWFydF9wcm90b2NvbCA9IHByb3RvY29sLlNtYXJ0Q2xpZW50UmVxdWVzdFByb3RvY29sT25l
KHJlcXVlc3QpCi0gICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoMSwgc21hcnRfcHJvdG9jb2wucXVl
cnlfdmVyc2lvbigpKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKDIsIHNtYXJ0X3Byb3RvY29s
LnF1ZXJ5X3ZlcnNpb24oKSkKIAogICAgIGRlZiBhc3NlcnRTZXJ2ZXJUb0NsaWVudEVuY29kaW5n
KHNlbGYsIGV4cGVjdGVkX2J5dGVzLCBleHBlY3RlZF90dXBsZSwKICAgICAgICAgICAgIGlucHV0
X3R1cGxlcyk6CkBAIC0xNDUyLDYgKzE0NTUsMzA0IEBACiAgICAgICAgICAgICBlcnJvcnMuUmVh
ZGluZ0NvbXBsZXRlZCwgc21hcnRfcHJvdG9jb2wucmVhZF9ib2R5X2J5dGVzKQogCiAKK2NsYXNz
IFRlc3RTbWFydFByb3RvY29sVHdvKHRlc3RzLlRlc3RDYXNlKToKKyAgICAiIiJUZXN0cyBmb3Ig
dGhlIHNtYXJ0IHByb3RvY29sIHZlcnNpb24gdHdvLgorCisgICAgRWFjaCB0ZXN0IGNhc2UgZ2V0
cyBhIHNtYXJ0X3NlcnZlciBhbmQgc21hcnRfY2xpZW50IGNyZWF0ZWQgZHVyaW5nIHNldFVwKCku
CisKKyAgICBJdCBpcyBwbGFubmVkIHRoYXQgdGhlIGNsaWVudCBjYW4gYmUgY2FsbGVkIHdpdGgg
c2VsZi5jYWxsX2NsaWVudCgpIGdpdmluZworICAgIGl0IGFuIGV4cGVjdGVkIHNlcnZlciByZXNw
b25zZSwgd2hpY2ggd2lsbCBiZSBmZWQgaW50byBpdCB3aGVuIGl0IHRyaWVzIHRvCisgICAgcmVh
ZC4gTGlrZXdpc2UsIHNlbGYuY2FsbF9zZXJ2ZXIgd2lsbCBjYWxsIGEgc2VydmVycyBtZXRob2Qg
d2l0aCBhIGNhbm5lZAorICAgIHNlcmlhbGlzZWQgY2xpZW50IHJlcXVlc3QuIE91dHB1dCBkb25l
IGJ5IHRoZSBjbGllbnQgb3Igc2VydmVyIGZvciB0aGVzZQorICAgIGNhbGxzIHdpbGwgYmUgY2Fw
dHVyZWQgdG8gc2VsZi50b19zZXJ2ZXIgYW5kIHNlbGYudG9fY2xpZW50LiBFYWNoIGVsZW1lbnQK
KyAgICBpbiB0aGUgbGlzdCBpcyBhIHdyaXRlIGNhbGwgZnJvbSB0aGUgY2xpZW50IG9yIHNlcnZl
ciByZXNwZWN0aXZlbHkuCisKKyAgICBUaGlzIHRlc3QgY2FzZSBpcyBtb3N0bHkgdGhlIHNhbWUg
YXMgVGVzdFNtYXJ0UHJvdG9jb2xPbmUuCisgICAgIiIiCisKKyAgICBkZWYgc2V0VXAoc2VsZik6
CisgICAgICAgIHN1cGVyKFRlc3RTbWFydFByb3RvY29sVHdvLCBzZWxmKS5zZXRVcCgpCisgICAg
ICAgICMgWFhYOiBzZWxmLnNlcnZlcl90b19jbGllbnQgZG9lc24ndCBzZWVtIHRvIGJlIHVzZWQu
ICBJZiBzbywKKyAgICAgICAgIyBJbnN0cnVtZW50ZWRTZXJ2ZXJQcm90b2NvbCBpcyByZWR1bmRh
bnQgdG9vLgorICAgICAgICBzZWxmLnNlcnZlcl90b19jbGllbnQgPSBbXQorICAgICAgICBzZWxm
LnRvX3NlcnZlciA9IFN0cmluZ0lPKCkKKyAgICAgICAgc2VsZi50b19jbGllbnQgPSBTdHJpbmdJ
TygpCisgICAgICAgIHNlbGYuY2xpZW50X21lZGl1bSA9IG1lZGl1bS5TbWFydFNpbXBsZVBpcGVz
Q2xpZW50TWVkaXVtKHNlbGYudG9fY2xpZW50LAorICAgICAgICAgICAgc2VsZi50b19zZXJ2ZXIp
CisgICAgICAgIHNlbGYuY2xpZW50X3Byb3RvY29sID0gcHJvdG9jb2wuU21hcnRDbGllbnRSZXF1
ZXN0UHJvdG9jb2xUd28oCisgICAgICAgICAgICBzZWxmLmNsaWVudF9tZWRpdW0pCisgICAgICAg
IHNlbGYuc21hcnRfc2VydmVyID0gSW5zdHJ1bWVudGVkU2VydmVyUHJvdG9jb2woc2VsZi5zZXJ2
ZXJfdG9fY2xpZW50KQorICAgICAgICBzZWxmLnNtYXJ0X3NlcnZlcl9yZXF1ZXN0ID0gcmVxdWVz
dC5TbWFydFNlcnZlclJlcXVlc3RIYW5kbGVyKAorICAgICAgICAgICAgTm9uZSwgcmVxdWVzdC5y
ZXF1ZXN0X2hhbmRsZXJzKQorCisgICAgZGVmIGFzc2VydE9mZnNldFNlcmlhbGlzYXRpb24oc2Vs
ZiwgZXhwZWN0ZWRfb2Zmc2V0cywgZXhwZWN0ZWRfc2VyaWFsaXNlZCwKKyAgICAgICAgY2xpZW50
KToKKyAgICAgICAgIiIiQ2hlY2sgdGhhdCBzbWFydCAoZGUpc2VyaWFsaXNlcyBvZmZzZXRzIGFz
IGV4cGVjdGVkLgorICAgICAgICAKKyAgICAgICAgV2UgY2hlY2sgYm90aCBzZXJpYWxpc2F0aW9u
IGFuZCBkZXNlcmlhbGlzYXRpb24gYXQgdGhlIHNhbWUgdGltZQorICAgICAgICB0byBlbnN1cmUg
dGhhdCB0aGUgcm91bmQgdHJpcHBpbmcgY2Fubm90IHNrZXc6IGJvdGggZGlyZWN0aW9ucyBzaG91
bGQKKyAgICAgICAgYmUgYXMgZXhwZWN0ZWQuCisgICAgICAgIAorICAgICAgICA6cGFyYW0gZXhw
ZWN0ZWRfb2Zmc2V0czogYSByZWFkdiBvZmZzZXQgbGlzdC4KKyAgICAgICAgOnBhcmFtIGV4cGVj
dGVkX3NlcmFsaXNlZDogYW4gZXhwZWN0ZWQgc2VyaWFsIGZvcm0gb2YgdGhlIG9mZnNldHMuCisg
ICAgICAgICIiIgorICAgICAgICAjIFhYWDogJ19kZXNlcmlhbGlzZV9vZmZzZXRzJyBzaG91bGQg
YmUgYSBtZXRob2Qgb2YgdGhlCisgICAgICAgICMgU21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2wg
aW4gZnV0dXJlLgorICAgICAgICByZWFkdl9jbWQgPSB2ZnMuUmVhZHZSZXF1ZXN0KE5vbmUpCisg
ICAgICAgIG9mZnNldHMgPSByZWFkdl9jbWQuX2Rlc2VyaWFsaXNlX29mZnNldHMoZXhwZWN0ZWRf
c2VyaWFsaXNlZCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChleHBlY3RlZF9vZmZzZXRzLCBv
ZmZzZXRzKQorICAgICAgICBzZXJpYWxpc2VkID0gY2xpZW50Ll9zZXJpYWxpc2Vfb2Zmc2V0cyhv
ZmZzZXRzKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX3NlcmlhbGlzZWQsIHNl
cmlhbGlzZWQpCisKKyAgICBkZWYgYnVpbGRfcHJvdG9jb2xfd2FpdGluZ19mb3JfYm9keShzZWxm
KToKKyAgICAgICAgb3V0X3N0cmVhbSA9IFN0cmluZ0lPKCkKKyAgICAgICAgc21hcnRfcHJvdG9j
b2wgPSBwcm90b2NvbC5TbWFydFNlcnZlclJlcXVlc3RQcm90b2NvbFR3byhOb25lLAorICAgICAg
ICAgICAgICAgIG91dF9zdHJlYW0ud3JpdGUpCisgICAgICAgIHNtYXJ0X3Byb3RvY29sLmhhc19k
aXNwYXRjaGVkID0gVHJ1ZQorICAgICAgICBzbWFydF9wcm90b2NvbC5yZXF1ZXN0ID0gc2VsZi5z
bWFydF9zZXJ2ZXJfcmVxdWVzdAorICAgICAgICBjbGFzcyBGYWtlQ29tbWFuZChvYmplY3QpOgor
ICAgICAgICAgICAgZGVmIGRvX2JvZHkoY21kLCBib2R5X2J5dGVzKToKKyAgICAgICAgICAgICAg
ICBzZWxmLmVuZF9yZWNlaXZlZCA9IFRydWUKKyAgICAgICAgICAgICAgICBzZWxmLmFzc2VydEVx
dWFsKCdhYmNkZWZnJywgYm9keV9ieXRlcykKKyAgICAgICAgICAgICAgICByZXR1cm4gcmVxdWVz
dC5TbWFydFNlcnZlclJlc3BvbnNlKCgnb2snLCApKQorICAgICAgICBzbWFydF9wcm90b2NvbC5y
ZXF1ZXN0Ll9jb21tYW5kID0gRmFrZUNvbW1hbmQoKQorICAgICAgICAjIENhbGwgYWNjZXB0X2J5
dGVzIHRvIG1ha2Ugc3VyZSB0aGF0IGludGVybmFsIHN0YXRlIGxpa2UgX2JvZHlfZGVjb2Rlcgor
ICAgICAgICAjIGlzIGluaXRpYWxpc2VkLiAgVGhpcyB0ZXN0IHNob3VsZCBwcm9iYWJseSBiZSBn
aXZlbiBhIGNsZWFyZXIKKyAgICAgICAgIyBpbnRlcmZhY2UgdG8gd29yayB3aXRoIHRoYXQgd2ls
bCBub3QgY2F1c2UgdGhpcyBpbmNvbnNpc3RlbmN5LgorICAgICAgICAjICAgLS0gQW5kcmV3IEJl
bm5ldHRzLCAyMDA2LTA5LTI4CisgICAgICAgIHNtYXJ0X3Byb3RvY29sLmFjY2VwdF9ieXRlcygn
JykKKyAgICAgICAgcmV0dXJuIHNtYXJ0X3Byb3RvY29sCisKKyAgICBkZWYgdGVzdF9jb25zdHJ1
Y3RfdmVyc2lvbl90d29fc2VydmVyX3Byb3RvY29sKHNlbGYpOgorICAgICAgICBzbWFydF9wcm90
b2NvbCA9IHByb3RvY29sLlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29sVHdvKE5vbmUsIE5vbmUp
CisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJycsIHNtYXJ0X3Byb3RvY29sLmV4Y2Vzc19idWZm
ZXIpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJycsIHNtYXJ0X3Byb3RvY29sLmluX2J1ZmZl
cikKKyAgICAgICAgc2VsZi5hc3NlcnRGYWxzZShzbWFydF9wcm90b2NvbC5oYXNfZGlzcGF0Y2hl
ZCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgxLCBzbWFydF9wcm90b2NvbC5uZXh0X3JlYWRf
c2l6ZSgpKQorCisgICAgZGVmIHRlc3RfY29uc3RydWN0X3ZlcnNpb25fdHdvX2NsaWVudF9wcm90
b2NvbChzZWxmKToKKyAgICAgICAgIyB3ZSBjYW4gY29uc3RydWN0IGEgY2xpZW50IHByb3RvY29s
IGZyb20gYSBjbGllbnQgbWVkaXVtIHJlcXVlc3QKKyAgICAgICAgb3V0cHV0ID0gU3RyaW5nSU8o
KQorICAgICAgICBjbGllbnRfbWVkaXVtID0gbWVkaXVtLlNtYXJ0U2ltcGxlUGlwZXNDbGllbnRN
ZWRpdW0oTm9uZSwgb3V0cHV0KQorICAgICAgICByZXF1ZXN0ID0gY2xpZW50X21lZGl1bS5nZXRf
cmVxdWVzdCgpCisgICAgICAgIGNsaWVudF9wcm90b2NvbCA9IHByb3RvY29sLlNtYXJ0Q2xpZW50
UmVxdWVzdFByb3RvY29sVHdvKHJlcXVlc3QpCisKKyAgICBkZWYgdGVzdF9zZXJ2ZXJfb2Zmc2V0
X3NlcmlhbGlzYXRpb24oc2VsZik6CisgICAgICAgICIiIlRoZSBTbWFydCBwcm90b2NvbCBzZXJp
YWxpc2VzIG9mZnNldHMgYXMgYSBjb21tYSBhbmQgXG4gc3RyaW5nLgorCisgICAgICAgIFdlIGNo
ZWNrIGEgbnVtYmVyIG9mIGJvdW5kYXJ5IGNhc2VzIGFyZSBhcyBleHBlY3RlZDogZW1wdHksIG9u
ZSBvZmZzZXQsCisgICAgICAgIG9uZSB3aXRoIHRoZSBvcmRlciBvZiByZWFkcyBub3QgaW5jcmVh
c2luZyAoYW4gb3V0IG9mIG9yZGVyIHJlYWQpLCBhbmQKKyAgICAgICAgb25lIHRoYXQgc2hvdWxk
IGNvYWxlc2NlLgorICAgICAgICAiIiIKKyAgICAgICAgc2VsZi5hc3NlcnRPZmZzZXRTZXJpYWxp
c2F0aW9uKFtdLCAnJywgc2VsZi5jbGllbnRfcHJvdG9jb2wpCisgICAgICAgIHNlbGYuYXNzZXJ0
T2Zmc2V0U2VyaWFsaXNhdGlvbihbKDEsMildLCAnMSwyJywgc2VsZi5jbGllbnRfcHJvdG9jb2wp
CisgICAgICAgIHNlbGYuYXNzZXJ0T2Zmc2V0U2VyaWFsaXNhdGlvbihbKDEwLDQwKSwgKDAsNSld
LCAnMTAsNDBcbjAsNScsCisgICAgICAgICAgICBzZWxmLmNsaWVudF9wcm90b2NvbCkKKyAgICAg
ICAgc2VsZi5hc3NlcnRPZmZzZXRTZXJpYWxpc2F0aW9uKFsoMSwyKSwgKDMsNCksICgxMDAsIDIw
MCldLAorICAgICAgICAgICAgJzEsMlxuMyw0XG4xMDAsMjAwJywgc2VsZi5jbGllbnRfcHJvdG9j
b2wpCisKKyAgICBkZWYgdGVzdF9hY2NlcHRfYnl0ZXNfb2ZfYmFkX3JlcXVlc3RfdG9fcHJvdG9j
b2woc2VsZik6CisgICAgICAgIG91dF9zdHJlYW0gPSBTdHJpbmdJTygpCisgICAgICAgIHNtYXJ0
X3Byb3RvY29sID0gcHJvdG9jb2wuU21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xUd28oCisgICAg
ICAgICAgICBOb25lLCBvdXRfc3RyZWFtLndyaXRlKQorICAgICAgICBzbWFydF9wcm90b2NvbC5h
Y2NlcHRfYnl0ZXMoJ2FiYycpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoJ2FiYycsIHNtYXJ0
X3Byb3RvY29sLmluX2J1ZmZlcikKKyAgICAgICAgc21hcnRfcHJvdG9jb2wuYWNjZXB0X2J5dGVz
KCdcbicpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoCisgICAgICAgICAgICAiMlx4MDFlcnJv
clx4MDFHZW5lcmljIGJ6ciBzbWFydCBwcm90b2NvbCBlcnJvcjogYmFkIHJlcXVlc3QgJ2FiYydc
biIsCisgICAgICAgICAgICBvdXRfc3RyZWFtLmdldHZhbHVlKCkpCisgICAgICAgIHNlbGYuYXNz
ZXJ0VHJ1ZShzbWFydF9wcm90b2NvbC5oYXNfZGlzcGF0Y2hlZCkKKyAgICAgICAgc2VsZi5hc3Nl
cnRFcXVhbCgwLCBzbWFydF9wcm90b2NvbC5uZXh0X3JlYWRfc2l6ZSgpKQorCisgICAgZGVmIHRl
c3RfYWNjZXB0X2JvZHlfYnl0ZXNfdG9fcHJvdG9jb2woc2VsZik6CisgICAgICAgIHByb3RvY29s
ID0gc2VsZi5idWlsZF9wcm90b2NvbF93YWl0aW5nX2Zvcl9ib2R5KCkKKyAgICAgICAgc2VsZi5h
c3NlcnRFcXVhbCg2LCBwcm90b2NvbC5uZXh0X3JlYWRfc2l6ZSgpKQorICAgICAgICBwcm90b2Nv
bC5hY2NlcHRfYnl0ZXMoJzdcbmFiYycpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoOSwgcHJv
dG9jb2wubmV4dF9yZWFkX3NpemUoKSkKKyAgICAgICAgcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCdk
ZWZnZCcpCisgICAgICAgIHByb3RvY29sLmFjY2VwdF9ieXRlcygnb25lXG4nKQorICAgICAgICBz
ZWxmLmFzc2VydEVxdWFsKDAsIHByb3RvY29sLm5leHRfcmVhZF9zaXplKCkpCisgICAgICAgIHNl
bGYuYXNzZXJ0VHJ1ZShzZWxmLmVuZF9yZWNlaXZlZCkKKworICAgIGRlZiB0ZXN0X2FjY2VwdF9y
ZXF1ZXN0X2FuZF9ib2R5X2FsbF9hdF9vbmNlKHNlbGYpOgorICAgICAgICBzZWxmLl9jYXB0dXJl
VmFyKCdCWlJfTk9fU01BUlRfVkZTJywgTm9uZSkKKyAgICAgICAgbWVtX3RyYW5zcG9ydCA9IG1l
bW9yeS5NZW1vcnlUcmFuc3BvcnQoKQorICAgICAgICBtZW1fdHJhbnNwb3J0LnB1dF9ieXRlcygn
Zm9vJywgJ2FiY2RlZmdoaWonKQorICAgICAgICBvdXRfc3RyZWFtID0gU3RyaW5nSU8oKQorICAg
ICAgICBzbWFydF9wcm90b2NvbCA9IHByb3RvY29sLlNtYXJ0U2VydmVyUmVxdWVzdFByb3RvY29s
VHdvKG1lbV90cmFuc3BvcnQsCisgICAgICAgICAgICAgICAgb3V0X3N0cmVhbS53cml0ZSkKKyAg
ICAgICAgc21hcnRfcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCdyZWFkdlx4MDFmb29cbjNcbjMsM2Rv
bmVcbicpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoMCwgc21hcnRfcHJvdG9jb2wubmV4dF9y
ZWFkX3NpemUoKSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgnMlx4MDFyZWFkdlxuM1xuZGVm
ZG9uZVxuJywgb3V0X3N0cmVhbS5nZXR2YWx1ZSgpKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFs
KCcnLCBzbWFydF9wcm90b2NvbC5leGNlc3NfYnVmZmVyKQorICAgICAgICBzZWxmLmFzc2VydEVx
dWFsKCcnLCBzbWFydF9wcm90b2NvbC5pbl9idWZmZXIpCisKKyAgICBkZWYgdGVzdF9hY2NlcHRf
ZXhjZXNzX2J5dGVzX2FyZV9wcmVzZXJ2ZWQoc2VsZik6CisgICAgICAgIG91dF9zdHJlYW0gPSBT
dHJpbmdJTygpCisgICAgICAgIHNtYXJ0X3Byb3RvY29sID0gcHJvdG9jb2wuU21hcnRTZXJ2ZXJS
ZXF1ZXN0UHJvdG9jb2xUd28oCisgICAgICAgICAgICBOb25lLCBvdXRfc3RyZWFtLndyaXRlKQor
ICAgICAgICBzbWFydF9wcm90b2NvbC5hY2NlcHRfYnl0ZXMoJ2hlbGxvXG5oZWxsb1xuJykKKyAg
ICAgICAgc2VsZi5hc3NlcnRFcXVhbCgiMlx4MDFva1x4MDEyXG4iLCBvdXRfc3RyZWFtLmdldHZh
bHVlKCkpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoImhlbGxvXG4iLCBzbWFydF9wcm90b2Nv
bC5leGNlc3NfYnVmZmVyKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCIiLCBzbWFydF9wcm90
b2NvbC5pbl9idWZmZXIpCisKKyAgICBkZWYgdGVzdF9hY2NlcHRfZXhjZXNzX2J5dGVzX2FmdGVy
X2JvZHkoc2VsZik6CisgICAgICAgICMgVGhlIGV4Y2VzcyBieXRlcyBsb29rIGxpa2UgdGhlIHN0
YXJ0IG9mIGFub3RoZXIgcmVxdWVzdC4KKyAgICAgICAgcHJvdG9jb2wgPSBzZWxmLmJ1aWxkX3By
b3RvY29sX3dhaXRpbmdfZm9yX2JvZHkoKQorICAgICAgICBwcm90b2NvbC5hY2NlcHRfYnl0ZXMo
JzdcbmFiY2RlZmdkb25lXG4yXHgwMScpCisgICAgICAgIHNlbGYuYXNzZXJ0VHJ1ZShzZWxmLmVu
ZF9yZWNlaXZlZCkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgiMlx4MDEiLCBwcm90b2NvbC5l
eGNlc3NfYnVmZmVyKQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKCIiLCBwcm90b2NvbC5pbl9i
dWZmZXIpCisgICAgICAgIHByb3RvY29sLmFjY2VwdF9ieXRlcygnWScpCisgICAgICAgIHNlbGYu
YXNzZXJ0RXF1YWwoIjJceDAxWSIsIHByb3RvY29sLmV4Y2Vzc19idWZmZXIpCisgICAgICAgIHNl
bGYuYXNzZXJ0RXF1YWwoIiIsIHByb3RvY29sLmluX2J1ZmZlcikKKworICAgIGRlZiB0ZXN0X2Fj
Y2VwdF9leGNlc3NfYnl0ZXNfYWZ0ZXJfZGlzcGF0Y2goc2VsZik6CisgICAgICAgIG91dF9zdHJl
YW0gPSBTdHJpbmdJTygpCisgICAgICAgIHNtYXJ0X3Byb3RvY29sID0gcHJvdG9jb2wuU21hcnRT
ZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xUd28oCisgICAgICAgICAgICBOb25lLCBvdXRfc3RyZWFtLndy
aXRlKQorICAgICAgICBzbWFydF9wcm90b2NvbC5hY2NlcHRfYnl0ZXMoJ2hlbGxvXG4nKQorICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKCIyXHgwMW9rXHgwMTJcbiIsIG91dF9zdHJlYW0uZ2V0dmFs
dWUoKSkKKyAgICAgICAgc21hcnRfcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCcyXHgwMWhlbCcpCisg
ICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoIjJceDAxaGVsIiwgc21hcnRfcHJvdG9jb2wuZXhjZXNz
X2J1ZmZlcikKKyAgICAgICAgc21hcnRfcHJvdG9jb2wuYWNjZXB0X2J5dGVzKCdsb1xuJykKKyAg
ICAgICAgc2VsZi5hc3NlcnRFcXVhbCgiMlx4MDFoZWxsb1xuIiwgc21hcnRfcHJvdG9jb2wuZXhj
ZXNzX2J1ZmZlcikKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbCgiIiwgc21hcnRfcHJvdG9jb2wu
aW5fYnVmZmVyKQorCisgICAgZGVmIHRlc3RfX3NlbmRfcmVzcG9uc2Vfc2V0c19maW5pc2hlZF9y
ZWFkaW5nKHNlbGYpOgorICAgICAgICBzbWFydF9wcm90b2NvbCA9IHByb3RvY29sLlNtYXJ0U2Vy
dmVyUmVxdWVzdFByb3RvY29sVHdvKAorICAgICAgICAgICAgTm9uZSwgbGFtYmRhIHg6IE5vbmUp
CisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoMSwgc21hcnRfcHJvdG9jb2wubmV4dF9yZWFkX3Np
emUoKSkKKyAgICAgICAgc21hcnRfcHJvdG9jb2wuX3NlbmRfcmVzcG9uc2UoKCd4JywpKQorICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKDAsIHNtYXJ0X3Byb3RvY29sLm5leHRfcmVhZF9zaXplKCkp
CisKKyAgICBkZWYgdGVzdF9xdWVyeV92ZXJzaW9uKHNlbGYpOgorICAgICAgICAiIiJxdWVyeV92
ZXJzaW9uIG9uIGEgU21hcnRDbGllbnRQcm90b2NvbFR3byBzaG91bGQgcmV0dXJuIGEgbnVtYmVy
LgorICAgICAgICAKKyAgICAgICAgVGhlIHByb3RvY29sIHByb3ZpZGVzIHRoZSBxdWVyeV92ZXJz
aW9uIGJlY2F1c2UgdGhlIGRvbWFpbiBsZXZlbCBjbGllbnRzCisgICAgICAgIG1heSBhbGwgbmVl
ZCB0byBiZSBhYmxlIHRvIHByb2JlIGZvciBjYXBhYmlsaXRpZXMuCisgICAgICAgICIiIgorICAg
ICAgICAjIFdoYXQgd2UgcmVhbGx5IHdhbnQgdG8gdGVzdCBoZXJlIGlzIHRoYXQgU21hcnRDbGll
bnRQcm90b2NvbFR3byBjYWxscworICAgICAgICAjIGFjY2VwdF9ieXRlcyh0dXBsZV9iYXNlZF9l
bmNvZGluZ19vZl9oZWxsbykgYW5kIHJlYWRzIGFuZCBwYXJzZXMgdGhlCisgICAgICAgICMgcmVz
cG9uc2Ugb2YgdHVwbGUtZW5jb2RlZCAob2ssIDEpLiAgQWxzbywgc2VwZXJhdGVseSB3ZSBzaG91
bGQgdGVzdAorICAgICAgICAjIHRoZSBlcnJvciBpZiB0aGUgcmVzcG9uc2UgaXMgYSBub24tdW5k
ZXJzdG9vZCB2ZXJzaW9uLgorICAgICAgICBpbnB1dCA9IFN0cmluZ0lPKCcyXHgwMW9rXHgwMTJc
bicpCisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkKKyAgICAgICAgY2xpZW50X21lZGl1bSA9
IG1lZGl1bS5TbWFydFNpbXBsZVBpcGVzQ2xpZW50TWVkaXVtKGlucHV0LCBvdXRwdXQpCisgICAg
ICAgIHJlcXVlc3QgPSBjbGllbnRfbWVkaXVtLmdldF9yZXF1ZXN0KCkKKyAgICAgICAgc21hcnRf
cHJvdG9jb2wgPSBwcm90b2NvbC5TbWFydENsaWVudFJlcXVlc3RQcm90b2NvbFR3byhyZXF1ZXN0
KQorICAgICAgICBzZWxmLmFzc2VydEVxdWFsKDIsIHNtYXJ0X3Byb3RvY29sLnF1ZXJ5X3ZlcnNp
b24oKSkKKworICAgIGRlZiBhc3NlcnRTZXJ2ZXJUb0NsaWVudEVuY29kaW5nKHNlbGYsIGV4cGVj
dGVkX2J5dGVzLCBleHBlY3RlZF90dXBsZSwKKyAgICAgICAgICAgIGlucHV0X3R1cGxlcyk6Cisg
ICAgICAgICIiIkFzc2VydCB0aGF0IGVhY2ggaW5wdXRfdHVwbGUgc2VyaWFsaXNlcyBhcyBleHBl
Y3RlZF9ieXRlcywgYW5kIHRoZQorICAgICAgICBieXRlcyBkZXNlcmlhbGlzZSBhcyBleHBlY3Rl
ZF90dXBsZS4KKyAgICAgICAgIiIiCisgICAgICAgICMgY2hlY2sgdGhlIGVuY29kaW5nIG9mIHRo
ZSBzZXJ2ZXIgZm9yIGFsbCBpbnB1dF90dXBsZXMgbWF0Y2hlcworICAgICAgICAjIGV4cGVjdGVk
IGJ5dGVzCisgICAgICAgIGZvciBpbnB1dF90dXBsZSBpbiBpbnB1dF90dXBsZXM6CisgICAgICAg
ICAgICBzZXJ2ZXJfb3V0cHV0ID0gU3RyaW5nSU8oKQorICAgICAgICAgICAgc2VydmVyX3Byb3Rv
Y29sID0gcHJvdG9jb2wuU21hcnRTZXJ2ZXJSZXF1ZXN0UHJvdG9jb2xUd28oCisgICAgICAgICAg
ICAgICAgTm9uZSwgc2VydmVyX291dHB1dC53cml0ZSkKKyAgICAgICAgICAgIHNlcnZlcl9wcm90
b2NvbC5fc2VuZF9yZXNwb25zZShpbnB1dF90dXBsZSkKKyAgICAgICAgICAgIHNlbGYuYXNzZXJ0
RXF1YWwoZXhwZWN0ZWRfYnl0ZXMsIHNlcnZlcl9vdXRwdXQuZ2V0dmFsdWUoKSkKKyAgICAgICAg
IyBjaGVjayB0aGUgZGVjb2Rpbmcgb2YgdGhlIGNsaWVudCBzbWFydF9wcm90b2NvbCBmcm9tIGV4
cGVjdGVkX2J5dGVzOgorICAgICAgICBpbnB1dCA9IFN0cmluZ0lPKGV4cGVjdGVkX2J5dGVzKQor
ICAgICAgICBvdXRwdXQgPSBTdHJpbmdJTygpCisgICAgICAgIGNsaWVudF9tZWRpdW0gPSBtZWRp
dW0uU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShpbnB1dCwgb3V0cHV0KQorICAgICAgICBy
ZXF1ZXN0ID0gY2xpZW50X21lZGl1bS5nZXRfcmVxdWVzdCgpCisgICAgICAgIHNtYXJ0X3Byb3Rv
Y29sID0gcHJvdG9jb2wuU21hcnRDbGllbnRSZXF1ZXN0UHJvdG9jb2xUd28ocmVxdWVzdCkKKyAg
ICAgICAgc21hcnRfcHJvdG9jb2wuY2FsbCgnZm9vJykKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVh
bChleHBlY3RlZF90dXBsZSwgc21hcnRfcHJvdG9jb2wucmVhZF9yZXNwb25zZV90dXBsZSgpKQor
CisgICAgZGVmIHRlc3RfY2xpZW50X2NhbGxfZW1wdHlfcmVzcG9uc2Uoc2VsZik6CisgICAgICAg
ICMgcHJvdG9jb2wuY2FsbCgpIGNhbiBnZXQgYmFjayBhbiBlbXB0eSB0dXBsZSBhcyBhIHJlc3Bv
bnNlLiBUaGlzIG9jY3VycworICAgICAgICAjIHdoZW4gdGhlIHBhcnNlZCBsaW5lIGlzIGFuIGVt
cHR5IGxpbmUsIGFuZCByZXN1bHRzIGluIGEgdHVwbGUgd2l0aAorICAgICAgICAjIG9uZSBlbGVt
ZW50IC0gYW4gZW1wdHkgc3RyaW5nLgorICAgICAgICBzZWxmLmFzc2VydFNlcnZlclRvQ2xpZW50
RW5jb2RpbmcoJzJceDAxXG4nLCAoJycsICksIFsoKSwgKCcnLCApXSkKKworICAgIGRlZiB1bnRl
c3RfY2xpZW50X2NhbGxfdGhyZWVfZWxlbWVudF9yZXNwb25zZShzZWxmKToKKyAgICAgICAgIyBw
cm90b2NvbC5jYWxsKCkgY2FuIGdldCBiYWNrIHR1cGxlcyBvZiBvdGhlciBsZW5ndGhzLiBBIHRo
cmVlIGVsZW1lbnQKKyAgICAgICAgIyB0dXBsZSBzaG91bGQgYmUgdW5wYWNrZWQgYXMgdGhyZWUg
c3RyaW5ncy4KKyAgICAgICAgc2VsZi5hc3NlcnRTZXJ2ZXJUb0NsaWVudEVuY29kaW5nKCcyXHgw
MWFceDAxYlx4MDEzNFxuJywgKCdhJywgJ2InLCAnMzQnKSwKKyAgICAgICAgICAgIFsoJ2EnLCAn
YicsICczNCcpXSkKKworICAgIGRlZiB0ZXN0X2NsaWVudF9jYWxsX3dpdGhfYm9keV9ieXRlc191
cGxvYWRzKHNlbGYpOgorICAgICAgICAjIHByb3RvY29sLmNhbGxfd2l0aF9ib2R5X2J5dGVzIHNo
b3VsZCBsZW5ndGgtcHJlZml4IHRoZSBieXRlcyBvbnRvIHRoZQorICAgICAgICAjIHdpcmUuCisg
ICAgICAgIGV4cGVjdGVkX2J5dGVzID0gIjJceDAxZm9vXG43XG5hYmNkZWZnZG9uZVxuIgorICAg
ICAgICBpbnB1dCA9IFN0cmluZ0lPKCJcbiIpCisgICAgICAgIG91dHB1dCA9IFN0cmluZ0lPKCkK
KyAgICAgICAgY2xpZW50X21lZGl1bSA9IG1lZGl1bS5TbWFydFNpbXBsZVBpcGVzQ2xpZW50TWVk
aXVtKGlucHV0LCBvdXRwdXQpCisgICAgICAgIHJlcXVlc3QgPSBjbGllbnRfbWVkaXVtLmdldF9y
ZXF1ZXN0KCkKKyAgICAgICAgc21hcnRfcHJvdG9jb2wgPSBwcm90b2NvbC5TbWFydENsaWVudFJl
cXVlc3RQcm90b2NvbFR3byhyZXF1ZXN0KQorICAgICAgICBzbWFydF9wcm90b2NvbC5jYWxsX3dp
dGhfYm9keV9ieXRlcygoJ2ZvbycsICksICJhYmNkZWZnIikKKyAgICAgICAgc2VsZi5hc3NlcnRF
cXVhbChleHBlY3RlZF9ieXRlcywgb3V0cHV0LmdldHZhbHVlKCkpCisKKyAgICBkZWYgdGVzdF9j
bGllbnRfY2FsbF93aXRoX2JvZHlfcmVhZHZfYXJyYXkoc2VsZik6CisgICAgICAgICMgcHJvdG9j
b2wuY2FsbF93aXRoX3VwbG9hZCBzaG91bGQgZW5jb2RlIHRoZSByZWFkdiBhcnJheSBhbmQgdGhl
bgorICAgICAgICAjIGxlbmd0aC1wcmVmaXggdGhlIGJ5dGVzIG9udG8gdGhlIHdpcmUuCisgICAg
ICAgIGV4cGVjdGVkX2J5dGVzID0gIjJceDAxZm9vXG43XG4xLDJcbjUsNmRvbmVcbiIKKyAgICAg
ICAgaW5wdXQgPSBTdHJpbmdJTygiXG4iKQorICAgICAgICBvdXRwdXQgPSBTdHJpbmdJTygpCisg
ICAgICAgIGNsaWVudF9tZWRpdW0gPSBtZWRpdW0uU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1
bShpbnB1dCwgb3V0cHV0KQorICAgICAgICByZXF1ZXN0ID0gY2xpZW50X21lZGl1bS5nZXRfcmVx
dWVzdCgpCisgICAgICAgIHNtYXJ0X3Byb3RvY29sID0gcHJvdG9jb2wuU21hcnRDbGllbnRSZXF1
ZXN0UHJvdG9jb2xUd28ocmVxdWVzdCkKKyAgICAgICAgc21hcnRfcHJvdG9jb2wuY2FsbF93aXRo
X2JvZHlfcmVhZHZfYXJyYXkoKCdmb28nLCApLCBbKDEsMiksKDUsNildKQorICAgICAgICBzZWxm
LmFzc2VydEVxdWFsKGV4cGVjdGVkX2J5dGVzLCBvdXRwdXQuZ2V0dmFsdWUoKSkKKworICAgIGRl
ZiB0ZXN0X2NsaWVudF9yZWFkX2JvZHlfYnl0ZXNfYWxsKHNlbGYpOgorICAgICAgICAjIHJlYWRf
Ym9keV9ieXRlcyBzaG91bGQgZGVjb2RlIHRoZSBib2R5IGJ5dGVzIGZyb20gdGhlIHdpcmUgaW50
bworICAgICAgICAjIGEgcmVzcG9uc2UuCisgICAgICAgIGV4cGVjdGVkX2J5dGVzID0gIjEyMzQ1
NjciCisgICAgICAgIHNlcnZlcl9ieXRlcyA9ICIyXHgwMW9rXG43XG4xMjM0NTY3ZG9uZVxuIgor
ICAgICAgICBpbnB1dCA9IFN0cmluZ0lPKHNlcnZlcl9ieXRlcykKKyAgICAgICAgb3V0cHV0ID0g
U3RyaW5nSU8oKQorICAgICAgICBjbGllbnRfbWVkaXVtID0gbWVkaXVtLlNtYXJ0U2ltcGxlUGlw
ZXNDbGllbnRNZWRpdW0oaW5wdXQsIG91dHB1dCkKKyAgICAgICAgcmVxdWVzdCA9IGNsaWVudF9t
ZWRpdW0uZ2V0X3JlcXVlc3QoKQorICAgICAgICBzbWFydF9wcm90b2NvbCA9IHByb3RvY29sLlNt
YXJ0Q2xpZW50UmVxdWVzdFByb3RvY29sVHdvKHJlcXVlc3QpCisgICAgICAgIHNtYXJ0X3Byb3Rv
Y29sLmNhbGwoJ2ZvbycpCisgICAgICAgIHNtYXJ0X3Byb3RvY29sLnJlYWRfcmVzcG9uc2VfdHVw
bGUoVHJ1ZSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChleHBlY3RlZF9ieXRlcywgc21hcnRf
cHJvdG9jb2wucmVhZF9ib2R5X2J5dGVzKCkpCisKKyAgICBkZWYgdGVzdF9jbGllbnRfcmVhZF9i
b2R5X2J5dGVzX2luY3JlbWVudGFsKHNlbGYpOgorICAgICAgICAjIHRlc3QgcmVhZGluZyBhIGZl
dyBieXRlcyBhdCBhIHRpbWUgZnJvbSB0aGUgYm9keQorICAgICAgICAjIFhYWDogcG9zc2libHkg
d2Ugc2hvdWxkIHRlc3QgZHJpYmJsaW5nIHRoZSBieXRlcyBpbnRvIHRoZSBzdHJpbmdpbworICAg
ICAgICAjIHRvIG1ha2UgdGhlIHN0YXRlIG1hY2hpbmUgd29yayBoYXJkZXI6IGhvd2V2ZXIsIGFz
IHdlIHVzZSB0aGUKKyAgICAgICAgIyBMZW5ndGhQcmVmaXhlZEJvZHlEZWNvZGVyIHRoYXQgaXMg
YWxyZWFkeSB3ZWxsIHRlc3RlZCAtIHdlIGNhbiBza2lwCisgICAgICAgICMgdGhhdC4KKyAgICAg
ICAgZXhwZWN0ZWRfYnl0ZXMgPSAiMTIzNDU2NyIKKyAgICAgICAgc2VydmVyX2J5dGVzID0gIjJc
eDAxb2tcbjdcbjEyMzQ1Njdkb25lXG4iCisgICAgICAgIGlucHV0ID0gU3RyaW5nSU8oc2VydmVy
X2J5dGVzKQorICAgICAgICBvdXRwdXQgPSBTdHJpbmdJTygpCisgICAgICAgIGNsaWVudF9tZWRp
dW0gPSBtZWRpdW0uU21hcnRTaW1wbGVQaXBlc0NsaWVudE1lZGl1bShpbnB1dCwgb3V0cHV0KQor
ICAgICAgICByZXF1ZXN0ID0gY2xpZW50X21lZGl1bS5nZXRfcmVxdWVzdCgpCisgICAgICAgIHNt
YXJ0X3Byb3RvY29sID0gcHJvdG9jb2wuU21hcnRDbGllbnRSZXF1ZXN0UHJvdG9jb2xUd28ocmVx
dWVzdCkKKyAgICAgICAgc21hcnRfcHJvdG9jb2wuY2FsbCgnZm9vJykKKyAgICAgICAgc21hcnRf
cHJvdG9jb2wucmVhZF9yZXNwb25zZV90dXBsZShUcnVlKQorICAgICAgICBzZWxmLmFzc2VydEVx
dWFsKGV4cGVjdGVkX2J5dGVzWzA6Ml0sIHNtYXJ0X3Byb3RvY29sLnJlYWRfYm9keV9ieXRlcygy
KSkKKyAgICAgICAgc2VsZi5hc3NlcnRFcXVhbChleHBlY3RlZF9ieXRlc1syOjRdLCBzbWFydF9w
cm90b2NvbC5yZWFkX2JvZHlfYnl0ZXMoMikpCisgICAgICAgIHNlbGYuYXNzZXJ0RXF1YWwoZXhw
ZWN0ZWRfYnl0ZXNbNDo2XSwgc21hcnRfcHJvdG9jb2wucmVhZF9ib2R5X2J5dGVzKDIpKQorICAg
ICAgICBzZWxmLmFzc2VydEVxdWFsKGV4cGVjdGVkX2J5dGVzWzZdLCBzbWFydF9wcm90b2NvbC5y
ZWFkX2JvZHlfYnl0ZXMoKSkKKworICAgIGRlZiB0ZXN0X2NsaWVudF9jYW5jZWxfcmVhZF9ib2R5
X2RvZXNfbm90X2VhdF9ib2R5X2J5dGVzKHNlbGYpOgorICAgICAgICAjIGNhbmNlbGxpbmcgdGhl
IGV4cGVjdGVkIGJvZHkgbmVlZHMgdG8gZmluaXNoIHRoZSByZXF1ZXN0LCBidXQgbm90CisgICAg
ICAgICMgcmVhZCBhbnkgbW9yZSBieXRlcy4KKyAgICAgICAgZXhwZWN0ZWRfYnl0ZXMgPSAiMTIz
NDU2NyIKKyAgICAgICAgc2VydmVyX2J5dGVzID0gIjJceDAxb2tcbjdcbjEyMzQ1Njdkb25lXG4i
CisgICAgICAgIGlucHV0ID0gU3RyaW5nSU8oc2VydmVyX2J5dGVzKQorICAgICAgICBvdXRwdXQg
PSBTdHJpbmdJTygpCisgICAgICAgIGNsaWVudF9tZWRpdW0gPSBtZWRpdW0uU21hcnRTaW1wbGVQ
aXBlc0NsaWVudE1lZGl1bShpbnB1dCwgb3V0cHV0KQorICAgICAgICByZXF1ZXN0ID0gY2xpZW50
X21lZGl1bS5nZXRfcmVxdWVzdCgpCisgICAgICAgIHNtYXJ0X3Byb3RvY29sID0gcHJvdG9jb2wu
U21hcnRDbGllbnRSZXF1ZXN0UHJvdG9jb2xUd28ocmVxdWVzdCkKKyAgICAgICAgc21hcnRfcHJv
dG9jb2wuY2FsbCgnZm9vJykKKyAgICAgICAgc21hcnRfcHJvdG9jb2wucmVhZF9yZXNwb25zZV90
dXBsZShUcnVlKQorICAgICAgICBzbWFydF9wcm90b2NvbC5jYW5jZWxfcmVhZF9ib2R5KCkKKyAg
ICAgICAgc2VsZi5hc3NlcnRFcXVhbCg1LCBpbnB1dC50ZWxsKCkpCisgICAgICAgIHNlbGYuYXNz
ZXJ0UmFpc2VzKAorICAgICAgICAgICAgZXJyb3JzLlJlYWRpbmdDb21wbGV0ZWQsIHNtYXJ0X3By
b3RvY29sLnJlYWRfYm9keV9ieXRlcykKKworCiBjbGFzcyBUZXN0U21hcnRDbGllbnRVbmljb2Rl
KHRlc3RzLlRlc3RDYXNlKToKICAgICAiIiJfU21hcnRDbGllbnQgdGVzdHMgZm9yIHVuaWNvZGUg
YXJndW1lbnRzLgogCkBAIC0xNjExLDcgKzE5MTIsNyBAQAogICAgICAgICBzZWxmLmFkZENsZWFu
dXAoaHR0cF9zZXJ2ZXIudGVhckRvd24pCiAKICAgICAgICAgcG9zdF9ib2R5ID0gJ2hlbGxvXG4n
Ci0gICAgICAgIGV4cGVjdGVkX3JlcGx5X2JvZHkgPSAnb2tceDAxMVxuJworICAgICAgICBleHBl
Y3RlZF9yZXBseV9ib2R5ID0gJ29rXHgwMTJcbicKIAogICAgICAgICBodHRwX3RyYW5zcG9ydCA9
IGdldF90cmFuc3BvcnQoaHR0cF9zZXJ2ZXIuZ2V0X3VybCgpKQogICAgICAgICBtZWRpdW0gPSBo
dHRwX3RyYW5zcG9ydC5nZXRfc21hcnRfbWVkaXVtKCkKQEAgLTE2MzIsNyArMTkzMyw3IEBACiAg
ICAgICAgIHNlbGYudHJhbnNwb3J0X3JlYWRvbmx5X3NlcnZlciA9IEhUVFBTZXJ2ZXJXaXRoU21h
cnRzCiAKICAgICAgICAgcG9zdF9ib2R5ID0gJ2hlbGxvXG4nCi0gICAgICAgIGV4cGVjdGVkX3Jl
cGx5X2JvZHkgPSAnb2tceDAxMVxuJworICAgICAgICBleHBlY3RlZF9yZXBseV9ib2R5ID0gJ29r
XHgwMTJcbicKIAogICAgICAgICBzbWFydF9zZXJ2ZXJfdXJsID0gc2VsZi5nZXRfcmVhZG9ubHlf
dXJsKCcuYnpyL3NtYXJ0JykKICAgICAgICAgcmVwbHkgPSB1cmxsaWIyLnVybG9wZW4oc21hcnRf
c2VydmVyX3VybCwgcG9zdF9ib2R5KS5yZWFkKCkKQEAgLTE2NTgsNyArMTk1OSw3IEBACiAgICAg
ICAgIHJlc3BvbnNlID0gc29ja2V0LndyaXRlZmlsZS5nZXR2YWx1ZSgpCiAgICAgICAgIHNlbGYu
YXNzZXJ0U3RhcnRzV2l0aChyZXNwb25zZSwgJ0hUVFAvMS4wIDIwMCAnKQogICAgICAgICAjIFRo
aXMgaW5jbHVkZXMgdGhlIGVuZCBvZiB0aGUgSFRUUCBoZWFkZXJzLCBhbmQgYWxsIHRoZSBib2R5
LgotICAgICAgICBleHBlY3RlZF9lbmRfb2ZfcmVzcG9uc2UgPSAnXHJcblxyXG5va1x4MDExXG4n
CisgICAgICAgIGV4cGVjdGVkX2VuZF9vZl9yZXNwb25zZSA9ICdcclxuXHJcbm9rXHgwMTJcbicK
ICAgICAgICAgc2VsZi5hc3NlcnRFbmRzV2l0aChyZXNwb25zZSwgZXhwZWN0ZWRfZW5kX29mX3Jl
c3BvbnNlKQogCiAKCg==
=== modified directory // last-changed:andrew.bennetts at canonical.com-200704240
... 51106-wwlidpflp1rwi3a7
# revision id: andrew.bennetts at canonical.com-20070424051106-wwlidpflp1rwi3a7
# sha1: abe85e5c85d6cb8b10ec77354a3020788d35cace
# inventory sha1: cd424335a838ddadb37e56ae5d6227eeae122ca7
# parent ids:
# pqm at pqm.ubuntu.com-20070419224637-jvlshh6kibtj43a5
# properties:
# bugs:
# branch-nick: hpss-protocol2
More information about the bazaar
mailing list