示例#1
0
    def auth(self, instructions):
        '''
        用户认证方法,默认用户为guest用户,认证成功后切换用户
        :param instructions: 客户端指令
        :return: 无
        '''
        import json
        import os
        res = json.loads(instructions[1])
        user = self.__users.get_user(res['username']) # 通过用户名获取用户信息

        # 判断用户是否存在
        if user:
            # 判断密码是否正确
            print(user.get_password())
            if user.get_password() == res['password']:
                # 如果验证当前用户等于认证成功的用户
                self.__current_user = user
                # 当前目录等于用户的家目录
                self.__current_path = os.path.abspath(os.path.join(conf.HOME_PATH,self.__current_user.get_username())).replace('\\', '/')
                # 告诉客户端用户成功
                self.request.sendall(mylib.s2b('200'))
                self.__loger.info('%s from [%s]' %(self.__code_list['200'], self.client_address))
            else:
                self.request.sendall(mylib.s2b('201'))
                self.__loger.error('%s from [%s]' %(self.__code_list['201'], self.client_address))
        else:
            self.request.sendall(mylib.s2b('201'))
            self.__loger.error('%s from [%s]' %(self.__code_list['201'], self.client_address))
示例#2
0
    def cd(self, client_cmd):
        '''
        cd方法,用于服务端目录切换
        :param client_cmd: 用户命令
        :return: 无
        '''
        path = client_cmd[1] # 获取cd的目录
        import os
        if path == '.': # 如果目录是.说明是当前目录,啥也不干
            pass
        elif path == '..':
            # 如果是.., 说明是父目录
            # 判断当前目录是不是已经是家目录,也就是根目录,若果是啥也不干,如果不是,进入到上一级目录
            if self.__current_path == self.__current_user['home']:
                self.request.sendall(mylib.s2b('ok'))
            else:
                self.__current_path = os.path.split(self.__current_path[0:len(self.__current_path)-1])[0] + '/'
                print(os.path.split(self.__current_path[0:len(self.__current_path)-1]))

                self.request.sendall(mylib.s2b('ok'))
        elif path == '/' or path == '~': # 如果是/或者~ 表示进入到家目录,当前目录等于用户的家目录
            self.__current_path = self.__current_user['home']
            self.request.sendall(mylib.s2b('ok'))
        else:
            # 其他情况,先判断目录是否合法,合法当前目录等于拼接后的目录,否则通知客户端目录不存在
            if os.path.isdir(self.__current_path + path):
                self.__current_path += path + '/'
                self.request.sendall(mylib.s2b('ok'))
            else:
                self.request.sendall(mylib.s2b('目录%s不存在' %path))
示例#3
0
    def cd(self, client_cmd):
        '''
        cd方法,用于服务端目录切换
        :param client_cmd: 用户命令
        :return: 无
        '''
        path = client_cmd[1]  # 获取cd的目录
        import os
        if path == '.':  # 如果目录是.说明是当前目录,啥也不干
            pass
        elif path == '..':
            # 如果是.., 说明是父目录
            # 判断当前目录是不是已经是家目录,也就是根目录,若果是啥也不干,如果不是,进入到上一级目录
            if self.__current_path == self.__current_user['home']:
                self.request.sendall(mylib.s2b('ok'))
            else:
                self.__current_path = os.path.split(
                    self.__current_path[0:len(self.__current_path) -
                                        1])[0] + '/'
                print(os.path.split(
                    self.__current_path[0:len(self.__current_path) - 1]))

                self.request.sendall(mylib.s2b('ok'))
        elif path == '/' or path == '~':  # 如果是/或者~ 表示进入到家目录,当前目录等于用户的家目录
            self.__current_path = self.__current_user['home']
            self.request.sendall(mylib.s2b('ok'))
        else:
            # 其他情况,先判断目录是否合法,合法当前目录等于拼接后的目录,否则通知客户端目录不存在
            if os.path.isdir(self.__current_path + path):
                self.__current_path += path + '/'
                self.request.sendall(mylib.s2b('ok'))
            else:
                self.request.sendall(mylib.s2b('目录%s不存在' % path))
