用Python實現一個簡單的聊天程序

　　學習完網絡套接字之后，我產生了寫一個聊天程序的想法。思路很簡單，首先創建一個套接字，客戶端和服務器可以通過套接字通信；然后，為了使通信變為全雙工，接收信息和發送信息由兩個線程分別完成；最后，我還給客戶端加了一個圖形界面，使它看起來不是那么丑陋。

　　得益於Python的強大，所有這些實現起來都不是特別困難。比如Python中的很多數據結構，像列表，都是線程安全的，這樣就免去了處理一大堆線程鎖的煩惱；Python提供了方便的圖形界面接口，tkinter，使得像我這種從來沒有過圖形界面編程經驗的人，也可以在短時間內創建一個還說得過去的界面；同時，Python還擁有大量high-level Interface，相比起那些更貼近系統的低級接口，尤其是對於那些對底層操作系統不太熟的人來說，使用起來更加方便，並且在大部分情況下，這些高級接口都能滿足你的需求；Python中的垃圾回收機制，讓程序員從內存管理這項繁重的勞動中解脫出來，程序員再也不用像在C中那樣小心謹慎，釋放掉每一塊不用的內存；最后不得不提到Python簡潔靈活的語法，它使得代碼more readable and more close to humanity，很多語法即使你以前從來沒有用過，你也很有可能猜對它該怎麽用！

　　下面來介紹一下程序的基本功能。

　　客戶端提供了簡單的用戶登錄、登出、注冊、發送信息、選擇聯系人等功能。首先，輸入服務器的IP地址，點擊connect（或按回車鍵），在客戶端與服務器之間建立連接；然后，輸入用戶賬號（只支持6位數字），點擊log in（或按回車鍵），如果登錄成功，log in 按鈕會變為log out，再點擊即位登出操作。登錄成功之后，用戶可以在contacts一欄里邊選擇聯系人發送信息。

　　服務器主要用來處理用戶連接以及信息的轉發。服務器為每個用戶提供一個user-buffer，所有發給該用戶的信息都先存在這個緩沖區中，由服務器統一進行轉發；每一個登錄的用戶都享有一個獨立的線程，該線程時刻監聽用戶的輸入並把它存入合適的緩沖區中。

程序運行截圖

'''
TCP Client Version 2.2
2015.12.19
'''

import selectors
import queue
import re
import threading
from socket import *
from tkinter import *
from time import ctime

BUFSIZE = 1024

#lock = threading.Lock()    # Global Lock
que = queue.Queue(4096)

