General  # 简单的描述
Request URL: https://www.baidu.com/  # 请求网址
Request Method: GET  # 请求方法
Status Code: 200 OK  # 状态代码 有数据 成功
Remote Address: 14.215.177.39:443  # 远程地址:服务器地址
Referrer Policy: no-referrer-when-downgrade  # 表示从https协议降为http协议时不发送referrer给跳转网站的服务器

Response Headers    view source  # 响应头  源始头
Bdpagetype: 1  # 百度服务器定义的特定值
Bdqid: 0xedfaa2040000c90c  # 百度服务器定义的特定值
Cache-Control: private  # 缓存控制:私有
Connection: Keep-Alive  # 连接:tpc socket的可靠连接
Content-Encoding: gzip  # 服务器通过这个头告诉浏览器数据的压缩格式
Content-Type: text/html  # 服务器通过这个头告诉浏览器回送数据的类型
Cxy_all: baidu+d83b58345e15ab078f816c529e1cef79
Date: Sun, 14 Apr 2019 02:47:43 GMT  # 时间
Expires: Sun, 14 Apr 2019 02:47:31 GMT  # 到期时间
Server: BWS/1.1  # 服务器通过这个头告诉浏览器服务器的型号
Set-Cookie: delPer=0; path=/; domain=.baidu.com
Set-Cookie: BDSVRTM=0; path=/
Set-Cookie: BD_HOME=0; path=/
Set-Cookie: H_PS_PSSID=1427_28827_21091_28768_28722_28558_28832_28585_28604_28606; path=/; domain=.baidu.com
"""Set-Cookie
    服务器与客户端验证身份的信息
    其中path=/; domain=.baidu.com为域名判断条件,如果满足该条件,才可以向服务器发送cookie
"""
Strict-Transport-Security: max-age=172800  # 通知浏览器,这个网站禁止使用HTTP方式加载,浏览器应该自动把所有尝试使用HTTP的请求自动替换为HTTPS请求
Transfer-Encoding: chunked  # Transfer-Encoding,是一个 HTTP 头部字段（响应头域）,字面意思是传输编码,最新的 HTTP规范里,只定义了一种编码传输:分块编码(chunked),数据分解成一系列数据块,并以一个或多个块发送,这样服务器可以发送数据而不需要预先知道发送内容的总大小
Vary: Accept-Encoding  # 告诉代理服务器缓存两种版本的资源:压缩和非压缩
X-Ua-Compatible: IE=Edge,chrome=1  # 这是一个文档兼容模式的定义,主要用于加强代码对IE的兼容性,强制IE使用当前本地最新版标准模式渲染或者用chrome内核渲染


Response Headers    view parsed  # 响应头  已解析源始头
HTTP/1.1 200 OK  # 使用HTTP协议进行传输的中协议版本号为1.1请求状态码为200 OK
Bdpagetype: 1  # 百度服务器定义的特定值
Bdqid: 0xfa9b2b6a00029507  # 百度服务器定义的特定值
Cache-Control: private  # 对数据进行缓存
Connection: keep-alive  # # 连接:tpc socket的可靠连接
Content-Encoding: gzip  # 传输资源的文件压缩格式
Content-Type: text/html;charset=utf-8  # 传输资源的文件类型和编码类型
Date: Thu, 04 Jun 2020 08:56:33 GMT  # 资源的发送时间
Expires: Thu, 04 Jun 2020 08:56:29 GMT  # 资源过期时间
Server: BWS/1.1  # 服务器的系统版本,其中BWS为百度自有服务器(Baidu Web Server)
Set-Cookie: BDSVRTM=0; path=/
Set-Cookie: BD_HOME=1; path=/
Set-Cookie: H_PS_PSSID=31728_1460_31326_21078_31069_31762_31605_31322_30824; path=/; domain=.baidu.com
"""Set-Cookie
    服务器与客户端验证身份的信息
    其中path=/; domain=.baidu.com为域名判断条件,如果满足该条件,才可以向服务器发送cookie
"""
Strict-Transport-Security: max-age=172800
"""Strict-Transport-Security: max-age=172800
    使用https安全传输,防止在浏览器默认http请求和服务器https资源之间进行转换的时候,遭受中间人攻击
    浏览器收到该条响应字段,会在max-age秒之内自动将http转换成https的安全访问形式,过期后会重复之前的步骤
"""
Traceid: 1591260993276042138618058074865138832647  # 标记了浏览器发起的某个请求,这个id可在服务端从接收请求到 响应请求中流转,甚至接力传递给下游应用中流转,用于唯一标记和定外这次请求,一般用于定位请求日志
X-Ua-Compatible: IE=Edge,chrome=1  # # 这是一个文档兼容模式的定义,主要用于加强代码对IE的兼容性,强制IE使用当前本地最新版标准模式渲染或者用chrome内核渲染
Transfer-Encoding: chunked   # Transfer-Encoding,是一个 HTTP 头部字段（响应头域）,字面意思是传输编码,最新的 HTTP规范里,只定义了一种编码传输:分块编码(chunked),数据分解成一系列数据块,并以一个或多个块发送,这样服务器可以发送数据而不需要预先知道发送内容的总大小