示例#4
0
    def put(self, instructions):
        '''
        put方法
        :param instructions: 客户端指令
        :return: 无
        '''
        import os
        import json

        res = json.loads(instructions[1])
        file_name = os.path.join(self.__current_path, res['filename']) # 获取上传的文件名
        md5 = res['md5'] # 获取上传的文件的md5
        tmp_file_name = os.path.join(self.__current_path, '%s.ftp' %res['filename']) # 定义临时文件
        if os.path.isfile(tmp_file_name): # 判断临时文件,如果存在说明没传完,将续传
            tmp_file_size = os.path.getsize(tmp_file_name) # 获取已经上传的大小
        else:
            tmp_file_size = 0
        self.request.send(mylib.s2b(r'ready|{"recv_size":%s}' %tmp_file_size)) # 通知客户端准备上传并返回已近上传的大小
        recv_size = tmp_file_size
        file_size = res['file_size']
        f = open(tmp_file_name, 'ab')
        self.__loger.info('Begin recv file  %s from client [%s]' %(file_name, self.client_address))
        while recv_size != file_size:
            # 只要已上传的大小不等于文件的大小就循环获取数据写入文件
            try:
                data = self.request.recv(conf.FILE_PER_SIZE)
                recv_size += len(data)
                f.write(data)
                mylib.process_bar(recv_size, file_size)
            except socket.error as e:
                print(self.__code_list['306'])
                f.close()
                break
            except IOError as e:
                print(self.__code_list['305'])
                f.close()
                break
        f.close()
        self.__loger.info('End recv file  %s from client [%s]' %(file_name, self.client_address))
        new_md5 = mylib.get_file_md5(tmp_file_name) # 获取上传后的md5值
        self.__loger.info('Begin validate md5 [%s]' %tmp_file_name)
        if new_md5 == md5: # 验证md5,成功则将临时文件名改为正式文件名
            import shutil
            shutil.move(tmp_file_name, file_name)
            self.request.sendall(mylib.s2b('308'))
            self.__loger.info('%s %s' %(self.__code_list['308'], tmp_file_name))
        else:
            os.remove(tmp_file_name)
            self.request.sendall(mylib.s2b('309'))
            self.__loger.info('%s %s' %(self.__code_list['309'], tmp_file_name))
        self.__loger.info('End validate md5 [%s]' %tmp_file_name)
示例#5
0
 def checkspacesize(self, client_cmd):
     '''
     检查剩余空间是否可以上传文件方法
     :param client_cmd: 用户命令
     :return: 无
     '''
     file_size = int(client_cmd[1]) # 获取文件大小
     # 获取剩余空间大小
     free_size = int(self.__current_user['max_size'] - mylib.get_dir_size_for_linux(self.__current_path))
     # 判断剩余空间是否够,如果够告诉客户端can,如果不够告诉客户端not
     if file_size < free_size:
         self.request.sendall(mylib.s2b('can'))
     else:
         self.request.sendall(mylib.s2b('not'))
示例#6
0
 def checkspacesize(self, client_cmd):
     '''
     检查剩余空间是否可以上传文件方法
     :param client_cmd: 用户命令
     :return: 无
     '''
     file_size = int(client_cmd[1]) # 获取文件大小
     # 获取剩余空间大小
     free_size = int(self.__current_user['max_size'] - mylib.get_dir_size_for_linux(self.__current_path))
     # 判断剩余空间是否够,如果够告诉客户端can,如果不够告诉客户端not
     if file_size < free_size:
         self.request.sendall(mylib.s2b('can'))
     else:
         self.request.sendall(mylib.s2b('not'))
示例#7
0
 def put(self, client_cmd):
     '''
     上传文件方法
     :param client_cmd: 客户端命令
     :return: 无
     '''
     import os
     import shutil
     # 拼接要上传的文件名
     print(client_cmd)
     filename = self.__current_path + os.path.split(client_cmd[1])[1]
     file_size = int(client_cmd[2])
     #filename = os.path.split(filename)[1]
     md5 = client_cmd[3] # 从客户端命令中获取文件的md5值,稍后用于比对
     # 定义临时文件
     tmp_filename = '%s.ftp' %filename
     # 判断临时文件是否存在,如果存在获取临时文件的大小,传给客户端,端点续传
     if os.path.isfile(tmp_filename):
         tmp_file_size = os.path.getsize(tmp_filename)
     else:
         tmp_file_size = 0
     self.request.sendall(mylib.s2b('put|ready|%s' %tmp_file_size))
     Confirm = mylib.b2s(self.request.recv(100))
     recv_size = tmp_file_size
     if Confirm.startswith('put|ready'):
         # 判断是否是续传,如果是续传文件以追加的形式打开,如果不是则以写的方式打开
         if recv_size == 0:
             f = open('%s.ftp' %filename, 'wb')
         else:
             f = open('%s.ftp' %filename, 'ab')
         # 接收文件知道传输结束
         while file_size != recv_size:
             data = self.request.recv(conf.FILE_PER_SIZE)
             # 如果传输中断,退出整个方法,这里用到了一个技巧,return一个None,强制结束
             if len(data) == 0:
                 f.close()
                 return None
             recv_size += len(data)
             f.write(data)
         f.close()
         # 对比文件md5值如果相同降临时文件重命名,否则删除
         new_md5 = mylib.get_file_md5('%s.ftp' %filename)
         if md5 == new_md5:
             shutil.move('%s.ftp' %filename, filename)
             self.request.sendall(mylib.s2b('上传成功'))
         else:
             os.remove(tmp_filename)
             self.request.sendall(mylib.s2b('上传失败'))