class GUI(object):
    '''
    This is the top module. It interacts with users. When a button is clicked
    or Return is pressed, a corresbonding event trigered. Connect is used to 
    estanblish a TCP connection with server while Log In tells server a user
    comes. We also provide an Add button, which allows user to add contacts.
    All the contacts will be displayed in a list box, and a double click on
    each contact will direct the user's message to a specific contact.
    Note that this module is based on other modules like Send and Recv, so it
    is not concerned with send and receive details. In fact it is wisdom to
    throw this burden to others. We just do what we can and do it perfectly.
    '''
    def __init__(self):
        self.root = Tk()
        self.root.title('Chat')

        self.frame_lft = Frame(self.root)
        self.frame_rgt = Frame(self.root)
        self.frame_lft.grid(row=0, column=0)
        self.frame_rgt.grid(row=0, column=1)

        self.entry_msg = Entry(self.frame_lft, width=46)    # entry, collect input
        self.entry_msg.grid(row=1, column=0)
        self.entry_msg.bind('<Return>', self.send_method)

        self.scrollbar_txt = Scrollbar(self.frame_lft, width=1)
        self.scrollbar_txt.grid(row=0, column=2, sticky=W+N+S)

        #self.button_qit = Button(self.root, text='Quit', command=self.root.quit)
        #self.button_qit.pack()

        self.text_msg = Text(self.frame_lft, state=DISABLED, width=49, wrap=WORD)    # text, display message
        self.text_msg.config(font='Fixedsys')
        self.text_msg.grid(row=0, column=0, columnspan=2, sticky=W+N+S+E)
        self.text_msg.config(yscrollcommand=self.scrollbar_txt.set)
        self.scrollbar_txt.config(command=self.text_msg.yview)
        
        self.entry_IP = Entry(self.frame_rgt, width=14)   # an IP address is supposed to input here
        self.entry_IP.grid(row=0, column=0, padx=5, pady=0)
        self.entry_IP.bind('<Return>', self.connect_method)

        self.button_cnt = Button(self.frame_rgt, text='connect', command=self.connect_method)    # click this button to connect
        self.button_cnt.config(height=1, width=8)
        self.button_cnt.grid(row=0, column=1, padx=0, pady=0)
        
        self.button_snd = Button(self.frame_lft, height=1, text='send', command=self.send_method)
        self.button_snd.config(width=8)
        self.button_snd.grid(row=1, column=1)

        ## New features in version 2.2 ##
        self.entry_log = Entry(self.frame_rgt, width=14)    # log in
        self.entry_log.grid(row=1, column=0, padx=5, pady=0)
        self.entry_log.bind('<Return>', self.login_method)  

        self.button_log = Button(self.frame_rgt, text='log in', command=self.login_method)  # first click means log in, second means log out
        self.button_log.config(width=8)
        self.button_log.grid(row=1, column=1, sticky=W)

        self.listbox_cat = Listbox(self.frame_rgt, height=17, width=24)
        self.listbox_cat.insert(END, '000000')
        self.listbox_cat.grid(row=3, column=0, columnspan=2, padx=5, sticky=N+S+E)
        self.listbox_cat.bind('<Double-1>', self.contact_method)

        self.scrollbar_cat = Scrollbar(self.frame_rgt, width=1)
        self.scrollbar_cat.grid(row=3, column=2, sticky=W+N+S)
        self.scrollbar_cat.config(command=self.listbox_cat.yview)
        self.listbox_cat.config(yscrollcommand=self.scrollbar_cat.set)

        self.entry_add = Entry(self.frame_rgt, width=14)
        self.entry_add.grid(row=4, column=0, padx=5, pady=0)
        self.entry_add.bind('<Return>', self.add_method)

        self.button_add = Button(self.frame_rgt, width=8, text='add')
        self.button_add.config(command=self.add_method)
        self.button_add.grid(row=4, column=1)

        self.label_cat = Label(self.frame_rgt, text='Contacts')
        self.label_cat.grid(row=2, column=0, sticky=W)

    def send_method(self, ev=None):
        data = self.entry_msg.get()
        self.entry_msg.delete(0, END)
        if not data:
            pass
        else:
            self.text_msg.config(state=NORMAL)
            self.text_msg.insert(END, data+'\n')
            self.text_msg.config(state=DISABLED)
            self.text_msg.see(END)
            self.send.send(data)

    def recv_method(self):
        try:
            data = que.get(block=False)
        except:
            pass
        else:
            self.text_msg.config(state=NORMAL)
            self.text_msg.insert(END, data+'\n')
            self.text_msg.config(state=DISABLED)
            self.text_msg.see(END)
            if re.match(r'^FROME', data):    # log in failed
                self.entry_log.config(state=NORMAL)
                self.button_log.config(text='log in', command=self.login_method)

        self.root.after(200, self.recv_method)    # runs every 200ms

    def connect_method(self, ev=None):
        IP = self.entry_IP.get()
        self.connt = Connt(IP)    # make an instance of Connt class
        self.connt()              # establish connection
        self.button_cnt.config(state=DISABLED)
        self.entry_IP.config(state=DISABLED)
        self.send = Send(self.connt.tcpCliSock)    # make an instance of Send class
        self.recv = Recv(self.connt.tcpCliSock)    # make an instance of Recv class
        self.recv_thread = threading.Thread(target=self.recv)  # a new thread, dealing with receiving
        self.recv_thread.daemon = True
        self.recv_thread.start()
        self.root.after(200, self.recv_method)

    def login_method(self, ev=None):
        ID = self.entry_log.get()
        if re.match(r'^[0-9]{6}$', ID) == None:
            pass
        else:
            self.send.send(ID)        # this action is infalliable
            self.button_log.config(text='log out', command=self.logout_method)
            self.entry_log.config(state=DISABLED)

    def logout_method(self, ev=None):
        self.send.send('::LOG OUT')
        self.button_log.config(text='log in', command=self.login_method)
        self.entry_log.config(state=NORMAL)

    def contact_method(self, ev=None):
        ID = self.listbox_cat.get(self.listbox_cat.curselection())
        self.send.send('::'+ID)
        self.text_msg.delete(1.0, END)     # delete all text
        self.text_msg.config(state=NORMAL)
        self.text_msg.insert(END, '[to '+ID+' '+ctime()+']\n')
        # if this contact action fails, server will send an error message.

    def add_method(self, ev=None):
        ID = self.entry_add.get()
        if re.match(r'[0-9]{6}', ID) == None:
            pass
        else:
            self.listbox_cat.insert(END, ID)
    
