Golang ReadDir示例

说明

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

编程语言: Golang

命名空间/包名称: io/ioutil

示例#1
文件: data.go 项目: rugo/randomman

/*
 * Holy moly, what a mess!
 */
func LoadAvailableManpages(basedir string) map[int][]string {
	availablePages := make(map[int][]string)

	sectionDirs, err := ioutil.ReadDir(basedir)
	if err != nil {
		log.Print(err)
	}
	for _, sectionDir := range sectionDirs {
		if sectionDir.IsDir() {
			sectionDirPath := path.Join(basedir, sectionDir.Name())
			files, err := ioutil.ReadDir(sectionDirPath)
			if err != nil {
				log.Print(err)
			}
			sectionNumber, err := strconv.Atoi(sectionDir.Name()[len(sectionDir.Name())-1:])
			if err != nil {
				log.Print(err)
			}
			for _, file := range files {
				if !file.IsDir() && strings.HasSuffix(file.Name(), ".html") {
					if _, ok := availablePages[sectionNumber]; !ok {
						availablePages[sectionNumber] = []string{}
					}
					availablePages[sectionNumber] = append(
						availablePages[sectionNumber],
						path.Join(sectionDirPath, file.Name()))
				}
			}

		}
	}
	return availablePages
}

示例#2
文件: default.go 项目: dsnet/gotab

func suggestPaths(tok string) (cnt int) {
	root, base := path.Split(tok)
	if isDir(tok) {
		root, base = tok, ""
	}

	fis, _ := ioutil.ReadDir(root)
	if root == "" {
		fis, _ = ioutil.ReadDir(".")
	}

	for _, fi := range fis {
		if strings.Index(fi.Name(), base) != 0 {
			// Skip paths don't match the partial token
			continue
		}
		if strings.Index(fi.Name(), ".") == 0 && len(base) == 0 {
			// Skip hidden folders unless there is a partial match
			continue
		}
		if fi.IsDir() {
			fmt.Println(root + fi.Name() + string(os.PathSeparator))
			cnt++
		} else {
			fmt.Println(root + fi.Name() + " ")
			cnt++
		}
	}
	return cnt
}

示例#3
文件: null.go 项目: contiv/volplugin

// Mounted shows any volumes that belong to volplugin on the host, in
// their native representation. They yield a *Mount.
func (d *Driver) Mounted(time.Duration) ([]*storage.Mount, error) {
	mounts := []*storage.Mount{}
	fis, err := ioutil.ReadDir(d.mountpath)
	if os.IsNotExist(err) {
		return mounts, os.MkdirAll(d.mountpath, 0700)
	} else if err != nil {
		return nil, errored.Errorf("Reading policy tree for mounts").Combine(err)
	}

	for _, fi := range fis {
		volumes, err := ioutil.ReadDir(filepath.Join(d.mountpath, fi.Name()))
		if err != nil {
			return nil, errored.Errorf("Reading mounted volumes for policy %q", fi.Name()).Combine(err)
		}

		for _, vol := range volumes {
			rel := filepath.Join(d.mountpath, fi.Name(), vol.Name())
			if err != nil {
				return nil, errored.Errorf("Calculating mount information for %q/%q", fi.Name(), vol.Name()).Combine(err)
			}

			mounts = append(mounts, &storage.Mount{
				Path: rel,
				Volume: storage.Volume{
					Name:   rel,
					Source: "null",
				},
			})
		}
	}

	return mounts, nil
}

示例#4
文件: util.go 项目: uwedeportivo/romba

func deleteEmptyFoldersImpl(root string, level int) error {
	fis, err := ioutil.ReadDir(root)
	if err != nil {
		return err
	}

	foundPlain := false

	for _, sfi := range fis {
		if sfi.IsDir() {
			err = deleteEmptyFoldersImpl(filepath.Join(root, sfi.Name()), level+1)
			if err != nil {
				return err
			}
		} else {
			foundPlain = true
		}
	}

	if !foundPlain && level > 0 {
		fis, err = ioutil.ReadDir(root)
		if err != nil {
			return err
		}

		if len(fis) == 0 {
			err = os.Remove(root)
			if err != nil {
				return err
			}
		}
	}
	return nil
}