Request Headers view source  # 请求头  源始头
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
"""Accept
    客户端希望接受的文件类型,后面的q=0.9(0<q<1)代表权重系数,越大表示越期待
"""
Accept-Encoding: gzip, deflate, br  # 设置接受的编码格式
Accept-Language: zh-CN,zh;q=0.9  # 浏览器支持的语言为简体中文和中文,优先支持简体中文
Cache-Control: max-age=0  # 缓存控制
Connection: keep-alive
"""Connection: keep-alive
    该字段可以承载三种不同类型的标签:
    HTTP首部字段名,列出了只与此连接有关的首部任意标签值,用于描述此连接的非标准选项值(close)表示的是TCP连接是否关闭,HTTP数据传输采用的TCP三次握手协议
    如果值为close,则该次传输数据结束关闭TCP连接,下次传输数据,要重新进行三次握手
    如果值为默认的keep-alive,则保持数据通道,下次数据传输可以直接传递,省去三次握手的过程
    一般我们只用值close来控制TCP连接状态
"""
    Cookie: BIDUPSID=D97A5AC4617B3E6A2486D73D9F89F5AF; PSTM=1590403180; BAIDUID=D97A5AC4617B3E6AA36FE3B792FD9646:FG=1; BD_UPN=12314353; cflag=13%3A3; BD_HOME=1; H_PS_PSSID=31728_1460_31326_21078_31069_31762_31605_31322_30824; delPer=0; BD_CK_SAM=1; BDORZ=B490B5EBF6F3CD402E515D22BCDA1598; yjs_js_security_passport=64f53ded3515c88a93fa8fb6ab0e4dafa11418ec_1591253192_js; PSINO=5; COOKIE_SESSION=1708_0_9_9_24_19_0_3_9_7_4_6_1708_0_6_0_1591254838_0_1591254844%7C9%230_0_1590910191%7C1
    Host: www.baidu.com  # # 浏览器发给服务器,声明浏览器访问哪台主机
    Upgrade-Insecure-Requests: 1
"""Upgrade-Insecure-Requests: 1
    该字段用于http和https格式的过渡,一般如果请求http时,服务器资源为https,或是相反,浏览器会提示或报错
    而Google浏览器使用该字段向服务器表明,浏览器本身可以将http转换成https,服务器可以随意发,浏览器会自动将http://该成https://
"""
    User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36
"""User-Agent
    用户Agent代理,即用户发出HTTP请求的客户端程序(例:浏览器Mozilla/5.0版本,Chrome/73.0.3683.86版本,spider爬虫,Web robot等)
"""


Request Headers view parsed  # 请求头  已解析源始头
GET / HTTP/1.1  # 请求方式 请求目录 协议版本
Host: www.baidu.com  # 浏览器发给服务器,声明浏览器访问哪台主机
Connection: keep-alive  # 浏览器发给服务器,声明请求完后是断开链接还是维持链接
Cache-Control: max-age=0  # 缓存控制
Upgrade-Insecure-Requests: 1  # 浏览器发给服务器,声明自己支持这种操作,也就是我能读懂你服务器发过来的上面这条信息,并且在以后发请求的时候不用http而用https
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36  # 浏览器发给服务器,声明支持的浏览器及版本
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3  # 浏览器发给服务器,声明浏览器所支持的数据类型
Accept-Encoding: gzip, deflate, br  # 浏览器发给服务器,声明浏览器支持的编码类型
Accept-Language: zh-CN,zh;q=0.9  # 浏览器发给服务器,声明浏览器支持的语言
Cookie: BAIDUID=BF236BEC6E4EF4DCF1AD838C2D217739:FG=1; PSTM=1555138860; BIDUPSID=88B1B87B29B6B36C8E48F551D3574BFE; BD_UPN=12314353; BDORZ=B490B5EBF6F3CD402E515D22BCDA1598; H_PS_PSSID=1427_28827_21091_28768_28722_28558_28832_28585_28604_28606; BDUSS=HU1UVhKRnNDMEhiYjlOVjNPQUhYfkxlZ2xTejV-c0Y0c2RzUVFSQUxtTVBOZHBjSUFBQUFBJCQAAAAAAAAAAAEAAABZiE1gQW5nZWxzxbe6wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA-oslwPqLJcW; delPer=0; BD_CK_SAM=1; PSINO=6; H_PS_645EC=c374KRUZaisqZePbVCOq52p9mRyTUyW7oNYJp%2Bbf2HRkfC7pCZ%2F5tPvURnM; ZD_ENTRY=baidu; BD_HOME=1

# html文件夹网盘链接: https://pan.baidu.com/s/1wbZ92KLstff3GurLV_C0lg  密码: hp9o
# 下载完命令行解压后放到程序的同级路径下,解压命令: tar -zxvf 06_html.tar.gz -C ./
import socket
import re


