Estoy tratando de escribir un programa de mensajería instantánea, la interfaz de usuario básica está casi terminada y estoy investigando la parte de recepción de mensajes. Tengo una clase de interfaz de usuario y una clase de rosca Receive_Socket. Cada vez que el socket de la clase Received_Socket recibe un mensaje, hace un gobject.idle_add () para llamar a un método de IU para mostrar el mensaje en una ventana de chat. Después de la línea gobject.idle.add (), tengo un ciclo while que se repite hasta que el mensaje se muestra en la ventana de chat (quiero que se muestre antes de recibir otro mensaje porque leí gobject.idle_add () no garantiza la orden de ejecución y, por supuesto, quiero que los mensajes se muestren en orden :))

Traté de resumir mi código:

Clase de UI:

Class UI:
##### somewhere in the init #####
    self.message_status = 0
def chat_window(self, contact, message=0):
    Check if a chat window is opened for the contact, if not it opens one.
    => In reality this check if a gtk.Window containing a gtk.Notebook is opened, 
    => if not it opens one
    => Then it creates a page for the contact in the notebook, containing a 
    => gtk.Textview which displays messages
    if message:
        self.message_display(contact, message)
def message_display(self,a,b):
    => Display the message in the message in the contact's textview
    self.message_status = 1

Clase Threadded Receive_Socket:

Class Receive_Socket(threading.thread):
    message = sock.recv(1024)
    => the sender name is written in the message 
    if message:
        gobject.idle_add(myui.chat_window,sender, message)
        while not myui.message_status:
            time.sleep(0.1)
        myui.message_status = 0

Código principal:

if __name__ == "__main__":
    myui = UI()
    reception = Receive_Socket()
    reception.start()
    gtk.main()

Mis preguntas :

1) ¿Este tipo de código parece eficiente? ¿Es (tener una clase receptora enhebrada junto con mi clase UI) la mejor manera de proceder?

2) En el momento en que se muestra el mensaje, el socket puede haber recibido 2 o más mensajes, por lo que cuando lo hace message = sock.recv (1024) nuevamente, se concatenarán múltiples mensajes en el mensaje variable. Pensé en incluir la longitud del mensaje en cada mensaje, por lo que si hay más de 1 mensaje en los 1024 bytes, tomará el mensaje y colocará el resto en una variable message_buffer y antes de hacer un sock.recv (1024) nuevamente verificaría si la variable message_buffer contiene cualquier cosa y si es así, coloque message_buffer en la variable de mensaje en lugar de sock.recv (1024). ¿Hay una solución más fácil / mejor para hacer esto?

Gracias por adelantado,

Nolhian