139 lines
3.1 KiB
Go
139 lines
3.1 KiB
Go
package server
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/andig/evcc/core"
|
|
"github.com/gorilla/websocket"
|
|
)
|
|
|
|
const (
|
|
// Time allowed to write a message to the peer
|
|
socketWriteTimeout = 10 * time.Second
|
|
)
|
|
|
|
var upgrader = websocket.Upgrader{
|
|
ReadBufferSize: 1024,
|
|
WriteBufferSize: 1024,
|
|
CheckOrigin: func(r *http.Request) bool { return true },
|
|
}
|
|
|
|
// SocketClient is a middleman between the websocket connection and the hub.
|
|
type SocketClient struct {
|
|
hub *SocketHub
|
|
|
|
// The websocket connection.
|
|
conn *websocket.Conn
|
|
|
|
// Buffered channel of outbound messages.
|
|
send chan []byte
|
|
}
|
|
|
|
// writePump pumps messages from the hub to the websocket connection.
|
|
func (c *SocketClient) writePump() {
|
|
defer c.conn.Close()
|
|
|
|
for msg := range c.send {
|
|
if err := c.conn.SetWriteDeadline(time.Now().Add(socketWriteTimeout)); err != nil {
|
|
return
|
|
}
|
|
if err := c.conn.WriteMessage(websocket.TextMessage, msg); err != nil {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// ServeWebsocket handles websocket requests from the peer.
|
|
func ServeWebsocket(hub *SocketHub, w http.ResponseWriter, r *http.Request) {
|
|
conn, err := upgrader.Upgrade(w, r, nil)
|
|
if err != nil {
|
|
log.ERROR.Println(err)
|
|
return
|
|
}
|
|
client := &SocketClient{hub: hub, conn: conn, send: make(chan []byte, 256)}
|
|
client.hub.register <- client
|
|
|
|
// run writing to client in goroutine
|
|
go client.writePump()
|
|
}
|
|
|
|
// SocketHub maintains the set of active clients and broadcasts messages to the
|
|
// clients.
|
|
type SocketHub struct {
|
|
// Registered clients.
|
|
clients map[*SocketClient]bool
|
|
|
|
// Register requests from the clients.
|
|
register chan *SocketClient
|
|
|
|
// Unregister requests from clients.
|
|
unregister chan *SocketClient
|
|
}
|
|
|
|
// NewSocketHub creates a web socket hub that distributes meter status and
|
|
// query results for the ui or other clients
|
|
func NewSocketHub() *SocketHub {
|
|
return &SocketHub{
|
|
register: make(chan *SocketClient),
|
|
unregister: make(chan *SocketClient),
|
|
clients: make(map[*SocketClient]bool),
|
|
}
|
|
}
|
|
|
|
func encode(v interface{}) (string, error) {
|
|
var s string
|
|
switch val := v.(type) {
|
|
case time.Duration:
|
|
// must be before stringer to convert to seconds instead of string
|
|
s = fmt.Sprintf("%d", int64(val.Seconds()))
|
|
case fmt.Stringer, string:
|
|
s = fmt.Sprintf("\"%s\"", val)
|
|
case float64:
|
|
s = fmt.Sprintf("%.3f", val)
|
|
default:
|
|
s = fmt.Sprintf("%v", val)
|
|
}
|
|
return s, nil
|
|
}
|
|
|
|
func (h *SocketHub) broadcast(i core.Param) {
|
|
if len(h.clients) > 0 {
|
|
val, err := encode(i.Val)
|
|
if err != nil {
|
|
log.FATAL.Fatal(err)
|
|
}
|
|
message := fmt.Sprintf("{\"%s\": %s}", i.Key, val)
|
|
|
|
for client := range h.clients {
|
|
select {
|
|
case client.send <- []byte(message):
|
|
default:
|
|
close(client.send)
|
|
delete(h.clients, client)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Run starts data and status distribution
|
|
func (h *SocketHub) Run(in <-chan core.Param, triggerChan chan<- struct{}) {
|
|
for {
|
|
select {
|
|
case client := <-h.register:
|
|
h.clients[client] = true
|
|
triggerChan <- struct{}{} // trigger loadpoint update
|
|
case client := <-h.unregister:
|
|
if _, ok := h.clients[client]; ok {
|
|
close(client.send)
|
|
delete(h.clients, client)
|
|
}
|
|
case msg, ok := <-in:
|
|
if !ok {
|
|
return // break if channel closed
|
|
}
|
|
h.broadcast(msg)
|
|
}
|
|
}
|
|
}
|