def handle_request(client_socket):
    """为一个客户端进行服务"""
    # 1.接收浏览器发送过来的HTTP请求
    recv_data = client_socket.recv(1024).decode(‘utf-8‘, errors="ignore")
    request_header_lines = recv_data.splitlines()
    for line in request_header_lines:
        print(line)

    # GET /index.html HTTP/1.1
    http_request_line = request_header_lines[0]
    get_file_name = re.match("[^/]+(/[^ ]*)", http_request_line).group(1)
    print("file name is ===>%s" % get_file_name)  # for test

    # 如果没有指定访问哪个页面,则默认访问index.html
    # GET / HTTP/1.1
    if get_file_name == "/":
        get_file_name = DOCUMENTS_ROOT + "/index.html"
    else:
        get_file_name = DOCUMENTS_ROOT + get_file_name
    print("file name is ===2>%s" % get_file_name)  # for test

    # 2.返回HTTP格式的数据给浏览器
    try:
        f = open(get_file_name, "rb")
    except IOError:
        # 404表示没有这个页面
        response_headers = "HTTP/1.1 404 not found\r\n"
        response_headers += "\r\n"
        response_body = "====sorry, file not found====".encode("utf-8")
    else:
        # 2.1 准备发送给浏览器的数据-->header
        response_headers = "HTTP/1.1 200 OK\r\n"
        # 2.2 用一个空的行与body进行隔开
        response_headers += "\r\n"
        # 2.3 准备发送给浏览器的数据-->body
        response_body = f.read()
        f.close()
    finally:
        # 因为头信息在组织的时候,是按照字符串组织的,不能与以二进制打开文件读取的数据合并,因此分开发送
        # 先发送response的头信息
        client_socket.send(response_headers.encode("utf-8"))
        # 再发送body
        client_socket.send(response_body)
        # 关闭套接字
        client_socket.close()


def main():
    """作为程序的主控制入口"""
    # 1.创建数据流套接字
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 2.设置当服务器先close 即服务器端4次挥手之后资源能够立即释放,保证下次运行程序时可以立即绑定7890端口
    tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    # 3.绑定服务器地址
    tcp_server_socket.bind(("", 7890))
    # 4.套接字由主动改为监听,并设置队列长度
    tcp_server_socket.listen(128)
    while True:
        # 5.等待客户端连接
        client_socket, client_addr = tcp_server_socket.accept()
        # 6.为客户端服务
        handle_request(client_socket)

    # 7.关闭监听套接字
    tcp_server_socket.close()


# 配置服务器静态资源路径
DOCUMENTS_ROOT = "./html"

if __name__ == "__main__":
    main()

# html文件夹网盘链接: https://pan.baidu.com/s/1wbZ92KLstff3GurLV_C0lg  密码: hp9o
# 下载完命令行解压后放到程序的同级路径下,解压命令: tar -zxvf 06_html.tar.gz -C ./
import socket
import multiprocessing
import re


class WSGIServer:
    """定义一个WSGI服务器的类"""
    def __init__(self, server_address):
        # 1.创建数据流套接字
        self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 2.设置当服务器先close 即服务器端4次挥手之后资源能够立即释放,保证下次运行程序时可以立即绑定7890端口
        self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        # 3.绑定服务器地址
        self.tcp_server_socket.bind(server_address)
        # 4.套接字由主动改为监听,并设置队列长度
        self.tcp_server_socket.listen(128)

    def serve_forever(self):
        """循环运行服务器,等待客户端链接并为客户端服务"""
        while True:
            # 5.等待客户端链接
            client_socket, client_addr = self.tcp_server_socket.accept()
            # 6.为客户端服务
            new_process = multiprocessing.Process(target=self.handle_request, args=(client_socket,))
            new_process.start()

            # 因为子进程已经复制了父进程的套接字等资源,所以父进程调用close不会将他们对应的这个链接关闭的
            client_socket.close()

    def handle_request(self, client_socket):
        """用一个新的进程为客户端服务"""
        # 1.接收浏览器发送过来的HTTP请求
        recv_data = client_socket.recv(1024).decode(‘utf-8‘, errors="ignore")
        request_header_lines = recv_data.splitlines()
        for line in request_header_lines:
            print(line)

        # GET /index.html HTTP/1.1
        http_request_line = request_header_lines[0]
        get_file_name = re.match("[^/]+(/[^ ]*)", http_request_line).group(1)
        print("file name is ===>%s" % get_file_name)  # for test

        # 如果没有指定访问哪个页面,则默认访问index.html
        # GET / HTTP/1.1
        if get_file_name == "/":
            get_file_name = DOCUMENTS_ROOT + "/index.html"
        else:
            get_file_name = DOCUMENTS_ROOT + get_file_name
        print("file name is ===2>%s" % get_file_name)  # for test

        # 2.返回HTTP格式的数据给浏览器
        try:
            f = open(get_file_name, "rb")
        except IOError:
            # 404表示没有这个页面
            response_headers = "HTTP/1.1 404 not found\r\n"
            response_headers += "\r\n"
            response_body = "====sorry, file not found====".encode("utf-8")
        else:
            # 2.1 准备发送给浏览器的数据-->header
            response_headers = "HTTP/1.1 200 OK\r\n"
            # 2.2 用一个空的行与body进行隔开
            response_headers += "\r\n"
            # 2.3 准备发送给浏览器的数据-->body
            response_body = f.read()
            f.close()
        finally:
            # 因为头信息在组织的时候,是按照字符串组织的,不能与以二进制打开文件读取的数据合并,因此分开发送
            # 先发送response的头信息
            client_socket.send(response_headers.encode("utf-8"))
            # 再发送body
            client_socket.send(response_body)
            # 关闭套接字
            client_socket.close()


