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>

plancontext/context.go

@@ -0,0 +1,48 @@
+package plancontext
+
+import (
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+)
+
+type ContextKey string
+
+// Context holds the execution context for a plan.
+//
+// Usage:
+// ctx := plancontext.New()
+// id := ctx.Secrets.Register("mysecret")
+// secret := ctx.Secrets.Get(id)
+type Context struct {
+	Platform    *platformContext
+	Directories *directoryContext
+	Secrets     *secretContext
+	Services    *serviceContext
+}
+
+func New() *Context {
+	return &Context{
+		Platform: &platformContext{
+			platform: defaultPlatform,
+		},
+		Directories: &directoryContext{
+			store: make(map[ContextKey]*Directory),
+		},
+		Secrets: &secretContext{
+			store: make(map[ContextKey]*Secret),
+		},
+		Services: &serviceContext{
+			store: make(map[ContextKey]*Service),
+		},
+	}
+}
+
+func hashID(v interface{}) ContextKey {
+	data, err := json.Marshal(v)
+	if err != nil {
+		panic(err)
+	}
+	hash := sha256.Sum256(data)
+	return ContextKey(fmt.Sprintf("%x", hash))
+}

plancontext/directory.go

@@ -0,0 +1,42 @@
+package plancontext
+
+import "sync"
+
+type Directory struct {
+	Path    string
+	Include []string
+	Exclude []string
+}
+
+type directoryContext struct {
+	l     sync.RWMutex
+	store map[ContextKey]*Directory
+}
+
+func (c *directoryContext) Register(directory *Directory) ContextKey {
+	c.l.Lock()
+	defer c.l.Unlock()
+
+	id := hashID(directory)
+	c.store[id] = directory
+	return id
+}
+
+func (c *directoryContext) Get(id ContextKey) *Directory {
+	c.l.RLock()
+	defer c.l.RUnlock()
+
+	return c.store[id]
+}
+
+func (c *directoryContext) List() []*Directory {
+	c.l.RLock()
+	defer c.l.RUnlock()
+
+	directories := make([]*Directory, 0, len(c.store))
+	for _, d := range c.store {
+		directories = append(directories, d)
+	}
+
+	return directories
+}

plancontext/platform.go

@@ -0,0 +1,32 @@
+package plancontext
+
+import (
+	"github.com/containerd/containerd/platforms"
+	specs "github.com/opencontainers/image-spec/specs-go/v1"
+)
+
+var (
+	// Default platform.
+	// FIXME: This should be auto detected using buildkit
+	defaultPlatform = specs.Platform{
+		OS:           "linux",
+		Architecture: "amd64",
+	}
+)
+
+type platformContext struct {
+	platform specs.Platform
+}
+
+func (c *platformContext) Get() specs.Platform {
+	return c.platform
+}
+
+func (c *platformContext) Set(platform string) error {
+	p, err := platforms.Parse(platform)
+	if err != nil {
+		return err
+	}
+	c.platform = p
+	return nil
+}

plancontext/secret.go

@@ -0,0 +1,40 @@
+package plancontext
+
+import "sync"
+
+type secretContext struct {
+	l     sync.RWMutex
+	store map[ContextKey]*Secret
+}
+
+type Secret struct {
+	PlainText string
+}
+
+func (c *secretContext) Register(secret *Secret) ContextKey {
+	c.l.Lock()
+	defer c.l.Unlock()
+
+	id := hashID(secret.PlainText)
+	c.store[id] = secret
+	return id
+}
+
+func (c *secretContext) Get(id ContextKey) *Secret {
+	c.l.RLock()
+	defer c.l.RUnlock()
+
+	return c.store[id]
+}
+
+func (c *secretContext) List() []*Secret {
+	c.l.RLock()
+	defer c.l.RUnlock()
+
+	secrets := make([]*Secret, 0, len(c.store))
+	for _, s := range c.store {
+		secrets = append(secrets, s)
+	}
+
+	return secrets
+}

plancontext/service.go

@@ -0,0 +1,29 @@
+package plancontext
+
+import "sync"
+
+type serviceContext struct {
+	l     sync.RWMutex
+	store map[ContextKey]*Service
+}
+
+type Service struct {
+	Unix  string
+	Npipe string
+}
+
+func (c *serviceContext) Register(service *Service) ContextKey {
+	c.l.Lock()
+	defer c.l.Unlock()
+
+	id := hashID(service)
+	c.store[id] = service
+	return id
+}
+
+func (c *serviceContext) Get(id ContextKey) *Service {
+	c.l.RLock()
+	defer c.l.RUnlock()
+
+	return c.store[id]
+}