isula-build: disable config path setting by users

reason:
Config path could be set by users before,
we change the rule now to avoid unnecessary settings,
which makes config easier and more clearly.
All the config files could only in directory "/etc/isula-build/".
Signed-off-by: Nxiadanni <xiadanni1@huawei.com>

builder/dockerfile/stage_builder_test.go

@@ -32,7 +32,6 @@ import (
 
 	constant "isula.org/isula-build"
 	dockerfile "isula.org/isula-build/builder/dockerfile/parser"
-	"isula.org/isula-build/image"
 	"isula.org/isula-build/pkg/docker"
 	"isula.org/isula-build/pkg/logger"
 	"isula.org/isula-build/pkg/parser"
@@ -202,9 +201,9 @@ CMD ["sh"]`
 				builder:   getBuilder(),
 				fromImage: "",
 				buildOpt: &stageBuilderOption{systemContext: &types.SystemContext{
-					SignaturePolicyPath:      image.DefaultSignaturePolicyPath,
-					SystemRegistriesConfPath: image.DefaultRegistryConfigPath,
-					RegistriesDirPath:        image.DefaultRegistryDirPath,
+					SignaturePolicyPath:      constant.SignaturePolicyPath,
+					SystemRegistriesConfPath: constant.RegistryConfigPath,
+					RegistriesDirPath:        constant.RegistryDirPath,
 				}},
 				rawStage: generateOneRawStage(t, contentJustForFillLog),
 			},
@@ -217,9 +216,9 @@ CMD ["sh"]`
 				builder:   getBuilder(),
 				fromImage: filepath.Join(testUtil.DefaultTestRegistry, getImageDesc()),
 				buildOpt: &stageBuilderOption{systemContext: &types.SystemContext{
-					SignaturePolicyPath:      image.DefaultSignaturePolicyPath,
-					SystemRegistriesConfPath: image.DefaultRegistryConfigPath,
-					RegistriesDirPath:        image.DefaultRegistryDirPath,
+					SignaturePolicyPath:      constant.SignaturePolicyPath,
+					SystemRegistriesConfPath: constant.RegistryConfigPath,
+					RegistriesDirPath:        constant.RegistryDirPath,
 				}},
 				rawStage: generateOneRawStage(t, contentJustForFillLog),
 			},
@@ -234,9 +233,9 @@ CMD ["sh"]`
 				name:    "stage3",
 				builder: getBuilder(),
 				buildOpt: &stageBuilderOption{systemContext: &types.SystemContext{
-					SignaturePolicyPath:      image.DefaultSignaturePolicyPath,
-					SystemRegistriesConfPath: image.DefaultRegistryConfigPath,
-					RegistriesDirPath:        image.DefaultRegistryDirPath,
+					SignaturePolicyPath:      constant.SignaturePolicyPath,
+					SystemRegistriesConfPath: constant.RegistryConfigPath,
+					RegistriesDirPath:        constant.RegistryDirPath,
 				}},
 				rawStage: generateOneRawStage(t, contentJustForFillLog),
 			},
@@ -251,9 +250,9 @@ CMD ["sh"]`
 				builder:   getBuilder(),
 				fromImage: filepath.Join(testUtil.DefaultTestRegistry, getImageDesc()),
 				buildOpt: &stageBuilderOption{systemContext: &types.SystemContext{
-					SignaturePolicyPath:      image.DefaultSignaturePolicyPath,
-					SystemRegistriesConfPath: image.DefaultRegistryConfigPath,
-					RegistriesDirPath:        image.DefaultRegistryDirPath,
+					SignaturePolicyPath:      constant.SignaturePolicyPath,
+					SystemRegistriesConfPath: constant.RegistryConfigPath,
+					RegistriesDirPath:        constant.RegistryDirPath,
 				}},
 				rawStage: generateOneRawStage(t, contentJustForFillLog),
 			},
