@@ -4,11 +4,11 @@ import (

 	"fmt"

 	"github.com/docker/distribution/reference"

+	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/backend"

 	"github.com/docker/docker/builder"

-	"github.com/docker/docker/builder/dockerfile"

+	"github.com/docker/docker/builder/fscache"

 	"github.com/docker/docker/image"

-	"github.com/docker/docker/pkg/idtools"

 	"github.com/docker/docker/pkg/stringid"

 	"github.com/pkg/errors"

 	"golang.org/x/net/context"

@@ -20,16 +20,21 @@ type ImageComponent interface {

 	TagImageWithReference(image.ID, string, reference.Named) error

 }

+// Builder defines interface for running a build

+type Builder interface {

+	Build(context.Context, backend.BuildConfig) (*builder.Result, error)

+}

+

 // Backend provides build functionality to the API router

 type Backend struct {

-	manager        *dockerfile.BuildManager

+	builder        Builder

+	fsCache        *fscache.FSCache

 	imageComponent ImageComponent

 }

 // NewBackend creates a new build backend from components

-func NewBackend(components ImageComponent, builderBackend builder.Backend, sg dockerfile.SessionGetter, idMappings *idtools.IDMappings) (*Backend, error) {

-	manager := dockerfile.NewBuildManager(builderBackend, sg, idMappings)

-	return &Backend{imageComponent: components, manager: manager}, nil

+func NewBackend(components ImageComponent, builder Builder, fsCache *fscache.FSCache) (*Backend, error) {

+	return &Backend{imageComponent: components, builder: builder, fsCache: fsCache}, nil

 }

 // Build builds an image from a Source

@@ -40,7 +45,7 @@ func (b *Backend) Build(ctx context.Context, config backend.BuildConfig) (string

 		return "", err

 	}

-	build, err := b.manager.Build(ctx, config)

+	build, err := b.builder.Build(ctx, config)

 	if err != nil {

 		return "", err

 	}

@@ -58,6 +63,15 @@ func (b *Backend) Build(ctx context.Context, config backend.BuildConfig) (string

 	return imageID, err

 }

+// PruneCache removes all cached build sources

+func (b *Backend) PruneCache(ctx context.Context) (*types.BuildCachePruneReport, error) {

+	size, err := b.fsCache.Prune()

+	if err != nil {

+		return nil, errors.Wrap(err, "failed to prune build cache")

+	}

+	return &types.BuildCachePruneReport{SpaceReclaimed: size}, nil

+}

+

 func squashBuild(build *builder.Result, imageComponent ImageComponent) (string, error) {

 	var fromID string

 	if build.FromImage != nil {

@@ -1,6 +1,7 @@

 package build

 import (

+	"github.com/docker/docker/api/types"

 	"github.com/docker/docker/api/types/backend"

 	"golang.org/x/net/context"

 )

@@ -10,6 +11,9 @@ type Backend interface {

 	// Build a Docker image returning the id of the image

 	// TODO: make this return a reference instead of string

 	Build(context.Context, backend.BuildConfig) (string, error)

+

+	// Prune build cache

+	PruneCache(context.Context) (*types.BuildCachePruneReport, error)

 }

 type experimentalProvider interface {

@@ -24,5 +24,6 @@ func (r *buildRouter) Routes() []router.Route {

 func (r *buildRouter) initRoutes() {

 	r.routes = []router.Route{

 		router.NewPostRoute("/build", r.postBuild, router.WithCancel),

+		router.NewPostRoute("/build/prune", r.postPrune, router.WithCancel),

 	}

 }

@@ -132,6 +132,14 @@ func newImageBuildOptions(ctx context.Context, r *http.Request) (*types.ImageBui

 	return options, nil

 }

+func (br *buildRouter) postPrune(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

+	report, err := br.backend.PruneCache(ctx)

+	if err != nil {

+		return err

+	}

+	return httputils.WriteJSON(w, http.StatusOK, report)

+}

+

 func (br *buildRouter) postBuild(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {

 	var (

 		notVerboseBuffer = bytes.NewBuffer(nil)

@@ -2,6 +2,7 @@ package system

 import (

 	"github.com/docker/docker/api/server/router"

+	"github.com/docker/docker/builder/fscache"

 	"github.com/docker/docker/daemon/cluster"

 )

@@ -11,13 +12,15 @@ type systemRouter struct {

 	backend Backend

 	cluster *cluster.Cluster

 	routes  []router.Route

+	builder *fscache.FSCache

 }

 // NewRouter initializes a new system router

-func NewRouter(b Backend, c *cluster.Cluster) router.Router {

+func NewRouter(b Backend, c *cluster.Cluster, fscache *fscache.FSCache) router.Router {

 	r := &systemRouter{

 		backend: b,

 		cluster: c,

+		builder: fscache,

 	}

 	r.routes = []router.Route{

@@ -17,6 +17,7 @@ import (

 	timetypes "github.com/docker/docker/api/types/time"

 	"github.com/docker/docker/api/types/versions"

 	"github.com/docker/docker/pkg/ioutils"

+	pkgerrors "github.com/pkg/errors"

 	"golang.org/x/net/context"

 )

@@ -75,6 +76,11 @@ func (s *systemRouter) getDiskUsage(ctx context.Context, w http.ResponseWriter,

 	if err != nil {

 		return err

 	}

+	builderSize, err := s.builder.DiskUsage()

+	if err != nil {

+		return pkgerrors.Wrap(err, "error getting build cache usage")

+	}

+	du.BuilderSize = builderSize

 	return httputils.WriteJSON(w, http.StatusOK, du)

 }

@@ -4745,6 +4745,27 @@ paths:

           schema:

             $ref: "#/definitions/ErrorResponse"

       tags: ["Image"]

+  /build/prune:

+    post:

+      summary: "Delete builder cache"

+      produces:

+        - "application/json"

+      operationId: "BuildPrune"

+      responses:

+        200:

+          description: "No error"

+          schema:

+            type: "object"

+            properties:

+              SpaceReclaimed:

+                description: "Disk space reclaimed in bytes"

+                type: "integer"

+                format: "int64"

+        500:

+          description: "Server error"

+          schema:

+            $ref: "#/definitions/ErrorResponse"

+      tags: ["Image"]

   /images/create:

     post:

       summary: "Create an image"

@@ -489,10 +489,11 @@ type Runtime struct {

 // DiskUsage contains response of Engine API:

 // GET "/system/df"

 type DiskUsage struct {

-	LayersSize int64

-	Images     []*ImageSummary

-	Containers []*Container

-	Volumes    []*Volume

+	LayersSize  int64

+	Images      []*ImageSummary

+	Containers  []*Container

+	Volumes     []*Volume

+	BuilderSize int64

 }

 // ContainersPruneReport contains the response for Engine API:

@@ -516,6 +517,12 @@ type ImagesPruneReport struct {

 	SpaceReclaimed uint64

 }

+// BuildCachePruneReport contains the response for Engine API:

+// POST "/build/prune"

+type BuildCachePruneReport struct {

+	SpaceReclaimed uint64

+}

+

 // NetworksPruneReport contains the response for Engine API:

 // POST "/networks/prune"

 type NetworksPruneReport struct {

@@ -7,6 +7,7 @@ import (

 	"io/ioutil"

 	"runtime"

 	"strings"

+	"time"

 	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/api/types"

@@ -15,6 +16,7 @@ import (

 	"github.com/docker/docker/builder"

 	"github.com/docker/docker/builder/dockerfile/command"

 	"github.com/docker/docker/builder/dockerfile/parser"

+	"github.com/docker/docker/builder/fscache"

 	"github.com/docker/docker/builder/remotecontext"

 	"github.com/docker/docker/client/session"

 	"github.com/docker/docker/pkg/archive"

@@ -52,16 +54,22 @@ type BuildManager struct {

 	backend   builder.Backend

 	pathCache pathCache // TODO: make this persistent

 	sg        SessionGetter

+	fsCache   *fscache.FSCache

 }

 // NewBuildManager creates a BuildManager

-func NewBuildManager(b builder.Backend, sg SessionGetter, idMappings *idtools.IDMappings) *BuildManager {

-	return &BuildManager{

+func NewBuildManager(b builder.Backend, sg SessionGetter, fsCache *fscache.FSCache, idMappings *idtools.IDMappings) (*BuildManager, error) {

+	bm := &BuildManager{

 		backend:   b,

 		pathCache: &syncmap.Map{},

 		sg:        sg,

 		archiver:  chrootarchive.NewArchiver(idMappings),

+		fsCache:   fsCache,

 	}

+	if err := fsCache.RegisterTransport(remotecontext.ClientSessionRemote, NewClientSessionTransport()); err != nil {

+		return nil, err

+	}

+	return bm, nil

 }

 // Build starts a new build from a BuildConfig

@@ -75,13 +83,13 @@ func (bm *BuildManager) Build(ctx context.Context, config backend.BuildConfig) (

 	if err != nil {

 		return nil, err

 	}

-	if source != nil {

-		defer func() {

+	defer func() {

+		if source != nil {

 			if err := source.Close(); err != nil {

 				logrus.Debugf("[BUILDER] failed to remove temporary context: %v", err)

 			}

-		}()

-	}

+		}

+	}()

 	// TODO @jhowardmsft LCOW support - this will require rework to allow both linux and Windows simultaneously.

 	// This is an interim solution to hardcode to linux if LCOW is turned on.

@@ -95,8 +103,10 @@ func (bm *BuildManager) Build(ctx context.Context, config backend.BuildConfig) (

 	ctx, cancel := context.WithCancel(ctx)

 	defer cancel()

-	if err := bm.initializeClientSession(ctx, cancel, config.Options); err != nil {

+	if src, err := bm.initializeClientSession(ctx, cancel, config.Options); err != nil {

 		return nil, err

+	} else if src != nil {

+		source = src

 	}

 	builderOptions := builderOptions{

@@ -111,20 +121,38 @@ func (bm *BuildManager) Build(ctx context.Context, config backend.BuildConfig) (

 	return newBuilder(ctx, builderOptions).build(source, dockerfile)

 }

-func (bm *BuildManager) initializeClientSession(ctx context.Context, cancel func(), options *types.ImageBuildOptions) error {

+func (bm *BuildManager) initializeClientSession(ctx context.Context, cancel func(), options *types.ImageBuildOptions) (builder.Source, error) {

 	if options.SessionID == "" || bm.sg == nil {

-		return nil

+		return nil, nil

 	}

 	logrus.Debug("client is session enabled")

+

+	ctx, cancelCtx := context.WithTimeout(ctx, sessionConnectTimeout)

+	defer cancelCtx()

+

 	c, err := bm.sg.Get(ctx, options.SessionID)

 	if err != nil {

-		return err

+		return nil, err

 	}

 	go func() {

 		<-c.Context().Done()

 		cancel()

 	}()

-	return nil

+	if options.RemoteContext == remotecontext.ClientSessionRemote {

+		st := time.Now()

+		csi, err := NewClientSessionSourceIdentifier(ctx, bm.sg,

+			options.SessionID, []string{"/"})

+		if err != nil {

+			return nil, err

+		}

+		src, err := bm.fsCache.SyncFrom(ctx, csi)

+		if err != nil {

+			return nil, err

+		}

+		logrus.Debugf("sync-time: %v", time.Since(st))

+		return src, nil

+	}

+	return nil, nil

 }

 // builderOptions are the dependencies required by the builder

new file mode 100644

@@ -0,0 +1,78 @@

+package dockerfile

+

+import (

+	"time"

+

+	"github.com/docker/docker/builder/fscache"

+	"github.com/docker/docker/builder/remotecontext"

+	"github.com/docker/docker/client/session"

+	"github.com/docker/docker/client/session/filesync"

+	"github.com/pkg/errors"

+	"golang.org/x/net/context"

+)

+

+const sessionConnectTimeout = 5 * time.Second

+

+// ClientSessionTransport is a transport for copying files from docker client

+// to the daemon.

+type ClientSessionTransport struct{}

+

+// NewClientSessionTransport returns new ClientSessionTransport instance

+func NewClientSessionTransport() *ClientSessionTransport {

+	return &ClientSessionTransport{}

+}

+

+// Copy data from a remote to a destination directory.

+func (cst *ClientSessionTransport) Copy(ctx context.Context, id fscache.RemoteIdentifier, dest string, cu filesync.CacheUpdater) error {

+	csi, ok := id.(*ClientSessionSourceIdentifier)

+	if !ok {

+		return errors.New("invalid identifier for client session")

+	}

+

+	return filesync.FSSync(ctx, csi.caller, filesync.FSSendRequestOpt{

+		SrcPaths:     csi.srcPaths,

+		DestDir:      dest,

+		CacheUpdater: cu,

+	})

+}

+

+// ClientSessionSourceIdentifier is an identifier that can be used for requesting

+// files from remote client

+type ClientSessionSourceIdentifier struct {

+	srcPaths  []string

+	caller    session.Caller

+	sharedKey string

+	uuid      string

+}

+

+// NewClientSessionSourceIdentifier returns new ClientSessionSourceIdentifier instance

+func NewClientSessionSourceIdentifier(ctx context.Context, sg SessionGetter, uuid string, sources []string) (*ClientSessionSourceIdentifier, error) {

+	csi := &ClientSessionSourceIdentifier{

+		uuid:     uuid,

+		srcPaths: sources,

+	}

+	caller, err := sg.Get(ctx, uuid)

+	if err != nil {

+		return nil, errors.Wrapf(err, "failed to get session for %s", uuid)

+	}

+

+	csi.caller = caller

+	return csi, nil

+}

+

+// Transport returns transport identifier for remote identifier

+func (csi *ClientSessionSourceIdentifier) Transport() string {

+	return remotecontext.ClientSessionRemote

+}

+

+// SharedKey returns shared key for remote identifier. Shared key is used

+// for finding the base for a repeated transfer.

+func (csi *ClientSessionSourceIdentifier) SharedKey() string {

+	return csi.caller.SharedKey()

+}

+

+// Key returns unique key for remote identifier. Requests with same key return

+// same data.

+func (csi *ClientSessionSourceIdentifier) Key() string {

+	return csi.uuid

+}

@@ -158,7 +158,7 @@ func executeTestCase(t *testing.T, testCase dispatchTestCase) {

 		}

 	}()

-	context, err := remotecontext.MakeTarSumContext(tarStream)

+	context, err := remotecontext.FromArchive(tarStream)

 	if err != nil {

 		t.Fatalf("Error when creating tar context: %s", err)

new file mode 100644

@@ -0,0 +1,602 @@

+package fscache

+

+import (

+	"encoding/json"

+	"os"

+	"path/filepath"

+	"sort"

+	"sync"

+	"time"

+

+	"github.com/Sirupsen/logrus"

+	"github.com/boltdb/bolt"

+	"github.com/docker/docker/builder"

+	"github.com/docker/docker/builder/remotecontext"

+	"github.com/docker/docker/client/session/filesync"

+	"github.com/docker/docker/pkg/directory"

+	"github.com/docker/docker/pkg/stringid"

+	"github.com/pkg/errors"

+	"github.com/tonistiigi/fsutil"

+	"golang.org/x/net/context"

+	"golang.org/x/sync/singleflight"

+)

+

+const dbFile = "fscache.db"

+const cacheKey = "cache"

+const metaKey = "meta"

+

+// Backend is a backing implementation for FSCache

+type Backend interface {

+	Get(id string) (string, error)

+	Remove(id string) error

+}

+

+// FSCache allows syncing remote resources to cached snapshots

+type FSCache struct {

+	opt        Opt

+	transports map[string]Transport

+	mu         sync.Mutex

+	g          singleflight.Group

+	store      *fsCacheStore

+}

+

+// Opt defines options for initializing FSCache

+type Opt struct {

+	Backend  Backend

+	Root     string // for storing local metadata

+	GCPolicy GCPolicy

+}

+

+// GCPolicy defines policy for garbage collection

+type GCPolicy struct {

+	MaxSize         uint64

+	MaxKeepDuration time.Duration

+}

+

+// NewFSCache returns new FSCache object

+func NewFSCache(opt Opt) (*FSCache, error) {

+	store, err := newFSCacheStore(opt)

+	if err != nil {

+		return nil, err

+	}

+	return &FSCache{

+		store:      store,

+		opt:        opt,

+		transports: make(map[string]Transport),

+	}, nil

+}

+

+// Transport defines a method for syncing remote data to FSCache

+type Transport interface {

+	Copy(ctx context.Context, id RemoteIdentifier, dest string, cs filesync.CacheUpdater) error

+}

+

+// RemoteIdentifier identifies a transfer request

+type RemoteIdentifier interface {

+	Key() string

+	SharedKey() string

+	Transport() string

+}

+

+// RegisterTransport registers a new transport method

+func (fsc *FSCache) RegisterTransport(id string, transport Transport) error {

+	fsc.mu.Lock()

+	defer fsc.mu.Unlock()

+	if _, ok := fsc.transports[id]; ok {

+		return errors.Errorf("transport %v already exists", id)

+	}

+	fsc.transports[id] = transport

+	return nil

+}

+

+// SyncFrom returns a source based on a remote identifier

+func (fsc *FSCache) SyncFrom(ctx context.Context, id RemoteIdentifier) (builder.Source, error) { // cacheOpt

+	trasportID := id.Transport()

+	fsc.mu.Lock()

+	transport, ok := fsc.transports[id.Transport()]

+	if !ok {

+		fsc.mu.Unlock()

+		return nil, errors.Errorf("invalid transport %s", trasportID)

+	}

+

+	logrus.Debugf("SyncFrom %s %s", id.Key(), id.SharedKey())

+	fsc.mu.Unlock()

+	sourceRef, err, _ := fsc.g.Do(id.Key(), func() (interface{}, error) {

+		var sourceRef *cachedSourceRef

+		sourceRef, err := fsc.store.Get(id.Key())

+		if err == nil {

+			return sourceRef, nil

+		}

+

+		// check for unused shared cache

+		sharedKey := id.SharedKey()

+		if sharedKey != "" {

+			r, err := fsc.store.Rebase(sharedKey, id.Key())

+			if err == nil {

+				sourceRef = r

+			}

+		}

+

+		if sourceRef == nil {

+			var err error

+			sourceRef, err = fsc.store.New(id.Key(), sharedKey)

+			if err != nil {

+				return nil, errors.Wrap(err, "failed to create remote context")

+			}

+		}

+

+		if err := syncFrom(ctx, sourceRef, transport, id); err != nil {

+			sourceRef.Release()

+			return nil, err

+		}

+		if err := sourceRef.resetSize(-1); err != nil {

+			return nil, err

+		}

+		return sourceRef, nil

+	})

+	if err != nil {

+		return nil, err

+	}

+	ref := sourceRef.(*cachedSourceRef)

+	if ref.src == nil { // failsafe

+		return nil, errors.Errorf("invalid empty pull")

+	}

+	wc := &wrappedContext{Source: ref.src, closer: func() error {

+		ref.Release()

+		return nil

+	}}

+	return wc, nil

+}

+

+// DiskUsage reports how much data is allocated by the cache

+func (fsc *FSCache) DiskUsage() (int64, error) {

+	return fsc.store.DiskUsage()

+}

+

+// Prune allows manually cleaning up the cache

+func (fsc *FSCache) Prune() (uint64, error) {

+	return fsc.store.Prune()

+}

+

+// Close stops the gc and closes the persistent db

+func (fsc *FSCache) Close() error {

+	return fsc.store.Close()

+}

+

+func syncFrom(ctx context.Context, cs *cachedSourceRef, transport Transport, id RemoteIdentifier) (retErr error) {

+	src := cs.src

+	if src == nil {

+		src = remotecontext.NewCachableSource(cs.Dir())

+	}

+

+	if !cs.cached {

+		if err := cs.storage.db.View(func(tx *bolt.Tx) error {

+			b := tx.Bucket([]byte(id.Key()))

+			dt := b.Get([]byte(cacheKey))

+			if dt != nil {

+				if err := src.UnmarshalBinary(dt); err != nil {

+					return err

+				}

+			} else {

+				return errors.Wrap(src.Scan(), "failed to scan cache records")

+			}

+			return nil

+		}); err != nil {

+			return err

+		}

+	}

+

+	dc := &detectChanges{f: src.HandleChange}

+

+	// todo: probably send a bucket to `Copy` and let it return source

+	// but need to make sure that tx is safe

+	if err := transport.Copy(ctx, id, cs.Dir(), dc); err != nil {

+		return errors.Wrapf(err, "failed to copy to %s", cs.Dir())

+	}

+

+	if !dc.supported {

+		if err := src.Scan(); err != nil {

+			return errors.Wrap(err, "failed to scan cache records after transfer")

+		}

+	}

+	cs.cached = true

+	cs.src = src

+	return cs.storage.db.Update(func(tx *bolt.Tx) error {

+		dt, err := src.MarshalBinary()

+		if err != nil {

+			return err

+		}

+		b := tx.Bucket([]byte(id.Key()))

+		return b.Put([]byte(cacheKey), dt)

+	})

+}

+

+type fsCacheStore struct {

+	root     string

+	mu       sync.Mutex

+	sources  map[string]*cachedSource

+	db       *bolt.DB

+	fs       Backend

+	gcTimer  *time.Timer

+	gcPolicy GCPolicy

+}

+

+// CachePolicy defines policy for keeping a resource in cache

+type CachePolicy struct {

+	Priority int

+	LastUsed time.Time

+}

+

+func defaultCachePolicy() CachePolicy {

+	return CachePolicy{Priority: 10, LastUsed: time.Now()}

+}

+

+func newFSCacheStore(opt Opt) (*fsCacheStore, error) {

+	if err := os.MkdirAll(opt.Root, 0700); err != nil {

+		return nil, err

+	}

+	p := filepath.Join(opt.Root, dbFile)

+	db, err := bolt.Open(p, 0600, nil)

+	if err != nil {

+		return nil, errors.Wrap(err, "failed to open database file %s")

+	}

+	s := &fsCacheStore{db: db, sources: make(map[string]*cachedSource), fs: opt.Backend, gcPolicy: opt.GCPolicy}

+	db.View(func(tx *bolt.Tx) error {

+		return tx.ForEach(func(name []byte, b *bolt.Bucket) error {

+			dt := b.Get([]byte(metaKey))

+			if dt == nil {

+				return nil

+			}

+			var sm sourceMeta

+			if err := json.Unmarshal(dt, &sm); err != nil {

+				return err

+			}

+			dir, err := s.fs.Get(sm.BackendID)

+			if err != nil {

+				return err // TODO: handle gracefully

+			}

+			source := &cachedSource{

+				refs:       make(map[*cachedSourceRef]struct{}),

+				id:         string(name),

+				dir:        dir,

+				sourceMeta: sm,

+				storage:    s,

+			}

+			s.sources[string(name)] = source

+			return nil

+		})

+	})

+

+	s.gcTimer = s.startPeriodicGC(5 * time.Minute)

+	return s, nil

+}

+

+func (s *fsCacheStore) startPeriodicGC(interval time.Duration) *time.Timer {

+	var t *time.Timer

+	t = time.AfterFunc(interval, func() {

+		if err := s.GC(); err != nil {

+			logrus.Errorf("build gc error: %v", err)

+		}

+		t.Reset(interval)

+	})

+	return t

+}

+

+func (s *fsCacheStore) Close() error {

+	s.gcTimer.Stop()

+	return s.db.Close()

+}

+

+func (s *fsCacheStore) New(id, sharedKey string) (*cachedSourceRef, error) {

+	s.mu.Lock()

+	defer s.mu.Unlock()

+	var ret *cachedSource

+	if err := s.db.Update(func(tx *bolt.Tx) error {

+		b, err := tx.CreateBucket([]byte(id))

+		if err != nil {

+			return err

+		}

+		backendID := stringid.GenerateRandomID()

+		dir, err := s.fs.Get(backendID)

+		if err != nil {

+			return err

+		}

+		source := &cachedSource{

+			refs: make(map[*cachedSourceRef]struct{}),

+			id:   id,

+			dir:  dir,

+			sourceMeta: sourceMeta{

+				BackendID:   backendID,

+				SharedKey:   sharedKey,

+				CachePolicy: defaultCachePolicy(),

+			},

+			storage: s,

+		}

+		dt, err := json.Marshal(source.sourceMeta)

+		if err != nil {

+			return err

+		}

+		if err := b.Put([]byte(metaKey), dt); err != nil {

+			return err

+		}

+		s.sources[id] = source

+		ret = source

+		return nil

+	}); err != nil {

+		return nil, err

+	}

+	return ret.getRef(), nil

+}

+

+func (s *fsCacheStore) Rebase(sharedKey, newid string) (*cachedSourceRef, error) {

+	s.mu.Lock()

+	defer s.mu.Unlock()

+	var ret *cachedSource

+	for id, snap := range s.sources {

+		if snap.SharedKey == sharedKey && len(snap.refs) == 0 {

+			if err := s.db.Update(func(tx *bolt.Tx) error {

+				if err := tx.DeleteBucket([]byte(id)); err != nil {

+					return err

+				}

+				b, err := tx.CreateBucket([]byte(newid))

+				if err != nil {

+					return err

+				}

+				snap.id = newid

+				snap.CachePolicy = defaultCachePolicy()

+				dt, err := json.Marshal(snap.sourceMeta)

+				if err != nil {

+					return err

+				}

+				if err := b.Put([]byte(metaKey), dt); err != nil {

+					return err

+				}

+				delete(s.sources, id)

+				s.sources[newid] = snap

+				return nil

+			}); err != nil {

+				return nil, err

+			}

+			ret = snap

+			break

+		}

+	}

+	if ret == nil {

+		return nil, errors.Errorf("no candidate for rebase")

+	}

+	return ret.getRef(), nil

+}

+

+func (s *fsCacheStore) Get(id string) (*cachedSourceRef, error) {

+	s.mu.Lock()

+	defer s.mu.Unlock()

+	src, ok := s.sources[id]

+	if !ok {

+		return nil, errors.Errorf("not found")

+	}

+	return src.getRef(), nil

+}

+

+// DiskUsage reports how much data is allocated by the cache

+func (s *fsCacheStore) DiskUsage() (int64, error) {

+	s.mu.Lock()

+	defer s.mu.Unlock()

+	var size int64

+

+	for _, snap := range s.sources {

+		if len(snap.refs) == 0 {

+			ss, err := snap.getSize()

+			if err != nil {

+				return 0, err

+			}

+			size += ss

+		}

+	}

+	return size, nil

+}

+

+// Prune allows manually cleaning up the cache

+func (s *fsCacheStore) Prune() (uint64, error) {

+	s.mu.Lock()

+	defer s.mu.Unlock()

+	var size uint64

+

+	for id, snap := range s.sources {

+		if len(snap.refs) == 0 {

+			ss, err := snap.getSize()

+			if err != nil {

+				return size, err

+			}

+			if err := s.delete(id); err != nil {

+				return size, errors.Wrapf(err, "failed to delete %s", id)

+			}

+			size += uint64(ss)

+		}

+	}

+	return size, nil

+}

+

+// GC runs a garbage collector on FSCache

+func (s *fsCacheStore) GC() error {

+	s.mu.Lock()

+	defer s.mu.Unlock()

+	var size uint64

+

+	cutoff := time.Now().Add(-s.gcPolicy.MaxKeepDuration)

+	var blacklist []*cachedSource

+

+	for id, snap := range s.sources {

+		if len(snap.refs) == 0 {

+			if cutoff.After(snap.CachePolicy.LastUsed) {

+				if err := s.delete(id); err != nil {

+					return errors.Wrapf(err, "failed to delete %s", id)

+				}

+			} else {

+				ss, err := snap.getSize()

+				if err != nil {

+					return err

+				}

+				size += uint64(ss)

+				blacklist = append(blacklist, snap)

+			}

+		}

+	}

+

+	sort.Sort(sortableCacheSources(blacklist))

+	for _, snap := range blacklist {