示例#5
文件: backup_test.go 项目: matomesc/rkt

func checkDirectory(dir string, expected map[string]string) error {
	list, err := ioutil.ReadDir(dir)
	if err != nil {
		return err
	}
	for _, fi := range list {
		if !fi.IsDir() {
			return fmt.Errorf("%s is not a directory", fi.Name())
		}
		dirName := fi.Name()
		if _, err := strconv.Atoi(dirName); err != nil {
			return fmt.Errorf("Name is not a number: %v", err)
		}
		expectedFileName, ok := expected[dirName]
		if !ok {
			return fmt.Errorf("Unexpected name found: %s", dirName)
		}
		subList, err := ioutil.ReadDir(filepath.Join(dir, dirName))
		if err != nil {
			return fmt.Errorf("Failed to get a list of files in %s: %v",
				dirName, err)
		}
		filesCount := len(subList)
		if filesCount != 1 {
			return fmt.Errorf("Expected only 1 file in %s, got %d",
				dirName, filesCount)
		}
		gottenFileName := subList[0].Name()
		if gottenFileName != expectedFileName {
			return fmt.Errorf("Expected %s in %s, got %s",
				expectedFileName, dirName, gottenFileName)
		}
	}
	return nil
}

示例#6
文件: keyreadwriter_test.go 项目: docker/swarmkit

func TestKeyReadWriterMigrate(t *testing.T) {
	cert, key, err := testutils.CreateRootCertAndKey("cn")
	require.NoError(t, err)

	tempdir, err := ioutil.TempDir("", "KeyReadWriter")
	require.NoError(t, err)
	defer os.RemoveAll(tempdir)

	path := ca.NewConfigPaths(filepath.Join(tempdir))

	// if the key exists in an old location, migrate it from there.
	tempKeyPath := filepath.Join(filepath.Dir(path.Node.Key), "."+filepath.Base(path.Node.Key))
	require.NoError(t, ioutil.WriteFile(path.Node.Cert, cert, 0644))
	require.NoError(t, ioutil.WriteFile(tempKeyPath, key, 0600))

	krw := ca.NewKeyReadWriter(path.Node, nil, nil)
	require.NoError(t, krw.Migrate())
	_, err = os.Stat(tempKeyPath)
	require.True(t, os.IsNotExist(err)) // it's been moved to the right place
	_, _, err = krw.Read()
	require.NoError(t, err)

	// migrate does not affect any existing files
	dirList, err := ioutil.ReadDir(filepath.Dir(path.Node.Key))
	require.NoError(t, err)
	require.NoError(t, krw.Migrate())
	dirList2, err := ioutil.ReadDir(filepath.Dir(path.Node.Key))
	require.NoError(t, err)
	require.Equal(t, dirList, dirList2)
	_, _, err = krw.Read()
	require.NoError(t, err)
}

示例#7
文件: unionfs_test.go 项目: eric-autoref/go-fuse

func TestUnionFsFdLeak(t *testing.T) {
	beforeEntries, err := ioutil.ReadDir("/proc/self/fd")
	if err != nil {
		t.Fatalf("ReadDir failed: %v", err)
	}

	wd, clean := setupUfs(t)
	err = ioutil.WriteFile(wd+"/ro/file", []byte("blablabla"), 0644)
	if err != nil {
		t.Fatalf("WriteFile failed: %v", err)
	}
	setRecursiveWritable(t, wd+"/ro", false)

	contents, err := ioutil.ReadFile(wd + "/mnt/file")
	if err != nil {
		t.Fatalf("ReadFile failed: %v", err)
	}

	err = ioutil.WriteFile(wd+"/mnt/file", contents, 0644)
	if err != nil {
		t.Fatalf("WriteFile failed: %v", err)
	}

	clean()

	afterEntries, err := ioutil.ReadDir("/proc/self/fd")
	if err != nil {
		t.Fatalf("ReadDir failed: %v", err)
	}

	if len(afterEntries) != len(beforeEntries) {
		t.Errorf("/proc/self/fd changed size: after %v before %v", len(beforeEntries), len(afterEntries))
	}
}

