telegraf/internal/globpath/globpath.go

120 lines
2.7 KiB
Go
Raw Normal View History

package globpath
import (
"os"
"path/filepath"
"strings"
"github.com/gobwas/glob"
2018-12-18 22:23:25 +00:00
"github.com/karrick/godirwalk"
)
type GlobPath struct {
path string
hasMeta bool
2018-12-13 20:25:49 +00:00
HasSuperMeta bool
rootGlob string
g glob.Glob
}
func Compile(path string) (*GlobPath, error) {
out := GlobPath{
hasMeta: hasMeta(path),
2018-12-13 20:25:49 +00:00
HasSuperMeta: hasSuperMeta(path),
path: path,
}
// if there are no glob meta characters in the path, don't bother compiling
// a glob object
2018-12-13 20:25:49 +00:00
if !out.hasMeta || !out.HasSuperMeta {
return &out, nil
}
// find the root elements of the object path, the entry point for recursion
// when you have a super-meta in your path (which are :
// glob(/your/expression/until/first/star/of/super-meta))
out.rootGlob = path[:strings.Index(path, "**")+1]
var err error
if out.g, err = glob.Compile(path, os.PathSeparator); err != nil {
return nil, err
}
return &out, nil
}
2018-12-13 20:25:49 +00:00
// Match returns all files matching the expression
2018-12-18 22:23:25 +00:00
// If it's a static path, returns path
func (g *GlobPath) Match() []string {
if !g.hasMeta {
2018-12-18 22:23:25 +00:00
return []string{g.path}
}
2018-12-13 20:25:49 +00:00
if !g.HasSuperMeta {
files, _ := filepath.Glob(g.path)
2018-12-18 22:23:25 +00:00
return files
}
roots, err := filepath.Glob(g.rootGlob)
if err != nil {
2018-12-18 22:23:25 +00:00
return []string{}
}
2018-12-18 22:23:25 +00:00
out := []string{}
walkfn := func(path string, _ *godirwalk.Dirent) error {
if g.g.Match(path) {
2018-12-18 22:23:25 +00:00
out = append(out, path)
}
return nil
}
for _, root := range roots {
2018-12-18 22:23:25 +00:00
fileinfo, err := os.Stat(root)
if err != nil {
continue
}
if !fileinfo.IsDir() {
if g.MatchString(root) {
out = append(out, root)
}
continue
}
godirwalk.Walk(root, &godirwalk.Options{
Callback: walkfn,
Unsorted: true,
})
}
return out
}
2018-12-13 20:25:49 +00:00
// MatchString test a string against the glob
func (g *GlobPath) MatchString(path string) bool {
if !g.HasSuperMeta {
res, _ := filepath.Match(g.path, path)
return res
}
return g.g.Match(path)
}
// GetRoots returns a list of files and directories which should be optimal
// prefixes of matching files when you have a super-meta in your expression :
// - any directory under these roots may contain a matching file
// - no file outside of these roots can match the pattern
// Note that it returns both files and directories.
func (g *GlobPath) GetRoots() []string {
if !g.hasMeta {
return []string{g.path}
}
if !g.HasSuperMeta {
matches, _ := filepath.Glob(g.path)
return matches
}
roots, _ := filepath.Glob(g.rootGlob)
return roots
}
// hasMeta reports whether path contains any magic glob characters.
func hasMeta(path string) bool {
return strings.IndexAny(path, "*?[") >= 0
}
// hasSuperMeta reports whether path contains any super magic glob characters (**).
func hasSuperMeta(path string) bool {
return strings.Index(path, "**") >= 0
}