Beispiel #1
0
// depends on initConfig()
func (this *runner) initStorage() error {
	var err error
	this.storage, err = historystorage.New(this.config.GetString("storageType"), this.storageDirPath)
	if err != nil {
		return err
	}
	this.storage.Init()
	this.workingDirPath = this.storage.CreateNewWorkingDir()
	this.materialsDirPath = path.Join(this.storageDirPath, storageMaterialsPath)
	return nil
}
Beispiel #2
0
// FIXME: refactor
func _init(args []string) int {
	if err := initFlagset.Parse(args); err != nil {
		fmt.Printf("%s", err.Error())
		return 1
	}

	if initFlagset.NArg() != 3 {
		fmt.Printf("specify <config file path> <materials dir path> <storage dir path>\n")
		return 1
	}

	confPath := initFlagset.Arg(0)
	materials := initFlagset.Arg(1)
	storagePath := initFlagset.Arg(2)

	cfi, err := os.Stat(confPath)
	if err != nil {
		fmt.Printf("failed to stat path: %s (%s)\n", confPath, err)
		return 1
	}

	if !cfi.Mode().IsRegular() {
		fmt.Printf("config file (%s) must be a regular file\n", confPath)
		return 1
	}
	if _initFlags.Force {
		// avoid catastrophe caused by a typo
		wellKnownDirs := map[string]bool{
			".": true, "..": true, "/": true, "/home": true, "/tmp": true, "/dummyWellKnownDir": true}
		if wellKnownDirs[storagePath] {
			fmt.Printf("storage dir(%s) typo?\n", storagePath)
			return 1
		}
		if err = os.RemoveAll(storagePath); err != nil {
			// NOTE: if storagePath does not exist, RemoveAll returns nil
			fmt.Printf("could not remove %s (%s)\n", storagePath, err)
			return 1
		}
		if err = os.Mkdir(storagePath, 0777); err != nil {
			fmt.Printf("could not create %s (%s)\n", storagePath, err)
			return 1
		}
	}

	sfi, err := os.Stat(storagePath)
	if err != nil {
		fmt.Printf("failed to stat path: %s (%s)\n", storagePath, err)
		return 1
	}

	if !sfi.Mode().IsDir() {
		fmt.Printf("storagePath directory (%s) must be a directory\n", storagePath)
		return 1
	}

	dir, err := os.Open(storagePath)
	if err != nil {
		fmt.Printf("failed to open storagePath directory: %s (%s)\n", storagePath, err)
		return 1
	}

	fi, err := dir.Readdir(0)
	if err != nil {
		fmt.Printf("failed to read storagePath directory: %s (%s)\n", storagePath, err)
		return 1
	}

	if len(fi) != 0 {
		fmt.Printf("directory for earthquake storagePath (%s) must be empty\n", storagePath)
		return 1
	}

	cfg, err := config.NewFromFile(confPath)
	if err != nil {
		fmt.Printf("parsing config file (%s) failed: %s\n", confPath, err)
		return 1
	}

	if !strings.EqualFold(filepath.Ext(confPath), ".toml") {
		fmt.Printf("this version does not support non-TOML configs")
		return 1
	}
	err = copyFile(path.Join(storagePath, historystorage.StorageTOMLConfigPath), confPath, 0644)
	if err != nil {
		fmt.Printf("placing config file (%s) failed (%s)\n", confPath, err)
		return 1
	}

	materialsDir := path.Join(storagePath, storageMaterialsPath)
	err = os.Mkdir(materialsDir, 0777)
	if err != nil {
		fmt.Printf("creating a directory for materials (%s) failed (%s)\n",
			materialsDir, err)
		return 1
		// TODO: cleaning conf file
	}
	cmd.DefaultFactory.SetMaterialsDir(materialsDir)

	err = recursiveHardLink(materials, materialsDir)
	if err != nil {
		fmt.Printf("%s\n", err)
		return 1
	}

	storage, err := historystorage.New(cfg.GetString("storageType"), storagePath)
	if err != nil {
		fmt.Printf("%s\n", err)
		return 1
	}
	storage.CreateStorage()

	if cfg.GetString("init") != "" {
		initScriptPath := path.Join(materialsDir, cfg.GetString("init"))
		runCmd := cmd.DefaultFactory.CreateCmd(initScriptPath)
		if err = runCmd.Run(); err != nil {
			fmt.Printf("could not run %s (%s)\n", initScriptPath, err)
			return 1
		}
	}
	fmt.Printf("ok\n")
	return 0
}