示例#8
文件: lab_directory_structure.go 项目: pombredanne/antiplagiarism

// DirectoryContents returns a two-dimensional slice with full-path directories
// to send to dupl for evaluation. The first index addresses the specific lab,
// and the second index addresses the specific student. If a student does not
// have the lab directory, the 2D slice will save the directory as an empty
// string. The second return argument indicates whether or not the function was
// successful. DirectoryContents takes as input baseDir, the location of the
// student directories, and labs, a slice of the labs.
func DirectoryContents(baseDir string, labs []LabInfo) ([][]string, bool) {
	// Try to read the base directory
	contents, err := ioutil.ReadDir(baseDir)
	if err != nil {
		fmt.Printf("Error reading directory %s: %s\n", baseDir, err)
		return nil, false
	}

	var studentDirs []string
	// Get a list of all the student directories (full path)
	for _, item := range contents {
		if item.IsDir() {
			studentDirs = append(studentDirs, filepath.Join(baseDir, item.Name()))
		}
	}

	studentsLabDirs := make([][]string, len(labs))
	// For each lab
	for i := range studentsLabDirs {
		studentsLabDirs[i] = make([]string, len(studentDirs))

		// For each student
		for j := range studentsLabDirs[i] {
			tempDir := filepath.Join(studentDirs[j], labs[i].Name)
			_, err := ioutil.ReadDir(tempDir)
			if err != nil {
				studentsLabDirs[i][j] = ""
			} else {
				studentsLabDirs[i][j] = tempDir
			}
		}
	}

	return studentsLabDirs, true
}

示例#9
文件: mount_test.go 项目: jszwedko/ec2-metadatafs

func TestLiveness(t *testing.T) {
	dir := testutil.TempDir()
	defer os.RemoveAll(dir)
	root := nodefs.NewDefaultNode()
	s, _, err := nodefs.MountRoot(dir, root, nil)
	if err != nil {
		t.Fatalf("MountRoot: %v", err)
	}
	go s.Serve()
	if err := s.WaitMount(); err != nil {
		t.Fatal("WaitMount", err)
	}
	defer s.Unmount()

	if _, err := ioutil.ReadDir(dir); err != nil {
		t.Fatalf("ReadDir: %v", err)
	}

	// We previously encountered a sitation where a finalizer would close our fd out from under us. Try to force both finalizers to run and object destruction to complete.
	runtime.GC()
	runtime.GC()

	if _, err := ioutil.ReadDir(dir); err != nil {
		t.Fatalf("ReadDir: %v", err)
	}
}

示例#10
文件: engine.go 项目: simudream/konfig

// New is the constructor for a new engine.
func New(root, conditions string) (*Engine, error) {
	hostname, err := os.Hostname()
	if err != nil {
		return nil, err
	}

	engine := &Engine{Root: root, Hostname: hostname}

	if _, err := os.Stat(path.Join(engine.Root, "logic")); err == nil {
		logic, err := ioutil.ReadDir(path.Join(engine.Root, "logic"))
		if err != nil {
			return nil, err
		}
		engine.Logic = logic
	}

	if _, err := os.Stat(path.Join(engine.Root, "stacks")); err == nil {
		stacks, err := ioutil.ReadDir(path.Join(engine.Root, "stacks"))
		if err != nil {
			return nil, err
		}

		engine.Stacks = stacks
	}

	engine.DryRun = true
	engine.PythonPath = "python"
	engine.PipPath = "pip"
	engine.jsVM = otto.New()

	engine.SetConditions(conditions)

	return engine, nil
}

示例#11
文件: util.go 项目: pelamlio/capstan

func SearchInstance(name string) (instanceName, instancePlatform string) {
	instanceName = ""
	instancePlatform = ""
	rootDir := filepath.Join(HomePath(), ".capstan", "instances")
	platforms, _ := ioutil.ReadDir(rootDir)
	for _, platform := range platforms {
		if !platform.IsDir() {
			continue
		}
		platformDir := filepath.Join(rootDir, platform.Name())
		instances, _ := ioutil.ReadDir(platformDir)
		for _, instance := range instances {
			if !instance.IsDir() {
				continue
			}
			if name != instance.Name() {
				continue
			}
			instanceName = instance.Name()
			instancePlatform = platform.Name()
			return
		}
	}
	return
}

