Sep 13, 2022 · Aug 26, 2022 · Aug 26, 2022 · Aug 29, 2022 · Aug 29, 2022 · Aug 30, 2022
diff --git a/cli/server.go b/cli/server.go

 cmd.Println("Waiting for WebSocket connections to close...")
 _ = coderAPI.Close()
 cmd.Println("Donewainting for WebSocket connections")
 cmd.Println("Donewaiting 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
 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
 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
 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)
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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("Donewainting for WebSocket connections")
		cmd.Println("Donewaiting for WebSocket connections")
deansheather marked this conversation as resolved. Show resolvedHide resolved

		// Close tunnel after we no longer have in-flight connections.
		if tunnel {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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) {
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -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)
Expand Down
Original file line number	Diff line number	Diff line change
		@@ -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)
		}