Move hcp client to subpackage hcpclient (#16800)

agent/consul/server.go

@@ -60,6 +60,7 @@ import (
 	agentgrpc "github.com/hashicorp/consul/agent/grpc-internal"
 	"github.com/hashicorp/consul/agent/grpc-internal/services/subscribe"
 	"github.com/hashicorp/consul/agent/hcp"
+	hcpclient "github.com/hashicorp/consul/agent/hcp/client"
 	logdrop "github.com/hashicorp/consul/agent/log-drop"
 	"github.com/hashicorp/consul/agent/metadata"
 	"github.com/hashicorp/consul/agent/pool"
@@ -2027,7 +2028,7 @@ func (s *Server) trackLeaderChanges() {
 // hcpServerStatus is the callback used by the HCP manager to emit status updates to the HashiCorp Cloud Platform when
 // enabled.
 func (s *Server) hcpServerStatus(deps Deps) hcp.StatusCallback {
-	return func(ctx context.Context) (status hcp.ServerStatus, err error) {
+	return func(ctx context.Context) (status hcpclient.ServerStatus, err error) {
 		status.Name = s.config.NodeName
 		status.ID = string(s.config.NodeID)
 		status.Version = cslversion.GetHumanVersion()

agent/consul/server_test.go

@@ -27,15 +27,14 @@ import (
 	"golang.org/x/time/rate"
 	"google.golang.org/grpc"
 
-	"github.com/hashicorp/consul/agent/hcp"
-
 	"github.com/hashicorp/consul-net-rpc/net/rpc"
 
 	"github.com/hashicorp/consul/agent/connect"
 	"github.com/hashicorp/consul/agent/consul/multilimiter"
 	rpcRate "github.com/hashicorp/consul/agent/consul/rate"
 	external "github.com/hashicorp/consul/agent/grpc-external"
 	grpcmiddleware "github.com/hashicorp/consul/agent/grpc-middleware"
+	hcpclient "github.com/hashicorp/consul/agent/hcp/client"
 	"github.com/hashicorp/consul/agent/metadata"
 	"github.com/hashicorp/consul/agent/rpc/middleware"
 	"github.com/hashicorp/consul/agent/structs"
@@ -2082,10 +2081,10 @@ func TestServer_hcpManager(t *testing.T) {
 	_, conf1 := testServerConfig(t)
 	conf1.BootstrapExpect = 1
 	conf1.RPCAdvertise = &net.TCPAddr{IP: []byte{127, 0, 0, 2}, Port: conf1.RPCAddr.Port}
-	hcp1 := hcp.NewMockClient(t)
-	hcp1.EXPECT().PushServerStatus(mock.Anything, mock.MatchedBy(func(status *hcp.ServerStatus) bool {
+	hcp1 := hcpclient.NewMockClient(t)
+	hcp1.EXPECT().PushServerStatus(mock.Anything, mock.MatchedBy(func(status *hcpclient.ServerStatus) bool {
 		return status.ID == string(conf1.NodeID)
-	})).Run(func(ctx context.Context, status *hcp.ServerStatus) {
+	})).Run(func(ctx context.Context, status *hcpclient.ServerStatus) {
 		require.Equal(t, status.LanAddress, "127.0.0.2")
 	}).Call.Return(nil)
 

agent/hcp/bootstrap/bootstrap.go

@@ -23,7 +23,7 @@ import (
 
 	"github.com/hashicorp/consul/agent/config"
 	"github.com/hashicorp/consul/agent/connect"
-	"github.com/hashicorp/consul/agent/hcp"
+	hcpclient "github.com/hashicorp/consul/agent/hcp/client"
 	"github.com/hashicorp/consul/lib"
 	"github.com/hashicorp/consul/lib/retry"
 	"github.com/hashicorp/go-uuid"
@@ -65,7 +65,7 @@ type RawBootstrapConfig struct {
 // fetch from HCP servers if the local data is incomplete.
 // It must be passed a (CLI) UI implementation so it can deliver progress
 // updates to the user, for example if it is waiting to retry for a long period.
-func LoadConfig(ctx context.Context, client hcp.Client, dataDir string, loader ConfigLoader, ui UI) (ConfigLoader, error) {
+func LoadConfig(ctx context.Context, client hcpclient.Client, dataDir string, loader ConfigLoader, ui UI) (ConfigLoader, error) {
 	ui.Output("Loading configuration from HCP")
 
 	// See if we have existing config on disk
@@ -181,14 +181,14 @@ func finalizeRuntimeConfig(rc *config.RuntimeConfig, cfg *RawBootstrapConfig) {
 
 // fetchBootstrapConfig will fetch boostrap configuration from remote servers and persist it to disk.
 // It will retry until successful or a terminal error condition is found (e.g. permission denied).
-func fetchBootstrapConfig(ctx context.Context, client hcp.Client, dataDir string, ui UI) (*RawBootstrapConfig, error) {
+func fetchBootstrapConfig(ctx context.Context, client hcpclient.Client, dataDir string, ui UI) (*RawBootstrapConfig, error) {
 	w := retry.Waiter{
 		MinWait: 1 * time.Second,
 		MaxWait: 5 * time.Minute,
 		Jitter:  retry.NewJitter(50),
 	}
 
-	var bsCfg *hcp.BootstrapConfig
+	var bsCfg *hcpclient.BootstrapConfig
 	for {
 		// Note we don't want to shadow `ctx` here since we need that for the Wait
 		// below.
@@ -225,7 +225,7 @@ func fetchBootstrapConfig(ctx context.Context, client hcp.Client, dataDir string
 // persistAndProcessConfig is called when we receive data from CCM.
 // We validate and persist everything that was received, then also update
 // the JSON config as needed.
-func persistAndProcessConfig(dataDir string, devMode bool, bsCfg *hcp.BootstrapConfig) (string, error) {
+func persistAndProcessConfig(dataDir string, devMode bool, bsCfg *hcpclient.BootstrapConfig) (string, error) {
 	if devMode {
 		// Agent in dev mode, we still need somewhere to persist the certs
 		// temporarily though to be able to start up at all since we don't support

agent/hcp/bootstrap/bootstrap_test.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/hashicorp/consul/agent/config"
 	"github.com/hashicorp/consul/agent/hcp"
+	hcpclient "github.com/hashicorp/consul/agent/hcp/client"
 	"github.com/hashicorp/consul/lib"
 	"github.com/hashicorp/consul/tlsutil"
 	"github.com/hashicorp/go-uuid"
@@ -157,7 +158,7 @@ func TestLoadConfig_Persistence(t *testing.T) {
 
 		// Override the client TLS config so that the test server can be trusted.
 		initial.RuntimeConfig.Cloud.WithTLSConfig(clientTLS)
-		client, err := hcp.NewClient(initial.RuntimeConfig.Cloud)
+		client, err := hcpclient.NewClient(initial.RuntimeConfig.Cloud)
 		require.NoError(t, err)
 
 		loader, err := LoadConfig(context.Background(), client, initial.RuntimeConfig.DataDir, baseLoader, ui)

agent/hcp/client.go → agent/hcp/client/client.go

@@ -1,7 +1,7 @@
 // Copyright (c) HashiCorp, Inc.
 // SPDX-License-Identifier: MPL-2.0
 
-package hcp
+package client
 
 import (
 	"context"
@@ -11,13 +11,13 @@ import (
 
 	httptransport "github.com/go-openapi/runtime/client"
 	"github.com/go-openapi/strfmt"
+
+	"github.com/hashicorp/consul/agent/hcp/config"
+	"github.com/hashicorp/consul/version"
 	hcpgnm "github.com/hashicorp/hcp-sdk-go/clients/cloud-global-network-manager-service/preview/2022-02-15/client/global_network_manager_service"
 	gnmmod "github.com/hashicorp/hcp-sdk-go/clients/cloud-global-network-manager-service/preview/2022-02-15/models"
 	"github.com/hashicorp/hcp-sdk-go/httpclient"
 	"github.com/hashicorp/hcp-sdk-go/resource"
-
-	"github.com/hashicorp/consul/agent/hcp/config"
-	"github.com/hashicorp/consul/version"
 )
 
 // Client interface exposes HCP operations that can be invoked by Consul

agent/hcp/deps.go

@@ -4,19 +4,20 @@
 package hcp
 
 import (
+	hcpclient "github.com/hashicorp/consul/agent/hcp/client"
 	"github.com/hashicorp/consul/agent/hcp/config"
 	"github.com/hashicorp/consul/agent/hcp/scada"
 	"github.com/hashicorp/go-hclog"
 )
 
 // Deps contains the interfaces that the rest of Consul core depends on for HCP integration.
 type Deps struct {
-	Client   Client
+	Client   hcpclient.Client
 	Provider scada.Provider
 }
 
 func NewDeps(cfg config.CloudConfig, logger hclog.Logger) (d Deps, err error) {
-	d.Client, err = NewClient(cfg)
+	d.Client, err = hcpclient.NewClient(cfg)
 	if err != nil {
 		return
 	}

agent/hcp/discover/discover.go

@@ -9,7 +9,7 @@ import (
 	"log"
 	"time"
 
-	"github.com/hashicorp/consul/agent/hcp"
+	hcpclient "github.com/hashicorp/consul/agent/hcp/client"
 	"github.com/hashicorp/consul/agent/hcp/config"
 )
 
@@ -32,7 +32,7 @@ func (p *Provider) Addrs(args map[string]string, l *log.Logger) ([]string, error
 		return nil, err
 	}
 
-	client, err := hcp.NewClient(cfg.CloudConfig)
+	client, err := hcpclient.NewClient(cfg.CloudConfig)
 	if err != nil {
 		return nil, err
 	}

agent/hcp/manager.go

@@ -8,6 +8,7 @@ import (
 	"sync"
 	"time"
 
+	hcpclient "github.com/hashicorp/consul/agent/hcp/client"
 	"github.com/hashicorp/consul/lib"
 	"github.com/hashicorp/go-hclog"
 )
@@ -18,7 +19,7 @@ var (
 )
 
 type ManagerConfig struct {
-	Client Client
+	Client hcpclient.Client
 
 	StatusFn    StatusCallback
 	MinInterval time.Duration
@@ -47,7 +48,7 @@ func (cfg *ManagerConfig) nextHeartbeat() time.Duration {
 	return min + lib.RandomStagger(max-min)
 }
 
-type StatusCallback func(context.Context) (ServerStatus, error)
+type StatusCallback func(context.Context) (hcpclient.ServerStatus, error)
 
 type Manager struct {
 	logger hclog.Logger

agent/hcp/manager_test.go

@@ -8,19 +8,20 @@ import (
 	"testing"
 	"time"
 
+	hcpclient "github.com/hashicorp/consul/agent/hcp/client"
 	"github.com/hashicorp/go-hclog"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 	"golang.org/x/net/context"
 )
 
 func TestManager_Run(t *testing.T) {
-	client := NewMockClient(t)
-	statusF := func(ctx context.Context) (ServerStatus, error) {
-		return ServerStatus{ID: t.Name()}, nil
+	client := hcpclient.NewMockClient(t)
+	statusF := func(ctx context.Context) (hcpclient.ServerStatus, error) {
+		return hcpclient.ServerStatus{ID: t.Name()}, nil
 	}
 	updateCh := make(chan struct{}, 1)
-	client.EXPECT().PushServerStatus(mock.Anything, &ServerStatus{ID: t.Name()}).Return(nil).Once()
+	client.EXPECT().PushServerStatus(mock.Anything, &hcpclient.ServerStatus{ID: t.Name()}).Return(nil).Once()
 	mgr := NewManager(ManagerConfig{
 		Client:   client,
 		Logger:   hclog.New(&hclog.LoggerOptions{Output: io.Discard}),
@@ -43,14 +44,14 @@ func TestManager_Run(t *testing.T) {
 }
 
 func TestManager_SendUpdate(t *testing.T) {
-	client := NewMockClient(t)
-	statusF := func(ctx context.Context) (ServerStatus, error) {
-		return ServerStatus{ID: t.Name()}, nil
+	client := hcpclient.NewMockClient(t)
+	statusF := func(ctx context.Context) (hcpclient.ServerStatus, error) {
+		return hcpclient.ServerStatus{ID: t.Name()}, nil
 	}
 	updateCh := make(chan struct{}, 1)
 
 	// Expect two calls, once during run startup and again when SendUpdate is called
-	client.EXPECT().PushServerStatus(mock.Anything, &ServerStatus{ID: t.Name()}).Return(nil).Twice()
+	client.EXPECT().PushServerStatus(mock.Anything, &hcpclient.ServerStatus{ID: t.Name()}).Return(nil).Twice()
 	mgr := NewManager(ManagerConfig{
 		Client:   client,
 		Logger:   hclog.New(&hclog.LoggerOptions{Output: io.Discard}),
@@ -73,14 +74,14 @@ func TestManager_SendUpdate(t *testing.T) {
 }
 
 func TestManager_SendUpdate_Periodic(t *testing.T) {
-	client := NewMockClient(t)
-	statusF := func(ctx context.Context) (ServerStatus, error) {
-		return ServerStatus{ID: t.Name()}, nil
+	client := hcpclient.NewMockClient(t)
+	statusF := func(ctx context.Context) (hcpclient.ServerStatus, error) {
+		return hcpclient.ServerStatus{ID: t.Name()}, nil
 	}
 	updateCh := make(chan struct{}, 1)
 
 	// Expect two calls, once during run startup and again when SendUpdate is called
-	client.EXPECT().PushServerStatus(mock.Anything, &ServerStatus{ID: t.Name()}).Return(nil).Twice()
+	client.EXPECT().PushServerStatus(mock.Anything, &hcpclient.ServerStatus{ID: t.Name()}).Return(nil).Twice()
 	mgr := NewManager(ManagerConfig{
 		Client:      client,
 		Logger:      hclog.New(&hclog.LoggerOptions{Output: io.Discard}),

command/agent/agent.go

@@ -21,8 +21,8 @@ import (
 
 	"github.com/hashicorp/consul/agent"
 	"github.com/hashicorp/consul/agent/config"
-	"github.com/hashicorp/consul/agent/hcp"
 	hcpbootstrap "github.com/hashicorp/consul/agent/hcp/bootstrap"
+	hcpclient "github.com/hashicorp/consul/agent/hcp/client"
 	"github.com/hashicorp/consul/command/cli"
 	"github.com/hashicorp/consul/command/flags"
 	"github.com/hashicorp/consul/lib"
@@ -169,7 +169,7 @@ func (c *cmd) run(args []string) int {
 		return 1
 	}
 	if res.RuntimeConfig.IsCloudEnabled() {
-		client, err := hcp.NewClient(res.RuntimeConfig.Cloud)
+		client, err := hcpclient.NewClient(res.RuntimeConfig.Cloud)
 		if err != nil {
 			ui.Error("error building HCP HTTP client: " + err.Error())
 			return 1