├── .gitignore
├── LICENSE
├── README.md
├── cleaner.go
├── client.go
├── config.go
├── config
    ├── config.ini
    └── log4go.xml
├── errors.go
├── example
    ├── client
    │   ├── chat.html
    │   ├── room.html
    │   ├── room_list.html
    │   └── static
    │   │   └── video
    │   │       └── iphonex.mp4
    └── serv
    │   └── main.go
├── kafka.go
├── log.go
├── message_handler.go
├── proto.go
├── room.go
├── static_server.go
├── utils
    └── concurrent_list.go
└── ws_server.go


/.gitignore:
--------------------------------------------------------------------------------
 1 | # Binaries for programs and plugins
 2 | *.exe
 3 | *.dll
 4 | *.so
 5 | *.dylib
 6 | 
 7 | # Test binary, build with `go test -c`
 8 | *.test
 9 | 
10 | # Output of the go coverage tool, specifically when used with LiteIDE
11 | *.out
12 | 
13 | # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
14 | .glide/
15 | .idea


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 JWL
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # danmu
 2 | 
 3 | 轻量弹幕（IM）系统，基于GO
 4 | 
 5 | # Require
 6 | 
 7 | `GO` >= `1.8`
 8 | 
 9 | `KAFKA` >= `1.0`
10 | 
11 | # Demo
12 | 
13 | 本项目为你提供了一个在线demo：[demo](http://danmu.jwlchina.cn)
14 | 
15 | # Getting Start
16 | 
17 | 安装好 `GOLANG` 环境以及 `KAFKA`
18 | 
19 | 获取项目源码
20 | ```bash
21 | go get github.com/kong36088/danmu
22 | ```
23 | 
24 | 到项目`config`目录下配置好你的kafka地址以及服务监听地址
25 | 
26 | 为 `kafka` 创建一个topic `danmu`
27 | ```bash
28 | kafka-topics.sh --create --topic danmu --zookeeper localhost:2181 --replication-factor 1 --partitions 1
29 | ```
30 | 
31 | 本项目为提供了一个使用实例，在完成环境部署后，运行以下命令：
32 | ```bash
33 | $ cd /path/to/your/application
34 | 
35 | $ cd example/serv/
36 | 
37 | $ go build   # or go run main.go
38 | 
39 | $ ./serv    # run your application
40 | ```
41 | 
42 | 服务开启之后，用浏览器访问打开html文件 `example/client/room_list.html` 即可看到服务效果


--------------------------------------------------------------------------------
/cleaner.go:
--------------------------------------------------------------------------------
 1 | package danmu
 2 | 
 3 | type Cleaner struct {
 4 | }
 5 | 
 6 | var (
 7 | 	cleaner *Cleaner
 8 | )
 9 | 
10 | func InitCleaner() error{
11 | 	cleaner = new(Cleaner)
12 | 
13 | 	return OK
14 | }
15 | 
16 | /**
17 | 	清除保存的client信息，关闭连接
18 |  */
19 | func (cleaner *Cleaner) CleanClient(client *Client) {
20 | 	client.Close()
21 | 
22 | 	room, err := roomBucket.Get(client.RoomId)
23 | 	if err == nil {
24 | 		delete(room.clients, client.Conn)
25 | 	}
26 | 
27 | 	clientBucket.Remove(client.Conn)
28 | 
29 | 	client = nil //for gc
30 | }
31 | 
32 | //TODO CleanRoom
33 | func (cleaner *Cleaner) CleanRoom(room *Room){
34 | 
35 | }
36 | 


--------------------------------------------------------------------------------
/client.go:
--------------------------------------------------------------------------------
  1 | package danmu
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	log "github.com/alecthomas/log4go"
  6 | 	"github.com/gorilla/websocket"
  7 | 	"strconv"
  8 | 	"sync"
  9 | 	"time"
 10 | )
 11 | 
 12 | type (
 13 | 	cid int64
 14 | )
 15 | 
 16 | var (
 17 | 	clientBucket *ClientBucket
 18 | 	keepalive    int
 19 | )
 20 | 
 21 | type Client struct {
 22 | 	ClientId cid //remain
 23 | 	RoomId   rid
 24 | 	Conn     *websocket.Conn
 25 | }
 26 | 
 27 | func NewClient(roomId rid, conn *websocket.Conn) *Client {
 28 | 	c := new(Client)
 29 | 	c.RoomId = roomId
 30 | 	c.Conn = conn
 31 | 	return c
 32 | }
 33 | 
 34 | func (client *Client) ReadJSON(v interface{}) error {
 35 | 	err := client.Conn.ReadJSON(v)
 36 | 	return err
 37 | }
 38 | 
 39 | func (client *Client) Read(v interface{}) (int, []byte, error) {
 40 | 	msgType, msg, err := client.Conn.ReadMessage()
 41 | 	return msgType, msg, err
 42 | }
 43 | 
 44 | func (client *Client) WriteErrorMsg(msg string) error {
 45 | 	err := client.Conn.WriteJSON(Proto{
 46 | 		OP:      OPErr,
 47 | 		Message: msg,
 48 | 		RoomId:  -1,
 49 | 	})
 50 | 	return err
 51 | }
 52 | 
 53 | func (client *Client) WriteMessage(msg string, roomId rid) error {
 54 | 	err := client.Conn.WriteJSON(Proto{
 55 | 		OP:      OPMsg,
 56 | 		Message: msg,
 57 | 		RoomId:  roomId,
 58 | 	})
 59 | 	return err
 60 | }
 61 | 
 62 | func (client *Client) WriteControl(messageType int, data []byte, deadline time.Time) error {
 63 | 	return client.Conn.WriteControl(messageType, data, deadline)
 64 | }
 65 | 
 66 | func (client *Client) Write(proto *Proto) error {
 67 | 	err := client.Conn.WriteJSON(proto)
 68 | 	return err
 69 | }
 70 | 
 71 | func (client *Client) BatchWrite(proto []*Proto) error {
 72 | 	jsonProtos, err := json.Marshal(proto)
 73 | 	if err != nil {
 74 | 		return err
 75 | 	}
 76 | 	err = client.Conn.WriteMessage(websocket.TextMessage, jsonProtos)
 77 | 	return err
 78 | }
 79 | 
 80 | func (client *Client) Close() error {
 81 | 	return client.Conn.Close()
 82 | }
 83 | 
 84 | func (client *Client) ErrorReport(err error, msg string) error {
 85 | 	if msg != "" {
 86 | 		return client.WriteErrorMsg(msg)
 87 | 	}
 88 | 	return OK
 89 | }
 90 | 
 91 | //keepAlive send ping message to client
 92 | // should be called by goroutines
 93 | func (client *Client) keepAlive() {
 94 | 	if keepalive <= 0 {
 95 | 		return
 96 | 	}
 97 | 	timeout := time.Duration(keepalive) * time.Second
 98 | 
 99 | 	lastResponse := time.Now()
100 | 	client.Conn.SetPongHandler(func(msg string) error {
101 | 		lastResponse = time.Now()
102 | 
103 | 		return nil
104 | 	})
105 | 	go func() {
106 | 		for {
107 | 			err := client.WriteControl(websocket.PingMessage, []byte("keepalive"), time.Now().Add(writeWait))
108 | 			if err != nil {
109 | 				return
110 | 			}
111 | 			time.Sleep(timeout / 2)
112 | 			if time.Now().Sub(lastResponse) > timeout {
113 | 				log.Info("Ping pong timeout, close client", client)
114 | 				cleaner.CleanClient(client)
115 | 				return
116 | 			}
117 | 		}
118 | 	}()
119 | }
120 | func (client *Client) CloseHandler() func(code int, text string) {
121 | 	return func(code int, text string) {
122 | 		message := []byte{}
123 | 		if code != websocket.CloseNoStatusReceived {
124 | 			message = websocket.FormatCloseMessage(code, "")
125 | 		}
126 | 		client.WriteControl(websocket.CloseMessage, message, time.Now().Add(writeWait))
127 | 		cleaner.CleanClient(client)
128 | 	}
129 | }
130 | 
131 | type ClientBucket struct {
132 | 	Clients map[*websocket.Conn]*Client
133 | 	lck     sync.RWMutex
134 | }
135 | 
136 | func InitClientBucket() error {
137 | 	var (
138 | 		err error
139 | 	)
140 | 	clientBucket = &ClientBucket{
141 | 		Clients: make(map[*websocket.Conn]*Client),
142 | 		lck:     sync.RWMutex{},
143 | 	}
144 | 
145 | 	keepalive, err = strconv.Atoi(Conf.GetConfig("sys", "keepalive_timeout"))
146 | 	if err != nil {
147 | 		return err
148 | 	}
149 | 	return OK
150 | }
151 | 
152 | func (cb *ClientBucket) Get(conn *websocket.Conn) (*Client, error) {
153 | 	cb.lck.RLock()
154 | 	defer cb.lck.RUnlock()
155 | 	if v, ok := cb.Clients[conn]; ok {
156 | 		return v, OK
157 | 	} else {
158 | 		return nil, ErrRoomDoesNotExist
159 | 	}
160 | 
161 | }
162 | 
163 | func (cb *ClientBucket) Add(client *Client) error {
164 | 	cb.lck.Lock()
165 | 	cb.Clients[client.Conn] = client
166 | 	cb.lck.Unlock()
167 | 	return OK
168 | }
169 | 
170 | func (cb *ClientBucket) Remove(conn *websocket.Conn) error {
171 | 	if _, ok := cb.Clients[conn]; !ok {
172 | 		return ErrRoomDoesNotExist
173 | 	}
174 | 	cb.lck.Lock()
175 | 	delete(cb.Clients, conn)
176 | 	cb.lck.Unlock()
177 | 	return OK
178 | }
179 | 