示例#8
0
 def put(self, client_cmd):
     '''
     上传文件方法
     :param client_cmd: 客户端命令
     :return: 无
     '''
     import os
     import shutil
     # 拼接要上传的文件名
     print(client_cmd)
     filename = self.__current_path + os.path.split(client_cmd[1])[1]
     file_size = int(client_cmd[2])
     #filename = os.path.split(filename)[1]
     md5 = client_cmd[3]  # 从客户端命令中获取文件的md5值,稍后用于比对
     # 定义临时文件
     tmp_filename = '%s.ftp' % filename
     # 判断临时文件是否存在,如果存在获取临时文件的大小,传给客户端,端点续传
     if os.path.isfile(tmp_filename):
         tmp_file_size = os.path.getsize(tmp_filename)
     else:
         tmp_file_size = 0
     self.request.sendall(mylib.s2b('put|ready|%s' % tmp_file_size))
     Confirm = mylib.b2s(self.request.recv(100))
     recv_size = tmp_file_size
     if Confirm.startswith('put|ready'):
         # 判断是否是续传,如果是续传文件以追加的形式打开,如果不是则以写的方式打开
         if recv_size == 0:
             f = open('%s.ftp' % filename, 'wb')
         else:
             f = open('%s.ftp' % filename, 'ab')
         # 接收文件知道传输结束
         while file_size != recv_size:
             data = self.request.recv(conf.FILE_PER_SIZE)
             # 如果传输中断,退出整个方法,这里用到了一个技巧,return一个None,强制结束
             if len(data) == 0:
                 f.close()
                 return None
             recv_size += len(data)
             f.write(data)
         f.close()
         # 对比文件md5值如果相同降临时文件重命名,否则删除
         new_md5 = mylib.get_file_md5('%s.ftp' % filename)
         if md5 == new_md5:
             shutil.move('%s.ftp' % filename, filename)
             self.request.sendall(mylib.s2b('上传成功'))
         else:
             os.remove(tmp_filename)
             self.request.sendall(mylib.s2b('上传失败'))
示例#9
0
 def rm(self, instructions):
     '''
     删除文件方法
     :param cliend_cmd: 用户命令
     :return: 无
     '''
     import json
     import os
     import shutil
     res = json.loads(instructions[1])
     filename = os.path.join(self.__current_path, res['path'])
     if self.__check_path(filename):
         if os.path.isdir(filename):# 如果是目录递归删除目录
             shutil.rmtree(filename)
             response_code = '500'
         elif os.path.isfile(filename): # 如果是文件,只删除文件
             os.remove(filename)
             response_code = '500'
         self.__loger.info('%s to rm %s' %(self.__code_list['500'], filename))
     else:
         # 其他情况说明文件或目录不存在
         #self.request.sendall(mylib.s2b('310'))
         response_code = '310'
         self.__loger.info('%s to rm %s' %(self.__code_list['310'], filename))
     self.request.send(mylib.s2b('{"code":"%s"}' %response_code)) # 返回错误码
示例#10
0
 def pwd(self, client_cmd):
     '''
     获取当前目录方法
     :param client_cmd: 用户命令
     :return:
     '''
     # 将当前目录告诉客户端
     self.request.sendall(mylib.s2b(self.__current_path))
示例#11
0
 def pwd(self, client_cmd):
     '''
     获取当前目录方法
     :param client_cmd: 用户命令
     :return:
     '''
     # 将当前目录告诉客户端
     self.request.sendall(mylib.s2b(self.__current_path))
示例#12
0
 def get(self, user_input):
     '''
     客户端下载方法
     :param user_input: 用户输入的指令
     :return: 无
     '''
     import os
     if len(user_input) == 2:  # 如果是get xxx,则表示下载到当前目录
         dst_path = '.'
     elif len(user_input) == 3:  # 如果是 get xxx xxx,则表示要下载到其他目录
         dst_path = user_input[2]
     else:
         print(self.__code_list['401'])
         return None
     if os.path.isdir(dst_path):  # 判断目标文件是否存在
         filename = user_input[1]  # 获取下载的文件名
         tmp_filename = os.path.join(self.__tmp_path, '%s.ftp' %
                                     os.path.split(filename)[1])  # 定义临时文件
         if os.path.isfile(tmp_filename):  # 判断临时文件是否存在(也就是是否需要续传)
             tmp_file_size = os.path.getsize(tmp_filename)  # 获取临时文件的大小
         else:
             tmp_file_size = 0
         self.__sk.send(
             mylib.s2b(r'get|{"filename":"%s", "sendsize": %s}' %
                       (filename, tmp_file_size)))  # 向服务端发送下载指令接文件名和已近下载的大小
         Confirm = mylib.b2s(self.__sk.recv(100)).split('|')  # 获取服务器反馈
         if Confirm[0] == 'ready':  # 如果是ready则准备下载文件
             file_size = json.loads(Confirm[1])['filesize']  # 获取文件大小
             md5 = json.loads(Confirm[1])['md5']  # 获取md5
             recv_size = tmp_file_size
             f = open(tmp_filename, 'ab')
             while file_size != recv_size:
                 # 只要已下载大小不等于文件大小则循环接受数据
                 try:
                     data = self.__sk.recv(conf.FILE_PER_SIZE)
                     recv_size += len(data)
                     f.write(data)
                     mylib.process_bar(recv_size, file_size)
                 except socket.error as e:
                     print(self.__code_list['306'])
                     f.close()
                     break
                 except IOError as e:
                     print(self.__code_list['305'])
             f.close()
             print('')
             print('Validating...')
             new_md5 = mylib.get_file_md5(tmp_filename)
             if new_md5 == md5:  # 验证md5,如果验证通过修改成正式文件名,如果没验证过去删除临时文件
                 import shutil
                 shutil.move(tmp_filename, os.path.join(dst_path, filename))
             else:
                 os.remove(tmp_filename)
         else:
             print(self.__code_list[Confirm[1]])
     else:
         print(self.__code_list['304'])
