Refactor provisionerd tests to disconnect from coderd

coder · kylecarbs · Jan 29, 2022 · Jan 29, 2022 · Jan 29, 2022 · Jan 29, 2022
commit b495991e0941c14a82ea9878961f0fb1e915976c
diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -25,7 +25,7 @@ func New(options *Options) http.Handler {
 		Database: options.Database,
 		Pubsub:   options.Pubsub,
 	}
-	provisionerd := &provisionerd{
+	provisioners := &provisioners{
 		Database: options.Database,
 		Pubsub:   options.Pubsub,
 	}
@@ -46,7 +46,8 @@ func New(options *Options) http.Handler {
 		})
 		r.Post("/login", users.loginWithPassword)
 		r.Post("/logout", users.logout)
-		r.Get("/provisionerd", provisionerd.listen)
+		r.Get("/provisionerd", provisioners.listen)
+
 		// Used for setup.
 		r.Post("/user", users.createInitialUser)
 		r.Route("/users", func(r chi.Router) {
@@ -109,6 +110,10 @@ func New(options *Options) http.Handler {
 				})
 			})
 		})
+
+		r.Route("/provisioners", func(r chi.Router) {
+			r.Get("/daemons", provisioners.listDaemons)
+		})
 	})
 	r.NotFound(site.Handler().ServeHTTP)
 	return r

diff --git a/coderd/coderdtest/coderdtest.go b/coderd/coderdtest/coderdtest.go
@@ -3,20 +3,27 @@ package coderdtest
 import (
 	"context"
 	"database/sql"
+	"io"
 	"net/http/httptest"
 	"net/url"
 	"os"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 
+	"cdr.dev/slog"
 	"cdr.dev/slog/sloggers/slogtest"
 	"github.com/coder/coder/coderd"
 	"github.com/coder/coder/codersdk"
 	"github.com/coder/coder/cryptorand"
 	"github.com/coder/coder/database"
 	"github.com/coder/coder/database/databasefake"
 	"github.com/coder/coder/database/postgres"
+	"github.com/coder/coder/provisioner/terraform"
+	"github.com/coder/coder/provisionerd"
+	"github.com/coder/coder/provisionersdk"
+	"github.com/coder/coder/provisionersdk/proto"
 )
 
 // Server represents a test instance of coderd.
@@ -57,6 +64,37 @@ func (s *Server) RandomInitialUser(t *testing.T) coderd.CreateInitialUserRequest
 	return req
 }
 