示例#12
文件: main.go 项目: matteosuppo/arduino-install-cores

func cleanup(directory string) {
	temp, err := ioutil.TempDir("", "")
	isError(err, "")
	files, err := ioutil.ReadDir(directory)
	isError(err, "")
	if 1 == len(files) {
		folder := filepath.Join(directory, files[0].Name())
		// Move to a tmp directory
		files, err = ioutil.ReadDir(folder)
		isError(err, "")
		for _, file := range files {
			var cmd *exec.Cmd
			cmd = exec.Command("mv", file.Name(), temp)
			cmd.Dir = folder
			output, err := cmd.CombinedOutput()
			isError(err, string(output))
		}
		err = os.RemoveAll(folder)
		isError(err, "")
		// move to the directory
		files, err = ioutil.ReadDir(temp)
		isError(err, "")
		for _, file := range files {
			var cmd *exec.Cmd
			cmd = exec.Command("mv", file.Name(), directory)
			cmd.Dir = temp
			output, err := cmd.CombinedOutput()
			isError(err, string(output))
		}
	}
}

示例#13
文件: merger.go 项目: blablacar/dgr

// list input files
func (in *inputs) listFiles() error {
	list_l1, err := ioutil.ReadDir(in.Directory)
	if err != nil {
		return err
	}
	for _, f_l1 := range list_l1 {
		if f_l1.Mode()&os.ModeSymlink == os.ModeSymlink {
			followed_file, err := os.Readlink(in.Directory + "/" + f_l1.Name())
			if err != nil {
				return err
			}
			if followed_file[0] != '/' {
				followed_file = in.Directory + "/" + followed_file
			}
			f_l1, err = os.Lstat(followed_file)
			if err != nil {
				return err
			}
			logs.WithField("followed_link", f_l1.Name()).Trace("Followed Link")
		}
		if f_l1.IsDir() {
			list_l2, err := ioutil.ReadDir(in.Directory + "/" + f_l1.Name())
			if err != nil {
				return err
			}
			for _, f_l2 := range list_l2 {
				in.Files = append(in.Files, f_l1.Name()+"/"+f_l2.Name())
			}
		} else {
			in.Files = append(in.Files, f_l1.Name())
		}
	}
	return nil
}

示例#14
文件: files.go 项目: katydid/katydid

func getFolders(path string) (map[string][]string, error) {
	folders := make(map[string][]string)
	codecFileInfos, err := ioutil.ReadDir(path)
	if err != nil {
		return nil, err
	}
	for _, codecFileInfo := range codecFileInfos {
		if !codecFileInfo.IsDir() {
			continue
		}
		codecFolderName := codecFileInfo.Name()
		codecPath := filepath.Join(path, codecFolderName)
		caseDirInfos, err := ioutil.ReadDir(codecPath)
		if err != nil {
			return nil, err
		}
		for _, caseDirInfo := range caseDirInfos {
			if !caseDirInfo.IsDir() {
				continue
			}
			casePath := filepath.Join(codecPath, caseDirInfo.Name())
			folders[codecFolderName] = append(folders[codecFolderName], casePath)
		}
	}
	return folders, nil
}

示例#15
文件: dalek-manager.go 项目: FRC-3637-Daleks/dalek-manager

func getLogList() ([]string, error) {
	var (
		files []string
		err   error
	)
	fileData, err := ioutil.ReadDir("dalek/logs")
	for _, f := range fileData {
		if f.IsDir() {
			console, manifest := false, false
			fileData, err := ioutil.ReadDir("dalek/logs/" + f.Name())
			if err != nil {
				return files, err
			}
			for _, f := range fileData {
				if f.Name() == "manifest.json" {
					manifest = true
				} else if f.Name() == "console.log" {
					console = true
				}
			}
			if manifest && console {
				files = append(files, f.Name())
			}
		}
	}
	return files, err
}

示例#16
文件: recorder.go 项目: ricorx7/echo

