backend changes to conform to keycloak auth logic

cmd/schema-orchestrator/main.go

@@ -7,12 +7,15 @@ package main
 
 import (
 	"fmt"
-	"log"
 	"os"
 	"schema-orchestrator/internal/drivers/rpcdriver"
 	"schema-orchestrator/internal/drivers/webdriver"
 	"schema-orchestrator/internal/usecases/produce"
 	"schema-orchestrator/internal/usecases/schema"
+	"strconv"
+
+	"github.com/rs/zerolog"
+	"github.com/rs/zerolog/log"
 
 	"git.science.uu.nl/graphpolaris/broker"
 	"git.science.uu.nl/graphpolaris/keyvaluestore"
@@ -23,6 +26,15 @@ import (
 This is the main method, it executes the code for this service
 */
 func main() {
+	// Set up logging
+	zerolog.TimeFieldFormat = zerolog.TimeFormatUnix
+	logLevel, log_err := strconv.Atoi(os.Getenv("LOG_LEVEL"))
+	if log_err != nil {
+		log.Error().AnErr("err", log_err).Msg("LOG_LEVEL not type int or empty")
+	}
+	zerolog.SetGlobalLevel(zerolog.Level(logLevel))
+	log.Logger = log.Output(zerolog.ConsoleWriter{Out: os.Stderr})
+
 	// Create rpcDriver
 	rpcDriver := rpcdriver.New()
 
@@ -33,21 +45,21 @@ func main() {
 	clientUpdaterRedisService := keyvaluestore.NewDriver()
 	err := clientUpdaterRedisService.Connect(os.Getenv("UI_REDIS_ADDRESS"))
 	if err != nil {
-		log.Panicln(fmt.Sprintf("keyValueStore error: %s", err))
+		log.Panic().Msg(fmt.Sprintf("keyValueStore error: %s", err))
 	}
 
 	// Create keyvaluestore to keep track of schema status
 	schemaStatusRedisService := keyvaluestore.NewDriver()
 	err = schemaStatusRedisService.Connect(os.Getenv("SCHEMA_REDIS_ADDRESS"))
 	if err != nil {
-		log.Panicln(fmt.Sprintf("keyValueStore error: %s", err))
+		log.Panic().Msg(fmt.Sprintf("keyValueStore error: %s", err))
 	}
 
 	// Create object store driver
 	objectStore := objectstore.NewDriver()
 	err = objectStore.Connect()
 	if err != nil {
-		log.Panicln(fmt.Sprintf("objectStore error: %s", err))
+		log.Panic().Msg(fmt.Sprintf("objectStore error: %s", err))
 	}
 
 	// Create producer service

internal/usecases/schema/retrieve.go

@@ -5,7 +5,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"log"
+
+	"github.com/rs/zerolog/log"
 
 	"git.science.uu.nl/graphpolaris/keyvaluestore"
 )
@@ -23,29 +24,28 @@ func (s *Service) Retrieve(request *[]byte, sessionID string, clientID string, d
 	// Check if the schema is currently being retrieved for this database
 	schemaBeingRetrievedInterface, err := s.keyValueStore.Get(context.Background(), fmt.Sprintf("%s-%s", databaseName, clientID), keyvaluestore.Bool)
 	if err != nil && err != keyvaluestore.ErrKeyNotFound {
-		log.Println(err)
-		log.Println(fmt.Sprintf("error accessing keyvaluestore in schema retrieve method: %s", err.Error()))
+		log.Error().AnErr("Err", err).Msg("error accessing keyvaluestore in schema retrieve method")
 		return err
 	}
 
 	// Cast the interface{} to bool
 	schemaBeingRetrieved, ok := schemaBeingRetrievedInterface.(bool)
 	if !ok {
-		log.Println("error casting schemaBeingRetrieved to bool")
+		log.Error().Msg("error casting schemaBeingRetrieved to bool")
 		return errors.New("internal error (kvs)")
 	}
 
 	// Schema is already being retrieved
 	if schemaBeingRetrieved {
-		log.Println("schema is already being retrieved")
+		log.Warn().Msg("schema is already being retrieved")
 		return nil
 	}
 
-	log.Println("schema is not being retrieved yet")
+	log.Trace().Msg("schema is not being retrieved yet")
 
 	// Check if the schema should be force refreshed
 	if !cached {
-		log.Println("Not cached! Producing a schema retrieval request")
+		log.Trace().Msg("Not cached! Producing a schema retrieval request")
 
 		// Produce a schema retrieval request
 		s.producer.ProduceSchemaRetrievalRequest(*request, sessionID, clientID, databaseName)
@@ -55,7 +55,7 @@ func (s *Service) Retrieve(request *[]byte, sessionID string, clientID string, d
 	// Check if the schema has been cached
 	schema, err := s.retrieveCachedSchema(clientID, databaseName)
 	if err != nil {
-		log.Println("schema not present in object store")
+		log.Trace().Msg("schema not present in object store")
 		// Schema was not in object store, or there was another issue with the object store
 		// Produce a schema retrieval request
 		s.producer.ProduceSchemaRetrievalRequest(*request, sessionID, clientID, databaseName)
@@ -67,7 +67,7 @@ func (s *Service) Retrieve(request *[]byte, sessionID string, clientID string, d
 		return nil
 	}
 
-	log.Println("schema present in object store")
+	log.Trace().Msg("schema present in object store")
 
 	// Produce the cached schema
 	jsonResult := make(map[string]interface{})