/
client.go
129 lines (104 loc) · 2.38 KB
/
client.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
127
128
129
package engineio
import (
"fmt"
"io"
"net"
"net/http"
"net/url"
"sync"
"time"
"github.com/googollee/go-socket.io/engineio/frame"
"github.com/googollee/go-socket.io/engineio/packet"
"github.com/googollee/go-socket.io/engineio/session"
"github.com/googollee/go-socket.io/engineio/transport"
)
// Pauser is connection which can be paused and resumes.
type Pauser interface {
Pause()
Resume()
}
// Opener is client connection which need receive open message first.
type Opener interface {
Open() (transport.ConnParameters, error)
}
type client struct {
conn transport.Conn
params transport.ConnParameters
transport string
context interface{}
close chan struct{}
closeOnce sync.Once
}
func (c *client) SetContext(v interface{}) {
c.context = v
}
func (c *client) Context() interface{} {
return c.context
}
func (c *client) ID() string {
return c.params.SID
}
func (c *client) Transport() string {
return c.transport
}
func (c *client) Close() error {
c.closeOnce.Do(func() {
close(c.close)
})
return c.conn.Close()
}
func (c *client) NextReader() (session.FrameType, io.ReadCloser, error) {
for {
ft, pt, r, err := c.conn.NextReader()
if err != nil {
return 0, nil, err
}
switch pt {
case packet.PONG:
if err = c.conn.SetReadDeadline(time.Now().Add(c.params.PingInterval + c.params.PingTimeout)); err != nil {
return 0, nil, err
}
case packet.CLOSE:
c.Close()
return 0, nil, io.EOF
case packet.MESSAGE:
return session.FrameType(ft), r, nil
}
r.Close()
}
}
func (c *client) NextWriter(typ session.FrameType) (io.WriteCloser, error) {
return c.conn.NextWriter(frame.Type(typ), packet.MESSAGE)
}
func (c *client) URL() url.URL {
return c.conn.URL()
}
func (c *client) LocalAddr() net.Addr {
return c.conn.LocalAddr()
}
func (c *client) RemoteAddr() net.Addr {
return c.conn.RemoteAddr()
}
func (c *client) RemoteHeader() http.Header {
return c.conn.RemoteHeader()
}
func (c *client) serve() {
defer c.conn.Close()
for {
select {
case <-c.close:
return
case <-time.After(c.params.PingInterval):
}
w, err := c.conn.NextWriter(frame.String, packet.PING)
if err != nil {
return
}
if err := w.Close(); err != nil {
return
}
if err = c.conn.SetWriteDeadline(time.Now().Add(c.params.PingInterval + c.params.PingTimeout)); err != nil {
fmt.Printf("set writer's deadline error,msg:%s\n", err.Error())
}
}
}