X-Git-Url: https://git.arvados.org/arvados.git/blobdiff_plain/72f0641da38b49a13fefe1a62faa6cf74c6ebe03..2df5de69d74ab1fbf1fbcec23d392193522b0364:/lib/service/cmd_test.go

diff --git a/lib/service/cmd_test.go b/lib/service/cmd_test.go
index ec7834972c..7a1f98a8f0 100644
--- a/lib/service/cmd_test.go
+++ b/lib/service/cmd_test.go
@@ -11,7 +11,9 @@ import (
 	"crypto/tls"
 	"fmt"
 	"io/ioutil"
+	"net"
 	"net/http"
+	"net/url"
 	"os"
 	"testing"
 	"time"
@@ -29,6 +31,129 @@ func Test(t *testing.T) {
 var _ = check.Suite(&Suite{})
 
 type Suite struct{}
+type key int
+
+const (
+	contextKey key = iota
+)
+
+func (*Suite) TestGetListenAddress(c *check.C) {
+	// Find an available port on the testing host, so the test
+	// cases don't get confused by "already in use" errors.
+	listener, err := net.Listen("tcp", ":")
+	c.Assert(err, check.IsNil)
+	_, unusedPort, err := net.SplitHostPort(listener.Addr().String())
+	c.Assert(err, check.IsNil)
+	listener.Close()
+
+	defer os.Unsetenv("ARVADOS_SERVICE_INTERNAL_URL")
+	for idx, trial := range []struct {
+		// internalURL => listenURL, both with trailing "/"
+		// because config loader always adds it
+		internalURLs     map[string]string
+		envVar           string
+		expectErrorMatch string
+		expectLogsMatch  string
+		expectListen     string
+		expectInternal   string
+	}{
+		{
+			internalURLs:   map[string]string{"http://localhost:" + unusedPort + "/": ""},
+			expectListen:   "http://localhost:" + unusedPort + "/",
+			expectInternal: "http://localhost:" + unusedPort + "/",
+		},
+		{ // implicit port 80 in InternalURLs
+			internalURLs:     map[string]string{"http://localhost/": ""},
+			expectListen:     "http://localhost/",
+			expectInternal:   "http://localhost/",
+			expectErrorMatch: `.*:80: bind: permission denied`,
+		},
+		{ // implicit port 443 in InternalURLs
+			internalURLs:   map[string]string{"https://host.example/": "http://localhost:" + unusedPort + "/"},
+			expectListen:   "http://localhost:" + unusedPort + "/",
+			expectInternal: "https://host.example/",
+		},
+		{
+			internalURLs:   map[string]string{"https://hostname.example/": "http://localhost:8000/"},
+			expectListen:   "http://localhost:8000/",
+			expectInternal: "https://hostname.example/",
+		},
+		{
+			internalURLs: map[string]string{
+				"https://hostname1.example/": "http://localhost:12435/",
+				"https://hostname2.example/": "http://localhost:" + unusedPort + "/",
+			},
+			envVar:         "https://hostname2.example", // note this works despite missing trailing "/"
+			expectListen:   "http://localhost:" + unusedPort + "/",
+			expectInternal: "https://hostname2.example/",
+		},
+		{ // cannot listen on any of the ListenURLs
+			internalURLs: map[string]string{
+				"https://hostname1.example/": "http://1.2.3.4:" + unusedPort + "/",
+				"https://hostname2.example/": "http://1.2.3.4:" + unusedPort + "/",
+			},
+			expectErrorMatch: "configuration does not enable the \"arvados-controller\" service on this host",
+		},
+		{ // cannot listen on any of the (implied) ListenURLs
+			internalURLs: map[string]string{
+				"https://1.2.3.4/": "",
+				"https://1.2.3.5/": "",
+			},
+			expectErrorMatch: "configuration does not enable the \"arvados-controller\" service on this host",
+		},
+		{ // impossible port number
+			internalURLs: map[string]string{
+				"https://host.example/": "http://0.0.0.0:1234567",
+			},
+			expectErrorMatch: `.*:1234567: listen tcp: address 1234567: invalid port`,
+		},
+		{
+			// env var URL not mentioned in config = obey env var, with warning
+			internalURLs:    map[string]string{"https://hostname1.example/": "http://localhost:8000/"},
+			envVar:          "https://hostname2.example",
+			expectListen:    "https://hostname2.example/",
+			expectInternal:  "https://hostname2.example/",
+			expectLogsMatch: `.*\Qpossible configuration error: listening on https://hostname2.example/ (from $ARVADOS_SERVICE_INTERNAL_URL) even though configuration does not have a matching InternalURLs entry\E.*\n`,
+		},
+		{
+			// env var + empty config = obey env var, with warning
+			envVar:          "https://hostname.example",
+			expectListen:    "https://hostname.example/",
+			expectInternal:  "https://hostname.example/",
+			expectLogsMatch: `.*\Qpossible configuration error: listening on https://hostname.example/ (from $ARVADOS_SERVICE_INTERNAL_URL) even though configuration does not have a matching InternalURLs entry\E.*\n`,
+		},
+	} {
+		c.Logf("trial %d %+v", idx, trial)
+		os.Setenv("ARVADOS_SERVICE_INTERNAL_URL", trial.envVar)
+		var logbuf bytes.Buffer
+		log := ctxlog.New(&logbuf, "text", "info")
+		services := arvados.Services{Controller: arvados.Service{InternalURLs: map[arvados.URL]arvados.ServiceInstance{}}}
+		for k, v := range trial.internalURLs {
+			u, err := url.Parse(k)
+			c.Assert(err, check.IsNil)
+			si := arvados.ServiceInstance{}
+			if v != "" {
+				u, err := url.Parse(v)
+				c.Assert(err, check.IsNil)
+				si.ListenURL = arvados.URL(*u)
+			}
+			services.Controller.InternalURLs[arvados.URL(*u)] = si
+		}
+		listenURL, internalURL, err := getListenAddr(services, "arvados-controller", log)
+		if trial.expectLogsMatch != "" {
+			c.Check(logbuf.String(), check.Matches, trial.expectLogsMatch)
+		}
+		if trial.expectErrorMatch != "" {
+			c.Check(err, check.ErrorMatches, trial.expectErrorMatch)
+			continue
+		}
+		if !c.Check(err, check.IsNil) {
+			continue
+		}
+		c.Check(listenURL.String(), check.Equals, trial.expectListen)
+		c.Check(internalURL.String(), check.Equals, trial.expectInternal)
+	}
+}
 
 func (*Suite) TestCommand(c *check.C) {
 	cf, err := ioutil.TempFile("", "cmd_test.")
@@ -42,11 +167,11 @@ func (*Suite) TestCommand(c *check.C) {
 	defer cancel()
 
 	cmd := Command(arvados.ServiceNameController, func(ctx context.Context, _ *arvados.Cluster, token string, reg *prometheus.Registry) Handler {
-		c.Check(ctx.Value("foo"), check.Equals, "bar")
+		c.Check(ctx.Value(contextKey), check.Equals, "bar")
 		c.Check(token, check.Equals, "abcde")
 		return &testHandler{ctx: ctx, healthCheck: healthCheck}
 	})
-	cmd.(*command).ctx = context.WithValue(ctx, "foo", "bar")
+	cmd.(*command).ctx = context.WithValue(ctx, contextKey, "bar")
 
 	done := make(chan bool)
 	var stdin, stdout, stderr bytes.Buffer
@@ -107,6 +232,7 @@ Clusters:
 				continue
 			}
 			body, err := ioutil.ReadAll(resp.Body)
+			c.Check(err, check.IsNil)
 			c.Logf("status %d, body %s", resp.StatusCode, string(body))
 			c.Check(resp.StatusCode, check.Equals, http.StatusOK)
 			break