guandan.dev

https://git.tonybtw.com/guandan.dev.git git://git.tonybtw.com/guandan.dev.git

1,553 bytes raw

package room

import (
	"crypto/rand"
	"encoding/hex"
	"github.com/gorilla/websocket"
	"net/http"
	"sync"
)

type Hub struct {
	rooms      map[string]*Room
	register   chan *Client
	unregister chan *Client
	mu         sync.RWMutex
}

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

func New_Hub() *Hub {
	return &Hub{
		rooms:      make(map[string]*Room),
		register:   make(chan *Client),
		unregister: make(chan *Client),
	}
}

func (h *Hub) Run() {
	for {
		select {
		case client := <-h.register:
			_ = client
		case client := <-h.unregister:
			if client.room != nil {
				client.room.leave <- client
			}
		}
	}
}

func (h *Hub) Handle_Websocket(w http.ResponseWriter, r *http.Request) {
	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		return
	}

	client := new_client(generate_id(), conn)

	h.register <- client

	go client.write_pump()
	go client.read_pump(h)
}

func (h *Hub) create_room() *Room {
	h.mu.Lock()
	defer h.mu.Unlock()

	room := new_room(generate_room_code())
	h.rooms[room.id] = room
	go room.run()

	return room
}

func (h *Hub) get_room(id string) *Room {
	h.mu.RLock()
	defer h.mu.RUnlock()

	return h.rooms[id]
}

func (h *Hub) delete_room(id string) {
	h.mu.Lock()
	defer h.mu.Unlock()

	delete(h.rooms, id)
}

func generate_id() string {
	b := make([]byte, 16)
	rand.Read(b)
	return hex.EncodeToString(b)
}

func generate_room_code() string {
	b := make([]byte, 3)
	rand.Read(b)
	return hex.EncodeToString(b)
}

1	`package room`
2
3	`import (`
4	`"crypto/rand"`
5	`"encoding/hex"`
6	`"github.com/gorilla/websocket"`
7	`"net/http"`
8	`"sync"`
9	`)`
10
11	`type Hub struct {`
12	`rooms map[string]*Room`
13	`register chan *Client`
14	`unregister chan *Client`
15	`mu sync.RWMutex`
16	`}`
17
18	`var upgrader = websocket.Upgrader{`
19	`ReadBufferSize: 1024,`
20	`WriteBufferSize: 1024,`
21	`CheckOrigin: func(r *http.Request) bool {`
22	`return true`
23	`},`
24	`}`
25
26	`func New_Hub() *Hub {`
27	`return &Hub{`
28	`rooms: make(map[string]*Room),`
29	`register: make(chan *Client),`
30	`unregister: make(chan *Client),`
31	`}`
32	`}`
33
34	`func (h *Hub) Run() {`
35	`for {`
36	`select {`
37	`case client := <-h.register:`
38	`_ = client`
39	`case client := <-h.unregister:`
40	`if client.room != nil {`
41	`client.room.leave <- client`
42	`}`
43	`}`
44	`}`
45	`}`
46
47	`func (h Hub) Handle_Websocket(w http.ResponseWriter, r http.Request) {`
48	`conn, err := upgrader.Upgrade(w, r, nil)`
49	`if err != nil {`
50	`return`
51	`}`
52
53	`client := new_client(generate_id(), conn)`
54
55	`h.register <- client`
56
57	`go client.write_pump()`
58	`go client.read_pump(h)`
59	`}`
60
61	`func (h Hub) create_room() Room {`
62	`h.mu.Lock()`
63	`defer h.mu.Unlock()`
64
65	`room := new_room(generate_room_code())`
66	`h.rooms[room.id] = room`
67	`go room.run()`
68
69	`return room`
70	`}`
71
72	`func (h Hub) get_room(id string) Room {`
73	`h.mu.RLock()`
74	`defer h.mu.RUnlock()`
75
76	`return h.rooms[id]`
77	`}`
78
79	`func (h *Hub) delete_room(id string) {`
80	`h.mu.Lock()`
81	`defer h.mu.Unlock()`
82
83	`delete(h.rooms, id)`
84	`}`
85
86	`func generate_id() string {`
87	`b := make([]byte, 16)`
88	`rand.Read(b)`
89	`return hex.EncodeToString(b)`
90	`}`
91
92	`func generate_room_code() string {`
93	`b := make([]byte, 3)`
94	`rand.Read(b)`
95	`return hex.EncodeToString(b)`
96	`}`