README
¶
go.serversets/mcset 
Package mcset provides consistent sharding over a set of memcache nodes provided by go.serversets.
Consistent hashing is provided by github.com/stathat/consistent
and the MCSet object fulfills the ServerSelector interface
to be used with github.com/bradfitz/gomemcache/memcache.
Client Usage
package main
import (
"log"
"github.com/bradfitz/gomemcache/memcache"
"github.com/dongnguyenvt/go.serversets"
"github.com/dongnguyenvt/go.serversets/mcset"
)
func main() {
zookeepers := []string{"10.0.1.0", "10.0.5.0", "10.0.9.0"}
watch, err := serversets.New(serversets.Production, "memcache_nodes", zookeepers).Watch()
if err != nil {
// This will be a problem connecting to Zookeeper
log.Fatalf("Registration error: %v", err)
}
cluster := mcset.New(watch)
memcacheClient := memcache.NewFromSelector(cluster)
// key will be consistently hash over the current set of servers
item, err := memcacheClient.Get("key")
log.Print(item, err)
}
Memcache node registration
package main
import (
"log"
"net"
"os"
"github.com/bradfitz/gomemcache/memcache"
"github.com/dongnguyenvt/go.serversets"
)
func main() {
localHostname, err := os.Hostname()
if err != nil {
log.Fatalf("Unable to determine hostname: %v", err)
}
// define a "ping" function
localClient := memcache.New(net.JoinHostPort(localHostname, "11211"))
pingFunc := func() error {
_, err := localClient.Get("ping")
if err == nil || err == memcache.ErrCacheMiss {
return nil
}
log.Printf("Memcache error: %v", err)
return err
}
// register the endpoint to the zookeepers
zookeepers := []string{"10.0.1.0", "10.0.5.0", "10.0.9.0"}
endpoint, err := serversets.New(serversets.Production, "memcache_nodes", zookeepers).
RegisterEndpoint(localHostname, 11211, pingFunc)
if err != nil {
// This will be a problem connecting to Zookeeper
log.Fatalf("Registration error: %v", err)
}
log.Printf("Registered as %s:11211", localHostname)
// will will wait forever, since you'll never actually close the endpoint
<-endpoint.CloseEvent
}
Dependencies
- github.com/dongnguyenvt/go.serversets to get the server list
- github.com/stathat/consistent for consistent hashing
Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Logger ¶
type Logger interface {
Printf(string, ...interface{})
}
Logger is an interface that can be implemented to provide custom log output.
type MCSet ¶
type MCSet struct {
Watcher
LastEvent time.Time
EventCount int
Logger Logger
// contains filtered or unexported fields
}
A MCSet is a wrapper around the serverset.Watch to handle the memcache use case. Basically provides some helper functions to pick the servers consistently.
func New ¶
New creates a new memcache server set. Can be used to just consistently hash keys to a known set of servers by having watch = nil and then calling SetEndpoints with the known set of memcache hosts.
func (*MCSet) Each ¶
Each runs the function over each server currently in the set. Kind of a weird signature but is necessary to satisfy the memcache.ServerSelector interface.
func (*MCSet) Endpoints ¶
Endpoints returns the current endpoints for this service. This can be those set via the serverset.Watch or manually via SetEndpoints()
func (*MCSet) Event ¶
func (s *MCSet) Event() <-chan struct{}
Event returns the event channel. This channel will get an object whenever something changes with the list of endpoints. Mostly just a passthrough of the underlying watch event.
func (*MCSet) PickServer ¶
PickServer consistently picks a server from the list. Kind of a weird signature but is necessary to satisfy the memcache.ServerSelector interface.
func (*MCSet) SetEndpoints ¶
SetEndpoints sets current list of endpoints. This will override the list returned by the serverset. An event by the serverset will override these values.
Source Files