coder · coadler · Apr 18, 2023 · Apr 17, 2023 · Apr 18, 2023
diff --git a/coderd/apidoc/docs.go b/coderd/apidoc/docs.go
diff --git a/coderd/apidoc/swagger.json b/coderd/apidoc/swagger.json
diff --git a/coderd/healthcheck/accessurl.go b/coderd/healthcheck/accessurl.go
@@ -0,0 +1,63 @@
+package healthcheck
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"net/url"
+	"time"
+
+	"golang.org/x/xerrors"
+)
+
+type AccessURLReport struct {
+	Healthy         bool
+	Reachable       bool
+	StatusCode      int
+	HealthzResponse string
+	Err             error
+}
+
+type AccessURLOptions struct {
+	AccessURL *url.URL
+	Client    *http.Client
+}
+
+func (r *AccessURLReport) Run(ctx context.Context, opts *AccessURLOptions) {
+	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+	defer cancel()
+
+	if opts.Client == nil {
+		opts.Client = http.DefaultClient
+	}
+
+	accessURL, err := opts.AccessURL.Parse("/healthz")
+	if err != nil {
+		r.Err = xerrors.Errorf("parse healthz endpoint: %w", err)
+		return
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "GET", accessURL.String(), nil)
+	if err != nil {
+		r.Err = xerrors.Errorf("create healthz request: %w", err)
+		return
+	}
+
+	res, err := opts.Client.Do(req)
+	if err != nil {
+		r.Err = xerrors.Errorf("get healthz endpoint: %w", err)
+		return
+	}
+	defer res.Body.Close()
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		r.Err = xerrors.Errorf("read healthz response: %w", err)
+		return
+	}
+
+	r.Reachable = true
+	r.Healthy = res.StatusCode == http.StatusOK
+	r.StatusCode = res.StatusCode
+	r.HealthzResponse = string(body)
+}
diff --git a/coderd/healthcheck/accessurl_test.go b/coderd/healthcheck/accessurl_test.go
@@ -0,0 +1,113 @@
+package healthcheck_test
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/xerrors"
+
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/coderd/healthcheck"
+)
+
+func TestAccessURL(t *testing.T) {
+	t.Parallel()
+
+	t.Run("OK", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			ctx, cancel = context.WithCancel(context.Background())
+			report      healthcheck.AccessURLReport
+			client      = coderdtest.New(t, nil)
+		)
+		defer cancel()
+
+		report.Run(ctx, &healthcheck.AccessURLOptions{
+			AccessURL: client.URL,
+		})
+
+		assert.True(t, report.Healthy)
+		assert.True(t, report.Reachable)
+		assert.Equal(t, http.StatusOK, report.StatusCode)
+		assert.Equal(t, "OK", report.HealthzResponse)
+		assert.NoError(t, report.Err)
+	})
+
+	t.Run("404", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			ctx, cancel = context.WithCancel(context.Background())
+			report      healthcheck.AccessURLReport
+			resp        = []byte("NOT OK")
+			srv         = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusNotFound)
+				w.Write(resp)
+			}))
+		)
+		defer cancel()
+		defer srv.Close()
+
+		u, err := url.Parse(srv.URL)
+		require.NoError(t, err)
+
+		report.Run(ctx, &healthcheck.AccessURLOptions{
+			Client:    srv.Client(),
+			AccessURL: u,
+		})
+
+		assert.False(t, report.Healthy)
+		assert.True(t, report.Reachable)
+		assert.Equal(t, http.StatusNotFound, report.StatusCode)
+		assert.Equal(t, string(resp), report.HealthzResponse)
+		assert.NoError(t, report.Err)
+	})
+
+	t.Run("ClientErr", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			ctx, cancel = context.WithCancel(context.Background())
+			report      healthcheck.AccessURLReport
+			resp        = []byte("OK")
+			srv         = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				w.Write(resp)
+			}))
+			client = srv.Client()
+		)
+		defer cancel()
+		defer srv.Close()
+
+		expErr := xerrors.New("client error")
+		client.Transport = roundTripFunc(func(r *http.Request) (*http.Response, error) {
+			return nil, expErr
+		})
+
+		u, err := url.Parse(srv.URL)
+		require.NoError(t, err)
+
+		report.Run(ctx, &healthcheck.AccessURLOptions{
+			Client:    client,
+			AccessURL: u,
+		})
+
+		assert.False(t, report.Healthy)
+		assert.False(t, report.Reachable)
+		assert.Equal(t, 0, report.StatusCode)
+		assert.Equal(t, "", report.HealthzResponse)
+		assert.ErrorIs(t, report.Err, expErr)
+	})
+}
+
+type roundTripFunc func(r *http.Request) (*http.Response, error)
+
+func (rt roundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) {
+	return rt(r)
+}
diff --git a/coderd/healthcheck/derp.go b/coderd/healthcheck/derp.go
@@ -30,6 +30,7 @@ type DERPReport struct {
 	Regions map[int]*DERPRegionReport `json:"regions"`
 
 	Netcheck     *netcheck.Report `json:"netcheck"`
+	NetcheckErr  error            `json:"netcheck_err"`
 	NetcheckLogs []string         `json:"netcheck_logs"`
 }
 
@@ -66,32 +67,30 @@ type DERPReportOptions struct {
 	DERPMap *tailcfg.DERPMap
 }
 
-func (r *DERPReport) Run(ctx context.Context, opts *DERPReportOptions) error {
+func (r *DERPReport) Run(ctx context.Context, opts *DERPReportOptions) {
 	r.Healthy = true
 	r.Regions = map[int]*DERPRegionReport{}
 
-	eg, ctx := errgroup.WithContext(ctx)
+	wg := &sync.WaitGroup{}
 
+	wg.Add(len(opts.DERPMap.Regions))
 	for _, region := range opts.DERPMap.Regions {
 		region := region
-		eg.Go(func() error {
+		go func() {
+			defer wg.Done()
 			regionReport := DERPRegionReport{
 				Region: region,
 			}
 
-			err := regionReport.Run(ctx)
-			if err != nil {
-				return xerrors.Errorf("run region report: %w", err)
-			}
+			regionReport.Run(ctx)
 
 			r.mu.Lock()
 			r.Regions[region.RegionID] = &regionReport
 			if !regionReport.Healthy {
 				r.Healthy = false
 			}
 			r.mu.Unlock()
-			return nil
-		})
+		}()
 	}
 
 	ncLogf := func(format string, args ...interface{}) {
@@ -103,44 +102,40 @@ func (r *DERPReport) Run(ctx context.Context, opts *DERPReportOptions) error {
 		PortMapper: portmapper.NewClient(tslogger.WithPrefix(ncLogf, "portmap: "), nil),
 		Logf:       tslogger.WithPrefix(ncLogf, "netcheck: "),
 	}
-	ncReport, err := nc.GetReport(ctx, opts.DERPMap)
-	if err != nil {
-		return xerrors.Errorf("run netcheck: %w", err)
-	}
-	r.Netcheck = ncReport
+	r.Netcheck, r.NetcheckErr = nc.GetReport(ctx, opts.DERPMap)
 
-	return eg.Wait()
+	wg.Wait()
 }
 
-func (r *DERPRegionReport) Run(ctx context.Context) error {
+func (r *DERPRegionReport) Run(ctx context.Context) {
 	r.Healthy = true
 	r.NodeReports = []*DERPNodeReport{}
-	eg, ctx := errgroup.WithContext(ctx)
 
+	wg := &sync.WaitGroup{}
+
+	wg.Add(len(r.Region.Nodes))
 	for _, node := range r.Region.Nodes {
 		node := node
-		eg.Go(func() error {
+		go func() {
+			defer wg.Done()
+
 			nodeReport := DERPNodeReport{
 				Node:    node,
 				Healthy: true,
 			}
 
-			err := nodeReport.Run(ctx)
-			if err != nil {
-				return xerrors.Errorf("run node report: %w", err)
-			}
+			nodeReport.Run(ctx)
 
 			r.mu.Lock()
 			r.NodeReports = append(r.NodeReports, &nodeReport)
 			if !nodeReport.Healthy {
 				r.Healthy = false
 			}
 			r.mu.Unlock()
-			return nil
-		})
+		}()
 	}
 
-	return eg.Wait()
+	wg.Wait()
 }
 
 func (r *DERPNodeReport) derpURL() *url.URL {
@@ -159,7 +154,7 @@ func (r *DERPNodeReport) derpURL() *url.URL {
 	return derpURL
 }
 
-func (r *DERPNodeReport) Run(ctx context.Context) error {
+func (r *DERPNodeReport) Run(ctx context.Context) {
 	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 	defer cancel()
 
@@ -179,7 +174,6 @@ func (r *DERPNodeReport) Run(ctx context.Context) error {
 		r.STUN.Error != nil {
 		r.Healthy = false
 	}
-	return nil
 }
 
 func (r *DERPNodeReport) doExchangeMessage(ctx context.Context) {