Golang Ext示例

说明

golang ext示例是从最受好评的开源项目中提取的实现代码,你可以参考下面示例的使用方式。

编程语言: Golang

命名空间/包名称: path/filepath

示例#1
文件: gomon.go 项目: Revanth47/gomon

// Run waits for watcher events sent by fsnotify
// and triggers the restart process if required
func (w *watch) Run() {
	t := time.Now()
	for {
		select {
		case event := <-w.Events:
			if time.Since(t) < threshold || event.Name == "" {
				break
			}

			t = time.Now()
			f, err := os.Stat(event.Name)

			if err != nil {
				log.Println("error watching ", err)
				break
			}
			if filepath.Ext(event.Name) == ".go" || filepath.Ext(event.Name) == ".tmpl" || f.IsDir() {
				Describe(event)
				w.HandleEvent(event)
				log.Println("restarting...")

				// Lock w to ensure that restart is an atomic operation
				w.mu.Lock()
				w.KillProcess()
				go w.StartNewProcess()
			}

		case err := <-w.Errors:
			if err != nil {
				log.Println("error:", err)
			}
		}
	}
}

示例#2
文件: invoicedata.go 项目: pawelropa/programmingingo

func suffixOf(filename string) string {
	suffix := filepath.Ext(filename)
	if suffix == ".gz" {
		suffix = filepath.Ext(filename[:len(filename)-3])
	}
	return suffix
}

示例#3
文件: compiler.go 项目: apache/incubator-mynewt-newt

// Generates a dependency Makefile (.d) for the specified source C file.
//
// @param file                  The name of the source file.
func (c *Compiler) GenDepsForFile(file string) error {
	if util.NodeNotExist(c.dstDir) {
		os.MkdirAll(c.dstDir, 0755)
	}

	depFile := c.dstDir + "/" +
		strings.TrimSuffix(file, filepath.Ext(file)) + ".d"
	depFile = filepath.ToSlash(depFile)

	var cmd string
	var err error

	cmd = c.ccPath + " " + c.cflagsString() + " " + c.includesString() +
		" -MM -MG " + file + " > " + depFile
	o, err := util.ShellCommand(cmd)
	if err != nil {
		return util.NewNewtError(string(o))
	}

	// Append the extra dependencies (.yml files) to the .d file.
	f, err := os.OpenFile(depFile, os.O_APPEND|os.O_WRONLY, 0666)
	if err != nil {
		return util.NewNewtError(err.Error())
	}
	defer f.Close()

	objFile := strings.TrimSuffix(file, filepath.Ext(file)) + ".o"
	if _, err := f.WriteString(objFile + ": " + c.depsString()); err != nil {
		return util.NewNewtError(err.Error())
	}

	return nil
}

示例#4
文件: notify.go 项目: nopsky/sfserver

func (w *Watcher) readEvent() {
	var (
		buf   [syscall.SizeofInotifyEvent * 4096]byte // Buffer for a maximum of 4096 raw events
		n     int                                     // Number of bytes read with read()
		errno error                                   // Syscall errno
	)

	for {

		select {
		case <-w.done:
			syscall.Close(w.fd)
			close(w.acceptEvent)
			close(w.Error)
			return
		default:
		}

		n, errno = syscall.Read(w.fd, buf[0:])

		if n == 0 {
			syscall.Close(w.fd)
			close(w.acceptEvent)
			close(w.Error)
			return
		}

		if n < syscall.SizeofInotifyEvent {
			log.Fatal("size of InotifyEvent error", errno)
		}

		var offset uint32 = 0

		for offset <= uint32(n-syscall.SizeofInotifyEvent) {
			raw := (*syscall.InotifyEvent)(unsafe.Pointer(&buf[offset]))
			event := new(FileEvent)
			event.wd = raw.Wd
			event.nameLen = raw.Len
			event.mask = raw.Mask
			event.cookie = raw.Cookie
			path := w.wm.paths[int(raw.Wd)]
			if raw.Len > 0 {
				// Point "bytes" at the first byte of the filename
				bytes := (*[syscall.PathMax]byte)(unsafe.Pointer(&buf[offset+syscall.SizeofInotifyEvent]))
				// The filename is padded with NUL bytes. TrimRight() gets rid of those.
				event.fileName = path + "/" + strings.TrimRight(string(bytes[0:raw.Len]), "\000")
			}

			if _, found := w.skipExt[filepath.Ext(event.fileName)]; !found {
				fmt.Println("--->", w.skipExt, "--->", filepath.Ext(event.fileName), "--->", found)
				//发送事件acceptEvent通道
				w.acceptEvent <- event
			} else {
				fmt.Println("过滤文件:", event.fileName)
			}

			offset += syscall.SizeofInotifyEvent + raw.Len
		}
	}
}

