Python datagram.ERRORDatagram類代碼示例

 def test_error(self):
     # Zero-length payload
     self.assertRaises(WireProtocolError, ERRORDatagram.from_wire, '')
     # One byte payload
     self.assertRaises(WireProtocolError, ERRORDatagram.from_wire, '\x00')
     # Errorcode only (maybe this should fail)
     dgram = ERRORDatagram.from_wire('\x00\x01')
     self.assertEqual(dgram.errorcode, 1)
     self.assertEqual(dgram.errmsg, errors[1])
     # Errorcode with errstring - not terminated
     dgram = ERRORDatagram.from_wire('\x00\x01foobar')
     self.assertEqual(dgram.errorcode, 1)
     self.assertEqual(dgram.errmsg, 'foobar')
     # Errorcode with errstring - terminated
     dgram = ERRORDatagram.from_wire('\x00\x01foobar\x00')
     self.assertEqual(dgram.errorcode, 1)
     self.assertEqual(dgram.errmsg, 'foobar')
     # Unknown errorcode
     self.assertRaises(WireProtocolError, ERRORDatagram.from_wire, '\x00\x0efoobar')
     # Unknown errorcode in from_code
     self.assertRaises(WireProtocolError, ERRORDatagram.from_code, 13)
     # from_code with custom message
     dgram = ERRORDatagram.from_code(3, "I've accidentally the whole message")
     self.assertEqual(dgram.errorcode, 3)
     self.assertEqual(dgram.errmsg, "I've accidentally the whole message")
     self.assertEqual(dgram.to_wire(), "\x00\x05\x00\x03I've accidentally the whole message\x00")
     # from_code default message
     dgram = ERRORDatagram.from_code(3)
     self.assertEqual(dgram.errorcode, 3)
     self.assertEqual(dgram.errmsg, "Disk full or allocation exceeded")
     self.assertEqual(dgram.to_wire(), "\x00\x05\x00\x03Disk full or allocation exceeded\x00")

    def datagramReceived(self, datagram, addr):
        datagram = TFTPDatagramFactory(*split_opcode(datagram))
        log.msg("Datagram received from %s: %s" % (addr, datagram))

        mode = datagram.mode.lower()
        if datagram.mode not in ('netascii', 'octet'):
            return self.transport.write(ERRORDatagram.from_code(ERR_ILLEGAL_OP,
                "Unknown transfer mode %s, - expected "
                "'netascii' or 'octet' (case-insensitive)" % mode).to_wire(), addr)
        try:
            if datagram.opcode == OP_WRQ:
                fs_interface = self.backend.get_writer(datagram.filename)
            elif datagram.opcode == OP_RRQ:
                fs_interface = self.backend.get_reader(datagram.filename)
        except Unsupported, e:
            return self.transport.write(ERRORDatagram.from_code(ERR_ILLEGAL_OP,
                                    str(e)).to_wire(), addr)

 def datagramReceived(self, datagram, addr):
     if self.remote[1] != addr[1]:
         self.transport.write(ERRORDatagram.from_code(ERR_TID_UNKNOWN).to_wire())
         return# Does not belong to this transfer
     datagram = TFTPDatagramFactory(*split_opcode(datagram))
     if datagram.opcode == OP_ERROR:
         return self.tftp_ERROR(datagram)
     return self._datagramReceived(datagram)

    def tftp_DATA(self, datagram):
        """Handle incoming DATA TFTP datagram

        @type datagram: L{DATADatagram}

        """
        next_blocknum = self.blocknum + 1
        if datagram.blocknum < next_blocknum:
            self.transport.write(ACKDatagram(datagram.blocknum).to_wire())
        elif datagram.blocknum == next_blocknum:
            if self.completed:
                self.transport.write(ERRORDatagram.from_code(
                    ERR_ILLEGAL_OP, b"Transfer already finished").to_wire())
            else:
                return self.nextBlock(datagram)
        else:
            self.transport.write(ERRORDatagram.from_code(
                ERR_ILLEGAL_OP, b"Block number mismatch").to_wire())

 def _startSession(self, datagram, addr, mode):
     try:
         if datagram.opcode == OP_WRQ:
             fs_interface = yield self.backend.get_writer(datagram.filename)
         elif datagram.opcode == OP_RRQ:
             fs_interface = yield self.backend.get_reader(datagram.filename)
     except Unsupported, e:
         self.transport.write(ERRORDatagram.from_code(ERR_ILLEGAL_OP,
                                 str(e)).to_wire(), addr)

 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 datagramReceived(self, datagram, addr):
        datagram = TFTPDatagramFactory(*split_opcode(datagram))
        log.msg("Datagram received from %s: %s" % (addr, datagram))

        mode = datagram.mode.lower()
        if datagram.mode not in ('netascii', 'octet'):
            return self.transport.write(ERRORDatagram.from_code(ERR_ILLEGAL_OP,
                "Unknown transfer mode %s, - expected "
                "'netascii' or 'octet' (case-insensitive)" % mode).to_wire(), addr)

        self._clock.callLater(0, self._startSession, datagram, addr, mode)

    def datagramReceived(self, datagram, addr):
        datagram = TFTPDatagramFactory(*split_opcode(datagram))
        log.msg("Datagram received from %s: %s" % (addr, datagram))

        mode = datagram.mode.lower()
        if mode not in (b'netascii', b'octet'):
            errmsg = (
                u"Unknown transfer mode '%s', - expected 'netascii' or 'octet'"
                u"(case-insensitive)" % mode.decode("ascii"))
            return self.transport.write(ERRORDatagram.from_code(
                ERR_ILLEGAL_OP, errmsg.encode("ascii", "replace")).to_wire(), addr)

        self._clock.callLater(0, self._startSession, datagram, addr, mode)

    def tftp_ACK(self, datagram):
        """Handle the incoming ACK TFTP datagram.

        @type datagram: L{ACKDatagram}

        """
        if datagram.blocknum < self.blocknum:
            log.msg("Duplicate ACK for blocknum %s" % datagram.blocknum)
        elif datagram.blocknum == self.blocknum:
            self.timeout_watchdog.cancel()
            if self.completed:
                log.msg("Final ACK received, transfer successful")
                self.cancel()
            else:
                return self.nextBlock()
        else:
            self.transport.write(ERRORDatagram.from_code(
                ERR_ILLEGAL_OP, b"Block number mismatch").to_wire())

 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, e:
         self.transport.write(ERRORDatagram.from_code(ERR_ILLEGAL_OP,
                                 str(e)).to_wire(), addr)

 def test_error_codes(self):
     # Error codes 0 to 8 are formally defined for TFTP (as of 2015-02-04).
     for errorcode in range(0, 9):
         data = struct.pack("!H", errorcode) + "message\x00"
         dgram = ERRORDatagram.from_wire(data)
         self.assertEqual(dgram.errorcode, errorcode)

 def test_ERROR(self):
     err_dgram = ERRORDatagram.from_code(ERR_NOT_DEFINED, 'no reason')
     self.ws.datagramReceived(err_dgram)
     self.clock.advance(0.1)
     self.failIf(self.transport.value())
     self.failUnless(self.transport.disconnecting)

 def test_ERROR(self):
     err_dgram = ERRORDatagram.from_code(ERR_NOT_DEFINED, "no reason")
     yield self.rs.datagramReceived(err_dgram)
     self.failIf(self.transport.value())
     self.failUnless(self.transport.disconnecting)

 def blockWriteFailure(self, failure):
     """Write failed"""
     log.err(failure)
     self.transport.write(ERRORDatagram.from_code(ERR_DISK_FULL).to_wire())
     self.cancel()

 def readFailed(self, fail):
     """The reader reported an error. Notify the remote end and cancel the transfer"""
     log.err(fail)
     self.transport.write(ERRORDatagram.from_code(ERR_NOT_DEFINED, b"Read failed").to_wire())
     self.cancel()