# 设定服务器的地址
SERVER_ADDR = ("", 7890)
# 设置服务器静态资源的路径
DOCUMENTS_ROOT = "./html"


def main():
    http_server = WSGIServer(SERVER_ADDR)
    print("web Server: Serving HTTP on port %d ...\n" % SERVER_ADDR[1])
    http_server.serve_forever()


if __name__ == "__main__":
    main()

# html文件夹网盘链接: https://pan.baidu.com/s/1wbZ92KLstff3GurLV_C0lg  密码: hp9o
# 下载完命令行解压后放到程序的同级路径下,解压命令: tar -zxvf 06_html.tar.gz -C ./
import socket
import os
import signal
import re


class WSGIServer:
    """定义一个WSGI服务器的类"""

    def __init__(self, server_address):
        # 1.创建数据流套接字
        self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 2.设置当服务器先close 即服务器端4次挥手之后资源能够立即释放,保证下次运行程序时可以立即绑定7890端口
        self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        # 3.绑定服务器地址
        self.tcp_server_socket.bind(server_address)
        # 4.套接字由主动改为监听,并设置队列长度
        self.tcp_server_socket.listen(128)

    def serve_forever(self):
        """循环运行服务器,等待客户端链接并为客户端服务"""
        print("父进程PID[%s]等待客户端的链接" % os.getpid())
        while True:
            try:
                # 5.等待客户端链接
                client_socket, client_addr = self.tcp_server_socket.accept()
            except KeyboardInterrupt:  # 用户中断执行(通常是输入^C)
                raise
            except Exception:
                continue
            # 6.处理子进程,避免成为僵尸进程-->SIGCHLD: 子进程改变状态时,父进程会收到这个信号;SIG_IGN: 忽略这个信号
            signal.signal(signal.SIGCHLD, signal.SIG_IGN)
            # 7.父进程为客户端创建新的进程
            pid = os.fork()
            if pid < 0:
                print("创建子进程失败...")
                # 关闭客户端套接字
                client_socket.close()
            elif pid == 0:
                # 子进程中不需要使用监听套接字,因此关闭子进程中的监听套接字
                self.tcp_server_socket.close()
                # 8.为客户端服务
                self.handle_request(client_socket)
            else:
                # 父进程中不需要使用客户端套接字,因此关不父进程中的客户端套接字
                client_socket.close()
                continue

    def handle_request(self, client_socket):
        """用一个新的进程为客户端服务"""
        # 1.接收浏览器发送过来的HTTP请求
        recv_data = client_socket.recv(1024).decode(‘utf-8‘, errors="ignore")
        request_header_lines = recv_data.splitlines()
        for line in request_header_lines:
            print(line)

        # GET /index.html HTTP/1.1
        http_request_line = request_header_lines[0]
        get_file_name = re.match("[^/]+(/[^ ]*)", http_request_line).group(1)
        print("file name is ===>%s" % get_file_name)  # for test

        # 如果没有指定访问哪个页面,则默认访问index.html
        # GET / HTTP/1.1
        if get_file_name == "/":
            get_file_name = DOCUMENTS_ROOT + "/index.html"
        else:
            get_file_name = DOCUMENTS_ROOT + get_file_name
        print("file name is ===2>%s" % get_file_name)  # for test

        # 2.返回HTTP格式的数据给浏览器
        try:
            f = open(get_file_name, "rb")
        except IOError:
            # 404表示没有这个页面
            response_headers = "HTTP/1.1 404 not found\r\n"
            response_headers += "\r\n"
            response_body = "====sorry, file not found====".encode("utf-8")
        else:
            # 2.1 准备发送给浏览器的数据-->header
            response_headers = "HTTP/1.1 200 OK\r\n"
            # 2.2 用一个空的行与body进行隔开
            response_headers += "\r\n"
            # 2.3 准备发送给浏览器的数据-->body
            response_body = f.read()
            f.close()
        finally:
            # 因为头信息在组织的时候,是按照字符串组织的,不能与以二进制打开文件读取的数据合并,因此分开发送
            # 先发送response的头信息
            client_socket.send(response_headers.encode("utf-8"))
            # 再发送body
            client_socket.send(response_body)
            # 关闭套接字
            client_socket.close()


# 设定服务器的地址
SERVER_ADDR = ("", 7890)
# 设置服务器静态资源的路径
DOCUMENTS_ROOT = "./html"


def main():
    http_server = WSGIServer(SERVER_ADDR)
    print("web Server: Serving HTTP on port %d ...\n" % SERVER_ADDR[1])
    http_server.serve_forever()


if __name__ == "__main__":
    main()

# html文件夹网盘链接: https://pan.baidu.com/s/1wbZ92KLstff3GurLV_C0lg  密码: hp9o
# 下载完命令行解压后放到程序的同级路径下,解压命令: tar -zxvf 06_html.tar.gz -C ./
from socketserver import ForkingMixIn
from socketserver import TCPServer
from socketserver import StreamRequestHandler
import re


# class WSGIServer(ForkingTCPServer):  # 写法一 ‘ForkingTCPServer‘ = ‘ForkingMixIn‘ + ‘TCPServer‘
class WSGIServer(ForkingMixIn, TCPServer):  # 写法二
    """定义一个创建服务器类继承自模块中的创建服务器类"""
    pass