示例#5
文件: main.go 项目: ronbu/made

// %f - whole filepath
// %d - dirname of path
// %b - basename of file
// %B - basename without extension
// %e - extension of file
func replaceForEach(name, arg string) (string, bool) {
	li := -1
	found := false
	for i := 0; i > li; {
		li = i
		if i = strings.Index(arg, "%"); i > -1 {
			ext := filepath.Ext(name)
			if len(ext) > 1 {
				ext = ext[1:] // strip
			}
			base := filepath.Base(name)
			m := map[rune]string{
				'f': name,
				'd': filepath.Dir(name),
				'b': base,
				'B': strings.TrimSuffix(base, filepath.Ext(name)),
				'e': ext,
			}
			i++
			r := rune(arg[i])
			insert, ok := m[r]
			if ok {
				found = true
				arg = strings.Replace(arg, "%"+string(r), insert, -1)
				// println(arg, insert, strings.TrimSuffix("dir/a.a", filepath.Ext("dir/a.a")))
			}
		} else {
			break
		}
	}
	return arg, found
}

示例#6
文件: asl.go 项目: DeKugelschieber/asl

// Creates a list of all ASL files to compile.
func readAslFiles(path string) {
	dir, err := ioutil.ReadDir(path)

	if err != nil {
		fmt.Println("Error reading in directory!")
		return
	}

	for i := 0; i < len(dir); i++ {
		name := dir[i].Name()

		if dir[i].IsDir() && recursive {
			readAslFiles(filepath.FromSlash(path + PathSeparator + name))
			continue
		}

		if !dir[i].IsDir() && strings.ToLower(filepath.Ext(name)) == extension {
			in := filepath.FromSlash(path + PathSeparator + dir[i].Name())
			out := filepath.FromSlash("./" + path[len(inDir):len(path)])
			newname := name[:len(name)-len(filepath.Ext(name))]

			file := ASLFile{in, out, newname}
			aslFiles = append(aslFiles, file)
		}
	}
}

示例#7
文件: main.go 项目: kleopatra999/skia-buildbot

func runBenchmark(fileInfoName, pathToPagesets, pathToPyFiles, localOutputDir, chromiumBuildName, chromiumBinary, runID, browserExtraArgs string) error {
	pagesetBaseName := filepath.Base(fileInfoName)
	if pagesetBaseName == util.TIMESTAMP_FILE_NAME || filepath.Ext(pagesetBaseName) == ".pyc" {
		// Ignore timestamp files and .pyc files.
		return nil
	}

	// Convert the filename into a format consumable by the run_benchmarks
	// binary.
	pagesetName := strings.TrimSuffix(pagesetBaseName, filepath.Ext(pagesetBaseName))
	pagesetPath := filepath.Join(pathToPagesets, fileInfoName)

	glog.Infof("===== Processing %s for %s =====", pagesetPath, runID)

	skutil.LogErr(os.Chdir(pathToPyFiles))
	args := []string{
		util.BINARY_RUN_BENCHMARK,
		fmt.Sprintf("%s.%s", *benchmarkName, util.BenchmarksToPagesetName[*benchmarkName]),
		"--page-set-name=" + pagesetName,
		"--page-set-base-dir=" + pathToPagesets,
		"--also-run-disabled-tests",
	}

	// Need to capture output for all benchmarks.
	outputDirArgValue := filepath.Join(localOutputDir, pagesetName)
	args = append(args, "--output-dir="+outputDirArgValue)
	// Figure out which browser should be used.
	if *targetPlatform == util.PLATFORM_ANDROID {
		if err := installChromeAPK(chromiumBuildName); err != nil {
			return fmt.Errorf("Error while installing APK: %s", err)
		}
		args = append(args, "--browser=android-chrome-shell")
	} else {
		args = append(args, "--browser=exact", "--browser-executable="+chromiumBinary)
	}
	// Split benchmark args if not empty and append to args.
	if *benchmarkExtraArgs != "" {
		for _, benchmarkArg := range strings.Split(*benchmarkExtraArgs, " ") {
			args = append(args, benchmarkArg)
		}
	}
	// Add the number of times to repeat.
	args = append(args, fmt.Sprintf("--page-repeat=%d", *repeatBenchmark))
	// Add browserArgs if not empty to args.
	if browserExtraArgs != "" {
		args = append(args, "--extra-browser-args="+browserExtraArgs)
	}
	// Set the PYTHONPATH to the pagesets and the telemetry dirs.
	env := []string{
		fmt.Sprintf("PYTHONPATH=%s:%s:%s:$PYTHONPATH", pathToPagesets, util.TelemetryBinariesDir, util.TelemetrySrcDir),
		"DISPLAY=:0",
	}
	timeoutSecs := util.PagesetTypeToInfo[*pagesetType].RunChromiumPerfTimeoutSecs
	if err := util.ExecuteCmd("python", args, env, time.Duration(timeoutSecs)*time.Second, nil, nil); err != nil {
		glog.Errorf("Run benchmark command failed with: %s", err)
		glog.Errorf("Killing all running chrome processes in case there is a non-recoverable error.")
		skutil.LogErr(util.ExecuteCmd("pkill", []string{"-9", "chrome"}, []string{}, 5*time.Minute, nil, nil))
	}
	return nil
}

