Golang Filter.Match方法代碼示例

func compareDirectories(request *subproto.UpdateRequest, state *state,
	subDirectory, requiredDirectory *filesystem.Directory,
	parentName string, filter *filter.Filter) {
	requiredPathName := path.Join(parentName, requiredDirectory.Name)
	// First look for entries that should be deleted.
	makeSubDirectory := false
	if subDirectory == nil {
		makeSubDirectory = true
	} else {
		subPathName := path.Join(parentName, subDirectory.Name)
		for name, subEntry := range subDirectory.EntriesByName {
			pathname := path.Join(subPathName, entryName(subEntry))
			if filter.Match(pathname) {
				continue
			}
			if _, ok := requiredDirectory.EntriesByName[name]; !ok {
				request.PathsToDelete = append(request.PathsToDelete, pathname)
				fmt.Printf("Delete: %s\n", pathname) // HACK
			}
		}
		if !filesystem.CompareDirectoriesMetadata(subDirectory,
			requiredDirectory, os.Stdout) {
			fmt.Printf("Different directory: %s...\n", requiredPathName) // HACK
			makeSubDirectory = true
			// TODO(rgooch): Update metadata.
		}
	}
	if makeSubDirectory {
		var newdir subproto.Directory
		newdir.Name = requiredPathName
		newdir.Mode = requiredDirectory.Mode
		newdir.Uid = requiredDirectory.Uid
		newdir.Gid = requiredDirectory.Gid
		request.DirectoriesToMake = append(request.DirectoriesToMake, newdir)
	}
	for name, requiredEntry := range requiredDirectory.EntriesByName {
		pathname := path.Join(requiredPathName, entryName(requiredEntry))
		if filter.Match(pathname) {
			continue
		}
		if subDirectory == nil {
			compareEntries(request, state, nil, requiredEntry, requiredPathName,
				filter)
		} else {
			if subEntry, ok := subDirectory.EntriesByName[name]; ok {
				compareEntries(request, state, subEntry, requiredEntry,
					requiredPathName, filter)
			} else {
				compareEntries(request, state, nil, requiredEntry,
					requiredPathName, filter)
			}
		}
	}
}

func (inode *DirectoryInode) filter(newFS *FileSystem,
	filter *filter.Filter, name string) *DirectoryInode {
	newInode := new(DirectoryInode)
	newInode.Mode = inode.Mode
	newInode.Uid = inode.Uid
	newInode.Gid = inode.Gid
	for _, entry := range inode.EntryList {
		subName := path.Join(name, entry.Name)
		if filter.Match(subName) {
			continue
		}
		var newEntry *DirectoryEntry
		if inode, ok := entry.inode.(*DirectoryInode); ok {
			newEntry = new(DirectoryEntry)
			newEntry.Name = entry.Name
			newEntry.InodeNumber = entry.InodeNumber
			newEntry.inode = inode.filter(newFS, filter, subName)
		} else {
			newEntry = entry
		}
		newInode.EntryList = append(newInode.EntryList, newEntry)
		newFS.InodeTable[entry.InodeNumber] = newEntry.inode
	}
	newFS.DirectoryCount++
	return newInode
}

func compareDirectories(request *subproto.UpdateRequest, state *state,
	subDirectory, requiredDirectory *filesystem.DirectoryInode,
	myPathName string, filter *filter.Filter) {
	// First look for entries that should be deleted.
	if subDirectory != nil {
		for name := range subDirectory.EntriesByName {
			pathname := path.Join(myPathName, name)
			if filter.Match(pathname) {
				continue
			}
			if _, ok := requiredDirectory.EntriesByName[name]; !ok {
				request.PathsToDelete = append(request.PathsToDelete, pathname)
			}
		}
	}
	for name, requiredEntry := range requiredDirectory.EntriesByName {
		pathname := path.Join(myPathName, name)
		if filter.Match(pathname) {
			continue
		}
		var subEntry *filesystem.DirectoryEntry
		if subDirectory != nil {
			if se, ok := subDirectory.EntriesByName[name]; ok {
				subEntry = se
			}
		}
		if subEntry == nil {
			addEntry(request, state, requiredEntry, pathname)
		} else {
			compareEntries(request, state, subEntry, requiredEntry, pathname,
				filter)
		}
		// If a directory: descend (possibly with the directory for the sub).
		requiredInode := requiredEntry.Inode()
		if requiredInode, ok := requiredInode.(*filesystem.DirectoryInode); ok {
			var subInode *filesystem.DirectoryInode
			if subEntry != nil {
				if si, ok := subEntry.Inode().(*filesystem.DirectoryInode); ok {
					subInode = si
				}
			}
			compareDirectories(request, state, subInode, requiredInode,
				pathname, filter)
		}
	}
}

