/*
Returns absolute path of executing file.
WARNING: this must be called before
changing the current directory
*/
func discoverExecName() string {
if DEBUG {
log.Print("Debug: discoverExecName\n")
}
f := os.Args[0]
if path.IsAbs(f) {
return f
}
wd, err := os.Getwd()
if err != nil {
panic(fmt.Sprintf("Getwd failed: %s", err))
}
_, err = os.Stat(f)
if err == nil { // relative file exists
return path.Clean(path.Join(wd, f))
} // not exists? lookup in path
f2, err := exec.LookPath(f)
if err != nil {
panic(fmt.Sprintf("lookpath failed: %s", err))
}
if path.IsAbs(f2) {
return f2
}
return path.Clean(path.Join(wd, f2))
}
func main() {
flag.StringVar(&etcdctlPath, "etcdctl-path", "/usr/bin/etcdctl", "absolute path to etcdctl executable")
flag.StringVar(&etcdPath, "etcd-path", "/usr/bin/etcd2", "absolute path to etcd2 executable")
flag.StringVar(&etcdRestoreDir, "etcd-restore-dir", "/var/lib/etcd2-restore", "absolute path to etcd2 restore dir")
flag.StringVar(&etcdName, "etcd-name", "default", "name of etcd2 node")
flag.StringVar(&etcdPeerUrls, "etcd-peer-urls", "", "advertise peer urls")
flag.Parse()
if etcdPeerUrls == "" {
panic("must set -etcd-peer-urls")
}
if finfo, err := os.Stat(etcdRestoreDir); err != nil {
panic(err)
} else {
if !finfo.IsDir() {
panic(fmt.Errorf("%s is not a directory", etcdRestoreDir))
}
}
if !path.IsAbs(etcdctlPath) {
panic(fmt.Sprintf("etcdctl-path %s is not absolute", etcdctlPath))
}
if !path.IsAbs(etcdPath) {
panic(fmt.Sprintf("etcd-path %s is not absolute", etcdPath))
}
if err := restoreEtcd(); err != nil {
panic(err)
}
}
// posixRel returns a relative path that is lexically equivalent to targpath when
// joined to basepath with an intervening separator.
//
// That is, Join(basepath, Rel(basepath, targpath)) is equivalent to targpath itself.
// On success, the returned path will always be relative to basepath,
// even if basepath and targpath share no elements.
// An error is returned if targpath can't be made relative to basepath or if
// knowing the current working directory would be necessary to compute it.
//
// Copy-pasted & slightly edited from Go's lib path/filepath/path.go .
//
// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
func posixRel(basepath, targpath string) (string, error) {
base := path.Clean(basepath)
targ := path.Clean(targpath)
if targ == base {
return ".", nil
}
if base == "." {
base = ""
}
if path.IsAbs(base) != path.IsAbs(targ) {
return "", errors.New("Rel: can't make " + targ + " relative to " + base)
}
// Position base[b0:bi] and targ[t0:ti] at the first differing elements.
bl := len(base)
tl := len(targ)
var b0, bi, t0, ti int
for {
for bi < bl && base[bi] != '/' {
bi++
}
for ti < tl && targ[ti] != '/' {
ti++
}
if targ[t0:ti] != base[b0:bi] {
break
}
if bi < bl {
bi++
}
if ti < tl {
ti++
}
b0 = bi
t0 = ti
}
if base[b0:bi] == ".." {
return "", errors.New("Rel: can't make " + targ + " relative to " + base)
}
if b0 != bl {
// Base elements left. Must go up before going down.
seps := strings.Count(base[b0:bl], string('/'))
size := 2 + seps*3
if tl != t0 {
size += 1 + tl - t0
}
buf := make([]byte, size)
n := copy(buf, "..")
for i := 0; i < seps; i++ {
buf[n] = '/'
copy(buf[n+1:], "..")
n += 3
}
if t0 != tl {
buf[n] = '/'
copy(buf[n+1:], targ[t0:])
}
return string(buf), nil
}
return targ[t0:], nil
}
/*
Returns absolute path of executing file.
WARNING: this must be called before
changing the current directory
*/
func (be *BdsExec) discoverExecName() string {
if DEBUG {
log.Printf("Debug: discoverExecName (%s)\n", be.args[0])
}
f := be.args[0]
if path.IsAbs(f) {
return f
}
wd, err := os.Getwd()
if err != nil {
panic(fmt.Sprintf("discoverExecName: Getwd failed '%s'", err))
}
_, err = os.Stat(f)
if err == nil {
// Relative file exists
return path.Clean(path.Join(wd, f))
}
f2, err := exec.LookPath(f)
if err != nil {
panic(fmt.Sprintf("discoverExecName: Lookpath failed '%s'", err))
}
if path.IsAbs(f2) {
return f2
}
return path.Clean(path.Join(wd, f2))
}
func main() {
wd, err := os.Getwd()
if err != nil {
panic(err)
}
fmt.Println("working directory: ", wd)
fmt.Println("base: ", path.Base(wd))
fmt.Println("dir: ", path.Dir(wd))
fmt.Println("ext: ", path.Ext(wd+"howdy.test"))
fmt.Println("abs: ", path.IsAbs(wd))
fmt.Println("abs: ", path.IsAbs("howdy/../../"))
dirty := "////howdy////lots/of//slashes//yeah/"
fmt.Println("dirty: ", dirty)
fmt.Println("clean: ", path.Clean(dirty))
fmt.Println("joined: ", path.Join("one", "two", "three", "four"))
dir, file := path.Split(wd + "/lala.txt")
fmt.Println("dir: ", dir, " file: ", file)
// Hmmmm, I wonder if path works with URLs.
var base string
url := "http://example.com/test/file.txt"
base, file = path.Split(url)
fmt.Printf("Got base %v and file %v\n", base, file)
// Looks like the double slash after http: gets messed up by path.Dir.
fmt.Printf("Base is %v\nDir is %v\n", path.Base(url), path.Dir(url))
}
func TestAbs(t *testing.T) {
fmt.Println("Ejecutanto test de Abs...")
falseExpected := path.IsAbs("./some/path")
trueExpected := path.IsAbs("/dev/nul")
if falseExpected == true || trueExpected == false {
t.Error("Fallo en test de Abs.")
}
}
// getBinlogSize returns the total size of the binlog files
func (m *MySQLBinlogGrowth) getBinlogSize(binLog string, dataDir string) (size int64, err error) {
// Read the binlog.index file
// It contains a list of log files, one per line
file, err := os.Open(binLog)
if err != nil {
m.log.Warn(fmt.Sprintf("Cannot open index file %s : %s", binLog, err))
return
}
defer file.Close()
// Read the file line by line
scanner := bufio.NewScanner(file)
for scanner.Scan() {
fileName := scanner.Text()
// If the fileName is not an absolute path, then it's relative to the datadir directory
if !path.IsAbs(fileName) {
fileName = path.Join(dataDir, fileName)
}
fileSize, err := getFileSize(fileName)
if err != nil {
m.log.Warn(err)
}
size += fileSize
}
if scanErr := scanner.Err(); scanErr != nil {
m.log.Warn("There was an error reading the index file")
return
}
return
}
func split(pathStr string) ([]string, error) {
cleanPath := path.Clean(pathStr)
if !path.IsAbs(cleanPath) {
return nil, fmt.Errorf("split: %s is not an absolute path", pathStr)
}
return splitHelper(cleanPath), nil
}
func zipPath(name string) (string, error) {
name = path.Clean(name)
if !path.IsAbs(name) {
return "", fmt.Errorf("stat: not an absolute path: %s", name)
}
return name[1:], nil // strip leading '/'
}
// getBinlogPath read and parse the my.cnf config file and returns the path to the binlog file and datadir.
func (m *MySQLBinlogGrowth) getBinlogPath() (binLog string, dataDir string) {
// read my.cnf config file
config, err := configparser.Read(m.myCnfPath)
if err != nil {
m.log.Error(err)
return
}
section, err := config.Section("mysqld")
if err != nil {
m.log.Error("mysqld section missing in ", m.myCnfPath)
return
}
binLog = section.ValueOf("log-bin")
if binLog == "" {
m.log.Error("log-bin value missing from ", m.myCnfPath)
return
}
dataDir = section.ValueOf("datadir")
if dataDir == "" {
m.log.Error("datadir value missing from ", m.myCnfPath)
return
}
// If the log-bin value is a relative path then it's based on datadir
if !path.IsAbs(binLog) {
binLog = path.Join(dataDir, binLog)
}
return
}
// validatePath validates a single path, returning an error if the path is
// invalid. paths may not:
//
// 1. be absolute
// 2. contain '..' as an element
// 3. start with '..'
// 4. contain filenames larger than 255 characters
// 5. be longer than 4096 characters
func validatePath(targetPath string) error {
// TODO: somehow unify this with the similar api validation,
// validateVolumeSourcePath; the error semantics are just different enough
// from this that it was time-prohibitive trying to find the right
// refactoring to re-use.
if targetPath == "" {
return fmt.Errorf("invalid path: must not be empty: %q", targetPath)
}
if path.IsAbs(targetPath) {
return fmt.Errorf("invalid path: must be relative path: %s", targetPath)
}
if len(targetPath) > maxPathLength {
return fmt.Errorf("invalid path: must be less than %d characters", maxPathLength)
}
items := strings.Split(targetPath, string(os.PathSeparator))
for _, item := range items {
if item == ".." {
return fmt.Errorf("invalid path: must not contain '..': %s", targetPath)
}
if len(item) > maxFileNameLength {
return fmt.Errorf("invalid path: filenames must be less than %d characters", maxFileNameLength)
}
}
if strings.HasPrefix(items[0], "..") && len(items[0]) > 2 {
return fmt.Errorf("invalid path: must not start with '..': %s", targetPath)
}
return nil
}
func getCommand(r *ReplYell) {
shellState := getShellState()
key := ""
switch len(r.Args) {
case 1:
key = r.Args[0]
case 0:
key = ""
fmt.Println("No key set: Getting pwd " + shellState.pwd)
default:
fmt.Println("Need one key - multiple key retrieval TODO")
return
}
if !path.IsAbs(key) {
key = path.Join(shellState.pwd, key)
} else {
key = path.Clean(key)
}
resp, err := shellState.kapi.Get(context.TODO(), key, nil)
if err != nil {
fmt.Println(err)
return
}
printResponseKey(resp)
}
// findConfig returns the filename of the
// config. It searches parent directories
// if it can't find any of the config
// filenames in the current directory.
func findConfig(location string) string {
configFiles := configFilenames(location)
// Absolute path to config given
if len(location) > 0 && path.IsAbs(location) {
if _, err := os.Stat(location); err == nil {
return location
}
} else { // Relative config
configPath, _ := os.Getwd()
for {
for _, f := range configFiles {
// the root path is a `/` but others don't have a trailing `/`
filename := strings.TrimSuffix(configPath, "/") + "/" + f
if _, err := os.Stat(filename); err == nil {
return filename
}
}
// loop only if we haven't yet reached the root
if parentPath := path.Dir(configPath); len(parentPath) != len(configPath) {
configPath = parentPath
} else {
break
}
}
}
panic(StatusError{fmt.Errorf("No configuration found %v", configFiles), 78})
}
func (bh *BoxHandler) PopulateBoxes(directories []string, port *int, hostname *string) {
log.Println("Populating boxes..")
absolutedirectories := []string{}
for _, d := range directories {
if !path.IsAbs(d) {
wd, _ := os.Getwd()
absolute := path.Clean(path.Join(wd, d))
absolutedirectories = append(absolutedirectories, absolute)
} else {
absolutedirectories = append(absolutedirectories, d)
}
}
bh.Directories = absolutedirectories
boxfiles := getBoxList(absolutedirectories)
boxdata := bh.getBoxData(boxfiles)
bh.createBoxes(boxdata, *port, hostname)
for _, boxinfo := range bh.Boxes {
for boxname, box := range boxinfo {
for _, version := range box.Versions {
for _, provider := range version.Providers {
log.Println("Found " + box.Username + "/" + boxname + "/" + version.Version + "/" + provider.Name)
}
}
}
}
}
func abs(name string) (string, error) {
if path.IsAbs(name) {
return name, nil
}
wd, err := os.Getwd()
return path.Join(wd, name), err
}
// Get the absolute filepath, based on built executable file.
func RealPath(fp string) (string, error) {
if path.IsAbs(fp) {
return fp, nil
}
wd, err := os.Getwd()
return path.Join(wd, fp), err
}
func isAbsolutePath(t, p string) error {
if !path.IsAbs(p) {
return fmt.Errorf("%s path '%s' is not an absolute path", t, p)
}
return nil
}
func join(dir, file string) (string, error) {
pth := path.Join(dir, file)
fi, err := os.Lstat(pth)
if err != nil {
panic("could not Lstat file")
}
// This stops absolute links from working, but garbage ones should still work.
// HINT[2]: "There are three types of symlinks. Those who care about the directories around them and those who don't. And then there's the garbage ones. symlink(2) is stupid."
if fi.Mode()&os.ModeSymlink == os.ModeSymlink {
link, err := os.Readlink(pth)
if err != nil {
panic("could not Readlink a link")
}
// Block relative symlinks, so they have to use /../../../../magic.
// Seriously though, why is symlink(2) *that* bad?
if !path.IsAbs(link) {
return "", fmt.Errorf("relative symlink detected")
}
pth = path.Join(dir, link)
}
pth = path.Clean(pth)
return pth, nil
}
func doArgs(cmds []*Command) error {
for _, c := range cmds {
globargv := []string{}
for _, v := range c.args {
if v.mod == "ENV" {
e := v.val
if !path.IsAbs(v.val) {
e = path.Join(envDir, e)
}
b, err := ioutil.ReadFile(e)
if err != nil {
return err
}
// It goes in as one argument. Not sure if this is what we want
// but it gets very weird to start splitting it on spaces. Or maybe not?
globargv = append(globargv, string(b))
} else if globs, err := filepath.Glob(v.val); err == nil && len(globs) > 0 {
globargv = append(globargv, globs...)
} else {
globargv = append(globargv, v.val)
}
}
c.cmd = globargv[0]
c.argv = globargv[1:]
}
return nil
}
func (c *config) MacSync(name string) MacSync {
parts := strings.Split(name, ":")
if !path.IsAbs(parts[0]) {
parts[0] = c.path + "/" + parts[0]
}
return c.macSyncMap[strings.Join(parts, ":")]
}
func zipPath(name string) string {
name = path.Clean(name)
if !path.IsAbs(name) {
panic(fmt.Sprintf("stat: not an absolute path: %s", name))
}
return name[1:] // strip leading '/'
}
//loadConfig unmarshals config for current application mode
func loadConfig() {
data, err := ioutil.ReadFile("./config/config.json")
if err != nil {
panic(err)
}
configs := &Configs{}
if err := json.Unmarshal(data, configs); err != nil {
panic(err)
}
switch GetMode() {
case DebugMode:
config = &configs.Debug
case ReleaseMode:
config = &configs.Release
case TestMode:
config = &configs.Test
}
if !path.IsAbs(config.Public) {
workingDir, err := os.Getwd()
if err != nil {
panic(err)
}
config.Public = path.Join(workingDir, config.Public)
}
config.Uploads = path.Join(config.Public, "uploads")
}
func GetConfig() Deceive {
conf := Deceive{
Host: "localhost",
Port: 1984,
Cert: "/etc/deceive/deceive.crt",
Key: "/etc/deceive/deceive.key",
CaCert: "/etc/deceive/ca.crt",
Root: "/var/lib/deceive/",
}
flags, err := config.LoadFlags("deceive", &conf)
if err != nil {
panic(err)
}
flags.Parse(os.Args[1:])
if !path.IsAbs(conf.Root) {
cwd, err := os.Getwd()
if err != nil {
panic(err)
}
conf.Root = path.Clean(path.Join(cwd, conf.Root))
}
return conf
}
func (a *App) assertValid() error {
if err := a.Exec.assertValid(); err != nil {
return err
}
if a.User == "" {
return errors.New(`user is required`)
}
if a.Group == "" {
return errors.New(`group is required`)
}
if !path.IsAbs(a.WorkingDirectory) && a.WorkingDirectory != "" {
return errors.New("workingDirectory must be an absolute path")
}
eh := make(map[string]bool)
for _, e := range a.EventHandlers {
name := e.Name
if eh[name] {
return fmt.Errorf("Only one eventHandler of name %q allowed", name)
}
eh[name] = true
}
if err := a.Environment.assertValid(); err != nil {
return err
}
return nil
}
// get absolute filepath, based on built executable file
func RealPath(file string) (string, error) {
if path.IsAbs(file) {
return file, nil
}
wd, err := os.Getwd()
return path.Join(wd, file), err
}
func (s *executor) createVolumes() ([]string, []string, error) {
var binds, volumesFrom []string
for _, volume := range s.Config.Docker.Volumes {
s.addVolume(&binds, &volumesFrom, volume)
}
// Cache Git sources:
// take path of the projects directory,
// because we use `rm -rf` which could remove the mounted volume
parentDir := path.Dir(s.Build.FullProjectDir())
// Caching is supported only for absolute and non-root paths
if path.IsAbs(parentDir) && parentDir != "/" {
if s.Build.GetGitStrategy() == common.GitFetch && !s.Config.Docker.DisableCache {
// create persistent cache container
s.addVolume(&binds, &volumesFrom, parentDir)
} else {
// create temporary cache container
container, _ := s.createCacheVolume("", parentDir)
if container != nil {
s.caches = append(s.caches, container)
volumesFrom = append(volumesFrom, container.ID)
}
}
}
return binds, volumesFrom, nil
}
func (c *Config) findConfigFile(configFileName string) (string, error) {
if configFileName == "" { // config not specified, let's search
if b, _ := exists(c.GetAbsPath("config.json")); b {
return c.GetAbsPath("config.json"), nil
}
if b, _ := exists(c.GetAbsPath("config.toml")); b {
return c.GetAbsPath("config.toml"), nil
}
if b, _ := exists(c.GetAbsPath("config.yaml")); b {
return c.GetAbsPath("config.yaml"), nil
}
return "", fmt.Errorf("config file not found in: %s", c.GetPath())
} else {
// If the full path is given, just use that
if path.IsAbs(configFileName) {
return configFileName, nil
}
// Else check the local directory
t := c.GetAbsPath(configFileName)
if b, _ := exists(t); b {
return t, nil
} else {
return "", fmt.Errorf("config file not found at: %s", t)
}
}
}
// GetLogReader returns a reader for the specified filename. Any
// external requests (say from the admin UI via HTTP) must specify
// allowAbsolute as false to prevent leakage of non-log
// files. Absolute filenames are allowed for the case of the cockroach "log"
// command, which provides human readable output from an arbitrary file,
// and is intended to be run locally in a terminal.
func GetLogReader(filename string, allowAbsolute bool) (io.ReadCloser, error) {
if path.IsAbs(filename) {
if !allowAbsolute {
return nil, fmt.Errorf("absolute pathnames are forbidden: %s", filename)
}
if verifyFile(filename) == nil {
return os.Open(filename)
}
}
// Verify there are no path separators in the a non-absolute pathname.
if path.Base(filename) != filename {
return nil, fmt.Errorf("pathnames must be basenames only: %s", filename)
}
if !logFileRE.MatchString(filename) {
return nil, fmt.Errorf("filename is not a cockroach log file: %s", filename)
}
var reader io.ReadCloser
var err error
filename = path.Join(*logDir, filename)
if verifyFile(filename) == nil {
reader, err = os.Open(filename)
if err == nil {
return reader, err
}
}
return nil, err
}
func handleInclude(reader LineReader, context *parserContext, attrValue string) error {
url_, err := url.Parse(attrValue)
if err != nil {
return err
}
if url_.Scheme == "file" || url_.Path == attrValue {
var abspathPattern string
if path.IsAbs(url_.Path) {
abspathPattern = url_.Path
} else {
abspathPattern = path.Join(context.opener.BasePath(), url_.Path)
}
files, err := Glob(context.opener.FileSystem(), abspathPattern)
if err != nil {
return err
}
for _, file := range files {
newReader, err := context.opener.NewLineReader(file)
if err != nil {
return err
}
defer newReader.Close()
parseConfig(newReader, &parserContext{
tag: context.tag,
tagArgs: context.tagArgs,
elems: context.elems,
attrs: context.attrs,
opener: context.opener.NewOpener(path.Dir(file)),
})
}
return nil
} else {
return errors.New("Not implemented!")
}
}
// normalizePaths parses the hosts out of HDFS URLs, and turns relative paths
// into absolute ones (by appending /user/<user>). If multiple HDFS urls with
// differing hosts are passed in, it returns an error.
func normalizePaths(paths []string) ([]string, string, error) {
namenode := ""
cleanPaths := make([]string, 0, len(paths))
for _, rawurl := range paths {
url, err := url.Parse(rawurl)
if err != nil {
return nil, "", err
}
if url.Host != "" {
if namenode != "" && namenode != url.Host {
return nil, "", errMultipleNamenodeUrls
}
namenode = url.Host
}
p := path.Clean(url.Path)
if !path.IsAbs(url.Path) {
p = path.Join(rootPath, p)
}
cleanPaths = append(cleanPaths, p)
}
return cleanPaths, namenode, nil
}