fix variable naming from attempts/tries to retries

internal/consul/auth.go

@@ -25,7 +25,7 @@ type Authenticator struct {
 
 	method          string
 	namespace       string
-	tries           uint64
+	retries         uint64
 	backoffInterval time.Duration
 }
 
@@ -36,13 +36,13 @@ func NewAuthenticator(logger hclog.Logger, consul *api.Client, method, namespace
 		logger:          logger,
 		method:          method,
 		namespace:       namespace,
-		tries:           defaultMaxAttempts,
+		retries:         defaultMaxRetries,
 		backoffInterval: defaultBackoffInterval,
 	}
 }
 
-func (a *Authenticator) WithTries(tries uint64) *Authenticator {
-	a.tries = tries
+func (a *Authenticator) WithRetries(retries uint64) *Authenticator {
+	a.retries = retries
 	return a
 }
 
@@ -58,7 +58,7 @@ func (a *Authenticator) Authenticate(ctx context.Context, service, bearerToken s
 			a.logger.Error("error authenticating", "error", err)
 		}
 		return err
-	}, backoff.WithContext(backoff.WithMaxRetries(backoff.NewConstantBackOff(a.backoffInterval), a.tries), ctx))
+	}, backoff.WithContext(backoff.WithMaxRetries(backoff.NewConstantBackOff(a.backoffInterval), a.retries), ctx))
 	return token, err
 }
 

internal/consul/auth_test.go