func (inode *DirectoryInode) list(w io.Writer, name string,
	numLinksTable NumLinksTable, numLinks int,
	listSelector ListSelector, filter *filter.Filter) error {
	if err := listUntilName(w, inode.Mode, numLinks, inode.Uid, inode.Gid,
		0, -1, -1, name, true, listSelector); err != nil {
		return err
	}
	for _, dirent := range inode.EntryList {
		pathname := path.Join(name, dirent.Name)
		if filter != nil && filter.Match(pathname) {
			continue
		}
		err := dirent.inode.List(w, pathname, numLinksTable,
			numLinksTable[dirent.InodeNumber], listSelector, filter)
		if err != nil {
			return err
		}
	}
	return nil
}

func decode(tarReader *tar.Reader, hasher Hasher, filter *filter.Filter) (
	*filesystem.FileSystem, error) {
	var decoderData decoderData
	decoderData.inodeTable = make(map[string]uint64)
	decoderData.directoryTable = make(map[string]*filesystem.DirectoryInode)
	fileSystem := &decoderData.fileSystem
	fileSystem.InodeTable = make(filesystem.InodeTable)
	// Create a default top-level directory which may be updated.
	decoderData.addInode("/", &fileSystem.DirectoryInode)
	fileSystem.DirectoryInode.Mode = syscall.S_IFDIR | syscall.S_IRWXU |
		syscall.S_IRGRP | syscall.S_IXGRP | syscall.S_IROTH | syscall.S_IXOTH
	decoderData.directoryTable["/"] = &fileSystem.DirectoryInode
	for {
		header, err := tarReader.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		header.Name = normaliseFilename(header.Name)
		if header.Name == "/.subd" ||
			strings.HasPrefix(header.Name, "/.subd/") {
			continue
		}
		if filter != nil && filter.Match(header.Name) {
			continue
		}
		err = decoderData.addHeader(tarReader, hasher, header)
		if err != nil {
			return nil, err
		}
	}
	delete(fileSystem.InodeTable, 0)
	fileSystem.DirectoryCount = uint64(len(decoderData.directoryTable))
	fileSystem.ComputeTotalDataBytes()
	sortDirectory(&fileSystem.DirectoryInode)
	return fileSystem, nil
}

func decode(tarReader *tar.Reader, dataHandler DataHandler,
	filter *filter.Filter) (*filesystem.FileSystem, error) {
	var decoderData decoderData
	decoderData.regularInodeTable = make(map[string]uint64)
	decoderData.symlinkInodeTable = make(map[string]uint64)
	decoderData.inodeTable = make(map[string]uint64)
	decoderData.directoryTable = make(map[string]*filesystem.Directory)
	fileSystem := &decoderData.fileSystem
	fileSystem.RegularInodeTable = make(filesystem.RegularInodeTable)
	fileSystem.SymlinkInodeTable = make(filesystem.SymlinkInodeTable)
	fileSystem.InodeTable = make(filesystem.InodeTable)
	// Create a container directory for the top-level directory.
	var containerDir filesystem.Directory
	decoderData.directoryTable["/"] = &containerDir
	for {
		header, err := tarReader.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		header.Name = normaliseFilename(header.Name)
		if filter.Match(header.Name) {
			continue
		}
		err = decoderData.addHeader(tarReader, dataHandler, header)
		if err != nil {
			return nil, err
		}
	}
	fileSystem.Directory = *containerDir.DirectoryList[0]
	sortDirectory(&fileSystem.Directory)
	fileSystem.DirectoryCount = uint64(len(decoderData.directoryTable))
	fileSystem.RebuildInodePointers()
	fileSystem.ComputeTotalDataBytes()
	return fileSystem, nil
}