Testing pub/sub for go, using Redis

pubsub_redis.go

package main

import (
        "fmt"
        "gopkg.in/redis.v2"
        "time"
)

const (
        Subscription int = iota
        PMessage
        Message
)

type RedisMessage struct {
        Channel     string
        Payload     string
        Pattern     string
        Count       int
        MessageName int
}

func ToMessage(msg interface{}) RedisMessage {
        var message RedisMessage
        switch msg.(type) {
        case *redis.Subscription:
                inter := msg.(*redis.Subscription)
                message.Channel = inter.Channel
                message.Count = inter.Count
                message.MessageName = Subscription

        case *redis.PMessage:
                inter := msg.(*redis.PMessage)
                message.Channel = inter.Channel
                message.Payload = inter.Payload
                message.Pattern = inter.Pattern
                message.MessageName = PMessage

        case *redis.Message:
                inter := msg.(*redis.Message)
                message.Channel = inter.Channel
                message.Payload = inter.Payload
                message.MessageName = Message

        }

        return message
}

func Subscribe(pubs *redis.PubSub, messages []string) error {
        for _, v := range messages {
                err := pubs.Subscribe(v)
                if err != nil {
                        return err
                }
        }

        return nil
}

func sub(client *redis.Client) {
        pubsub := client.PubSub()
        defer pubsub.Close()

        err := Subscribe(pubsub, []string{"say_hello", "quit"})

        if err != nil {
                fmt.Printf("Error subscribing: ", err)
        }

        for {
                msg, err := pubsub.Receive()
                if err != nil {
                        break
                }

                message := ToMessage(msg)
                if message.MessageName == PMessage || message.MessageName == Message {
                        switch message.Channel {
                        case "say_hello":
                                fmt.Printf("speak: %s\n", message.Payload)
                        case "quit":
                                fmt.Println("Bye")
                                return
                        }
                } else if message.MessageName != Subscription {
                        time.Sleep(1)
                }
        }
}

func main() {
        client := redis.NewTCPClient(&redis.Options{
                Addr:     "localhost:6379",
                Password: "", // no password set
                DB:       0,  // use default DB
        })
        defer client.Close()

        fmt.Println("listening ...")
        sub(client)
}