class HandleRequest(StreamRequestHandler):
    """定义一个处理请求类继承模块的处理请求类"""

    def handle(self):  # 固定的入口方法
        # 等待客户端连接 self.request等同于accept()创建一个新的客户端连接
        client_socket = self.request
        client_addr = self.request.getpeername()  # for test
        print("客户端 %s 连接上服务器" % str(client_addr))  # for test

        while True:
            # 1.接收浏览器发送过来的HTTP请求
            recv_data = client_socket.recv(1024).decode(‘utf-8‘, errors="ignore")
            request_header_lines = recv_data.splitlines()
            for line in request_header_lines:
                print(line)

            # GET /index.html HTTP/1.1
            http_request_line = request_header_lines[0]
            get_file_name = re.match("[^/]+(/[^ ]*)", http_request_line).group(1)
            print("file name is ===>%s" % get_file_name)  # for test

            # 如果没有指定访问哪个页面,则默认访问index.html
            # GET / HTTP/1.1
            if get_file_name == "/":
                get_file_name = DOCUMENTS_ROOT + "/index.html"
            else:
                get_file_name = DOCUMENTS_ROOT + get_file_name
            print("file name is ===2>%s" % get_file_name)  # for test

            # 2.返回HTTP格式的数据给浏览器
            try:
                f = open(get_file_name, "rb")
            except IOError:
                # 404表示没有这个页面
                response_body = "====sorry, file not found====".encode("utf-8")
                response_headers = "HTTP/1.1 404 not found\r\n"
                response_headers += "Content-Type: text/html; charset=utf-8\r\n"
                response_headers += "Content-Length: %d\r\n" % (len(response_body))
                response_headers += "\r\n"
            else:
                # 2.1 准备发送给浏览器的数据-->body
                response_body = f.read()
                f.close()
                # 2.2 准备发送给浏览器的数据-->header
                response_headers = "HTTP/1.1 200 OK\r\n"
                # 2.3 发送body数据长度,让服务器根据长度确认body数据已完成接收,实现长连接
                response_headers += "Content-Length: %d\r\n" % (len(response_body))
                # 2.4 用一个空的行与body进行隔开
                response_headers += "\r\n"
            finally:
                # 因为头信息在组织的时候,是按照字符串组织的,不能与以二进制打开文件读取的数据合并,因此分开发送
                # 先发送response的头信息
                client_socket.send(response_headers.encode("utf-8"))
                # 再发送body
                client_socket.send(response_body)
                # 长连接下不需要关闭套接字,而是在header头中声明要发送的body长度
                # client_socket.close()


# 设定服务器的地址
SERVER_ADDR = ("", 7890)
# 设置服务器静态资源的路径
DOCUMENTS_ROOT = "./html"


def main():
    http_server = WSGIServer(SERVER_ADDR, HandleRequest)
    print("web Server: Serving HTTP on port %d ...\n" % SERVER_ADDR[1])
    http_server.serve_forever()


if __name__ == "__main__":
    main()

# html文件夹网盘链接: https://pan.baidu.com/s/1wbZ92KLstff3GurLV_C0lg  密码: hp9o
# 下载完命令行解压后放到程序的同级路径下,解压命令: tar -zxvf 06_html.tar.gz -C ./
import socket
import threading
import re


class WSGIServer:
    """定义一个WSGI服务器的类"""
    def __init__(self, server_address):
        # 1.创建数据流套接字
        self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 2.设置当服务器先close 即服务器端4次挥手之后资源能够立即释放,保证下次运行程序时可以立即绑定7890端口
        self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        # 3.绑定服务器地址
        self.tcp_server_socket.bind(server_address)
        # 4.套接字由主动改为监听,并设置队列长度
        self.tcp_server_socket.listen(128)

    def serve_forever(self):
        """循环运行服务器,等待客户端链接并为客户端服务"""
        while True:
            # 5.等待客户端链接
            client_socket, client_addr = self.tcp_server_socket.accept()
            # 6.为客户端服务
            new_thread = threading.Thread(target=self.handle_request, args=(client_socket,))
            new_thread.start()

            # 因为线程是共享同一个套接字,所以主线程不能关闭,否则子线程就不能再使用这个套接字
            # client_socket.close()

    def handle_request(self, client_socket):
        """用一个新的进程为客户端服务"""
        # 1.接收浏览器发送过来的HTTP请求
        recv_data = client_socket.recv(1024).decode(‘utf-8‘, errors="ignore")
        request_header_lines = recv_data.splitlines()
        for line in request_header_lines:
            print(line)

        # GET /index.html HTTP/1.1
        http_request_line = request_header_lines[0]
        get_file_name = re.match("[^/]+(/[^ ]*)", http_request_line).group(1)
        print("file name is ===>%s" % get_file_name)

        # 如果没有指定访问哪个页面,则默认访问index.html
        # GET / HTTP/1.1
        if get_file_name == "/":
            get_file_name = DOCUMENTS_ROOT + "/index.html"
        else:
            get_file_name = DOCUMENTS_ROOT + get_file_name
        print("file name is ===2>%s" % get_file_name)

        # 2.返回HTTP格式的数据给浏览器
        try:
            f = open(get_file_name, "rb")
        except IOError:
            # 404表示没有这个页面
            response_headers = "HTTP/1.1 404 not found\r\n"
            response_headers += "\r\n"
            response_body = "====sorry, file not found====".encode("utf-8")
        else:
            # 2.1 准备发送给浏览器的数据-->header
            response_headers = "HTTP/1.1 200 OK\r\n"
            # 2.2 用一个空的行与body进行隔开
            response_headers += "\r\n"
            # 2.3 准备发送给浏览器的数据-->body
            response_body = f.read()
            f.close()
        finally:
            # 因为头信息在组织的时候,是按照字符串组织的,不能与以二进制打开文件读取的数据合并,因此分开发送
            # 先发送response的头信息
            client_socket.send(response_headers.encode("utf-8"))
            # 再发送body
            client_socket.send(response_body)
            # 关闭套接字
            client_socket.close()