--------------------------------------------------------------------------------
/config.go:
--------------------------------------------------------------------------------
 1 | package danmu
 2 | 
 3 | import (
 4 | 	"errors"
 5 | 	"flag"
 6 | 	"fmt"
 7 | 	log "github.com/alecthomas/log4go"
 8 | 	"github.com/larspensjo/config"
 9 | 	"os"
10 | 	"runtime"
11 | )
12 | 
13 | var (
14 | 	Conf        *Config
15 | 	appPath = os.Getenv("GOPATH") + "/src/github.com/kong36088/danmu/"
16 | 	configFile  = flag.String("config", appPath+"config/config.ini", "General configuration file")
17 | )
18 | 
19 | type Config struct {
20 | 	values map[string]map[string]string
21 | }
22 | 
23 | //topic list
24 | 
25 | func NewConfig() *Config {
26 | 	return &Config{
27 | 		values: make(map[string]map[string]string),
28 | 	}
29 | }
30 | 
31 | func InitConfig() error {
32 | 	Conf = NewConfig()
33 | 
34 | 	runtime.GOMAXPROCS(runtime.NumCPU())
35 | 	flag.Parse()
36 | 
37 | 	cfgSecs, err := config.ReadDefault(*configFile)
38 | 	if err != nil {
39 | 		return errors.New(fmt.Sprintf("Fail to find %s %s", *configFile, err))
40 | 	}
41 | 
42 | 	for _, section := range cfgSecs.Sections() {
43 | 		options, err := cfgSecs.SectionOptions(section)
44 | 		if err != nil {
45 | 			log.Error("Read options of file %s section %s  failed, %s\n", *configFile, section, err)
46 | 			continue
47 | 		}
48 | 		Conf.values[section] = make(map[string]string)
49 | 		for _, v := range options {
50 | 			option, err := cfgSecs.String(section, v)
51 | 			if err != nil {
52 | 				log.Error("Read file %s option %s failed, %s\n", *configFile, v, err)
53 | 				continue
54 | 			}
55 | 			Conf.values[section][v] = option
56 | 		}
57 | 	}
58 | 	return nil
59 | }
60 | 
61 | func (c *Config) GetConfig(section, option string) string {
62 | 	return c.values[section][option]
63 | }
64 | 
65 | func (c *Config) GetSectionConfig(section string) map[string]string {
66 | 	return c.values[section]
67 | }
68 | 
69 | func (c *Config) GetAllConfig() map[string]map[string]string {
70 | 	return c.values
71 | }
72 | 


--------------------------------------------------------------------------------
/config/config.ini:
--------------------------------------------------------------------------------
 1 | [sys]
 2 | port=9500
 3 | keepalive_timeout=60   #心跳检测超时时间，设置为0则不进行检测
 4 | log_conf=./config/log4go.xml
 5 | push_freq=1   #弹幕推送时延，默认1秒推送一次
 6 | 
 7 | [kafka]
 8 | address=localhost:9092
 9 | group=danmu_c
10 | topic=danmu


--------------------------------------------------------------------------------
/config/log4go.xml:
--------------------------------------------------------------------------------
 1 | <logging>
 2 |   <filter enabled="true">
 3 |     <tag>stdout</tag>
 4 |     <type>console</type>
 5 |     <!-- level is (:?FINEST|FINE|DEBUG|TRACE|INFO|WARNING|ERROR) -->
 6 |     <level>DEBUG</level>
 7 |   </filter>
 8 |   <filter enabled="false">
 9 |     <tag>debug_file</tag>
