coder · deansheather · Sep 13, 2022 · Aug 26, 2022 · Aug 26, 2022 · Aug 29, 2022
diff --git a/cli/server.go b/cli/server.go
@@ -688,7 +688,7 @@ func Server(newAPI func(*coderd.Options) *coderd.API) *cobra.Command {
 
 			cmd.Println("Waiting for WebSocket connections to close...")
 			_ = coderAPI.Close()
-			cmd.Println("Done wainting for WebSocket connections")
+			cmd.Println("Done waiting for WebSocket connections")
 
 			// Close tunnel after we no longer have in-flight connections.
 			if tunnel {

diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -160,6 +160,26 @@ func New(options *Options) *API {
 		httpmw.Recover(api.Logger),
 		httpmw.Logger(api.Logger),
 		httpmw.Prometheus(options.PrometheusRegistry),
+		// handleSubdomainApplications checks if the first subdomain is a valid
+		// app URL. If it is, it will serve that application.
+		api.handleSubdomainApplications(
+			// Middleware to impose on the served application.
+			httpmw.RateLimitPerMinute(options.APIRateLimit),
+			httpmw.UseLoginURL(func() *url.URL {
+				if options.AccessURL == nil {
+					return nil
+				}
+
+				u := *options.AccessURL
+				u.Path = "/login"
+				return &u
+			}()),
+			// This should extract the application specific API key when we
+			// implement a scoped token.
+			httpmw.ExtractAPIKey(options.Database, oauthConfigs, true),
+			httpmw.ExtractUserParam(api.Database),
+			httpmw.ExtractWorkspaceAndAgentParam(api.Database),
+		),
 		// Build-Version is helpful for debugging.
 		func(next http.Handler) http.Handler {
 			return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

diff --git a/coderd/coderdtest/coderdtest.go b/coderd/coderdtest/coderdtest.go
@@ -182,8 +182,12 @@ func newWithAPI(t *testing.T, options *Options) (*codersdk.Client, io.Closer, *c
 	srv.Start()
 	t.Cleanup(srv.Close)
 
+	tcpAddr, ok := srv.Listener.Addr().(*net.TCPAddr)
+	require.True(t, ok)
+
 	serverURL, err := url.Parse(srv.URL)
 	require.NoError(t, err)
+	serverURL.Host = fmt.Sprintf("localhost:%d", tcpAddr.Port)
 
 	derpPort, err := strconv.Atoi(serverURL.Port())
 	require.NoError(t, err)

diff --git a/coderd/httpapi/url.go b/coderd/httpapi/url.go
@@ -0,0 +1,100 @@
+package httpapi
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"golang.org/x/xerrors"
+)
+
+var (
+	// Remove the "starts with" and "ends with" regex components.
+	nameRegex = strings.Trim(UsernameValidRegex.String(), "^$")
+	appURL    = regexp.MustCompile(fmt.Sprintf(
+		// {PORT/APP_NAME}--{AGENT_NAME}--{WORKSPACE_NAME}--{USERNAME}
+		`^(?P<AppName>%[1]s)--(?P<AgentName>%[1]s)--(?P<WorkspaceName>%[1]s)--(?P<Username>%[1]s)$`,
+		nameRegex))
+)
+
+// SplitSubdomain splits a subdomain from the rest of the hostname. E.g.:
+//   - "foo.bar.com" becomes "foo", "bar.com"
+//   - "foo.bar.baz.com" becomes "foo", "bar.baz.com"
+//
+// An error is returned if the string doesn't contain a period.
+func SplitSubdomain(hostname string) (subdomain string, rest string, err error) {
+	toks := strings.SplitN(hostname, ".", 2)
+	if len(toks) < 2 {
+		return "", "", xerrors.New("no subdomain")
+	}
+
+	return toks[0], toks[1], nil
+}
+
+// ApplicationURL is a parsed application URL hostname.
+type ApplicationURL struct {
+	// Only one of AppName or Port will be set.
+	AppName       string
+	Port          uint16
+	AgentName     string
+	WorkspaceName string
+	Username      string
+	// BaseHostname is the rest of the hostname minus the application URL part
+	// and the first dot.
+	BaseHostname string
+}
+
+// String returns the application URL hostname without scheme.
+func (a ApplicationURL) String() string {
+	appNameOrPort := a.AppName
+	if a.Port != 0 {
+		appNameOrPort = strconv.Itoa(int(a.Port))
+	}
+
+	return fmt.Sprintf("%s--%s--%s--%s.%s", appNameOrPort, a.AgentName, a.WorkspaceName, a.Username, a.BaseHostname)
+}
+
+// ParseSubdomainAppURL parses an ApplicationURL from the given hostname. If
+// the subdomain is not a valid application URL hostname, returns a non-nil
+// error.
+//
+// Subdomains should be in the form:
+//
+//	{PORT/APP_NAME}--{AGENT_NAME}--{WORKSPACE_NAME}--{USERNAME}
+//	(eg. http://8080--main--dev--dean.hi.c8s.io)
+func ParseSubdomainAppURL(hostname string) (ApplicationURL, error) {
+	subdomain, rest, err := SplitSubdomain(hostname)
+	if err != nil {
+		return ApplicationURL{}, xerrors.Errorf("split host domain %q: %w", hostname, err)
+	}
+
+	matches := appURL.FindAllStringSubmatch(subdomain, -1)
+	if len(matches) == 0 {
+		return ApplicationURL{}, xerrors.Errorf("invalid application url format: %q", subdomain)
+	}
+	matchGroup := matches[0]
+
+	appName, port := AppNameOrPort(matchGroup[appURL.SubexpIndex("AppName")])
+	return ApplicationURL{
+		AppName:       appName,
+		Port:          port,
+		AgentName:     matchGroup[appURL.SubexpIndex("AgentName")],
+		WorkspaceName: matchGroup[appURL.SubexpIndex("WorkspaceName")],
+		Username:      matchGroup[appURL.SubexpIndex("Username")],
+		BaseHostname:  rest,
+	}, nil
+}
+
+// AppNameOrPort takes a string and returns either the input string or a port
+// number.
+func AppNameOrPort(val string) (string, uint16) {
+	port, err := strconv.ParseUint(val, 10, 16)
+	if err != nil || port == 0 {
+		port = 0
+	} else {
+		val = ""
+	}
+
+	return val, uint16(port)
+}