-
Notifications
You must be signed in to change notification settings - Fork 0
/
websocket_go.go
126 lines (99 loc) · 2.14 KB
/
websocket_go.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
// +build !js
package ninchat
import (
"encoding/json"
"sync"
"time"
"github.com/gorilla/websocket"
)
const webSocketSupported = true
type webSocket struct {
notify chan struct{}
goingAway bool
err error
conn *websocket.Conn
lock sync.Mutex
buf [][]byte
}
func newWebSocket(host string, header map[string][]string, timeout duration, log func(...interface{})) *webSocket {
dialer := &websocket.Dialer{
TLSClientConfig: &tlsConfig,
HandshakeTimeout: time.Duration(timeout),
}
ws := &webSocket{
notify: make(chan struct{}, 1),
}
ws.conn, _, ws.err = dialer.Dial("wss://"+host+socketPath, prepareHeader(header))
if ws.err != nil {
close(ws.notify)
return ws
}
ws.notify <- struct{}{}
go func() {
defer close(ws.notify)
for {
var (
typ int
data []byte
)
if typ, data, ws.err = ws.conn.ReadMessage(); ws.err != nil {
if err, ok := ws.err.(*websocket.CloseError); ok {
ws.goingAway = (err.Code == websocket.CloseGoingAway)
}
return
}
switch typ {
case websocket.TextMessage, websocket.BinaryMessage:
ws.lock.Lock()
ws.buf = append(ws.buf, data)
ws.lock.Unlock()
select {
case ws.notify <- struct{}{}:
default:
}
default:
// XXX: is this possible?
}
}
}()
return ws
}
func (ws *webSocket) sendInitialJSON(object interface{}) error {
return ws.sendJSON(object)
}
func (ws *webSocket) send(data []byte) error {
return ws.conn.WriteMessage(websocket.BinaryMessage, data)
}
func (ws *webSocket) sendJSON(object interface{}) error {
return ws.conn.WriteJSON(object)
}
func (ws *webSocket) sendPayload(action *Action) (err error) {
for _, data := range action.Payload {
if err = ws.send(data); err != nil {
return
}
}
return
}
func (ws *webSocket) receive() (data []byte) {
ws.lock.Lock()
defer ws.lock.Unlock()
if len(ws.buf) > 0 {
data = ws.buf[0]
ws.buf = ws.buf[1:]
}
return
}
func (ws *webSocket) receiveJSON() (object map[string]interface{}, err error) {
x := ws.receive()
if x == nil {
return
}
err = json.Unmarshal(x, &object)
return
}
func (ws *webSocket) close() {
if ws.conn != nil {
ws.conn.Close()
}
}