func getFileList() RecordedFileList {
	rootPath := *record + "record" + string(os.PathSeparator)

	// Read all the directory in the record folder
	files, _ := ioutil.ReadDir(rootPath)

	var recordedFiles RecordedFileList
	var fileList []RecordedFileInfo

	for _, f := range files {
		if f.IsDir() { // Find subfolders
			subFiles, _ := ioutil.ReadDir(rootPath + string(os.PathSeparator) + f.Name()) // Get the subfiles within subfolder
			for _, sf := range subFiles {
				subFile := new(RecordedFileInfo)         // Create struct
				subFile.RcrdFolder = rootPath + f.Name() // Set folder
				subFile.RcrdFile = sf.Name()             // Set file name
				fileList = append(fileList, *subFile)    // Add struct to list
			}
		}
	}

	// Set the file list
	recordedFiles.FileList = fileList

	fmt.Println("Recorded Files: ", recordedFiles)

	return recordedFiles
}

示例#17
文件: lol.go 项目: cfc4n/lol_replayer_for_tencent

func (this *launcher_commands) LolSetConfigPath(gameroot_path, runtime_path string) error {
	_, e := ioutil.ReadDir(gameroot_path)
	if e != nil {
		return e
	}
	this.gameroot_path = gameroot_path

	_, e = ioutil.ReadDir(runtime_path)
	if e != nil {
		return e
	}
	this.runtime_path = runtime_path

	this.gamelog_path = this.runtime_path + "/logs/"
	if _, e = os.Stat(this.gamelog_path); e != nil {
		e = os.Mkdir(this.gamelog_path, 0777)
		if e != nil {
			return e
		}
	}

	this.client_cn_dirname = "lol_air_client" //默认英文客户端路径
	//	this.client_cn_dirname = "lol_air_client_tencent"	//中文客户端路径
	return nil
}

示例#18
文件: disk_publisher_test.go 项目: vds/oops

func TestDiskPublisherWrite(t *testing.T) {
	o := oops.Oops{
		Id:    "oopsId",
		Error: errors.New("this is an error").Error(),
	}
	tempFolder, err := ioutil.TempDir("/tmp", "oops")
	if err != nil {
		t.Error("error creating temporary directory for oopses")
	}
	defer os.RemoveAll(tempFolder)

	fileInfo, err := ioutil.ReadDir(tempFolder)
	if err != nil {
		t.Error("error reading temporary directory")
	}
	if len(fileInfo) != 0 {
		t.Error("error, temporary directory not empty")
	}
	dp := oops.DiskPublisher{tempFolder}
	err = dp.Write(o)
	if err != nil {
		t.Error("error writing the oops")
	}
	fileInfo, err = ioutil.ReadDir(tempFolder)
	if err != nil {
		t.Error("error reading temporary directory")
	}
	if len(fileInfo) != 1 {
		t.Error("error, temporary directory should contain only one oops")
	}
}

示例#19
文件: servicebuilder.go 项目: rudle/p2

// using the servicebuilder yaml files, find any extraneous runit services and
// remove them
// runsvdir automatically stops services that no longer exist, explicit stop is
// not required
func (s *ServiceBuilder) Prune() error {
	configs, err := s.loadConfigDir()
	if err != nil {
		return err
	}

	links, err := ioutil.ReadDir(s.RunitRoot)
	if err != nil {
		return err
	}
	for _, link := range links {
		if _, exists := configs[link.Name()]; !exists {
			if err = os.Remove(filepath.Join(s.RunitRoot, link.Name())); err != nil {
				return err
			}
		}
	}

	stages, err := ioutil.ReadDir(s.StagingRoot)
	if err != nil {
		return err
	}
	for _, stage := range stages {
		if _, exists := configs[stage.Name()]; !exists {
			if err = os.RemoveAll(filepath.Join(s.StagingRoot, stage.Name())); err != nil {
				return err
			}
		}
	}

	return nil
}

示例#20
文件: kalecgos.go 项目: RichoDemus/kalecgos

