Golang Long Connection

This is a creation in Article, where the information may have evolved or changed.

Design ideas: Each websocket allows the connection is time-limited, after timeout, the server will automatically disconnect, then the long connection on the service side after the disconnection information sent by the client to detect the disconnection information to initiate a connection request, and then through the handshake information to ensure that the client is connected with the servers.

Design structure:

[Plain]View Plain Copy  

2. Type Longsocket struct {
4. Ws *websocket. Conn
6. Writech Chan []byte
8. READCH Chan []byte
10. shakehand BOOL
12. URL string
14. Protocol string
16. Origin string
18. buffersize int
20. Status int
22. Mu sync. Mutex
24. }

The long connection actively sends a message to the connecting party via the ' Writech ' channel, reading the information in the connection through the ' READCH ' channel, setting ' Shakehand ' to determine whether to send the handshake information, status to identify the connection status.

Through the Writeloop to send handshake information, while listening to the ' Writech ' channel, forward the message in the channel.

[Plain]View Plain Copy  

2. Call Func with a gorouting, it'll send shake hands message to service to make sure
4. If you want to send message call func ' Write ', and the case Writech'll be vaild
6. Func (L *longsocket) Writeloop () {
8. Defer func () {
10. If err: = Recover (); Err! = Nil {
12. Fmt. Println ("Writeloop", err)
14. }
16. }()
20. for {
22. ErrCount: = 0
24. If l.status! = status_connect {
26. Break
28. }
30. Select {
32. Case <-time. After (time. Second * time. Duration (shake_hands_frequency)):
34. If L.shakehand {
36. _, Err: = L.ws.write ([]byte (SHAKE_HANDS_MSG))
38. If err! = Nil {
40. errcount++
42. }
44. }
46. Case msg: = <-l.writech:
48. _, Err: = L.ws.write (msg)
50. If err! = Nil {
52. errcount++
54. }
56. }
60. If ErrCount! = 0 {
62. Break
64. }
66. }
68. L.close ()
70. }

The message is received via Readloop and forwarded to the ' READCH ' channel.

[Plain]View Plain Copy  

2. Read Message form socket and write them to READCH
4. Func (L *longsocket) Readloop () {
6. Defer func () {
8. If err: = Recover (); Err! = Nil {
10. Fmt. Println ("Readloop", err)
12. }
14. }()
18. for {
20. If l.status! = status_connect {
22. Break
24. }
26. BUF: = Make ([]byte, L.buffersize)
28. N, Err: = L.ws.read (BUF)
30. If err! = Nil {
32. Break
34. }
38. If n > 0 {
40. L.READCH <-Buf[0:n]
42. }
44. }
46. L.close ()
48. }

The message can then be forwarded through the Read function to a shape such as

Type dealmsg func ([]byte, *longsocket) error

function to do the corresponding message processing, of course, you can also send the corresponding processing message through the Longsocket parameter.

Source has been uploaded githup as follows, including demo for reference.

Https://github.com/qianlnk/longsocket