10 |     <type>file</type>
11 |     <level>DEBUG</level>
12 |     <property name="filename">/var/log/danmu/danmu_debug.log</property>
13 |     <property name="format">[%D %T] [%L] [%S] %M</property>
14 |     <property name="rotate">true</property> <!-- true enables log rotation, otherwise append -->
15 |     <property name="maxsize">0M</property> <!-- \d+[KMG]? Suffixes are in terms of 2**10 -->
16 |     <property name="maxlines">0K</property> <!-- \d+[KMG]? Suffixes are in terms of thousands -->
17 |     <property name="daily">true</property> <!-- Automatically rotates when a log message is written after midnight -->
18 |   </filter>
19 |   <filter enabled="true">
20 |     <tag>info_file</tag>
21 |     <type>file</type>
22 |     <level>INFO</level>
23 |     <property name="filename">/var/log/danmu/danmu_info.log</property>
24 |     <!--
25 |        %T - Time (15:04:05 MST)
26 |        %t - Time (15:04)
27 |        %D - Date (2006/01/02)
28 |        %d - Date (01/02/06)
29 |        %L - Level (FNST, FINE, DEBG, TRAC, WARN, EROR, CRIT)
30 |        %S - Source
31 |        %M - Message
32 |        It ignores unknown format strings (and removes them)
33 |        Recommended: "[%D %T] [%L] (%S) %M"
34 |     -->
35 |     <property name="format">[%D %T] [%L] [%S] %M</property>
36 |     <property name="rotate">true</property> <!-- true enables log rotation, otherwise append -->
37 |     <property name="maxsize">0M</property> <!-- \d+[KMG]? Suffixes are in terms of 2**10 -->
38 |     <property name="maxlines">0K</property> <!-- \d+[KMG]? Suffixes are in terms of thousands -->
39 |     <property name="daily">true</property> <!-- Automatically rotates when a log message is written after midnight -->
40 |   </filter>
41 |   <filter enabled="false">
42 |     <tag>warn_file</tag>
43 |     <type>file</type>
44 |     <level>WARNING</level>
45 |     <property name="filename">/var/log/danmu/danmu_warn.log</property>
46 |     <property name="format">[%D %T] [%L] [%S] %M</property>
47 |     <property name="rotate">true</property> <!-- true enables log rotation, otherwise append -->
48 |     <property name="maxsize">0M</property> <!-- \d+[KMG]? Suffixes are in terms of 2**10 -->
49 |     <property name="maxlines">0K</property> <!-- \d+[KMG]? Suffixes are in terms of thousands -->
50 |     <property name="daily">true</property> <!-- Automatically rotates when a log message is written after midnight -->
51 |   </filter>
52 |   <filter enabled="true">
53 |     <tag>error_file</tag>
54 |     <type>file</type>
55 |     <level>ERROR</level>
56 |     <property name="filename">/var/log/danmu/danmu_error.log</property>
57 |     <property name="format">[%D %T] [%L] [%S] %M</property>
58 |     <property name="rotate">true</property> <!-- true enables log rotation, otherwise append -->
59 |     <property name="maxsize">0M</property> <!-- \d+[KMG]? Suffixes are in terms of 2**10 -->
60 |     <property name="maxlines">0K</property> <!-- \d+[KMG]? Suffixes are in terms of thousands -->
61 |     <property name="daily">true</property> <!-- Automatically rotates when a log message is written after midnight -->
62 |   </filter>
63 | </logging>
64 | 


--------------------------------------------------------------------------------
/errors.go:
--------------------------------------------------------------------------------
 1 | package danmu
 2 | 
 3 | import "errors"
 4 | 
 5 | var (
 6 | 	OK error = nil
 7 | 	//sys
 8 | 	ErrParamError = errors.New("incorrect param")
 9 | 
10 | 	//room
11 | 	ErrRoomDoesNotExist = errors.New("room does not exist")
12 | )
13 | 


--------------------------------------------------------------------------------
/example/client/chat.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <title>Chat Example</title>
  5 |     <script type="text/javascript">
  6 |         window.onload = function () {
  7 |             var conn;
  8 |             var msg = document.getElementById("msg");
  9 |             var log = document.getElementById("log");
 10 | 
 11 |             function appendLog(item) {
 12 |                 var doScroll = log.scrollTop === log.scrollHeight - log.clientHeight;
 13 |                 log.appendChild(item);
 14 |                 if (doScroll) {
 15 |                     log.scrollTop = log.scrollHeight - log.clientHeight;
 16 |                 }
 17 |             }
 18 | 
 19 |             document.getElementById("form").onsubmit = function () {
 20 |                 if (!conn) {
 21 |                     return false;
 22 |                 }
 23 |                 if (!msg.value) {
 24 |                     return false;
 25 |                 }
 26 |                 conn.send(JSON.stringify({op: "message", message: msg.value, room_id: 1}));
 27 |                 msg.value = "";
 28 |                 return false;
 29 |             };
 30 | 
 31 |             if (window["WebSocket"]) {
 32 |                 conn = new WebSocket("ws://localhost:9500/ws?room=1");
 33 |                 conn.onclose = function (evt) {
 34 |                     var item = document.createElement("div");
 35 |                     item.innerHTML = "<b>Connection closed.</b>";
 36 |                     appendLog(item);
 37 |                 };
 38 |                 conn.onmessage = function (evt) {
 39 |                     var messages = evt.data.split('\n');
 40 |                     for (var i = 0; i < messages.length; i++) {
 41 |                         if (messages[i] != "") {
 42 |                             var item = document.createElement("div");
 43 |                             item.innerText = JSON.parse(messages[i]).message;
 44 |                             appendLog(item);
 45 |                         }
 46 |                     }
 47 |                 };
 48 |             } else {
 49 |                 var item = document.createElement("div");
 50 |                 item.innerHTML = "<b>Your browser does not support WebSockets.</b>";
 51 |                 appendLog(item);
 52 |             }
 53 |         };
 54 |     </script>
 55 |     <style type="text/css">
 56 |         html {
 57 |             overflow: hidden;
 58 |         }
 59 | 
 60 |         body {
 61 |             overflow: hidden;
 62 |             padding: 0;
 63 |             margin: 0;
 64 |             width: 100%;
 65 |             height: 100%;
 66 |             background: gray;
 67 |         }
 68 | 
 69 |         #log {
 70 |             background: white;
 71 |             margin: 0;
 72 |             padding: 0.5em 0.5em 0.5em 0.5em;
 73 |             position: absolute;
 74 |             top: 0.5em;
 75 |             left: 0.5em;
 76 |             right: 0.5em;
 77 |             bottom: 3em;
 78 |             overflow: auto;
 79 |         }
 80 | 
 81 |         #form {
 82 |             padding: 0 0.5em 0 0.5em;
 83 |             margin: 0;
 84 |             position: absolute;
 85 |             bottom: 1em;
 86 |             left: 0px;
 87 |             width: 100%;
 88 |             overflow: hidden;
 89 |         }
 90 | 
 91 |     </style>
 92 | </head>
 93 | <body>
 94 | <div id="log"></div>
 95 | <form id="form">
 96 |     <input type="submit" value="Send"/>
 97 |     <input type="text" id="msg" size="64"/>
 98 | </form>
 99 | </body>
100 | </html>