示例#8
文件: ipa.go 项目: raceli/gohttp

func NewPlistHandler(rootDir string) macaron.Handler {
	return func(r *http.Request, w http.ResponseWriter, ctx *macaron.Context) {
		relpath := ctx.Params("*")
		if filepath.Ext(relpath) == ".plist" {
			relpath = relpath[0:len(relpath)-6] + ".ipa"
		}
		abspath := filepath.Join(rootDir, relpath)

		plinfo, err := parseIPA(abspath)
		if err != nil {
			log.Println(err)
			ctx.Error(500, err.Error())
			return
		}
		filepath.Ext(relpath)
		ipaURL := url.URL{
			Scheme: "https",
			Host:   r.Host,
			Path:   relpath,
		}
		imgURL := url.URL{
			Scheme: "https",
			Host:   r.Host,
			Path:   filepath.Join("/$ipaicon", relpath),
		}
		data, err := generateDownloadPlist(ipaURL.String(), imgURL.String(), plinfo)
		if err != nil {
			ctx.Error(500, err.Error())
			return
		}
		w.Header().Set("Content-Type", "text/xml")
		w.Write(data)
	}
}

示例#9
文件: doc.go 项目: yuzhouisme/website

func (dc *DocController) Prepare() {
	dc.BaseController.Prepare()

	// get correct file in doc directory
	p := dc.Ctx.Request.URL.Path
	p = strings.Replace(p, "/docs", "beedoc/"+dc.Lang, -1)
	p = strings.TrimRight(p, "/")
	if filepath.Ext(p) == "" {
		p += ".md"
	}
	dc.docFile = p

	// serve static file
	if filepath.Ext(p) != ".md" {
		http.ServeFile(dc.Ctx.ResponseWriter, dc.Ctx.Request, p)
		dc.StopRun()
	}

	// render md doc file
	if err := dc.renderDoc(); err != nil {
		dc.CustomAbort(503, err.Error())
		return
	}

}

示例#10
文件: gomediaserver.go 项目: Nixes/GoMediaServer

// this converts pngs and jpgs to smaller jpgs, and writes them out to the http connection, this thing EATS ALL THE MEMORY
func generateThumb(w http.ResponseWriter, path string) {
	file, err := os.Open(path)
	if err != nil {
		fmt.Print("Error opening image:", err)
	}
	var img image.Image = nil
	if filepath.Ext(path) == ".png" {
		img, err = png.Decode(file)
		if err != nil {
			fmt.Print("Error decoding image:", err)
			return
		}
		file.Close()
	} else if filepath.Ext(path) == ".jpg" {
		img, err = jpeg.Decode(file)
		if err != nil {
			fmt.Print("Error decoding image:", err)
			return
		}
		file.Close()
	} else {
		return
	}
	// resize to height 200
	err = jpeg.Encode(w, resize.Resize(0, 200, img, resize.NearestNeighbor), nil)
	if err != nil {
		fmt.Print("Error encoding thumb:", err)
	}
}

示例#11
文件: service.go 项目: huuzkee-foundation/winsvc

func walkpath(path string, f os.FileInfo, err error, outfile *os.File, fchan chan FileDesc) error {

	filetype := "FILE"
	if f.IsDir() {
		filetype = "DIR"
	}
	outfile.WriteString(filetype)
	outfile.WriteString(",\t\"")
	outfile.WriteString(f.Name())
	outfile.WriteString("\",\t")
	outfile.WriteString(filepath.Ext(path))
	outfile.WriteString(",\t\"")
	outfile.WriteString(filepath.Dir(path))
	outfile.WriteString("\",\t\"")
	outfile.WriteString(f.ModTime().String())
	outfile.WriteString("\",\t")
	outfile.WriteString(strconv.Itoa(int(f.Size())))
	outfile.WriteString(",\t\"")
	outfile.WriteString(path)
	outfile.WriteString("\"\r\n")

	fdesc := FileDesc{"0000", filetype, f.Name(), filepath.Ext(path), filepath.Dir(path), path, strconv.Itoa(int(f.Size())), f.ModTime().String()}
	fchan <- fdesc

	return nil
}

示例#12
文件: media.go 项目: if1live/makina

