python 开发一个支持多用户在线的FTP

Server.py 服务端
 
#Echo server program
import
socket
 
HOST=‘’  #空代表0.0.0.0
PORT= 50007  #监听端口
s= socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 生成socket tcp通信实例，
s.bind((HOST,PORT)) #绑定ip和端口，注意bind只接受一个参数，(HOST,PORT) 做成一个元祖传进去
s.listen(1)  #开始监听，里面的数字是代表服务端在拒绝新连接之前可以最多挂起多少连接，不过实验过了没啥用，所以写个1就好了
 
conn,addr= s.accept()  #接受连接，并返回两个变量，conn代表每个新连接进入后服务端都会为其生成一个新实例，后面可以用这个实例进行发送和接收，addr是连接进来的客户端的地址，accept()方法在有新连接进入时就会返回conn,addr这两个变量，但如果没有连接时，此方法就会阻塞直至有新连接过来。
 
print'Connected by', addr
 
while  True:
    data = conn.recv(1024) #接收1024字节数据
    if not data: break     #如果收不到客户端数据了（代表客户端断开了），就断开
    conn.sendall(data.upper())    #将收到的数据全变成大写再发给客户端
     
conn.close() #关闭连接

Client.py 客户端
 
import
socket
 
HOST= '192.168.3.1' # 远程socket服务器ip
PORT= 50007         # 远程socket服务器端口
 
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) #实例化socket
s.connect((HOST,PORT)) #连接socket服务器
 
while True:
    msg = raw_input("Your msg::").strip() #让用户输入消息，去除回车和空格
    if len(msg) == 0:continue 
     
    s.sendall(msg) #向服务器发送消息
    data= s.recv(1024)       #接收服务器的消息
     
    print 'Received:', data
s.close()

if not data: break

#Echo server program
import socket
 
HOST=''  #空代表0.0.0.0
PORT= 50007  #监听端口
s= socket.socket(socket.AF_INET,socket.SOCK_STREAM) 
s.bind((HOST,PORT)) 
s.listen(1)
 
 
while True:
    conn,addr= s.accept()  
 
    print'Connected by', addr
 
    while  True:
        data = conn.recv(1024) #接收1024字节数据
        if not data: break     #如果收不到客户端数据了（代表客户端断开了），就断开
        conn.sendall(data.upper())    #将收到的数据全变成大写再发给客户端
 
    conn.close() #关闭此客户端的连接实例

conn,addr= s.accept()

import SocketServer
 
class MyTCPHandler(SocketServer.BaseRequestHandler):
    #继承BaseRequestHandler基类，然后必须重写handle方法，并且在handle方法里实现与客户端的所有交互
     
    def handle(self):
 
        while  True:
            data = self.request.recv(1024) #接收1024字节数据
            if not data: break     
            self.request.sendall(data.upper())
 
if __name__ == "__main__":
    HOST, PORT = "localhost", 50007
 
    # 把刚才写的类当作一个参数传给ThreadingTCPServer这个类，下面的代码就创建了一个多线程socket server
    server = SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
 
    # 启动这个server,这个server会一直运行，除非按ctrl-C停止
    server.serve_forever()