class Send(object):
    '''
    This module deals with every detail in sending bytes through a socket, 
    such as lock, encode, blocking, etc, and provide a send interface for
    GUI module.
    '''
    def __init__(self, fd):
        self.fd = fd
        self.sel = selectors.DefaultSelector()
        self.sel.register(self.fd, selectors.EVENT_WRITE)

    def send(self, data):
        self.sel.select()    # wait until the socket is ready to write
        #if lock.acquire():
        self.fd.send(data.encode('utf-8'))
            #lock.release()
        #else:
        #    pass

class Recv(object):
    '''
    This module deals with every detail in receiving bytes from a socket,
    and providing a friendly recv interface for GUI module.
    '''
    def __init__(self, fd):
        self.fd = fd
        self.sel = selectors.DefaultSelector()
        self.sel.register(self.fd, selectors.EVENT_READ)

    def recv(self):
        while True:
            self.sel.select()
            #if lock.acquire():
            byte = self.fd.recv(BUFSIZE)
            que.put(byte.decode('utf-8'))
            #    lock.release()
            #else:
            #    pass

    def __call__(self):
        self.recv()

class Connt(object):
    '''
    This module deals with establishing a TCP connection with host.
    '''
    def __init__(self, IP):
        self.HOST = IP
        self.PORT = 21567
        self.ADDR = (self.HOST, self.PORT)
        self.tcpCliSock = socket(AF_INET, SOCK_STREAM)

    def connect(self):
        self.tcpCliSock.connect(self.ADDR)
        
    def __call__(self):
        self.connect()

def main():
    gui = GUI()
    gui.root.mainloop()

if __name__ == '__main__':
    main()
    

'''
TCP Server Version 2.2
2015.12.19
'''
import selectors
import threading
import queue
import re
from socket import *
from time import ctime

BUFSIZE = 1024
HOST = input('HOST: ')
PORT = 21567
ADDR = (HOST, PORT)
tcpServSock = socket(AF_INET, SOCK_STREAM)
tcpServSock.bind(ADDR)
tcpServSock.listen(100)

user_list = []    # all registered users
user_buff = {}    # each user has a buffer
acti_user = []    # once a user logs in, he/she becomes active
acti_user_list = []

sel = selectors.DefaultSelector()
lock = threading.Lock()

