小渣渣学习笔记 python day29【文件上传 socketserver】

#文件上传 server端
import socket
import json
ipaddr = '127.0.0.1'
port = 9002

sk = socket.socket()
sk.bind((ipaddr,port))
sk.listen()

conn,addr = sk.accept()
msg = conn.recv(1024).decode('utf-8') #先decode 再用json loads回来
msg = json.loads(msg)
print(msg)

print(msg['filesize'])
with open(r'C:\Users\lyq\PycharmProjects\untitled\day29\test\TXT2mVZq.mp4',mode='wb') as f1:
    while msg['filesize']>0:
        msg2 = conn.recv(1024)
        msg['filesize']-=len(msg2)
        #这里减去len(msg2)是说，虽然按照1024字节接收，但是不一定接收到这么多，还是要按照实际长度减
        f1.write(msg2)

conn.close()
sk.close()

#文件上传 client端
import socket
import json
import os
ipaddr = '127.0.0.1'
port = 9002

sk = socket.socket()
sk.connect((ipaddr,port))
#发送文件名和文件大小
abs_path = r'D:\迅雷下载\TXT2mVZq.mp4'
filename = os.path.basename(abs_path)
filesize = os.path.getsize(abs_path)
#网络编程不用字符串拼接的方式传输
dict_file_info = {'filename':filename,'filesize':filesize}
str_dic = json.dumps(dict_file_info)
sk.send(str_dic.encode('utf-8')) #粘包发生在2个send之间，这里可能出现

with open(abs_path,mode='rb') as f1:
    # content = f1.read() #小文件可以一次性读完，大文件就要切分
    while filesize>0: #循环读取大文件并发送
        content = f1.read(1024) #每次读1024字节
        filesize-=len(content) #严禁一点也要按照实际的content长度减
        sk.send(content)

sk.close()

#文件上传 server端 【解决先发字典的时候可能出现的粘包现象】

import socket
import json
import struct
ipaddr = '127.0.0.1'
port = 9002

sk = socket.socket()
sk.bind((ipaddr,port))
sk.listen()

conn,addr = sk.accept()
len1 = conn.recv(4)
dic_len = struct.unpack('i',len1)[0]#先用conn.recv(4)接收4个字节的值，再unpack成先发来的字典的长度dic_len，后续用这个长度接收字典内容
msg = conn.recv(dic_len).decode('utf-8') #先decode 再用json loads回来
msg = json.loads(msg)
print(msg)

print(msg['filesize'])
with open(r'C:\Users\lyq\PycharmProjects\untitled\day29\test\TXT2mVZq.mp4',mode='wb') as f1:
    while msg['filesize']>0:
        msg2 = conn.recv(1024)
        msg['filesize']-=len(msg2)
        #这里减去len(msg2)是说，虽然按照1024字节接收，但是不一定接收到这么多，还是要按照实际长度减
        f1.write(msg2)

conn.close()
sk.close()



#文件上传 client端 【解决先发字典的时候可能出现的粘包现象】
import socket
import json
import os
import struct
ipaddr = '127.0.0.1'
port = 9002

sk = socket.socket()
sk.connect((ipaddr,port))
#发送文件名和文件大小
abs_path = r'D:\迅雷下载\TXT2mVZq.mp4'
filename = os.path.basename(abs_path)
filesize = os.path.getsize(abs_path)
#网络编程不用字符串拼接的方式传输
dict_file_info = {'filename':filename,'filesize':filesize}
str_dic = json.dumps(dict_file_info)
msg1 = str_dic.encode('utf-8')
sk.send(struct.pack('i',len(msg1)))
sk.send(msg1) #粘包发生在2个send之间，这里可能出现

with open(abs_path,mode='rb') as f1:
    # content = f1.read() #小文件可以一次性读完，大文件就要切分
    while filesize>0: #循环读取大文件并发送
        content = f1.read(1024) #每次读1024字节
        filesize-=len(content) #严禁一点也要按照实际的content长度减
        sk.send(content)

sk.close()

#验证客户端合法性server端
import socket
import os #导入os模块 利用 urandom函数
import hashlib
ipaddr = '127.0.0.1'
port = 9002
secret_key = b'tom_hi' #这个就是公钥
sk = socket.socket()
sk.bind((ipaddr,port))
sk.listen()
conn,addr = sk.accept()
#server端先发一个字符串给客户端
rand = os.urandom(32)
conn.send(rand)
#server端自己也把字符串进行加密，与client端发送过来的进行对比
sha = hashlib.sha1(rand)
sha.update((rand))
res = sha.hexdigest()
#server接收客户端对之前先发的字符串进行的加密，加密按照公钥
res_client = conn.recv(1024).decode('utf-8')
print(res_client)
if res == res_client:
    conn.send(b'right')
else:
    conn.close()

sk.close()
#验证客户端合法性 client端
import socket
import hashlib
ipaddr = '127.0.0.1'
port = 9002
secret_key = b'tom_hi' #这个就是公钥
sk = socket.socket()
sk.connect((ipaddr,port))
#client接收server端发的一个字符串
rand = sk.recv(32)
#client端按照公钥进行加密,并发送个server端
sha = hashlib.sha1(rand)
sha.update((rand))
res = sha.hexdigest()
sk.send(res.encode('utf-8'))
msg = sk.recv(1024)
print(msg.decode('utf-8'))

sk.close()

#并发的客户端请求
import socket
import time
import socketserver
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        conn = self.request
        while 1:
            try:
                msg = conn.recv(1024).decode('utf-8')
                conn.send(msg.upper().encode('utf-8'))
                time.sleep(1)
            except ConnectionResetError:
                break
server = socketserver.ThreadingTCPServer(('127.0.0.1',9002),Myserver)
server.serve_forever()
#并发的客户端请求
import socket
sk = socket.socket()
sk.connect(('127.0.0.1',9002))
while 1:
    sk.send(b'hello')
    msg = sk.recv(1024).decode('utf-8')
    print(msg)
sk.close()

#操作系统
#I/O 输入输出 相对于内存而言
#Input 输入：鼠标 键盘
#FCFS :先来先服务
#分时操作系统：
#多任务操作系统：
#单CPU：时间片
#分布式操作系统：python可以用celary实现
#进程：运行中的程序，运行起来，它就占用计算机资源，操作系统可以调度它，计算机中最小的资源分配单位
#并发：多个程序同时执行，只有一个cpu，多个程序轮流在一个cpu上执行，宏观上，多个程序在同时执行，微观上，多个程序轮流在cpu上执行，本质是串行
#并行：多个程序同时执行，同时在多个cpu上执行
#同步：一件事结束，才能做另一件事
#异步：在A事情操作的时候发起B事务
#阻塞：遇到cpu不工作了，input
#非阻塞：
#线程：进程里，执行代码是线程操作的，进程中的单位资源，是计算机中能调度的最小的单位

#【练习】
#网络编程思维导图
#并发：
    #多道操作系统
        #cpu使用率
        #用户体验
    #分时操作系统
        #cpu的使用率
        #用户体验
    #基础并发概念
#ftp实现：