survive subscription error

reconnect.go

package main

// Demonstrate how to reconnect.

import (
	"fmt"
	"log"
	"time"

	"github.com/centrifugal/centrifuge-mobile"
	"github.com/centrifugal/centrifugo/libcentrifugo/auth"
)

func init() {
	log.SetFlags(log.Ldate | log.Ltime)
}

// In production you need to receive credentials from application backend.
func credentials() *centrifuge.Credentials {
	// Never show secret to client of your application. Keep it on your application backend only.
	secret := "secret"
	// Application user ID.
	user := "42"
	// Current timestamp as string.
	timestamp := centrifuge.Timestamp()
	// Empty info.
	info := ""
	// Generate client token so Centrifugo server can trust connection parameters received from client.
	token := auth.GenerateClientToken(secret, user, timestamp, info)

	return &centrifuge.Credentials{
		User:      user,
		Timestamp: timestamp,
		Info:      info,
		Token:     token,
	}
}

type subEventHandler struct{}

func (h *subEventHandler) OnMessage(sub *centrifuge.Sub, msg *centrifuge.Message) {
	log.Println(fmt.Sprintf("New message received in channel %s: %#v", sub.Channel(), msg))
}

func (h *subEventHandler) OnSubscribeSuccess(sub *centrifuge.Sub, ctx *centrifuge.SubscribeSuccessContext) {
	log.Println(fmt.Sprintf("Subscribed on %s, recovered: %v, resubscribed: %v", sub.Channel(), ctx.Recovered, ctx.Resubscribed))
}

func (h *subEventHandler) OnUnsubscribe(sub *centrifuge.Sub, ctx *centrifuge.UnsubscribeContext) {
	log.Println(fmt.Sprintf("Unsubscribed from %s", sub.Channel()))
}

type eventHandler struct {
	done chan struct{}
}

func (h *eventHandler) OnConnect(c *centrifuge.Client, ctx *centrifuge.ConnectContext) {
	log.Printf("Connected with id: %s", ctx.ClientID)

	subEvents := centrifuge.NewSubEventHandler()
	subHandler := &subEventHandler{}
	subEvents.OnMessage(subHandler)
	subEvents.OnSubscribeSuccess(subHandler)
	subEvents.OnUnsubscribe(subHandler)

	sub, err := c.Subscribe("public:chat", subEvents)
	if err != nil {
		log.Println(err)
		c.Disconnect()
		c.Connect()
		return
	}

	go func() {
		for {
			history, err := sub.History()
			if err != nil {
				log.Printf("Error retreiving channel history: %s", err.Error())
			} else {
				log.Printf("%d messages in channel history", len(history))
			}
			time.Sleep(time.Second)
		}
	}()

	return
}

func (h *eventHandler) OnDisconnect(c *centrifuge.Client, ctx *centrifuge.DisconnectContext) {
	log.Printf("Disconnected: %s, reconnect: %v", ctx.Reason, ctx.Reconnect)
}

func newConnection(done chan struct{}) *centrifuge.Client {
	creds := credentials()
	wsURL := "ws://localhost:8000/connection/websocket"

	handler := &eventHandler{
		done: done,
	}

	events := centrifuge.NewEventHandler()
	events.OnConnect(handler)
	events.OnDisconnect(handler)

	c := centrifuge.New(wsURL, creds, events, centrifuge.DefaultConfig())

	err := c.Connect()
	if err != nil {
		log.Fatalln(err)
	}

	return c
}

func main() {
	log.Println("Start program")
	done := make(chan struct{})
	c := newConnection(done)
	defer c.Close()
	<-done
}