ConsulWatch

README

goConsulWatch

golang Consul Subscription example with using consul watch

import in your project

import (
    "github.com/HaesungSeo/goConsulWatch"
)

example code

simple

package main

import (
    "flag"
    "fmt"
    "reflect"
    "time"

    goConsulWatch "github.com/HaesungSeo/goConsulWatch"
)

func isMapSame(src, dst map[string]string) bool {
    return reflect.DeepEqual(src, dst)
}

func diff(src, dst map[string]string) map[string]string {
    differ := make(map[string]string)
    for k, val1 := range src {
        val2, ok := dst[k]
        if !ok {
            differ[k] = fmt.Sprintf("[%s] removed", k)
        }
        if val1 != val2 {
            differ[k] = fmt.Sprintf("[%s] [%s] -->[%s]", k, val1, val2)
        }
    }
    for k, val2 := range dst {
        _, ok := src[k]
        if !ok {
            differ[k] = fmt.Sprintf("[%s] New [%s]", k, val2)
        }
        // maybe already compared
    }
    return differ
}

// Watch example
func main() {
    addr := flag.String("s", ":8080", "consul server address")
    keyType := flag.String("t", "keyprefix", "consul watch type, one of key keyprefix")
    key := flag.String("k", "/", "consul kv key")

    flag.Parse()

    cfg, err := goConsulWatch.New(*addr, *keyType, *key)
    if err != nil {
        fmt.Printf("ERROR: %s\n", err)
        return
    }

    old := cfg.KVCopy()
    fmt.Printf("%s\n", old)
    for {
        select {
        case <-time.After(1 * time.Second):
            cur := cfg.KVCopy()
            if !isMapSame(cur, old) {
                diff := diff(old, cur)
                for _, v := range diff {
                    fmt.Printf("%s\n", v)
                }
            }
            old = cur
        }
    }
}

with two terminal, Run binary simple at first terminal,
then Run consul cli at the other one. watch the result

first terminal

./simple -k foo -t key
map[]
[foo] New [hello]
[foo] [hello] -->[world]
[foo] [world] -->[and goodbye]
[foo] [and goodbye] -->[]
[foo] New [again]

second terminal

$ consul kv put foo hello
Success! Data written to: foo
$ consul kv put foo world
Success! Data written to: foo
$ consul kv put foo "and goodbye"
Success! Data written to: foo
$ consul kv delete foo
Success! Deleted key: foo
$ consul kv put foo again
Success! Data written to: foo
$

Documentation

Index

• Variables
• type ConsulWatch
  • func New(addr, keyType, key string) (*ConsulWatch, error)
  • func (c *ConsulWatch) KV(key string) string
  • func (c *ConsulWatch) KVCopy() map[string]string
  • func (c *ConsulWatch) KVFlush()
  • func (c *ConsulWatch) KVSet(key, value string)
  • func (c *ConsulWatch) Stop(key string)
• type KeytypeError
  • func (e *KeytypeError) Error() string
  • func (e *KeytypeError) Unwrap() error
• type ParseError
  • func (e *ParseError) Error() string
  • func (e *ParseError) Unwrap() error

Variables

var (
	ErrWatch = errors.New("unsupported watch type")
)

Types

type ConsulWatch

type ConsulWatch struct {
	// contains filtered or unexported fields
}

func New

func New(addr, keyType, key string) (*ConsulWatch, error)

Watch example

func (*ConsulWatch) KV

func (c *ConsulWatch) KV(key string) string

func (*ConsulWatch) KVCopy

func (c *ConsulWatch) KVCopy() map[string]string

func (*ConsulWatch) KVFlush

func (c *ConsulWatch) KVFlush()

func (*ConsulWatch) KVSet

func (c *ConsulWatch) KVSet(key, value string)

func (*ConsulWatch) Stop

func (c *ConsulWatch) Stop(key string)

type KeytypeError

type KeytypeError struct {
	Err error
	// contains filtered or unexported fields
}

func (*KeytypeError) Error

func (e *KeytypeError) Error() string

func (*KeytypeError) Unwrap

func (e *KeytypeError) Unwrap() error

type ParseError

type ParseError struct {
	Query string
	Err   error
}

func (*ParseError) Error

func (e *ParseError) Error() string

func (*ParseError) Unwrap

func (e *ParseError) Unwrap() error