示例#13
0
 def put(self, user_input):
     '''
     客户端上传方法
     :param user_input: 指令
     :return: 无
     '''
     import json
     if len(user_input) == 2:
         file_name = user_input[1]
         if not os.path.isfile(file_name):
             print(self.__code_list['302'])
             return None
         self.__sk.sendall(mylib.s2b('checkspacesize'))
         res = json.loads(mylib.b2s(self.__sk.recv(100)))
         free_size = int(res['freesize']) * 1024 * 1024  # 获取剩余空间大小
         file_size = os.path.getsize(file_name)
         if free_size > file_size:  # 判断剩余空间是否够,够就下载,不够就直接返回
             md5 = mylib.get_file_md5(file_name)  # 获取上传文件的md5
             self.__sk.send(
                 mylib.s2b(
                     r'put|{"filename":"%s", "file_size":%s, "md5":"%s"}' %
                     (os.path.split(file_name)[1], file_size,
                      md5)))  # 发送上传指令,并通知服务端文件名,文件大小和md5
             res = mylib.b2s(self.__sk.recv(200)).split('|')  # 获取服务端确认信息
             if res[0] == 'ready':
                 send_size = json.loads(res[1])['recv_size']  # 获取已经上传的大小
                 f = open(file_name, 'rb')
                 f.seek(send_size)  # 设定文件的其实位置为已上传的大小
                 while file_size != send_size:
                     # 只要文件大小不等于上传的大小则循环读文件并上传数据
                     if file_size - send_size > conf.FILE_PER_SIZE:
                         data = f.read(conf.FILE_PER_SIZE)
                         send_size += conf.FILE_PER_SIZE
                     else:
                         data = f.read(file_size - send_size)
                         send_size += (file_size - send_size)
                     self.__sk.send(data)
                     mylib.process_bar(send_size, file_size)
                 print(mylib.b2s(self.__sk.recv(200)))
                 print("")
         else:
             print(self.__code_list['307'])
     else:
         print(self.__code_list['401'])
示例#14
0
 def move(self, cliend_cmd):
     '''
     移动文件或重命名文件方法
     :param cliend_cmd: 用户命令
     :return:
     '''
     import shutil
     import os
     # 获取旧的文件名
     filename = self.__current_path + cliend_cmd[1]
     # 获取新的文件名
     new_filename = self.__current_path + cliend_cmd[2]
     if filename.startswith('~') or filename.startswith('/') or filename.startswith('..') or new_filename.startswith('~') or new_filename.startswith('/') or new_filename.startswith('..'):
         self.request.sendall(mylib.s2b('目录不合法'))
     elif os.path.isfile(filename) or os.path.isdir(filename): # 旧的文件或目录存在执行move
         shutil.move(filename, new_filename)
         self.request.sendall(mylib.s2b('ok'))
     else:
         # 否则告诉客户端目录或文件不存在
         self.request.sendall(mylib.s2b('目录或文件%s不存在' %filename))
示例#15
0
 def move(self, cliend_cmd):
     '''
     移动文件或重命名文件方法
     :param cliend_cmd: 用户命令
     :return:
     '''
     import shutil
     import os
     # 获取旧的文件名
     filename = self.__current_path + cliend_cmd[1]
     # 获取新的文件名
     new_filename = self.__current_path + cliend_cmd[2]
     if filename.startswith('~') or filename.startswith('/') or filename.startswith('..') or new_filename.startswith('~') or new_filename.startswith('/') or new_filename.startswith('..'):
         self.request.sendall(mylib.s2b('目录不合法'))
     elif os.path.isfile(filename) or os.path.isdir(filename): # 旧的文件或目录存在执行move
         shutil.move(filename, new_filename)
         self.request.sendall(mylib.s2b('ok'))
     else:
         # 否则告诉客户端目录或文件不存在
         self.request.sendall(mylib.s2b('目录或文件%s不存在' %filename))
