func NewWatcher(tagPrefix, configPath string) (*Watcher, error) {
client, err := api.NewClient(&api.Config{Address: Addr, Scheme: "http"})
if err != nil {
return nil, err
}
w := &Watcher{
client: client,
tagPrefix: tagPrefix,
configPath: configPath,
}
return w, nil
}
func NewBackend(cfg *config.Consul, apiAddr string) (registry.Backend, error) {
// create a reusable client
c, err := api.NewClient(&api.Config{Address: cfg.Addr, Scheme: "http"})
if err != nil {
return nil, err
}
// ping the agent
dc, err := datacenter(c)
if err != nil {
return nil, err
}
// we're good
log.Printf("[INFO] consul: Connecting to %q in datacenter %q", cfg.Addr, dc)
return &be{c: c, dc: dc, cfg: cfg, apiAddr: apiAddr}, nil
}
// Datacenter returns the datacenter of the local agent
func Datacenter() (string, error) {
client, err := api.NewClient(&api.Config{Address: Addr, Scheme: Scheme})
if err != nil {
return "", nil
}
self, err := client.Agent().Self()
if err != nil {
return "", err
}
cfg, ok := self["Config"]
if !ok {
return "", errors.New("consul: self.Config not found")
}
dc, ok := cfg["Datacenter"].(string)
if !ok {
return "", errors.New("consul: self.Datacenter not found")
}
return dc, nil
}
func newClient() (*api.Client, error) {
return api.NewClient(&api.Config{Address: Addr, Scheme: Scheme})
}
func main() {
var addr, consul, name, prefix, proto string
flag.StringVar(&addr, "addr", "127.0.0.1:5000", "host:port of the service")
flag.StringVar(&consul, "consul", "127.0.0.1:8500", "host:port of the consul agent")
flag.StringVar(&name, "name", filepath.Base(os.Args[0]), "name of the service")
flag.StringVar(&prefix, "prefix", "", "comma-sep list of host/path prefixes to register")
flag.StringVar(&proto, "proto", "http", "protocol for endpoints: http or ws")
flag.Parse()
if prefix == "" {
flag.Usage()
os.Exit(1)
}
// register prefixes
prefixes := strings.Split(prefix, ",")
for _, p := range prefixes {
switch proto {
case "http":
http.HandleFunc(p, func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Serving %s from %s on %s\n", r.RequestURI, name, addr)
})
case "ws":
http.Handle(p, websocket.Handler(EchoServer))
default:
log.Fatal("Invalid protocol ", proto)
}
}
// start http server
go func() {
log.Printf("Listening on %s serving %s", addr, prefix)
if err := http.ListenAndServe(addr, nil); err != nil {
log.Fatal(err)
}
}()
// register consul health check endpoint
http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprintln(w, "OK")
})
// build urlprefix-host/path tag list
// e.g. urlprefix-/foo, urlprefix-/bar, ...
var tags []string
for _, p := range prefixes {
tags = append(tags, "urlprefix-"+p)
}
// get host and port as string/int
host, portstr, err := net.SplitHostPort(addr)
if err != nil {
log.Fatal(err)
}
port, err := strconv.Atoi(portstr)
if err != nil {
log.Fatal(err)
}
// register service with health check
serviceID := name + "-" + addr
service := &api.AgentServiceRegistration{
ID: serviceID,
Name: name,
Port: port,
Address: host,
Tags: tags,
Check: &api.AgentServiceCheck{
HTTP: "http://" + addr + "/health",
Interval: "1s",
Timeout: "1s",
},
}
config := &api.Config{Address: consul, Scheme: "http"}
client, err := api.NewClient(config)
if err != nil {
log.Fatal(err)
}
if err := client.Agent().ServiceRegister(service); err != nil {
log.Fatal(err)
}
log.Printf("Registered service %q in consul with tags %q", name, strings.Join(tags, ","))
// run until we get a signal
quit := make(chan os.Signal, 1)
signal.Notify(quit, os.Interrupt, os.Kill)
<-quit
// deregister service
if err := client.Agent().ServiceDeregister(serviceID); err != nil {
log.Fatal(err)
}
log.Printf("Deregistered service %q in consul", name)
}