// 트윗에 붙은 이미지가 여러개인 경우와 한개인 경우를 구분
func MakeMediaFileName(tweet *anaconda.Tweet, media anaconda.EntityMedia) string {
	mediaCount := len(tweet.ExtendedEntities.Media)
	if mediaCount <= 1 {
		url := FindMediaURL(media)
		ext := filepath.Ext(url)
		return fmt.Sprintf("%s%s", tweet.IdStr, ext)
	}

	found := -1
	for i := 0; i < mediaCount; i++ {
		m := tweet.ExtendedEntities.Media[i]
		if m.Media_url == media.Media_url {
			found = i
			break
		}
	}

	if found < 0 {
		// not found
		return ""
	}

	num := found + 1
	url := FindMediaURL(media)
	ext := filepath.Ext(url)
	return fmt.Sprintf("%s_%d%s", tweet.IdStr, num, ext)
}

示例#13
文件: open.go 项目: knutsel/httpcache

// Open returns an in-memory VFS initialized with the contents
// of the given filename, which must have one of the following
// extensions:
//
//  - .zip
//  - .tar
//  - .tar.gz
//  - .tar.bz2
func Open(filename string) (VFS, error) {
	f, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer f.Close()
	base := filepath.Base(filename)
	ext := strings.ToLower(filepath.Ext(base))
	nonExt := filename[:len(filename)-len(ext)]
	if strings.ToLower(filepath.Ext(nonExt)) == ".tar" {
		ext = ".tar" + ext
	}
	switch ext {
	case ".zip":
		st, err := f.Stat()
		if err != nil {
			return nil, err
		}
		return Zip(f, st.Size())
	case ".tar":
		return Tar(f)
	case ".tar.gz":
		return TarGzip(f)
	case ".tar.bz2":
		return TarBzip2(f)
	}
	return nil, fmt.Errorf("can't open a VFS from a %s file", ext)
}

示例#14
文件: stegosaurus.go 项目: jbeda/stegosaurus

// loadTemplates walks sourceDir and loads all base templates into t.  These
// are files that have a '.tmpl' extensions and a leading underscore.  The
// template name is the filename with those stripped.
func loadBaseTemplates(t *template.Template) error {
	return filepath.Walk(*sourceDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if info.IsDir() {
			return nil
		}

		basename := filepath.Base(path)
		// Only handle files that start with _
		if !strings.HasPrefix(basename, "_") {
			return nil
		}

		// Only handle files with ".tmpl" extension
		ext := filepath.Ext(basename)
		if ext != ".tmpl" {
			return nil
		}

		fmt.Printf("Loading template file: %v\n", path)

		// Strip off "_" and ".tmpl"
		name := strings.TrimPrefix(strings.TrimSuffix(basename, filepath.Ext(basename)), "_")
		data, err := ioutil.ReadFile(path)
		_, err = t.New(name).Parse(string(data))
		if err != nil {
			return err
		}
		return nil
	})
}

示例#15
文件: command.go 项目: todashuta/goemon

func (g *goemon) externalCommand(command, file string) bool {
	var cmd *exec.Cmd
	command = os.Expand(command, func(s string) string {
		switch s {
		case "GOEMON_TARGET_FILE":
			return file
		case "GOEMON_TARGET_BASE":
			return filepath.Base(file)
		case "GOEMON_TARGET_DIR":
			return filepath.ToSlash(filepath.Dir(file))
		case "GOEMON_TARGET_EXT":
			return filepath.Ext(file)
		case "GOEMON_TARGET_NAME":
			fn := filepath.Base(file)
			ext := filepath.Ext(file)
			return fn[:len(fn)-len(ext)]
		}
		return os.Getenv(s)
	})
	if runtime.GOOS == "windows" {
		cmd = exec.Command("cmd", "/c", command)
	} else {
		cmd = exec.Command("sh", "-c", command)
	}
	g.Logger.Println("executing", command)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	err := cmd.Run()
	if err != nil {
		g.Logger.Println(err)
		return false
	}
	return true
}

示例#16
文件: file_resource.go 项目: pombredanne/webmachine.go

