0

出于某种原因，self.connected该类asyncore.dispatcher不认为我的套接字是在客户端连接的。服务器端将套接字视为已连接并将其视为已连接，但客户端不知道它是否已连接并且handle_connect不“proc”，因此我不能使用它的覆盖版本来检查套接字是否连接。

关于这段代码为什么它不起作用的任何想法：

#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
import asyncore
from threading import *
from socket import *
from time import sleep
from os import _exit
from logger import *
from config import *

class logDispatcher(asyncore.dispatcher):
    def __init__(self, config=None):
        self.inbuffer = ''
        self.buffer = ''
        self.lockedbuffer = False
        self.is_writable = False

        asyncore.dispatcher.__init__(self)
        #Thread.__init__(self)

        self.create_socket(AF_INET, SOCK_STREAM)

        #self.is_writable = True
        #self.start()

    def compare(self, obj, otherobj):
        return (str(obj).lower() == str(otherobj).lower()[:len(str(obj))])
    def _in(self, obj, otherobj):
        return (str(obj).lower() in str(otherobj).lower())

    def parse(self):
        if self.inbuffer[-2:] != '\r\n':
            return False

        self.lockedbuffer = True
        self.inbuffer = ''
        self.lockedbuffer = False

    def readable(self):
        return True

    def handle_connect(self):
        log('Connected to ' + str(server), 'SOCK_CORE')

    def handle_close(self):
        self.close()

    def handle_read(self):
        data = self.recv(8192)
        while self.lockedbuffer:
            sleep(0.01)
        self.inbuffer += data

    def writable(self):
        return (len(self.buffer) > 0)

    def handle_write(self):
        while self.is_writable:
            sent = self.send(self.buffer)
            sleep(1)
            self.buffer = self.buffer[sent:]
            if len(self.buffer) <= 0:
                self.is_writable = False
            sleep(0.01)

    def _send(self, what):
        self.buffer += what + '\r\n'
        self.is_writable = True

    def handle_error(self):
        log('Error, closing socket!', 'SOCK_CORE')
        self.close()

    def run(self):
        log('Log socket engine initating', 'SOCK_CORE')
        self.connect((server, server_port))

        print self.connected
        sleep(3)
        print self.connected

class start(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.start()
    def run(self):
        asyncore.loop(0.1)

start()
logDisp = logDispatcher()
logDisp.run()
4

1 回答 1

1 
def handle_connect_event(self):
    self.is_connected = True

将它添加到您的调度程序将为您提供一种检查套接字是否已连接的方法，这要归功于python -m trace -t script.pyPython中的一些堆栈跟踪（asyncore只要套接字已连接或处于连接状态。

之后，我还替换了线程 asyncore.loop() 并将其替换为锁定主线程的“静态”放置，这两种组合之一（或两者）现在解决了问题..逻辑不一样就像我不喜欢的问题一样，但我假设我需要创建自己的 dispach_event 就像我要创建一个 OpenGL GUI 类一样，我会在每个循环中手动调用 dispatch_event() 在线程中的一些方式“让事物保持活力”..这只是一个想法..

无论如何，这是一个工作示例：

#!/usr/bin/python
# -*- coding: iso-8859-15 -*-
import asyncore, socket
from threading import *
from time import sleep
from os import _exit
from logger import *
from config import *

def _map():
    return {}
def _array():
    return []

class logDispatcher(Thread, asyncore.dispatcher):
    def __init__(self, config=None):
        self.inbuffer = ''
        self.buffer = ''
        self.lockedbuffer = False
        self.is_writable = False

        self.is_connected = False

        self.exit = False
        self.initated = False

        asyncore.dispatcher.__init__(self)
        Thread.__init__(self)

        self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            self.connect((server, server_port))
        except:
            log('Could not connect to ' + server, 'LOG_SOCK')
            return None

        self.start()

    def handle_connect_event(self):
        self.is_connected = True

    def handle_connect(self):
        self.is_connected = True
        log('Connected to ' + str(server), 'LOG_SOCK')

    def handle_close(self):
        self.is_connected = False
        self.close()

    def handle_read(self):
        data = self.recv(8192)
        while self.lockedbuffer:
            sleep(0.01)

        self.inbuffer += data


    def handle_write(self):
        while self.is_writable:
            sent = self.send(self.buffer)
            sleep(1)

            self.buffer = self.buffer[sent:]
            if len(self.buffer) <= 0:
                self.is_writable = False
            sleep(0.01)

    def _send(self, what):
        self.buffer += what + '\r\n'
        self.is_writable = True

    def run(self):
        sleep(1)
        log('Log engine initating (hooking on to main)', 'LOG_CORE')

        main = None
        for t in enumerate():
            if t.getName() == 'MainThread':
                main = t

        log('Log engine attached to main', 'LOG_CORE')

        while (main and main.isAlive()) and (self.connected or self.is_connected):
            print 'WHAM', self.connected, self.is_connected
            sleep(1)

while 1:
    logDisp = logDispatcher()
    asyncore.loop(0.1)
    log('Logserver disconnected, trying to reconnect!', 'CORE')
    sleep(10)
于 2013-04-02T00:38:41.173 回答