def recv():
    global tcpServSock
    while True:
        lock.acquire(blocking=True)
        ret = sel.select(timeout=1)
        lock.release()
        for key, event in ret:    # some socket is readable
            if key.fileobj == tcpServSock:    # a new connection comes
                new_socket, new_addr = tcpServSock.accept()
                print('connected from %s [%s]' %(new_addr, ctime()))
                lock.acquire(blocking=True)
                sel.register(new_socket, selectors.EVENT_READ)
                lock.release()
            else:    # some one clicked Log In
                try:
                    ID = key.fileobj.recv(BUFSIZE).decode('utf-8')
                except:
                    print('%s disconnected' %(key.fileobj))
                    lock.acquire(blocking=True)
                    sel.unregister(key.fileobj)
                    lock.release()
                    continue
                if ID not in user_list:
                    user_list.append(ID)
                    acti_user_list.append(ID)
                    user_buff[ID] = queue.Queue(4096)
                    print('%s signed up [%s]' %(ID, ctime()))
                else:
                    if ID in acti_user_list:  # already logged in, deny
                        server_msg = 'FROME SERVER: already logged in'
                        key.fileobj.send(server_msg.encode('utf-8'))
                        continue
                    else:
                        acti_user_list.append(ID)
                    print('%s logged in [%s]' %(ID, ctime()))
                user = User(key.fileobj, ID)    # create an instance for logged in user
                acti_user.append(user)
                user()
                lock.acquire(blocking=True)
                sel.unregister(key.fileobj)
                lock.release()


def forward():
    while True:
        for eachUser in acti_user:
            if eachUser.zombie == True:    # this user has logged out
                lock.acquire(blocking=True)
                sel.register(eachUser.socket, selectors.EVENT_READ)  # after user's loging out,
                                                                     # recv_thread will take over the socket and listen to it
                lock.release()
                acti_user.remove(eachUser)
                del(eachUser)
                continue
            if eachUser.death == True:
                acti_user.remove(eachUser)
                del(eachUser)
                continue
            while user_buff[eachUser.ID].qsize():
                msg = user_buff[eachUser.ID].get()
                ## some ckecking is desired, for the socket may not be writable
                eachUser.socket.send(msg.encode('utf-8'))


class User(object):
    def __init__(self, socket, ID):
        self.socket = socket
        self.ID = ID
        self.zombie = False
        self.death = False
        self.contact = None
        self.sel = selectors.DefaultSelector()
        self.sel.register(self.socket, selectors.EVENT_READ)
    def recv(self):
        while True:
            self.sel.select()
            try:
                msg = self.socket.recv(BUFSIZE).decode('utf-8')
            except:
                print('%s disconnected' %(self.socket))
                acti_user_list.remove(self.ID)
                self.death = True
                return None
            if re.match(r'^::[0-9]{6}', msg):
                # user wants to contact with some one
                contact = msg[2:]
                if contact not in user_list:
                    server_msg = 'FROME SERVER: no such user'
                    self.socket.send(server_msg.encode('utf-8'))
                else:
                    self.contact = msg[2:]
            elif msg == '::LOG OUT':
                # user wants to log out
                acti_user_list.remove(self.ID)
                print('%s logged out [%s]' %(self.ID, ctime()))
                self.zombie = True
                print(self.zombie)
                return None
            else:
                if self.contact != None:
                    msg = '[' + 'frome ' + self.ID + ' ' + ctime() + ']\n' + msg
                    user_buff[self.contact].put(msg)
                else:
                    server_msg = 'FROME SERVER: choose a contact first'
                    self.socket.send(server_msg.encode('utf-8'))
    
    def __call__(self):
        self.recv_thread = threading.Thread(target=self.recv)
        self.recv_thread.daemon = True
        self.recv_thread.start()


def main():
    fd = open(r'.\user.txt', 'r+')
    for eachUser in fd:
        user_list.append(eachUser[0:6])
        user_buff[eachUser[0:6]] = queue.Queue(4096)
    print(user_list)
    
    sel.register(tcpServSock, selectors.EVENT_READ)

    recv_thread = threading.Thread(target=recv)
    recv_thread.daemon = True
    recv_thread.start()

    forward_thread = threading.Thread(target=forward)
    forward_thread.daemon = True
    forward_thread.start()

    while True:
        pass    # infinate loop

if __name__ == '__main__':
    main()