// Takes the path to the addons directory and returns a slice of addons
func getAddons(addonsDirectory string) []addon {
	addons := make([]addon, 0)
	addonDirectories, _ := ioutil.ReadDir(addonsDirectory)
	for _, addonDirectory := range addonDirectories {
		filesInAddonDirectory, err := ioutil.ReadDir(addonsDirectory + "/" + addonDirectory.Name() + "/")
		if err != nil {
			log.Fatal(err)
		}
		for _, addonFile := range filesInAddonDirectory {
			if strings.HasSuffix(addonFile.Name(), ".toc") {
				tocFile, err := ioutil.ReadFile(addonsDirectory + "/" + addonDirectory.Name() + "/" + addonFile.Name())
				if err != nil {
					log.Fatal(err)
				}
				id, version := getAddonProperties(addonDirectory.Name(), string(tocFile))
				if version == "" {
					addon := addon{id: id, successful: false}
					if id != "" && !contains(addons, addon) {
						addons = append(addons, addon)
					}
				} else {
					addon := addon{id: id, version: version, successful: true}
					if id != "" && !contains(addons, addon) {
						addons = append(addons, addon)
					}
				}

			}
		}
	}
	return addons
}

示例#21
文件: ssh_test.go 项目: axelaris/diego-acceptance-tests

func compareDir(actualDir, expectedDir string) {
	actualDirInfo, err := os.Stat(actualDir)
	Expect(err).NotTo(HaveOccurred())

	expectedDirInfo, err := os.Stat(expectedDir)
	Expect(err).NotTo(HaveOccurred())

	Expect(actualDirInfo.Mode()).To(Equal(expectedDirInfo.Mode()))

	actualFiles, err := ioutil.ReadDir(actualDir)
	Expect(err).NotTo(HaveOccurred())

	expectedFiles, err := ioutil.ReadDir(actualDir)
	Expect(err).NotTo(HaveOccurred())

	Expect(len(actualFiles)).To(Equal(len(expectedFiles)))
	for i, actualFile := range actualFiles {
		expectedFile := expectedFiles[i]
		if actualFile.IsDir() {
			compareDir(filepath.Join(actualDir, actualFile.Name()), filepath.Join(expectedDir, expectedFile.Name()))
		} else {
			compareFile(filepath.Join(actualDir, actualFile.Name()), filepath.Join(expectedDir, expectedFile.Name()))
		}
	}
}

示例#22
文件: misc.go 项目: hanwen/termite

func ReadHexDatabase(d string) map[string]bool {
	hexRe := regexp.MustCompile("^([0-9a-fA-F][0-9a-fA-F])+$")
	db := map[string]bool{}
	entries, err := ioutil.ReadDir(d)
	if err != nil {
		return db
	}

	for _, e := range entries {
		if !hexRe.MatchString(e.Name()) || !e.IsDir() {
			continue
		}

		sub, _ := ioutil.ReadDir(fastpath.Join(d, e.Name()))
		for _, s := range sub {
			if !hexRe.MatchString(s.Name()) || s.IsDir() {
				continue
			}

			hex := e.Name() + s.Name()
			bin := make([]byte, len(hex)/2)
			n, err := fmt.Sscanf(hex, "%x", &bin)
			if n != 1 {
				log.Panic("sscanf %d %v", n, err)
			}

			db[string(bin)] = true
		}
	}

	return db
}

示例#23
文件: flatstore_it_test.go 项目: cgrates/cgrates

