remaster: a reckoning of weird ideas (+ add gRPC runtime service)

Makefile

@@ -14,6 +14,9 @@ pkg/runtimes/bin/exe.%: pkg/runtimes/shim/main.go
 cmd/bass/bass: shims
 	env GOOS=$(GOOS) GOARCH=$(GOARCH) CGO_ENABLED=0 go build -trimpath -ldflags "-X main.version=$(VERSION)" -o ./cmd/bass/bass ./cmd/bass
 
+pkg/proto/%.pb.go: proto/%.proto
+	protoc -I=./proto --go_out=. --go-grpc_out=. proto/$*.proto
+
 nix/vendorSha256.txt: go.mod go.sum
 	./hack/get-nix-vendorsha > $@
 
@@ -26,6 +29,9 @@ install: cmd/bass/bass
 	mkdir -p $(DESTDIR)
 	cp $< $(DESTDIR)
 
+.PHONY: proto
+proto: pkg/proto/bass.pb.go pkg/proto/runtime.pb.go pkg/proto/progress.pb.go pkg/proto/memo.pb.go
+
 .PHONY: clean
 clean:
 	rm -f cmd/bass/bass $(shims)

bass/bass.bass

@@ -4,7 +4,7 @@
 
 ; load dependencies
 (use (.git (linux/alpine/git))
-     (git:github/vito/tabs/ref/main/nix))
+     (git:github/vito/tabs/ref/main/nix.bass))
 
 ; clones the repo and checks out the given sha
 (defn checkout [sha]
@@ -152,7 +152,7 @@
       (undo-wordwrap src (src/notes/ notes)))))
 
 (provide [release]
-  (use (git:github/vito/tabs/ref/main/gh))
+  (use (git:github/vito/tabs/ref/main/gh.bass))
 
   ; returns the github release module
   (defn release [token]

bass/bass.lock

@@ -332,7 +332,7 @@ memos:  {
       }
       output:  {
         string:  {
-          value:  "66938767c1fa545039225b4a06d7edc4a67a46cf"
+          value:  "d2b84a954119fa7506192aa5c0a9be7fa291500a"
         }
       }
     }

bass/checks

@@ -1,8 +1,8 @@
 #!/usr/bin/env bass
 
 (use (.git (linux/alpine/git))
-     (*dir*/bass)
-     (*dir*/github))
+     (*dir*/bass.bass)
+     (*dir*/github.bass))
 
 ; a github client that uses commit statuses for checks
 (defn status-client [repo]

bass/github.bass

@@ -1,7 +1,7 @@
 #!/usr/bin/env bass
 
 (provide [start-status]
-  (def *memos* *dir*/memos.json)
+  (def *memos* *dir*/bass.lock)
 
   ; starts the thunk and reflects its status as a Commit Status
   (defn start-status [thunk name sha repo auth]

bass/shipit

@@ -2,7 +2,7 @@
 
 ; load libraries
 (use (.strings)
-     (*dir*/bass))
+     (*dir*/bass.bass))
 
 ; builds and publishes a GitHub release
 ;

bass/test

@@ -1,12 +1,13 @@
 #!/usr/bin/env bass
 
+(use (*dir*/bass.bass))
+
 ; runs tests against src passed on *stdin*
 ;
 ; Emits code coverage to *stdout*.
 (defn main testflags
   (for [{:src src} *stdin*]
-    (use (src/project))
-    (let [tests (project:tests src ["./..." & testflags])]
+    (let [tests (bass:tests src ["./..." & testflags])]
       (log "running tests")
       (run tests)
       (emit {:coverage tests/cover.html} *stdout*))))

cmd/bass/bump.go

@@ -2,12 +2,12 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"os"
-	"strings"
 
 	"github.com/vito/bass/pkg/bass"
+	"github.com/vito/bass/pkg/proto"
 	"github.com/vito/progrock"
+	"google.golang.org/protobuf/encoding/prototext"
 )
 
 func bump(ctx context.Context) error {
@@ -17,63 +17,59 @@ func bump(ctx context.Context) error {
 			return err
 		}
 
-		var lf bass.LockfileContent
-		err = bass.UnmarshalJSON(lockContent, &lf)
+		content := &proto.Memosphere{}
+		err = prototext.Unmarshal(lockContent, content)
 		if err != nil {
 			return err
 		}
 
-		for thunkFn, pairs := range lf.Data {
-			segs := strings.SplitN(thunkFn, ":", 2)
-			if len(segs) != 2 {
-				return fmt.Errorf("malformed bass.lock key: %q", thunkFn)
-			}
-
-			thunkID := segs[0]
-			fn := bass.Symbol(segs[1])
-			thunk := lf.Thunks[thunkID]
-
-			runtime, err := bass.RuntimeFromContext(ctx, nil)
+		for _, memo := range content.Memos {
+			thunk := bass.Thunk{}
+			err := thunk.UnmarshalProto(memo.Module)
 			if err != nil {
 				return err
 			}
 
-			scope, err := runtime.Load(ctx, thunk)
+			scope, err := bass.Bass.Load(ctx, thunk)
 			if err != nil {
 				return err
 			}
 
-			var comb bass.Combiner
-			err = scope.GetDecode(fn, &comb)
-			if err != nil {
-				return err
-			}
+			for _, call := range memo.Calls {
+				binding := bass.Symbol(call.Binding)
 
-			for i, pair := range pairs {
-				res, err := bass.Trampoline(ctx, comb.Call(ctx, pair.Input.Value, bass.NewEmptyScope(), bass.Identity))
+				var comb bass.Combiner
+				err = scope.GetDecode(binding, &comb)
 				if err != nil {
 					return err
 				}
 
-				// update reference inline
-				pairs[i].Output.Value = res
-			}
-		}
+				for _, res := range call.Results {
+					input, err := bass.FromProto(res.Input)
+					if err != nil {
+						return err
+					}
 
-		lockFile, err := os.Create(bumpLock)
-		if err != nil {
-			return err
-		}
+					out, err := bass.Trampoline(ctx, comb.Call(ctx, input, bass.NewEmptyScope(), bass.Identity))
+					if err != nil {
+						return err
+					}
+
+					output, err := bass.MarshalProto(out)
+					if err != nil {
+						return err
+					}
 
-		defer lockFile.Close()
+					res.Output = output
+				}
+			}
+		}
 
-		enc := bass.NewEncoder(lockFile)
-		enc.SetIndent("", "  ")
-		err = enc.Encode(lf)
+		payload, err := prototext.MarshalOptions{Multiline: true}.Marshal(content)
 		if err != nil {
 			return err
 		}
 
-		return nil
+		return os.WriteFile(bumpLock, payload, 0644)
 	})
 }

