go errgroup 递归搜索目录中的Go文件

为了测试sync.ErrGroup的所有功能，我写了一个小程序，用一个指定的模式递归搜索目录中的Go文件。这有助于在Go源代码树中查找已使用已弃用或更新的包的实例。要测试sync.ErrGroup的所有功能，我还为应用程序添加了超时设置在功能。 如果达到时间限制，所有搜索和处理goroutine将被取消，程序将结束

 

当程序运行时，它会生成以下结果：

$ gogrep -timeout 1000ms . fmt                                                                                                 
gogrep.go
 hits

如果你使用的参数不正确的话，你会看到下面的输出

gogrep by Brian Ketelsen
Flags:
-timeout duration
    timeout in milliseconds (default 500ms)
Usage:
gogrep [flags] path pattern

代码如下：

package main
import (
    "bytes"
    "flag"
    "fmt"
    "io/ioutil"
    "log"
    "os"
    "path/filepath"
    "strings"
    "time"
    "golang.org/x/net/context"
    "golang.org/x/sync/errgroup"
)
func main() {
    duration := flag.Duration("timeout", 500*time.Millisecond, "timeout in milliseconds")
    flag.Usage = func() {
        fmt.Printf("%s by Brian Ketelsen\n", os.Args[0])
        fmt.Println("Usage:")
        fmt.Printf("    gogrep [flags] path pattern \n")
        fmt.Println("Flags:")
        flag.PrintDefaults()
    }
    flag.Parse()
    if flag.NArg() != 2 {
        flag.Usage()
        os.Exit(-1)
    }
    path := flag.Arg(0)
    pattern := flag.Arg(1)
    ctx, _ := context.WithTimeout(context.Background(), *duration)
    m, err := search(ctx, path, pattern)
    if err != nil {
        log.Fatal(err)
    }
    for _, name := range m {
        fmt.Println(name)
    }
    fmt.Println(len(m), "hits")
}
func search(ctx context.Context, root string, pattern string) ([]string, error) {
    g, ctx := errgroup.WithContext(ctx)
    paths := make(chan string, 100)
    // get all the paths
    g.Go(func() error {
        defer close(paths)
        return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
            if err != nil {
                return err
            }
            if !info.Mode().IsRegular() {
                return nil
            }
            if !info.IsDir() && !strings.HasSuffix(info.Name(), ".go") {
                return nil
            }
            select {
            case paths <- path:
            case <-ctx.Done():
                return ctx.Err()
            }
            return nil
        })
    })
    c := make(chan string, 100)
    for path := range paths {
        p := path
        g.Go(func() error {
            data, err := ioutil.ReadFile(p)
            if err != nil {
                return err
            }
            if !bytes.Contains(data, []byte(pattern)) {
                return nil
            }
            select {
            case c <- p:
            case <-ctx.Done():
                return ctx.Err()
            }
            return nil
        })
    }
    go func() {
        g.Wait()
        close(c)
    }()
    var m []string
    for r := range c {
        m = append(m, r)
    }
    return m, g.Wait()
}

我创建了一个context.Context并且为它添加了超时设置，当超时时间到了，”ctx”将接收到channel的超时警告。WithTimeout同样也会返回一个取消的方法，但是我们不需要，所以用 “_” 来忽略掉了。 
下面的search() 方法的有context,search path,和 search pattern。最后把找到的文件和数量输出