+func (s *Server) AddProvisionerd(t *testing.T) io.Closer {
+	tfClient, tfServer := provisionersdk.TransportPipe()
+	ctx, cancelFunc := context.WithCancel(context.Background())
+	t.Cleanup(func() {
+		_ = tfClient.Close()
+		_ = tfServer.Close()
+		cancelFunc()
+	})
+	go func() {
+		err := terraform.Serve(ctx, &terraform.ServeOptions{
+			ServeOptions: &provisionersdk.ServeOptions{
+				Listener: tfServer,
+			},
+		})
+		require.NoError(t, err)
+	}()
+
+	closer := provisionerd.New(s.Client.ProvisionerDaemonClient, &provisionerd.Options{
+		Logger:       slogtest.Make(t, nil).Named("provisionerd").Leveled(slog.LevelInfo),
+		PollInterval: 50 * time.Millisecond,
+		Provisioners: provisionerd.Provisioners{
+			string(database.ProvisionerTypeTerraform): proto.NewDRPCProvisionerClient(provisionersdk.Conn(tfClient)),
+		},
+		WorkDirectory: t.TempDir(),
+	})
+	t.Cleanup(func() {
+		_ = closer.Close()
+	})
+	return closer
+}
+
 // New constructs a new coderd test instance. This returned Server
 // should contain no side-effects.
 func New(t *testing.T) Server {

diff --git a/coderd/coderdtest/coderdtest_test.go b/coderd/coderdtest/coderdtest_test.go
@@ -16,4 +16,5 @@ func TestNew(t *testing.T) {
 	t.Parallel()
 	server := coderdtest.New(t)
 	_ = server.RandomInitialUser(t)
+	_ = server.AddProvisionerd(t)
 }
diff --git a/coderd/provisionerd_test.go b/coderd/provisionerd_test.go
diff --git a/coderd/provisionerd.go → coderd/provisioners.go b/coderd/provisionerd.go → coderd/provisioners.go
@@ -14,6 +14,7 @@ import (
 	"storj.io/drpc/drpcmux"
 	"storj.io/drpc/drpcserver"
 
+	"github.com/go-chi/render"
 	"github.com/google/uuid"
 	"github.com/hashicorp/yamux"
 	"github.com/moby/moby/pkg/namesgenerator"
@@ -27,12 +28,30 @@ import (
 	"nhooyr.io/websocket"
 )
 
-type provisionerd struct {
+type ProvisionerDaemon database.ProvisionerDaemon
+
+type provisioners struct {
 	Database database.Store
 	Pubsub   database.Pubsub
 }
 
-func (p *provisionerd) listen(rw http.ResponseWriter, r *http.Request) {
+func (p *provisioners) listDaemons(rw http.ResponseWriter, r *http.Request) {
+	daemons, err := p.Database.GetProvisionerDaemons(r.Context())
+	if errors.Is(err, sql.ErrNoRows) {
+		err = nil
+	}
+	if err != nil {
+		httpapi.Write(rw, http.StatusInternalServerError, httpapi.Response{
+			Message: fmt.Sprintf("get provisioner daemons: %s", err),
+		})
+		return
+	}
+
+	render.Status(r, http.StatusOK)
+	render.JSON(rw, r, daemons)
+}
+
+func (p *provisioners) listen(rw http.ResponseWriter, r *http.Request) {
 	conn, err := websocket.Accept(rw, r, nil)
 	if err != nil {
 		httpapi.Write(rw, http.StatusBadRequest, httpapi.Response{

diff --git a/coderd/provisioners_test.go b/coderd/provisioners_test.go
@@ -0,0 +1,81 @@
+package coderd_test
+
+import (
+	"archive/tar"
+	"bytes"
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/database"
+)
+
+func TestProvisionerd(t *testing.T) {
+	t.Parallel()
+	t.Run("ListDaemons", func(t *testing.T) {
+		t.Parallel()
+		server := coderdtest.New(t)
+		_ = server.AddProvisionerd(t)
+		require.Eventually(t, func() bool {
+			daemons, err := server.Client.ProvisionerDaemons(context.Background())
+			require.NoError(t, err)
+			return len(daemons) > 0
+		}, time.Second, 10*time.Millisecond)
+	})
+
+	t.Run("RunJob", func(t *testing.T) {
+		t.Parallel()
+		server := coderdtest.New(t)
+		user := server.RandomInitialUser(t)
+		_ = server.AddProvisionerd(t)
+
+		project, err := server.Client.CreateProject(context.Background(), user.Organization, coderd.CreateProjectRequest{
+			Name:        "my-project",
+			Provisioner: database.ProvisionerTypeTerraform,
+		})
+		require.NoError(t, err)
+
+		var buffer bytes.Buffer
+		writer := tar.NewWriter(&buffer)
+		content := `variable "frog" {}
+	resource "null_resource" "dev" {}`
+		err = writer.WriteHeader(&tar.Header{
+			Name: "main.tf",
+			Size: int64(len(content)),
+		})
+		require.NoError(t, err)
+		_, err = writer.Write([]byte(content))
+		require.NoError(t, err)
+
+		projectHistory, err := server.Client.CreateProjectHistory(context.Background(), user.Organization, project.Name, coderd.CreateProjectVersionRequest{
+			StorageMethod: database.ProjectStorageMethodInlineArchive,
+			StorageSource: buffer.Bytes(),
+		})
+		require.NoError(t, err)
+
+		workspace, err := server.Client.CreateWorkspace(context.Background(), "", coderd.CreateWorkspaceRequest{
+			ProjectID: project.ID,
+			Name:      "wowie",
+		})
+		require.NoError(t, err)
+
+		workspaceHistory, err := server.Client.CreateWorkspaceHistory(context.Background(), "", workspace.Name, coderd.CreateWorkspaceHistoryRequest{
+			ProjectHistoryID: projectHistory.ID,
+			Transition:       database.WorkspaceTransitionCreate,
+		})
+		require.NoError(t, err)
+
+		logs, err := server.Client.FollowWorkspaceHistoryLogs(context.Background(), "me", workspace.Name, workspaceHistory.Name)
+		require.NoError(t, err)
+
+		for {
+			log := <-logs
+			fmt.Printf("Got %s %s\n", log.CreatedAt, log.Output)
+		}
+	})
+}
diff --git a/codersdk/provisionerd.go b/codersdk/provisionerd.go
diff --git a/codersdk/provisioners.go b/codersdk/provisioners.go
@@ -0,0 +1,51 @@
+package codersdk
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+
+	"golang.org/x/xerrors"
+	"nhooyr.io/websocket"
+
+	"github.com/hashicorp/yamux"
+
+	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/provisionerd/proto"
+	"github.com/coder/coder/provisionersdk"
+)
+
+func (c *Client) ProvisionerDaemons(ctx context.Context) ([]coderd.ProvisionerDaemon, error) {
+	res, err := c.request(ctx, http.MethodGet, "/api/v2/provisioners/daemons", nil)
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+	if res.StatusCode != http.StatusOK {
+		return nil, readBodyAsError(res)
+	}
+	var daemons []coderd.ProvisionerDaemon
+	return daemons, json.NewDecoder(res.Body).Decode(&daemons)
+}
+
+// ProvisionerDaemonClient returns the gRPC service for a provisioner daemon implementation.
+func (c *Client) ProvisionerDaemonClient(ctx context.Context) (proto.DRPCProvisionerDaemonClient, error) {
+	serverURL, err := c.url.Parse("/api/v2/provisionerd")
+	if err != nil {
+		return nil, xerrors.Errorf("parse url: %w", err)
+	}
+	conn, res, err := websocket.Dial(ctx, serverURL.String(), &websocket.DialOptions{
+		HTTPClient: c.httpClient,
+	})
+	if err != nil {
+		if res == nil {
+			return nil, err
+		}
+		return nil, readBodyAsError(res)
+	}
+	session, err := yamux.Client(websocket.NetConn(context.Background(), conn, websocket.MessageBinary), nil)
+	if err != nil {
+		return nil, xerrors.Errorf("multiplex client: %w", err)
+	}
+	return proto.NewDRPCProvisionerDaemonClient(provisionersdk.Conn(session)), nil
+}
diff --git a/codersdk/provisioners_test.go b/codersdk/provisioners_test.go
@@ -0,0 +1,20 @@
+package codersdk_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/coder/coder/coderd/coderdtest"
+)
+
+func TestProvisioners(t *testing.T) {
+	t.Parallel()
+	t.Run("ListDaemons", func(t *testing.T) {
+		t.Parallel()
+		server := coderdtest.New(t)
+		_, err := server.Client.ProvisionerDaemons(context.Background())
+		require.NoError(t, err)
+	})
+}