[读书笔记]WebSocket服务篇

1.1.1 WebSocket概述

WebSockets通过一次握手建立连接，服务器就可以主动地向客户端发送消息。

一举淘汰了Comet和Ajax轮询（polling），长轮询（long-polling)，已经流（streaming）解决方案的。 在全双工的实时浏览器通信中，大大减少了网络流量并降低了网络延迟。

1.1.2 传统实时HTTP应用程序的复杂性

如图所示

传统的实时，体验的代价非常高，包括额外的时间延迟，不必要的网络流量和CPU性能消耗。

1.1.3 WebSocket握手

为了建立WebSocket通信，客户端和服务器在初始握手时，将HTTP协议升级到WebSocket协议

1.2 简单的WebSocket服务器

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import  asyncore

import  socket

import  struct

import  time

from  hashlib  import  sha1

from  base64  import  encodestring

class  WebSocketConnection ( asyncore  . dispatcher_with_send ):

     #初始化类

     def  __init__ ( self  ,  conn ,  server ):

        asyncore  . dispacher_with_send . __init__ ( self  ,  conn )  #每一个WebSocket连接都是一个支持缓冲发送的一步套接字包装程序

       

        self  . server  =  server

        self  . server .  session . append  ( self )

        self  . readystat  =  "connecting"

        self  . buffer  =  ""

     #读取来自客户端的数据   

     def  handle_read ( self  ):

        data  =  self .  recv ( 1024  )  #接受客户端发来的数据

        self  . buffer  +=  data     #接收到的数据添加到缓冲区中

         if  self .  readystat  ==  "connecting" :

            self  . parse_connnecting ()  #如果是连接状态，则进行连接数据解析

         elif  self .  readystat  ==  "open" :

            selft  . parse_frametype ()  #如果是打开状态， 解析数据帧类型

     #关闭连接       

     def  handle_close ( self  ):

        self  . server .  sessions . remove  ( self )

        self  . close ()

       

     #解客户端的连接数据

     def  parse_connnecting ( self  ):

        header_end  =   self . buffer . find  ( "\r\n\r\n" )  #计算数据结束的位置

         if  header_end  ==  - 1  :

             return

         else :

            header  =  self .  buffer [: header_end  ]  #取开头的数据

           

            self  . buffer  =  self . buffer  [ header_end  +  4 :]  #删除开头的数据及\r\n\r\n

            header_lines  =  header . split ( "\r\n"  )

            headers  =  {}

             #HTTP请求header数据类似

             #GET /chat HTTP/1.1   (第一行数据)

             #Host: example.com

             #...

            method  ,  path ,  protocal  =  header_lines  [ 0 ].  split ( " "  )

             if  method  !=  "GET"  or  protocal  !=  "HTTP/1.1"  or  path [  0 ]  !=  "/" :

                self  . terminate ()  #格式有误，终止连接

                 return

             #解析头部信息key，value，类似Host: example.com

             for  line  in  header_lines [ 1  :]:

                key  ,  value  =  line . split  ( ": " )

                headers  [ key ]  =  value

            headers  [ "Location" ]  =  "ws://"  +  headers [ "Host"  ]  +  path

            self  . readystate  =  "open"

            self  . handler  =  self . server  . handlers . get ( path  ,  None  )( self )

             if  "Sec-WebSocket-Key1"  in  headers . keys  ():

                self  . send_server_handshake_76 ( headers )

             else :

                self  . send_server_handshake_75 ( headers )

     #终止连接       

     def  terminate ( self  ):

        self  . ready_state  =  "closed"

        self  . close ()

     #v.76版本的websocket协议返回信息  

     def  send_server_handshake_76 ( self  ,  headers ):

         """

        Send the WebSocket Protocol v.76 handshake response

        """

        key1  =  headers [ "Sec-WebSocket-Key1"  ]

        key2  =  headers [ "Sec-WebSocket-Key2"  ]

         # read additional 8 bytes from buffer

        key3  ,  self .  buffer  =  self  . buffer [:  8 ],  self  . buffer [  8 :]

         #应答的token

        response_token  =  self .  calculate_key ( key1  ,  key2 ,  key3 )

         # write out response headers

        self  . send_bytes ( "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" )

        self  . send_bytes ( "Upgrade: WebSocket\r\n"  )

        self  . send_bytes ( "Connection: Upgrade\r\n"  )

        self  . send_bytes ( "Sec-WebSocket-Origin: %s\r\n"  %  headers [ "Origin" ])

        self  . send_bytes ( "Sec-WebSocket-Location: %s\r\n"  %  headers [ "Location" ])

         if  "Sec-WebSocket-Protocol"  in  headers :

            protocol  =  headers [ "Sec-WebSocket-Protocol"  ]

            self  . send_bytes ( "Sec-WebSocket-Protocol: %s\r\n"  %  protocol )

        self  . send_bytes ( "\r\n"  )

         # write out hashed response token

        self  . send_bytes ( response_token )

     #计算key

     def  calculate_key ( self  ,  key1 ,  key2 ,  key3  ):

         # parse keys 1 and 2 by extracting numerical characters

        num1  =  int (  "" . join  ([ digit  for  digit  in  list  ( key1 )  if  digit . isdigit ()]))

        spaces1  =  len ([  char  for  char  in  list (  key1 )  if  char  ==  " "  ])

        num2  =  int (  "" . join  ([ digit  for  digit  in  list  ( key2 )  if  digit . isdigit ()]))

        spaces2  =  len ([  char  for  char  in  list (  key2 )  if  char  ==  " "  ])

        combined  =  struct . pack ( ">II"  ,  num1 /  spaces1 ,  num2  / spaces2 )  +  key3

         # md5 sum the combined bytes

         return  hashlib . md5 ( combined  ). digest ()

     #v.75版本的websocket协议返回信息  

     def  send_server_handshake_75 ( self  ,  headers ):

         """

        Send the WebSocket Protocol v.75 handshake response

        """

        self  . send_bytes ( "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" )

        self  . send_bytes ( "Upgrade: WebSocket\r\n"  )

        self  . send_bytes ( "Connection: Upgrade\r\n"  )

        self  . send_bytes ( "WebSocket-Origin: %s\r\n"  %  headers [ "Origin"  ])

        self  . send_bytes ( "WebSocket-Location: %s\r\n"  %  headers [ "Location" ])

         if  "Protocol"  in  headers :

            self  . send_bytes ( "WebSocket-Protocol: %s\r\n"  %  headers [ "Protocol" ])

        self  . send_bytes ( "\r\n"  )

     #解析 数据帧类型

     def  parse_frametype ( self  ):

         while  len (  self . buffer  ):

            type_byte  =  self .  buffer [ 0  ]

             if  type_byte  ==  "\x00" :

                 if  not  self . parse_textframe  ():

                     return

     #解析 文本帧

     def  parse_textframe ( self  ):

        terminator_index  =  self .  buffer . find  ( "\xFF" )

         if  terminator_index  !=  - 1  :

            frame  =  self .  buffer [ 1  : terminator_index ]

            self  . buffer  =  self . buffer  [ terminator_index + 1 :]

            s  =  frame .  decode ( "UTF8"  )

            self  . handler . dispatch ( s  )

             return  True

         else :

             # incomplete frame

             return  false

     #发送数据

     def  send ( self  ,  s ):

         if  self .  readystate  ==  "open" :  #打开状态下，才发送

            self  . send_bytes ( "\x00"  )  #发送数据头部

            self  . send_bytes ( s . encode  ( "UTF8" ))

            self  . send_bytes ( "\xFF"  )  #发送数据尾部

     def  send_bytes ( self  ,  bytes ):

        asyncore  . dispatcher_with_send . send ( self  ,  bytes )

#输出控制器

class  EchoHandler ( object  ):

     """

    The EchoHandler repeats each incoming string to the same websocket

    """

     def  __init__ ( self  ,  conn ):

        self  . conn  =  conn

       

     def  dispatch ( self  ,  data ):

         try :

            self  . conn .  send ( data  )  #发送数据

         except :

             pass

#web服务      

class  WebSocketServer ( asyncore  . dispatcher ):

     def  __init__ ( self  ,  port =  80 ,  handlers  = None ):

        asyncore  . dispatcher . __init__ ( self  )

        self  . handlers  =  handlers

        self  . sessions  =  []

        self  . port  =  port

        self  . create_socket ( socket . AF_INET  ,  socket . SOCK_STREAM )

        self  . set_reuse_addr ()

        self  . bind ((  "" ,  port  ))

        self  . listen (  5 )

     def  handle_accept ( self  ):

        conn  ,  addr  =  self . accept  ()

        session  =  WebSocketConnection ( conn ,  self  )  #处理websocket服务

#主函数

if  __name__  ==  "__main__" :

     print  "Starting WebSocket Server"

    WebSocketServer ( port  = 8080 ,  handlers ={ "/echo"  :  EchoHandler })

    asyncore . loop  ()