Пример #1
0
func SetEngine() (err error) {
	switch DbCfg.Type {
	case "mysql":
		orm, err = xorm.NewEngine("mysql", fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8",
			DbCfg.User, DbCfg.Pwd, DbCfg.Host, DbCfg.Name))
	case "postgres":
		orm, err = xorm.NewEngine("postgres", fmt.Sprintf("user=%s password=%s dbname=%s sslmode=%s",
			DbCfg.User, DbCfg.Pwd, DbCfg.Name, DbCfg.SslMode))
	case "sqlite3":
		os.MkdirAll(path.Dir(DbCfg.Path), os.ModePerm)
		orm, err = xorm.NewEngine("sqlite3", DbCfg.Path)
	default:
		return fmt.Errorf("Unknown database type: %s", DbCfg.Type)
	}
	if err != nil {
		return fmt.Errorf("models.init(fail to conntect database): %v", err)
	}

	// WARNNING: for serv command, MUST remove the output to os.stdout,
	// so use log file to instead print to stdout.
	execDir, _ := base.ExecDir()
	logPath := execDir + "/log/xorm.log"
	os.MkdirAll(path.Dir(logPath), os.ModePerm)

	f, err := os.Create(logPath)
	if err != nil {
		return fmt.Errorf("models.init(fail to create xorm.log): %v", err)
	}
	orm.Logger = f

	orm.ShowSQL = true
	orm.ShowDebug = true
	orm.ShowErr = true
	return nil
}
Пример #2
0
// TenetCfgPathRecusive looks for a config file at cfgPath. If the config
// file name is equal to DefaultTenetCfgPath, the func recursively searches the
// parent directory until a file with that name is found. In the case that
// none is found "" is retuned.
func TenetCfgPathRecusive(cfgPath string) (string, error) {
	var err error
	cfgPath, err = filepath.Abs(cfgPath)
	if err != nil {
		return "", err
	}

	if _, err := os.Stat(cfgPath); os.IsNotExist(err) {
		dir, file := path.Split(cfgPath)
		if file == DefaultTenetCfgPath {
			if dir == "/" {
				// we've reached the end of the line. Fall back to default:
				usr, err := user.Current()
				if err != nil {
					return "", err
				}

				lHome, err := util.LingoHome()
				if err != nil {
					return "", errors.Trace(err)
				}
				defaultTenets := path.Join(usr.HomeDir, lHome, DefaultTenetCfgPath)
				if _, err := os.Stat(defaultTenets); err != nil {
					return "", err
				}
				return defaultTenets, nil
			}
			parent := path.Dir(path.Dir(dir))
			return TenetCfgPathRecusive(parent + "/" + DefaultTenetCfgPath)
		}
		return "", err
	}
	return cfgPath, nil
}
Пример #3
0
Файл: zeus.go Проект: burke/zeus
func execManPage(page string) {
	binaryPath := os.Args[0]
	gemDir := path.Dir(path.Dir(binaryPath))
	manDir := path.Join(gemDir, "man/build")
	zeus := path.Join(manDir, page)
	syscall.Exec("/usr/bin/env", []string{"/usr/bin/env", "man", zeus}, os.Environ())
}
Пример #4
0
func (p *FileProvider) regenerate(oldsid, sid string) (err error) {
	p.lock.Lock()
	defer p.lock.Unlock()

	filename := p.filepath(sid)
	if com.IsExist(filename) {
		return fmt.Errorf("new sid '%s' already exists", sid)
	}

	oldname := p.filepath(oldsid)
	if !com.IsFile(oldname) {
		data, err := EncodeGob(make(map[interface{}]interface{}))
		if err != nil {
			return err
		}
		if err = os.MkdirAll(path.Dir(oldname), os.ModePerm); err != nil {
			return err
		}
		if err = ioutil.WriteFile(oldname, data, os.ModePerm); err != nil {
			return err
		}
	}

	if err = os.MkdirAll(path.Dir(filename), os.ModePerm); err != nil {
		return err
	}
	if err = os.Rename(oldname, filename); err != nil {
		return err
	}
	return nil
}
Пример #5
0
// POST /problem/edit
func (p *Problem) PostEdit(problem models.Problem,
	inputTest, outputTest []byte) revel.Result {
	defer func() {
		delete(p.Session, ID)
	}()
	if inputTest != nil {
		problem.InputTestPath = path.Dir(problem.InputTestPath) +
			"/inputTest"
		_, err := util.WriteFile(problem.InputTestPath, inputTest)
		if err != nil {
			log.Println(err)
		}

	}
	if outputTest != nil {
		problem.OutputTestPath = path.Dir(problem.OutputTestPath) +
			"/outputTest"
		_, err := util.WriteFile(problem.OutputTestPath, outputTest)
		if err != nil {
			log.Println(err)
		}
	}
	id, err := strconv.ParseInt(p.Session[ID], 10, 64)
	if err != nil {
		p.Flash.Error("id error")
		log.Println(err)
		return p.Redirect("/")
	}
	_, err = engine.Id(id).Update(problem)
	if err != nil {
		log.Println(err)
	}
	return p.Redirect("/")
}
Пример #6
0
func (fs *memFileSystem) watcherCallback() {
	for {
		select {
		case e := <-fs.watcher.Event:
			if e.IsCreate() {
				fi := fs.reloadFile(e.Name)
				if fi != nil && fi.IsDir() {
					err := fs.watcher.Watch(e.Name)
					if err != nil {
						logger.Printf("failed to add watch: %s err: %v", e.Name, err)
					}
				}
				fs.reloadFile(path.Dir(e.Name))
			}
			if e.IsModify() {
				fs.reloadFile(e.Name)
			}
			if e.IsDelete() || e.IsRename() {
				fi := fs.deleteFile(e.Name)
				if fi != nil && fi.IsDir() {
					err := fs.watcher.RemoveWatch(e.Name)
					if err != nil {
						logger.Printf("failed to remove watch: %s err: %v", e.Name, err)
					}
				}
				fs.reloadFile(path.Dir(e.Name))
			}
		case err := <-fs.watcher.Error:
			logger.Printf("watcher error: %v", err)
		}
	}
}
Пример #7
0
func InjectLinks(adID string, content string, r *http.Request) string {

	// log.Println(r.Host)
	// log.Println(r.URL)
	timeNow = time.Now()

	host := r.Host

	//Get the last directory

	var curPath = ""
	prefixPth, err := regexp.MatchString("^[\\./]", r.URL.Path)
	if prefixPth && err == nil {
		curPath = path.Dir(r.URL.Path[1:])
	} else {
		curPath = path.Dir(r.URL.Path)
	}
	if curPath == "." || curPath == "/" {
		curPath = ""
	}

	// log.Println("HOST: " + host)
	// log.Println("URL: " + r.URL.String())
	// log.Println("PTH: " + curPath)

	content = replaceILK(content, host, curPath)
	content = replaceMLK(content, host, curPath, adID)

	return content
}
Пример #8
0
func (imdb *ImageDataBase) makeDirectory(directory image.Directory,
	username string, userRpc bool) error {
	directory.Name = path.Clean(directory.Name)
	pathname := path.Join(imdb.baseDir, directory.Name)
	imdb.Lock()
	defer imdb.Unlock()
	oldDirectoryMetadata, ok := imdb.directoryMap[directory.Name]
	if userRpc {
		if ok {
			return fmt.Errorf("directory: %s already exists", directory.Name)
		}
		directory.Metadata = oldDirectoryMetadata
		parentMetadata, ok := imdb.directoryMap[path.Dir(directory.Name)]
		if !ok {
			return fmt.Errorf("no metadata for: %s", path.Dir(directory.Name))
		}
		if parentMetadata.OwnerGroup != "" {
			if err := checkUserInGroup(username,
				parentMetadata.OwnerGroup); err != nil {
				return err
			}
		}
		directory.Metadata.OwnerGroup = parentMetadata.OwnerGroup
	}
	if err := os.Mkdir(pathname, dirPerms); err != nil && !os.IsExist(err) {
		return err
	}
	return imdb.updateDirectoryMetadata(directory)
}
Пример #9
0
func buildName(dstPath string) (relpath string, author string, err error) {
	fname := path.Base(dstPath)
	curPath := path.Dir(dstPath)
	parts := []string{}

	for !fileExists(path.Join(curPath, configFile)) {
		parts = append([]string{path.Base(curPath)}, parts...)
		newCurPath := path.Dir(curPath)

		if newCurPath == curPath {
			fail("Couldn't find %s. Did you create it?", configFile)
		}

		curPath = newCurPath
	}

	// TODO: This is ugly. Fix by making a real config file.
	bs, err := ioutil.ReadFile(path.Join(curPath, configFile))
	if err != nil {
		return "", "", err
	}

	parts = append([]string{path.Base(curPath)}, parts...)
	parts = append(parts, fname)
	return path.Join(parts...), string(bs), nil
}
Пример #10
0
func init() {
	os.Chdir(path.Dir(os.Args[0]))
	BeeApp = NewApp()
	AppPath = path.Dir(os.Args[0])
	StaticDir = make(map[string]string)
	TemplateCache = make(map[string]*template.Template)
	HttpAddr = ""
	HttpPort = 8080
	AppName = "beego"
	RunMode = "dev" //default runmod
	AutoRender = true
	RecoverPanic = true
	PprofOn = false
	ViewsPath = "views"
	SessionOn = false
	SessionProvider = "memory"
	SessionName = "beegosessionID"
	SessionGCMaxLifetime = 3600
	SessionSavePath = ""
	UseFcgi = false
	MaxMemory = 1 << 26 //64MB
	EnableGzip = false
	StaticDir["/static"] = "static"
	AppConfigPath = path.Join(AppPath, "conf", "app.conf")
	HttpServerTimeOut = 0
	ErrorsShow = true
	XSRFKEY = "beegoxsrf"
	XSRFExpire = 0
	TemplateLeft = "{{"
	TemplateRight = "}}"
	BeegoServerName = "beegoServer"
	ParseConfig()
	runtime.GOMAXPROCS(runtime.NumCPU())
}
Пример #11
0
func expandRoot(root string) string {
	if rroot := []rune(root); rroot[0] == '.' {
		// Get the current directory
		cd, err := os.Getwd()

		// Check for an error
		if err != nil {
			panic(err)
		} //if

		// Check if the path is simple
		switch root {
		case ".":
			return cd
		case "..":
			return path.Dir(cd)
		} //switch

		// Check if the second is also a '.'
		if rroot[1] == '.' {
			return path.Clean(path.Join(path.Dir(cd), root[2:]))
		} //if

		// Return the current directory and everything after the first '.'
		return path.Clean(path.Join(cd, root[1:]))
	} //if

	return path.Clean(root)
} //expandRoot
Пример #12
0
func (d *Disk) saveMetaToDisk() error {
	m := &meta{
		StorageObjects: d.storageObjects,
		PartSize:       d.partSize,
	}

	meta_file_path := path.Join(d.path, metaFileName)
	err := os.MkdirAll(path.Dir(meta_file_path), 0700)
	if err != nil {
		return fmt.Errorf("Error on creating the directory %s - %s", path.Dir(meta_file_path), err)
	}
	meta_file, err := os.Create(meta_file_path)
	if err != nil {
		return fmt.Errorf("Error on creating meta file for disk storage - %s", err)
	}
	defer meta_file.Close()

	err = json.NewEncoder(meta_file).Encode(m)

	if err != nil {
		return fmt.Errorf("Error on encoding to meta file - %s", err)
	}

	d.logger.Logf("Wrote meta to %s", path.Join(d.path, metaFileName))
	return nil
}
Пример #13
0
// spawn spawns the given filename in background using syscall
func spawn(name string) {
	filepath := path.Join("/init/services", name)

	stdinpath := path.Join("/logs/", name+".stdin")
	stdoutpath := path.Join("/logs/", name+".stdout")
	stderrpath := path.Join("/logs/", name+".stderr")

	os.MkdirAll(path.Dir(stdinpath), 0777)
	os.MkdirAll(path.Dir(stdoutpath), 0777)
	os.MkdirAll(path.Dir(stderrpath), 0777)

	fstdin, err := os.Create(stdinpath)
	if err != nil {
		log.Println("waat", err)
	}
	fstdout, err := os.Create(stdoutpath)
	if err != nil {
		log.Println("waat", err)
	}
	fstderr, err := os.Create(stderrpath)
	if err != nil {
		log.Println("waat", err)
	}

	// Open Files for stdout, stderr
	procAttr := &syscall.ProcAttr{
		Dir:   "/",
		Env:   []string{"MYVAR=345"},
		Files: []uintptr{fstdin.Fd(), fstdout.Fd(), fstderr.Fd()},
		Sys:   nil,
	}

	pid, err := syscall.ForkExec(filepath, nil, procAttr)
	if err != nil {
		log.WithFields(log.Fields{
			"service": filepath,
			"error":   err,
		}).Error("Could not start service.")
	} else {
		log.WithFields(log.Fields{
			"service": filepath,
			"pid":     pid,
		}).Info("Started service succesfully")
	}

	log.Info("Waiting for 3 seconds")
	time.Sleep(3 * time.Second)

	a, err1 := ioutil.ReadFile(stdoutpath)
	b, err2 := ioutil.ReadFile(stderrpath)
	if err1 != nil || err2 != nil {
		log.Error("Could not read", err1, err2)
	} else {
		log.WithFields(log.Fields{
			"service": name,
			"stdout":  string(a),
			"stderr":  string(b),
		}).Info("Service ended.")
	}
}
Пример #14
0
func ShadowCopy(source, destination string) (err error) {
	source = trimTrailingSlash(source)
	destination = trimTrailingSlash(destination)
	srcInfo, srcErr := os.Stat(source)
	if srcErr != nil {
		return srcErr
	}
	dstInfo, dstErr := os.Stat(destination)
	if srcInfo.IsDir() && dstInfo != nil && !dstInfo.IsDir() && !os.IsNotExist(dstErr) {
		return fmt.Errorf("Cannot overwrite non-directory '%s' with directory '%s'", destination, source)
	}
	dstIsDir := false
	if dstInfo != nil {
		dstIsDir = dstInfo.IsDir()
	}
	return filepath.Walk(source, func(pathFile string, info os.FileInfo, e error) error {
		if !info.IsDir() && info.Mode().IsRegular() {
			// Copy file
			cpyPath := destination
			if dstInfo != nil && dstInfo.IsDir() {
				if srcInfo.IsDir() {
					if dstIsDir {
						cpyPath = pathFile[len(path.Dir(source)):]
					} else {
						cpyPath = pathFile[len(source):]
					}
				} else {
					cpyPath = path.Base(pathFile)
				}
				cpyPath = path.Join(destination, cpyPath)
			}
			e = shadowCopyFile(pathFile, cpyPath)
			if e != nil {
				err = e
				return err
			}
		} else if info.IsDir() {
			// Copy directory
			dirpath := destination
			if dstInfo != nil && dstInfo.IsDir() {
				if dstIsDir {
					dirpath = path.Join(destination, pathFile[len(path.Dir(source)):])
				} else {
					dirpath = path.Join(destination, pathFile[len(source):])
				}
			}
			e = os.Mkdir(dirpath, 0755)
			if e != nil {
				err = e
				return err
			}
			dstInfo, e = os.Stat(dirpath)
			if e != nil {
				err = e
				return err
			}
		}
		return nil
	})
}
Пример #15
0
func (b *Box) setupShared() error {
	os.Mkdir(b.SharedDirectory(), 0777)

	for _, asset := range b.Shared {
		assetPath := b.RevisionDirectory() + "/" + asset
		sharedRealPath := b.SharedDirectory() + "/" + asset

		if !exists(sharedRealPath) {
			if exists(assetPath) {
				os.MkdirAll(path.Dir(sharedRealPath), 0777)

				cmd := exec.Command("mv", assetPath, path.Dir(sharedRealPath)+"/")
				cmd.Stdout = b.OutputStream
				cmd.Stderr = b.ErrorStream
				if err := cmd.Run(); err != nil {
					return err
				}
			} else {
				return errors.New("Shared asset '" + assetPath + "' should exist in source code.")
			}
		}
	}

	return nil
}
Пример #16
0
func NewLogrusLogger(ctx *cli.Context) Logger {
	logFile := ctx.GlobalString("log-file")
	if logFile != "" {
		if err := os.MkdirAll(path.Dir(logFile), 0755); err != nil {
			logrus.Errorf("Failed to create path %s: %s", path.Dir(logFile), err.Error())
		} else {
			file, err := os.OpenFile(logFile, syscall.O_CREAT|syscall.O_APPEND|syscall.O_WRONLY, 0644)
			if err != nil {
				logrus.Errorf("Failed to open log file %s: %s", logFile, err.Error())
			} else {
				logrus.SetOutput(file)
			}
		}
	}
	switch ctx.GlobalString("log-format") {
	case "json":
		logrus.SetFormatter(&logrus.JSONFormatter{})
	case "logstash":
		logrus.SetFormatter(&logstash.LogstashFormatter{})
	default:
		logrus.SetFormatter(&logrus.TextFormatter{})
	}
	if ctx.GlobalBool("debug") {
		logrus.SetLevel(logrus.DebugLevel)
	}

	return &logrusLogger{
		logger: logrus.StandardLogger(),
	}
}
Пример #17
0
// Flatten changes the config object into a self contained config (useful for making secrets)
func FlattenConfig(config *Config) error {
	for key, authInfo := range config.AuthInfos {
		baseDir, err := MakeAbs(path.Dir(authInfo.LocationOfOrigin), "")
		if err != nil {
			return err
		}

		if err := FlattenContent(&authInfo.ClientCertificate, &authInfo.ClientCertificateData, baseDir); err != nil {
			return err
		}
		if err := FlattenContent(&authInfo.ClientKey, &authInfo.ClientKeyData, baseDir); err != nil {
			return err
		}

		config.AuthInfos[key] = authInfo
	}
	for key, cluster := range config.Clusters {
		baseDir, err := MakeAbs(path.Dir(cluster.LocationOfOrigin), "")
		if err != nil {
			return err
		}

		if err := FlattenContent(&cluster.CertificateAuthority, &cluster.CertificateAuthorityData, baseDir); err != nil {
			return err
		}

		config.Clusters[key] = cluster
	}

	return nil
}
Пример #18
0
func writeConfigGO() {
	if current(buildGO, configGO) {
		return
	}
	installedLibDir := path.Dir(installedLibPath)
	cfLibPath, err := cfc.InstalledLibPath(cfPackageName)
	if err != nil {
		log.Fatal(err)
	}
	cfLibDir := path.Dir(cfLibPath)
	content := fmt.Sprintf(
		"// Auto-generated by build.go, specifying absolute path to static lib.\n"+
			"package lucy\n"+
			"// #cgo CFLAGS: -I%s/../core\n"+
			"// #cgo CFLAGS: -I%s\n"+
			"// #cgo CFLAGS: -I%s/autogen/include\n"+
			"// #cgo LDFLAGS: -L%s\n"+
			"// #cgo LDFLAGS: -L%s\n"+
			"// #cgo LDFLAGS: -L%s\n"+
			"// #cgo LDFLAGS: -llucy\n"+
			"// #cgo LDFLAGS: -lclownfish\n"+
			"import \"C\"\n",
		buildDir, buildDir, buildDir, buildDir, installedLibDir, cfLibDir)
	ioutil.WriteFile(configGO, []byte(content), 0666)
}
Пример #19
0
// Uglify does the opposite of PrettifyURLPath().
//     /section/name/index.html becomes /section/name.html
//     /section/name/           becomes /section/name.html
//     /section/name.html       becomes /section/name.html
func Uglify(in string) string {
	if path.Ext(in) == "" {
		if len(in) < 2 {
			return "/"
		}
		// /section/name/  -> /section/name.html
		return path.Clean(in) + ".html"
	}

	name, ext := fileAndExt(in, pb)
	if name == "index" {
		// /section/name/index.html -> /section/name.html
		d := path.Dir(in)
		if len(d) > 1 {
			return d + ext
		}
		return in
	}
	// /.xml -> /index.xml
	if name == "" {
		return path.Dir(in) + "index" + ext
	}
	// /section/name.html -> /section/name.html
	return path.Clean(in)
}
Пример #20
0
// findFile returns the name and contents of the .yang file associated with
// name, or an error.  If name is a module name rather than a file name (it does
// not have a .yang extension and there is no / in name), .yang is appended to
// the the name.  The directory that the .yang file is found in is added to Path
// if not already in Path.
//
// If a path has the form dir/... then dir and all direct or indirect
// subdirectories of dir are searched.
//
// The current directory (.) is always checked first, no matter the value of
// Path.
func findFile(name string) (string, string, error) {
	slash := strings.Index(name, "/")

	if slash < 0 && !strings.HasSuffix(name, ".yang") {
		name += ".yang"
	}

	switch data, err := readFile(name); true {
	case err == nil:
		AddPath(path.Dir(name))
		return name, string(data), nil
	case slash >= 0:
		// If there are any /'s in the name then don't search Path.
		return "", "", fmt.Errorf("no such file: %s", name)
	}

	for _, dir := range Path {
		var n string
		if path.Base(dir) == "..." {
			n = findInDir(path.Dir(dir), name)
		} else {
			n = path.Join(dir, name)
		}
		if n == "" {
			continue
		}
		if data, err := readFile(n); err == nil {
			return n, string(data), nil
		}
	}
	return "", "", fmt.Errorf("no such file: %s", name)
}
Пример #21
0
// load a PCM from <<pathTo>>, which if not explicitly pointing into a folder with the <<Sample Rate>>, numerically as its name, will look into a sub-folder with the sampleRate indicated by the PCM parameter, and if that's zero will load any samplerate available. Also adds extension ".pcm".
func LoadPCM(pathTo string, p *PCM) (err error) {
	sampleRate, err := strconv.ParseUint(path.Base(path.Dir(pathTo)), 10, 32)
	if err != nil {
		if p.samplePeriod == 0 {
			var files []os.FileInfo
			files, err = ioutil.ReadDir(path.Dir(pathTo))
			if err != nil {
				return
			}
			for _, file := range files {
				if file.IsDir() && file.Size() > 0 {
					sampleRate, err = strconv.ParseUint(file.Name(), 10, 32)
					if err == nil {
						pathTo = path.Join(path.Dir(pathTo), file.Name(), path.Base(pathTo))
						break
					}
				}
			}
		} else {
			pathTo = path.Join(path.Dir(pathTo), strconv.FormatInt(int64(unitX/x(p.samplePeriod)), 10), path.Base(pathTo))
		}
	} else {
		p.samplePeriod = X(1 / float32(sampleRate))
	}
	p.Data, err = ioutil.ReadFile(pathTo + ".pcm")
	return
}
Пример #22
0
func (r *recurDirReader) appendReadDirAfterMarker(marker string, entries []os.FileInfo) ([]os.FileInfo, error) {
	markerBase := path.Base(marker)
	markerDir := path.Dir(marker)
	infos, err := r.readDirFunc(markerDir)
	if err != nil {
		return entries, err
	}

	i := indexOfName(infos, markerBase)

	if marker == r.marker && infos[i].IsDir() {
		subinfos, err := r.readDirFunc(marker)
		if err != nil {
			return entries, err
		}
		entries, err = r.processFileInfos(marker, subinfos, entries)
		if err != nil || r.hasReachedLimit(entries) {
			return entries, err
		}
	}

	entries, err = r.processFileInfos(markerDir, infos[i+1:], entries)
	if err != nil || r.hasReachedLimit(entries) {
		return entries, err
	}

	for ; markerDir != r.dir; markerDir = path.Dir(markerDir) {
		entries, err = r.appendReadDirAfterMarker(markerDir, entries)
		if err != nil || r.hasReachedLimit(entries) {
			return entries, err
		}
	}
	return entries, nil
}
Пример #23
0
func staticRoot() string {
	if len(webroot) == 0 {
		_, filename, _, _ := runtime.Caller(1)
		return path.Join(path.Dir(path.Dir(filename)), "shell", "static")
	}
	return webroot
}
Пример #24
0
// sendDir works out given a lastDir and a remote which directories should be sent
func sendDir(lastDir string, remote string, level int) (dirNames []string, newLastDir string) {
	dir := path.Dir(remote)
	if dir == "." {
		// No slashes - nothing to do!
		return nil, lastDir
	}
	if dir == lastDir {
		// Still in same directory
		return nil, lastDir
	}
	newLastDir = lastDir
	for {
		slashes := strings.Count(dir, "/")
		if !strings.HasPrefix(lastDir, dir) && slashes < level {
			dirNames = append([]string{dir}, dirNames...)
		}
		if newLastDir == lastDir {
			newLastDir = dir
		}
		dir = path.Dir(dir)
		if dir == "." {
			break
		}
	}
	return dirNames, newLastDir
}
Пример #25
0
func serve(c *cli.Context) {
	// Ensure api socket directory exists; if not, create it
	apiSocket := getApiSocket(c)
	if _, err := os.Stat(apiSocket); os.IsNotExist(err) {
		os.MkdirAll(path.Dir(apiSocket), 0777)
	}

	d := dokku.New()

	// If caching is enabled, create cache socket if necessary and launch cache
	// server in the background
	if !c.BoolT("enable-cache") {
		cacheSocket := getCacheSocket(c)
		if _, err := os.Stat(cacheSocket); os.IsNotExist(err) {
			os.MkdirAll(path.Dir(cacheSocket), 0777)
		}

		go func() {
			err := listenCache(d, cacheSocket)
			if err != nil {
				panic(err)
			}
		}()
	}

	// Start api server
	err := listenAPI(d, apiSocket)
	if err != nil {
		panic(err)
	}
}
Пример #26
0
func (v *VuesController) Post() {
	file := v.Ctx.Input.Param(":files")
	d, f := Emplacement(Root, file)
	fileNotExt := strings.TrimSuffix(f, filepath.Ext(f))
	c := fileNotExt + ".srt"
	pathSrt := path.Dir(d) + "/" + fileNotExt + ".srt"

	if !filepath.HasPrefix(f, ".") {
		finfo, err := os.Stat(d)
		if err != nil {
			check(err)
		} else {
			if !finfo.IsDir() {
				err := os.Rename(d, path.Dir(d)+"/."+f)
				if err != nil {
					check(err)
				}
				if !filepath.HasPrefix(c, ".") {
					_, err = os.Stat(pathSrt)
					if err == nil {
						err := os.Rename(pathSrt, path.Dir(pathSrt)+"/."+c)
						if err != nil {
							check(err)
						}
					}
				}
				v.Redirect("/list/"+path.Dir(file), 302)
			}
		}
	} else {
		fmt.Println(" le fichier a déjà été modifié !")
		v.Redirect("/list/"+path.Dir(file), 302)
	}
}
Пример #27
0
func updateReadme(t *testing.T, repo *Repository, content string) (*Oid, *Oid) {
	loc, err := time.LoadLocation("Europe/Berlin")
	checkFatal(t, err)
	sig := &Signature{
		Name:  "Rand Om Hacker",
		Email: "*****@*****.**",
		When:  time.Date(2013, 03, 06, 14, 30, 0, 0, loc),
	}

	tmpfile := "README"
	err = ioutil.WriteFile(path.Join(path.Dir(path.Dir(repo.Path())), tmpfile), []byte(content), 0644)
	checkFatal(t, err)

	idx, err := repo.Index()
	checkFatal(t, err)
	err = idx.AddByPath("README")
	checkFatal(t, err)
	treeId, err := idx.WriteTree()
	checkFatal(t, err)

	currentBranch, err := repo.Head()
	checkFatal(t, err)
	currentTip, err := repo.LookupCommit(currentBranch.Target())
	checkFatal(t, err)

	message := "This is a commit\n"
	tree, err := repo.LookupTree(treeId)
	checkFatal(t, err)
	commitId, err := repo.CreateCommit("HEAD", sig, sig, message, tree, currentTip)
	checkFatal(t, err)

	return commitId, treeId
}
Пример #28
0
func createFiles(c *cli.Context) {
	fmt.Println("Running: create")

	_, f, _, ok := runtime.Caller(0)
	if !ok {
		panic("No caller information")
	}

	srcPath = filepath.Join(path.Dir(f), "src")
	distPath = filepath.Join(path.Dir(f), "dist")

	// Create dist folders if not present
	os.MkdirAll(filepath.Join(distPath, "yaml", "countries"), 0775)
	os.MkdirAll(filepath.Join(distPath, "yaml", "subdivisions"), 0775)
	os.MkdirAll(filepath.Join(distPath, "json", "countries"), 0775)
	os.MkdirAll(filepath.Join(distPath, "json", "subdivisions"), 0775)

	// Begin parsing and saving
	//
	var countries *[]gountries.Country
	var err error

	// Unrmarshal the large country.json file first and return a slice of countries
	if countries, err = populateCountriesFromJSON(); err != nil {
		fmt.Println("Could not parse JSON: " + err.Error())
		return
	}

	// Next, parse yaml files and return a slice with saveable data
	data := getSaveableData(countries)

	saveBytesToFiles(data)
}
Пример #29
0
func (d *driver) addDirs(diffInfo *pfs.DiffInfo, child *pfs.File, shard uint64) {
	childPath := child.Path
	dirPath := path.Dir(childPath)
	for {
		_append, ok := diffInfo.Appends[dirPath]
		if !ok {
			_append = newAppend(pfs.FileType_FILE_TYPE_DIR)
			diffInfo.Appends[dirPath] = _append
		}
		if _append.Children == nil {
			_append.Children = make(map[string]bool)
		}
		_append.Children[childPath] = true
		if diffInfo.ParentCommit != nil {
			_append.LastRef = d.lastRef(
				client.NewFile(diffInfo.ParentCommit.Repo.Name, diffInfo.ParentCommit.ID, dirPath),
				shard,
			)
		}
		if dirPath == "." {
			break
		}
		childPath = dirPath
		dirPath = path.Dir(childPath)
	}
}
Пример #30
0
func init() {
	// find the directory with the assets.
	// this doesn't work if you:
	// 1. move the binary
	// 2. put ngrok in your PATH
	// but you shouldn't be doing either of these things while developng anyways
	var binPath string
	execPath := os.Args[0]
	if path.IsAbs(execPath) {
		binPath = execPath
	} else {
		wd, err := os.Getwd()
		if err != nil {
			panic(err)
		}
		binPath = path.Join(wd, execPath)
	}
	assetDir = path.Join(path.Dir(path.Dir(binPath)), "assets")

	// call all the functions on startup to make sure the files exist
	fns := []func() []byte{
		BodyHtml,
		PageHtml,
		HighlightJs,
		HighlightCss,
		BootstrapCss,
		JqueryJs,
		VkBeautifyJs,
	}
	for _, f := range fns {
		f()
	}
}