# 设定服务器的地址
SERVER_ADDR = ("", 7890)
# 设置服务器静态资源的路径
DOCUMENTS_ROOT = "./html"


def main():
    http_server = WSGIServer(SERVER_ADDR)
    print("web Server: Serving HTTP on port %d ...\n" % SERVER_ADDR[1])
    http_server.serve_forever()


if __name__ == "__main__":
    main()

# html文件夹网盘链接: https://pan.baidu.com/s/1wbZ92KLstff3GurLV_C0lg  密码: hp9o
# 下载完命令行解压后放到程序的同级路径下,解压命令: tar -zxvf 06_html.tar.gz -C ./
import socket
import re
import gevent
from gevent import monkey

monkey.patch_all()


class WSGIServer:
    """定义一个WSGI服务器的类"""
    def __init__(self, server_address):
        # 1.创建数据流套接字
        self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 2.设置当服务器先close 即服务器端4次挥手之后资源能够立即释放,保证下次运行程序时可以立即绑定7890端口
        self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        # 3.绑定服务器地址
        self.tcp_server_socket.bind(server_address)
        # 4.套接字由主动改为监听,并设置队列长度
        self.tcp_server_socket.listen(128)

    def serve_forever(self):
        """循环运行服务器,等待客户端链接并为客户端服务"""
        while True:
            # 5.等待客户端链接
            client_socket, client_addr = self.tcp_server_socket.accept()
            # 6.为客户端服务
            gevent.spawn(self.handle_request, client_socket)

    def handle_request(self, client_socket):
        """用协程为客户端服务"""
        # 1.接收浏览器发送过来的HTTP请求
        recv_data = client_socket.recv(1024).decode(‘utf-8‘, errors="ignore")
        request_header_lines = recv_data.splitlines()
        for line in request_header_lines:
            print(line)

        # GET /index.html HTTP/1.1
        http_request_line = request_header_lines[0]
        get_file_name = re.match("[^/]+(/[^ ]*)", http_request_line).group(1)
        print("file name is ===>%s" % get_file_name)

        # 如果没有指定访问哪个页面,则默认访问index.html
        # GET / HTTP/1.1
        if get_file_name == "/":
            get_file_name = DOCUMENTS_ROOT + "/index.html"
        else:
            get_file_name = DOCUMENTS_ROOT + get_file_name
        print("file name is ===2>%s" % get_file_name)

        # 2.返回HTTP格式的数据给浏览器
        try:
            f = open(get_file_name, "rb")
        except IOError:
            # 404表示没有这个页面
            response_headers = "HTTP/1.1 404 not found\r\n"
            response_headers += "\r\n"
            response_body = "====sorry, file not found====".encode("utf-8")
        else:
            # 2.1 准备发送给浏览器的数据-->header
            response_headers = "HTTP/1.1 200 OK\r\n"
            # 2.2 用一个空的行与body进行隔开
            response_headers += "\r\n"
            # 2.3 准备发送给浏览器的数据-->body
            response_body = f.read()
            f.close()
        finally:
            # 因为头信息在组织的时候,是按照字符串组织的,不能与以二进制打开文件读取的数据合并,因此分开发送
            # 先发送response的头信息
            client_socket.send(response_headers.encode("utf-8"))
            # 再发送body
            client_socket.send(response_body)
            # 关闭套接字
            client_socket.close()


# 设定服务器的地址
SERVER_ADDR = ("", 7890)
# 设置服务器静态资源的路径
DOCUMENTS_ROOT = "./html"


def main():
    http_server = WSGIServer(SERVER_ADDR)
    print("web Server: Serving HTTP on port %d ...\n" % SERVER_ADDR[1])
    http_server.serve_forever()


if __name__ == "__main__":
    main()

# html文件夹网盘链接: https://pan.baidu.com/s/1wbZ92KLstff3GurLV_C0lg  密码: hp9o
# 下载完命令行解压后放到程序的同级路径下,解压命令: tar -zxvf 06_html.tar.gz -C ./
import sys
import time
import socket
import re