func TestFlatstoreitProcessFiles(t *testing.T) {
	if err := ioutil.WriteFile(path.Join("/tmp", "acc_1.log"), []byte(fullSuccessfull), 0644); err != nil {
		t.Fatal(err.Error)
	}
	if err := ioutil.WriteFile(path.Join("/tmp", "missed_calls_1.log"), []byte(fullMissed), 0644); err != nil {
		t.Fatal(err.Error)
	}
	if err := ioutil.WriteFile(path.Join("/tmp", "acc_2.log"), []byte(part1), 0644); err != nil {
		t.Fatal(err.Error)
	}
	if err := ioutil.WriteFile(path.Join("/tmp", "acc_3.log"), []byte(part2), 0644); err != nil {
		t.Fatal(err.Error)
	}
	//Rename(oldpath, newpath string)
	for _, fileName := range []string{"acc_1.log", "missed_calls_1.log", "acc_2.log", "acc_3.log"} {
		if err := os.Rename(path.Join("/tmp", fileName), path.Join(flatstoreCdrcCfg.CdrInDir, fileName)); err != nil {
			t.Fatal(err)
		}
	}
	time.Sleep(time.Duration(3) * time.Second) // Give time for processing to happen and the .unparired file to be written
	filesInDir, _ := ioutil.ReadDir(flatstoreCdrcCfg.CdrInDir)
	if len(filesInDir) != 0 {
		t.Errorf("Files in cdrcInDir: %+v", filesInDir)
	}
	filesOutDir, _ := ioutil.ReadDir(flatstoreCdrcCfg.CdrOutDir)
	if len(filesOutDir) != 5 {
		t.Errorf("In CdrcOutDir, expecting 5 files, got: %d", len(filesOutDir))
	}
	ePartContent := "INVITE|2daec40c|548625ac|[email protected]:0:0:0:0:0:0:0|200|OK|1436454408|*prepaid|1001|1002||3401:2069362475\n"
	if partContent, err := ioutil.ReadFile(path.Join(flatstoreCdrcCfg.CdrOutDir, "acc_3.log.unpaired")); err != nil {
		t.Error(err)
	} else if ePartContent != string(partContent) {
		t.Errorf("Expecting: %s, received: %s", ePartContent, string(partContent))
	}
}

示例#24
文件: main.go 项目: huonw/toml-test

func runAllTests() []result {
	invalidTests, err := ioutil.ReadDir(dirInvalid)
	if err != nil {
		log.Fatalf("Cannot read invalid directory (%s): %s", dirInvalid, err)
	}

	validTests, err := ioutil.ReadDir(dirValid)
	if err != nil {
		log.Fatalf("Cannot read valid directory (%s): %s", dirValid, err)
	}

	results := make([]result, 0, len(invalidTests)+len(validTests))
	for _, f := range invalidTests {
		if !strings.HasSuffix(f.Name(), fmt.Sprintf(".%s", invalidExt)) {
			continue
		}
		tname := stripSuffix(f.Name())
		results = append(results, runInvalidTest(tname))
	}
	for _, f := range validTests {
		if !strings.HasSuffix(f.Name(), ".toml") {
			continue
		}
		tname := stripSuffix(f.Name())
		results = append(results, runValidTest(tname))
	}
	return results
}

示例#25
文件: hist.go 项目: 0x7cc/rsc

func loadDates() []string {
	var all []string
	ydir, err := ioutil.ReadDir(filepath.Join(*mtpt, *host))
	if err != nil {
		fmt.Fprintf(os.Stderr, "%v\n", err)
		os.Exit(3)
	}
	for _, y := range ydir {
		if !y.IsDir() || !yyyy.MatchString(y.Name()) {
			continue
		}
		ddir, err := ioutil.ReadDir(filepath.Join(*mtpt, *host, y.Name()))
		if err != nil {
			continue
		}
		for _, d := range ddir {
			if !d.IsDir() || !mmdd.MatchString(d.Name()) {
				continue
			}
			date := y.Name() + "/" + d.Name()
			if *vers > date {
				continue
			}
			all = append(all, filepath.Join(*mtpt, *host, date))
		}
	}
	return all
}

示例#26
文件: migrate_dirs.go 项目: alexandrev/eris-cli

func checkFileNamesAndMigrate(depDir, newDir string) error {
	depDirFiles, err := ioutil.ReadDir(depDir)
	if err != nil {
		return fmt.Errorf("could not read files from dir to be deprecated %s:\n%v\n", depDir, err)
	}
	newDirFiles, err := ioutil.ReadDir(newDir)
	if err != nil {
		return fmt.Errorf("could not read files from new dir %s:\n%v\n", newDir, err)
	}

	fileNamesToCheck := make(map[string]bool) //map of filenames in new dir
	if len(newDirFiles) != 0 {
		for _, file := range newDirFiles {
			fileNamesToCheck[file.Name()] = true
		}
	}

	for _, file := range depDirFiles { //if any filenames match, must resolve
		depFile := path.Join(depDir, file.Name())
		newFile := path.Join(newDir, file.Name()) //file may not actually exist (yet)

		if fileNamesToCheck[file.Name()] == true { //conflict!
			return fmt.Errorf("identical file name in deprecated dir (%s) and new dir to migrate to (%s)\nplease resolve and re-run command", depFile, newFile)
		} else { //filenames don't match, move file from depDir to newDir

			if err := os.Rename(depFile, newFile); err != nil {
				logger.Errorf("File migration NOT succesful:\t%s ====> %s\n", depFile, newFile)
				return err
			}
			logger.Printf("File migration succesful:\t%s ====> %s\n", depFile, newFile)
		}
	}
	return nil
}

