Merge pull request #220 from AkihiroSuda/split-solver-1

solver: split llbop pkg

cmd/buildd/main.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/containerd/containerd/sys"
 	"github.com/docker/go-connections/sockets"
+	"github.com/moby/buildkit/cache/cacheimport"
 	"github.com/moby/buildkit/control"
 	"github.com/moby/buildkit/frontend"
 	"github.com/moby/buildkit/frontend/dockerfile"
@@ -19,6 +20,7 @@ import (
 	"github.com/moby/buildkit/util/appdefaults"
 	"github.com/moby/buildkit/util/profiler"
 	"github.com/moby/buildkit/worker"
+	"github.com/moby/buildkit/worker/base"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
@@ -33,7 +35,7 @@ type workerInitializerOpt struct {
 }
 
 type workerInitializer struct {
-	fn func(c *cli.Context, common workerInitializerOpt) ([]*worker.Worker, error)
+	fn func(c *cli.Context, common workerInitializerOpt) ([]worker.Worker, error)
 	// less priority number, more preferred
 	priority int
 }
@@ -227,10 +229,28 @@ func newController(c *cli.Context, root string) (*control.Controller, error) {
 	frontends := map[string]frontend.Frontend{}
 	frontends["dockerfile.v0"] = dockerfile.NewDockerfileFrontend()
 	frontends["gateway.v0"] = gateway.NewGatewayFrontend()
+
+	// cache exporter and importer are manager concepts but as there is no
+	// way to pull data into specific worker yet we currently set them up
+	// as part of default worker
+	var ce *cacheimport.CacheExporter
+	var ci *cacheimport.CacheImporter
+
+	w, err := wc.GetDefault()
+	if err != nil {
+		return nil, err
+	}
+
+	wt := w.(*base.Worker)
+	ce = wt.CacheExporter
+	ci = wt.CacheImporter
+
 	return control.NewController(control.Opt{
 		SessionManager:   sessionManager,
 		WorkerController: wc,
 		Frontends:        frontends,
+		CacheExporter:    ce,
+		CacheImporter:    ci,
 	})
 }
 
@@ -242,7 +262,7 @@ func newWorkerController(c *cli.Context, wiOpt workerInitializerOpt) (*worker.Co
 			return nil, err
 		}
 		for _, w := range ws {
-			logrus.Infof("Found worker %q", w.Name)
+			logrus.Infof("found worker %q", w.Name())
 			if err = wc.Add(w); err != nil {
 				return nil, err
 			}
@@ -256,7 +276,7 @@ func newWorkerController(c *cli.Context, wiOpt workerInitializerOpt) (*worker.Co
 	if err != nil {
 		return nil, err
 	}
-	logrus.Infof("Found %d workers, default=%q", nWorkers, defaultWorker.Name)
-	logrus.Warn("Currently, only the default worker can be used.")
+	logrus.Infof("found %d workers, default=%q", nWorkers, defaultWorker.Name)
+	logrus.Warn("currently, only the default worker can be used.")
 	return wc, nil
 }

cmd/buildd/main_containerd_worker.go

@@ -8,6 +8,7 @@ import (
 
 	ctd "github.com/containerd/containerd"
 	"github.com/moby/buildkit/worker"
+	"github.com/moby/buildkit/worker/base"
 	"github.com/moby/buildkit/worker/containerd"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
@@ -33,7 +34,7 @@ func init() {
 	// TODO(AkihiroSuda): allow using multiple snapshotters. should be useful for some applications that does not work with the default overlay snapshotter. e.g. mysql (docker/for-linux#72)",
 }
 
-func containerdWorkerInitializer(c *cli.Context, common workerInitializerOpt) ([]*worker.Worker, error) {
+func containerdWorkerInitializer(c *cli.Context, common workerInitializerOpt) ([]worker.Worker, error) {
 	socket := c.GlobalString("containerd-worker-addr")
 	boolOrAuto, err := parseBoolOrAuto(c.GlobalString("containerd-worker"))
 	if err != nil {
@@ -47,11 +48,11 @@ func containerdWorkerInitializer(c *cli.Context, common workerInitializerOpt) ([
 		return nil, err
 	}
 	opt.SessionManager = common.sessionManager
-	w, err := worker.NewWorker(opt)
+	w, err := base.NewWorker(opt)
 	if err != nil {
 		return nil, err
 	}
-	return []*worker.Worker{w}, nil
+	return []worker.Worker{w}, nil
 }
 
 func validContainerdSocket(socket string) bool {

cmd/buildd/main_oci_worker.go

@@ -6,6 +6,7 @@ import (
 	"os/exec"
 
 	"github.com/moby/buildkit/worker"
+	"github.com/moby/buildkit/worker/base"
 	"github.com/moby/buildkit/worker/runc"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli"
@@ -25,7 +26,7 @@ func init() {
 	// TODO: allow multiple oci runtimes and snapshotters
 }
 
-func ociWorkerInitializer(c *cli.Context, common workerInitializerOpt) ([]*worker.Worker, error) {
+func ociWorkerInitializer(c *cli.Context, common workerInitializerOpt) ([]worker.Worker, error) {
 	boolOrAuto, err := parseBoolOrAuto(c.GlobalString("oci-worker"))
 	if err != nil {
 		return nil, err
@@ -38,11 +39,11 @@ func ociWorkerInitializer(c *cli.Context, common workerInitializerOpt) ([]*worke
 		return nil, err
 	}
 	opt.SessionManager = common.sessionManager
-	w, err := worker.NewWorker(opt)
+	w, err := base.NewWorker(opt)
 	if err != nil {
 		return nil, err
 	}
-	return []*worker.Worker{w}, nil
+	return []worker.Worker{w}, nil
 }
 
 func validOCIBinary() bool {

control/control.go

@@ -3,6 +3,7 @@ package control
 import (
 	"github.com/docker/distribution/reference"
 	controlapi "github.com/moby/buildkit/api/services/control"
+	"github.com/moby/buildkit/cache/cacheimport"
 	"github.com/moby/buildkit/client"
 	"github.com/moby/buildkit/exporter"
 	"github.com/moby/buildkit/frontend"
@@ -21,6 +22,8 @@ type Opt struct {
 	SessionManager   *session.Manager
 	WorkerController *worker.Controller
 	Frontends        map[string]frontend.Frontend
+	CacheExporter    *cacheimport.CacheExporter
+	CacheImporter    *cacheimport.CacheImporter
 }
 
 type Controller struct { // TODO: ControlService
@@ -30,8 +33,13 @@ type Controller struct { // TODO: ControlService
 
 func NewController(opt Opt) (*Controller, error) {
 	c := &Controller{
-		opt:    opt,
-		solver: solver.NewLLBSolver(opt.WorkerController, opt.Frontends),
+		opt: opt,
+		solver: solver.NewLLBOpSolver(solver.LLBOpt{
+			WorkerController: opt.WorkerController,
+			Frontends:        opt.Frontends,
+			CacheExporter:    opt.CacheExporter,
+			CacheImporter:    opt.CacheImporter,
+		}),
 	}
 	return c, nil
 }
@@ -44,7 +52,7 @@ func (c *Controller) Register(server *grpc.Server) error {
 func (c *Controller) DiskUsage(ctx context.Context, r *controlapi.DiskUsageRequest) (*controlapi.DiskUsageResponse, error) {
 	resp := &controlapi.DiskUsageResponse{}
 	for _, w := range c.opt.WorkerController.GetAll() {
-		du, err := w.CacheManager.DiskUsage(ctx, client.DiskUsageInfo{
+		du, err := w.DiskUsage(ctx, client.DiskUsageInfo{
 			Filter: r.Filter,
 		})
 		if err != nil {
@@ -89,9 +97,9 @@ func (c *Controller) Solve(ctx context.Context, req *controlapi.SolveRequest) (*
 		return nil, err
 	}
 	if req.Exporter != "" {
-		exp, ok := w.Exporters[req.Exporter]
-		if !ok {
-			return nil, errors.Errorf("exporter %q could not be found", req.Exporter)
+		exp, err := w.Exporter(req.Exporter)
+		if err != nil {
+			return nil, err
 		}
 		expi, err = exp.Resolve(ctx, req.ExporterAttrs)
 		if err != nil {

solver/jobs.go

@@ -162,7 +162,7 @@ type job struct {
 type cacheRecord struct {
 	VertexSolver
 	index Index
-	ref   Reference
+	ref   Ref
 }
 
 func (j *job) load(def *pb.Definition, resolveOp ResolveOpFunc) (*Input, error) {
@@ -225,7 +225,7 @@ func (j *job) loadInternal(def *pb.Definition, resolveOp ResolveOpFunc) (*Input,
 	if err != nil {
 		return nil, err
 	}
-	return &Input{Vertex: vtx.(*vertex), Index: idx}, nil
+	return &Input{Vertex: vtx.(*vertex), Index: Index(idx)}, nil
 }
 
 func (j *job) discard() {
@@ -253,28 +253,28 @@ func (j *job) getSolver(dgst digest.Digest) (VertexSolver, error) {
 	return st.solver, nil
 }
 
-func (j *job) getRef(ctx context.Context, v *vertex, index Index) (Reference, error) {
-	s, err := j.getSolver(v.Digest())
+func (j *job) getRef(ctx context.Context, cv client.Vertex, index Index) (Ref, error) {
+	s, err := j.getSolver(cv.Digest)
 	if err != nil {
 		return nil, err
 	}
-	ref, err := getRef(ctx, s, v, index, j.cache)
+	ref, err := getRef(ctx, s, cv, index, j.cache)
 	if err != nil {
 		return nil, err
 	}
 	j.keepCacheRef(s, index, ref)
 	return ref, nil
 }
 
-func (j *job) keepCacheRef(s VertexSolver, index Index, ref Reference) {
-	immutable, ok := toImmutableRef(ref)
+func (j *job) keepCacheRef(s VertexSolver, index Index, ref Ref) {
+	immutable, ok := ToImmutableRef(ref)
 	if ok {
 		j.cached[immutable.ID()] = &cacheRecord{s, index, ref}
 	}
 }
 
-func (j *job) cacheExporter(ref Reference) (CacheExporter, error) {
-	immutable, ok := toImmutableRef(ref)
+func (j *job) cacheExporter(ref Ref) (CacheExporter, error) {
+	immutable, ok := ToImmutableRef(ref)
 	if !ok {
 		return nil, errors.Errorf("invalid reference")
 	}
@@ -285,7 +285,7 @@ func (j *job) cacheExporter(ref Reference) (CacheExporter, error) {
 	return cr.Cache(cr.index, cr.ref), nil
 }
 
-func getRef(ctx context.Context, s VertexSolver, v *vertex, index Index, cache instructioncache.InstructionCache) (Reference, error) {
+func getRef(ctx context.Context, s VertexSolver, cv client.Vertex, index Index, cache instructioncache.InstructionCache) (Ref, error) {
 	k, err := s.CacheKey(ctx, index)
 	if err != nil {
 		return nil, err
@@ -295,8 +295,8 @@ func getRef(ctx context.Context, s VertexSolver, v *vertex, index Index, cache i
 		return nil, err
 	}
 	if ref != nil {
-		markCached(ctx, v.clientVertex)
-		return ref.(Reference), nil
+		markCached(ctx, cv)
+		return ref.(Ref), nil
 	}
 
 	ev, err := s.OutputEvaluator(index)
@@ -316,8 +316,8 @@ func getRef(ctx context.Context, s VertexSolver, v *vertex, index Index, cache i
 				return nil, err
 			}
 			if ref != nil {
-				markCached(ctx, v.clientVertex)
-				return ref.(Reference), nil
+				markCached(ctx, cv)
+				return ref.(Ref), nil
 			}
 			continue
 		}

solver/llbbridge.go

@@ -1,10 +1,7 @@
 package solver
 
 import (
-	"io"
-
 	"github.com/moby/buildkit/cache"
-	"github.com/moby/buildkit/executor"
 	"github.com/moby/buildkit/frontend"
 	"github.com/moby/buildkit/worker"
 	digest "github.com/opencontainers/go-digest"
@@ -17,7 +14,7 @@ type llbBridge struct {
 	*Solver
 	job *job
 	// this worker is used for running containerized frontend, not vertices
-	worker *worker.Worker
+	worker.Worker
 }
 
 type resolveImageConfig interface {
@@ -45,27 +42,9 @@ func (s *llbBridge) Solve(ctx context.Context, req frontend.SolveRequest) (cache
 	if err != nil {
 		return nil, nil, err
 	}
-	immutable, ok := toImmutableRef(ref)
+	immutable, ok := ToImmutableRef(ref)
 	if !ok {
 		return nil, nil, errors.Errorf("invalid reference for exporting: %T", ref)
 	}
 	return immutable, exp, nil
 }
-
-func (s *llbBridge) ResolveImageConfig(ctx context.Context, ref string) (digest.Digest, []byte, error) {
-	// ImageSource is typically source/containerimage
-	resolveImageConfig, ok := s.worker.ImageSource.(resolveImageConfig)
-	if !ok {
-		return "", nil, errors.Errorf("worker %q does not implement ResolveImageConfig", s.worker.Name)
-	}
-	return resolveImageConfig.ResolveImageConfig(ctx, ref)
-}
-
-func (s *llbBridge) Exec(ctx context.Context, meta executor.Meta, rootFS cache.ImmutableRef, stdin io.ReadCloser, stdout, stderr io.WriteCloser) error {
-	active, err := s.worker.CacheManager.New(ctx, rootFS)
-	if err != nil {
-		return err
-	}
-	defer active.Release(context.TODO())
-	return s.worker.Executor.Exec(ctx, meta, active, nil, stdin, stdout, stderr)
-}

solver/build.go → solver/llbop/build.go

@@ -1,4 +1,4 @@
-package solver
+package llbop
 
 import (
 	"encoding/json"
@@ -7,7 +7,9 @@ import (
 	"github.com/containerd/containerd/fs"
 	"github.com/moby/buildkit/client/llb"
 	"github.com/moby/buildkit/snapshot"
+	"github.com/moby/buildkit/solver"
 	"github.com/moby/buildkit/solver/pb"
+	"github.com/moby/buildkit/worker"
 	digest "github.com/opencontainers/go-digest"
 	"github.com/pkg/errors"
 	"golang.org/x/net/context"
@@ -17,11 +19,11 @@ const buildCacheType = "buildkit.build.v0"
 
 type buildOp struct {
 	op *pb.BuildOp
-	s  *Solver
-	v  Vertex
+	s  worker.SubBuilder
+	v  solver.Vertex
 }
 
-func newBuildOp(v Vertex, op *pb.Op_Build, s *Solver) (Op, error) {
+func NewBuildOp(v solver.Vertex, op *pb.Op_Build, s worker.SubBuilder) (solver.Op, error) {
 	return &buildOp{
 		op: op.Build,
 		s:  s,
@@ -43,7 +45,7 @@ func (b *buildOp) CacheKey(ctx context.Context) (digest.Digest, error) {
 	return digest.FromBytes(dt), nil
 }
 
-func (b *buildOp) Run(ctx context.Context, inputs []Reference) (outputs []Reference, retErr error) {
+func (b *buildOp) Run(ctx context.Context, inputs []solver.Ref) (outputs []solver.Ref, retErr error) {
 	if b.op.Builder != pb.LLBBuilder {
 		return nil, errors.Errorf("only llb builder is currently allowed")
 	}
@@ -60,7 +62,7 @@ func (b *buildOp) Run(ctx context.Context, inputs []Reference) (outputs []Refere
 	}
 	inp := inputs[i]
 
-	ref, ok := toImmutableRef(inp)
+	ref, ok := solver.ToImmutableRef(inp)
 	if !ok {
 		return nil, errors.Errorf("invalid reference for build %T", inp)
 	}
@@ -107,14 +109,14 @@ func (b *buildOp) Run(ctx context.Context, inputs []Reference) (outputs []Refere
 	lm.Unmount()
 	lm = nil
 
-	newref, err := b.s.subBuild(ctx, b.v.Digest(), SolveRequest{
+	newref, err := b.s.SubBuild(ctx, b.v.Digest(), solver.SolveRequest{
 		Definition: def.ToPB(),
 	})
 	if err != nil {
 		return nil, err
 	}
 
-	return []Reference{newref}, err
+	return []solver.Ref{newref}, err
 }
 
 func (b *buildOp) ContentMask(context.Context) (digest.Digest, [][]string, error) {