웹 socket 에서 protobuf 요청 을 전송 합 니 다. 작은 프로그램 에서 protobuf 요청 을 받 아 tcp 서비스 로 전송 한 다음 tcp 서비스의 응답 을 작은 프로그램 으로 전송 합 니 다.

package main

import (
    "flag"
    "net"
    "github.com/BurntSushi/toml"
    "github.com/gorilla/websocket"
    "log"
    "net/http"
    "runtime"
    "encoding/binary"
    "zonst/logging"
    "zonst/qipai/fsnotifyutil"
    "zonst/qipai/messages"
)

var listenAddr string
var tomlFile string

// var pid int

func init() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    flag.StringVar(&listenAddr, "listenAddr", ":10000", "server listen addr")
    flag.StringVar(&tomlFile, "tomlFile", "docs/test.toml", "server TOML config file")
}

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool { return true },
}

func (c *Context) echo(w http.ResponseWriter, r *http.Request) {
    conn, _ := upgrader.Upgrade(w, r, nil)
    //  protobuf tcp    
    tcpConn, err := net.Dial("tcp", "xxx.xx.xx.xxx:10000")
    if err != nil {
        logging.Errorf("connect tcp err : %v 
", err)
        return
    }

    logging.Debugf("connect tcp server success %v 
", tcpConn)

    go c.ReadWebsocket(conn, tcpConn)
    go c.ReadTcp(conn, tcpConn)
}

func (c *Context) ReadWebsocket(conn *websocket.Conn, tcpConn net.Conn) {
    for {
        //mtype :TextMessage=1/BinaryMessage=2/CloseMessage=8/PingMessage=9/PongMessage=10
        mtype, msg, _ := conn.ReadMessage()
        logging.Debugf("mtype %v 
", mtype)
        logging.Debugf("msg %v 
", msg)
        switch mtype {
        case 2:
            logging.Debugf("      ： %v 
", binary.Size(msg))
            //protobuf messageID
            protoMsgID := int32(msg[4])

            //   
            protoMsgContent := msg[8:]
            logging.Debugf("msg content : %v 
", string(msg))
            // n, err := c.ProxyConn.Write(protoMsgContent)
            // logging.Debugln("=======================websocket write:", n, err)
            switch protoMsgID {
            case int32(messages.ProConnectRequest_ID):
                logging.Debugf("     : %v 
", protoMsgID)
                n, err := tcpConn.Write(msg)
                logging.Debugln("=======================websocket write:", n, err)
                // return
            case int32(messages.ProHeartBeatRequest_ID):
                logging.Debugf("    : %v 
", protoMsgID)
                n, err := tcpConn.Write(msg)
                logging.Debugln("=======================websocket write:", n, err)
                // n, err := c.ProxyConn.Write(protoMsgContent)
                // logging.Debugln("=======================websocket write:", n, err)
                // return
            case int32(messages.ProSocketCloseRequest_ID):
                logging.Debugf("     : %v 
", protoMsgID)
                n, err := tcpConn.Write(msg)
                logging.Debugln("=======================websocket write:", n, err)
                // return
            case int32(messages.ProForceUserOfflineRequest_ID):
                logging.Debugf("     : %v 
", protoMsgID)
                // return
            default:
                logging.Debugf("   : %v 
", protoMsgID)
                _, err := tcpConn.Write(msg)
                if err != nil {
                    logging.Errorf("tcpConn.Write err : %v
", err)
                }
                // logging.Debugln("=======================websocket write:", n, err)

                // return
            }
        default:
            conn.Close()
            return
        }
    }
}
func (c *Context) ReadTcp(conn *websocket.Conn, tcpConn net.Conn) {

    var (
        buf []byte
    )
    buf = make([]byte, 1024)
    for {
        length, err := tcpConn.Read(buf)
        // logging.Debugf("     tcp return content ================= tcpConn : %v 
", tcpConn)
        if err != nil {
            logging.Errorf("tcp conn err : %v 
", err)
            // tcpConn.Close()
            // conn.Close()
            break
        }

        logging.Debugf("   tcp   ================== : %v 
", string(buf[:length]))
        conn.WriteMessage(2, buf[:length])
    }
}

func main() {
    flag.Parse()

    // Context   
    c := NewContext()
    //   TOML  
    if _, err := toml.DecodeFile(tomlFile, &c.TOMLConfig); err != nil {
        logging.Errorf("TOML:DecodeFile: %v
", err)
        return
    }
    logging.Debugf("Config: %#v
", c.TOMLConfig)
    logging.Debugf("MetricConfig: %#v
", c.TOMLConfig.MetricConfig)

    //   TOML         
    if err := c.Init(); err != nil {
        logging.Errorf("Context Init: %v
", err)
        return
    }

    http.HandleFunc("/", c.echo)

    log.Fatal(http.ListenAndServe(listenAddr, nil))

}