@@ -270,9 +269,9 @@ CMD ["sh"]`
 				// NOTE:If the digest changes, the test case fails to be executed.
 				fromImage: filepath.Join(testUtil.DefaultTestRegistry, getImageDigest()),
 				buildOpt: &stageBuilderOption{systemContext: &types.SystemContext{
-					SignaturePolicyPath:      image.DefaultSignaturePolicyPath,
-					SystemRegistriesConfPath: image.DefaultRegistryConfigPath,
-					RegistriesDirPath:        image.DefaultRegistryDirPath,
+					SignaturePolicyPath:      constant.SignaturePolicyPath,
+					SystemRegistriesConfPath: constant.RegistryConfigPath,
+					RegistriesDirPath:        constant.RegistryDirPath,
 				}},
 				rawStage: generateOneRawStage(t, contentJustForFillLog),
 			},
@@ -286,9 +285,9 @@ CMD ["sh"]`
 				builder:   getBuilder(),
 				fromImage: filepath.Join(testUtil.DefaultTestRegistry, "busybox@sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"),
 				buildOpt: &stageBuilderOption{systemContext: &types.SystemContext{
-					SignaturePolicyPath:      image.DefaultSignaturePolicyPath,
-					SystemRegistriesConfPath: image.DefaultRegistryConfigPath,
-					RegistriesDirPath:        image.DefaultRegistryDirPath,
+					SignaturePolicyPath:      constant.SignaturePolicyPath,
+					SystemRegistriesConfPath: constant.RegistryConfigPath,
+					RegistriesDirPath:        constant.RegistryDirPath,
 				}},
 				rawStage: generateOneRawStage(t, contentJustForFillLog),
 			},
@@ -302,8 +301,8 @@ CMD ["sh"]`
 				builder:   getBuilder(),
 				fromImage: filepath.Join(testUtil.DefaultTestRegistry, "busybox:aaaaaaaaaaa"),
 				buildOpt: &stageBuilderOption{systemContext: &types.SystemContext{
-					SignaturePolicyPath:      image.DefaultSignaturePolicyPath,
-					SystemRegistriesConfPath: image.DefaultRegistryConfigPath,
+					SignaturePolicyPath:      constant.SignaturePolicyPath,
+					SystemRegistriesConfPath: constant.RegistryConfigPath,
 				}},
 				rawStage: generateOneRawStage(t, contentJustForFillLog),
 			},
@@ -317,9 +316,9 @@ CMD ["sh"]`
 				builder:   getBuilder(),
 				fromImage: "scratch",
 				buildOpt: &stageBuilderOption{systemContext: &types.SystemContext{
-					SignaturePolicyPath:      image.DefaultSignaturePolicyPath,
-					SystemRegistriesConfPath: image.DefaultRegistryConfigPath,
-					RegistriesDirPath:        image.DefaultRegistryDirPath,
+					SignaturePolicyPath:      constant.SignaturePolicyPath,
+					SystemRegistriesConfPath: constant.RegistryConfigPath,
+					RegistriesDirPath:        constant.RegistryDirPath,
 				}},
 				rawStage: generateOneRawStage(t, contentJustForFillLog),
 			},

cmd/daemon/config/config.go

@@ -14,23 +14,11 @@
 // Package config package implements isula-build daemon config
 package config
 
-// TomlConfig defines the configuration of isula-builder, it will work
-// if the daemon starts with "--config path" and the file exists
+// TomlConfig defines the configuration of isula-builder
 type TomlConfig struct {
 	Debug    bool   `toml:"debug"`
 	LogLevel string `toml:"loglevel"`
 	Runtime  string `toml:"runtime"`
 	RunRoot  string `toml:"run_root"`
 	DataRoot string `toml:"data_root"`
-	Storage  storage
-	Image    image
-}
-
-type storage struct {
-	ConfigPath string `toml:"storage_config_path"`
-}
-
-type image struct {
-	RegistryConfigPath  string `toml:"registry_config_path"`
-	SignaturePolicyPath string `toml:"signature_policy_path"`
 }

cmd/daemon/config/configuration.toml

@@ -24,17 +24,3 @@ data_root = "/var/lib/isula-build/"
 
 # Default "runc" found in $PATH
 runtime = ""
-
-[storage]
-# Default config path for containers/storage library
-# See "storage.toml" for details
-storage_config_path = "/etc/isula-build/storage.toml"
-
-[image]
-# Default config path for containers/image library
-# See "registries.toml" for details
-registry_config_path = "/etc/isula-build/registries.toml"
-
-# Syntax for the signature verification policy file
-# See "github.com/containers/image/docs" for details
-signature_policy_path = "/etc/isula-build/policy.json"

cmd/daemon/main.go

@@ -36,8 +36,6 @@ import (
 	"isula.org/isula-build/util"
 )
 
