PYTHON2.day09-程序员宅基地

前倾回顾
1.总结进程线程的区别
2.网络通信模型
   [1] 循环模型：循环接收请求处理请求，每次同时只能处理一个请求
   [2]IO并发模型，可以同时处理多个IO请求
   [3]多进程/多线程网络并发：可以互不影响处理多个任务
3.基于fork的多进程并发
4.ftp文件服务模型
*****************************************************
一.基于threading的多线程网络并发
    [1]实现原理：每当一个客户端发起请求，就创建一个新的线程处理客户端具体请求，主线程循环等待处理其他客户端连接。
    [2]实现步骤：
             1.创建监听套接字
             2.循环接收客户端请求连接
             3.当有新的客户端连接创建线程处理客户端请求
             4.主线程继续等待其他客户端连接
             5.当客户端退出，则对应
            
二.集成模块完成多进程/多线程网并发
   1. import sockectserver
    *通过模块提供的不同的类的组合来完成多进程或者多线程
     .tcp 或udp的网路并发模型
    
     2.常用类说明
         TCPServer:创建TCP服务端套接字
         UDPServer:创建UDP服务端套接字
        
         StreamRequestHandler:处理TCP客户端请求
         DatageramRequestHandler:处理udp客户端请求
        
         ForkingMinIn :创建多进程并发
         ForkingTCPServer :ForkingMinIn + TCPServer
         ForkingUDPServer  :ForkingMinIn + UDPServer
        
         ThreadingMixIn :创建多线程并发
         ThreadingTCPServer     :ThreadingMixIn + TCPServer
         ThreadingUDPServer  :ThreadingMixIn + UDPServer
     3.步骤
         1.创建服务器类，通过选择继承的类，决定创建TCP或者UDP,
           多进程或者多线程确定定法类型
         2.创建请求处理类,根据服务类型选择stream处理类还是Datager处理类。重写handle方法，左具体的请求处理
         3. 通过服务器类创建服务器对象，并绑定请求处理类
         4.通过富强武器对象，调用server_forever()启动服务
        
三.HTTPServer  v2.0
     1.主要功能：
         1.接收客户端(浏览器)请求
         2.解析客户端发送的请求
         3.根据请求组织数据内容
         4.将数据内容形参http响应格式返回给浏览器
     2.升级点
         1.采用多线程并发，可以满足多个客户端同时同时发起请求情况
         2.做基本的请求解析，根据具体的请求返回具体内容，
           同时满足客户端点单的非网页请求情况
         3.通过类接口形式进行功能封装
     3.技术点
         1.HTTP协议要求数据传输使用tcp套接字
         2.httpserver采用多线程并发网络模型
         3.类的封装接口
         4.http协议的请求和响应格式
        
         http请求：
             请求行：GET   /abc.html    HTTP/1.1
             请求头：
             空行
             请求体

        http响应：
             响应行：HTTP/1.1   200   OK
             响应头
             空行
             响应体：返回的数据内容
  

'''
HTTP Server v2.0
*多线程并发
*基本的request解析
*能够反馈基本数据
*使用类封装
'''

from socket  import *
from threading import Thread
import sys


