vendor/github.com/go-kit/kit/examples/profilesvc/client/client.go

   1 // Package client provides a profilesvc client based on a predefined Consul
   2 // service name and relevant tags. Users must only provide the address of a
   3 // Consul server.
   4 package client
   5
   6 import (
   7         "io"
   8         "time"
   9
  10         consulapi "github.com/hashicorp/consul/api"
  11
  12         "github.com/go-kit/kit/endpoint"
  13         "github.com/go-kit/kit/examples/profilesvc"
  14         "github.com/go-kit/kit/log"
  15         "github.com/go-kit/kit/sd"
  16         "github.com/go-kit/kit/sd/consul"
  17         "github.com/go-kit/kit/sd/lb"
  18 )
  19
  20 // New returns a service that's load-balanced over instances of profilesvc found
  21 // in the provided Consul server. The mechanism of looking up profilesvc
  22 // instances in Consul is hard-coded into the client.
  23 func New(consulAddr string, logger log.Logger) (profilesvc.Service, error) {
  24         apiclient, err := consulapi.NewClient(&consulapi.Config{
  25                 Address: consulAddr,
  26         })
  27         if err != nil {
  28                 return nil, err
  29         }
  30
  31         // As the implementer of profilesvc, we declare and enforce these
  32         // parameters for all of the profilesvc consumers.
  33         var (
  34                 consulService = "profilesvc"
  35                 consulTags    = []string{"prod"}
  36                 passingOnly   = true
  37                 retryMax      = 3
  38                 retryTimeout  = 500 * time.Millisecond
  39         )
  40
  41         var (
  42                 sdclient  = consul.NewClient(apiclient)
  43                 instancer = consul.NewInstancer(sdclient, logger, consulService, consulTags, passingOnly)
  44                 endpoints profilesvc.Endpoints
  45         )
  46         {
  47                 factory := factoryFor(profilesvc.MakePostProfileEndpoint)
  48                 endpointer := sd.NewEndpointer(instancer, factory, logger)
  49                 balancer := lb.NewRoundRobin(endpointer)
  50                 retry := lb.Retry(retryMax, retryTimeout, balancer)
  51                 endpoints.PostProfileEndpoint = retry
  52         }
  53         {
  54                 factory := factoryFor(profilesvc.MakeGetProfileEndpoint)
  55                 endpointer := sd.NewEndpointer(instancer, factory, logger)
  56                 balancer := lb.NewRoundRobin(endpointer)
  57                 retry := lb.Retry(retryMax, retryTimeout, balancer)
  58                 endpoints.GetProfileEndpoint = retry
  59         }
  60         {
  61                 factory := factoryFor(profilesvc.MakePutProfileEndpoint)
  62                 endpointer := sd.NewEndpointer(instancer, factory, logger)
  63                 balancer := lb.NewRoundRobin(endpointer)
  64                 retry := lb.Retry(retryMax, retryTimeout, balancer)
  65                 endpoints.PutProfileEndpoint = retry
  66         }
  67         {
  68                 factory := factoryFor(profilesvc.MakePatchProfileEndpoint)
  69                 endpointer := sd.NewEndpointer(instancer, factory, logger)
  70                 balancer := lb.NewRoundRobin(endpointer)
  71                 retry := lb.Retry(retryMax, retryTimeout, balancer)
  72                 endpoints.PatchProfileEndpoint = retry
  73         }
  74         {
  75                 factory := factoryFor(profilesvc.MakeDeleteProfileEndpoint)
  76                 endpointer := sd.NewEndpointer(instancer, factory, logger)
  77                 balancer := lb.NewRoundRobin(endpointer)
  78                 retry := lb.Retry(retryMax, retryTimeout, balancer)
  79                 endpoints.DeleteProfileEndpoint = retry
  80         }
  81         {
  82                 factory := factoryFor(profilesvc.MakeGetAddressesEndpoint)
  83                 endpointer := sd.NewEndpointer(instancer, factory, logger)
  84                 balancer := lb.NewRoundRobin(endpointer)
  85                 retry := lb.Retry(retryMax, retryTimeout, balancer)
  86                 endpoints.GetAddressesEndpoint = retry
  87         }
  88         {
  89                 factory := factoryFor(profilesvc.MakeGetAddressEndpoint)
  90                 endpointer := sd.NewEndpointer(instancer, factory, logger)
  91                 balancer := lb.NewRoundRobin(endpointer)
  92                 retry := lb.Retry(retryMax, retryTimeout, balancer)
  93                 endpoints.GetAddressEndpoint = retry
  94         }
  95         {
  96                 factory := factoryFor(profilesvc.MakePostAddressEndpoint)
  97                 endpointer := sd.NewEndpointer(instancer, factory, logger)
  98                 balancer := lb.NewRoundRobin(endpointer)
  99                 retry := lb.Retry(retryMax, retryTimeout, balancer)
 100                 endpoints.PostAddressEndpoint = retry
 101         }
 102         {
 103                 factory := factoryFor(profilesvc.MakeDeleteAddressEndpoint)
 104                 endpointer := sd.NewEndpointer(instancer, factory, logger)
 105                 balancer := lb.NewRoundRobin(endpointer)
 106                 retry := lb.Retry(retryMax, retryTimeout, balancer)
 107                 endpoints.DeleteAddressEndpoint = retry
 108         }
 109
 110         return endpoints, nil
 111 }
 112
 113 func factoryFor(makeEndpoint func(profilesvc.Service) endpoint.Endpoint) sd.Factory {
 114         return func(instance string) (endpoint.Endpoint, io.Closer, error) {
 115                 service, err := profilesvc.MakeClientEndpoints(instance)
 116                 if err != nil {
 117                         return nil, nil, err
 118                 }
 119                 return makeEndpoint(service), nil, nil
 120         }
 121 }