A working Websocket implementation

Author: gernest

README.md

@@ -1,2 +1,24 @@
 # chat
 Simple chat application with utron
+
+This is implementation of a chat application that ports [revel based chat
+application](https://revel.github.io/samples/chat.html) to use utron framework.
+
+# Prerequisite
+
+You only need a working Go environment
+
+# Installation
+```
+go get github.com/utronframework/chat
+```
+
+# Running the application
+
+```
+ cd $GOPATH/github.com/utronframework/chat
+ go run main.go
+```
+
+# screen shot
+![chat app with utron](screenshot.png)

chatroom/chatroom.go

@@ -0,0 +1,114 @@
+package chatroom
+
+import (
+	"container/list"
+	"time"
+)
+
+type Event struct {
+	Type      string // "join", "leave", or "message"
+	User      string
+	Timestamp int    // Unix timestamp (secs)
+	Text      string // What the user said (if Type == "message")
+}
+
+type Subscription struct {
+	Archive []Event      // All the events from the archive.
+	New     <-chan Event // New events coming in.
+}
+
+// Owner of a subscription must cancel it when they stop listening to events.
+func (s Subscription) Cancel() {
+	unsubscribe <- s.New // Unsubscribe the channel.
+	drain(s.New)         // Drain it, just in case there was a pending publish.
+}
+
+func newEvent(typ, user, msg string) Event {
+	return Event{typ, user, int(time.Now().Unix()), msg}
+}
+
+func Subscribe() Subscription {
+	resp := make(chan Subscription)
+	subscribe <- resp
+	return <-resp
+}
+
+func Join(user string) {
+	publish <- newEvent("join", user, "")
+}
+
+func Say(user, message string) {
+	publish <- newEvent("message", user, message)
+}
+
+func Leave(user string) {
+	publish <- newEvent("leave", user, "")
+}
+
+const archiveSize = 10
+
+var (
+	// Send a channel here to get room events back.  It will send the entire
+	// archive initially, and then new messages as they come in.
+	subscribe = make(chan (chan<- Subscription), 10)
+	// Send a channel here to unsubscribe.
+	unsubscribe = make(chan (<-chan Event), 10)
+	// Send events here to publish them.
+	publish = make(chan Event, 10)
+)
+
+// This function loops forever, handling the chat room pubsub
+func chatroom() {
+	archive := list.New()
+	subscribers := list.New()
+
+	for {
+		select {
+		case ch := <-subscribe:
+			var events []Event
+			for e := archive.Front(); e != nil; e = e.Next() {
+				events = append(events, e.Value.(Event))
+			}
+			subscriber := make(chan Event, 10)
+			subscribers.PushBack(subscriber)
+			ch <- Subscription{events, subscriber}
+
+		case event := <-publish:
+			for ch := subscribers.Front(); ch != nil; ch = ch.Next() {
+				ch.Value.(chan Event) <- event
+			}
+			if archive.Len() >= archiveSize {
+				archive.Remove(archive.Front())
+			}
+			archive.PushBack(event)
+
+		case unsub := <-unsubscribe:
+			for ch := subscribers.Front(); ch != nil; ch = ch.Next() {
+				if ch.Value.(chan Event) == unsub {
+					subscribers.Remove(ch)
+					break
+				}
+			}
+		}
+	}
+}
+
+func init() {
+	go chatroom()
+}
+
+// Helpers
+
+// Drains a given channel of any messages.
+func drain(ch <-chan Event) {
+	for {
+		select {
+		case _, ok := <-ch:
+			if !ok {
+				return
+			}
+		default:
+			return
+		}
+	}
+}

config/app.yml

@@ -0,0 +1,10 @@
+app_name: utron chat application
+base_url: http://localhost:8090
+port: 8090
+verbose: false
+static_dir: public
+view_dir: views
+database: ""
+database_conn: ""
+automigrate: true
+no_model: true

controllers/app.go

@@ -0,0 +1,38 @@
+package controllers
+
+import (
+	"net/http"
+
+	"github.com/gernest/utron/controller"
+)
+
+type App struct {
+	controller.BaseController
+	Routes []string
+}
+
+func (a *App) Index() {
+	a.Ctx.Template = "Application/Index"
+	a.Ctx.Data["title"] = "Sign in"
+	a.HTML(http.StatusOK)
+}
+
+func (a *App) Demo() {
+	r := a.Ctx.Request()
+	r.ParseForm()
+	user := r.FormValue("user")
+	demo := r.FormValue("demo")
+	switch demo {
+	case "websocket":
+		a.Ctx.Redirect("/websocket/room?user="+user, http.StatusFound)
+	}
+}
+
+func NewApp() controller.Controller {
+	return &App{
+		Routes: []string{
+			"get;/;Index",
+			"get;/demo;Demo",
+		},
+	}
+}

controllers/refresh.go

@@ -0,0 +1,31 @@
+package controllers
+
+import "github.com/gernest/utron/controller"
+
+type Refresh struct {
+	controller.BaseController
+	Routes []string
+}
+
+func (c Refresh) Index() {
+}
+
+func (c Refresh) Room() {
+}
+
+func (c Refresh) Say(user, message string) {
+}
+
+func (c Refresh) Leave(user string) {
+}
+
+func NewRefresh() controller.Controller {
+	return &Refresh{
+		Routes: []string{
+			"get;/refresh;Index",
+			"get;/refresh/room;Room",
+			"post;/refresh/room;Say",
+			"post;/refresh/room/leave;Leave",
+		},
+	}
+}

controllers/websocket.go

@@ -0,0 +1,97 @@
+package controllers
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/gernest/utron/controller"
+	"github.com/gorilla/websocket"
+	"github.com/utronframework/chat/chatroom"
+)
+
+var upgrader = websocket.Upgrader{
+	ReadBufferSize:  1024,
+	WriteBufferSize: 1024,
+}
+
+type Websocket struct {
+	controller.BaseController
+	Routes []string
+}
+
+func (w *Websocket) Room() {
+	r := w.Ctx.Request()
+	user := r.URL.Query().Get("user")
+	w.Ctx.Data["title"] = "Chat Room"
+	w.Ctx.Data["user"] = user
+	w.Ctx.Template = "WebSocket/Room"
+	w.HTML(http.StatusOK)
+}
+
+func (w *Websocket) RoomSocket() {
+	fmt.Println("HOME WS")
+	r := w.Ctx.Request()
+	res := w.Ctx.Response()
+	user := r.URL.Query().Get("user")
+	conn, err := upgrader.Upgrade(res, r, nil)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	subscription := chatroom.Subscribe()
+	defer subscription.Cancel()
+
+	chatroom.Join(user)
+	defer chatroom.Leave(user)
+
+	// Send down the archive.
+	for _, event := range subscription.Archive {
+		if conn.WriteJSON(event) != nil {
+			return
+		}
+	}
+
+	// In order to select between websocket messages and subscription events, we
+	// need to stuff websocket events into a channel.
+	newMessages := make(chan string)
+	go func() {
+		for {
+			_, b, err := conn.ReadMessage()
+			if err != nil {
+				close(newMessages)
+				return
+			}
+			newMessages <- string(b)
+		}
+	}()
+
+	// Now listen for new events from either the websocket or the chatroom.
+	for {
+		select {
+		case event := <-subscription.New:
+			if conn.WriteJSON(&event) != nil {
+				return
+			}
+		case msg, ok := <-newMessages:
+			// If the channel is closed, they disconnected.
+			if !ok {
+				return
+			}
+
+			// Otherwise, say something.
+			chatroom.Say(user, msg)
+		}
+	}
+	return
+}
+
+func NewWebsocket() controller.Controller {
+	return &Websocket{
+		Routes: []string{
+			"get;/websocket/room;Room",
+			"get;/websocket/room/socket;RoomSocket",
+		},
+	}
+}