示例#16
0
 def get(self, user_input):
     '''
     客户端下载方法
     :param user_input: 用户输入的指令
     :return: 无
     '''
     import os
     if len(user_input) == 2: # 如果是get xxx,则表示下载到当前目录
         dst_path = '.'
     elif len(user_input) == 3: # 如果是 get xxx xxx,则表示要下载到其他目录
         dst_path = user_input[2]
     else:
         print(self.__code_list['401'])
         return None
     if os.path.isdir(dst_path): # 判断目标文件是否存在
         filename = user_input[1] # 获取下载的文件名
         tmp_filename = os.path.join(self.__tmp_path,'%s.ftp' %os.path.split(filename)[1]) # 定义临时文件
         if os.path.isfile(tmp_filename): # 判断临时文件是否存在(也就是是否需要续传)
             tmp_file_size = os.path.getsize(tmp_filename) # 获取临时文件的大小
         else:
             tmp_file_size = 0
         self.__sk.send(mylib.s2b(r'get|{"filename":"%s", "sendsize": %s}' %(filename, tmp_file_size))) # 向服务端发送下载指令接文件名和已近下载的大小
         Confirm = mylib.b2s(self.__sk.recv(100)).split('|') # 获取服务器反馈
         if Confirm[0] == 'ready': # 如果是ready则准备下载文件
             file_size = json.loads(Confirm[1])['filesize'] # 获取文件大小
             md5 = json.loads(Confirm[1])['md5'] # 获取md5
             recv_size = tmp_file_size
             f = open(tmp_filename, 'ab')
             while file_size != recv_size:
                 # 只要已下载大小不等于文件大小则循环接受数据
                 try:
                     data = self.__sk.recv(conf.FILE_PER_SIZE)
                     recv_size += len(data)
                     f.write(data)
                     mylib.process_bar(recv_size, file_size)
                 except socket.error as e:
                     print(self.__code_list['306'])
                     f.close()
                     break
                 except IOError as e:
                     print(self.__code_list['305'])
             f.close()
             print('')
             print('Validating...')
             new_md5 = mylib.get_file_md5(tmp_filename)
             if new_md5 == md5: # 验证md5,如果验证通过修改成正式文件名,如果没验证过去删除临时文件
                 import shutil
                 shutil.move(tmp_filename, os.path.join(dst_path, filename))
             else:
                 os.remove(tmp_filename)
         else:
             print(self.__code_list[Confirm[1]])
     else:
         print(self.__code_list['304'])
示例#17
0
 def rm(self, user_input):
     '''
     删除文件方法
     :param user_input: 用户命令
     :return: 无
     '''
     if len(user_input) == 2:
         self.__sk.send(mylib.s2b('rm|{"path" : "%s"}' %user_input[1])) # 向服务端发送删除指令
         res = json.loads(mylib.b2s(self.__sk.recv(200))) # 获取执行结果(错误码)
         print(self.__code_list[res['code']])
     else:
         print(self.__code_list['401'])
示例#18
0
 def auth(self, client_cmd):
     '''
     认证用户方法
     :param client_cmd: 用户命令
     :return: 无
     '''
     user = self.__userobj.get_user(client_cmd[1]) # 通过用名获取用户信息
     # 判断用户是否存在
     if user:
         # 判断密码是否正确
         if user['password'] == client_cmd[2]:
             # 如果验证当前用户等于认证成功的用户
             self.__current_user = user
             # 当前目录等于用户的家目录
             self.__current_path = user['home']
             # 告诉客户端用户成功
             self.request.sendall(mylib.s2b('ok'))
         else:
             self.request.sendall(mylib.s2b('fail'))
     else:
         self.request.sendall(mylib.s2b('fail'))
示例#19
0
 def rm(self, cliend_cmd):
     '''
     删除文件方法
     :param cliend_cmd: 用户命令
     :return: 无
     '''
     filename = self.__current_path + cliend_cmd[1] # 获取要删除的文件
     import os
     import shutil
     if filename.startswith('~') or filename.startswith('/') or filename.startswith('..'):
         # 目录不合法
         self.request.sendall('目录不合法')
     elif os.path.isdir(filename):# 如果是目录递归删除目录
         shutil.rmtree(filename)
         self.request.sendall(mylib.s2b('ok'))
     elif os.path.isfile(filename): # 如果是文件,只删除文件
         os.remove(filename)
         self.request.sendall(mylib.s2b('ok'))
     else:
         # 其他情况说明文件或目录不存在
         self.request.sendall(mylib.s2b('目录或文件%s不存在' %filename))
示例#20
0
 def rm(self, cliend_cmd):
     '''
     删除文件方法
     :param cliend_cmd: 用户命令
     :return: 无
     '''
     filename = self.__current_path + cliend_cmd[1] # 获取要删除的文件
     import os
     import shutil
     if filename.startswith('~') or filename.startswith('/') or filename.startswith('..'):
         # 目录不合法
         self.request.sendall('目录不合法')
     elif os.path.isdir(filename):# 如果是目录递归删除目录
         shutil.rmtree(filename)
         self.request.sendall(mylib.s2b('ok'))
     elif os.path.isfile(filename): # 如果是文件,只删除文件
         os.remove(filename)
         self.request.sendall(mylib.s2b('ok'))
     else:
         # 其他情况说明文件或目录不存在
         self.request.sendall(mylib.s2b('目录或文件%s不存在' %filename))
