Paul reznikov/do tasks

0-limit-crawler/main.go

@@ -12,17 +12,20 @@ package main
 import (
 	"fmt"
 	"sync"
+	"time"
 )
 
 // Crawl uses `fetcher` from the `mockfetcher.go` file to imitate a
 // real crawler. It crawls until the maximum depth has reached.
-func Crawl(url string, depth int, wg *sync.WaitGroup) {
+func Crawl(url string, depth int, wg *sync.WaitGroup, ticker <-chan time.Time) {
 	defer wg.Done()
 
 	if depth <= 0 {
 		return
 	}
 
+	<-ticker
+
 	body, urls, err := fetcher.Fetch(url)
 	if err != nil {
 		fmt.Println(err)
@@ -35,14 +38,16 @@ func Crawl(url string, depth int, wg *sync.WaitGroup) {
 	for _, u := range urls {
 		// Do not remove the `go` keyword, as Crawl() must be
 		// called concurrently
-		go Crawl(u, depth-1, wg)
+		go Crawl(u, depth-1, wg, ticker)
 	}
 }
 
 func main() {
 	var wg sync.WaitGroup
 
+	ticker := time.NewTicker(1 * time.Second)
+
 	wg.Add(1)
-	Crawl("http://golang.org/", 4, &wg)
+	Crawl("http://golang.org/", 4, &wg, ticker.C)
 	wg.Wait()
 }

1-producer-consumer/main.go

@@ -10,39 +10,48 @@ package main
 
 import (
 	"fmt"
+	"sync"
 	"time"
 )
 
-func producer(stream Stream) (tweets []*Tweet) {
+func producer(stream Stream, tweetsChan chan<- *Tweet) {
 	for {
 		tweet, err := stream.Next()
 		if err == ErrEOF {
-			return tweets
+			close(tweetsChan)
+			return
 		}
 
-		tweets = append(tweets, tweet)
+		tweetsChan <- tweet
 	}
 }
 
-func consumer(tweets []*Tweet) {
-	for _, t := range tweets {
-		if t.IsTalkingAboutGo() {
-			fmt.Println(t.Username, "\ttweets about golang")
+func consumer(tweetsChan <-chan *Tweet, wg *sync.WaitGroup) {
+	defer wg.Done()
+
+	for tweet := range tweetsChan {
+		if tweet.IsTalkingAboutGo() {
+			fmt.Println(tweet.Username, "\ttweets about golang")
 		} else {
-			fmt.Println(t.Username, "\tdoes not tweet about golang")
+			fmt.Println(tweet.Username, "\tdoes not tweet about golang")
 		}
 	}
 }
 
 func main() {
 	start := time.Now()
 	stream := GetMockStream()
+	var wg sync.WaitGroup
+
+	tweetsChan := make(chan *Tweet)
 
 	// Producer
-	tweets := producer(stream)
+	go producer(stream, tweetsChan)
 
+	wg.Add(1)
 	// Consumer
-	consumer(tweets)
+	go consumer(tweetsChan, &wg)
+	wg.Wait()
 
 	fmt.Printf("Process took %s\n", time.Since(start))
 }

2-race-in-cache/main.go

@@ -10,6 +10,7 @@ package main
 
 import (
 	"container/list"
+	"sync"
 	"testing"
 )
 
@@ -32,34 +33,49 @@ type KeyStoreCache struct {
 	cache map[string]*list.Element
 	pages list.List
 	load  func(string) string
+	mutex *sync.Mutex
 }
 
 // New creates a new KeyStoreCache
 func New(load KeyStoreCacheLoader) *KeyStoreCache {
 	return &KeyStoreCache{
 		load:  load.Load,
 		cache: make(map[string]*list.Element),
+		mutex: &sync.Mutex{},
 	}
 }
 
 // Get gets the key from cache, loads it from the source if needed
 func (k *KeyStoreCache) Get(key string) string {
+
+	k.mutex.Lock()
+	defer k.mutex.Unlock()
+
 	if e, ok := k.cache[key]; ok {
 		k.pages.MoveToFront(e)
 		return e.Value.(page).Value
 	}
+
 	// Miss - load from database and save it in cache
 	p := page{key, k.load(key)}
+
 	// if cache is full remove the least used item
 	if len(k.cache) >= CacheSize {
+
 		end := k.pages.Back()
+
 		// remove from map
 		delete(k.cache, end.Value.(page).Key)
+
 		// remove from list
 		k.pages.Remove(end)
+
 	}
+
 	k.pages.PushFront(p)
+
 	k.cache[key] = k.pages.Front()
+
 	return p.Value
 }
 

2-race-in-cache/mockserver.go

@@ -31,7 +31,7 @@ func RunMockServer(cache *KeyStoreCache, t *testing.T) {
 				go func(i int) {
 					value := cache.Get("Test" + strconv.Itoa(i))
 					if t != nil {
-						if value != "Test" + strconv.Itoa(i) {
+						if value != "Test"+strconv.Itoa(i) {
 							t.Errorf("Incorrect db response %v", value)
 						}
 					}

3-limit-service-time/main.go

@@ -10,6 +10,8 @@
 
 package main
 
+import "time"
+
 // User defines the UserModel. Use this to check whether a User is a
 // Premium user or not
 type User struct {
@@ -21,8 +23,36 @@ type User struct {
 // HandleRequest runs the processes requested by users. Returns false
 // if process had to be killed
 func HandleRequest(process func(), u *User) bool {
-	process()
-	return true
+	var (
+		startReqProc, endReqProc time.Time
+	)
+
+	done := make(chan struct{})
+
+	go func() {
+		startReqProc = time.Now()
+		process()
+		endReqProc = time.Now()
+		done <- struct{}{}
+	}()
+
+	if u.IsPremium {
+		<-done
+		return true
+	}
+
+	select {
+	case <-time.After(10 * time.Second):
+		return false
+	case <-done:
+		diff := endReqProc.Sub(startReqProc).Seconds()
+		u.TimeUsed += int64(diff)
+		if u.TimeUsed <= 10 {
+			return true
+		}
+		return false
+	}
+
 }
 
 func main() {

4-graceful-sigint/main.go

@@ -13,10 +13,38 @@
 
 package main
 
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+)
+
 func main() {
+	sigsStop := make(chan os.Signal)
+
+	signal.Notify(sigsStop, syscall.SIGINT, syscall.SIGTERM)
+
 	// Create a process
 	proc := MockProcess{}
 
+	fmt.Println("The program is running. Press Ctrl+C to complete.")
+
 	// Run the process (blocking)
-	proc.Run()
+	go proc.Run()
+	sigStop := <-sigsStop
+	fmt.Printf("\nA signal has been received: %v.\n", sigStop)
+
+	go proc.Stop()
+	fmt.Println("We are completing the work correctly...")
+
+	select {
+	case <-time.After(5 * time.Second):
+		fmt.Println("\nThe correct shutdown has been completed.")
+	case sigStop = <-sigsStop:
+		fmt.Printf("\nA signal has been received: %v. Early termination of work.", sigStop)
+	}
+
+	os.Exit(0)
 }