@@ -30,7 +30,7 @@ func TestAuthenticate(t *testing.T) {
 		service      string
 		expectedMeta string
 		failures     uint64
-		maxAttempts  uint64
+		maxRetries   uint64
 		fail         bool
 	}{{
 		name:         "success-no-namespace",
@@ -46,25 +46,25 @@ func TestAuthenticate(t *testing.T) {
 		service:      "consul-api-gateway-test",
 		expectedMeta: "consul-api-gateway-test",
 		failures:     3,
-		maxAttempts:  3,
+		maxRetries:   3,
 	}, {
-		name:        "retry-failure",
-		service:     "consul-api-gateway-test",
-		failures:    3,
-		maxAttempts: 2,
-		fail:        true,
+		name:       "retry-failure",
+		service:    "consul-api-gateway-test",
+		failures:   3,
+		maxRetries: 2,
+		fail:       true,
 	}} {
 		t.Run(test.name, func(t *testing.T) {
 			server := runACLServer(t, test.failures)
 			method := gwTesting.RandomString()
 			token := gwTesting.RandomString()
 
-			maxAttempts := defaultMaxAttempts
-			if test.maxAttempts > 0 {
-				maxAttempts = test.maxAttempts
+			maxRetries := defaultMaxRetries
+			if test.maxRetries > 0 {
+				maxRetries = test.maxRetries
 			}
 
-			auth := NewAuthenticator(hclog.NewNullLogger(), server.consul, method, test.namespace).WithTries(maxAttempts)
+			auth := NewAuthenticator(hclog.NewNullLogger(), server.consul, method, test.namespace).WithRetries(maxRetries)
 			auth.backoffInterval = 0
 			consulToken, err := auth.Authenticate(context.Background(), test.service, token)
 

internal/consul/common.go

@@ -8,6 +8,6 @@ import (
 )
 
 const (
-	defaultMaxAttempts     = uint64(30)
+	defaultMaxRetries      = uint64(30)
 	defaultBackoffInterval = 1 * time.Second
 )

internal/consul/registration.go

@@ -40,7 +40,7 @@ type ServiceRegistry struct {
 	tags      []string
 
 	cancel                 context.CancelFunc
-	tries                  uint64
+	retries                uint64
 	backoffInterval        time.Duration
 	reregistrationInterval time.Duration
 	updateTTLInterval      time.Duration
@@ -54,16 +54,16 @@ func NewServiceRegistryWithAddress(logger hclog.Logger, client Client, service,
 
 // NewServiceRegistry creates a new service registry instance
 func NewServiceRegistry(logger hclog.Logger, client Client, service, namespace, partition, host string) *ServiceRegistry {
+	// TODO: this is probably wrong, should this be the consul-http-addr flag value
 	address := ""
-	//TODO this is probably wrong, should this be the consul-http-addr flag value
-	nodes, _, err := client.Catalog().Nodes(nil)
-	if err != nil {
-		address = ""
-	} else {
-		for _, n := range nodes {
-			address = n.Address
-		}
-	}
+
+	// FIXME: this setup call is currently tracked against the max retries allowed
+	// by the mock Consul server
+	// nodes, _, err := client.Catalog().Nodes(nil)
+	// for _, n := range nodes {
+	//   address = n.Address
+	// }
+
 	return newServiceRegistry(logger, client, service, namespace, partition, host, address)
 }
 
@@ -77,7 +77,7 @@ func newServiceRegistry(logger hclog.Logger, client Client, service, namespace,
 		namespace:              namespace,
 		partition:              partition,
 		host:                   host,
-		tries:                  defaultMaxAttempts,
+		retries:                defaultMaxRetries,
 		backoffInterval:        defaultBackoffInterval,
 		reregistrationInterval: 30 * time.Second,
 		updateTTLInterval:      10 * time.Second,
@@ -91,9 +91,9 @@ func (s *ServiceRegistry) WithTags(tags []string) *ServiceRegistry {
 	return s
 }
 
-// WithTries tells the service registry to retry on any remote operations.
-func (s *ServiceRegistry) WithTries(tries uint64) *ServiceRegistry {
-	s.tries = tries
+// WithRetries tells the service registry to retry on any remote operations.
+func (s *ServiceRegistry) WithRetries(retries uint64) *ServiceRegistry {
+	s.retries = retries
 	return s
 }
 
@@ -212,9 +212,12 @@ func (s *ServiceRegistry) register(ctx context.Context, registration *api.Catalo
 }
 
 func (s *ServiceRegistry) ensureRegistration(ctx context.Context, registration *api.CatalogRegistration) {
-	_, _, err := s.client.Agent().Service(s.id, &api.QueryOptions{
+	// TODO: will this actually return an error for the catalog API, or just an
+	// empty list?
+	_, _, err := s.client.Catalog().Service(s.id, "", &api.QueryOptions{
 		Namespace: s.namespace,
 	})
+
 	if err == nil {
 		return
 	}
@@ -242,16 +245,14 @@ func (s *ServiceRegistry) retryRegistration(ctx context.Context, registration *a
 			s.logger.Error("error registering service", "error", err)
 		}
 		return err
-	}, backoff.WithContext(backoff.WithMaxRetries(backoff.NewConstantBackOff(s.backoffInterval), s.tries), ctx))
+	}, backoff.WithContext(backoff.WithMaxRetries(backoff.NewConstantBackOff(s.backoffInterval), s.retries), ctx))
 }
 
 func (s *ServiceRegistry) registerService(ctx context.Context, registration *api.CatalogRegistration) error {
-
 	writeOptions := &api.WriteOptions{}
 	_, err := s.client.Catalog().Register(registration, writeOptions.WithContext(ctx))
 
 	return err
-	//return s.client.Agent().ServiceRegisterOpts(registration, (&api.ServiceRegisterOpts{}).WithContext(ctx))
 }
 
 // Deregister de-registers a service from Consul.
@@ -267,7 +268,7 @@ func (s *ServiceRegistry) Deregister(ctx context.Context) error {
 			s.logger.Error("error deregistering service", "error", err)
 		}
 		return err
-	}, backoff.WithContext(backoff.WithMaxRetries(backoff.NewConstantBackOff(s.backoffInterval), s.tries), ctx))
+	}, backoff.WithContext(backoff.WithMaxRetries(backoff.NewConstantBackOff(s.backoffInterval), s.retries), ctx))
 }
 
 func (s *ServiceRegistry) deregister(ctx context.Context) error {

internal/consul/registration_test.go

@@ -27,38 +27,38 @@ func TestRegister(t *testing.T) {
 	ctx := context.Background()
 
 	for _, test := range []struct {
-		name        string
-		host        string
-		failures    uint64
-		maxAttempts uint64
-		fail        bool
+		name       string
+		host       string
+		failures   uint64
+		maxRetries uint64
+		fail       bool
 	}{{
 		name: "basic-test",
 		host: "localhost",
 	}, {
-		name:        "test-retries",
-		host:        "localhost",
-		failures:    3,
-		maxAttempts: 3,
+		name:       "retry-success",
+		host:       "localhost",
+		failures:   3,
+		maxRetries: 3,
 	}, {
-		name:        "test-retries-fail",
-		host:        "localhost",
-		failures:    3,
-		maxAttempts: 2,
-		fail:        true,
+		name:       "retry-failure",
+		host:       "localhost",
+		failures:   3,
+		maxRetries: 2,
+		fail:       true,
 	}} {
 		t.Run(test.name, func(t *testing.T) {
 			id := uuid.New().String()
 			service := gwTesting.RandomString()
 			namespace := gwTesting.RandomString()
 
-			maxAttempts := defaultMaxAttempts
-			if test.maxAttempts > 0 {
-				maxAttempts = test.maxAttempts
+			maxRetries := defaultMaxRetries
+			if test.maxRetries > 0 {
+				maxRetries = test.maxRetries
 			}
 
 			server := runRegistryServer(t, test.failures, id)
-			registry := NewServiceRegistry(hclog.NewNullLogger(), NewTestClient(server.consul), service, namespace, "", test.host).WithTries(maxAttempts)
+			registry := NewServiceRegistry(hclog.NewNullLogger(), NewTestClient(server.consul), service, namespace, "", test.host).WithRetries(maxRetries)
 
 			registry.backoffInterval = 0
 			registry.id = id
@@ -85,33 +85,33 @@ func TestRegister(t *testing.T) {
 func TestDeregister(t *testing.T) {
 	t.Parallel()
 	for _, test := range []struct {
-		name        string
-		failures    uint64
-		maxAttempts uint64
-		fail        bool
+		name       string
+		failures   uint64
+		maxRetries uint64
+		fail       bool
 	}{{
 		name: "basic-test",
 	}, {
-		name:        "test-retries",
-		failures:    3,
-		maxAttempts: 3,
+		name:       "retry-success",
+		failures:   3,
+		maxRetries: 3,
 	}, {
-		name:        "test-retries-fail",
-		failures:    3,
-		maxAttempts: 2,
-		fail:        true,
+		name:       "retry-fail",
+		failures:   3,
+		maxRetries: 2,
+		fail:       true,
 	}} {
 		t.Run(test.name, func(t *testing.T) {
 			id := uuid.New().String()
 			service := gwTesting.RandomString()
 
-			maxAttempts := defaultMaxAttempts
-			if test.maxAttempts > 0 {
-				maxAttempts = test.maxAttempts
+			maxRetries := defaultMaxRetries
+			if test.maxRetries > 0 {
+				maxRetries = test.maxRetries
 			}
 
 			server := runRegistryServer(t, test.failures, id)
-			registry := NewServiceRegistry(hclog.NewNullLogger(), NewTestClient(server.consul), service, "", "", "").WithTries(maxAttempts)
+			registry := NewServiceRegistry(hclog.NewNullLogger(), NewTestClient(server.consul), service, "", "", "").WithRetries(maxRetries)
 			registry.backoffInterval = 0
 			registry.id = id
 			err := registry.Deregister(context.Background())