server: listen on the memory connection only (#4406)

this will temporarily break 'tilt alpha get'
while we transition to the new system

internal/cli/updog_get_test.go

@@ -20,6 +20,9 @@ import (
 )
 
 func TestUpdogGet(t *testing.T) {
+	if true {
+		t.Skip("TODO(nick): bring this back")
+	}
 	f := newServerFixture(t)
 	defer f.TearDown()
 
@@ -60,10 +63,11 @@ func newServerFixture(t *testing.T) *serverFixture {
 	port, err := freeport.GetFreePort()
 	require.NoError(t, err)
 
-	cfg, err := server.ProvideTiltServerOptions(ctx, "localhost", model.WebPort(port), model.TiltBuild{}, memconn)
+	cfg, err := server.ProvideTiltServerOptions(ctx, model.TiltBuild{}, memconn)
 	require.NoError(t, err)
 
-	hudsc := server.ProvideHeadsUpServerController(model.WebPort(port), cfg, &server.HeadsUpServer{}, assets.NewFakeServer(), model.WebURL{})
+	hudsc := server.ProvideHeadsUpServerController("localhost",
+		model.WebPort(port), cfg, &server.HeadsUpServer{}, assets.NewFakeServer(), model.WebURL{})
 	st := store.NewTestingStore()
 	require.NoError(t, hudsc.SetUp(ctx, st))
 

internal/engine/upper_test.go

@@ -3781,9 +3781,10 @@ func newTestFixture(t *testing.T) *testFixture {
 	dcw := dcwatch.NewEventWatcher(fakeDcc, dockerClient)
 	dclm := runtimelog.NewDockerComposeLogManager(fakeDcc)
 	memconn := server.ProvideMemConn()
-	serverOptions, err := server.ProvideTiltServerOptions(ctx, "localhost", 0, model.TiltBuild{}, memconn)
+	serverOptions, err := server.ProvideTiltServerOptions(ctx, model.TiltBuild{}, memconn)
 	require.NoError(t, err)
-	hudsc := server.ProvideHeadsUpServerController(0, serverOptions, &server.HeadsUpServer{}, assets.NewFakeServer(), model.WebURL{})
+	hudsc := server.ProvideHeadsUpServerController(
+		"localhost", 0, serverOptions, &server.HeadsUpServer{}, assets.NewFakeServer(), model.WebURL{})
 	ewm := k8swatch.NewEventWatchManager(kCli, of, ns)
 	tcum := cloud.NewStatusManager(httptest.NewFakeClientEmptyJSON(), clock)
 	fe := cmd.NewFakeExecer()

internal/hud/server/apiserver.go

@@ -2,8 +2,6 @@ package server
 
 import (
 	"context"
-	"fmt"
-	"net"
 
 	"k8s.io/client-go/dynamic"
 
@@ -27,7 +25,7 @@ func ProvideMemConn() apiserver.ConnProvider {
 }
 
 // Configures the Tilt API server.
-func ProvideTiltServerOptions(ctx context.Context, host model.WebHost, port model.WebPort, tiltBuild model.TiltBuild, memconn apiserver.ConnProvider) (*APIServerConfig, error) {
+func ProvideTiltServerOptions(ctx context.Context, tiltBuild model.TiltBuild, memconn apiserver.ConnProvider) (*APIServerConfig, error) {
 	w := logger.Get(ctx).Writer(logger.DebugLvl)
 	builder := builder.NewServerBuilder().
 		WithOutputWriter(w)
@@ -36,30 +34,19 @@ func ProvideTiltServerOptions(ctx context.Context, host model.WebHost, port mode
 		builder = builder.WithResourceMemoryStorage(obj, "data")
 	}
 	builder = builder.WithOpenAPIDefinitions("tilt", tiltBuild.Version, openapi.GetOpenAPIDefinitions)
-	if port == 0 {
-		builder = builder.WithConnProvider(memconn)
-	} else {
-		builder = builder.WithBindPort(int(port))
-	}
+
+	// TODO(nick): We're going to split the APIServer into a separate port
+	// that speaks HTTPS instead of HTTP. For the transition period,
+	// we'll use the in-memory connection.
+	builder = builder.WithConnProvider(memconn)
 
 	o, err := builder.ToServerOptions()
 	if err != nil {
 		return nil, err
 	}
 
-	if port == 0 {
-		// Fake bind port
-		o.ServingOptions.BindPort = 1
-	} else {
-		l, err := net.Listen("tcp", fmt.Sprintf("%s:%d", string(host), int(port)))
-		if err != nil {
-			return nil, fmt.Errorf("Tilt cannot start because you already have another process on port %d\n"+
-				"If you want to run multiple Tilt instances simultaneously,\n"+
-				"use the --port flag or TILT_PORT env variable to set a custom port\nOriginal error: %v",
-				port, err)
-		}
-		o.ServingOptions.Listener = l
-	}
+	// Fake bind port
+	o.ServingOptions.BindPort = 1
 
 	err = o.Complete()
 	if err != nil {

internal/hud/server/apiserver_test.go

@@ -25,10 +25,10 @@ import (
 func TestAPIServerDynamicClient(t *testing.T) {
 	ctx, _, _ := testutils.CtxAndAnalyticsForTest()
 	memconn := ProvideMemConn()
-	cfg, err := ProvideTiltServerOptions(ctx, "localhost", 0, model.TiltBuild{}, memconn)
+	cfg, err := ProvideTiltServerOptions(ctx, model.TiltBuild{}, memconn)
 	require.NoError(t, err)
 
-	hudsc := ProvideHeadsUpServerController(0, cfg, &HeadsUpServer{}, assets.NewFakeServer(), model.WebURL{})
+	hudsc := ProvideHeadsUpServerController("localhost", 0, cfg, &HeadsUpServer{}, assets.NewFakeServer(), model.WebURL{})
 	st := store.NewTestingStore()
 	require.NoError(t, hudsc.SetUp(ctx, st))
 	defer hudsc.TearDown(ctx)

internal/hud/server/controller.go

@@ -3,6 +3,7 @@ package server
 import (
 	"context"
 	"fmt"
+	"net"
 	"net/http"
 	"time"
 
@@ -15,17 +16,20 @@ import (
 )
 
 type HeadsUpServerController struct {
+	host            model.WebHost
 	port            model.WebPort
 	hudServer       *HeadsUpServer
 	assetServer     assets.Server
 	apiServer       *http.Server
+	webServer       *http.Server
 	webURL          model.WebURL
 	apiServerConfig *APIServerConfig
 
 	shutdown func()
 }
 
 func ProvideHeadsUpServerController(
+	host model.WebHost,
 	port model.WebPort,
 	apiServerConfig *APIServerConfig,
 	hudServer *HeadsUpServer,
@@ -36,6 +40,7 @@ func ProvideHeadsUpServerController(
 	close(emptyCh)
 
 	return &HeadsUpServerController{
+		host:            host,
 		port:            port,
 		hudServer:       hudServer,
 		assetServer:     assetServer,
@@ -49,9 +54,13 @@ func (s *HeadsUpServerController) TearDown(ctx context.Context) {
 	s.shutdown()
 	s.assetServer.TearDown(ctx)
 
-	ctx, cancel := context.WithTimeout(ctx, 10*time.Millisecond)
-	defer cancel()
-	_ = s.apiServer.Shutdown(ctx)
+	ctxWeb, cancelWeb := context.WithTimeout(ctx, 10*time.Millisecond)
+	defer cancelWeb()
+	_ = s.webServer.Shutdown(ctxWeb)
+
+	ctxApi, cancelApi := context.WithTimeout(ctx, 10*time.Millisecond)
+	defer cancelApi()
+	_ = s.apiServer.Shutdown(ctxApi)
 }
 
 func (s *HeadsUpServerController) OnChange(ctx context.Context, st store.RStore, _ store.ChangeSummary) {
@@ -105,6 +114,20 @@ func (s *HeadsUpServerController) setUpHelper(ctx context.Context, st store.RSto
 	r.PathPrefix("/debug").Handler(http.DefaultServeMux) // for /debug/pprof
 	r.PathPrefix("/").Handler(s.hudServer.Router())
 
+	webListener, err := net.Listen("tcp", fmt.Sprintf("%s:%d", string(s.host), int(s.port)))
+	if err != nil {
+		return fmt.Errorf("Tilt cannot start because you already have another process on port %d\n"+
+			"If you want to run multiple Tilt instances simultaneously,\n"+
+			"use the --port flag or TILT_PORT env variable to set a custom port\nOriginal error: %v",
+			s.port, err)
+	}
+
+	s.webServer = &http.Server{
+		Addr:    webListener.Addr().String(),
+		Handler: s.hudServer.Router(),
+	}
+	runServer(ctx, s.webServer, webListener)
+
 	s.apiServer = &http.Server{
 		Addr:           serving.Listener.Addr().String(),
 		Handler:        r,