#封装具体的类作为THHP Server功能模块
class HTTPServer(object):
    def __init__(self,server_addr,static_dir):
        #添加对象属性
        self.server_address = server_addr#属性
        self.static_dir = static_dir
        self.create_socket()
        self.bind()

    def create_socket(self):
        self.sockfd = socket()
        self.sockfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

    def bind(self):
        self.sockfd.bind(self.server_address)
        self.ip = self.server_address[0]
        self.port =self.server_address[1]
    #启动服务
    def serve_forever(self):
        self.sockfd.listen(5)
        print('Listen the port %d'%self.port)
        while True:
            try:
                connfd,addr = self.sockfd.accept()
            except KeyboardInterrupt:
                self.sockfd.close()
                sys.exit("退出服务器")
            except Exception as e:
                print("Error:",e)
                continue
            #创建多线程处理请求
            clientThread = Thread(target = self.handle,args=(connfd,))
            clientThread.setDaemon(True)
            clientThread.start()

    #具体处理thhp请求
    def handle(self,connfd):
        #接受ＨＴＴＰ请求
        request = connfd.recv(4096)
        #防止浏览器异常断开
        if not request:
            connfd.close()
            return
        #请求解析
        requestHeaders = request.splitlines()
        print(connfd.getpeername(),":",requestHeaders[0])
        #获取请求内容
        getRequest = str(requestHeaders[0]).split(' ')[1]

        if getRequest =='/' or getRequest[-5:]=='.html':
            self.get_html(connfd,getRequest)
        else:
            print("想获取其他内容")
        connfd.close()

    def get_html(self,connfd,getRequest):
        if getRequest =='/':
            filename = self.static_dir + '/manager.html'
        else:
            filename =self.static_dir + getRequest
        try:
            f = open(filename)
        except IOError:
            #没有找到网页
            responseHeaders = "HTTP/1.1 404 Not Found\r\n"
            responseHeaders += '\r\n'
            responseBody = "Sorry,Not found the page"
        else:
            #返回网页内容
            responseHeaders = "HTTP/1.1 200 OK\r\n"
            responseHeaders +="\r\n"
            responseBody = f.read()
        finally:
            response =  responseHeaders + responseBody
            connfd.send(response.encode())#发给客户端

    def get_data(self,connfd,getRequest):
        responseHeaders = "HTTP/1.1 200 OK\r\n"
        responseHeaders += '\r\n'
        responseBody ="<p>waiting httpserver v3.0</p>"
        response =  responseHeaders + responseBody
        connfd.send(response.encode())#发给客户端


if __name__=="__main__":
    #使用者自己设定ress
    server_addr = ('0.0.0.0',8000)
    #用户提供存放网页的目录
    static_dir ="./static"
    #创富强武器对象
    httpd = HTTPServer(server_addr,static_dir)
    #启动服务
    httpd.serve_forever()

四.    协程技术
     1.定义：纤程。微线程。是为非抢占多任务产生子程序的计算机组件。
             协程允许不同入口点在不同位置暂停或开始，
             简单来说，
             协程就是可以暂停的执行的函数
     * yield可以实现上述函数暂停执行功能，
                     即yield是python内部实现协程的基础关键字
     *协程的本质其实是一个单线程程序,不会使用计算机多核资源
      
     2.协程原理：记录一个函数的上下文栈帧，协程调度切换时会记录的上下文保存，
                 在切换回来时进行调取，恢复原有的执行内容，
                 以便从上一次执行位置继续执行
                
     3.协程优缺点
         优点：【1】协程完成多任务占用计算资源很少
               【2】由于协程的多任务切换在应用层完成，因此切换开销少
               【3】协程为单线程程序，无需进程共享资源同步互斥处理
              
         缺点：【1】无法利用计算机的多核资源
        
     4.利用协程模块完成协程
         【1】greenlet模块
             1.安装  sudo pip3 install greenlet
             2.函数 
                     greenlet.greenlet(func)
                     功能：创建协程对象
                     参数：协程函数
                    
                     g.switch()
                     功能：选择要执行的协程函数
            

from greenlet import greenlet

def test1():
    print("执行test1")
    gr2.switch()
    print("结束test2")
    gr2.switch()

def test2():
    gr1.switch()
    print("执行test1")
    print("结束test2")

#将函数变为协程
gr1 = greenlet(test1)
gr2 = greenlet(test2)


#启动协程
gr1.switch() #执行协程1

       
         【2】gevent
             1.安装：sudo pip3 install gevent
             2.函数：
                     gevent.spawn(func,argv)
                     功能：生成协程对象
                     参数：func 协程函数
                           argv 给协程函数传参(不定参)
                     返回值：协程对象
                     gevent.joinall(list,[timeout])
                     功能：阻塞等待协程执行完毕
                     参数：list 协程对象列表
                           timeout 超时时间
                     gevent.sleep(sec)
                     功能：gevent睡眠阻塞
                     参数：睡眠时间   

                    * gevent协程 只有在遇到gevent指定的阻塞行为时才会自动在协程之间进行跳转
                       如：gevent.joinall(),gevent.sleep()带来阻塞

