Simple solution for golang tour webcrawler exercise

I'm new to Go and I saw some solutions for this exercise, but I think they are complex...

In my solution everything seems simple, but I've got a deadlock error. I can't figure out how to properly close channels and stop loop inside main block. Is there a simple way to do this?

Solution on Golang playground

Thanks for any/all help one may provide!

<!-- language: lang-golang -->

package main
import (
"fmt"
"sync"
)
type Fetcher interface {
// Fetch returns the body of URL and
// a slice of URLs found on that page.
Fetch(url string) (body string, urls []string, err error)
}
type SafeCache struct {
cache map[string]bool
mux   sync.Mutex
}
func (c *SafeCache) Set(s string) {
c.mux.Lock()
c.cache
展开收缩
 = true
c.mux.Unlock()
}
func (c *SafeCache) Get(s string) bool {
c.mux.Lock()
defer c.mux.Unlock()
return c.cache
展开收缩
}
var (
sc = SafeCache{cache: make(map[string]bool)}
errs, ress = make(chan error), make(chan string)
)
// Crawl uses fetcher to recursively crawl
// pages starting with url, to a maximum of depth.
func Crawl(url string, depth int, fetcher Fetcher) {
if depth <= 0 {
return
}
var (
body string
err error
urls []string
)
if ok := sc.Get(url); !ok {
sc.Set(url)
body, urls, err = fetcher.Fetch(url)
} else {
err = fmt.Errorf("Already fetched: %s", url)
}
if err != nil {
errs <- err
return
}
ress <- fmt.Sprintf("found: %s %q\n", url, body)
for _, u := range urls {
go Crawl(u, depth-1, fetcher)
}
return
}
func main() {
go Crawl("http://golang.org/", 4, fetcher)
for {
select {
case res, ok := <-ress:
fmt.Println(res)
if !ok {
break
}
case err, ok := <-errs:
fmt.Println(err)
if !ok {
break
}
}
}
}
// fakeFetcher is Fetcher that returns canned results.
type fakeFetcher map[string]*fakeResult
type fakeResult struct {
body string
urls []string
}
func (f fakeFetcher) Fetch(url string) (string, []string, error) {
if res, ok := f
; ok {
return res.body, res.urls, nil
}
return "", nil, fmt.Errorf("not found: %s", url)
}
// fetcher is a populated fakeFetcher.
var fetcher = fakeFetcher{
"http://golang.org/": &fakeResult{
"The Go Programming Language",
[]string{
"http://golang.org/pkg/",
"http://golang.org/cmd/",
},
},
"http://golang.org/pkg/": &fakeResult{
"Packages",
[]string{
"http://golang.org/",
"http://golang.org/cmd/",
"http://golang.org/pkg/fmt/",
"http://golang.org/pkg/os/",
},
},
"http://golang.org/pkg/fmt/": &fakeResult{
"Package fmt",
[]string{
"http://golang.org/",
"http://golang.org/pkg/",
},
},
"http://golang.org/pkg/os/": &fakeResult{
"Package os",
[]string{
"http://golang.org/",
"http://golang.org/pkg/",
},
},
}

you can solve this with sync.WaitGroup

1. You can start listening your channels in separate goroutines.
2. WaitGroup will coordinate how many goroutines do you have.

wg.Add(1) says that we're going to start new goroutine.

wg.Done() says that goroutine is finished.

wg.Wait() blocks goroutine, until all started goroutines aren't finished yet.

This 3 methods allows you to coordinate goroutines.

Go playground link

PS. you might be interested in sync.RWMutex for your SafeCache