prepare the transition to #Plan.context

This change helps the transition between `dagger input` and `#Plan.context`.

In summary, the codebase now relies on a *context* for execution with mapping to *IDs*.
In the future, *context* will come from a `#Plan.context`.
In the meantime, a bridge converts `dagger input` to a plan context. This allows both *old* and *new* style configurations to co-exist with the same underlying engine.

- Implement `plancontext`. Context holds the execution context for a plan. Currently this includes the platform, local directories, secrets and services (e.g. unix/npipe).
- Contextual data can be registered at any point. In the future, this will be done by `#Plan.context`
- Migrated the `dagger input` codebase to register inputs in a `plancontext`
- Migrated low-level types/operations to the *Context ID* pattern.
  - `dagger.#Stream` now only includes an `id` (instead of `unix` path)
  - `dagger.#Secret` still includes only an ID, but now it's based off `plancontext`
  - `op.#Local` now only includes an `id` (instead of `path`, `include`, `exclude`.

Signed-off-by: Andrea Luzzardi <aluzzardi@gmail.com>

solver/secretsprovider.go

@@ -2,55 +2,27 @@ package solver
 
 import (
 	"context"
-	"strings"
 
 	"github.com/moby/buildkit/session"
 	"github.com/moby/buildkit/session/secrets"
 	"github.com/moby/buildkit/session/secrets/secretsprovider"
 	"github.com/rs/zerolog/log"
-	"go.dagger.io/dagger/state"
+	"go.dagger.io/dagger/plancontext"
 )
 
-type SecretsStore struct {
-	Secrets session.Attachable
-	store   *inputStore
-}
-
-func (s SecretsStore) GetSecret(ctx context.Context, id string) ([]byte, error) {
-	return s.store.GetSecret(ctx, id)
-}
-
-func NewSecretsStoreProvider(st *state.State) SecretsStore {
-	store := &inputStore{st}
-
-	return SecretsStore{
-		Secrets: secretsprovider.NewSecretProvider(store),
-		store:   store,
-	}
+func NewSecretsStoreProvider(pctx *plancontext.Context) session.Attachable {
+	return secretsprovider.NewSecretProvider(&inputStore{pctx})
 }
 
 type inputStore struct {
-	st *state.State
+	pctx *plancontext.Context
 }
 
 func (s *inputStore) GetSecret(ctx context.Context, id string) ([]byte, error) {
 	lg := log.Ctx(ctx)
 
-	const secretPrefix = "secret="
-
-	if !strings.HasPrefix(id, secretPrefix) {
-		return nil, secrets.ErrNotFound
-	}
-
-	id = strings.TrimPrefix(id, secretPrefix)
-
-	id = strings.Split(id, ";hash=")[0]
-
-	input, ok := s.st.Inputs[id]
-	if !ok {
-		return nil, secrets.ErrNotFound
-	}
-	if input.Secret == nil {
+	secret := s.pctx.Secrets.Get(plancontext.ContextKey(id))
+	if secret == nil {
 		return nil, secrets.ErrNotFound
 	}
 
@@ -59,5 +31,5 @@ func (s *inputStore) GetSecret(ctx context.Context, id string) ([]byte, error) {
 		Str("id", id).
 		Msg("injecting secret")
 
-	return []byte(input.Secret.PlainText()), nil
+	return []byte(secret.PlainText), nil
 }

solver/socketprovider.go

@@ -3,24 +3,20 @@ package solver
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"github.com/moby/buildkit/session"
 	"github.com/moby/buildkit/session/sshforward"
+	"go.dagger.io/dagger/plancontext"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
 )
 
-const (
-	unixPrefix  = "unix="
-	npipePrefix = "npipe="
-)
-
 type SocketProvider struct {
+	pctx *plancontext.Context
 }
 
-func NewDockerSocketProvider() session.Attachable {
-	return &SocketProvider{}
+func NewDockerSocketProvider(pctx *plancontext.Context) session.Attachable {
+	return &SocketProvider{pctx}
 }
 
 func (sp *SocketProvider) Register(server *grpc.Server) {
@@ -28,13 +24,6 @@ func (sp *SocketProvider) Register(server *grpc.Server) {
 }
 
 func (sp *SocketProvider) CheckAgent(ctx context.Context, req *sshforward.CheckAgentRequest) (*sshforward.CheckAgentResponse, error) {
-	id := sshforward.DefaultID
-	if req.ID != "" {
-		id = req.ID
-	}
-	if !strings.HasPrefix(id, unixPrefix) && !strings.HasPrefix(id, npipePrefix) {
-		return &sshforward.CheckAgentResponse{}, fmt.Errorf("invalid socket forward key %s", id)
-	}
 	return &sshforward.CheckAgentResponse{}, nil
 }
 
@@ -47,7 +36,12 @@ func (sp *SocketProvider) ForwardAgent(stream sshforward.SSH_ForwardAgentServer)
 		id = v[0]
 	}
 
-	conn, err := dialStream(id)
+	service := sp.pctx.Services.Get(plancontext.ContextKey(id))
+	if service == nil {
+		return fmt.Errorf("invalid socket id %q", id)
+	}
+
+	conn, err := dialService(service)
 	if err != nil {
 		return fmt.Errorf("failed to connect to %s: %w", id, err)
 	}

solver/socketprovider_unix.go

@@ -4,17 +4,17 @@
 package solver
 
 import (
-	"fmt"
+	"errors"
 	"net"
-	"strings"
 	"time"
+
+	"go.dagger.io/dagger/plancontext"
 )
 
-func dialStream(id string) (net.Conn, error) {
-	if !strings.HasPrefix(id, unixPrefix) {
-		return nil, fmt.Errorf("invalid socket forward key %s", id)
+func dialService(service *plancontext.Service) (net.Conn, error) {
+	if service.Unix == "" {
+		return nil, errors.New("unsupported socket type")
 	}
 
-	id = strings.TrimPrefix(id, unixPrefix)
-	return net.DialTimeout("unix", id, time.Second)
+	return net.DialTimeout("unix", service.Unix, time.Second)
 }

solver/socketprovider_windows.go

@@ -4,20 +4,19 @@
 package solver
 
 import (
-	"fmt"
+	"errors"
 	"net"
-	"strings"
 	"time"
 
 	"github.com/Microsoft/go-winio"
+	"go.dagger.io/dagger/plancontext"
 )
 
-func dialStream(id string) (net.Conn, error) {
-	if !strings.HasPrefix(id, npipePrefix) {
-		return nil, fmt.Errorf("invalid socket forward key %s", id)
+func dialService(service *plancontext.Service) (net.Conn, error) {
+	if service.Npipe == "" {
+		return nil, errors.New("unsupported socket type")
 	}
 
-	id = strings.TrimPrefix(id, npipePrefix)
 	dur := time.Second
-	return winio.DialPipe(id, &dur)
+	return winio.DialPipe(service.Npipe, &dur)
 }

solver/solver.go

@@ -18,6 +18,7 @@ import (
 	"github.com/opencontainers/go-digest"
 	specs "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/rs/zerolog/log"
+	"go.dagger.io/dagger/plancontext"
 )
 
 type Solver struct {
@@ -27,12 +28,12 @@ type Solver struct {
 }
 
 type Opts struct {
-	Control      *bk.Client
-	Gateway      bkgw.Client
-	Events       chan *bk.SolveStatus
-	Auth         *RegistryAuthProvider
-	SecretsStore SecretsStore
-	NoCache      bool
+	Control *bk.Client
+	Gateway bkgw.Client
+	Events  chan *bk.SolveStatus
+	Context *plancontext.Context
+	Auth    *RegistryAuthProvider
+	NoCache bool
 }
 
 func New(opts Opts) Solver {
@@ -194,8 +195,8 @@ func (s Solver) Export(ctx context.Context, st llb.State, img *dockerfile2llb.Im
 		Exports: []bk.ExportEntry{output},
 		Session: []session.Attachable{
 			s.opts.Auth,
-			s.opts.SecretsStore.Secrets,
-			NewDockerSocketProvider(),
+			NewSecretsStoreProvider(s.opts.Context),
+			NewDockerSocketProvider(s.opts.Context),
 		},
 	}