func (p *FileResource) ContentTypesProvided(req Request, cxt Context) ([]MediaTypeHandler, Request, Context, int, os.Error) {
	frc := cxt.(FileResourceContext)
	var arr []MediaTypeHandler
	if frc.IsDir() {
		arr = []MediaTypeHandler{NewJsonDirectoryListing(frc.FullPath(), req.URL().Path), NewHtmlDirectoryListing(frc.FullPath(), req.URL().Path)}
	} else if frc.HasMultipleResources() {
		dir, _ := path.Split(frc.FullPath())
		filenames := frc.MultipleResourceNames()
		arr = make([]MediaTypeHandler, len(filenames))
		for i, filename := range filenames {
			extension := filepath.Ext(filename)
			mediaType := mime.TypeByExtension(extension)
			if len(mediaType) == 0 {
				// default to text/plain
				mediaType = MIME_TYPE_TEXT_PLAIN
			}
			fullFilename := path.Join(dir, filename)
			tempFrc := NewFileResourceContextWithPath(fullFilename)
			arr[i] = NewPassThroughMediaTypeHandler(mediaType, tempFrc, tempFrc.Len(), tempFrc.LastModified())
		}
	} else {
		extension := filepath.Ext(frc.FullPath())
		mediaType := mime.TypeByExtension(extension)
		if len(mediaType) == 0 {
			// default to text/plain
			mediaType = MIME_TYPE_TEXT_PLAIN
		}
		arr = []MediaTypeHandler{NewPassThroughMediaTypeHandler(mediaType, frc, frc.Len(), frc.LastModified())}
	}
	return arr, req, cxt, 0, nil
}

示例#17
文件: gtfsd.go 项目: npaton/gogtfs

func discoverGtfsPaths(path string) (results []string) {
	// log.Println("discoverGtfsPaths")
	path = filepath.Clean(path)
	fileInfo, err := os.Lstat(path)
	if err != nil {
		return
	}

	if fileInfo.IsDir() {
		file, err := os.Open(path)
		if err != nil {
			return
		}
		defer file.Close()
		fileInfos, err := file.Readdir(-1)
		if err != nil {
			return
		}

		requiredFiles := gtfs.RequiredFiles
		requiredCalendarFiles := gtfs.RequiredEitherCalendarFiles
		foundCalendar := false
		foundFiles := make([]string, 0, len(requiredFiles))
		for _, fi := range fileInfos {
			name := fi.Name()
			if fi.IsDir() {
				subdirectoryResults := discoverGtfsPaths(path + "/" + name)
				for _, newpath := range subdirectoryResults {
					results = append(results, newpath)
				}
			} else if filepath.Ext(name) == ".zip" {
				results = append(results, path+"/"+name)
			} else {
				for _, f := range requiredFiles {
					if name == f { // This loops a little too much but hey...
						foundFiles = append(foundFiles, f)
					}
				}
				if !foundCalendar {
					for _, f := range requiredCalendarFiles {
						if name == f {
							foundCalendar = true
						}
					}
				}

			}
		}

		if len(foundFiles) == len(requiredFiles) && foundCalendar {
			results = append(results, path)
		}

	} else {
		if filepath.Ext(path) == ".zip" {
			results = append(results, path)
		}
	}
	return
}

示例#18
文件: mpeg.go 项目: dankomiocevic/mulifs

// GetMp3Tags returns a FileTags struct with
// all the information obtained from the tags in the
// MP3 file.
// Includes the Artist, Album and Song and defines
// default values if the values are missing.
// If the tags are missing, the default values will
// be stored on the file.
// If the tags are obtained correctly the first
// return value will be nil.
func GetMp3Tags(path string) (error, FileTags) {
	mp3File, err := id3.Open(path)
	if err != nil {
		_, file := filepath.Split(path)
		extension := filepath.Ext(file)
		songTitle := file[0 : len(file)-len(extension)]
		return err, FileTags{songTitle, "unknown", "unknown"}
	}

	defer mp3File.Close()

	title := mp3File.Title()
	if title == "" || title == "unknown" {
		_, file := filepath.Split(path)
		extension := filepath.Ext(file)
		title = file[0 : len(file)-len(extension)]
		mp3File.SetTitle(title)
	}

	artist := mp3File.Artist()
	if artist == "" {
		artist = "unknown"
		mp3File.SetArtist(artist)
	}

	album := mp3File.Album()
	if album == "" {
		album = "unknown"
		mp3File.SetAlbum(album)
	}

	ft := FileTags{title, artist, album}
	return nil, ft
}

示例#19
文件: matcher.go 项目: bmatsuo/gutterd

// Match a torrent against the patterns of m. If all non-nil patterns match the
// corresponding fields in torrent, then the method returns true.
func (m *Matcher) Match(torrent *metadata.Metadata) bool {
	if m.Tracker != nil {
		if !m.Tracker.MatchString(torrent.Announce) {
			return false
		}
	}
	if m.Ext != nil {
		var exts []string
		if torrent.Info.SingleFileMode() {
			exts = append(exts, filepath.Ext(torrent.Info.Name))
		} else {
			for _, file := range torrent.Info.Files {
				path := file.Path
				exts = append(exts, filepath.Ext(path[len(path)-1]))
			}
		}
		matches := false
		for _, ext := range exts {
			if m.Ext.MatchString(ext) {
				matches = true
			}
		}
		if !matches {
			return false
		}
	}
	if m.Basename != nil {
		basename := filepath.Base(torrent.Info.Name)
		if !m.Basename.MatchString(basename) {
			return false
		}
	}
	return true
}