示例#27
文件: face_detect.go 项目: sheepbao/Learning_go

func getPicData(pic_path string) (pic_datas []PicData) {

	pic_datas = make([]PicData, 0, 10)
	pic_data := new(PicData)

	dir, err := ioutil.ReadDir(pic_path)

	if err != nil {
		println("ReadDir faild")
		return
	}
	i := 0
	for _, v := range dir {
		if i >= 100 {
			break
		}
		if v.IsDir() {
			i++
			pic_data.pics = make([]string, 0, 10)
			pic_data.name = v.Name()

			subdir, _ := ioutil.ReadDir(pic_path + "/" + v.Name())
			for _, f := range subdir {
				// println(f.Name())
				pic_data.pics = append(pic_data.pics, f.Name())
			}

			pic_datas = append(pic_datas, *pic_data)
		}
	}
	return

}

示例#28
文件: repository.go 项目: bgxavier/capstan

func (r *Repo) ListImages() {
	fmt.Println(FileInfoHeader())
	namespaces, _ := ioutil.ReadDir(r.Path)
	for _, n := range namespaces {
		images, _ := ioutil.ReadDir(filepath.Join(r.Path, n.Name()))
		nrImages := 0
		nrFiles := 0
		for _, i := range images {
			if i.IsDir() {
				info := MakeFileInfo(r.Path, n.Name(), i.Name())
				if info == nil {
					fmt.Println(n.Name() + "/" + i.Name())
				} else {
					fmt.Println(info.String())
				}
				nrImages++
			} else {
				nrFiles++
			}
		}
		// Image is directly at repository root with no namespace:
		if nrImages == 0 && nrFiles != 0 {
			fmt.Println(n.Name())
		}
	}
}

示例#29
文件: templates.go 项目: smilecs/yellowpages

func TemplateInit() {
	var allFiles []string
	files, err := ioutil.ReadDir("./web/frontend_templates")
	if err != nil {
		fmt.Println(err)
	}
	files2, err := ioutil.ReadDir("./web/frontend_templates/partials")
	if err != nil {
		fmt.Println(err)
	}

	for _, file := range files {
		filename := file.Name()
		log.Println(filename)
		if strings.HasSuffix(filename, ".html") {
			allFiles = append(allFiles, "./web/frontend_templates/"+filename)
		}
	}

	for _, file := range files2 {
		filename := file.Name()
		log.Println(filename)
		if strings.HasSuffix(filename, ".html") {
			allFiles = append(allFiles, "./web/frontend_templates/partials/"+filename)
		}
	}

	templates = template.Must(template.ParseFiles(allFiles...))
}

示例#30
文件: list.go 项目: nariyu/gigo

//List provides list of packages in $GOPATH/src
func List(c *cli.Context) {

	srcpath := fmt.Sprintf("%s/src/", os.Getenv("GOPATH"))
	srcdir, err := ioutil.ReadDir(srcpath)
	if err != nil {
		log.Fatal(err)
	}
	if len(srcdir) == 0 {
		log.Fatal(fmt.Sprintf("%s is empty", srcpath))
	}
	for _, source := range srcdir {
		fmt.Println("Packages from " + source.Name())
		title, err := ioutil.ReadDir(srcpath + source.Name())
		if err != nil {
			log.Print(err)
		}

		for _, pack := range title {
			if pack.IsDir() {
				fmt.Println(pack.Name())
			}
		}
		fmt.Println("\n")
	}
}

展开阅读全文