--------------------------------------------------------------------------------
/example/client/room.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | <head>
  4 |     <meta charset="utf-8">
  5 |     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  6 |     <title>Room</title>
  7 |     <link rel="stylesheet" href="">
  8 |     <style type="text/css" media="screen">
  9 |         * {
 10 |             margin: 0px;
 11 |             padding: 0px
 12 |         }
 13 | 
 14 |         html, body {
 15 |             height: 100%
 16 |         }
 17 | 
 18 |         body {
 19 |             overflow: hidden;
 20 |             background-color: #FFF;
 21 |             text-align: center;
 22 |         }
 23 | 
 24 |         .flex-column {
 25 |             display: flex;
 26 |             flex-direction: column;
 27 |             justify-content: space-between;, align-items: center;
 28 |         }
 29 | 
 30 |         .flex-row {
 31 |             display: flex;
 32 |             flex-direction: row;
 33 |             justify-content: center;
 34 |             align-items: center;
 35 |         }
 36 | 
 37 |         .wrap {
 38 |             overflow: hidden;
 39 |             width: 70%;
 40 |             height: 600px;
 41 |             margin: 100px auto;
 42 |             padding: 20px;
 43 |             background-color: transparent;
 44 |             box-shadow: 0 0 9px #222;
 45 |             border-radius: 20px;
 46 |         }
 47 | 
 48 |         .wrap .box {
 49 |             position: relative;
 50 |             width: 100%;
 51 |             height: 90%;
 52 |             background-color: #000000;
 53 |             border-radius: 10px
 54 |         }
 55 | 
 56 |         .wrap .box span {
 57 |             position: absolute;
 58 |             top: 10px;
 59 |             left: 20px;
 60 |             display: block;
 61 |             padding: 10px;
 62 |             color: #336688
 63 |         }
 64 | 
 65 |         .wrap .send {
 66 |             display: flex;
 67 |             width: 100%;
 68 |             height: 10%;
 69 |             background-color: #000000;
 70 |             border-radius: 8px
 71 |         }
 72 | 
 73 |         .wrap .send input {
 74 |             width: 40%;
 75 |             height: 60%;
 76 |             border: 0;
 77 |             outline: 0;
 78 |             border-radius: 5px 0px 0px 5px;
 79 |             box-shadow: 0px 0px 5px #d9d9d9;
 80 |             text-indent: 1em
 81 |         }
 82 | 
 83 |         .wrap .send .send-btn {
 84 |             width: 100px;
 85 |             height: 60%;
 86 |             background-color: #fe943b;
 87 |             color: #FFF;
 88 |             text-align: center;
 89 |             border-radius: 0px 5px 5px 0px;
 90 |             line-height: 30px;
 91 |             cursor: pointer;
 92 |         }
 93 | 
 94 |         .wrap .send .send-btn:hover {
 95 |             background-color: #4cacdc
 96 |         }
 97 |     </style>
 98 | </head>
 99 | <body>
100 | <div class="wrap flex-column">
101 |     <div class="box">
102 |         <video src="static/video/iphonex.mp4" width="100%" height="100%" controls autoplay></video>
103 |     </div>
104 |     <div class="send flex-row">
105 |         <input type="text" class="con" placeholder="弹幕发送[]~(^v^)~*">
106 |         <div class="send-btn">发送</div>
107 |     </div>
108 | </div>
109 | 
110 | <script src="https://cdn.bootcss.com/jquery/1.12.4/jquery.min.js" type="text/javascript"></script>
111 | <script>
112 | 
113 |     window.onload = function () {
114 |         const ADDR = "ws://localhost:9500/ws";
115 |         const DELAY = 15000;
116 |         const RETRY = 10;
117 |         var conn;
118 |         var roomId = parseInt(getQueryString("room"), 10);
119 | 
120 |         var ws = {
121 |             retry: RETRY,
122 |             init: function () {
123 |                 if (this.retry <= 0) {
124 |                     return;
125 |                 }
126 |                 if (roomId === "" || !roomId) {
127 |                     alert("please select your room");
128 |                     return;
129 |                 }
130 | 
131 |                 conn = new WebSocket(ADDR + "?room=" + roomId);
132 |                 conn.onopen = this.onOpen;
133 |                 conn.onclose = this.onClose;
134 |                 conn.onmessage = this.onMessage;
135 | 
136 |             },
137 |             onOpen: function (evt) {
138 |                 this.retry = RETRY;
139 |             },
140 |             onMessage: function (evt) {
141 |                 var messages = evt.data.split('\n');
142 |                 for (var i = 0; i < messages.length; i++) {
143 |                     if (messages[i] !== "") {
144 |                         var msg = JSON.parse(messages[i]);
145 |                         for (i = 0; i < msg.length; i++) {
146 |                             switch (msg[i].op) {
147 |                                 case "message":
148 |                                     createEle(msg[i].message);   //执行节点创建模块
149 |                                     break;
150 |                                 case "error":
151 |                                     alert(msg[i].message);
152 |                                     break;
153 |                                 default:
154 |                                     break;
155 |                             }
156 |                         }
157 |                     }
158 |                 }
159 |             },
160 |             onClose: function (evt) {
161 |                 alert("Connection closed.");
162 |                 setTimeout(function () {
163 |                     ws.reconnect()
164 |                 }, DELAY);
165 | 
166 |             },
167 |             reconnect: function () {
168 |                 this.retry--;
169 |                 console.log(this.retry);
170 |                 this.init();
171 |             },
172 |             send: function (txt) {
173 |                 conn.send(JSON.stringify({op: "message", message: txt, room_id: roomId}));
174 |             }
175 | 
176 |         };
177 |         if (window["WebSocket"]) {
178 |             ws.init();
179 |         } else {
180 |             alert('Your browser does not support WebSockets.');
181 |         }
182 | 
183 |         function send() {
184 |             //获取oCon的内容
185 |             if (oCon.value.length <= 0 || (/^\s+$/).test(oCon.value)) {
186 |                 //alert('请输入弹幕');
187 |                 return false;
188 |             }
189 |             message = oCon.value;
190 |             //生成标签
191 |             oCon.value = '';   //收尾工作清空输入框
192 |             ws.send(message);
193 |         }
194 | 
195 |         //1.获取元素
196 |         var oBox = document.querySelector('.box');   //获取.box元素
197 |         var oCon = document.querySelector('.con');   //获取input框
198 |         var oBtn = document.querySelector('.send-btn');   //获取发送按钮
199 |         var cW = oBox.offsetWidth;   //获取box的宽度
200 |         var cH = oBox.offsetHeight;   //获取box的高度
201 |         var message = '';   //弹幕内容初始化
202 |         oBtn.onclick = send;   //点击发送
203 |         oCon.onkeydown = function (e) {
204 |             e = e || window.event;
205 |             if (e.keyCode === 13) {
206 |                 //回车键
207 |                 send();
208 |             }
209 |         };
210 | 
211 |         function createEle(txt) {
212 |             //动态生成span标签
213 |             var oMessage = document.createElement('span');   //创建标签
214 |             oMessage.innerHTML = txt;   //接收参数txt并且生成替换内容
215 |             oMessage.style.left = cW + 'px';  //初始化生成位置x
216 |             oBox.appendChild(oMessage);   //把标签塞到oBox里面
217 |             roll.call(oMessage, {
218 |                 //call改变函数内部this的指向
219 |                 timing: ['linear', 'ease-out'][~~(Math.random() * 2)],
220 |                 color: '#' + (~~(Math.random() * (1 << 24))).toString(16),
221 |                 top: random(0, cH),
222 |                 fontSize: random(16, 32)
223 |             });
224 |         }
225 | 
226 |         function roll(opt) {
227 |             //弹幕滚动
228 |             //如果对象中不存在timing 初始化
229 |             opt.timing = opt.timing || 'linear';
230 |             opt.color = opt.color || '#fff';
231 |             opt.top = opt.top || 0;
232 |             opt.fontSize = opt.fontSize || 16;
233 |             this._left = parseInt(this.offsetLeft);   //获取当前left的值
234 |             this.style.color = opt.color;   //初始化颜色
235 |             this.style.top = opt.top + 'px';
236 |             this.style.fontSize = opt.fontSize + 'px';
237 |             this.timer = setInterval(function () {
238 |                 if (this._left <= 100) {
239 |                     clearInterval(this.timer);   //终止定时器
240 |                     this.parentNode.removeChild(this);
241 |                     return;   //终止函数
242 |                 }
243 |                 switch (opt.timing) {
244 |                     case 'linear':   //如果匀速
245 |                         this._left += -2;
246 |                         break;
247 |                     case 'ease-out':   //
248 |                         this._left += (0 - this._left) * .01;
249 |                         break;
250 |                 }
251 |                 this.style.left = this._left + 'px';
252 |             }.bind(this), 1000 / 60);
253 |         }
254 | 
255 |         function random(start, end) {
256 |             //随机数封装
257 |             return start + ~~(Math.random() * (end - start));
258 |         }
259 | 
260 |         function getQueryString(key) {
261 |             var reg = new RegExp("(^|&)" + key + "=([^&]*)(&|$)");
262 |             var result = window.location.search.substr(1).match(reg);
263 |             return result ? decodeURIComponent(result[2]) : null;
264 |         }
265 |     }
266 | 
267 | 
268 | </script>
269 | </body>
270 | </html>