class WSGIServer:
    """定义一个WSGI服务器的类"""
    def __init__(self, server_addr):
        # 1.创建数据流套接字
        self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 2.设置当服务器先close 即服务器端4次挥手之后资源能够立即释放,保证下次运行程序时可以立即绑定7890端口
        self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        # 3.绑定服务器地址
        self.tcp_server_socket.bind(server_addr)
        # 4.套接字由主动改为监听,并设置队列长度
        self.tcp_server_socket.listen(128)
        # 5.设置为非堵塞后,如果accept时,恰巧没有客户端connect,那么accept会产生一个异常,所以需要try来进行处理
        self.tcp_server_socket.setblocking(False)  # 将监听套接字设置为非堵塞
        self.client_socket_list = list()  # 创建客户端client_socket轮询列表

    def serve_forever(self):
        """循环运行服务器,等待客户端链接并为客户端服务"""
        while True:
            time.sleep(1)  # for test
            try:
                # 6.等待客户端链接
                client_socket, client_addr = self.tcp_server_socket.accept()
            except Exception as ret:
                print("--->1<---没有客户端到来: ", ret)  # for test
            else:
                # 7.当有客户端连接时,将客户端的套接字加入到轮询列表
                client_socket.setblocking(False)  # 将客户端套接字设置为非堵塞
                self.client_socket_list.append(client_socket)

            # 8.遍历列表看是否有收到客户端套接字发送的消息,如果收到消息则为客户端服务
            for client_socket in self.client_socket_list:
                try:
                    # 1.接收浏览器发送过来的HTTP请求
                    request = client_socket.recv(1024).decode("utf-8", errors="ignore")
                except Exception as ret:
                    print("--->2<---这个客户端没有发送过来请求: ", ret)  # for test
                else:
                    if request:
                        # 2.1 为这个客户端服务
                        self.handle_request(request, client_socket)
                    else:
                        # 2.2 客户端调用了close导致recv返回,服务端将关闭客户端套接字并从轮询列表中删除
                        client_socket.close()
                        self.client_socket_list.remove(client_socket)

            print(self.client_socket_list)

    def handle_request(self, request, client_socket):
        """为客户端服务"""
        # 1.提取客户端发送过来的数据
        request_header_lines = request.splitlines()
        for i, line in enumerate(request_header_lines):
            print(i, line)

        # GET /index.html HTTP/1.1
        http_request_line = request_header_lines[0]
        ret = re.match(r"([^/]*)([^ ]+)", http_request_line)
        if ret:
            print("正则提取数据:", ret.group(1))
            print("正则提取数据:", ret.group(2))
            get_file_name = ret.group(2)
            # 如果没有指定访问哪个页面,则默认访问index.html
            # GET / HTTP/1.1
            if get_file_name == "/":
                get_file_name = DOCUMENTS_ROOT + "/index.html"
            else:
                get_file_name = DOCUMENTS_ROOT + get_file_name
            print("要访问的完整路径是: %s" % get_file_name)

        # 2.返回HTTP格式的数据给浏览器
        try:
            f = open(get_file_name, "rb")
        except IOError:
            # 404表示没有这个页面
            response_body = "====sorry, file not found====".encode("utf-8")
            response_headers = "HTTP/1.1 404 not found\r\n"
            response_headers += "Content-Type: text/html; charset=utf-8\r\n"
            response_headers += "Content-Length: %d\r\n" % (len(response_body))
            response_headers += "\r\n"
        else:
            # 2.1 准备发送给浏览器的数据-->body
            response_body = f.read()
            f.close()
            # 2.2 准备发送给浏览器的数据-->header
            response_headers = "HTTP/1.1 200 OK\r\n"
            # 2.3 发送body数据长度,让服务器根据长度确认body数据已完成接收,实现长连接
            response_headers += "Content-Length: %d\r\n" % (len(response_body))
            # 2.4 用一个空的行与body进行隔开
            response_headers += "\r\n"
        finally:
            # 因为头信息在组织的时候,是按照字符串组织的,不能与以二进制打开文件读取的数据合并,因此分开发送
            # 先发送response的头信息
            client_socket.send(response_headers.encode("utf-8"))
            # 再发送body
            client_socket.send(response_body)
            # 长连接下不需要关闭套接字,而是在header头中声明要发送的body长度
            # client_socket.close()


# 设置服务器静态资源的路径
DOCUMENTS_ROOT = "./html"


def main():
    # python3 xxx.py 7890
    if len(sys.argv) == 2:
        port = sys.argv[1]
        if port.isdigit():
            port = int(port)
    else:
        print("运行方式如: python3 xxx.py 7890")
        return
    server_addr = ("", port)
    http_server = WSGIServer(server_addr)
    print("web Server: Serving HTTP on port %d ...\n" % port)
    http_server.serve_forever()


if __name__ == "__main__":
    main()

# html文件夹网盘链接: https://pan.baidu.com/s/1wbZ92KLstff3GurLV_C0lg  密码: hp9o
# 下载完命令行解压后放到程序的同级路径下,解压命令: tar -zxvf 06_html.tar.gz -C ./
import sys
import socket
import re
import select