示例#21
0
 def auth(self, client_cmd):
     '''
     认证用户方法
     :param client_cmd: 用户命令
     :return: 无
     '''
     user = self.__userobj.get_user(client_cmd[1])  # 通过用名获取用户信息
     # 判断用户是否存在
     if user:
         # 判断密码是否正确
         if user['password'] == client_cmd[2]:
             # 如果验证当前用户等于认证成功的用户
             self.__current_user = user
             # 当前目录等于用户的家目录
             self.__current_path = user['home']
             # 告诉客户端用户成功
             self.request.sendall(mylib.s2b('ok'))
         else:
             self.request.sendall(mylib.s2b('fail'))
     else:
         self.request.sendall(mylib.s2b('fail'))
示例#22
0
 def put(self, user_input):
     '''
     客户端上传方法
     :param user_input: 指令
     :return: 无
     '''
     import json
     if len(user_input) == 2:
         file_name = user_input[1]
         if not os.path.isfile(file_name):
             print(self.__code_list['302'])
             return None
         self.__sk.sendall(mylib.s2b('checkspacesize'))
         res = json.loads(mylib.b2s(self.__sk.recv(100)))
         free_size = int(res['freesize']) * 1024 * 1024 # 获取剩余空间大小
         file_size = os.path.getsize(file_name)
         if free_size > file_size: # 判断剩余空间是否够,够就下载,不够就直接返回
             md5 = mylib.get_file_md5(file_name) # 获取上传文件的md5
             self.__sk.send(mylib.s2b(r'put|{"filename":"%s", "file_size":%s, "md5":"%s"}' %(os.path.split(file_name)[1], file_size, md5))) # 发送上传指令,并通知服务端文件名,文件大小和md5
             res = mylib.b2s(self.__sk.recv(200)).split('|') # 获取服务端确认信息
             if res[0] == 'ready':
                 send_size = json.loads(res[1])['recv_size'] # 获取已经上传的大小
                 f = open(file_name, 'rb')
                 f.seek(send_size) # 设定文件的其实位置为已上传的大小
                 while file_size != send_size:
                     # 只要文件大小不等于上传的大小则循环读文件并上传数据
                     if file_size - send_size > conf.FILE_PER_SIZE:
                         data = f.read(conf.FILE_PER_SIZE)
                         send_size += conf.FILE_PER_SIZE
                     else:
                         data = f.read(file_size - send_size)
                         send_size += (file_size - send_size)
                     self.__sk.send(data)
                     mylib.process_bar(send_size, file_size)
                 print(mylib.b2s(self.__sk.recv(200)))
                 print("")
         else:
             print(self.__code_list['307'])
     else:
         print(self.__code_list['401'])
示例#23
0
 def __runcmd(self, cmd):
     '''
     执行原生shell命令方法
     :param cmd: 命令
     :return:
     '''
     cmd_call = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
     cmd_result = cmd_call.stdout.read()
     ack_msg = mylib.s2b("CMD_RESULT_SIZE|%s" %len(cmd_result))
     self.request.send(ack_msg)
     client_ack = self.request.recv(50)
     if client_ack.decode() == 'CLIENT_READY_TO_RECV':
         self.request.send(cmd_result)
示例#24
0
 def __runcmd(self, cmd):
     '''
     执行原生shell命令方法
     :param cmd: 命令
     :return:
     '''
     cmd_call = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
     cmd_result = cmd_call.stdout.read()
     ack_msg = mylib.s2b("CMD_RESULT_SIZE|%s" % len(cmd_result))
     self.request.send(ack_msg)
     client_ack = self.request.recv(50)
     if client_ack.decode() == 'CLIENT_READY_TO_RECV':
         self.request.send(cmd_result)
示例#25
0
 def rm(self, user_input):
     '''
     删除文件方法
     :param user_input: 用户命令
     :return: 无
     '''
     if len(user_input) == 2:
         self.__sk.send(mylib.s2b('rm|{"path" : "%s"}' %
                                  user_input[1]))  # 向服务端发送删除指令
         res = json.loads(mylib.b2s(self.__sk.recv(200)))  # 获取执行结果(错误码)
         print(self.__code_list[res['code']])
     else:
         print(self.__code_list['401'])
