github.com/alibaba/sealer@v0.8.6-0.20220430115802-37a2bdaa8173/pkg/image/store/layer_store_test.go (about)

     1  // Copyright © 2021 Alibaba Group Holding Ltd.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package store
    16  
    17  import (
    18  	"os"
    19  	"path/filepath"
    20  	"testing"
    21  
    22  	"gotest.tools/skip"
    23  
    24  	"github.com/alibaba/sealer/common"
    25  	"github.com/alibaba/sealer/logger"
    26  	"github.com/alibaba/sealer/utils"
    27  )
    28  
    29  const fileContent = "fake file content"
    30  
    31  type mockROLayer struct {
    32  	roLayer    ROLayer
    33  	tmpRelPath string
    34  	files      []string
    35  }
    36  
    37  var layers = []mockROLayer{
    38  	{
    39  		tmpRelPath: "/tmp/layerstore-test/a",
    40  		files:      []string{"a", "b"},
    41  	},
    42  	{
    43  		tmpRelPath: "/tmp/layerstore-test/b",
    44  		files:      []string{"b", "c"},
    45  	},
    46  	{
    47  		tmpRelPath: "/tmp/layerstore-test/c",
    48  		files:      []string{"d", "e"},
    49  	},
    50  	{
    51  		tmpRelPath: "/tmp/layerstore-test/d",
    52  		files:      []string{"f", "g"},
    53  	},
    54  }
    55  
    56  func makeFakeLayer(layer mockROLayer) error {
    57  	err := os.MkdirAll(layer.tmpRelPath, common.FileMode0755)
    58  	if err != nil {
    59  		return err
    60  	}
    61  
    62  	for _, file := range layer.files {
    63  		err = utils.AtomicWriteFile(filepath.Join(layer.tmpRelPath, file), []byte(fileContent), common.FileMode0644)
    64  		if err != nil {
    65  			return err
    66  		}
    67  	}
    68  
    69  	return nil
    70  }
    71  
    72  func cleanTmpLayers(layer mockROLayer) error {
    73  	_ = os.Remove(layer.tmpRelPath)
    74  	backend, err := NewFSStoreBackend()
    75  	if err != nil {
    76  		return err
    77  	}
    78  	err = os.RemoveAll(backend.LayerDataDir(layer.roLayer.id.ToDigest()))
    79  	if err != nil {
    80  		logger.Warn(err)
    81  	}
    82  
    83  	err = os.RemoveAll(backend.LayerDBDir(layer.roLayer.id.ToDigest()))
    84  	if err != nil {
    85  		logger.Warn(err)
    86  	}
    87  	return nil
    88  }
    89  
    90  func TestLayerStore_RegisterLayerForBuilder(t *testing.T) {
    91  	skip.If(t, os.Getuid() != 0, "skipping test that requires root")
    92  
    93  	var err error
    94  	for _, layer := range layers {
    95  		err = makeFakeLayer(layer)
    96  		if err != nil {
    97  			t.Errorf("failed to make layers, err: %s", err)
    98  		}
    99  	}
   100  
   101  	err = os.MkdirAll(layerDataRoot, common.FileMode0755)
   102  	if err != nil {
   103  		t.Error(err)
   104  	}
   105  	err = os.MkdirAll(layerDBRoot, common.FileMode0755)
   106  	if err != nil {
   107  		t.Error(err)
   108  	}
   109  
   110  	ls, err := NewDefaultLayerStore()
   111  	if err != nil {
   112  		t.Errorf("failed to get layer store, err: %s", err)
   113  	}
   114  
   115  	newLayers := []mockROLayer{}
   116  	layerExists := map[string]bool{}
   117  	for _, layer := range layers {
   118  		layerID, err := ls.RegisterLayerForBuilder(layer.tmpRelPath)
   119  		if err != nil {
   120  			t.Errorf("failed to registry layer %s, err: %s", layer.tmpRelPath, err)
   121  		}
   122  		layer.roLayer = ROLayer{id: LayerID(layerID)}
   123  		newLayers = append(newLayers, layer)
   124  		layerExists[layerID.String()] = true
   125  	}
   126  
   127  	defer func() {
   128  		for _, layer := range newLayers {
   129  			err := cleanTmpLayers(layer)
   130  			if err != nil {
   131  				logger.Error(err)
   132  			}
   133  		}
   134  	}()
   135  
   136  	lls, ok := ls.(*layerStore)
   137  	if !ok {
   138  		t.Errorf("failed to convert to layerStore")
   139  	}
   140  
   141  	err = lls.loadAllROLayers()
   142  	if err != nil {
   143  		t.Errorf("failed to load layers, err: %s", err)
   144  	}
   145  
   146  	for key := range lls.layers {
   147  		if layerExists[key.String()] {
   148  			delete(layerExists, key.String())
   149  		}
   150  	}
   151  
   152  	if len(layerExists) > 0 {
   153  		t.Errorf("there are still some layer not load correctly")
   154  	}
   155  }