-const defaultConfigPath = "/etc/isula-build/configuration.toml"
-
 var daemonOpts daemon.Options
 
 func newDaemonCommand() *cobra.Command {
@@ -53,7 +51,6 @@ func newDaemonCommand() *cobra.Command {
 		SilenceErrors: true,
 		Version:       fmt.Sprintf("%s, build %s", version.Version, version.GitCommit),
 	}
-	rootCmd.PersistentFlags().StringVarP(&daemonOpts.ConfigFile, "config", "c", defaultConfigPath, "Config file path")
 	rootCmd.PersistentFlags().BoolVarP(&daemonOpts.Debug, "debug", "D", false, "Open debug mode")
 	rootCmd.PersistentFlags().StringVar(&daemonOpts.DataRoot, "dataroot", constant.DefaultDataRoot, "Persistent dir")
 	rootCmd.PersistentFlags().StringVar(&daemonOpts.RunRoot, "runroot", constant.DefaultRunRoot, "Runtime dir")
@@ -138,38 +135,29 @@ func before(cmd *cobra.Command) error {
 
 	logrus.SetOutput(os.Stdout)
 	logrus.SetFormatter(&logrus.TextFormatter{FullTimestamp: true})
-	if daemonOpts.RunRoot == daemonOpts.DataRoot {
-		return errors.Errorf("runroot(%q) and dataroot(%q) must be different paths", daemonOpts.RunRoot, daemonOpts.DataRoot)
-	}
 
-	configPath := cmd.Flag("config").Value.String()
 	store.SetDefaultStoreOptions(store.DaemonStoreOptions{
 		RunRoot:      filepath.Join(daemonOpts.RunRoot, "storage"),
 		DataRoot:     filepath.Join(daemonOpts.DataRoot, "storage"),
 		Driver:       daemonOpts.StorageDriver,
 		DriverOption: util.CopyStrings(daemonOpts.StorageOpts),
 	})
-	if !util.IsExist(configPath) {
-		logrus.Warnf("Main config file missing, the default configuration is used")
-	} else {
-		conf, err := loadConfig(configPath)
-		if err != nil {
-			logrus.Errorf("Load and parse main config file failed: %v", err)
-			os.Exit(constant.DefaultFailedCode)
-		}
 
-		mergeConfig(conf, cmd)
+	if err := checkAndValidateConfig(cmd); err != nil {
+		return err
 	}
 
 	if err := initLogging(); err != nil {
 		return err
 	}
 
-	image.SetSystemContext()
+	if err := setupWorkingDirectories(); err != nil {
+		return err
+	}
 
-	workDirs := []string{daemonOpts.DataRoot, daemonOpts.RunRoot}
+	image.SetSystemContext(daemonOpts.DataRoot)
 
-	return setupWorkingDirectories(workDirs)
+	return nil
 }
 
 func loadConfig(path string) (config.TomlConfig, error) {
@@ -192,17 +180,11 @@ func loadConfig(path string) (config.TomlConfig, error) {
 	}
 	_, err = toml.Decode(string(configData), &conf)
 
-	if err = checkFilesInConf(conf); err != nil {
-		return conf, err
-	}
-
 	return conf, err
 }
 
-func mergeStorageConfig(conf config.TomlConfig, cmd *cobra.Command) {
-	if conf.Storage.ConfigPath != "" {
-		store.SetDefaultConfigFilePath(conf.Storage.ConfigPath)
-	}
+func mergeStorageConfig(cmd *cobra.Command) {
+	store.SetDefaultConfigFilePath(constant.StorageConfigPath)
 	option, err := store.GetDefaultStoreOptions(true)
 	if err == nil {
 		if option.GraphDriverName != "" && !cmd.Flag("storage-driver").Changed {
@@ -229,15 +211,6 @@ func mergeStorageConfig(conf config.TomlConfig, cmd *cobra.Command) {
 	store.SetDefaultStoreOptions(storeOpt)
 }
 
-func mergeImageConfig(conf config.TomlConfig) {
-	if conf.Image.RegistryConfigPath != "" {
-		image.DefaultRegistryConfigPath = conf.Image.RegistryConfigPath
-	}
-	if conf.Image.SignaturePolicyPath != "" {
-		image.DefaultSignaturePolicyPath = conf.Image.SignaturePolicyPath
-	}
-}
-
 func mergeConfig(conf config.TomlConfig, cmd *cobra.Command) {
 	if strconv.FormatBool(conf.Debug) == "true" && !cmd.Flag("debug").Changed {
 		daemonOpts.Debug = true
@@ -256,12 +229,14 @@ func mergeConfig(conf config.TomlConfig, cmd *cobra.Command) {
 	if conf.DataRoot != "" && !cmd.Flag("dataroot").Changed {
 		daemonOpts.DataRoot = conf.DataRoot
 	}
-
-	mergeStorageConfig(conf, cmd)
-	mergeImageConfig(conf)
 }
 
-func setupWorkingDirectories(dirs []string) error {
+func setupWorkingDirectories() error {
+	if daemonOpts.RunRoot == daemonOpts.DataRoot {
+		return errors.Errorf("runroot(%q) and dataroot(%q) must be different paths", daemonOpts.RunRoot, daemonOpts.DataRoot)
+	}
+
+	dirs := []string{daemonOpts.DataRoot, daemonOpts.RunRoot}
 	for _, dir := range dirs {
 		if !filepath.IsAbs(dir) {
 			return errors.Errorf("%q not an absolute dir, the \"dataroot\" and \"runroot\" must be an absolute path", dir)
@@ -281,21 +256,36 @@ func setupWorkingDirectories(dirs []string) error {
 	return nil
 }
 
-func checkFilesInConf(conf config.TomlConfig) error {
-	confFiles := []string{conf.Storage.ConfigPath, conf.Image.RegistryConfigPath, conf.Image.SignaturePolicyPath}
-	for _, file := range confFiles {
-		if file != "" {
-			if !filepath.IsAbs(file) {
-				return errors.Errorf("file path %q in configuration is not an absolute path", file)
-			}
+func checkAndValidateConfig(cmd *cobra.Command) error {
+	// check if configuration.toml file exists, merge config if exists
+	if !util.IsExist(constant.ConfigurationPath) {
+		logrus.Warnf("Main config file missing, the default configuration is used")
+	} else {
+		conf, err := loadConfig(constant.ConfigurationPath)
+		if err != nil {
+			logrus.Errorf("Load and parse main config file failed: %v", err)
+			os.Exit(constant.DefaultFailedCode)
+		}
+
+		mergeConfig(conf, cmd)
+	}
 
+	// file policy.json must be exist
+	if !util.IsExist(constant.SignaturePolicyPath) {
+		return errors.Errorf("policy config file %v is not exist", constant.SignaturePolicyPath)
+	}
+
+	// check all config files
+	confFiles := []string{constant.RegistryConfigPath, constant.SignaturePolicyPath, constant.StorageConfigPath}
+	for _, file := range confFiles {
+		if util.IsExist(file) {
 			fi, err := os.Stat(file)
 			if err != nil {
-				return errors.Wrapf(err, "stat file %q in configuration failed", file)
+				return errors.Wrapf(err, "stat file %q failed", file)
 			}
 
 			if !fi.Mode().IsRegular() {
-				return errors.Errorf("file %s in configuration should be a regular file", fi.Name())
+				return errors.Errorf("file %s should be a regular file", fi.Name())
 			}
 
 			if err := util.CheckFileSize(file, constant.MaxFileSize); err != nil {
@@ -304,5 +294,10 @@ func checkFilesInConf(conf config.TomlConfig) error {
 		}
 	}
 
+	// if storage config file exists, merge storage config
+	if util.IsExist(constant.StorageConfigPath) {
+		mergeStorageConfig(cmd)
+	}
+
 	return nil
 }

cmd/daemon/main_test.go

@@ -21,19 +21,18 @@ import (
 	"gotest.tools/fs"
 
 	constant "isula.org/isula-build"
-	"isula.org/isula-build/daemon"
 )
 
 func TestSetupWorkingDirectories(t *testing.T) {
 	var testDir *fs.Dir
 	var testcases = []struct {
 		name        string
-		prepareFunc func(t *testing.T, daemonOpts *daemon.Options)
+		prepareFunc func(t *testing.T)
 		wantErr     bool
 	}{
 		{
 			name: "TC1 - normal - new env",
-			prepareFunc: func(t *testing.T, daemonOpts *daemon.Options) {
+			prepareFunc: func(t *testing.T) {
 				testDir = fs.NewDir(t, "TestSetupWorkingDirectories")
 				daemonOpts.DataRoot = testDir.Join("data")
 				daemonOpts.RunRoot = testDir.Join("run")
@@ -42,7 +41,7 @@ func TestSetupWorkingDirectories(t *testing.T) {
 		},
 		{
 			name: "TC2 - normal - already exist",
-			prepareFunc: func(t *testing.T, daemonOpts *daemon.Options) {
+			prepareFunc: func(t *testing.T) {
 				testDir = fs.NewDir(t, "TestSetupWorkingDirectories")
 				daemonOpts.DataRoot = testDir.Join("data")
 				daemonOpts.RunRoot = testDir.Join("run")
@@ -53,7 +52,7 @@ func TestSetupWorkingDirectories(t *testing.T) {
 		},
 		{
 			name: "TC3 - abnormal - exist file with same name",
-			prepareFunc: func(t *testing.T, daemonOpts *daemon.Options) {
+			prepareFunc: func(t *testing.T) {
 				testDir = fs.NewDir(t, "TestSetupWorkingDirectories")
 				daemonOpts.DataRoot = testDir.Join("data")
 				daemonOpts.RunRoot = testDir.Join("run")
@@ -64,7 +63,7 @@ func TestSetupWorkingDirectories(t *testing.T) {
 		},
 		{
 			name: "TC4 - abnormal - exist file with same name 2",
-			prepareFunc: func(t *testing.T, daemonOpts *daemon.Options) {
+			prepareFunc: func(t *testing.T) {
 				testDir = fs.NewDir(t, "TestSetupWorkingDirectories")
 				daemonOpts.DataRoot = testDir.Join("data")
 				daemonOpts.RunRoot = testDir.Join("run")
@@ -75,7 +74,7 @@ func TestSetupWorkingDirectories(t *testing.T) {
 		},
 		{
 			name: "TC5 - abnormal - exist file with same name 3",
-			prepareFunc: func(t *testing.T, daemonOpts *daemon.Options) {
+			prepareFunc: func(t *testing.T) {
 				testDir = fs.NewDir(t, "TestSetupWorkingDirectories")
 				daemonOpts.DataRoot = testDir.Join("data")
 				daemonOpts.RunRoot = testDir.Join("run")
@@ -86,7 +85,7 @@ func TestSetupWorkingDirectories(t *testing.T) {
 		},
 		{
 			name: "TC6 - abnormal - Relative path",
-			prepareFunc: func(t *testing.T, daemonOpts *daemon.Options) {
+			prepareFunc: func(t *testing.T) {
 				daemonOpts.DataRoot = "foo/bar"
 				daemonOpts.RunRoot = "foo/bar"
 			},
@@ -95,12 +94,10 @@ func TestSetupWorkingDirectories(t *testing.T) {
 	}
 	for _, tt := range testcases {
 		t.Run(tt.name, func(t *testing.T) {
-			d := &daemon.Options{}
-			tt.prepareFunc(t, d)
+			tt.prepareFunc(t)
 			defer testDir.Remove()
 
-			dirs := []string{d.RunRoot, d.DataRoot}
-			if err := setupWorkingDirectories(dirs); (err != nil) != tt.wantErr {
+			if err := setupWorkingDirectories(); (err != nil) != tt.wantErr {
 				t.Errorf("testing failed! err = %v, wantErr = %v", err, tt.wantErr)
 			}
 		})

constant.go

@@ -17,6 +17,18 @@ package constant
 import "time"
 
 const (
+	// ConfigurationPath is isula-build configuration path
+	ConfigurationPath = "/etc/isula-build/configuration.toml"
+	// RegistryConfigPath describes the config path of registries
+	RegistryConfigPath = "/etc/isula-build/registries.toml"
+	// SignaturePolicyPath describes the policy path
+	SignaturePolicyPath = "/etc/isula-build/policy.json"
+	// StorageConfigPath describes the storage path
+	StorageConfigPath = "/etc/isula-build/storage.toml"
+	// RegistryDirPath is the dir to store registry configs
+	RegistryDirPath = "/etc/isula-build/registries.d"
+	// AuthFilePath is authentication file used for registry connection
+	AuthFilePath = "/etc/isula-build/auth.json"
 	// DefaultGRPCAddress is the local unix socket used by isula-builder
 	DefaultGRPCAddress = "unix:///var/run/isula_build.sock"
 	// UnixPrefix is the prefix used on defined an unix sock
@@ -53,10 +65,8 @@ const (
 	DefaultCertRoot = "/etc/isula-build/certs.d"
 	// LayoutTime is the time format used to parse time from a string
 	LayoutTime = "2006-01-02 15:04:05"
-
 	// BuildContainerImageType is the default build type
 	BuildContainerImageType = "ctr-img"
-
 	// BufferSize is default buffer size for file transportation
 	BufferSize = 32 * 1024
 )

daemon/daemon.go

@@ -40,7 +40,6 @@ const lockFileName = "isula-builder.lock"
 
 // Options carries the options configured to daemon
 type Options struct {
-	ConfigFile    string
 	Debug         bool
 	LogLevel      string
 	DataRoot      string

daemon/login.go

@@ -62,7 +62,7 @@ func (b *Backend) Login(ctx context.Context, req *pb.LoginRequest) (*pb.LoginRes
 	auth, err := config.GetCredentials(sysCtx, req.Server)
 	if err != nil {
 		auth = types.DockerAuthConfig{}
-		return &pb.LoginResponse{Content: err.Error()}, errors.Wrapf(err, "failed to read auth file %v", image.DefaultAuthFile)
+		return &pb.LoginResponse{Content: err.Error()}, errors.Wrapf(err, "failed to read auth file %v", constant.AuthFilePath)
 	}
 
 	usernameFromAuth, passwordFromAuth := auth.Username, auth.Password

image/context.go

@@ -34,9 +34,9 @@ var (
 
 func init() {
 	globalSystemContext = types.SystemContext{
-		SignaturePolicyPath:         DefaultSignaturePolicyPath,
-		SystemRegistriesConfDirPath: DefaultRegistryConfigPath,
-		RegistriesDirPath:           DefaultRegistryDirPath,
+		SignaturePolicyPath:         constant.SignaturePolicyPath,
+		SystemRegistriesConfDirPath: constant.RegistryConfigPath,
+		RegistriesDirPath:           constant.RegistryDirPath,
 	}
 }
 
@@ -61,18 +61,18 @@ func validateConfigFiles(configs []string) error {
 }
 
 // SetSystemContext set the values of globalSystemContext
-func SetSystemContext() {
-	err := validateConfigFiles([]string{DefaultSignaturePolicyPath, DefaultRegistryConfigPath})
+func SetSystemContext(dataRoot string) {
+	err := validateConfigFiles([]string{constant.SignaturePolicyPath, constant.RegistryConfigPath})
 	if err != nil {
 		logrus.Fatal(err)
 	}
 
 	once.Do(func() {
-		globalSystemContext.SignaturePolicyPath = DefaultSignaturePolicyPath
-		globalSystemContext.SystemRegistriesConfPath = DefaultRegistryConfigPath
-		globalSystemContext.RegistriesDirPath = DefaultRegistryDirPath
-		globalSystemContext.BlobInfoCacheDir = DefaultBlobInfoCacheDirPath
-		globalSystemContext.AuthFilePath = DefaultAuthFile
+		globalSystemContext.SignaturePolicyPath = constant.SignaturePolicyPath
+		globalSystemContext.SystemRegistriesConfPath = constant.RegistryConfigPath
+		globalSystemContext.RegistriesDirPath = constant.RegistryDirPath
+		globalSystemContext.BlobInfoCacheDir = dataRoot
+		globalSystemContext.AuthFilePath = constant.AuthFilePath
 	})
 }
 

image/context_test.go

@@ -18,6 +18,8 @@ import (
 	"os"
 	"os/exec"
 	"testing"
+
+	constant "isula.org/isula-build"
 )
 
 func doCmd(cmd string) {
@@ -96,10 +98,11 @@ func TestSetSystemContext(t *testing.T) {
 		}
 	}
 
-	prepareFunc(DefaultSignaturePolicyPath)
-	prepareFunc(DefaultRegistryConfigPath)
+	prepareFunc(constant.SignaturePolicyPath)
+	prepareFunc(constant.RegistryConfigPath)
+	dataRoot := constant.DefaultDataRoot
 
-	SetSystemContext()
+	SetSystemContext(dataRoot)
 }
 
 func TestGetSystemContext(t *testing.T) {

image/image.go

@@ -48,23 +48,6 @@ import (
 	"isula.org/isula-build/util"
 )
 
-var (
-	// DefaultRegistryConfigPath describes the config path of registries
-	DefaultRegistryConfigPath = "/etc/isula-build/registries.toml"
-
-	// DefaultSignaturePolicyPath describes the policy path
-	DefaultSignaturePolicyPath = "/etc/isula-build/policy.json"
-
-	// DefaultRegistryDirPath is the dir to store registry configs
-	DefaultRegistryDirPath = "/etc/isula-build/registries.d"
-
-	// DefaultBlobInfoCacheDirPath is the dir to cache blob info
-	DefaultBlobInfoCacheDirPath = "/var/lib/isula-build"
-
-	// DefaultAuthFile is authentication file used for registry connection
-	DefaultAuthFile = "/etc/isula-build/auth.json"
-)
-
 // PrepareImageOptions describes the options required for preparing the image
 type PrepareImageOptions struct {
 	SystemContext *types.SystemContext