由於要在頁面上呼叫後臺的一個shell程式，但是這個shell執行時間很長，如果非同步獲取shell的輸出？而不必漫長的等待shell執行完畢才會一下把資料全部輸出？

我們知道原生的http協議不可能完成這個要求，除非你把輸出更新到一個文本里，然後用js倫詢去取，這不扯淡嗎

因為是內部的程式，當然有這樣要求的程式基本都是內部，或者小團體使用，所以，嘗試一下websocket吧

先研究一下websocket協議

首先是握手 handleshake

        GET /chat HTTP/1.1
        Host: server.example.com
        Upgrade: websocket
        Connection: Upgrade
        Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
        Origin: http://example.com
        Sec-WebSocket-Protocol: chat, superchat
        Sec-WebSocket-Version: 13

然後伺服器會返回這麼一個頭給客戶端

        HTTP/1.1 101 Switching Protocols
        Upgrade: websocket
        Connection: Upgrade
        Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
        Sec-WebSocket-Protocol: chat

其中有一個注意點

Sec-WebSocket-Key和

Sec-WebSocket-Accept

公式如下

Sec-WebSocket-Accept = base64(sha1(Sec-WebSocket-Key+258EAFA5-E914-47DA-95CA-C5AB0DC85B11))

"+"號不算在內

具體python程式碼如下

# -*- coding: utf8 -*-

import socket
import time
from threading import Thread
import hashlib
import base64
class returnCrossDomain(Thread):
    def __init__(self,connection):
        Thread.__init__(self)
        self.con = connection
        self.isHandleShake = False
    def run(self):
        while True:
            if not self.isHandleShake: #握手
                clientData  = self.con.recv(1024)
                dataList = clientData.split("\r\n")
                header = {}
                print clientData
                for data in dataList:
                    if ": " in data:
                        unit = data.split(": ")
                        header[unit[0]] = unit[1]
                secKey = header['Sec-WebSocket-Key'];
                resKey = base64.encodestring(hashlib.new("sha1",secKey+"258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest()).replace('\n','');

                response = '''HTTP/1.1 101 Switching Protocols\r\n'''
                response += '''Upgrade: websocket\r\n'''
                response += '''Connection: Upgrade\r\n'''
                response += '''Sec-WebSocket-Accept: %s\r\n'''%(resKey,)
                response += '''Sec-WebSocket-Protocol: chat\r\n\r\n'''
                self.con.send(response)
                self.isHandleShake = True
            else:
                data = self.con.recv(1024)
                print data

def main():
    sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    sock.bind(('',88))
    sock.listen(100)
    while True:
        try:
            connection,address = sock.accept()
            returnCrossDomain(connection).start()
        except:
            time.sleep(1)

if __name__=="__main__":
    main()
 

js程式碼如下

var socket = new WebSocket('ws://localhost:88');
socket.onopen = function() {
        alert(1);
}

順利彈出1

下邊開始研究資料傳輸 有一個問題折騰了我好久，就是因為我複製的時候沒有把這個頭給去掉，導致瀏覽器一直收不到資訊，我鬱悶阿

response += '''Sec-WebSocket-Protocol: chat\r\n\r\n'''

這句話的意思就是，使用chat這個協議，而不使用websocket協議，所以我按照websocket協議來，肯定怎麼都收不到資料，去掉之後，果斷成功

websocket的資料傳輸部分有點小麻煩，老版本的websocket 是很簡單的，每條訊息都是 一個0xFF打頭,0x00結尾，很容易，但是肯定會引發安全問題

新版本的協議如下

服務端從客戶端讀資料

1.讀1Byte位元組，注意是Byte=8bits，這個要注意，奶奶的，剛看說明文件的時候，看過了，怎麼也看不懂

這1個Byte分 8個bit  ，前4個bit 不去研究，後4個bit代表這個資料段的作用，比如是一條資料，一條socket關閉資訊等，

獲取這四個位元組很簡單

data_head = self.con.recv(1)
header = struct.unpack("B",data_head)[0]
opcode = header & 0b00001111

      *  %x0 denotes a continuation frame

      *  %x1 denotes a text frame

      *  %x2 denotes a binary frame

      *  %x3-7 are reserved for further non-control frames

      *  %x8 denotes a connection close

      *  %x9 denotes a ping

      *  %xA denotes a pong

      *  %xB-F are reserved for further control frames

2.再讀取1個byte注意是byte=8個bits

這8個bits分兩端，第一bit代表是否masking，我的理解就是是否加密

後7個bits代表著真正資料的長度payloadlength，如果payloadlength<=125那麼資料長度就是payloadlength，如果payloadlength=126,那麼就再去2Bytes的unsiged integer，來代表資料長度，如果payloadlength = 127 那麼 就再讀8個位元組的unsignedlonglong,具體程式碼如下

data_length = self.con.recv(1)
data_lengths= struct.unpack("B",data_length)
data_length = data_lengths[0]& 0b01111111
print bin(data_lengths[0])
masking = data_lengths[0] >> 7

if data_length<=125:
     payloadLength = data_length
elif data_length==126:
     payloadLength = struct.unpack("H",self.con.recv(2))[0]
elif data_length==127:
     payloadLength = struct.unpack("Q",self.con.recv(8))[0]
print "字串長度是:%d"%(data_length,)

如果masking==1

那麼就讀取4個Bytes

然後按照長度讀取資料，進行解密工作，具體程式碼和演算法如下

如果masking==0

那麼就直接讀取剛才計算得到的資料長度的資料了

                   if masking==1:
                        print "是masking"
                        maskingKey = self.con.recv(4)
                        self.maskingKey = maskingKey
                    data = self.con.recv(payloadLength)
                    i = 0
                    true_data = ''
                    for d in data:
                        true_data += chr(ord(d) ^ ord(maskingKey[i%4]))
                        i += 1
                    self.onData(true_data)

傳送資料很簡單，和接收資料一樣的格式，不過我們就不用masking 加密了，所以第二個位元組的第一個bit設為0

具體程式碼如下

def sendData(self,text) :
        print "給客戶端傳送資訊%s"%(text,)
        #頭
        self.con.send(struct.pack("!B",0x81))
        #計算長度
        length = len(text)
       # masking = 0b00000000;

        if length<=125:
            self.con.send(struct.pack("!B",length))

        elif length<=65536:
            self.con.send(struct.pack("!B",126))
            self.con.send(struct.pack("!H",length))
        else:
            self.con.send(struct.pack("!B",127))
            self.con.send(struct.pack("!Q",length))

        self.con.send(struct.pack("!%ds"%(length,),text))

具體的程式碼可以去我的git上下載,我已經封裝好了模組，對應的js也有一個寫好的類，裡邊有demo 歡迎大家嘗試