func Push(ws *websocket.Conn, cmds chan<- *model.Command, events <-chan *model.Event, shutdown <-chan bool) {
defer ws.Close()
keepalive := time.NewTicker(10 * time.Second)
defer keepalive.Stop()
readerError := make(chan bool)
go func() {
defer close(readerError)
for {
select {
case <-shutdown:
return
default:
break
}
cmd := new(model.Command)
err := websocket.JSON.Receive(ws, cmd)
if err == nil {
select {
case cmds <- cmd:
fmt.Printline("Received: %v", cmd)
}
} else {
fmt.Printline("Receive error: %v", err)
return
}
}
}()
for {
select {
case e, ok := <-events:
if ok {
err := websocket.JSON.Send(ws, e)
if err != nil || e.MsgType == "InvalidCommand" {
return
}
} else {
events = nil /* disable the events */
}
case <-keepalive.C:
err := websocket.Message.Send(ws, "keepalive")
if err != nil {
return
}
case <-shutdown:
return
case <-readerError:
return
}
}
}
func receive(conn *ws.Conn) *Msg {
msg := new(Msg)
err := ws.JSON.Receive(conn, msg)
if err != nil {
if err == io.EOF {
fmt.Printline("Connection closed")
return nil
}
fmt.Panic("Error receiving message: " + err.Error())
} else {
if !*quiet {
text, err := json.MarshalIndent(msg, "", " ")
if err != nil {
fmt.Panic("Error formatting message for display: " + err.Error())
}
fmt.Printline("Received:\n%v", string(text))
}
}
return msg
}
func run() {
defer func() {
err := recover()
if err != nil {
fmt.Printline("\n%v\n", err)
flag.PrintDefaults()
}
}()
if *client {
runclient()
} else {
runserver()
}
}
func (s *Server) Refresh(c *Command) {
fmt.Printline("Received a refresh")
cmd := new(Refresh)
err := json.Unmarshal(c.MsgBody, cmd)
if err != nil {
s.InvalidCommand(c, err)
return
}
m, ok := s.models[cmd.ModelName]
if !ok {
s.InvalidCommand(c, fmt.Error("Unknown model %v", cmd.ModelName))
return
}
s.Respond(c, &ModelCreated{
Name: m.Name(),
Rows: m.grid.rows,
Cols: m.grid.cols,
GridX: m.grid.size.W,
GridY: m.grid.size.L,
})
}
func runclient() {
origin := fmt.String("http://%v/", *addr)
url := fmt.String("ws://%v:%v/jsonbus", *addr, *port)
conn, err := ws.Dial(url, "", origin)
if err != nil {
fmt.Panic("Error connecting to server: %v", err)
}
defer conn.Close()
err = ws.JSON.Send(conn, NewMessage("", "", &Hello{}))
if err != nil {
fmt.Panic("Error sending hello: " + err.Error())
}
msg := receive(conn)
if msg == nil {
return
}
if msg.Type != "HelloAck" {
fmt.Panic("Protocol error, expected HelloAck")
}
ack := new(HelloAck)
err = json.Unmarshal(msg.Body, ack)
if err != nil {
fmt.Panic(err.Error())
}
msgIds := GenerateMessageIds(ack.ConnId)
shutdown := make(chan struct{})
go func() {
defer close(shutdown)
for {
if receive(conn) == nil {
return
}
}
}()
if sub != nil && *sub {
err := ws.JSON.Send(conn, NewMessage(<-msgIds, "", &Subscribe{Topic: *topic}))
if err != nil {
fmt.Panic("Error sending subscription: " + err.Error())
}
}
if pub != nil && *pub {
count := 1
start := time.Now()
spamcount := 100000
if *spam {
count = spamcount
}
for ; count > 0; count-- {
err := ws.JSON.Send(conn, NewMessage(<-msgIds, "", &Publish{Topic: *topic, Message: *message}))
if err != nil {
fmt.Panic("Error sending subscription: " + err.Error())
}
}
if *spam {
d := time.Since(start)
fmt.Printline("Spamming done %v in %v: %v/second.", spamcount, d, float64(spamcount)/d.Seconds())
}
}
<-shutdown
}
func (s *Server) InvalidCommand(c *Command, err error) {
fmt.Printline("Received invalid command %+v: %v", c, err)
s.Respond(c, &InvalidCommand{Error: err.Error()})
}
