Dont Call Us We Will Call You
Tags: go, sse, http2, serverpush
Published: 2020-08-31 07:40:06

---
title: Dont Call Us We Will Call You
published: true
date: 2018-03-29 11:28:58 UTC
tags: ["golang", "sse", "http2", "serverpush"]
canonical_url: https://www.turtle-techies.com/post/dont-call-us-we-will-call-you/
---


## Motivation

Recently, more and more websites, servers and tools are starting to adopt http2. What started as <a href="https://en.wikipedia.org/wiki/SPDY" target="_blank">SPDY</a> somewhere around 2012, evolved and accepted as http2 around 2015.  
After some reading about <a href="https://medium.com/@whale_eat_squid/why-http-2-isnt-the-answer-35ba28ad8dc3" target="_blank">some of the benfits of http2</a> I decided I have to give it a try.  
Basically, I wanted to build a very simple "event driven" app that will use http2's server push.  
This was my general idea:  

* Users get an SPA ui that allows them to read "live" messages
* The ui is served using server push over http2
* Messages are read from some kind of queue
* The user gets the messages as soon as they come 
* Messages come from some source (doesn't matter)
* Use polling as less as possible

The final code is at <a href="https://github.com/asafg6/MessagesAppPOC" target="_blank">https://github.com/asafg6/MessagesAppPOC</a>.  
Want to know how I got there? Keep reading. 

## Client Updates

The first thing I thought about, was how will the client recieve updates from the server. My line of thought automatically went towards websockets, which provides full duplex communication. Webscokets have been around for a while now and are supported in the popular browsers, so they make a nice choice. However, I wanted to use http2, but websockets are only using it to open the initial connection, the actual streaming just uses tcp. After some research, I came accross <a href="https://www.smashingmagazine.com/2018/02/sse-websockets-data-flow-http2/" target="_blank">this article</a>, by Martin Chaov. The article compares between long polling, websockets and server sent events. I have never used server sent events and also never got the reassuring "We use it in production" statement from anyone. In any case, this sounded like the best solution for what I wanted.  
Here's what Martin wrote about server sent events:  

>It works as expected and looks like magic at first. We get everything we want for our application to work in an efficient way. As with all things that look too good to be true, we sometimes face some issues that need to be addressed. However, they are not complicated to implement or go around

The most important things I got out from reading this are:

1. Connections will be multiplexed over http2
2. Clients that disconnect will automatically try to reconnect

Sounds perfect. As I chose Go for the server I just had to find an implementation for SSE.

## Server Sent Events In Go

Go gives you a low level api that you can use in order to implement server sent events. You can cast **http.ResponseWriter** in to a **http.Flusher**. All you need to do is write to the responseWriter in the right format and after you are done call flusher.Flush().  
I wanted to avoid reinventing the wheel, so I started looking for Go packages that implement an SSE server. Quick google search revealed some implementations, for example <a href="https://github.com/julienschmidt/sse" target ="_blank">https://github.com/julienschmidt/sse</a> and <a href="https://github.com/alexandrevicenzi/go-sse" target="_blank">https://github.com/alexandrevicenzi/go-sse</a> (there are more). I went through the sources and found a lot of stuff I didn't expect to find. Channels, maps, configurations, goroutines and more. Certainly a lot more than I needed, or to be more accurate - a lot of stuff I just don't need. I was really tempted to use one of the packages, their code was neatly written and looked pretty decent. However, taking into consideration the low amount of github stars on the packages I found and the high amount of bells and whistles, I decided to roll my own.  
You can find my implementation at <a href="https://github.com/asafg6/sse_handler" target="_blank">https://github.com/asafg6/sse_handler</a>, it's around 70 lines of code and it has no sophisitication whatsoever.
Basically, it provides a function that wraps your "for loop" function that you'll use to send events to the client and returns a **func(http.ResponseWriter, *http.Request)** that you can then pass to http.Handle.
So, after some coding and debugging, I was satisfied with my solution. 

## Server Push

Multiplexing is great, but server push should save precious milliseconds. The problem is, how do you know in advance what paths the client is going to ask for? The very simple solution would be to hold a list of paths in a configuration file and let the server read it when it starts. Don't take my word for it, check out <a href="https://www.nginx.com/blog/nginx-1-13-9-http2-server-push/" target="_blank">Nginx 1.13.9</a>.The thing is... For this POC, I built a small React app using <a href="https://github.com/facebook/create-react-app" target="_blank">Create-React-App</a>. Everytime you build your React app for production it generates js files with hashes (using webpack plugin). As a side note, maybe regular expressions support will offer a better solution? I decided to keep it as simple as possible. Just put all the files that the React build script generates in a list and push them whenever index.html is requested, assuming that the client will request them at some point.
The go interface for server push looks like this:  
**From <a href="https://blog.golang.org/h2push" target="_blank">https://blog.golang.org/h2push</a>**
```go
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if pusher, ok := w.(http.Pusher); ok {
            // Push is supported.
            if err := pusher.Push("/app.js", nil); err != nil {
                log.Printf("Failed to push: %v", err)
            }
        }
        // ...
    })
```

Here is my implementation:  
```go
func serveIndex(w http.ResponseWriter, r *http.Request) {
	log.Println("serving index.html")
	pusher, ok := w.(http.Pusher)
	if ok {
		log.Println("Push is supported")
		for _, path := range pushPaths {
			if err := pusher.Push(path , nil); err != nil {
				log.Printf("Failed to push: %v", err)
			} else {
				log.Printf("Pushed %v", path)
			}
		}
	}
	http.ServeFile(w, r, client_dir + "/index.html")
}

func visit(path string, f os.FileInfo, err error) error {
	if !f.IsDir() && !strings.Contains(path, "index.html") {
		pushPaths = append(pushPaths, strings.TrimPrefix(path, client_dir))
	}
	return nil
}

func fillPushPaths() {
	pushPaths = make([]string, 0)
	err := filepath.Walk(client_dir, visit)
	if err != nil {
		log.Printf("filepath.Walk() returned %v\n", err)
	}
	log.Println(pushPaths)
}

```

## Broadcasting Messages

After deciding on the infrastructure, I had to find a way to broadcast messages efficiently throughout my app. The Go standard way for communicating between goroutines is to use channels. After some research, I found out that the concurrency pattern I am looking for is "fan out". You can see an example of the "fan out" pattern in this <a href="https://stackoverflow.com/questions/16930251/go-one-producer-many-consumers" target="_blank">StackOverflow question</a>. This pattern is quite nice, but it seems that opening a channel for each consumer is a waste. Especially in the case where all consumers need to get the same value. After some thinking, I decided to use shared memory. Instead of using channels, my idea was to use a linked list that will always return the current item. Each item will have a next function that will block until the next item will be available. Go has tools for such cases, **sync.Cond** lets you block until something happens with **cond.wait()**. When something does happen you can use **Broadcast** to wake up all the goroutines waiting.
Here's what I came up with at first:  
```go
package messages

import (
	"sync"
)

type BroadcastChannel struct {
	channelItem *ChannelItem
	lock sync.Mutex
}

func (channel *BroadcastChannel) Listen() *ChannelItem {
	channel.lock.Lock()
	defer channel.lock.Unlock()
	return channel.channelItem
}


func (channel *BroadcastChannel) Publish(data interface{}) {
	channel.lock.Lock()
	defer channel.lock.Unlock()
	newItem := MakeNewChannelItem(data)
	channel.channelItem.setNext(newItem)
	channel.channelItem = newItem
}


func MakeNewBroadcastChannel() *BroadcastChannel {
	m := sync.Mutex{}
	nilItem := MakeNewChannelItem(nil)
	return &BroadcastChannel{channelItem: nilItem, lock: m}
}

type ChannelItem struct {
	next *ChannelItem
	cond *sync.Cond
	data interface{}
}

func (channelItem *ChannelItem) GetNextMessageOrWait() *ChannelItem {
	channelItem.cond.L.Lock()
	defer channelItem.cond.L.Unlock()
	for channelItem.next == nil {
		channelItem.cond.Wait()
	}
	return channelItem.next
}

func (channelItem *ChannelItem) setNext(next *ChannelItem) {
	channelItem.cond.L.Lock()
	defer channelItem.cond.L.Unlock()
	channelItem.next = next
	channelItem.cond.Broadcast()

}

func (channelItem *ChannelItem) GetData() interface{} {
	return channelItem.data
}

func MakeNewChannelItem(data interface{}) *ChannelItem {
	m := sync.Mutex{}
	cond := sync.NewCond(&m)
	return &ChannelItem{data:data, cond:cond}
}

```

This implementation kind of behaves like a channel, blocking until there's a value.  
After some more coding, I found out that this implemenatation has a very strong down side - it can't be canceled. In a case that a client disconnects the code keeps blocking and the goroutine becomes a memory leak. There's no way to cancel a goroutine from outside, it has to "die" on it's own. Go's SSE interface gives you a channel that tells you when the client disconnects, so naturally I wanted a way to use that. 
Here's my solution:  
```go
...

func (channelItem *ChannelItem) GetNextMessageOrWaitWithClose(close <- chan bool) *ChannelItem {

	waitChan := make( chan struct{})
	go func() {
		channelItem.cond.L.Lock()
		defer channelItem.cond.L.Unlock()
		channelItem.cond.Wait()
		waitChan <- struct {}{}
	} ()
	select {
	case _, _ = <- waitChan:
		return channelItem.next
	case _, ok := <- close:
		if ok {
			return nil
		}

	}
	return channelItem.next
}
...
```
As you can see, in the end I had to use what I was trying to avoid... a channel for each goroutine. However, this channel is an empty one so it hardly takes any memory, so it's the lesser evil. I could avoid using the **waitChan** if Go's select block supported waiting on a variable, but anyway, it gets the job done.  


## Someone Has To Poll Eventually

PubSub systems are the obvious tool for broadcasting messages. What I needed is a PubSub that lets you publish from one producer to many consumers, and can be clusterized. After some searching, I found out that Redis PUBSUB fits perfectly. Redis PUBSUB is scalable and has the option to publish messages from multiple producers to multiple consumers. The client uses long polling, which is still polling.. but I guess someone has to poll eventually.  
There might be other tools that I could have used here, but as this was not my main focus I just went with the first one that fitted.

## The Client

The client, as I already mentioned, is a very simple React app. It listens to events from the servers and displays the incoming messages.  
SSE is very simple to implement in Javascript, here is my Events class:  
```javascript


class Events {

    constructor() {
        this.client = new EventSource('https://' + window.location.host + '/messages');
    }

    register(eventName, handler) {
        this.client.addEventListener(eventName, handler);
    }

    unRegister(eventName, handler) {
        this.client.removeEventListener(eventName, handler);
    }


}

export default Events;


``` 

And the client code:  

```javascript

import React, { Component } from 'react';


class MessageList extends Component {

    constructor(props) {
        super(props);
        this.state = {messages: []}
    }

    componentWillMount() {
        const { events, channel } = this.props;
        events.register(channel, (e) => { 
            this.addMessage(JSON.parse(e.data)); 
        })
    }

    componentWillUnmount() {
        const { events, channel } = this.props;
        events.unRegister(channel, (e) => { this.addMessage(e) })

    }

    addMessage(e) {
        let messages = this.state.messages.slice();
        messages.push(e);
        this.setState({ messages });
    }

    render() {
        const { messages } = this.state; 
        return (
            <div className="message-box" style={{backgroundColor: this.props.color}}>
            { messages.map((message) => {
                return (
                    <div className="msg" key={message.id.toString()} >
                        <p>{message.data}</p>
                    </div>
                );
            }) }
            </div>
        );
    }
}

export default MessageList;

```

## Summary

All the pieces together make up the following flows:  

Client flow:  

1. Client connects to the app, all resources are pushed using pusher
2. Eventsource connects to SSE handler 
3. Components registers to events and wait for data
4. Events come in and data is displayed on the screen

Server flow:  

1. A message is pushed to Redis PUBSUB
2. The Redis client gets the message and pushes it to the BroadcastChannel
3. SSE layer gets the message from BroadcastChannel and sends an event to the client

I hope you enjoyed, and of course, feel free to comment or share.  
Thank you for reading.