Initial worker porting steps (#232)

2020-08-12 00:40:39 -04:00
1 parent 73a38b1433
commit 203e2b5dc2
@@ -10,19 +10,23 @@ import (
 	"github.com/hashicorp/boundary/internal/cmd/base"
 	"github.com/hashicorp/boundary/internal/cmd/config"
 	"github.com/hashicorp/go-hclog"
+	wrapping "github.com/hashicorp/go-kms-wrapping"
+	"github.com/hashicorp/vault/sdk/helper/base62"
 )

 // TestController wraps a base.Server and Controller to provide a
 // fully-programmatic controller for tests. Error checking (for instance, for
 // valid config) is not stringent at the moment.
 type TestController struct {
-	b      *base.Server
-	c      *Controller
-	t      *testing.T
-	addrs  []string // The address the Controller API is listening on
-	client *api.Client
-	ctx    context.Context
-	cancel context.CancelFunc
+	b            *base.Server
+	c            *Controller
+	t            *testing.T
+	apiAddrs     []string // The address the Controller API is listening on
+	clusterAddrs []string
+	client       *api.Client
+	ctx          context.Context
+	cancel       context.CancelFunc
+	name         string
 }

 // Controller returns the underlying controller
@@ -30,6 +34,10 @@ func (tc *TestController) Controller() *Controller {
 	return tc.c
 }

+func (tc *TestController) Config() *Config {
+	return tc.c.conf
+}
+
 func (tc *TestController) Client() *api.Client {
 	return tc.client
 }
@@ -42,23 +50,52 @@ func (tc *TestController) Cancel() {
 	tc.cancel()
 }

+func (tc *TestController) Name() string {
+	return tc.name
+}
+
 func (tc *TestController) ApiAddrs() []string {
-	if tc.addrs != nil {
-		return tc.addrs
+	return tc.addrs("api")
+}
+
+func (tc *TestController) ClusterAddrs() []string {
+	return tc.addrs("cluster")
+}
+
+func (tc *TestController) addrs(purpose string) []string {
+	var prefix string
+	switch purpose {
+	case "api":
+		if tc.apiAddrs != nil {
+			return tc.apiAddrs
+		}
+		prefix = "http://"
+	case "cluster":
+		if tc.clusterAddrs != nil {
+			return tc.clusterAddrs
+		}
 	}

+	addrs := make([]string, 0, len(tc.b.Listeners))
 	for _, listener := range tc.b.Listeners {
-		if listener.Config.Purpose[0] == "api" {
+		if listener.Config.Purpose[0] == purpose {
 			tcpAddr, ok := listener.Mux.Addr().(*net.TCPAddr)
 			if !ok {
 				tc.t.Fatal("could not parse address as a TCP addr")
 			}
-			addr := fmt.Sprintf("http://%s:%d", tcpAddr.IP.String(), tcpAddr.Port)
-			tc.addrs = append(tc.addrs, addr)
+			addr := fmt.Sprintf("%s%s:%d", prefix, tcpAddr.IP.String(), tcpAddr.Port)
+			addrs = append(addrs, addr)
 		}
 	}

-	return tc.addrs
+	switch purpose {
+	case "api":
+		tc.apiAddrs = addrs
+	case "cluster":
+		tc.clusterAddrs = addrs
+	}
+
+	return addrs
 }

 func (tc *TestController) buildClient() {
@@ -90,7 +127,7 @@ func (tc *TestController) Shutdown() {
 	tc.cancel()

 	if tc.c != nil {
-		if err := tc.c.Shutdown(); err != nil {
+		if err := tc.c.Shutdown(false); err != nil {
 			tc.t.Error(err)
 		}
 	}
@@ -127,6 +164,10 @@ type TestControllerOpts struct {
 	// database
 	DisableDatabaseCreation bool

+	// If set, instead of creating a dev database, it will connect to an
+	// existing database given the url
+	DatabaseUrl string
+
 	// If true, the controller will not be started
 	DisableAutoStart bool

@@ -134,6 +175,19 @@ type TestControllerOpts struct {
 	// performed but they won't cause 403 Forbidden. Useful for API-level
 	// testing to avoid a lot of faff.
 	DisableAuthorizationFailures bool
+
+	// The controller KMS to use, or one will be created
+	ControllerKMS wrapping.Wrapper
+
+	// The worker auth KMS to use, or one will be created
+	WorkerAuthKMS wrapping.Wrapper
+
+	// The name to use for the controller, otherwise one will be randomly
+	// generated, unless provided in a non-nil Config
+	Name string
+
+	// The logger to use, or one will be created
+	Logger hclog.Logger
 }

 func NewTestController(t *testing.T, opts *TestControllerOpts) *TestController {
@@ -162,6 +216,7 @@ func NewTestController(t *testing.T, opts *TestControllerOpts) *TestController {
 		if err != nil {
 			t.Fatal(err)
 		}
+		opts.Config.Controller.Name = opts.Name
 	}

 	// Set default org ID, preferring one passed in from opts over config
@@ -182,24 +237,52 @@ func NewTestController(t *testing.T, opts *TestControllerOpts) *TestController {
 	}

 	// Start a logger
-	tc.b.Logger = hclog.New(&hclog.LoggerOptions{
-		Level: hclog.Trace,
-	})
+	tc.b.Logger = opts.Logger
+	if tc.b.Logger == nil {
+		tc.b.Logger = hclog.New(&hclog.LoggerOptions{
+			Level: hclog.Trace,
+		})
+	}
+
+	if opts.Config.Controller == nil {
+		opts.Config.Controller = new(config.Controller)
+	}
+	if opts.Config.Controller.Name == "" {
+		opts.Config.Controller.Name, err = base62.Random(5)
+		if err != nil {
+			t.Fatal(err)
+		}
+		tc.b.Logger.Info("controller name generated", "name", opts.Config.Controller.Name)
+	}
+	tc.name = opts.Config.Controller.Name

 	// Set up KMSes
-	if err := tc.b.SetupKMSes(nil, opts.Config.SharedConfig, []string{"controller", "worker-auth"}); err != nil {
-		t.Fatal(err)
+	switch {
+	case opts.ControllerKMS != nil && opts.WorkerAuthKMS != nil:
+		tc.b.ControllerKMS = opts.ControllerKMS
+		tc.b.WorkerAuthKMS = opts.WorkerAuthKMS
+	case opts.ControllerKMS == nil && opts.WorkerAuthKMS == nil:
+		if err := tc.b.SetupKMSes(nil, opts.Config.SharedConfig, []string{"controller", "worker-auth"}); err != nil {
+			t.Fatal(err)
+		}
+	default:
+		t.Fatal("either controller and worker auth KMS must both be set, or neither")
 	}

 	// Ensure the listeners use random port allocation
 	for _, listener := range opts.Config.Listeners {
 		listener.RandomPort = true
 	}
-	if err := tc.b.SetupListeners(nil, opts.Config.SharedConfig); err != nil {
+	if err := tc.b.SetupListeners(nil, opts.Config.SharedConfig, []string{"api", "cluster"}); err != nil {
 		t.Fatal(err)
 	}

-	if !opts.DisableDatabaseCreation {
+	if opts.DatabaseUrl != "" {
+		tc.b.DatabaseUrl = opts.DatabaseUrl
+		if err := tc.b.ConnectToDatabase("postgres"); err != nil {
+			t.Fatal(err)
+		}
+	} else if !opts.DisableDatabaseCreation {
 		if err := tc.b.CreateDevDatabase("postgres"); err != nil {
 			t.Fatal(err)
 		}
@@ -228,3 +311,30 @@ func NewTestController(t *testing.T, opts *TestControllerOpts) *TestController {

 	return tc
 }
+
+func (tc *TestController) AddClusterControllerMember(t *testing.T, opts *TestControllerOpts) *TestController {
+	if opts == nil {
+		opts = new(TestControllerOpts)
+	}
+	nextOpts := &TestControllerOpts{
+		DatabaseUrl:         tc.c.conf.DatabaseUrl,
+		DefaultAuthMethodId: tc.c.conf.DevAuthMethodId,
+		DefaultOrgId:        tc.c.conf.DefaultOrgId,
+		ControllerKMS:       tc.c.conf.ControllerKMS,
+		WorkerAuthKMS:       tc.c.conf.WorkerAuthKMS,
+		Name:                opts.Name,
+		Logger:              tc.c.conf.Logger,
+	}
+	if opts.Logger != nil {
+		nextOpts.Logger = opts.Logger
+	}
+	if nextOpts.Name == "" {
+		var err error
+		nextOpts.Name, err = base62.Random(5)
+		if err != nil {
+			t.Fatal(err)
+		}
+		nextOpts.Logger.Info("controller name generated", "name", nextOpts.Name)
+	}
+	return NewTestController(t, nextOpts)
+}