--------------------------------------------------------------------------------
/example/client/room_list.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <title>Room list</title>
 6 |     <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css">
 7 |     <style type="text/css">
 8 |         .room-box {
 9 |             height:300px;
10 |         }
11 |         .room{
12 |             font-size:40px;
13 |             text-align: center;
14 |             line-height:300px;
15 |             overflow:hidden;
16 |         }
17 |     </style>
18 | </head>
19 | <body>
20 | 
21 | <div class="container">
22 |     <div class="room-box">
23 |         <div class="col-sm-4 room">
24 |             <a href="room.html?room=1">房间1</a>
25 |         </div>
26 |         <div class="col-sm-4 room">
27 |             <a href="room.html?room=2">房间2</a>
28 |         </div>
29 |         <div class="col-sm-4 room">
30 |             <a href="room.html?room=3">房间3</a>
31 |         </div>
32 |     </div>
33 |     <div class="room-box">
34 |         <div class="col-sm-4 room">
35 |             <a href="room.html?room=4">房间4</a>
36 |         </div>
37 |         <div class="col-sm-4 room">
38 |             <a href="room.html?room=5">房间5</a>
39 |         </div>
40 |         <div class="col-sm-4 room">
41 |             <a href="room.html?room=6">房间6</a>
42 |         </div>
43 |     </div>
44 | </div>
45 | 
46 | </body>
47 | </html>


--------------------------------------------------------------------------------
/example/client/static/video/iphonex.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/kong36088/danmu/40ae9f888d9bfaa7a627b55739a16082934804c7/example/client/static/video/iphonex.mp4


--------------------------------------------------------------------------------
/example/serv/main.go:
--------------------------------------------------------------------------------
1 | package main
2 | 
3 | import (
4 | 	"github.com/kong36088/danmu"
5 | )
6 | 
7 | func main() {
8 | 	danmu.StartServer()
9 | }


--------------------------------------------------------------------------------
/kafka.go:
--------------------------------------------------------------------------------
  1 | package danmu
  2 | 
  3 | import (
  4 | 	"github.com/Shopify/sarama"
  5 | 	log "github.com/alecthomas/log4go"
  6 | 	"github.com/bsm/sarama-cluster"
  7 | 	"strings"
  8 | 	"time"
  9 | )
 10 | 
 11 | var (
 12 | 	Topic    string
 13 | 	Topics   []string
 14 | 	Group    string
 15 | 	producer sarama.AsyncProducer
 16 | 	consumer *cluster.Consumer
 17 | )
 18 | 
 19 | func InitKafka(kafkaAddrs []string) error {
 20 | 	var (
 21 | 		err error
 22 | 	)
 23 | 	Topic = Conf.GetConfig("kafka", "topic")
 24 | 	Topics = strings.Split(Topic, ",")
 25 | 	Group = Conf.GetConfig("kafka", "group")
 26 | 
 27 | 	err = InitKafkaProducer(kafkaAddrs)
 28 | 	if err != nil {
 29 | 		return err
 30 | 	}
 31 | 	err = InitKafkaConsumer(kafkaAddrs)
 32 | 	if err != nil {
 33 | 		return err
 34 | 	}
 35 | 
 36 | 	return nil
 37 | }
 38 | 
 39 | func CloseKafka() {
 40 | 	producer.Close()
 41 | 	consumer.Close()
 42 | }
 43 | 
 44 | // producer
 45 | 
 46 | func InitKafkaProducer(kafkaAddrs []string) error {
 47 | 	var (
 48 | 		err error
 49 | 	)
 50 | 	config := sarama.NewConfig()
 51 | 	//config.Producer.RequiredAcks = sarama.NoResponse
 52 | 	config.Producer.RequiredAcks = sarama.WaitForLocal
 53 | 	config.Producer.Partitioner = sarama.NewHashPartitioner
 54 | 	config.Producer.Return.Successes = true
 55 | 	config.Producer.Return.Errors = true
 56 | 	config.Producer.Timeout = 5 * time.Second
 57 | 	producer, err = sarama.NewAsyncProducer(kafkaAddrs, config)
 58 | 	if err != nil{
 59 | 		return err
 60 | 	}
 61 | 	go handleProducerSuccess()
 62 | 	go handleProducerError()
 63 | 	return OK
 64 | }
 65 | 
 66 | func handleProducerSuccess() {
 67 | 	var (
 68 | 		pm *sarama.ProducerMessage
 69 | 	)
 70 | 	for {
 71 | 		pm = <-producer.Successes()
 72 | 		if pm != nil {
 73 | 			log.Info("producer message success, partition:%d offset:%d key:%v valus:%s", pm.Partition, pm.Offset, pm.Key, pm.Value)
 74 | 		}
 75 | 	}
 76 | }
 77 | 
 78 | func handleProducerError() {
 79 | 	var (
 80 | 		err *sarama.ProducerError
 81 | 	)
 82 | 	for {
 83 | 		err = <-producer.Errors()
 84 | 		if err != nil {
 85 | 			log.Error("producer message error, partition:%d offset:%d key:%v valus:%s error(%v)", err.Msg.Partition, err.Msg.Offset, err.Msg.Key, err.Msg.Value, err.Err)
 86 | 		}
 87 | 	}
 88 | }
 89 | 
 90 | //consumer
 91 | 
 92 | func InitKafkaConsumer(kafkaAddrs []string) error {
 93 | 	var (
 94 | 		err error
 95 | 	)
 96 | 	config := cluster.NewConfig()
 97 | 	config.Group.Return.Notifications = false
 98 | 	config.Consumer.Return.Errors = true
 99 | 	config.Consumer.Offsets.CommitInterval = 1 * time.Second
100 | 	config.Consumer.Offsets.Initial = sarama.OffsetNewest //初始从最新的offset开始
101 | 
102 | 	consumer, err = cluster.NewConsumer(kafkaAddrs, Group, Topics, config)
103 | 	if err != nil {
104 | 		return err
105 | 	}
106 | 
107 | 	// consume errors
108 | 	go handleConsumerError()
109 | 
110 | 	return OK
111 | }
112 | 
113 | func handleConsumerError() {
114 | 	for err := range consumer.Errors() {
115 | 		log.Error("Consumer Error: %s\n", err.Error())
116 | 	}
117 | }
118 | 