示例#26
0
 def get(self, client_cmd):
     '''
     下载文件方法
     :param client_cmd: 分割后的命令
     :return: 无
     '''
     #print(client_cmd)
     import os
     # 拼接目录和文件名
     filename = self.__current_path + client_cmd[1]
     # 判断文件是否存在
     if os.path.isfile(filename):
         # 获取文件的md5
         md5 = mylib.get_file_md5(filename)
         # 获取文件大小
         file_size = os.path.getsize(filename)
         # 将文件的的大小,md5以及文件准备就绪的信息通知客户端
         res = "get|ready|%s|%s" % (file_size, md5)
         self.request.sendall(mylib.s2b(res))
         f = open(filename, 'rb')
         # 获取已经传输的文件大小
         send_size = int(client_cmd[2])
         # 定位文件的位置,用于断电续传
         f.seek(send_size)
         # 判断文件是否传输完毕
         while file_size != send_size:
             # 传输读取文件内容并传输,如果剩余大小每次传输的大小,则传输固定大小,如果剩余的大小
             if file_size - send_size > conf.FILE_PER_SIZE:
                 data = f.read(conf.FILE_PER_SIZE)
                 send_size += conf.FILE_PER_SIZE
             else:
                 data = f.read(file_size - send_size)
                 send_size += (file_size - send_size)
             self.request.sendall(data)
             #print(file_size, send_size)
     else:
         res = "文件%s不存在" % filename
         self.request.sendall(mylib.s2b(res))
示例#27
0
 def get(self, client_cmd):
     '''
     下载文件方法
     :param client_cmd: 分割后的命令
     :return: 无
     '''
     #print(client_cmd)
     import os
     # 拼接目录和文件名
     filename = self.__current_path + client_cmd[1]
     # 判断文件是否存在
     if os.path.isfile(filename):
         # 获取文件的md5
         md5 = mylib.get_file_md5(filename)
         # 获取文件大小
         file_size = os.path.getsize(filename)
         # 将文件的的大小,md5以及文件准备就绪的信息通知客户端
         res = "get|ready|%s|%s" %(file_size, md5)
         self.request.sendall(mylib.s2b(res))
         f = open(filename, 'rb')
         # 获取已经传输的文件大小
         send_size = int(client_cmd[2])
         # 定位文件的位置,用于断电续传
         f.seek(send_size)
         # 判断文件是否传输完毕
         while file_size != send_size:
             # 传输读取文件内容并传输,如果剩余大小每次传输的大小,则传输固定大小,如果剩余的大小
             if file_size - send_size > conf.FILE_PER_SIZE:
                 data = f.read(conf.FILE_PER_SIZE)
                 send_size += conf.FILE_PER_SIZE
             else:
                 data = f.read(file_size - send_size)
                 send_size += (file_size - send_size)
             self.request.sendall(data)
             #print(file_size, send_size)
     else:
         res = "文件%s不存在" %filename
         self.request.sendall(mylib.s2b(res))
示例#28
0
    def checkspacesize(self, instructions):
        '''
        检查剩余空间是否可以上传文件方法
        :param client_cmd: 用户命令
        :return: 无
        '''
        # 获取剩余空间大小
        import subprocess
        cmd_call = subprocess.Popen('du -s %s' %self.__home_path, shell = True, stdout = subprocess.PIPE)
        res = cmd_call.stdout.read()

        # 计算剩余空间,并返回
        free_size = self.__current_user.get_quota() * 1024 * 1024 - int(mylib.b2s(res).split()[0])
        self.request.send(mylib.s2b(r'{"freesize":%s}' %free_size))
示例#29
0
 def auth(self, user_input):
     '''
     认证方法
     :param user_input: 用户输入命令
     :return:
     '''
     username = input('username: '******'password: '******'auth|%s|%s' % (username, mylib.jiami(password)))) # 调用服务端的认证方法,验证用户名密码
     res = mylib.b2s(self.__sk.recv(100)) # 获取验证结果
     print(res)
     if res == 'ok': # 如果验证成功,修改当前用户名和登录状态
         self.__current_user = username
         self.__is_login = True
示例#30
0
 def cd(self, user_input):
     '''
     切换服务端目录方法
     :param user_input: 用户指令
     :return: 无
     '''
     if len(user_input) == 2:
         self.__sk.send(mylib.s2b('cd|{"path" : "%s"}' %user_input[1])) # 发送cd指令
         res = json.loads(mylib.b2s(self.__sk.recv(200))) # 获取服务端反馈
         if res['code'] == '500':
             self.__current_path = res['path'] # 修改当前目录等于返回来的目录
         else:
             print(self.__code_list[res['code']])
     else:
         print(self.__code_list['401'])