示例#20
文件: scanner.go 项目: amaniak/gel

func (s *Scanner) findSQLFiles(pathToFile string, f os.FileInfo, err error) error {
	if filepath.Ext(f.Name()) == SQL_EXTENSTION {

		namespace := strings.TrimSuffix(f.Name(), filepath.Ext(f.Name()))
		file, err := os.Open(pathToFile)

		defer file.Close()

		buffer := bufio.NewScanner(file)

		if err != nil {
			log.Fatal(err)
		}

		line := 1

		for buffer.Scan() {
			fileInfo := &FileInfo{namespace, f.Name(), pathToFile}

			node := &Ast{fileInfo, line,
				buffer.Text(), buffer.Bytes(), ""}
			s.Buffer = append(s.Buffer, node)
			line = line + 1
		}
	}
	return nil
}

示例#21
文件: test_suite.go 项目: 40a/bootkube

func PrecompiledTestSuite(path string) (TestSuite, error) {
	info, err := os.Stat(path)
	if err != nil {
		return TestSuite{}, err
	}

	if info.IsDir() {
		return TestSuite{}, errors.New("this is a directory, not a file")
	}

	if filepath.Ext(path) != ".test" {
		return TestSuite{}, errors.New("this is not a .test binary")
	}

	if info.Mode()&0111 == 0 {
		return TestSuite{}, errors.New("this is not executable")
	}

	dir := relPath(filepath.Dir(path))
	packageName := strings.TrimSuffix(filepath.Base(path), filepath.Ext(path))

	return TestSuite{
		Path:        dir,
		PackageName: packageName,
		IsGinkgo:    true,
		Precompiled: true,
	}, nil
}

示例#22
文件: server.go 项目: mengzhuo/bla

func (s *Server) LoadStaticFiles() {

	log.Print("Rebuild from: ", Cfg.TemplatePath)
	Link(filepath.Join(Cfg.TemplatePath, "asset"),
		filepath.Join(Cfg.PublicPath, Cfg.BasePath, "asset"))

	log.Print("Loading Asset files")

	orig, err := filepath.Abs(filepath.Join(Cfg.TemplatePath, "asset"))
	if err != nil {
		log.Fatal(err)
	}

	filepath.Walk(orig,
		func(path string, info os.FileInfo, e error) (err error) {

			if info == nil || !info.Mode().IsRegular() {
				return
			}
			if !(filepath.Ext(path) == ".css" || filepath.Ext(path) == ".js") {
				return
			}
			log.Print("|- ", path)
			s.StaticFiles = append(s.StaticFiles, path)
			return
		})
}

示例#23
文件: aws_test.go 项目: kljensen/aws

// Get a list of the files in the AWS test suite.
//
func getAWSSuiteFiles(dir string) (files []string, err error) {

	d, err := os.Open(dir)
	if err != nil {
		return
	}
	f, err := d.Readdirnames(0)
	if err != nil {
		return
	}

	sort.Strings(f)

	files = make([]string, 0)
	for i := 0; i < len(f)-1; {
		if filepath.Ext(f[i]) == ".req" &&
			filepath.Ext(f[i+1]) == ".sreq" {
			files = append(files, f[i][:len(f[i])-4])
			i += 2
		} else {
			i++
		}
	}
	return

}

示例#24
文件: main.go 项目: useidel/notary

func parseConfig() *viper.Viper {
	if verbose {
		logrus.SetLevel(logrus.DebugLevel)
		logrus.SetOutput(os.Stderr)
	}

	// Get home directory for current user
	homeDir, err := homedir.Dir()
	if err != nil {
		fatalf("Cannot get current user home directory: %v", err)
	}
	if homeDir == "" {
		fatalf("Cannot get current user home directory")
	}

	// By default our trust directory (where keys are stored) is in ~/.notary/
	mainViper.SetDefault("trust_dir", filepath.Join(homeDir, filepath.Dir(configDir)))

	// If there was a commandline configFile set, we parse that.
	// If there wasn't we attempt to find it on the default location ~/.notary/config
	if configFile != "" {
		configFileExt = strings.TrimPrefix(filepath.Ext(configFile), ".")
		configFileName = strings.TrimSuffix(filepath.Base(configFile), filepath.Ext(configFile))
		configPath = filepath.Dir(configFile)
	} else {
		configPath = filepath.Join(homeDir, filepath.Dir(configDir))
	}

	// Setup the configuration details into viper
	mainViper.SetConfigName(configFileName)
	mainViper.SetConfigType(configFileExt)
	mainViper.AddConfigPath(configPath)

	// Find and read the config file
	err = mainViper.ReadInConfig()
	if err != nil {
		logrus.Debugf("Configuration file not found, using defaults")
		// If we were passed in a configFile via -c, bail if it doesn't exist,
		// otherwise ignore it: we can use the defaults
		if configFile != "" || !os.IsNotExist(err) {
			fatalf("error opening config file %v", err)
		}
	}

	// At this point we either have the default value or the one set by the config.
	// Either way, the command-line flag has precedence and overwrites the value
	if trustDir != "" {
		mainViper.Set("trust_dir", trustDir)
	}

	// Expands all the possible ~/ that have been given, either through -d or config
	// If there is no error, use it, if not, attempt to use whatever the user gave us
	expandedTrustDir, err := homedir.Expand(mainViper.GetString("trust_dir"))
	if err == nil {
		mainViper.Set("trust_dir", expandedTrustDir)
	}
	logrus.Debugf("Using the following trust directory: %s", mainViper.GetString("trust_dir"))

	return mainViper
}