--------------------------------------------------------------------------------
/log.go:
--------------------------------------------------------------------------------
 1 | package danmu
 2 | 
 3 | import (
 4 | 	log "github.com/alecthomas/log4go"
 5 | )
 6 | 
 7 | func InitLog() error {
 8 | 	logPath := Conf.GetConfig("sys", "log_conf")
 9 | 	log.LoadConfiguration(appPath + logPath)
10 | 	return OK
11 | }
12 | 
13 | func CloseLog() {
14 | 	log.Close()
15 | }
16 | 


--------------------------------------------------------------------------------
/message_handler.go:
--------------------------------------------------------------------------------
  1 | package danmu
  2 | 
  3 | import (
  4 | 	"encoding/json"
  5 | 	log "github.com/alecthomas/log4go"
  6 | 	"strconv"
  7 | 	"sync"
  8 | 	"time"
  9 | )
 10 | 
 11 | var (
 12 | 	commandChans map[*Room]chan string
 13 | 	lock         *sync.RWMutex
 14 | 	pushFreq     int
 15 | 	msgRoomObs   RoomObserverInterface
 16 | )
 17 | 
 18 | func InitMessageHandler() error {
 19 | 	var err error
 20 | 
 21 | 	commandChans = make(map[*Room]chan string)
 22 | 	lock = &sync.RWMutex{}
 23 | 
 24 | 	pushFreq, err = strconv.Atoi(Conf.GetConfig("sys", "push_freq"))
 25 | 	msgRoomObs = new(MessageRoomObserver)
 26 | 
 27 | 	roomBucket.AttachObserver(msgRoomObs)
 28 | 
 29 | 	if err != nil {
 30 | 		return err
 31 | 	}
 32 | 	return OK
 33 | }
 34 | 
 35 | type MessageRoomObserver struct{}
 36 | 
 37 | func (mro *MessageRoomObserver) Update(action int, room *Room) {
 38 | 	lock.Lock()
 39 | 	defer lock.Unlock()
 40 | 
 41 | 	if action == RoomActionAdd {
 42 | 		commandChans[room] = make(chan string)
 43 | 		go messagePusher(room, commandChans[room])
 44 | 	} else if action == RoomActionDelete {
 45 | 		commandChans[room] <- "stop"
 46 | 		delete(commandChans, room)
 47 | 	}
 48 | 
 49 | }
 50 | 
 51 | func messageHandler() {
 52 | 	var (
 53 | 		proto *Proto
 54 | 	)
 55 | 	proto = NewProto()
 56 | 	for {
 57 | 		select {
 58 | 		case msg, ok := <-consumer.Messages():
 59 | 			if ok {
 60 | 				//fmt.Printf("%s/%d/%d\t%s\t%s\n", msg.Topic, msg.Partition, msg.Offset, msg.Key, msg.Value)
 61 | 				consumer.MarkOffset(msg, "") // mark message as processed
 62 | 
 63 | 				if err := json.Unmarshal(msg.Value, proto); err != nil {
 64 | 					log.Error(err)
 65 | 					continue
 66 | 				}
 67 | 
 68 | 				roomId := proto.RoomId
 69 | 				room, err := roomBucket.Get(rid(roomId))
 70 | 				if err != nil {
 71 | 					log.Error(err)
 72 | 					continue
 73 | 				}
 74 | 				room.protoList.PushBack(proto)
 75 | 				log.Debug(proto)
 76 | 			}
 77 | 		}
 78 | 	}
 79 | }
 80 | 
 81 | func messagePusher(room *Room, commandChan chan string) {
 82 | 	ticker := time.NewTicker(time.Duration(pushFreq) * time.Second) // 推送定时器
 83 | 	for {
 84 | 		select {
 85 | 		case command := <-commandChan:
 86 | 			if command == "stop" {
 87 | 				return
 88 | 			}
 89 | 		case <- ticker.C:
 90 | 			datas := room.protoList.PopAll()
 91 | 			protoLen := len(datas)
 92 | 			if protoLen > 0 {
 93 | 				protos := make([]*Proto, 0, protoLen)
 94 | 				for i := 0; i < protoLen; i++ {
 95 | 					proto, err := datas[i].(*Proto)
 96 | 					if err == false {
 97 | 						log.Error("*Proto type assertion failed")
 98 | 						continue
 99 | 					}
100 | 					protos = append(protos, proto)
101 | 				}
102 | 				for _, client := range room.GetClients() {
103 | 					client.BatchWrite(protos)
104 | 				}
105 | 			}
106 | 		}
107 | 	}
108 | }
109 | 


--------------------------------------------------------------------------------
/proto.go:
--------------------------------------------------------------------------------
 1 | package danmu
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	log "github.com/alecthomas/log4go"
 6 | )
 7 | 
 8 | const (
 9 | 	OPErr = "error"
10 | 	OPMsg = "message"
11 | )
12 | 
13 | type Proto struct {
14 | 	OP    string `json:"op"`
15 | 	Message string `json:"message"`
16 | 	RoomId  rid    `json:"room_id"`
17 | }
18 | 
19 | func NewProto() *Proto{
20 | 	return &Proto{}
21 | }
22 | 
23 | func (p Proto) String() string {
24 | 	return p.JsonEncode()
25 | }
26 | 
27 | func (p *Proto) JsonEncode() string {
28 | 	j, err := json.Marshal(p)
29 | 	if err != nil {
30 | 		log.Error(err)
31 | 		return ""
32 | 	}
33 | 	return string(j)
34 | }
35 | 


