sean feedback!

Author: derwolfe

ticktock.go renamed to main.go

@@ -14,7 +14,7 @@ import (
 )
 
 const (
-	TIMEOUT = 3 //seconds
+	TIMEOUT = 3 * time.Second
 	GITHUB  = "https://status.github.com/api/status.json"
 	CODECOV = "https://wdzsn5dlywj9.statuspage.io/api/v2/status.json"
 	TRAVIS  = "https://pnpcptp8xh9k.statuspage.io/api/v2/status.json"
@@ -40,20 +40,13 @@ func updaterInit() {
 	ticker := time.NewTicker(1 * time.Minute)
 	updateState(DataStore)
 	go func() {
-		for {
-			select {
-			case <-ticker.C:
-				updateState(DataStore)
-			}
+		for _ = range ticker.C {
+			updateState(DataStore)
 		}
 	}()
 }
 
-func statusFetch(url string) (*[]byte, error) {
-	timeout := time.Duration(TIMEOUT * time.Second)
-	client := http.Client{
-		Timeout: timeout,
-	}
+func statusFetch(url string, client http.Client) ([]byte, error) {
 	resp, err := client.Get(url)
 	if err != nil {
 		return nil, err
@@ -63,38 +56,44 @@ func statusFetch(url string) (*[]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &body, nil
+	return body, nil
 }
 
 func updateState(store *state.Store) {
-	var wg sync.WaitGroup
+	wg := sync.WaitGroup{}
+
 	sources := []string{GITHUB, TRAVIS, QUAY, CODECOV}
 	// match the length of sources
-	wg.Add(4)
+	wg.Add(len(sources))
+
+	timeout := time.Duration(TIMEOUT)
+	client := http.Client{
+		Timeout: timeout,
+	}
 
 	for _, url := range sources {
 		go func(url string) {
 			log.Printf("Started Fetching: %s", url)
 			InflightStatus.Inc()
 			defer InflightStatus.Dec()
 			defer wg.Done()
-			body, err := statusFetch(url)
+			body, err := statusFetch(url, client)
 			if err != nil {
 				log.Printf("Error fetching: %s, %s", url, err)
 				return
 			}
 			log.Printf("Succeeded fetching: %s", url)
 
-			var good bool
+			var parser parsing.Parser
 			switch url {
 			case GITHUB:
-				source := parsing.GithubStatus{}
-				good = source.Parse(body)
+				parser = parsing.GithubParser
 			case CODECOV, TRAVIS, QUAY:
-				source := parsing.StatusPageStatus{}
-				good = source.Parse(body)
+				parser = parsing.StatusPageParser
+			default:
+				parser = parsing.DefaultParser
 			}
-
+			good := parser(body)
 			r := state.Refined{
 				Good:          good,
 				SourceMessage: body,

parsing/parsing.go

@@ -27,21 +27,23 @@ type GithubStatus struct {
 	LastUpdated time.Time `json:"last_updated"`
 }
 
-type Parser interface {
-	Parse(body *[]byte) bool
-}
+type Parser func([]byte) bool
 
-func (g *GithubStatus) Parse(body *[]byte) bool {
+func GithubParser(body []byte) bool {
 	parsed := GithubStatus{}
-	json.Unmarshal(*body, &parsed)
+	json.Unmarshal(body, &parsed)
 	return parsed.Status == "good"
 }
 
-func (g *StatusPageStatus) Parse(body *[]byte) bool {
+func StatusPageParser(body []byte) bool {
 	parsed := StatusPageStatus{
 		Page:   StatusPageInnerPage{},
 		Status: StatusPageInnerStatus{},
 	}
-	json.Unmarshal(*body, &parsed)
+	json.Unmarshal(body, &parsed)
 	return parsed.Status.Indicator == "none"
 }
+
+func DefaultParser(body []byte) bool {
+	return false
+}

state/state.go

@@ -10,20 +10,19 @@ type Refined struct {
 	Url           string
 	LastUpdated   time.Time
 	Good          bool
-	SourceMessage *[]byte
+	SourceMessage []byte
 }
 
 type Store struct {
+	sync.RWMutex
 	Statuses    map[string]*Refined
 	LastUpdated time.Time
-	mutex       *sync.RWMutex
 }
 
 func NewStore() *Store {
 	return &Store{
 		LastUpdated: time.Now(),
 		Statuses:    make(map[string]*Refined),
-		mutex:       new(sync.RWMutex),
 	}
 }
 
@@ -33,35 +32,35 @@ type ReadWrite interface {
 	CurrentValue() *Front
 }
 
-func (s *Store) Read(url string) (*Refined, error) {
-	s.mutex.RLock()
+func (s Store) Read(url string) (*Refined, error) {
+	s.RLock()
 	target, ok := s.Statuses[url]
-	s.mutex.RUnlock()
+	s.RUnlock()
 	if ok == false {
 		return nil, errors.New("URL not found")
 	}
 	return target, nil
 }
 
-func (s *Store) Write(newStore *Refined) {
-	s.mutex.Lock()
-	s.Statuses[newStore.Url] = newStore
+func (s *Store) Write(status *Refined) {
+	s.Lock()
+	s.Statuses[status.Url] = status
 	s.LastUpdated = time.Now()
-	s.mutex.Unlock()
+	s.Unlock()
 }
 
 type Front struct {
-	Alarm       bool       `json:"alarm"`
-	LastUpdated *time.Time `json:"last_updated"`
+	Alarm       bool      `json:"alarm"`
+	LastUpdated time.Time `json:"last_updated"`
 }
 
-func (s *Store) CurrentValue() *Front {
-	s.mutex.RLock()
+func (s Store) CurrentValue() *Front {
+	s.RLock()
 	acc := true
 	for _, r := range s.Statuses {
 		acc = acc && r.Good
 	}
-	ret := &Front{Alarm: acc, LastUpdated: &s.LastUpdated}
-	s.mutex.RUnlock()
+	ret := &Front{Alarm: acc, LastUpdated: s.LastUpdated}
+	s.RUnlock()
 	return ret
 }