gitee.com/leisunstar/runtime@v0.0.0-20200521203717-5cef3e7b53f9/virtcontainers/factory/factory_test.go (about)

     1  // Copyright (c) 2018 HyperHQ Inc.
     2  //
     3  // SPDX-License-Identifier: Apache-2.0
     4  //
     5  
     6  package factory
     7  
     8  import (
     9  	"context"
    10  	"os"
    11  	"testing"
    12  
    13  	vc "github.com/kata-containers/runtime/virtcontainers"
    14  	"github.com/kata-containers/runtime/virtcontainers/factory/base"
    15  	"github.com/kata-containers/runtime/virtcontainers/persist/fs"
    16  	"github.com/kata-containers/runtime/virtcontainers/utils"
    17  	"github.com/sirupsen/logrus"
    18  	"github.com/stretchr/testify/assert"
    19  )
    20  
    21  const testDisabledAsNonRoot = "Test disabled as requires root privileges"
    22  
    23  func TestNewFactory(t *testing.T) {
    24  	var config Config
    25  
    26  	assert := assert.New(t)
    27  
    28  	ctx := context.Background()
    29  	_, err := NewFactory(ctx, config, true)
    30  	assert.Error(err)
    31  	_, err = NewFactory(ctx, config, false)
    32  	assert.Error(err)
    33  
    34  	config.VMConfig = vc.VMConfig{
    35  		HypervisorType: vc.MockHypervisor,
    36  		AgentType:      vc.NoopAgentType,
    37  		ProxyType:      vc.NoopProxyType,
    38  	}
    39  
    40  	_, err = NewFactory(ctx, config, false)
    41  	assert.Error(err)
    42  
    43  	defer fs.MockStorageDestroy()
    44  	config.VMConfig.HypervisorConfig = vc.HypervisorConfig{
    45  		KernelPath: fs.MockStorageRootPath(),
    46  		ImagePath:  fs.MockStorageRootPath(),
    47  	}
    48  
    49  	// direct
    50  	f, err := NewFactory(ctx, config, false)
    51  	assert.Nil(err)
    52  	f.CloseFactory(ctx)
    53  	f, err = NewFactory(ctx, config, true)
    54  	assert.Nil(err)
    55  	f.CloseFactory(ctx)
    56  
    57  	// template
    58  	if os.Geteuid() != 0 {
    59  		t.Skip(testDisabledAsNonRoot)
    60  	}
    61  
    62  	config.Template = true
    63  	config.TemplatePath = fs.MockStorageRootPath()
    64  	f, err = NewFactory(ctx, config, false)
    65  	assert.Nil(err)
    66  	f.CloseFactory(ctx)
    67  	_, err = NewFactory(ctx, config, true)
    68  	assert.Error(err)
    69  
    70  	// Cache
    71  	config.Cache = 10
    72  	f, err = NewFactory(ctx, config, false)
    73  	assert.Nil(err)
    74  	f.CloseFactory(ctx)
    75  	_, err = NewFactory(ctx, config, true)
    76  	assert.Error(err)
    77  
    78  	config.Template = false
    79  	f, err = NewFactory(ctx, config, false)
    80  	assert.Nil(err)
    81  	f.CloseFactory(ctx)
    82  	_, err = NewFactory(ctx, config, true)
    83  	assert.Error(err)
    84  }
    85  
    86  func TestFactorySetLogger(t *testing.T) {
    87  	assert := assert.New(t)
    88  
    89  	testLog := logrus.WithFields(logrus.Fields{"testfield": "foobar"})
    90  	testLog.Level = logrus.DebugLevel
    91  	SetLogger(context.Background(), testLog)
    92  
    93  	var config Config
    94  	config.VMConfig.HypervisorConfig = vc.HypervisorConfig{
    95  		KernelPath: "foo",
    96  		ImagePath:  "bar",
    97  	}
    98  	ctx := context.Background()
    99  	vf, err := NewFactory(ctx, config, false)
   100  	assert.Nil(err)
   101  
   102  	f, ok := vf.(*factory)
   103  	assert.True(ok)
   104  
   105  	assert.Equal(f.log().Logger.Level, testLog.Logger.Level)
   106  }
   107  
   108  func TestVMConfigValid(t *testing.T) {
   109  	assert := assert.New(t)
   110  
   111  	defer fs.MockStorageDestroy()
   112  	config := vc.VMConfig{
   113  		HypervisorType: vc.MockHypervisor,
   114  		HypervisorConfig: vc.HypervisorConfig{
   115  			KernelPath: fs.MockStorageRootPath(),
   116  			ImagePath:  fs.MockStorageRootPath(),
   117  		},
   118  	}
   119  
   120  	f := factory{}
   121  
   122  	err := f.validateNewVMConfig(config)
   123  	assert.NotNil(err)
   124  
   125  	config.AgentType = vc.NoopAgentType
   126  	err = f.validateNewVMConfig(config)
   127  	assert.NotNil(err)
   128  
   129  	config.ProxyType = vc.NoopProxyType
   130  	err = f.validateNewVMConfig(config)
   131  	assert.Nil(err)
   132  }
   133  
   134  func TestCheckVMConfig(t *testing.T) {
   135  	assert := assert.New(t)
   136  
   137  	var config1, config2 vc.VMConfig
   138  
   139  	// default config should equal
   140  	err := checkVMConfig(config1, config2)
   141  	assert.Nil(err)
   142  
   143  	config1.HypervisorType = vc.MockHypervisor
   144  	err = checkVMConfig(config1, config2)
   145  	assert.Error(err)
   146  
   147  	config2.HypervisorType = vc.MockHypervisor
   148  	err = checkVMConfig(config1, config2)
   149  	assert.Nil(err)
   150  
   151  	config1.AgentType = vc.NoopAgentType
   152  	err = checkVMConfig(config1, config2)
   153  	assert.Error(err)
   154  
   155  	config2.AgentType = vc.NoopAgentType
   156  	err = checkVMConfig(config1, config2)
   157  	assert.Nil(err)
   158  
   159  	testDir := fs.MockStorageRootPath()
   160  	defer fs.MockStorageDestroy()
   161  
   162  	config1.HypervisorConfig = vc.HypervisorConfig{
   163  		KernelPath: testDir,
   164  		ImagePath:  testDir,
   165  	}
   166  	err = checkVMConfig(config1, config2)
   167  	assert.Error(err)
   168  
   169  	config2.HypervisorConfig = vc.HypervisorConfig{
   170  		KernelPath: testDir,
   171  		ImagePath:  testDir,
   172  	}
   173  	err = checkVMConfig(config1, config2)
   174  	assert.Nil(err)
   175  }
   176  
   177  func TestFactoryGetVM(t *testing.T) {
   178  	assert := assert.New(t)
   179  
   180  	testDir := fs.MockStorageRootPath()
   181  	defer fs.MockStorageDestroy()
   182  
   183  	hyperConfig := vc.HypervisorConfig{
   184  		KernelPath: testDir,
   185  		ImagePath:  testDir,
   186  	}
   187  	vmConfig := vc.VMConfig{
   188  		HypervisorType:   vc.MockHypervisor,
   189  		HypervisorConfig: hyperConfig,
   190  		AgentType:        vc.NoopAgentType,
   191  		ProxyType:        vc.NoopProxyType,
   192  	}
   193  
   194  	err := vmConfig.Valid()
   195  	assert.Nil(err)
   196  
   197  	ctx := context.Background()
   198  
   199  	// direct factory
   200  	if os.Geteuid() != 0 {
   201  		t.Skip(testDisabledAsNonRoot)
   202  	}
   203  
   204  	f, err := NewFactory(ctx, Config{VMConfig: vmConfig}, false)
   205  	assert.Nil(err)
   206  
   207  	vm, err := f.GetVM(ctx, vmConfig)
   208  	assert.Nil(err)
   209  
   210  	err = vm.Stop()
   211  	assert.Nil(err)
   212  
   213  	f.CloseFactory(ctx)
   214  
   215  	// template factory
   216  	f, err = NewFactory(ctx, Config{Template: true, TemplatePath: testDir, VMConfig: vmConfig}, false)
   217  	assert.Nil(err)
   218  
   219  	vm, err = f.GetVM(ctx, vmConfig)
   220  	assert.Nil(err)
   221  
   222  	err = vm.Stop()
   223  	assert.Nil(err)
   224  
   225  	f.CloseFactory(ctx)
   226  
   227  	// fetch template factory
   228  	f, err = NewFactory(ctx, Config{Template: true, TemplatePath: testDir, VMConfig: vmConfig}, false)
   229  	assert.Nil(err)
   230  
   231  	_, err = NewFactory(ctx, Config{Template: true, TemplatePath: testDir, VMConfig: vmConfig}, true)
   232  	assert.Error(err)
   233  
   234  	vm, err = f.GetVM(ctx, vmConfig)
   235  	assert.Nil(err)
   236  
   237  	err = vm.Stop()
   238  	assert.Nil(err)
   239  
   240  	f.CloseFactory(ctx)
   241  
   242  	// cache factory over direct factory
   243  	f, err = NewFactory(ctx, Config{Cache: 2, VMConfig: vmConfig}, false)
   244  	assert.Nil(err)
   245  
   246  	vm, err = f.GetVM(ctx, vmConfig)
   247  	assert.Nil(err)
   248  
   249  	err = vm.Stop()
   250  	assert.Nil(err)
   251  
   252  	f.CloseFactory(ctx)
   253  
   254  	// cache factory over template factory
   255  	f, err = NewFactory(ctx, Config{Template: true, TemplatePath: testDir, Cache: 2, VMConfig: vmConfig}, false)
   256  	assert.Nil(err)
   257  
   258  	vm, err = f.GetVM(ctx, vmConfig)
   259  	assert.Nil(err)
   260  
   261  	err = vm.Stop()
   262  	assert.Nil(err)
   263  
   264  	// CPU hotplug
   265  	vmConfig.HypervisorConfig.NumVCPUs++
   266  	vm, err = f.GetVM(ctx, vmConfig)
   267  	assert.Nil(err)
   268  
   269  	err = vm.Stop()
   270  	assert.Nil(err)
   271  
   272  	// Memory hotplug
   273  	vmConfig.HypervisorConfig.MemorySize += 128
   274  	vm, err = f.GetVM(ctx, vmConfig)
   275  	assert.Nil(err)
   276  
   277  	err = vm.Stop()
   278  	assert.Nil(err)
   279  
   280  	// checkConfig fall back
   281  	vmConfig.HypervisorConfig.Mlock = true
   282  	vm, err = f.GetVM(ctx, vmConfig)
   283  	assert.Nil(err)
   284  
   285  	err = vm.Stop()
   286  	assert.Nil(err)
   287  
   288  	f.CloseFactory(ctx)
   289  }
   290  
   291  func TestDeepCompare(t *testing.T) {
   292  	assert := assert.New(t)
   293  
   294  	foo := vc.VMConfig{}
   295  	bar := vc.VMConfig{}
   296  	assert.True(utils.DeepCompare(foo, bar))
   297  
   298  	foo.HypervisorConfig.NumVCPUs = 1
   299  	assert.False(utils.DeepCompare(foo, bar))
   300  	bar.HypervisorConfig.NumVCPUs = 1
   301  	assert.True(utils.DeepCompare(foo, bar))
   302  
   303  	// slice
   304  	foo.HypervisorConfig.KernelParams = []vc.Param{}
   305  	assert.True(utils.DeepCompare(foo, bar))
   306  	foo.HypervisorConfig.KernelParams = append(foo.HypervisorConfig.KernelParams, vc.Param{Key: "key", Value: "value"})
   307  	assert.False(utils.DeepCompare(foo, bar))
   308  	bar.HypervisorConfig.KernelParams = append(bar.HypervisorConfig.KernelParams, vc.Param{Key: "key", Value: "value"})
   309  	assert.True(utils.DeepCompare(foo, bar))
   310  
   311  	// map
   312  	var fooMap map[string]vc.VMConfig
   313  	var barMap map[string]vc.VMConfig
   314  	assert.False(utils.DeepCompare(foo, fooMap))
   315  	assert.True(utils.DeepCompare(fooMap, barMap))
   316  	fooMap = make(map[string]vc.VMConfig)
   317  	assert.True(utils.DeepCompare(fooMap, barMap))
   318  	fooMap["foo"] = foo
   319  	assert.False(utils.DeepCompare(fooMap, barMap))
   320  	barMap = make(map[string]vc.VMConfig)
   321  	assert.False(utils.DeepCompare(fooMap, barMap))
   322  	barMap["foo"] = bar
   323  	assert.True(utils.DeepCompare(fooMap, barMap))
   324  
   325  	// invalid interface
   326  	var f1 vc.Factory
   327  	var f2 vc.Factory
   328  	var f3 base.FactoryBase
   329  	assert.True(utils.DeepCompare(f1, f2))
   330  	assert.True(utils.DeepCompare(f1, f3))
   331  
   332  	// valid interface
   333  	var config Config
   334  	var err error
   335  	ctx := context.Background()
   336  	config.VMConfig = vc.VMConfig{
   337  		HypervisorType: vc.MockHypervisor,
   338  		AgentType:      vc.NoopAgentType,
   339  		ProxyType:      vc.NoopProxyType,
   340  	}
   341  	testDir := fs.MockStorageRootPath()
   342  	defer fs.MockStorageDestroy()
   343  
   344  	config.VMConfig.HypervisorConfig = vc.HypervisorConfig{
   345  		KernelPath: testDir,
   346  		ImagePath:  testDir,
   347  	}
   348  	f1, err = NewFactory(ctx, config, false)
   349  	assert.Nil(err)
   350  	assert.True(utils.DeepCompare(f1, f1))
   351  	f2, err = NewFactory(ctx, config, false)
   352  	assert.Nil(err)
   353  	assert.False(utils.DeepCompare(f1, f2))
   354  }