--------------------------------------------------------------------------------
/room.go:
--------------------------------------------------------------------------------
  1 | package danmu
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	log "github.com/alecthomas/log4go"
  6 | 	"github.com/gorilla/websocket"
  7 | 	"github.com/kong36088/danmu/utils"
  8 | 	"strconv"
  9 | 	"sync"
 10 | )
 11 | 
 12 | const (
 13 | 	roomMapCup = 100
 14 | )
 15 | 
 16 | type (
 17 | 	rid int64
 18 | )
 19 | 
 20 | //TODO room auto create
 21 | func (r rid) String() string {
 22 | 	return strconv.Itoa(int(r))
 23 | }
 24 | 
 25 | var (
 26 | 	roomList       = []rid{1, 2, 3, 4, 5, 6, 7, 8}
 27 | 	roomBucket     *RoomBucket
 28 | )
 29 | 
 30 | type Room struct {
 31 | 	RoomId    rid
 32 | 	clients   map[*websocket.Conn]*Client
 33 | 	lck       sync.RWMutex
 34 | 	protoList *utils.ConcurrentList //Batch push
 35 | }
 36 | 
 37 | func NewRoom(roomId rid) *Room {
 38 | 	r := new(Room)
 39 | 	r.RoomId = roomId
 40 | 	r.clients = make(map[*websocket.Conn]*Client)
 41 | 	r.protoList = utils.NewConcurrentList()
 42 | 	return r
 43 | }
 44 | 
 45 | func (room *Room) AddClient(client *Client) error {
 46 | 	room.lck.Lock()
 47 | 	room.clients[client.Conn] = client
 48 | 	room.lck.Unlock()
 49 | 
 50 | 	return nil
 51 | }
 52 | 
 53 | func (room *Room) GetClients() map[*websocket.Conn]*Client {
 54 | 	room.lck.RLock()
 55 | 	m := room.clients
 56 | 	room.lck.RUnlock()
 57 | 
 58 | 	return m
 59 | }
 60 | 
 61 | func (room Room) String() string {
 62 | 	return fmt.Sprintf("RoomId:%s", room.RoomId)
 63 | }
 64 | 
 65 | type RoomBucket struct {
 66 | 	Rooms     map[rid]*Room
 67 | 	lck       sync.RWMutex
 68 | 	observers map[interface{}]interface{}
 69 | }
 70 | 
 71 | func InitRoomBucket() error {
 72 | 	roomBucket = &RoomBucket{
 73 | 		Rooms:     make(map[rid]*Room, roomMapCup),
 74 | 		lck:       sync.RWMutex{},
 75 | 		observers: make(map[interface{}]interface{}),
 76 | 	}
 77 | 	for _, v := range roomList {
 78 | 		r := NewRoom(v)
 79 | 		err := roomBucket.Add(r)
 80 | 		if err != nil {
 81 | 			log.Exit(err)
 82 | 		}
 83 | 	}
 84 | 	return OK
 85 | }
 86 | 
 87 | func (rb *RoomBucket) Get(id rid) (*Room, error) {
 88 | 	rb.lck.RLock()
 89 | 	defer rb.lck.RUnlock()
 90 | 	if v, ok := rb.Rooms[id]; ok {
 91 | 		return v, nil
 92 | 	} else {
 93 | 		return nil, ErrRoomDoesNotExist
 94 | 	}
 95 | 
 96 | }
 97 | 
 98 | func (rb *RoomBucket) Add(room *Room) error {
 99 | 	rb.lck.Lock()
100 | 	rb.Rooms[room.RoomId] = room
101 | 	rb.lck.Unlock()
102 | 
103 | 	rb.notify(RoomActionAdd, room)
104 | 
105 | 	return OK
106 | }
107 | 
108 | func (rb *RoomBucket) Remove(room *Room) error {
109 | 	if _, ok := rb.Rooms[room.RoomId]; !ok {
110 | 		return ErrRoomDoesNotExist
111 | 	}
112 | 	rb.lck.Lock()
113 | 	delete(rb.Rooms, room.RoomId)
114 | 	rb.lck.Unlock()
115 | 
116 | 	rb.notify(RoomActionDelete, room)
117 | 
118 | 	return OK
119 | }
120 | 
121 | func (rb *RoomBucket) AttachObserver(observer RoomObserverInterface) {
122 | 	rb.lck.Lock()
123 | 	rb.observers[observer] = observer
124 | 
125 | 	for _, room := range rb.Rooms {
126 | 		observer.Update(RoomActionAdd, room)
127 | 	}
128 | 
129 | 	rb.lck.Unlock()
130 | }
131 | 
132 | func (rb *RoomBucket) DetachObserver(observer RoomObserverInterface) {
133 | 	rb.lck.Lock()
134 | 	delete(rb.observers, observer)
135 | 
136 | 	for _, room := range rb.Rooms {
137 | 		observer.Update(RoomActionDelete, room)
138 | 	}
139 | 
140 | 	rb.lck.Unlock()
141 | }
142 | 
143 | func (rb *RoomBucket) notify(action int, room *Room) {
144 | 	rb.lck.RLock()
145 | 	defer rb.lck.RUnlock()
146 | 
147 | 	for _, ob := range rb.observers {
148 | 		ob.(RoomObserverInterface).Update(action, room)
149 | 	}
150 | }
151 | 
152 | const (
153 | 	RoomActionAdd    = 1
154 | 	RoomActionDelete = 2
155 | )
156 | 
157 | type RoomObserverInterface interface {
158 | 	Update(int, *Room)
159 | }
160 | 


--------------------------------------------------------------------------------
/static_server.go:
--------------------------------------------------------------------------------
 1 | package danmu
 2 | 
 3 | 
 4 | import (
 5 | 	"bytes"
 6 | 	"errors"
 7 | 	"fmt"
 8 | 	"html/template"
 9 | 	"net/http"
10 | )
11 | 
12 | 
13 | func StaticHandler(res http.ResponseWriter, req *http.Request) {
14 | 	t, err := template.ParseFiles("I:\\ubuntu14.04\\share\\docker\\go\\www\\src\\github.com\\kong36088\\danmu\\client\\index.html")
15 | 	if err != nil {
16 | 		fmt.Println(err)
17 | 		return
18 | 	}
19 | 	err = WriteTemplateToHttpResponse(res, t)
20 | 	if err != nil {
21 | 		fmt.Println(err)
22 | 		return
23 | 	}
24 | }
25 | 
26 | func WriteTemplateToHttpResponse(res http.ResponseWriter, t *template.Template) error {
27 | 	if t == nil || res == nil {
28 | 		return errors.New("WriteTemplateToHttpResponse: t must not be nil.")
29 | 	}
30 | 	var buf bytes.Buffer
31 | 	err := t.Execute(&buf, nil)
32 | 	if err != nil {
33 | 		return err
34 | 	}
35 | 	res.Header().Set("Content-Type", "text/html; charset=utf-8")
36 | 	_, err = res.Write(buf.Bytes())
37 | 	return err
38 | }


