def setUp(self): self.clock = Clock() self.tmp_dir_path = tempfile.mkdtemp() self.target = FilePath(self.tmp_dir_path).child('foo') with self.target.open('wb') as temp_fd: temp_fd.write(self.test_data) self.reader = DelayedReader(self.target, _clock=self.clock, delay=2) self.transport = FakeTransport(hostAddress=('127.0.0.1', self.port)) self.rs = RemoteOriginReadSession(('127.0.0.1', 65465), self.reader, _clock=self.clock) self.rs.transport = self.transport
def setUp(self): self.clock = Clock() self.temp_dir = FilePath(tempfile.mkdtemp()).asBytesMode() self.target = self.temp_dir.child(b'foo') with self.target.open('wb') as temp_fd: temp_fd.write(self.test_data) self.reader = DelayedReader(self.target, _clock=self.clock, delay=2) self.transport = FakeTransport(hostAddress=('127.0.0.1', self.port)) self.options = OrderedDict() self.options[b'blksize'] = b'9' self.options[b'tsize'] = b'34' self.rs = RemoteOriginReadSession(('127.0.0.1', 65465), self.reader, options=self.options, _clock=self.clock) self.rs.transport = self.transport
def _startSession(self, datagram, addr, mode): # Set up a call context so that we can pass extra arbitrary # information to interested backends without adding extra call # arguments, or switching to using a request object, for example. context = {} if self.transport is not None: # Add the local and remote addresses to the call context. local = self.transport.getHost() context["local"] = local.host, local.port context["remote"] = addr try: if datagram.opcode == OP_WRQ: fs_interface = yield call(context, self.backend.get_writer, datagram.filename) elif datagram.opcode == OP_RRQ: fs_interface = yield call(context, self.backend.get_reader, datagram.filename) except Unsupported as e: self.transport.write( ERRORDatagram.from_code( ERR_ILLEGAL_OP, u"{}".format(e).encode("ascii", "replace")).to_wire(), addr) except AccessViolation: self.transport.write( ERRORDatagram.from_code(ERR_ACCESS_VIOLATION).to_wire(), addr) except FileExists: self.transport.write( ERRORDatagram.from_code(ERR_FILE_EXISTS).to_wire(), addr) except FileNotFound: self.transport.write( ERRORDatagram.from_code(ERR_FILE_NOT_FOUND).to_wire(), addr) except BackendError as e: self.transport.write( ERRORDatagram.from_code( ERR_NOT_DEFINED, u"{}".format(e).encode("ascii", "replace")).to_wire(), addr) else: if datagram.opcode == OP_WRQ: if mode == b'netascii': fs_interface = NetasciiReceiverProxy(fs_interface) session = RemoteOriginWriteSession(addr, fs_interface, datagram.options, _clock=self._clock) reactor.listenUDP(0, session) returnValue(session) elif datagram.opcode == OP_RRQ: if mode == b'netascii': fs_interface = NetasciiSenderProxy(fs_interface) session = RemoteOriginReadSession(addr, fs_interface, datagram.options, _clock=self._clock) reactor.listenUDP(0, session) returnValue(session)
def setUp(self): self.clock = Clock() self.tmp_dir_path = tempfile.mkdtemp() self.target = FilePath(self.tmp_dir_path).child("foo") with self.target.open("wb") as temp_fd: temp_fd.write(self.test_data) self.reader = DelayedReader(self.target, _clock=self.clock, delay=2) self.transport = FakeTransport(hostAddress=("127.0.0.1", self.port)) self.options = OrderedDict() self.options["blksize"] = "9" self.options["tsize"] = "34" self.rs = RemoteOriginReadSession(("127.0.0.1", 65465), self.reader, options=self.options, _clock=self.clock) self.rs.transport = self.transport
class RemoteOriginReadOptionNegotiation(unittest.TestCase): test_data = """line1 line2 anotherline""" port = 65466 def setUp(self): self.clock = Clock() self.tmp_dir_path = tempfile.mkdtemp() self.target = FilePath(self.tmp_dir_path).child('foo') with self.target.open('wb') as temp_fd: temp_fd.write(self.test_data) self.reader = DelayedReader(self.target, _clock=self.clock, delay=2) self.transport = FakeTransport(hostAddress=('127.0.0.1', self.port)) self.rs = RemoteOriginReadSession(('127.0.0.1', 65465), self.reader, options={'blksize':'9'}, _clock=self.clock) self.rs.transport = self.transport def test_option_normal(self): self.rs.startProtocol() self.clock.advance(0.1) oack_datagram = OACKDatagram({'blksize':'9'}).to_wire() self.assertEqual(self.transport.value(), oack_datagram) self.clock.advance(3) self.assertEqual(self.transport.value(), oack_datagram * 2) self.transport.clear() self.rs.datagramReceived(ACKDatagram(0).to_wire(), ('127.0.0.1', 65465)) self.clock.pump((1,)*3) self.assertEqual(self.transport.value(), DATADatagram(1, self.test_data[:9]).to_wire()) self.addCleanup(self.rs.cancel) def test_option_timeout(self): self.rs.startProtocol() self.clock.advance(0.1) oack_datagram = OACKDatagram({'blksize':'9'}).to_wire() self.assertEqual(self.transport.value(), oack_datagram) self.failIf(self.transport.disconnecting) self.clock.advance(3) self.assertEqual(self.transport.value(), oack_datagram * 2) self.failIf(self.transport.disconnecting) self.clock.advance(2) self.assertEqual(self.transport.value(), oack_datagram * 3) self.failIf(self.transport.disconnecting) self.clock.advance(2) self.assertEqual(self.transport.value(), oack_datagram * 3) self.failUnless(self.transport.disconnecting) def tearDown(self): shutil.rmtree(self.tmp_dir_path)
class BootstrapRemoteOriginRead(unittest.TestCase): test_data = """line1 line2 anotherline""" port = 65466 def setUp(self): self.clock = Clock() self.tmp_dir_path = tempfile.mkdtemp() self.target = FilePath(self.tmp_dir_path).child('foo') with self.target.open('wb') as temp_fd: temp_fd.write(self.test_data) self.reader = DelayedReader(self.target, _clock=self.clock, delay=2) self.transport = FakeTransport(hostAddress=('127.0.0.1', self.port)) self.rs = RemoteOriginReadSession(('127.0.0.1', 65465), self.reader, _clock=self.clock) self.rs.transport = self.transport @inlineCallbacks def test_invalid_tid(self): self.rs.startProtocol() data_datagram = DATADatagram(1, 'foobar') yield self.rs.datagramReceived(data_datagram, ('127.0.0.1', 11111)) err_dgram = TFTPDatagramFactory(*split_opcode(self.transport.value())) self.assertEqual(err_dgram.errorcode, ERR_TID_UNKNOWN) self.addCleanup(self.rs.cancel) def test_remote_origin_read_bootstrap(self): # First datagram self.rs.session.block_size = 5 self.rs.startProtocol() self.clock.pump((1,)*3) data_datagram_1 = DATADatagram(1, self.test_data[:5]) self.assertEqual(self.transport.value(), data_datagram_1.to_wire()) self.failIf(self.transport.disconnecting) # Normal exchange continues self.transport.clear() self.rs.datagramReceived(ACKDatagram(1).to_wire(), ('127.0.0.1', 65465)) self.clock.pump((1,)*3) data_datagram_2 = DATADatagram(2, self.test_data[5:10]) self.assertEqual(self.transport.value(), data_datagram_2.to_wire()) self.failIf(self.transport.disconnecting) self.addCleanup(self.rs.cancel) def tearDown(self): shutil.rmtree(self.tmp_dir_path)
class RemoteOriginReadOptionNegotiation(unittest.TestCase): test_data = """line1 line2 anotherline""" port = 65466 def setUp(self): self.clock = Clock() self.tmp_dir_path = tempfile.mkdtemp() self.target = FilePath(self.tmp_dir_path).child('foo') with self.target.open('wb') as temp_fd: temp_fd.write(self.test_data) self.reader = DelayedReader(self.target, _clock=self.clock, delay=2) self.transport = FakeTransport(hostAddress=('127.0.0.1', self.port)) self.options = OrderedDict() self.options['blksize'] = '9' self.options['tsize'] = '34' self.rs = RemoteOriginReadSession(('127.0.0.1', 65465), self.reader, options=self.options, _clock=self.clock) self.rs.transport = self.transport def test_option_normal(self): self.rs.startProtocol() self.clock.advance(0.1) oack_datagram = OACKDatagram(self.options).to_wire() self.assertEqual(self.transport.value(), oack_datagram) self.clock.advance(3) self.assertEqual(self.transport.value(), oack_datagram * 2) self.transport.clear() self.rs.datagramReceived(ACKDatagram(0).to_wire(), ('127.0.0.1', 65465)) self.clock.pump((1,)*3) self.assertEqual(self.transport.value(), DATADatagram(1, self.test_data[:9]).to_wire()) self.addCleanup(self.rs.cancel) def test_option_timeout(self): self.rs.startProtocol() self.clock.advance(0.1) oack_datagram = OACKDatagram(self.options).to_wire() self.assertEqual(self.transport.value(), oack_datagram) self.failIf(self.transport.disconnecting) self.clock.advance(3) self.assertEqual(self.transport.value(), oack_datagram * 2) self.failIf(self.transport.disconnecting) self.clock.advance(2) self.assertEqual(self.transport.value(), oack_datagram * 3) self.failIf(self.transport.disconnecting) self.clock.advance(2) self.assertEqual(self.transport.value(), oack_datagram * 3) self.failUnless(self.transport.disconnecting) def test_option_tsize(self): # A tsize option of 0 sent as part of a read session prompts a tsize # response with the actual size of the file. self.options['tsize'] = '0' self.rs.startProtocol() self.clock.advance(0.1) self.transport.clear() self.clock.advance(3) # The response contains the size of the test data. self.options['tsize'] = str(len(self.test_data)) oack_datagram = OACKDatagram(self.options).to_wire() self.assertEqual(self.transport.value(), oack_datagram) def tearDown(self): shutil.rmtree(self.tmp_dir_path)
ERRORDatagram.from_code(ERR_ACCESS_VIOLATION).to_wire(), addr) except FileExists: self.transport.write( ERRORDatagram.from_code(ERR_FILE_EXISTS).to_wire(), addr) except FileNotFound: self.transport.write( ERRORDatagram.from_code(ERR_FILE_NOT_FOUND).to_wire(), addr) except BackendError, e: self.transport.write( ERRORDatagram.from_code(ERR_NOT_DEFINED, str(e)).to_wire(), addr) else: if datagram.opcode == OP_WRQ: if mode == 'netascii': fs_interface = NetasciiReceiverProxy(fs_interface) session = RemoteOriginWriteSession(addr, fs_interface, datagram.options, _clock=self._clock) reactor.listenUDP(0, session) returnValue(session) elif datagram.opcode == OP_RRQ: if mode == 'netascii': fs_interface = NetasciiSenderProxy(fs_interface) session = RemoteOriginReadSession(addr, fs_interface, datagram.options, _clock=self._clock) reactor.listenUDP(0, session) returnValue(session)
class BootstrapRemoteOriginRead(unittest.TestCase): test_data = b"""line1 line2 anotherline""" port = 65466 def setUp(self): self.clock = Clock() self.temp_dir = FilePath(tempfile.mkdtemp()).asBytesMode() self.target = self.temp_dir.child(b'foo') with self.target.open('wb') as temp_fd: temp_fd.write(self.test_data) self.reader = DelayedReader(self.target, _clock=self.clock, delay=2) self.transport = FakeTransport(hostAddress=('127.0.0.1', self.port)) self.rs = RemoteOriginReadSession(('127.0.0.1', 65465), self.reader, _clock=self.clock) self.rs.transport = self.transport @inlineCallbacks def test_invalid_tid(self): self.rs.startProtocol() data_datagram = DATADatagram(1, b'foobar') yield self.rs.datagramReceived(data_datagram, ('127.0.0.1', 11111)) err_dgram = TFTPDatagramFactory(*split_opcode(self.transport.value())) self.assertEqual(err_dgram.errorcode, ERR_TID_UNKNOWN) self.addCleanup(self.rs.cancel) def test_remote_origin_read_bootstrap(self): # First datagram self.rs.session.block_size = 5 self.rs.startProtocol() self.clock.pump((1,)*3) data_datagram_1 = DATADatagram(1, self.test_data[:5]) self.assertEqual(self.transport.value(), data_datagram_1.to_wire()) self.assertFalse(self.transport.disconnecting) # Normal exchange continues self.transport.clear() self.rs.datagramReceived(ACKDatagram(1).to_wire(), ('127.0.0.1', 65465)) self.clock.pump((1,)*3) data_datagram_2 = DATADatagram(2, self.test_data[5:10]) self.assertEqual(self.transport.value(), data_datagram_2.to_wire()) self.assertFalse(self.transport.disconnecting) self.addCleanup(self.rs.cancel) def test_remote_origin_read_session_not_started_rollover(self): # if a rollover is done, we reach blocknum 0 again. But this time # session is already started. # Here we test the case where rollover has not happened yet data_datagram = DATADatagram(1, self.test_data[:5]) data_datagram.opcode = OP_ACK data_datagram.blocknum = 0 self.rs.session.block_size = 5 self.clock.pump((1,)*3) self.rs.session.transport = b"Fake" self.rs.session.started = False self.rs._datagramReceived(data_datagram) self.assertEqual(self.rs.session.started, True) self.assertEqual(self.rs.session.transport, self.rs.transport) self.addCleanup(self.rs.cancel) def test_remote_origin_read_session_started_rollover(self): # if a rollover is done, we reach blocknum 0 again. But this time # session is already started. # Here we test the case where rollover has already happened data_datagram = DATADatagram(1, self.test_data[:5]) data_datagram.opcode = OP_ACK data_datagram.blocknum = 0 self.rs.session.block_size = 5 self.rs.startProtocol() self.clock.pump((1,)*3) self.assertEqual( self.rs._datagramReceived(data_datagram), self.rs.session.datagramReceived(data_datagram)) self.addCleanup(self.rs.cancel) def tearDown(self): self.temp_dir.remove()
class BootstrapRemoteOriginRead(unittest.TestCase): test_data = b"""line1 line2 anotherline""" port = 65466 def setUp(self): self.clock = Clock() self.temp_dir = FilePath(tempfile.mkdtemp()).asBytesMode() self.target = self.temp_dir.child(b'foo') with self.target.open('wb') as temp_fd: temp_fd.write(self.test_data) self.reader = DelayedReader(self.target, _clock=self.clock, delay=2) self.transport = FakeTransport(hostAddress=('127.0.0.1', self.port)) self.rs = RemoteOriginReadSession(('127.0.0.1', 65465), self.reader, _clock=self.clock) self.rs.transport = self.transport @inlineCallbacks def test_invalid_tid(self): self.rs.startProtocol() data_datagram = DATADatagram(1, b'foobar') yield self.rs.datagramReceived(data_datagram, ('127.0.0.1', 11111)) err_dgram = TFTPDatagramFactory(*split_opcode(self.transport.value())) self.assertEqual(err_dgram.errorcode, ERR_TID_UNKNOWN) self.addCleanup(self.rs.cancel) def test_remote_origin_read_bootstrap(self): # First datagram self.rs.session.block_size = 5 self.rs.startProtocol() self.clock.pump((1, ) * 3) data_datagram_1 = DATADatagram(1, self.test_data[:5]) self.assertEqual(self.transport.value(), data_datagram_1.to_wire()) self.assertFalse(self.transport.disconnecting) # Normal exchange continues self.transport.clear() self.rs.datagramReceived( ACKDatagram(1).to_wire(), ('127.0.0.1', 65465)) self.clock.pump((1, ) * 3) data_datagram_2 = DATADatagram(2, self.test_data[5:10]) self.assertEqual(self.transport.value(), data_datagram_2.to_wire()) self.assertFalse(self.transport.disconnecting) self.addCleanup(self.rs.cancel) def test_remote_origin_read_session_not_started_rollover(self): # if a rollover is done, we reach blocknum 0 again. But this time # session is already started. # Here we test the case where rollover has not happened yet data_datagram = DATADatagram(1, self.test_data[:5]) data_datagram.opcode = OP_ACK data_datagram.blocknum = 0 self.rs.session.block_size = 5 self.clock.pump((1, ) * 3) self.rs.session.transport = b"Fake" self.rs.session.started = False self.rs._datagramReceived(data_datagram) self.assertEqual(self.rs.session.started, True) self.assertEqual(self.rs.session.transport, self.rs.transport) self.addCleanup(self.rs.cancel) def test_remote_origin_read_session_started_rollover(self): # if a rollover is done, we reach blocknum 0 again. But this time # session is already started. # Here we test the case where rollover has already happened data_datagram = DATADatagram(1, self.test_data[:5]) data_datagram.opcode = OP_ACK data_datagram.blocknum = 0 self.rs.session.block_size = 5 self.rs.startProtocol() self.clock.pump((1, ) * 3) self.assertEqual(self.rs._datagramReceived(data_datagram), self.rs.session.datagramReceived(data_datagram)) self.addCleanup(self.rs.cancel) def tearDown(self): self.temp_dir.remove()