main.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+
+	"github.com/gernest/utron"
+	"github.com/utronframework/chat/controllers"
+)
+
+func main() {
+
+	// Start the MVC App
+	app, err := utron.NewMVC()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Register Controllers
+	app.AddController(controllers.NewApp)
+	app.AddController(controllers.NewWebsocket)
+	app.AddController(controllers.NewRefresh)
+
+	// Start the server
+	port := fmt.Sprintf(":%d", app.Config.Port)
+	app.Log.Info("staring server on port", port)
+	log.Fatal(http.ListenAndServe(port, app))
+}

public/images/favicon.png

@@ -0,0 +1,36 @@
+
+// Simple JavaScript Templating
+// John Resig - http://ejohn.org/ - MIT Licensed
+(function(){
+  var cache = {};
+ 
+  this.tmpl = function tmpl(str, data){
+    // Figure out if we're getting a template, or if we need to
+    // load the template - and be sure to cache the result.
+    var fn = !/\W/.test(str) ?
+      cache[str] = cache[str] ||
+        tmpl(document.getElementById(str).innerHTML) :
+     
+      // Generate a reusable function that will serve as a template
+      // generator (and which will be cached).
+      new Function("obj",
+        "var p=[],print=function(){p.push.apply(p,arguments);};" +
+       
+        // Introduce the data as local variables using with(){}
+        "with(obj){p.push('" +
+       
+        // Convert the template into pure JavaScript
+        str
+          .replace(/[\r\t\n]/g, " ")
+          .split("<%").join("\t")
+          .replace(/((^|%>)[^\t]*)'/g, "$1\r")
+          .replace(/\t=(.*?)%>/g, "',$1,'")
+          .split("\t").join("');")
+          .split("%>").join("p.push('")
+          .split("\r").join("\\'")
+      + "');}return p.join('');");
+   
+    // Provide some basic currying to the user
+    return data ? fn( data ) : fn;
+  };
+})();