websocket client

client.go

package main

import (
	"bufio"
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"net/url"
	"os"
	"os/signal"
	"strings"
	"time"

	"github.com/gorilla/websocket"
)

type message struct {
	Action    string `json:"action"`
	Payload   string `json:"payload"`
	Recipient string `json:"recipient"`
}

var addr = flag.String("addr", "localhost:8080", "http service address")
var mode = flag.String("mode", "player", "player or dm mode")

func createMessage(command string) message {
	action := strings.Trim(command, " ")
	tokens := strings.Split(action, " ")

	switch tokens[0] {
	case "/msg":
		return message{Action: "say", Payload: action, Recipient: tokens[1]}
	case "/setname":
		return message{Action: "setname", Payload: tokens[1], Recipient: ""}
	case "/whisper":
		return message{Action: "whisper", Payload: tokens[2], Recipient: tokens[1]}
	case "/list":
		return message{Action: "list", Payload: "", Recipient: ""}
	case "/file":
		return message{Action: "file", Payload: tokens[1], Recipient: ""}
	}

	return message{Action: "say", Payload: action, Recipient: "all"}

}

func writeFile(message []byte, fileName string) {
	f, err := os.Create(fileName)
	if err != nil {
		log.Printf("error creating file: %s\n", err)
		return
	}
	defer f.Close()

	w := bufio.NewWriter(f)
	n4, err := w.Write(message)
	if err != nil {
		log.Printf("error writing file: %s\n", err)
		return
	}
	log.Printf("Wrote %d bytes\n", n4)
	w.Flush()
}

func main() {
	flag.Parse()
	log.SetFlags(0)

	interrupt := make(chan os.Signal, 1)
	signal.Notify(interrupt, os.Interrupt)

	u := url.URL{Scheme: "ws", Host: *addr, Path: "/receive"}
	log.Printf("connecting to %s", u.String())

	c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
	if err != nil {
		log.Fatal("dial:", err)
	}
	defer c.Close()

	done := make(chan struct{})

	go func() {
		defer close(done)
		for {
			msgType, message, err := c.ReadMessage()
			if err != nil {
				log.Println("error read: ", err)
				return
			}
			if msgType == websocket.TextMessage {
				log.Printf("recv: %s", message)
			}
			if msgType == websocket.BinaryMessage {
				writeFile(message, "example.mp3")
			}
		}
	}()

	if *mode == "dm" {
		fmt.Print("*** Welcome master! ***\n")
		reader := bufio.NewReader(os.Stdin)
		go func() {
			for {
				text, _ := reader.ReadString('\n')
				// convert CRLF to LF
				text = strings.Replace(text, "\n", "", -1)

				msg := createMessage(text)
				packet, err := json.Marshal(msg)
				if err != nil {
					log.Println("write:", err)
					return
				}

				err = c.WriteMessage(websocket.TextMessage, []byte(packet))
				if err != nil {
					log.Println("write:", err)
					return
				}
			}
		}()
	}

	for {
		select {
		case <-done:
			return
		case <-interrupt:
			// Cleanly close the connection by sending a close message and then
			// waiting (with timeout) for the server to close the connection.
			log.Println("interrupt")
			err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
			if err != nil {
				log.Println("write close:", err)
				return
			}
			select {
			case <-done:
			case <-time.After(time.Second):
			}
			return
		}
	}
}