示例#25
文件: basic-epub.go 项目: laumann/go-play

// Processing a book
func (book *Book) process() {
	mimetype()
	fmt.Printf("%#v\n", book)

	toInclude := []string{"mimetype"} // mimetype MUST be the first file in the archive

	filepath.Walk(config.workDir, func(path string, info os.FileInfo, err error) error {
		if err == nil && ismember(filepath.Ext(path), &fileExtToInclude) {
			toInclude = append(toInclude, path)
		}
		return err
	})
	fmt.Printf("Files to include: %s\n", toInclude)

	// Process is as follows
	// 1. get book details: author, title + list of files to process
	// 2. Process files individually
	// 3. Generate OPF from spine and metadata
	// 4. zip generated files and auxiliary files in .epub (this should be
	//    done from the original "source" directory.

	// Step 4:
	if config.epubFile == "" {
		config.epubFile = strings.Replace(strings.Replace(book.title, " ", "-", -1), ",", "", -1)
	}

	if filepath.Ext(config.epubFile) != ".epub" {
		config.epubFile += ".epub"
	}

	fmt.Printf("Outputting to file: %s\n", config.epubFile)
}

示例#26
文件: manifest.go 项目: helm/helm-classic

// Files gets a list of all manifest files inside of a chart.
//
// chartDir should contain the path to a chart (the directory which
// holds a Chart.yaml file).
//
// This returns an error if it can't access the directory.
func Files(chartDir string) ([]string, error) {
	dir := filepath.Join(chartDir, "manifests")
	files := []string{}

	if _, err := os.Stat(dir); err != nil {
		return files, err
	}

	// add manifest files
	walker := func(fname string, fi os.FileInfo, e error) error {
		if e != nil {
			log.Warn("Encountered error walking %q: %s", fname, e)
			return nil
		}

		if fi.IsDir() {
			return nil
		}

		if filepath.Ext(fname) == ".yaml" || filepath.Ext(fname) == ".yml" {
			files = append(files, fname)
		}

		return nil
	}
	filepath.Walk(dir, walker)

	return files, nil
}

示例#27
文件: discovery.go 项目: RAMESHBABUK/docker

// Scan scans all the plugin paths and returns all the names it found
func Scan() ([]string, error) {
	var names []string
	if err := filepath.Walk(socketsPath, func(path string, fi os.FileInfo, err error) error {
		if err != nil {
			return nil
		}

		if fi.Mode()&os.ModeSocket != 0 {
			name := strings.TrimSuffix(fi.Name(), filepath.Ext(fi.Name()))
			names = append(names, name)
		}
		return nil
	}); err != nil {
		return nil, err
	}

	for _, path := range specsPaths {
		if err := filepath.Walk(path, func(p string, fi os.FileInfo, err error) error {
			if err != nil || fi.IsDir() {
				return nil
			}
			name := strings.TrimSuffix(fi.Name(), filepath.Ext(fi.Name()))
			names = append(names, name)
			return nil
		}); err != nil {
			return nil, err
		}
	}
	return names, nil
}

示例#28
文件: imagetagserver.go 项目: rasmuswz/imagetag

