Question

我一直在使用asyncio.Protocol在python中编写MUD，但是当用户关闭其客户端（通常是终端，因为您通过telnet连接）而没有正确断开连接时，我遇到了问题。

服务器不会将用户识别为已断开连接，并且他们仍然在游戏中。

问题只发生在远程连接客户端时（出于某种原因，可能有人可以解释......）从localhost连接时不会发生这种情况。

是否有一种简洁的方法来检查用户是否仍然实际连接（没有其他软件客户端），或者如果失败，我如何合并超时？

我的协议目前看起来像这样：

class User(Protocol):

    def connection_made(self, transport):
        self.transport = transport
        self.addr = transport.get_extra_info('peername')
        self.authd = False
        self.name = None
        self.admin = False
        self.room = None
        self.table = None
        self.db = None

        self.flags = []

        print("Connected: {}".format(self.addr))
        server.connected.append(self)

        actions['help'](self, ['welcome'])
        self.get_prompt()

    def data_received(self, data):
        msg = data.decode().strip()
        args = msg.split()

        if self.authd is False:
            actions['login'](self, args)
            return

        if msg:
            if args[0] in self.db.aliases:
                args[0] = str(self.db.aliases[args[0]])
                msg = ' '.join(args)
                args = msg.split()

            if msg[0] in server.channels:
                ch = db.session.query(db.models.Channel).get(msg[0])
                if msg[1] =='@':
                    channels.send_to_channel(self, ch, msg[2:], do_emote=True)
                else:
                    channels.send_to_channel(self, ch, msg[1:])
                self.get_prompt()
                return

            if args[0] in actions:
                if self.is_frozen():
                    self.send_to_self("You're frozen solid!")
                else:
                    actions[args[0]](self, args[1:] if len(args) > 1 else None)
                self.get_prompt()
                return
            self.send_to_self("Huh?")
        else:
            if self.table is not None:
                actions['table'](self, None)
            elif self.room is not None:
                actions['look'](self, None)

    def send_to_self(self, msg):
        msg = "\r\n" + msg
        msg = colourify(msg)
        self.transport.write(msg.encode())

    @staticmethod
    def send_to_user(user, msg):
        msg = "\r\n"+msg
        msg = colourify(msg)
        user.transport.write(msg.encode())

    @staticmethod
    def send_to_users(users, msg):
        msg = "\r\n"+msg
        msg = colourify(msg)
        for user in users:
            user.transport.write(msg.encode())

    def connection_lost(self, ex):
        print("Disconnected: {}".format(self.addr))
        server.connected.remove(self)

        if self.authd:
            self.save()
            server.users.remove(self)
            self.room.occupants.remove(self)

注意：我已经砍掉了很多多余的东西。如果您需要完整的代码，那就是here.

Answer 1

您可以在每个data_received()调用上安排一个新的超时处理程序（当然，取消之前的超时处理程序）。我发现这种方法太麻烦了。

或者，作为一个选项，切换到asyncio streams - 您可以使用asyncio.wait_for或尚未发布的全新asyncio.timeout。

使用asyncio.Protocol的客户端超时

1 个答案: