feat: Refactor API routes to use UUIDs instead of friendly names (#401)

* Add client for agent

* Cleanup code

* Fix linting error

* Rename routes to be simpler

* Rename workspace history to workspace build

* Refactor HTTP middlewares to use UUIDs

* Cleanup routes

* Compiles!

* Fix files and organizations

* Fix querying

* Fix agent lock

* Cleanup database abstraction

* Add parameters

* Fix linting errors

* Fix log race

* Lock on close wait

* Fix log cleanup

* Fix e2e tests

* Fix upstream version of opencensus-go

* Update coderdtest.go

* Fix coverpkg

* Fix codecov ignore

codersdk/provisionerdaemons.go

@@ -0,0 +1,102 @@
+package codersdk
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+
+	"github.com/hashicorp/yamux"
+	"golang.org/x/xerrors"
+	"nhooyr.io/websocket"
+
+	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/provisionerd/proto"
+	"github.com/coder/coder/provisionersdk"
+)
+
+// ListenProvisionerDaemon returns the gRPC service for a provisioner daemon implementation.
+func (c *Client) ListenProvisionerDaemon(ctx context.Context) (proto.DRPCProvisionerDaemonClient, error) {
+	serverURL, err := c.URL.Parse("/api/v2/provisionerdaemons/me/listen")
+	if err != nil {
+		return nil, xerrors.Errorf("parse url: %w", err)
+	}
+	conn, res, err := websocket.Dial(ctx, serverURL.String(), &websocket.DialOptions{
+		HTTPClient: c.httpClient,
+		// Need to disable compression to avoid a data-race.
+		CompressionMode: websocket.CompressionDisabled,
+	})
+	if err != nil {
+		if res == nil {
+			return nil, err
+		}
+		return nil, readBodyAsError(res)
+	}
+	config := yamux.DefaultConfig()
+	config.LogOutput = io.Discard
+	session, err := yamux.Client(websocket.NetConn(ctx, conn, websocket.MessageBinary), config)
+	if err != nil {
+		return nil, xerrors.Errorf("multiplex client: %w", err)
+	}
+	return proto.NewDRPCProvisionerDaemonClient(provisionersdk.Conn(session)), nil
+}
+
+// provisionerJobLogsBefore provides log output that occurred before a time.
+// This is abstracted from a specific job type to provide consistency between
+// APIs. Logs is the only shared route between jobs.
+func (c *Client) provisionerJobLogsBefore(ctx context.Context, path string, before time.Time) ([]coderd.ProvisionerJobLog, error) {
+	values := url.Values{}
+	if !before.IsZero() {
+		values["before"] = []string{strconv.FormatInt(before.UTC().UnixMilli(), 10)}
+	}
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("%s?%s", path, values.Encode()), nil)
+	if err != nil {
+		return nil, err
+	}
+	if res.StatusCode != http.StatusOK {
+		defer res.Body.Close()
+		return nil, readBodyAsError(res)
+	}
+
+	var logs []coderd.ProvisionerJobLog
+	return logs, json.NewDecoder(res.Body).Decode(&logs)
+}
+
+// provisionerJobLogsAfter streams logs that occurred after a specific time.
+func (c *Client) provisionerJobLogsAfter(ctx context.Context, path string, after time.Time) (<-chan coderd.ProvisionerJobLog, error) {
+	afterQuery := ""
+	if !after.IsZero() {
+		afterQuery = fmt.Sprintf("&after=%d", after.UTC().UnixMilli())
+	}
+	res, err := c.request(ctx, http.MethodGet, fmt.Sprintf("%s?follow%s", path, afterQuery), nil)
+	if err != nil {
+		return nil, err
+	}
+	if res.StatusCode != http.StatusOK {
+		defer res.Body.Close()
+		return nil, readBodyAsError(res)
+	}
+
+	logs := make(chan coderd.ProvisionerJobLog)
+	decoder := json.NewDecoder(res.Body)
+	go func() {
+		defer close(logs)
+		var log coderd.ProvisionerJobLog
+		for {
+			err = decoder.Decode(&log)
+			if err != nil {
+				return
+			}
+			select {
+			case <-ctx.Done():
+				return
+			case logs <- log:
+			}
+		}
+	}()
+	return logs, nil
+}