示例#31
0
 def get(self, instructions):
     '''
     get 指令方法
     :param instructions: 客户端命令
     :return: 无
     '''
     import os
     import json
     res = json.loads(instructions[1])
     filename = os.path.join(self.__current_path, res['filename']) # 获取文件名
     if os.path.isfile(filename) and self.__check_path(filename): # 判断文件是否存在以及是否在家目录范围内
         md5 = mylib.get_file_md5(filename) # 获取下载文件的md5
         file_size = os.path.getsize(filename) # 获取下载文件的大小
         self.request.send(mylib.s2b('ready|{"filesize":%s, "md5": "%s"}' %(file_size, md5))) # 通知客户端准备下载和MD5
         f = open(filename, 'rb')
         send_size = res['sendsize'] # 获取已经下载的大小
         f.seek(send_size) # 设定起始位置,用于续传
         self.__loger.info('Begin send file  %s to client [%s]' %(filename, self.client_address))
         while file_size != send_size:
             # 传输读取文件内容并传输,如果剩余大小每次传输的大小,则传输固定大小,如果剩余的大小
             if file_size - send_size > conf.FILE_PER_SIZE:
                 data = f.read(conf.FILE_PER_SIZE)
                 send_size += conf.FILE_PER_SIZE
             else:
                 data = f.read(file_size - send_size)
                 send_size += (file_size - send_size)
             try:
                 self.request.send(data)
             except socket.error as e:
                 self.__loger.error('%s when send file %s to client [%s]' %(e, filename, self.client_address))
                 break
             print(file_size, send_size)
         f.close()
         self.__loger.info('End send file %s to client [%s]' %(filename, self.client_address))
     else:
         self.request.send(mylib.s2b('fail|303'))
示例#32
0
 def cd(self, user_input):
     '''
     切换服务端目录方法
     :param user_input: 用户指令
     :return: 无
     '''
     if len(user_input) == 2:
         self.__sk.send(mylib.s2b('cd|{"path" : "%s"}' %
                                  user_input[1]))  # 发送cd指令
         res = json.loads(mylib.b2s(self.__sk.recv(200)))  # 获取服务端反馈
         if res['code'] == '500':
             self.__current_path = res['path']  # 修改当前目录等于返回来的目录
         else:
             print(self.__code_list[res['code']])
     else:
         print(self.__code_list['401'])
示例#33
0
 def cd(self, instructions):
     '''
     cd命令方法
     :param instructions: 客户端命令
     :return: 无
     '''
     import os
     import json
     path = json.loads(instructions[1])['path'] # 获取要cd的目录
     tmp_path = os.path.abspath(os.path.join(self.__current_path, path)) # 定义临时目录
     if os.path.isdir(tmp_path) and self.__check_path(tmp_path): #判断目录是否存在和是否绕过家目录
         self.__current_path = tmp_path.replace('\\', '/')
         response_code = '500'
     else:
         response_code = '303'
     self.request.send(mylib.s2b('{"code":"%s", "path":"%s"}' %(response_code, self.__current_path.replace(self.__home_path, "")))) # 返回当前目录
示例#34
0
 def auth(self, user_input):
     '''
     认证方法
     :param user_input: 用户输入命令
     :return:
     '''
     if len(user_input) ==1:
         username = input('username: '******'password: '******'auth|{"username":"******", "password":"******"}' % (username, mylib.jiami(password)))) # 调用服务端的认证方法,验证用户名密码
         res = mylib.b2s(self.__sk.recv(200)) # 获取验证结果
         print(self.__code_list[res])
         if res == '200': # 如果验证成功,修改当前用户名和登录状态
             self.__current_user = username
             self.__is_login = True
     else:
         print(self.__code_list['401'])
示例#35
0
 def auth(self, user_input):
     '''
     认证方法
     :param user_input: 用户输入命令
     :return:
     '''
     if len(user_input) == 1:
         username = input('username: '******'password: '******'auth|{"username":"******", "password":"******"}' %
                 (username, mylib.jiami(password))))  # 调用服务端的认证方法,验证用户名密码
         res = mylib.b2s(self.__sk.recv(200))  # 获取验证结果
         print(self.__code_list[res])
         if res == '200':  # 如果验证成功,修改当前用户名和登录状态
             self.__current_user = username
             self.__is_login = True
     else:
         print(self.__code_list['401'])
示例#36
0
 def __runcmd(self, cmd):
     '''
     执行原生shell命令方法
     :param cmd: shell命令
     :return: 无
     '''
     self.__sk.sendall(mylib.s2b(cmd))
     server_ack_msg = self.__sk.recv(100)
     cmd_res_msg = str(server_ack_msg.decode()).split("|")
     if cmd_res_msg[0] == "CMD_RESULT_SIZE":
         cmd_res_size = int(cmd_res_msg[1])
         self.__sk.send(b"CLIENT_READY_TO_RECV")
     res = ''
     received_size = 0
     while received_size < cmd_res_size:
         data = self.__sk.recv(500)
         received_size += len(data)
         res += str(data.decode())
     else:
         print(str(res))
示例#37
0
 def __runcmd(self, cmd):
     '''
     执行原生shell命令方法
     :param cmd: shell命令
     :return: 无
     '''
     self.__sk.sendall(mylib.s2b(cmd))
     server_ack_msg = self.__sk.recv(100)
     cmd_res_msg = str(server_ack_msg.decode()).split("|")
     if cmd_res_msg[0] == "CMD_RESULT_SIZE":
         cmd_res_size = int(cmd_res_msg[1])
         self.__sk.send(b"CLIENT_READY_TO_RECV")
     res = ''
     received_size = 0
     while received_size < cmd_res_size:
         data = self.__sk.recv(500)
         received_size += len(data)
         res += str(data.decode())
     else:
         print(str(res))