class WsgiServer:
    """定义一个WSGI服务器的类"""
    def __init__(self, server_addr):
        # 1.创建数据流套接字
        self.tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # 2.设置当服务器先close 即服务器端4次挥手之后资源能够立即释放,保证下次运行程序时可以立即绑定7890端口
        self.tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        # 3.绑定服务器地址
        self.tcp_server_socket.bind(server_addr)
        # 4.套接字由主动改为监听,并设置队列长度
        self.tcp_server_socket.listen(128)

        # 5.创建epoll对象
        self.epoll = select.epoll()
        # 6.将tcp服务器的监听套接对应的fd注册到epoll中进行监听,如果fd已经注册过,则会发生异常
        self.epoll.register(self.tcp_server_socket.fileno(), select.EPOLLIN | select.EPOLLET)
        # 7.创建添加的fd对应的套接字
        self.fd_socket = dict()

    def serve_forever(self):
        """循环运行服务器,等待客户端链接并为客户端服务"""
        # 等待新的客户端连接或者已连接的客户端发送过来数据
        while True:
            # epoll进行fd扫描的地方,未指定超时时间则为阻塞等待,直到系统检测到数据到来,通过事件通知方式告诉程序才会解阻塞
            epoll_list = self.epoll.poll()  # epoll_list列表结构: [(fd, event),]
            # fd: 套接字对应的文件描述符
            # event: 这个文件描述符到底是什么事件,例如可以调用recv接收等

            # 对事件进行判断
            for fd, event in epoll_list:
                # 如果是服务器的监听套接字被激活可以收数据,那么意味着可以进行accept,即有新的客户端连接
                if fd == self.tcp_server_socket.fileno():
                    new_socket, new_addr = self.tcp_server_socket.accept()

                    # 向epoll中注册连接socket的可读事件,EPOLLIN(可读),EPOLLOUT(可写),EPOLLET(ET模式)
                    # LT模式: 当epoll检测到描述符事件发生并将此事件通知应用程序
                    # LT模式下应用程序可以不立即处理该事件,下次调用epoll时,会再次响应应用程序并通知此事件
                    # ET模式: 当epoll检测到描述符事件发生并将此事件通知应用程序
                    # LT模式下应用程序必须立即处理该事件,如果不处理,下次调用epoll时,不会再次响应应用程序并通知此事件
                    self.epoll.register(new_socket.fileno(), select.EPOLLIN | select.EPOLLET)
                    # 记录这个信息
                    self.fd_socket[new_socket.fileno()] = new_socket
                # 如果是客户端发送数据,客户端套接字将被激活,服务器可以接收到客服端发送的数据
                elif event == select.EPOLLIN:
                    # # 从激活 fd 上接收
                    request = self.fd_socket[fd].recv(1024).decode("utf-8")
                    if request:
                        self.handle_request(request, self.fd_socket[fd])
                    else:
                        # 在epoll中注销客户端的信息
                        self.epoll.unregister(fd)
                        # 关闭客户端的文件句柄
                        self.fd_socket[fd].close()
                        # 在字典中删除与已关闭客户端相关的信息
                        del self.fd_socket[fd]

    def handle_request(self, request, client_socket):
        """为客户端服务"""
        # 1.接收浏览器发送过来的HTTP请求
        request_header_lines = request.splitlines()
        for i, line in enumerate(request_header_lines):
            print(i, line)

        # GET /index.html HTTP/1.1
        http_request_line = request_header_lines[0]
        ret = re.match(r"([^/]*)([^ ]+)", http_request_line)
        if ret:
            print("正则提取数据:", ret.group(1))
            print("正则提取数据:", ret.group(2))
            get_file_name = ret.group(2)
            # 如果没有指定访问哪个页面,则默认访问index.html
            # GET / HTTP/1.1
            if get_file_name == "/":
                get_file_name = DOCUMENTS_ROOT + "/index.html"
            else:
                get_file_name = DOCUMENTS_ROOT + get_file_name
            print("要访问的完整路径是: %s" % get_file_name)

        # 2.返回HTTP格式的数据给浏览器
        try:
            f = open(get_file_name, "rb")
        except IOError:
            # 404表示没有这个页面
            response_body = "====sorry, file not found====".encode("utf-8")
            response_headers = "HTTP/1.1 404 not found\r\n"
            response_headers += "Content-Type: text/html; charset=utf-8\r\n"
            response_headers += "Content-Length: %d\r\n" % (len(response_body))
            response_headers += "\r\n"
        else:
            # 2.1 准备发送给浏览器的数据-->body
            response_body = f.read()
            f.close()
            # 2.2 准备发送给浏览器的数据-->header
            response_headers = "HTTP/1.1 200 OK\r\n"
            # 2.3 发送body数据长度,让服务器根据长度确认body数据已完成接收,实现长连接
            response_headers += "Content-Length: %d\r\n" % (len(response_body))
            # 2.4 用一个空的行与body进行隔开
            response_headers += "\r\n"
        finally:
            # 因为头信息在组织的时候,是按照字符串组织的,不能与以二进制打开文件读取的数据合并,因此分开发送
            # 先发送response的头信息
            client_socket.send(response_headers.encode("utf-8"))
            # 再发送body
            client_socket.send(response_body)
            # 长连接下不需要关闭套接字,而是在header头中声明要发送的body长度
            # client_socket.close()


# 设置服务器静态资源的路径
DOCUMENTS_ROOT = "./html"


def main():
    # python3 xxx.py 7890
    if len(sys.argv) == 2:
        port = sys.argv[1]
        if port.isdigit():
            port = int(port)
    else:
        print("运行方式如: python3 xxx.py 7890")
        return
    server_addr = ("", port)
    http_server = WsgiServer(server_addr)
    print("web Server: Serving HTTP on port %d ...\n" % port)
    http_server.serve_forever()


if __name__ == "__main__":
    main()