Esempio n. 1
0
// Exists checks for codebase existence by using the basic pkg rev Exists()
// routine to see if the specified codebase (at any specified rev, or from
// the default VCS rev) can be found.  If so it'll return the fullest URI
// it can to that codebase pkg repo, otherwise an error is returned.
// Config file and env var settings can help to find the codebase, ie:
// * DVLN_CODEBASE_PATH in env or codebase_path in cfg file
// -  > space separated list of paths to prepend to the codebase name
// -  > eg: "github.com/dvln git+ssh://host.com/path/to/clones /some/local/dir"
// -     - note: 'hub' and 'hub:<uri>' reserved for future user/central dvln hub
// -  > all values are *always* forward slash regardless of platform
// -  > 'dvln' as the codebase would result in looking, in order, here:
// -     > "github.com/dvln/dvln[.git]"
// -     > "git+ssh://host.com/clone/path/dvln[.git]"
// -     > "/some/local/dir/dvln[.git]"
// -     > "dvln"
// -  > final fallback will be on the individual dvln itself
// Based on the above existence checks it'll return:
// - string: URI: full path (on filesystem) or URL (if remote), "" if not found
// - locality: where it exists (LocalDir, RemoteURL, NonExistent)
// - error: any error that is detected in scanning for the workspace
func (cb *Defn) Exists(codebaseVerSel string) (string, Locality, error) {
	//eriknow, make some choices around codebase existence checks...
	//         should be a challenge, that's for sure
	var err error
	exists := false
	if codebaseVerSel != "" {
		exists, err = file.Exists(codebaseVerSel)
	}
	wkspcRootDir := ""
	if !exists {
		wkspcRootDir = globs.GetString("wkspcRootDir")
	}
	if wkspcRootDir == "" {
		wkspcRootDir = globs.GetString("dvlnCfgDir")
	}
	if codebaseVerSel == "" || !exists || err != nil {
		if err == nil {
			out.Debugln("No codebase file to read, skipping (considered normal)")
		} else {
			out.Debugf("No codebase file to read, skipping (abnormal, unexpected err: %s)\n", err)
		}
		return "", NonExistent, err
	}
	return codebaseVerSel, LocalDir, nil
}
Esempio n. 2
0
File: wkspc.go Progetto: dvln/wkspc
// RootDir will return the path to the top-most workspace root directory
// based on our current path unless a "starting directory" path is given
// (all other params are ignored).  It will return the path to the
// workspace root if it found one, otherwise "" (a non-nil error implies
// there was an unexpected problem... ie: not being able to find a workspace
// root directory is NOT an error condition).  Note: if you wish to bypass
// cached workspace root info then use RootDirFind() directly instead.
func RootDir(path ...string) (string, error) {
	// wkspcRootDir starts out as "none", if something else we've calc'd it..
	wkspcRootDir := globs.GetString("wkspcrootDir")
	if wkspcRootDir != "none" {
		return wkspcRootDir, nil
	}
	// otherwise find it (this will always try and find it and cache it)
	return RootDirFind(path...)
}
Esempio n. 3
0
File: wkspc.go Progetto: dvln/wkspc
// SetRootDir will set the given dir as the workspace root directory, it will also
// set some "derived" settings in globs (viper) such as:
//   wkspcMetaDir:    $wsroot/.dvln
//   wkspcLogDir:     $wsroot/.dvln/log
//   wkspcTmpDir:     $wsroot/.dvln/tmp
//   wkspcVCSDir:     $wsroot/.dvln/vcs
//   wkspcVCSDataDir: $wsroot/.dvln/vcs/wkspc
//   wkspcDBDir:      $wsroot/.dvln/db
//   wkspcDB:         $wsroot/.dvln/db/wkspc.db
// As other dirs or files are added relative to the .dvln/ wkspc meta-data dir
// they can be added here to "bootstap" them.  Note that if
func SetRootDir(rootDir string) error {
	if rootDir == "" {
		// if there is no root dir found allow it to be set to "" and bail
		globs.Set("wkspcRootDir", rootDir)
		return nil
	}
	directory := true
	_, err := prepIfNotThere(directory, rootDir, "", "wkspcRootDir")
	if err != nil {
		return err
	}
	wkspcMetaDir, err := prepIfNotThere(directory, rootDir, globs.GetString("wkspcMetaDirName"), "wkspcMetaDir")
	if err != nil {
		return err
	}
	_, err = prepIfNotThere(directory, wkspcMetaDir, "log", "wkspcLogDir")
	if err != nil {
		return err
	}
	_, err = prepIfNotThere(directory, wkspcMetaDir, "tmp", "wkspcTmpDir")
	if err != nil {
		return err
	}
	wkspcVCSDir, err := prepIfNotThere(directory, wkspcMetaDir, "vcs", "wkspcVCSDir")
	if err != nil {
		return err
	}
	wkspcVCSDataDir, err := prepIfNotThere(directory, wkspcVCSDir, "wkspc", "wkspcVCSDataDir")
	if err != nil {
		return err
	}
	_, err = prepIfNotThere(!directory, wkspcVCSDataDir, "static.dvln", "wkspcStaticDvln")
	if err != nil {
		return err
	}
	wkspcDBDir, err := prepIfNotThere(directory, wkspcMetaDir, "db", "wkspcDBDir")
	if err != nil {
		return err
	}
	_, err = prepIfNotThere(!directory, wkspcDBDir, "wkspc.db", "wkspcDB")
	if err != nil {
		return err
	}
	return nil
}
Esempio n. 4
0
File: wkspc.go Progetto: dvln/wkspc
// RootDirFind gets the workspaces root dir (if there is one), note that this will
// not use any "cached" values and it will store the result in globs (viper)
// under the "wkspcRootDir" key (you can access that with any upper/lower case
// as viper is case insensitive).
func RootDirFind(path ...string) (string, error) {
	startDir := ""
	var err error
	if path == nil || path[0] == "" {
		startDir, err = os.Getwd()
		if err != nil {
			return "", out.WrapErr(err, "Unable to find the workspace root directory (get current working dir failed)", 4100)
		}
	} else {
		startDir = path[0]
	}
	rootDir, err := dir.FindDirInOrAbove(startDir, globs.GetString("wkspcMetaDirName"))
	if err == nil {
		// Cache the root dir in "globs" (viper) memory if no error
		globs.Set("wkspcRootDir", rootDir)
	}
	return rootDir, err
}