[supervisor] local exposed

Author: mustard-mh

components/supervisor/pkg/ports/exposed-ports.go

@@ -6,6 +6,8 @@ package ports
 
 import (
 	"context"
+	"fmt"
+	"net/url"
 	"time"
 
 	backoff "github.com/cenkalti/backoff/v4"
@@ -57,9 +59,14 @@ func (*NoopExposedPorts) Expose(ctx context.Context, local uint32, public bool)
 // GitpodExposedPorts uses a connection to the Gitpod server to implement
 // the ExposedPortsInterface.
 type GitpodExposedPorts struct {
-	WorkspaceID string
-	InstanceID  string
-	C           gitpod.APIInterface
+	WorkspaceID  string
+	InstanceID   string
+	WorkspaceUrl string
+	C            gitpod.APIInterface
+
+	localExposedPort   []uint32
+	localExposedNotice chan struct{}
+	lastServerExposed  []*gitpod.WorkspaceInstancePort
 
 	requests chan *exposePortRequest
 }
@@ -71,15 +78,35 @@ type exposePortRequest struct {
 }
 
 // NewGitpodExposedPorts creates a new instance of GitpodExposedPorts
-func NewGitpodExposedPorts(workspaceID string, instanceID string, gitpodService gitpod.APIInterface) *GitpodExposedPorts {
+func NewGitpodExposedPorts(workspaceID string, instanceID string, workspaceUrl string, gitpodService gitpod.APIInterface) *GitpodExposedPorts {
 	return &GitpodExposedPorts{
-		WorkspaceID: workspaceID,
-		InstanceID:  instanceID,
-		C:           gitpodService,
+		WorkspaceID:  workspaceID,
+		InstanceID:   instanceID,
+		WorkspaceUrl: workspaceUrl,
+		C:            gitpodService,
 
 		// allow clients to submit 30 expose requests without blocking
-		requests: make(chan *exposePortRequest, 30),
+		requests:           make(chan *exposePortRequest, 30),
+		localExposedNotice: make(chan struct{}, 30),
+	}
+}
+
+func (g *GitpodExposedPorts) getPortUrl(port uint32) string {
+	u, err := url.Parse(g.WorkspaceUrl)
+	if err != nil {
+		return ""
+	}
+	u.Host = fmt.Sprintf("%d-%s", port, u.Host)
+	return u.String()
+}
+
+func (g *GitpodExposedPorts) existInLocalExposed(port uint32) bool {
+	for _, p := range g.localExposedPort {
+		if p == port {
+			return true
+		}
 	}
+	return false
 }
 
 // Observe starts observing the exposed ports until the context is canceled.
@@ -98,22 +125,41 @@ func (g *GitpodExposedPorts) Observe(ctx context.Context) (<-chan []ExposedPort,
 			errchan <- err
 			return
 		}
+		mixin := func(localExposedPort []uint32, serverExposePort []*gitpod.WorkspaceInstancePort) []ExposedPort {
+			res := make(map[uint32]ExposedPort)
+			for _, port := range g.localExposedPort {
+				res[port] = ExposedPort{
+					LocalPort: port,
+					Public:    false,
+					URL:       g.getPortUrl(port),
+				}
+			}
+
+			for _, p := range serverExposePort {
+				res[uint32(p.Port)] = ExposedPort{
+					LocalPort: uint32(p.Port),
+					Public:    p.Visibility == "public",
+					URL:       p.URL,
+				}
+			}
+			exposedPort := make([]ExposedPort, 0, len(res))
+			for _, p := range res {
+				exposedPort = append(exposedPort, p)
+			}
+			return exposedPort
+		}
 		for {
 			select {
 			case u := <-updates:
 				if u == nil {
 					return
 				}
+				g.lastServerExposed = u.Status.ExposedPorts
 
-				res := make([]ExposedPort, len(u.Status.ExposedPorts))
-				for i, p := range u.Status.ExposedPorts {
-					res[i] = ExposedPort{
-						LocalPort: uint32(p.Port),
-						Public:    p.Visibility == "public",
-						URL:       p.URL,
-					}
-				}
-
+				res := mixin(g.localExposedPort, g.lastServerExposed)
+				reschan <- res
+			case <-g.localExposedNotice:
+				res := mixin(g.localExposedPort, g.lastServerExposed)
 				reschan <- res
 			case <-ctx.Done():
 				return
@@ -180,14 +226,19 @@ func (g *GitpodExposedPorts) doExpose(req *exposePortRequest) {
 
 // Expose exposes a port to the internet. Upon successful execution any Observer will be updated.
 func (g *GitpodExposedPorts) Expose(ctx context.Context, local uint32, public bool) <-chan error {
-	v := "private"
-	if public {
-		v = "public"
+	if !public {
+		if !g.existInLocalExposed(local) {
+			g.localExposedPort = append(g.localExposedPort, local)
+			g.localExposedNotice <- struct{}{}
+		}
+		c := make(chan error)
+		close(c)
+		return c
 	}
 	req := &exposePortRequest{
 		port: &gitpod.WorkspaceInstancePort{
 			Port:       float64(local),
-			Visibility: v,
+			Visibility: "public",
 		},
 		ctx:  ctx,
 		done: make(chan error),

components/supervisor/pkg/supervisor/supervisor.go

@@ -634,7 +634,7 @@ func createExposedPortsImpl(cfg *Config, gitpodService *gitpod.APIoverJSONRPC) p
 		log.Error("auto-port exposure won't work")
 		return &ports.NoopExposedPorts{}
 	}
-	return ports.NewGitpodExposedPorts(cfg.WorkspaceID, cfg.WorkspaceInstanceID, gitpodService)
+	return ports.NewGitpodExposedPorts(cfg.WorkspaceID, cfg.WorkspaceInstanceID, cfg.WorkspaceUrl, gitpodService)
 }
 
 // supervisor ships some binaries we want in the PATH. We could just add some directory to the path, but