--------------------------------------------------------------------------------
/utils/concurrent_list.go:
--------------------------------------------------------------------------------
 1 | package utils
 2 | 
 3 | import (
 4 | 	"container/list"
 5 | 	"sync"
 6 | )
 7 | 
 8 | type ConcurrentList struct {
 9 | 	lock *sync.RWMutex
10 | 	list *list.List
11 | }
12 | 
13 | func NewConcurrentList() *ConcurrentList {
14 | 	return &ConcurrentList{
15 | 		lock: &sync.RWMutex{},
16 | 		list: list.New(),
17 | 	}
18 | }
19 | 
20 | func (cl *ConcurrentList) PushBack(v interface{}) *list.Element {
21 | 	cl.lock.Lock()
22 | 
23 | 	ele := cl.list.PushBack(v)
24 | 
25 | 	cl.lock.Unlock()
26 | 
27 | 	return ele
28 | }
29 | 
30 | func (cl *ConcurrentList) Pop() interface{} {
31 | 	cl.lock.Lock()
32 | 
33 | 	value := cl.list.Remove(cl.list.Back())
34 | 
35 | 	cl.lock.Unlock()
36 | 
37 | 	return value
38 | }
39 | 
40 | func (cl *ConcurrentList) PopAll() []interface{} {
41 | 	datas := make([]interface{}, 0, cl.Len())
42 | 
43 | 	if cap(datas) > 0 {
44 | 		cl.lock.Lock()
45 | 
46 | 		for i := 0; i < cap(datas); i++ {
47 | 			datas = append(datas, cl.list.Remove(cl.list.Front()))
48 | 		}
49 | 		cl.lock.Unlock()
50 | 
51 | 		return datas
52 | 	} else {
53 | 		return nil
54 | 	}
55 | 
56 | }
57 | 
58 | func (cl *ConcurrentList) Back() *list.Element {
59 | 	cl.lock.RLock()
60 | 
61 | 	ele := cl.list.Back()
62 | 
63 | 	cl.lock.RUnlock()
64 | 
65 | 	return ele
66 | }
67 | 
68 | func (cl *ConcurrentList) Front() *list.Element {
69 | 	cl.lock.RLock()
70 | 
71 | 	ele := cl.list.Front()
72 | 
73 | 	cl.lock.RUnlock()
74 | 
75 | 	return ele
76 | }
77 | 
78 | func (cl *ConcurrentList) Len() int {
79 | 	cl.lock.RLock()
80 | 
81 | 	length := cl.list.Len()
82 | 
83 | 	cl.lock.RUnlock()
84 | 
85 | 	return length
86 | }
87 | 


--------------------------------------------------------------------------------
/ws_server.go:
--------------------------------------------------------------------------------
  1 | package danmu
  2 | 
  3 | import (
  4 | 	"github.com/Shopify/sarama"
  5 | 	log "github.com/alecthomas/log4go"
  6 | 	"github.com/gorilla/websocket"
  7 | 	"net/http"
  8 | 	"strconv"
  9 | 	"strings"
 10 | 	"time"
 11 | )
 12 | 
 13 | const (
 14 | 	writeWait   = time.Second
 15 | 	roomIdFiled = "room"
 16 | )
 17 | 
 18 | //TODO 在线人数
 19 | var
 20 | (
 21 | 	upgrader = websocket.Upgrader{
 22 | 		ReadBufferSize:  1024,
 23 | 		WriteBufferSize: 1024,
 24 | 		CheckOrigin: func(r *http.Request) bool {
 25 | 			return true
 26 | 		}, // 解决域不一致的问题
 27 | 	} // 将http升级为websocket
 28 | )
 29 | 
 30 | func onConnect(w http.ResponseWriter, r *http.Request) {
 31 | 	conn, err := upgrader.Upgrade(w, r, nil)
 32 | 	if err != nil {
 33 | 		log.Error(err)
 34 | 		return
 35 | 	}
 36 | 	client := NewClient(0, conn)
 37 | 	roomId := r.FormValue(roomIdFiled)
 38 | 	roomIdi, err := strconv.Atoi(roomId)
 39 | 	if err != nil {
 40 | 		client.WriteErrorMsg("incorrect roomId.")
 41 | 		cleaner.CleanClient(client)
 42 | 		log.Error("Parse roomid failed, roomid: %s, err: %s\n", roomId, err)
 43 | 		return
 44 | 	}
 45 | 	room, err := roomBucket.Get(rid(roomIdi))
 46 | 	if err != nil {
 47 | 		client.WriteErrorMsg("Room does not exist.")
 48 | 		cleaner.CleanClient(client)
 49 | 		log.Error("Room does not exist, roomid: %s, err: %s\n", roomId, err)
 50 | 		return
 51 | 	}
 52 | 	client.RoomId = rid(roomIdi)
 53 | 	room.AddClient(client)
 54 | 
 55 | 	clientBucket.Add(client)
 56 | 
 57 | 	//send
 58 | 	go listen(client)
 59 | 	go client.keepAlive()
 60 | 
 61 | }
 62 | 
 63 | // listen  message that receive from client
 64 | // should be called by goroutines
 65 | func listen(client *Client) {
 66 | 	defer cleaner.CleanClient(client)
 67 | 	for {
 68 | 		proto := Proto{}
 69 | 		err := client.ReadJSON(&proto)
 70 | 		if err != nil {
 71 | 			if websocket.IsCloseError(err, websocket.CloseGoingAway, websocket.CloseNoStatusReceived) {
 72 | 				return
 73 | 			} else {
 74 | 				log.Error(err)
 75 | 				return
 76 | 			}
 77 | 		}
 78 | 		log.Debug(proto)
 79 | 		msg := &sarama.ProducerMessage{
 80 | 			Topic: Topic,
 81 | 			Value: sarama.ByteEncoder(proto.JsonEncode()),
 82 | 		}
 83 | 		producer.Input() <- msg
 84 | 	}
 85 | }
 86 | 
 87 | func StartServer() {
 88 | 	var (
 89 | 		err error
 90 | 	)
 91 | 	if err = InitConfig(); err != nil {
 92 | 		panic(err)
 93 | 	}
 94 | 
 95 | 	if err = InitLog(); err != nil {
 96 | 		panic(err)
 97 | 	}
 98 | 	defer CloseLog()
 99 | 	log.Info("danmu server start")
100 | 
101 | 	kafkaAddrs := Conf.GetConfig("kafka", "address")
102 | 	kafkaAddr := strings.Split(kafkaAddrs, ",")
103 | 
104 | 	if err = InitKafka(kafkaAddr); err != nil {
105 | 		log.Exit(err)
106 | 	}
107 | 	defer CloseKafka()
108 | 
109 | 	if err = InitRoomBucket(); err != nil {
110 | 		log.Exit(err)
111 | 	}
112 | 
113 | 	if err = InitClientBucket(); err != nil {
114 | 		log.Exit(err)
115 | 	}
116 | 
117 | 	if err = InitCleaner(); err != nil {
118 | 		log.Exit(err)
119 | 	}
120 | 
121 | 	// http.HandleFunc("/", StaticHandler)
122 | 	http.HandleFunc("/ws", onConnect)
123 | 
124 | 	if err = InitMessageHandler(); err != nil {
125 | 		log.Exit(err)
126 | 	}
127 | 	go messageHandler()
128 | 
129 | 	addr := ":" + Conf.GetConfig("sys", "port")
130 | 	err = http.ListenAndServe(addr, nil)
131 | 	if err != nil {
132 | 		log.Exit(err)
133 | 	}
134 | }
135 | 


--------------------------------------------------------------------------------