func (ths *ImageTagServer) go_list_dir(w http.ResponseWriter, r *http.Request) {
	var exts map[string]bool = map[string]bool{".jpg": true, ".png": true, ".JPG": true}

	path := r.URL.Query().Get("path")
	path = ths.imgRoot + path
	path = strings.Replace(path, "..", "", -1)

	println("Path: " + path)

	info, infoErr := os.Stat(path)
	if infoErr != nil {
		ths.GetEvents() <- "Path err: " + infoErr.Error()
		http.Error(w, infoErr.Error(), http.StatusNotFound)
		return
	}

	if info.IsDir() == false {
		ths.GetEvents() <- path + " - no such directory"
		http.Error(w, "No such directory", http.StatusNotFound)
		return
	}

	result := new(Directory)
	result.Name = info.Name()

	children := bytes.NewBuffer(nil)

	files, _ := ioutil.ReadDir(path)
	for file := range files {
		finfo, finfoErr := os.Stat(path + "/" + files[file].Name())
		if finfoErr != nil {
			ths.GetEvents() <- finfoErr.Error()
			continue
		}

		if finfo.IsDir() == true {
			fname := filepath.Base(files[file].Name())
			children.WriteString(fname + "|" + ITEM_TYPE_DIR + ";")
		} else {
			ths.events <- ("Extension is: " + filepath.Ext(path+finfo.Name()))
			if _, ok := exts[filepath.Ext(path+finfo.Name())]; ok {
				fname := filepath.Base(files[file].Name())
				children.WriteString(fname + "|" + ITEM_TYPE_IMG + ";")
			}
		}
	}

	result.Children = children.String()
	println(result.Children)
	jsonStr, jsonStrErr := json.Marshal(result)
	if jsonStrErr != nil {
		ths.GetEvents() <- jsonStrErr.Error()
	}

	println(string(jsonStr))
	w.Write(jsonStr)
	return

}

示例#29
文件: assets.go 项目: influx6/todo

// AssetTree provides a map tree of files across the given directory that match the filenames being used
func AssetTree(dir string, ext string) (AssetMap, error) {
	var stat os.FileInfo
	var err error

	//do the path exists
	if stat, err = os.Stat(dir); err != nil {
		return nil, err
	}

	var tree = make(AssetMap)

	//do we have a directory?
	if !stat.IsDir() {

		var fext string
		var rel = filepath.Base(dir)

		if strings.Index(rel, ".") != -1 {
			fext = filepath.Ext(rel)
		}

		if fext == ext {
			tree[rel] = filepath.ToSlash(dir)
		}

	} else {
		filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {

			//if info is nil or is a directory when we skip
			if info == nil || info.IsDir() {
				return nil
			}

			var rel string
			var rerr error

			//is this path relative to the current one, if not,return err
			if rel, rerr = filepath.Rel(dir, path); rerr != nil {
				return rerr
			}

			var fext string

			if strings.Index(rel, ".") != -1 {
				fext = filepath.Ext(rel)
			}

			if fext == ext {
				tree[rel] = filepath.ToSlash(path)
				// tree[strings.TrimSuffix(rel, ext)] = filepath.ToSlash(path)
			}

			return nil
		})

	}

	return tree, nil
}

示例#30
文件: list.go 项目: kameleon83/raspDlna

func List(dir string) []models.FileInfo {
	list := []models.FileInfo{}
	fi := models.FileInfo{}
	if info, err := os.Stat(dir); err == nil && info.IsDir() {
		f, _ := ioutil.ReadDir(dir)
		for _, entry := range f {
			namePresent := ""
			fileNotExt := strings.TrimSuffix(entry.Name(), filepath.Ext(entry.Name()))
			taille, nomTaille := Taille(float64(entry.Size()))
			if a, _ := SrtOrNot(entry.Name()); a != true {
				for _, entry2 := range f {
					tailleSrt, SrtNametaillle := Taille(float64(entry2.Size()))
					if a, b := SrtOrNot(entry2.Name()); a == true {
						if fileNotExt == b {
							namePresent = entry.Name()
							fi = models.FileInfo{
								Name:          entry.Name(),
								NameExt:       filepath.Ext(entry.Name()),
								Size:          float64(int(taille*100)) / 100,
								Mode:          entry.Mode(),
								ModTime:       entry.ModTime(),
								IsDir:         entry.IsDir(),
								NameSize:      nomTaille,
								Srt:           1,
								SizeSrt:       float64(int(tailleSrt*100)) / 100,
								NameTailleSrt: SrtNametaillle,
								GetUid:        entry.Sys().(*syscall.Stat_t).Uid,
								GetGid:        entry.Sys().(*syscall.Stat_t).Gid,
							}
							fi.Lock()
							list = append(list, fi)
							fi.Unlock()
						}
					}
				}
				if namePresent != entry.Name() {

					fi = models.FileInfo{
						Name:     entry.Name(),
						NameExt:  filepath.Ext(entry.Name()),
						Size:     float64(int(taille*100)) / 100,
						Mode:     entry.Mode(),
						ModTime:  entry.ModTime(),
						IsDir:    entry.IsDir(),
						NameSize: nomTaille,
						Srt:      0,
						GetUid:   entry.Sys().(*syscall.Stat_t).Uid,
						GetGid:   entry.Sys().(*syscall.Stat_t).Gid,
					}
					fi.Lock()
					list = append(list, fi)
					fi.Unlock()
				}

			}
		}
	}
	return list
}

展开阅读全文