github.com/LazyboyChen7/engine@v17.12.1-ce-rc2+incompatible/builder/fscache/fscache_test.go (about)

     1  package fscache
     2  
     3  import (
     4  	"io/ioutil"
     5  	"os"
     6  	"path/filepath"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/moby/buildkit/session/filesync"
    11  	"github.com/stretchr/testify/assert"
    12  	"golang.org/x/net/context"
    13  )
    14  
    15  func TestFSCache(t *testing.T) {
    16  	tmpDir, err := ioutil.TempDir("", "fscache")
    17  	assert.Nil(t, err)
    18  	defer os.RemoveAll(tmpDir)
    19  
    20  	backend := NewNaiveCacheBackend(filepath.Join(tmpDir, "backend"))
    21  
    22  	opt := Opt{
    23  		Root:     tmpDir,
    24  		Backend:  backend,
    25  		GCPolicy: GCPolicy{MaxSize: 15, MaxKeepDuration: time.Hour},
    26  	}
    27  
    28  	fscache, err := NewFSCache(opt)
    29  	assert.Nil(t, err)
    30  
    31  	defer fscache.Close()
    32  
    33  	err = fscache.RegisterTransport("test", &testTransport{})
    34  	assert.Nil(t, err)
    35  
    36  	src1, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo", "data", "bar"})
    37  	assert.Nil(t, err)
    38  
    39  	dt, err := ioutil.ReadFile(filepath.Join(src1.Root().Path(), "foo"))
    40  	assert.Nil(t, err)
    41  	assert.Equal(t, string(dt), "data")
    42  
    43  	// same id doesn't recalculate anything
    44  	src2, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo", "data2", "bar"})
    45  	assert.Nil(t, err)
    46  	assert.Equal(t, src1.Root().Path(), src2.Root().Path())
    47  
    48  	dt, err = ioutil.ReadFile(filepath.Join(src1.Root().Path(), "foo"))
    49  	assert.Nil(t, err)
    50  	assert.Equal(t, string(dt), "data")
    51  	assert.Nil(t, src2.Close())
    52  
    53  	src3, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo2", "data2", "bar"})
    54  	assert.Nil(t, err)
    55  	assert.NotEqual(t, src1.Root().Path(), src3.Root().Path())
    56  
    57  	dt, err = ioutil.ReadFile(filepath.Join(src3.Root().Path(), "foo2"))
    58  	assert.Nil(t, err)
    59  	assert.Equal(t, string(dt), "data2")
    60  
    61  	s, err := fscache.DiskUsage()
    62  	assert.Nil(t, err)
    63  	assert.Equal(t, s, int64(0))
    64  
    65  	assert.Nil(t, src3.Close())
    66  
    67  	s, err = fscache.DiskUsage()
    68  	assert.Nil(t, err)
    69  	assert.Equal(t, s, int64(5))
    70  
    71  	// new upload with the same shared key shoutl overwrite
    72  	src4, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo3", "data3", "bar"})
    73  	assert.Nil(t, err)
    74  	assert.NotEqual(t, src1.Root().Path(), src3.Root().Path())
    75  
    76  	dt, err = ioutil.ReadFile(filepath.Join(src3.Root().Path(), "foo3"))
    77  	assert.Nil(t, err)
    78  	assert.Equal(t, string(dt), "data3")
    79  	assert.Equal(t, src4.Root().Path(), src3.Root().Path())
    80  	assert.Nil(t, src4.Close())
    81  
    82  	s, err = fscache.DiskUsage()
    83  	assert.Nil(t, err)
    84  	assert.Equal(t, s, int64(10))
    85  
    86  	// this one goes over the GC limit
    87  	src5, err := fscache.SyncFrom(context.TODO(), &testIdentifier{"foo4", "datadata", "baz"})
    88  	assert.Nil(t, err)
    89  	assert.Nil(t, src5.Close())
    90  
    91  	// GC happens async
    92  	time.Sleep(100 * time.Millisecond)
    93  
    94  	// only last insertion after GC
    95  	s, err = fscache.DiskUsage()
    96  	assert.Nil(t, err)
    97  	assert.Equal(t, s, int64(8))
    98  
    99  	// prune deletes everything
   100  	released, err := fscache.Prune(context.TODO())
   101  	assert.Nil(t, err)
   102  	assert.Equal(t, released, uint64(8))
   103  
   104  	s, err = fscache.DiskUsage()
   105  	assert.Nil(t, err)
   106  	assert.Equal(t, s, int64(0))
   107  }
   108  
   109  type testTransport struct {
   110  }
   111  
   112  func (t *testTransport) Copy(ctx context.Context, id RemoteIdentifier, dest string, cs filesync.CacheUpdater) error {
   113  	testid := id.(*testIdentifier)
   114  	return ioutil.WriteFile(filepath.Join(dest, testid.filename), []byte(testid.data), 0600)
   115  }
   116  
   117  type testIdentifier struct {
   118  	filename  string
   119  	data      string
   120  	sharedKey string
   121  }
   122  
   123  func (t *testIdentifier) Key() string {
   124  	return t.filename
   125  }
   126  func (t *testIdentifier) SharedKey() string {
   127  	return t.sharedKey
   128  }
   129  func (t *testIdentifier) Transport() string {
   130  	return "test"
   131  }