/brz/remove-bazaar : revision 2018.5.3

41

SmartClientHTTPMediumRequest,

42

SmartRequestHandler,

43

)

44

from bzrlib.transport.smart import medium

44

from bzrlib.transport.smart import medium, protocol

45

46

47

class StringIOSSHVendor(object):

591

transport = local.LocalTransport(urlutils.local_path_to_url('/'))

592

server = medium.SmartServerPipeStreamMedium(

593

to_server, from_server, transport)

594

protocol = smart.SmartServerRequestProtocolOne(transport,

594

smart_protocol = protocol.SmartServerRequestProtocolOne(transport,

595

from_server.write)

596

server._serve_one_request(protocol)

596

server._serve_one_request(smart_protocol)

597

self.assertEqual('ok\0011\n',

598

from_server.getvalue())

599

604

from_server = StringIO()

605

server = medium.SmartServerPipeStreamMedium(

606

to_server, from_server, transport)

607

protocol = smart.SmartServerRequestProtocolOne(transport,

607

smart_protocol = protocol.SmartServerRequestProtocolOne(transport,

608

from_server.write)

609

server._serve_one_request(protocol)

609

server._serve_one_request(smart_protocol)

610

self.assertEqual('ok\n'

611

'17\n'

612

'contents\nof\nfile\n'

622

from_server = StringIO()

623

server = medium.SmartServerPipeStreamMedium(

624

to_server, from_server, transport)

625

protocol = smart.SmartServerRequestProtocolOne(transport,

625

smart_protocol = protocol.SmartServerRequestProtocolOne(transport,

626

from_server.write)

627

server._serve_one_request(protocol)

627

server._serve_one_request(smart_protocol)

628

self.assertEqual('ok\n'

629

'17\n'

630

'contents\nof\nfile\n'

1064

self.to_client = StringIO()

1065

self.client_medium = medium.SmartSimplePipesClientMedium(self.to_client,

1066

self.to_server)

1067

self.client_protocol = smart.SmartClientRequestProtocolOne(

1067

self.client_protocol = protocol.SmartClientRequestProtocolOne(

1068

self.client_medium)

1069

self.smart_server = InstrumentedServerProtocol(self.server_to_client)

1070

self.smart_server_request = smart.SmartServerRequestHandler(None)

1090

1091

def build_protocol_waiting_for_body(self):

1092

out_stream = StringIO()

1093

protocol = smart.SmartServerRequestProtocolOne(None, out_stream.write)

1094

protocol.has_dispatched = True

1095

protocol.request = smart.SmartServerRequestHandler(None)

1093

smart_protocol = protocol.SmartServerRequestProtocolOne(None,

1094

out_stream.write)

1095

smart_protocol.has_dispatched = True

1096

smart_protocol.request = smart.SmartServerRequestHandler(None)

1096

1097

def handle_end_of_bytes():

1097

1098

self.end_received = True

1098

self.assertEqual('abcdefg', protocol.request._body_bytes)

1099

protocol.request.response = smart.SmartServerResponse(('ok', ))

1100

protocol.request._end_of_body_handler = handle_end_of_bytes

1099

self.assertEqual('abcdefg', smart_protocol.request._body_bytes)

1100

response = protocol.SmartServerResponse(('ok', ))

1101

smart_protocol.request.response = response

1102

smart_protocol.request._end_of_body_handler = handle_end_of_bytes

1101

1103

# Call accept_bytes to make sure that internal state like _body_decoder

1102

1104

# is initialised. This test should probably be given a clearer

1103

1105

# interface to work with that will not cause this inconsistency.

1104

1106

# -- Andrew Bennetts, 2006-09-28

1105

protocol.accept_bytes('')

1106

return protocol

1107

smart_protocol.accept_bytes('')

1108

return smart_protocol

1107

1109

1108

1110

def test_construct_version_one_server_protocol(self):

1109

protocol = smart.SmartServerRequestProtocolOne(None, None)

1110

self.assertEqual('', protocol.excess_buffer)

1111

self.assertEqual('', protocol.in_buffer)

1112

self.assertFalse(protocol.has_dispatched)

1113

self.assertEqual(1, protocol.next_read_size())

1111

smart_protocol = protocol.SmartServerRequestProtocolOne(None, None)

1112

self.assertEqual('', smart_protocol.excess_buffer)

1113

self.assertEqual('', smart_protocol.in_buffer)

1114

self.assertFalse(smart_protocol.has_dispatched)

1115

self.assertEqual(1, smart_protocol.next_read_size())

1114

1116

1115

1117

def test_construct_version_one_client_protocol(self):

1116

1118

# we can construct a client protocol from a client medium request

1117

1119

output = StringIO()

1118

1120

client_medium = medium.SmartSimplePipesClientMedium(None, output)

1119

1121

request = client_medium.get_request()

1120

client_protocol = smart.SmartClientRequestProtocolOne(request)

1122

client_protocol = protocol.SmartClientRequestProtocolOne(request)

1121

1123

1122

1124

def test_server_offset_serialisation(self):

1123

1125

"""The Smart protocol serialises offsets as a comma and \n string.

1137

1139

1138

1140

def test_accept_bytes_of_bad_request_to_protocol(self):

1139

1141

out_stream = StringIO()

1140

protocol = smart.SmartServerRequestProtocolOne(None, out_stream.write)

1141

protocol.accept_bytes('abc')

1142

self.assertEqual('abc', protocol.in_buffer)

1143

protocol.accept_bytes('\n')

1144

self.assertEqual("error\x01Generic bzr smart protocol error: bad request"

1145

" 'abc'\n", out_stream.getvalue())

1146

self.assertTrue(protocol.has_dispatched)

1147

self.assertEqual(0, protocol.next_read_size())

1142

smart_protocol = protocol.SmartServerRequestProtocolOne(

1143

None, out_stream.write)

1144

smart_protocol.accept_bytes('abc')

1145

self.assertEqual('abc', smart_protocol.in_buffer)

1146

smart_protocol.accept_bytes('\n')

1147

self.assertEqual(

1148

"error\x01Generic bzr smart protocol error: bad request 'abc'\n",

1149

out_stream.getvalue())

1150

self.assertTrue(smart_protocol.has_dispatched)

1151

self.assertEqual(0, smart_protocol.next_read_size())

1148

1152

1149

1153

def test_accept_body_bytes_to_protocol(self):

1150

1154

protocol = self.build_protocol_waiting_for_body()

1160

1164

mem_transport = memory.MemoryTransport()

1161

1165

mem_transport.put_bytes('foo', 'abcdefghij')

1162

1166

out_stream = StringIO()

1163

protocol = smart.SmartServerRequestProtocolOne(mem_transport,

1167

smart_protocol = protocol.SmartServerRequestProtocolOne(mem_transport,

1164

1168

out_stream.write)

1165

protocol.accept_bytes('readv\x01foo\n3\n3,3done\n')

1166

self.assertEqual(0, protocol.next_read_size())

1169

smart_protocol.accept_bytes('readv\x01foo\n3\n3,3done\n')

1170

self.assertEqual(0, smart_protocol.next_read_size())

1167

1171

self.assertEqual('readv\n3\ndefdone\n', out_stream.getvalue())

1168

self.assertEqual('', protocol.excess_buffer)

1169

self.assertEqual('', protocol.in_buffer)

1172

self.assertEqual('', smart_protocol.excess_buffer)

1173

self.assertEqual('', smart_protocol.in_buffer)

1170

1174

1171

1175

def test_accept_excess_bytes_are_preserved(self):

1172

1176

out_stream = StringIO()

1173

protocol = smart.SmartServerRequestProtocolOne(None, out_stream.write)

1174

protocol.accept_bytes('hello\nhello\n')

1177

smart_protocol = protocol.SmartServerRequestProtocolOne(

1178

None, out_stream.write)

1179

smart_protocol.accept_bytes('hello\nhello\n')

1175

1180

self.assertEqual("ok\x011\n", out_stream.getvalue())

1176

self.assertEqual("hello\n", protocol.excess_buffer)

1177

self.assertEqual("", protocol.in_buffer)

1181

self.assertEqual("hello\n", smart_protocol.excess_buffer)

1182

self.assertEqual("", smart_protocol.in_buffer)

1178

1183

1179

1184

def test_accept_excess_bytes_after_body(self):

1180

1185

protocol = self.build_protocol_waiting_for_body()

1188

1193

1189

1194

def test_accept_excess_bytes_after_dispatch(self):

1190

1195

out_stream = StringIO()

1191

protocol = smart.SmartServerRequestProtocolOne(None, out_stream.write)

1192

protocol.accept_bytes('hello\n')

1196

smart_protocol = protocol.SmartServerRequestProtocolOne(

1197

None, out_stream.write)

1198

smart_protocol.accept_bytes('hello\n')

1193

1199

self.assertEqual("ok\x011\n", out_stream.getvalue())

1194

protocol.accept_bytes('hel')

1195

self.assertEqual("hel", protocol.excess_buffer)

1196

protocol.accept_bytes('lo\n')

1197

self.assertEqual("hello\n", protocol.excess_buffer)

1198

self.assertEqual("", protocol.in_buffer)

1200

smart_protocol.accept_bytes('hel')

1201

self.assertEqual("hel", smart_protocol.excess_buffer)

1202

smart_protocol.accept_bytes('lo\n')

1203

self.assertEqual("hello\n", smart_protocol.excess_buffer)

1204

self.assertEqual("", smart_protocol.in_buffer)

1199

1205

1200

1206

def test__send_response_sets_finished_reading(self):

1201

protocol = smart.SmartServerRequestProtocolOne(None, lambda x: None)

1202

self.assertEqual(1, protocol.next_read_size())

1203

protocol._send_response(('x',))

1204

self.assertEqual(0, protocol.next_read_size())

1207

smart_protocol = protocol.SmartServerRequestProtocolOne(

1208

None, lambda x: None)

1209

self.assertEqual(1, smart_protocol.next_read_size())

1210

smart_protocol._send_response(('x',))

1211

self.assertEqual(0, smart_protocol.next_read_size())

1205

1212

1206

1213

def test_query_version(self):

1207

1214

"""query_version on a SmartClientProtocolOne should return a number.

1217

1224

output = StringIO()

1218

1225

client_medium = medium.SmartSimplePipesClientMedium(input, output)

1219

1226

request = client_medium.get_request()

1220

protocol = smart.SmartClientRequestProtocolOne(request)

1221

self.assertEqual(1, protocol.query_version())

1227

smart_protocol = protocol.SmartClientRequestProtocolOne(request)

1228

self.assertEqual(1, smart_protocol.query_version())

1222

1229

1223

1230

def assertServerToClientEncoding(self, expected_bytes, expected_tuple,

1224

1231

input_tuples):

1229

1236

# expected bytes

1230

1237

for input_tuple in input_tuples:

1231

1238

server_output = StringIO()

1232

server_protocol = smart.SmartServerRequestProtocolOne(

1239

server_protocol = protocol.SmartServerRequestProtocolOne(

1233

1240

None, server_output.write)

1234

1241

server_protocol._send_response(input_tuple)

1235

1242

self.assertEqual(expected_bytes, server_output.getvalue())

1236

# check the decoding of the client protocol from expected_bytes:

1243

# check the decoding of the client smart_protocol from expected_bytes:

1237

1244

input = StringIO(expected_bytes)

1238

1245

output = StringIO()

1239

1246

client_medium = medium.SmartSimplePipesClientMedium(input, output)

1240

1247

request = client_medium.get_request()

1241

protocol = smart.SmartClientRequestProtocolOne(request)

1242

protocol.call('foo')

1243

self.assertEqual(expected_tuple, protocol.read_response_tuple())

1248

smart_protocol = protocol.SmartClientRequestProtocolOne(request)

1249

smart_protocol.call('foo')

1250

self.assertEqual(expected_tuple, smart_protocol.read_response_tuple())

1244

1251

1245

1252

def test_client_call_empty_response(self):

1246

1253

# protocol.call() can get back an empty tuple as a response. This occurs

1262

1269

output = StringIO()

1263

1270

client_medium = medium.SmartSimplePipesClientMedium(input, output)

1264

1271

request = client_medium.get_request()

1265

protocol = smart.SmartClientRequestProtocolOne(request)

1266

protocol.call_with_body_bytes(('foo', ), "abcdefg")

1272

smart_protocol = protocol.SmartClientRequestProtocolOne(request)

1273

smart_protocol.call_with_body_bytes(('foo', ), "abcdefg")

1267

1274

self.assertEqual(expected_bytes, output.getvalue())

1268

1275

1269

1276

def test_client_call_with_body_readv_array(self):

1274

1281

output = StringIO()

1275

1282

client_medium = medium.SmartSimplePipesClientMedium(input, output)

1276

1283

request = client_medium.get_request()

1277

protocol = smart.SmartClientRequestProtocolOne(request)

1278

protocol.call_with_body_readv_array(('foo', ), [(1,2),(5,6)])

1284

smart_protocol = protocol.SmartClientRequestProtocolOne(request)

1285

smart_protocol.call_with_body_readv_array(('foo', ), [(1,2),(5,6)])

1279

1286

self.assertEqual(expected_bytes, output.getvalue())

1280

1287

1281

1288

def test_client_read_body_bytes_all(self):

1287

1294

output = StringIO()

1288

1295

client_medium = medium.SmartSimplePipesClientMedium(input, output)

1289

1296

request = client_medium.get_request()

1290

protocol = smart.SmartClientRequestProtocolOne(request)

1291

protocol.call('foo')

1292

protocol.read_response_tuple(True)

1293

self.assertEqual(expected_bytes, protocol.read_body_bytes())

1297

smart_protocol = protocol.SmartClientRequestProtocolOne(request)

1298

smart_protocol.call('foo')

1299

smart_protocol.read_response_tuple(True)

1300

self.assertEqual(expected_bytes, smart_protocol.read_body_bytes())

1294

1301

1295

1302

def test_client_read_body_bytes_incremental(self):

1296

1303

# test reading a few bytes at a time from the body

1304

1311

output = StringIO()

1305

1312

client_medium = medium.SmartSimplePipesClientMedium(input, output)

1306

1313

request = client_medium.get_request()

1307

protocol = smart.SmartClientRequestProtocolOne(request)

1308

protocol.call('foo')

1309

protocol.read_response_tuple(True)

1310

self.assertEqual(expected_bytes[0:2], protocol.read_body_bytes(2))

1311

self.assertEqual(expected_bytes[2:4], protocol.read_body_bytes(2))

1312

self.assertEqual(expected_bytes[4:6], protocol.read_body_bytes(2))

1313

self.assertEqual(expected_bytes[6], protocol.read_body_bytes())

1314

smart_protocol = protocol.SmartClientRequestProtocolOne(request)

1315

smart_protocol.call('foo')

1316

smart_protocol.read_response_tuple(True)

1317

self.assertEqual(expected_bytes[0:2], smart_protocol.read_body_bytes(2))

1318

self.assertEqual(expected_bytes[2:4], smart_protocol.read_body_bytes(2))

1319

self.assertEqual(expected_bytes[4:6], smart_protocol.read_body_bytes(2))

1320

self.assertEqual(expected_bytes[6], smart_protocol.read_body_bytes())

1314

1321

1315

1322

def test_client_cancel_read_body_does_not_eat_body_bytes(self):

1316

1323

# cancelling the expected body needs to finish the request, but not

1321

1328

output = StringIO()

1322

1329

client_medium = medium.SmartSimplePipesClientMedium(input, output)

1323

1330

request = client_medium.get_request()

1324

protocol = smart.SmartClientRequestProtocolOne(request)

1325

protocol.call('foo')

1326

protocol.read_response_tuple(True)

1327

protocol.cancel_read_body()

1331

smart_protocol = protocol.SmartClientRequestProtocolOne(request)

1332

smart_protocol.call('foo')

1333

smart_protocol.read_response_tuple(True)

1334

smart_protocol.cancel_read_body()

1328

1335

self.assertEqual(3, input.tell())

1329

self.assertRaises(errors.ReadingCompleted, protocol.read_body_bytes)

1336

self.assertRaises(

1337

errors.ReadingCompleted, smart_protocol.read_body_bytes)

1330

1338

1331

1339

1332

1340

class LengthPrefixedBodyDecoder(tests.TestCase):

1335

1343

# something similar to the ProtocolBase method.

1336

1344

1337

1345

def test_construct(self):

1338

decoder = smart.LengthPrefixedBodyDecoder()

1346

decoder = protocol.LengthPrefixedBodyDecoder()

1339

1347

self.assertFalse(decoder.finished_reading)

1340

1348

self.assertEqual(6, decoder.next_read_size())

1341

1349

self.assertEqual('', decoder.read_pending_data())

1342

1350

self.assertEqual('', decoder.unused_data)

1343

1351

1344

1352

def test_accept_bytes(self):

1345

decoder = smart.LengthPrefixedBodyDecoder()

1353

decoder = protocol.LengthPrefixedBodyDecoder()

1346

1354

decoder.accept_bytes('')

1347

1355

self.assertFalse(decoder.finished_reading)

1348

1356

self.assertEqual(6, decoder.next_read_size())

1375

1383

self.assertEqual('blarg', decoder.unused_data)

1376

1384

1377

1385

def test_accept_bytes_all_at_once_with_excess(self):

1378

decoder = smart.LengthPrefixedBodyDecoder()

1386

decoder = protocol.LengthPrefixedBodyDecoder()

1379

1387

decoder.accept_bytes('1\nadone\nunused')

1380

1388

self.assertTrue(decoder.finished_reading)

1381

1389

self.assertEqual(1, decoder.next_read_size())

1383

1391

self.assertEqual('unused', decoder.unused_data)

1384

1392

1385

1393

def test_accept_bytes_exact_end_of_body(self):

1386

decoder = smart.LengthPrefixedBodyDecoder()

1394

decoder = protocol.LengthPrefixedBodyDecoder()

1387

1395

decoder.accept_bytes('1\na')

1388

1396

self.assertFalse(decoder.finished_reading)

1389

1397

self.assertEqual(5, decoder.next_read_size())