from core import selectors_client


if __name__==‘__main__‘:
    client=selectors_client.Selecotors_client(‘localhost‘,5555)
    client.run()
    

from core import selectors_server


if __name__==‘__main__‘:
    server=selectors_server.Selectors_server(‘localhost‘,5555)
    server.run()

import os
import sys
import platform
BASE_DIR  = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)

server_path =  (BASE_DIR+"\db"+"\server")
client_path = (BASE_DIR+"\db" + "\client" )
print(server_path)
print(client_path)

import socket,os,json,random
from conf import settings


class Selecotors_client(object):
    def __init__(self,ip,port):
        self.ip=ip
        self.port=port
        self.client = socket.socket()
    
    def put(self):
   
        self.file_path=‘%s\%s‘%(settings.client_path,self.file_name)
        if os.path.isfile(self.file_path):
            self.file_size=os.stat(self.file_path).st_size
            msg_dic={‘client‘:{‘action‘:‘put‘,
                               ‘file_name‘:self.file_name,
                               ‘file_size‘:self.file_size}}
            data=json.dumps(msg_dic)
            self.client.send(data.encode())
            print(self.client.recv(1024))
            with open(self.file_path,‘rb‘) as f:
                for line in f:
                    self.client.send(line)
            print(self.client.recv(1024).decode())
        else:
            print("文件不存在")



    def get(self):
        self.file_path = ‘%s\%s‘ % (settings.client_path, self.file_name)
        new=random.randint(1,100)
        msg_dic={‘client‘:{
            ‘action‘:‘get‘,
            ‘file_name‘:self.file_name,
            ‘file_size‘:0
        }}
        data=json.dumps(msg_dic)
        self.client.send(data.encode())
        file_size=self.client.recv(1024)
        file_size=int(file_size.decode())
        print(file_size)
        self.client.send("1".encode())
        recv_size=0
        with open(self.file_path+‘.%s‘%new,‘wb‘)as f:
            while recv_size<file_size:
                size=file_size-recv_size
                if size>1024:
                    data=self.client.recv(1024)
                else:
                    data=self.client.recv(size)
                f.write(data)
                recv_size+=len(data)
                
    def run(self):
        
        self.client.connect((self.ip,self.port))
        while True:
            try:
                self.choice_msg=input(">:").strip()
                self.action=self.choice_msg.split()[0]
                if len(self.choice_msg)==0:
                    continue
                elif len(self.choice_msg)==1:
                    if self.choice_msg[0]==‘exit‘:
                        break
                else:
                    self.file_name=self.choice_msg.split()[1]
                    if self.action==‘put‘:
                        self.put()
                    elif self.action==‘get‘:
                        self.get()
            except IndexError as e:
                print(e)

    

import selectors,os,socket,json
from conf import settings
import errno,random
sel = selectors.DefaultSelector()
class Selectors_server(object):
    ‘‘‘服务器类‘‘‘
    def __init__(self,ip,port):
        self.sock=socket.socket()
        self.ip=ip
        self.port=port


    def get(self,conn,mask):

            if os.path.isfile(self.file_path):
                while True:
                    try:
                        file_size = os.stat(self.file_path).st_size
                        conn.send(str(file_size).encode())
                        data=conn.recv(1024)
                        print(data.decode())
                        with open(self.file_path, ‘rb‘)as f:
                            for line in f:
                                conn.send(line)
                            break
                    except BlockingIOError as e:
                        pass

    def put(self,conn,mask):
        conn.send(‘1‘.encode())
        new=random.randint(1,100)
        file_path=‘%s\%s‘%(settings.server_path,self.file_name)
        recverd_size=0
        with open(file_path+‘.%s‘%new,‘wb‘) as f:
            while recverd_size <self.file_size:
                try:
                    size=self.file_size-recverd_size
                    if size>1024:
                        data=conn.recv(1024)
                    else:
                        data=conn.recv(size)
                    recverd_size+=len(data)
                    f.write(data)
            
                except BlockingIOError as e:
                    pass
                # else:
                #     time.sleep(0.00001)
            conn.send(‘ok‘.encode())


    def read(self,conn,mask):
        try:
            self.data = conn.recv(1024)
            if self.data:
                # print(self.data)
                self.data_receive = json.loads(self.data.decode())
                self.action = self.data_receive[‘client‘][‘action‘]
                self.file_name = self.data_receive[‘client‘][‘file_name‘]
                self.file_size = self.data_receive[‘client‘][‘file_size‘]
                self.file_path = "%s\%s" % (settings.server_path, self.file_name)
                if self.action == ‘get‘:
                    self.get(conn,mask)

                elif self.action == ‘put‘:
                    self.put(conn,mask)
            else:
                print(‘closing‘, conn)
                sel.unregister(conn)
                conn.close()
        except ConnectionResetError as e:
            print(‘closing‘,conn,e)
            sel.unregister(conn)
            conn.close()

    def accept(self,sock,mask):
        conn,addr=sock.accept()

        conn.setblocking(False)
        sel.register(conn,selectors.EVENT_READ,self.read)
    def register(self,sock):

        sel.register(sock, selectors.EVENT_READ, self.accept)
        while True:
            events = sel.select()  # 默认是阻塞的，有活动连接就返回获得的连接列表
            for key, mask in events:
                callback = key.data  # accept
                callback(key.fileobj, mask)

    def run(self):
        self.sock = socket.socket()
        self.sock.bind((self.ip, self.port))
        self.sock.listen(100)
        self.sock.setblocking(False)
        self.register(self.sock)