Merge pull request #55 from robertoduessmann/cache

Implement caching

Author: robertoduessmann

cache/manager.go

@@ -7,36 +7,48 @@ import (
 
 type cacheManager struct {
 	avaliablesCache map[string]CacheClient
+	mu              sync.RWMutex
 }
 
-var instance CacheManager = nil
+var (
+	instance CacheManager
+	once     sync.Once
+)
 
 func NewCacheManager() CacheManager {
-	sync.OnceFunc(func() {
-		if instance == nil {
-			instance = cacheManager{
-				avaliablesCache: make(map[string]CacheClient),
-			}
+	once.Do(func() {
+		instance = &cacheManager{
+			avaliablesCache: make(map[string]CacheClient),
 		}
-	})()
+	})
 	return instance
 }
 
-func (m cacheManager) NewCache(name string, ttl time.Duration) CacheClient {
+func (m *cacheManager) NewCache(name string, ttl time.Duration) CacheClient {
+	m.mu.RLock()
 	client, found := m.avaliablesCache[name]
+	m.mu.RUnlock()
 	if found {
 		return client
 	}
 
+	m.mu.Lock()
+	defer m.mu.Unlock()
 	cacheClient := NewCacheClient(ttl)
 	m.avaliablesCache[name] = cacheClient
 	return cacheClient
 }
 
-func (m cacheManager) Erase(name string) bool {
+func (m *cacheManager) Erase(name string) bool {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if _, exists := m.avaliablesCache[name]; exists {
+		delete(m.avaliablesCache, name)
+		return true
+	}
 	return false
 }
 
-func (m cacheManager) Delete(name string) bool {
-	return false
+func (m *cacheManager) Delete(name string) bool {
+	return m.Erase(name)
 }

controller/v2/weather.go

@@ -3,10 +3,12 @@ package v2
 import (
 	"encoding/json"
 	"fmt"
+	"log"
 	"net/http"
 	"time"
 
 	"github.com/gorilla/mux"
+	"github.com/robertoduessmann/weather-api/cache"
 	"github.com/robertoduessmann/weather-api/model"
 )
 
@@ -15,60 +17,70 @@ const (
 	wttrURL    = "https://wttr.in"
 )
 
-// CurrentWeather gets the current weather to show in JSON format
-//
-// This endpoint uses wttr API with JSON response under the hood to make it
-// easier to handle with units and formats
+func writeError(w http.ResponseWriter, status int, message string) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	json.NewEncoder(w).Encode(model.ErrorMessage{Message: message})
+}
+
 func CurrentWeather(w http.ResponseWriter, r *http.Request) {
 	city := mux.Vars(r)["city"]
+	unit := mux.Vars(r)["unit"]
+	cacheKey := fmt.Sprintf("%s-%s", city, unit)
+
+	cacheManager := cache.NewCacheManager()
+	weatherCache := cacheManager.NewCache("weather", 10*time.Minute)
+
+	if cached, found := weatherCache.Get(cacheKey); found {
+		log.Printf("[CACHE HIT] key=%s", cacheKey)
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(cached.([]byte))
+		return
+	}
+
+	log.Printf("[CACHE MISS] key=%s", cacheKey)
 	uri := fmt.Sprintf("%s/%s?format=j1", wttrURL, city)
 	res, err := http.Get(uri)
-
 	if err != nil {
-		errJSON, _ := json.Marshal(model.ErrorMessage{Message: err.Error()})
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Header().Set("Content-Type", "application/json")
-		w.Write(errJSON)
+		writeError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
+	defer res.Body.Close()
 
 	if res.StatusCode != http.StatusOK {
-		errJSON, _ := json.Marshal(model.ErrorMessage{Message: "NOT_FOUND"})
-		w.WriteHeader(http.StatusNotFound)
-		w.Header().Set("Content-Type", "application/json")
-		w.Write(errJSON)
+		writeError(w, http.StatusNotFound, "NOT_FOUND")
 		return
 	}
 
-	defer res.Body.Close()
-
 	var wttr wttrResponse
 	if err := json.NewDecoder(res.Body).Decode(&wttr); err != nil {
-		errJSON, _ := json.Marshal(model.ErrorMessage{Message: err.Error()})
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Header().Set("Content-Type", "application/json")
-		w.Write(errJSON)
+		writeError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
 
-	var (
-		cc   = wttr.CurrentCondition[0]
-		unit = mux.Vars(r)["unit"]
-	)
+	if len(wttr.CurrentCondition) == 0 || len(wttr.CurrentCondition[0].WeatherDesc) == 0 {
+		writeError(w, http.StatusInternalServerError, "Unexpected API response")
+		return
+	}
 
+	cc := wttr.CurrentCondition[0]
 	response := model.Weather{
 		Description: cc.WeatherDesc[0].Value,
 		Temperature: cc.Temp(unit),
 		Wind:        cc.Windspeed(unit),
+		Forecast:    [3]model.Forecast{},
 	}
 
-	for i, weather := range wttr.Weather {
+	for i := 0; i < len(wttr.Weather) && i < 3; i++ {
+		weather := wttr.Weather[i]
+		if len(weather.Hourly) == 0 {
+			writeError(w, http.StatusInternalServerError, "Incomplete forecast data")
+			return
+		}
+
 		day, err := time.Parse(timeFormat, weather.Date)
 		if err != nil {
-			errJSON, _ := json.Marshal(model.ErrorMessage{Message: err.Error()})
-			w.WriteHeader(http.StatusInternalServerError)
-			w.Header().Set("Content-Type", "application/json")
-			w.Write(errJSON)
+			writeError(w, http.StatusInternalServerError, err.Error())
 			return
 		}
 
@@ -79,11 +91,14 @@ func CurrentWeather(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	if err := json.NewEncoder(w).Encode(response); err != nil {
-		errJSON, _ := json.Marshal(model.ErrorMessage{Message: err.Error()})
-		w.WriteHeader(http.StatusInternalServerError)
-		w.Header().Set("Content-Type", "application/json")
-		w.Write(errJSON)
+	encoded, err := json.Marshal(response)
+	if err != nil {
+		writeError(w, http.StatusInternalServerError, err.Error())
 		return
 	}
+
+	weatherCache.Put(cacheKey, encoded)
+
+	w.Header().Set("Content-Type", "application/json")
+	w.Write(encoded)
 }