import gevent
from gevent import spawn

def foo():
    print("Running foo")
    gevent.sleep(3)
    print("Foo again")

def bar():
    print("Running bar")
    gevent.sleep(2)
    print("Bar again")

f = gevent.spawn(foo)
b = gevent.spawn(bar)
gevent.joinall([f,b])

# from gevent import spawn,sleep,joinall

# def foo():
#     print("Running foo")
#     sleep(3)
#     print("Foo again")

# def bar():
#     print("Running bar")
#     sleep(2)
#     print("Bar again")
# f = spawn(foo)
# b = spawn(bar)
# joinall([f,b])

作业：1.梳理之前的项目代码思路
       2.复习mysql数据库用法                     
                    
                    
        
                
    
            
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

'''
HTTP Server v2.0
*多线程并发
*基本的request解析
*能够反馈基本数据
*使用类封装
'''

from socket  import *
from threading import Thread
import sys


#封装具体的类作为THHP Server功能模块
class HTTPServer(object):
    def __init__(self,server_addr,static_dir):
        #添加对象属性
        self.server_address = server_addr#属性
        self.static_dir = static_dir
        self.create_socket()
        self.bind()

    def create_socket(self):
        self.sockfd = socket()
        self.sockfd.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)

    def bind(self):
        self.sockfd.bind(self.server_address)
        self.ip = self.server_address[0]
        self.port =self.server_address[1]
    #启动服务
    def serve_forever(self):
        self.sockfd.listen(5)
        print('Listen the port %d'%self.port)
        while True:
            try:
                connfd,addr = self.sockfd.accept()
            except KeyboardInterrupt:
                self.sockfd.close()
                sys.exit("退出服务器")
            except Exception as e:
                print("Error:",e)
                continue
            #创建多线程处理请求
            clientThread = Thread(target = self.handle,args=(connfd,))
            clientThread.setDaemon(True)
            clientThread.start()

    #具体处理thhp请求
    def handle(self,connfd):
        #接受ＨＴＴＰ请求
        request = connfd.recv(4096)
        #防止浏览器异常断开
        if not request:
            connfd.close()
            return
        #请求解析
        requestHeaders = request.splitlines()
        print(connfd.getpeername(),":",requestHeaders[0])
        #获取请求内容
        getRequest = str(requestHeaders[0]).split(' ')[1]

        if getRequest =='/' or getRequest[-5:]=='.html':
            self.get_html(connfd,getRequest)
        else:
            print("想获取其他内容")
        connfd.close()

    def get_html(self,connfd,getRequest):
        if getRequest =='/':
            filename = self.static_dir + '/manager.html'
        else:
            filename =self.static_dir + getRequest
        try:
            f = open(filename)
        except IOError:
            #没有找到网页
            responseHeaders = "HTTP/1.1 404 Not Found\r\n"
            responseHeaders += '\r\n'
            responseBody = "Sorry,Not found the page"
        else:
            #返回网页内容
            responseHeaders = "HTTP/1.1 200 OK\r\n"
            responseHeaders +="\r\n"
            responseBody = f.read()
        finally:
            response =  responseHeaders + responseBody
            connfd.send(response.encode())#发给客户端

    def get_data(self,connfd,getRequest):
        responseHeaders = "HTTP/1.1 200 OK\r\n"
        responseHeaders += '\r\n'
        responseBody ="<p>waiting httpserver v3.0</p>"
        response =  responseHeaders + responseBody
        connfd.send(response.encode())#发给客户端


if __name__=="__main__":
    #使用者自己设定ress
    server_addr = ('0.0.0.0',8000)
    #用户提供存放网页的目录
    static_dir ="./static"
    #创富强武器对象
    httpd = HTTPServer(server_addr,static_dir)
    #启动服务
    httpd.serve_forever()