Introduce optional service_registration stanza

command/commands.go

@@ -155,6 +155,10 @@ var (
 		"raft":                   physRaft.NewRaftBackend,
 		"zookeeper":              physZooKeeper.NewZooKeeperBackend,
 	}
+
+	physicalServiceDiscoverers = map[string]physical.ServiceDiscoveryFactory{
+		"consul": physConsul.NewConsulServiceDiscovery,
+	}
 )
 
 // Commands is the mapping of all the available commands.
@@ -517,9 +521,12 @@ func initCommands(ui, serverCmdUi cli.Ui, runOpts *RunOptions) {
 				CredentialBackends: credentialBackends,
 				LogicalBackends:    logicalBackends,
 				PhysicalBackends:   physicalBackends,
-				ShutdownCh:         MakeShutdownCh(),
-				SighupCh:           MakeSighupCh(),
-				SigUSR2Ch:          MakeSigUSR2Ch(),
+
+				PhysicalServiceDiscoverers: physicalServiceDiscoverers,
+
+				ShutdownCh: MakeShutdownCh(),
+				SighupCh:   MakeSighupCh(),
+				SigUSR2Ch:  MakeSigUSR2Ch(),
 			}, nil
 		},
 		"ssh": func() (cli.Command, error) {

command/server.go

@@ -79,6 +79,8 @@ type ServerCommand struct {
 	LogicalBackends    map[string]logical.Factory
 	PhysicalBackends   map[string]physical.Factory
 
+	PhysicalServiceDiscoverers map[string]physical.ServiceDiscoveryFactory
+
 	ShutdownCh chan struct{}
 	SighupCh   chan struct{}
 	SigUSR2Ch  chan struct{}
@@ -935,6 +937,24 @@ func (c *ServerCommand) Run(args []string) int {
 		return 1
 	}
 
+	// Initialize the Service Discovery, if there is one
+	var configSd physical.ServiceDiscovery
+	if config.ServiceDiscovery != nil {
+		sdFactory, ok := c.PhysicalServiceDiscoverers[config.ServiceDiscovery.Type]
+		if !ok {
+			c.UI.Error(fmt.Sprintf("Unknown service_discovery type %s", config.ServiceDiscovery.Type))
+			return 1
+		}
+
+		namedSDLogger := c.logger.Named("service_discovery." + config.ServiceDiscovery.Type)
+		allLoggers = append(allLoggers, namedSDLogger)
+		configSd, err = sdFactory(config.ServiceDiscovery.Config, namedSDLogger)
+		if err != nil {
+			c.UI.Error(fmt.Sprintf("Error initializing service_discovery of type %s: %s", config.ServiceDiscovery.Type, err))
+			return 1
+		}
+	}
+
 	infoKeys := make([]string, 0, 10)
 	info := make(map[string]string)
 	info["log level"] = logLevelString
@@ -1019,6 +1039,7 @@ func (c *ServerCommand) Run(args []string) int {
 		RedirectAddr:              config.Storage.RedirectAddr,
 		StorageType:               config.Storage.Type,
 		HAPhysical:                nil,
+		ConfigServiceDiscovery:    configSd,
 		Seal:                      barrierSeal,
 		AuditBackends:             c.AuditBackends,
 		CredentialBackends:        c.CredentialBackends,
@@ -1218,6 +1239,13 @@ CLUSTER_SYNTHESIS_COMPLETE:
 		}
 	}
 
+	// If ServiceDiscovery is configured, then the backend must support HA
+	isBackendHA := coreConfig.HAPhysical != nil && coreConfig.HAPhysical.HAEnabled()
+	if (coreConfig.ConfigServiceDiscovery != nil) && !isBackendHA {
+		c.UI.Output("service_discovery is configured, but storage does not support HA")
+		return 1
+	}
+
 	// Initialize the core
 	core, newCoreError := vault.NewCore(coreConfig)
 	if newCoreError != nil {
@@ -1473,21 +1501,18 @@ CLUSTER_SYNTHESIS_COMPLETE:
 	// Instantiate the wait group
 	c.WaitGroup = &sync.WaitGroup{}
 
-	// If the backend supports service discovery, run service discovery
-	if coreConfig.HAPhysical != nil && coreConfig.HAPhysical.HAEnabled() {
-		sd, ok := coreConfig.HAPhysical.(physical.ServiceDiscovery)
-		if ok {
-			activeFunc := func() bool {
-				if isLeader, _, _, err := core.Leader(); err == nil {
-					return isLeader
-				}
-				return false
-			}
-
-			if err := sd.RunServiceDiscovery(c.WaitGroup, c.ShutdownCh, coreConfig.RedirectAddr, activeFunc, core.Sealed, core.PerfStandby); err != nil {
-				c.UI.Error(fmt.Sprintf("Error initializing service discovery: %v", err))
-				return 1
+	// If service discovery is available, run service discovery
+	sd := coreConfig.ServiceDiscovery()
+	if sd != nil {
+		activeFunc := func() bool {
+			if isLeader, _, _, err := core.Leader(); err == nil {
+				return isLeader
 			}
+			return false
+		}
+		if err := sd.RunServiceDiscovery(c.WaitGroup, c.ShutdownCh, coreConfig.RedirectAddr, activeFunc, core.Sealed, core.PerfStandby); err != nil {
+			c.UI.Error(fmt.Sprintf("Error initializing service discovery: %v", err))
+			return 1
 		}
 	}
 

command/server/config.go

@@ -28,6 +28,8 @@ type Config struct {
 	Storage   *Storage    `hcl:"-"`
 	HAStorage *Storage    `hcl:"-"`
 
+	ServiceDiscovery *ServiceDiscovery `hcl:"-"`
+
 	Seals   []*Seal  `hcl:"-"`
 	Entropy *Entropy `hcl:"-"`
 
@@ -150,6 +152,16 @@ func (b *Storage) GoString() string {
 	return fmt.Sprintf("*%#v", *b)
 }
 
+// ServiceDiscovery is the optional service discovery for the server.
+type ServiceDiscovery struct {
+	Type   string
+	Config map[string]string
+}
+
+func (b *ServiceDiscovery) GoString() string {
+	return fmt.Sprintf("*%#v", *b)
+}
+
 // Seal contains Seal configuration for the server
 type Seal struct {
 	Type     string
@@ -291,6 +303,11 @@ func (c *Config) Merge(c2 *Config) *Config {
 		result.HAStorage = c2.HAStorage
 	}
 
+	result.ServiceDiscovery = c.ServiceDiscovery
+	if c2.ServiceDiscovery != nil {
+		result.ServiceDiscovery = c2.ServiceDiscovery
+	}
+
 	result.Entropy = c.Entropy
 	if c2.Entropy != nil {
 		result.Entropy = c2.Entropy
@@ -584,6 +601,13 @@ func ParseConfig(d string) (*Config, error) {
 		}
 	}
 
+	//parse service discovery
+	if o := list.Filter("service_discovery"); len(o.Items) > 0 {
+		if err := parseServiceDiscovery(&result, o, "service_discovery"); err != nil {
+			return nil, errwrap.Wrapf("error parsing 'service_discovery': {{err}}", err)
+		}
+	}
+
 	if o := list.Filter("hsm"); len(o.Items) > 0 {
 		if err := parseSeals(&result, o, "hsm"); err != nil {
 			return nil, errwrap.Wrapf("error parsing 'hsm': {{err}}", err)
@@ -828,6 +852,30 @@ func parseHAStorage(result *Config, list *ast.ObjectList, name string) error {
 	return nil
 }
 
+func parseServiceDiscovery(result *Config, list *ast.ObjectList, name string) error {
+	if len(list.Items) > 1 {
+		return fmt.Errorf("only one %q block is permitted", name)
+	}
+
+	// Get our item
+	item := list.Items[0]
+	key := name
+	if len(item.Keys) > 0 {
+		key = item.Keys[0].Token.Value().(string)
+	}
+
+	var m map[string]string
+	if err := hcl.DecodeObject(&m, item.Val); err != nil {
+		return multierror.Prefix(err, fmt.Sprintf("%s.%s:", name, key))
+	}
+
+	result.ServiceDiscovery = &ServiceDiscovery{
+		Type:   strings.ToLower(key),
+		Config: m,
+	}
+	return nil
+}
+
 func parseSeals(result *Config, list *ast.ObjectList, blockName string) error {
 	if len(list.Items) > 2 {
 		return fmt.Errorf("only two or less %q blocks are permitted", blockName)
@@ -1008,6 +1056,14 @@ func (c *Config) Sanitized() map[string]interface{} {
 		result["ha_storage"] = sanitizedHAStorage
 	}
 
+	// Sanitize service_discovery stanza
+	if c.ServiceDiscovery != nil {
+		sanitizedServiceDiscovery := map[string]interface{}{
+			"type": c.ServiceDiscovery.Type,
+		}
+		result["service_discovery"] = sanitizedServiceDiscovery
+	}
+
 	// Sanitize seals stanza
 	if len(c.Seals) != 0 {
 		var sanitizedSeals []interface{}

command/server/config_test_helpers.go

@@ -47,6 +47,13 @@ func testLoadConfigFile_topLevel(t *testing.T, entropy *Entropy) {
 			DisableClustering: true,
 		},
 
+		ServiceDiscovery: &ServiceDiscovery{
+			Type: "consul",
+			Config: map[string]string{
+				"foo": "bar",
+			},
+		},
+
 		Telemetry: &Telemetry{
 			StatsdAddr:                 "bar",
 			StatsiteAddr:               "foo",
@@ -126,6 +133,13 @@ func testLoadConfigFile_json2(t *testing.T, entropy *Entropy) {
 			DisableClustering: true,
 		},
 
+		ServiceDiscovery: &ServiceDiscovery{
+			Type: "consul",
+			Config: map[string]string{
+				"foo": "bar",
+			},
+		},
+
 		CacheSize: 45678,
 
 		EnableUI:    true,
@@ -261,6 +275,13 @@ func testLoadConfigFile(t *testing.T) {
 			DisableClustering: true,
 		},
 
+		ServiceDiscovery: &ServiceDiscovery{
+			Type: "consul",
+			Config: map[string]string{
+				"foo": "bar",
+			},
+		},
+
 		Telemetry: &Telemetry{
 			StatsdAddr:              "bar",
 			StatsiteAddr:            "foo",
@@ -324,6 +345,13 @@ func testLoadConfigFile_json(t *testing.T) {
 			DisableClustering: true,
 		},
 
+		ServiceDiscovery: &ServiceDiscovery{
+			Type: "consul",
+			Config: map[string]string{
+				"foo": "bar",
+			},
+		},
+
 		ClusterCipherSuites: "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
 
 		Telemetry: &Telemetry{
@@ -476,6 +504,9 @@ func testConfig_Sanitized(t *testing.T) {
 			"redirect_addr":      "top_level_api_addr",
 			"type":               "consul",
 		},
+		"service_discovery": map[string]interface{}{
+			"type": "consul",
+		},
 		"telemetry": map[string]interface{}{
 			"circonus_api_app":                       "",
 			"circonus_api_token":                     "",

command/server/test-fixtures/config.hcl

@@ -18,6 +18,10 @@ ha_backend "consul" {
     disable_clustering = "true"
 }
 
+service_discovery "consul" {
+    foo = "bar"
+}
+
 telemetry {
     statsd_address = "bar"
     statsite_address = "foo"

command/server/test-fixtures/config.hcl.json

@@ -11,6 +11,11 @@
 			"disable_clustering": "true"
 		}
 	},
+	"service_discovery": {
+		"consul": {
+			"foo": "bar",
+		}
+	},
 	"telemetry": {
 		"statsite_address": "baz"
 	},

command/server/test-fixtures/config2.hcl

@@ -21,6 +21,10 @@ ha_storage "consul" {
     disable_clustering = "true"
 }
 
+service_discovery "consul" {
+    foo = "bar"
+}
+
 telemetry {
     statsd_address = "bar"
     statsite_address = "foo"

command/server/test-fixtures/config2.hcl.json

@@ -25,6 +25,11 @@
       "disable_clustering": "true"
     }
   },
+  "service_discovery":{
+    "consul":{
+      "foo":"bar"
+    }
+  },
   "cache_size": 45678,
   "telemetry":{
     "statsd_address":"bar",

command/server/test-fixtures/config3.hcl

@@ -22,6 +22,10 @@ ha_backend "consul" {
   token = "foo"
 }
 
+service_discovery "consul" {
+  token = "foo"
+}
+
 telemetry {
   statsd_address = "bar"
   circonus_api_token = "baz"
@@ -38,4 +42,4 @@ default_lease_ttl = "10h"
 cluster_name = "testcluster"
 pid_file = "./pidfile"
 raw_storage_endpoint = true
-disable_sealwrap = true
+disable_sealwrap = true