[add] Added storage.go abstraction layer

Author: filipecosta90

author.go

@@ -1,7 +1,5 @@
 package main
 
-import "fmt"
-
 // The Author struct represents the data in the JSON/JSONB column.
 // We can use struct tags to control how each field is encoded.
 type Author struct {
@@ -10,7 +8,7 @@ type Author struct {
 	About    string `json:"About"`
 }
 
-func authorToHsetCmdArgs(author Author) []interface{} {
+func authorToKeyValueMap(author Author) []interface{} {
 	nonNullValues := make([]interface{}, 0)
 	if author.Name != "" {
 		nonNullValues = append(nonNullValues, "Name", author.Name)
@@ -24,11 +22,7 @@ func authorToHsetCmdArgs(author Author) []interface{} {
 	return nonNullValues
 }
 
-func getRedisAuthorKey(authorId int) string {
-	return fmt.Sprintf("author:%d", authorId)
-}
-
-func UpdateAuthorFromRedisReply(author Author, redisReply map[string]string) (updatedAuthor Author, err error) {
+func UpdateAuthorFromMapState(author Author, redisReply map[string]string) (updatedAuthor Author, err error) {
 	updatedAuthor = author
 	if name, ok := redisReply["Name"]; ok {
 		updatedAuthor.Name = name

main.go

@@ -28,7 +28,10 @@ type server struct {
 
 func initTracer(serviceName string, jaegerAgentEndpoint string) {
 
-	// Create and install Jaeger export pipeline
+	// Spans are created by tracers, which can be acquired from a Tracer Provider.
+	// In our example we will use Jaeger as our trace provider
+	// To do so, we will follow Jaeger godoc and leverage the NewExportPipeline() method
+	// that sets up a complete export pipeline with the recommended setup for trace provider
 	tp, _, err := jaeger.NewExportPipeline(
 		jaeger.WithCollectorEndpoint(fmt.Sprintf("%s/api/traces", jaegerAgentEndpoint)),
 		jaeger.WithProcess(jaeger.Process{
@@ -49,6 +52,7 @@ func initTracer(serviceName string, jaegerAgentEndpoint string) {
 	// See: https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#tracerprovider
 	otel.SetTracerProvider(tp)
 
+	// Traces can extend beyond a single process. This requires context propagation, a mechanism where identifiers for a trace are sent to remote processes.
 	// TextMapPropagator performs the injection and extraction of a cross-cutting concern value as string key/values
 	// pairs into carriers that travel in-band across process boundaries.
 	// The carrier of propagated data on both the client (injector) and server (extractor) side is usually an HTTP request.

routes.go

@@ -18,7 +18,6 @@ func (server *server) routes() {
 
 func getIdFromRequest(req *http.Request) (id int, err error) {
 	vars := mux.Vars(req)
-	fmt.Println(vars["id"])
 	if vars["id"] != "" {
 		id, _ = strconv.Atoi(vars["id"])
 	} else {
@@ -45,18 +44,10 @@ func (server *server) handleAuthorPostOrPut() http.HandlerFunc {
 			return
 		}
 		ctx := req.Context()
-		nonNullValues := authorToHsetCmdArgs(author)
-		_, err = server.client.HSet(ctx, getRedisAuthorKey(authorId), nonNullValues...).Result()
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		redisReply, err := server.client.HGetAll(ctx, getRedisAuthorKey(authorId)).Result()
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusBadRequest)
+		err, replyAuthor, done := server.persistToStorageLayer(w, author, err, ctx, authorId)
+		if done {
 			return
 		}
-		replyAuthor, _ := UpdateAuthorFromRedisReply(author, redisReply)
 		encodedAuthor, err := json.Marshal(replyAuthor)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusBadRequest)
@@ -74,12 +65,16 @@ func (server *server) handleAuthorGet() http.HandlerFunc {
 			return
 		}
 		ctx := req.Context()
-		redisReply, err := server.client.HGetAll(ctx, getRedisAuthorKey(authorId)).Result()
+		found, storageReplyMap := server.retrieveFromStorageLayer(err, ctx, authorId)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusBadRequest)
 			return
 		}
-		replyAuthor, _ := UpdateAuthorFromRedisReply(Author{}, redisReply)
+		if !found {
+			http.Error(w, fmt.Sprintf("The resource Author with id %d does not exist", authorId), http.StatusNotFound)
+			return
+		}
+		replyAuthor, _ := UpdateAuthorFromMapState(Author{}, storageReplyMap)
 		encodedAuthor, err := json.Marshal(replyAuthor)
 		if err != nil {
 			http.Error(w, err.Error(), http.StatusBadRequest)

storage.go

@@ -0,0 +1,36 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+)
+
+func getRedisAuthorKey(authorId int) string {
+	return fmt.Sprintf("author:%d", authorId)
+}
+
+func (server *server) persistToStorageLayer(w http.ResponseWriter, author Author, err error, ctx context.Context, authorId int) (error, Author, bool) {
+	nonNullValues := authorToKeyValueMap(author)
+	_, err = server.client.HSet(ctx, getRedisAuthorKey(authorId), nonNullValues...).Result()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return nil, Author{}, true
+	}
+	redisReply, err := server.client.HGetAll(ctx, getRedisAuthorKey(authorId)).Result()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return nil, Author{}, true
+	}
+	replyAuthor, _ := UpdateAuthorFromMapState(author, redisReply)
+	return err, replyAuthor, false
+}
+
+func (server *server) retrieveFromStorageLayer(err error, ctx context.Context, authorId int) (found bool, storageReplyMap map[string]string) {
+	storageReplyMap, err = server.client.HGetAll(ctx, getRedisAuthorKey(authorId)).Result()
+	found = true
+	if len(storageReplyMap) == 0 {
+		found = false
+	}
+	return
+}