#_*_coding:utf-8_*_
__author__ = 'jieli'
 
 
import socket
import os
class FtpClient(object):
    def __init__(self,host,port ):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.connect((host, port)) #连接服务器
    def start(self): #实例化客户端类后，需要调用此方法启动客户端
        self.interactive()  #跟用户的交互都在这个方法里
         
         
    def interactive(self):
        while True:
            user_input = raw_input(">>:").strip()
            if len(user_input) == 0:continue
            user_input = user_input.split() #用户输入的指令进行拆分，第一个参数是指要进行什么动作，比如get remote_filename
 
            if hasattr(self,user_input[0]):#判断类中是否有get或其它输入的方法
                func = getattr(self,user_input[0]) #通过字符串获取类中对应方法的内存对象
                func(user_input) #调用此内存对象
 
            else: 
                print "\033[31;1mWrong cmd usage\033[0m"
 
    def get(self,msg): #从服务器端下载文件
        print '--get func---',msg
        if len(msg) ==2 :
            file_name = msg[1]
            instruction = "FileTransfer|get|%s" % file_name #告诉服务器端要下载什么文件
            self.sock.send(instruction)
            feedback = self.sock.recv(100) #等待服务器端的消息确认
            print '-->',feedback
            if feedback.startswith("FileTransfer|get|ready"): #代表服务器上文件存在，并且服务器已经准备好了发送此文件到客户端
                file_size = int(feedback.split("|")[-1]) # 服务器端发回来的确认消息中，最后面一个值是文件大小，必须知道文件大小才知道一共要收多少内容
                self.sock.send("FileTransfer|get|recv_ready") #告诉服务器端已经准备好了接收
                recv_size = 0 # 因为文件可能会比较大，一次收不完，所以要循环收，每收到一次，就计个数
                f = file('client_recv/%s' % os.path.basename(file_name),'wb') #在本地创建一个新文件来存这个要下载的文件内容
                print '--->',file_name
                while not file_size == recv_size:#只要文件总大小和已收到的大小不想等，就代表还没收完
                    if file_size - recv_size>1024:#文件总大下减已收到的大小等于还剩下没收到的大小，如果这个数大于1024，代表一次肯定收不完，那就还得多循环几次
                        data = self.sock.recv(1024) #这次收1024字节，但实际上收到的可能比1024小，所以需要以实际收到的数为准
                        recv_size += len(data) # 已收到的大小加上这一次循环收到的实际大小
                    else:# 如果最后剩下的少于1024，那就一次性把剩下的都收过来
                        data = self.sock.recv(file_size - recv_size) 
                        #recv_size = file_size #不能这么写，因为这一次依然不一定能一次性收完，因为实际收到的数据可能比你规定的数据要少， 所以需要按下面这行的方式写
                        recv_size += (file_size - recv_size) 
                    f.write(data) #收到的内容写入文件
                    print file_size,recv_size
                else:
                    print '---recv file:%s---' % file_name
                    f.close() 
            else:
                print feedback
        else:
            print "\033[31;1mWrong cmd usage\033[0m"
 
    def put(self): 
        pass
    def ls(self):
        pass
    def cd(self):
        pass
    def delete(self):
        pass
 
 
if __name__ == "__main__":
    f = FtpClient('localhost',9002)
    f.start()

#_*_coding:utf-8_*_
 
import SocketServer
 
import os
class MyTCPHandler(SocketServer.BaseRequestHandler):
    def handle(self):
        while True:
            instruction = self.request.recv(1024).strip() #接收客户端命令
            if not instruction :break
            instruction = instruction.split('|') #将客户端发过来的消息按|来拆分，消息类似这种格式 “FileTransfer|get|file_name”
            if hasattr(self,instruction[0]): #判断类中是否有这个方法
                func = getattr(self, instruction[0]) #获取这个方法的内存对象
                func(instruction) #调用此方法
    def FileTransfer(self,msg): #负责文件的发送和接收
        print '---filetransfer---',msg
        if msg[1] == 'get': #如果客户端发来的指令是get,那就是下载文件
            print "client wants to download file:", msg[2]
            if os.path.isfile(msg[2]): #判断客户端发的文件名是否存在并是个文件
                file_size = os.path.getsize(msg[2]) # 获取文件大小
                res = "ready|%s" % file_size # 把文件大小告诉客户端
            else:
                res = "file doesn't exist" #文件也有可能不存在
            send_confirmation = "FileTransfer|get|%s" %res 
            self.request.send(send_confirmation) # 发送确认消息给客户端
            feedback = self.request.recv(100) #等待客户端确认， 如果这时不等客户端确认就立刻给客户端发文件内容，因为为了减少IO操作，socket发送和接收是有缓冲区的，缓冲区满了才会发送，那上一条消息很有可能会和文件内容的一部分被合并成一条消息发给客户端，这就行成了粘包，所以这里等待客户端的一个确认消息，就把两次发送分开了，不会再有粘包
            if feedback == 'FileTransfer|get|recv_ready': #如果客户端说准备好接收了
                f = file(msg[2],'rb')
                send_size = 0 #发送的逻辑跟客户端循环接收的逻辑是一样的
                while not file_size == send_size :
                    if file_size - send_size > 1024:
                        data = f.read(1024)
                        send_size += 1024
                    else: #left data less than 1024
                        data = f.read(file_size - send_size)
                        send_size +=(file_size - send_size)
                    self.request.send(data)
                    print file_size,send_size
                else:
                    print '---send file:%s done----' % msg[2]
                    f.close()
        elif msg[1] == 'put':
            pass
 
 
if __name__ == '__main__':
 
    HOST, PORT = "", 9002
 
    server = SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
 
    server.serve_forever()