cmd/bass/export.go

@@ -3,6 +3,7 @@ package main
 import (
 	"archive/tar"
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"os"
@@ -17,20 +18,25 @@ import (
 
 func export(ctx context.Context) error {
 	return withProgress(ctx, "export", func(ctx context.Context, vertex *progrock.VertexRecorder) error {
-		dec := bass.NewDecoder(os.Stdin)
+		dec := bass.NewRawDecoder(os.Stdin)
 
-		var val bass.Value
-		err := dec.Decode(&val)
+		var msg json.RawMessage
+		err := dec.Decode(&msg)
 		if err != nil {
 			return err
 		}
 
 		var errs error
 
 		var path bass.ThunkPath
-		err = val.Decode(&path)
+		err = json.Unmarshal([]byte(msg), &path)
 		if err == nil {
-			runtime, err := bass.RuntimeFromContext(ctx, path.Thunk.Platform())
+			platform := path.Thunk.Platform()
+			if platform == nil {
+				return fmt.Errorf("cannot export bass thunk path: %s", path)
+			}
+
+			runtime, err := bass.RuntimeFromContext(ctx, *platform)
 			if err != nil {
 				return err
 			}
@@ -43,9 +49,14 @@ func export(ctx context.Context) error {
 		}
 
 		var thunk bass.Thunk
-		err = val.Decode(&thunk)
+		err = json.Unmarshal([]byte(msg), &path)
 		if err == nil {
-			runtime, err := bass.RuntimeFromContext(ctx, thunk.Platform())
+			platform := path.Thunk.Platform()
+			if platform == nil {
+				return fmt.Errorf("cannot export bass thunk: %s", thunk)
+			}
+
+			runtime, err := bass.RuntimeFromContext(ctx, *platform)
 			if err != nil {
 				return err
 			}

cmd/bass/main.go

@@ -140,7 +140,7 @@ func root(ctx context.Context) error {
 	ctx = bass.WithRuntimePool(ctx, pool)
 
 	if runnerAddr != "" {
-		return runnerLoop(ctx, runnerAddr, config.Runtimes)
+		return runnerLoop(ctx, runnerAddr, pool.Runtimes)
 	}
 
 	if runExport {

cmd/bass/run.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"context"
-	"fmt"
 	"os"
 	"path/filepath"
 
@@ -51,11 +50,7 @@ func run(ctx context.Context, filePath string, argv ...string) error {
 
 		stdin := bass.Stdin
 		if len(inputs) > 0 {
-			stdin, err = cli.InputsSource(inputs)
-			if err != nil {
-				err = fmt.Errorf("inputs: %w", err)
-				return
-			}
+			stdin = cli.InputsSource(inputs)
 		}
 
 		scope := bass.NewRunScope(bass.Ground, bass.RunState{

cmd/bass/forward.go → cmd/bass/runner.go

@@ -11,7 +11,6 @@ import (
 	"strings"
 
 	"github.com/cenkalti/backoff/v4"
-	"github.com/vito/bass/pkg/bass"
 	"github.com/vito/bass/pkg/runtimes"
 	"github.com/vito/bass/pkg/zapctx"
 	"github.com/vito/progrock"
@@ -31,20 +30,20 @@ var defaultKeys = []string{
 	"id_rsa",
 }
 
-func runnerLoop(ctx context.Context, sshAddr string, configs []bass.RuntimeConfig) error {
+func runnerLoop(ctx context.Context, sshAddr string, assoc []runtimes.Assoc) error {
 	ctx, stop := signal.NotifyContext(ctx, os.Interrupt)
 	defer stop()
 
 	return withProgress(ctx, "runner", func(ctx context.Context, bassVertex *progrock.VertexRecorder) (err error) {
 		exp := backoff.NewExponentialBackOff()
 		exp.MaxElapsedTime = 0 // https://www.youtube.com/watch?v=6BtuqUX934U
 		return backoff.Retry(func() error {
-			return runner(ctx, sshAddr, configs)
+			return runner(ctx, sshAddr, assoc)
 		}, exp)
 	})
 }
 
-func runner(ctx context.Context, sshAddr string, configs []bass.RuntimeConfig) error {
+func runner(ctx context.Context, sshAddr string, assoc []runtimes.Assoc) error {
 	ctx, stop := signal.NotifyContext(ctx, os.Interrupt)
 	defer stop()
 
@@ -137,7 +136,7 @@ func runner(ctx context.Context, sshAddr string, configs []bass.RuntimeConfig) e
 	}
 
 	forwards := new(errgroup.Group)
-	for _, runtime := range configs {
+	for _, runtime := range assoc {
 		runtime := runtime
 		forwards.Go(func() error {
 			return client.Forward(ctx, runtime)