feat:#36 added protobuf communication for modules

services/ical/Dockerfile

@@ -24,8 +24,8 @@ RUN apk add --no-cache --update go gcc g++
 COPY go.mod go.sum ./
 RUN go mod download
 
-COPY ical/*.go ./ical/
 COPY ical/. ./ical
+COPY common/. ./common
 RUN CGO_ENABLED=1 GOOS=linux go build -o /htwkalender-ical ical/main.go
 
 # production stage
@@ -46,7 +46,7 @@ COPY --chown=$USER:$USER --from=build /htwkalender-ical ./
 # Expose port 8091 to the outside world
 EXPOSE 8091
 
-ENTRYPOINT ["./htwkalender-ical"]
+ENTRYPOINT ["./main"]
 
 
 FROM golang:1.21.6 AS dev
@@ -59,8 +59,8 @@ COPY go.mod go.sum ./
 RUN go mod download
 
 # Copy the source from the current directory to the Working Directory inside the container
-COPY ical/*.go ./ical/
 COPY ical/. ./ical
+COPY common/. ./common
 
 # Build the Go app
 RUN CGO_ENABLED=1 GOOS=linux go build -o /htwkalender-ical ical/main.go

services/ical/main.go

@@ -20,18 +20,24 @@ import (
 	"github.com/gofiber/fiber/v3"
 	"github.com/gofiber/fiber/v3/log"
 	"github.com/gofiber/fiber/v3/middleware/logger"
+	"htwkalender/ical/model"
 	"htwkalender/ical/service"
+	"htwkalender/ical/service/connector/grpc"
 )
 
 // main function for the ical service
 // uses rest api to get the data from the data-manager
 // exposes rest api endpoints with fiber to serve the data for clients
 func main() {
+	const host = "htwkalender-data-manager"
+
+	grpcClient := grpc.ConnectGRPCServer(host)
+	defer grpc.CloseGRPCServer(grpcClient)
 
 	// Initialize a new Fiber app
 	webdavRequestMethods := []string{"PROPFIND", "MKCOL", "COPY", "MOVE"}
 
-	app := fiber.New(fiber.Config{
+	fiberApp := fiber.New(fiber.Config{
 		CaseSensitive:  true,
 		StrictRouting:  true,
 		ServerHeader:   "Fiber",
@@ -39,10 +45,17 @@ func main() {
 		RequestMethods: append(fiber.DefaultMethods[:], webdavRequestMethods...),
 	})
 
-	app.Use(logger.New())
+	var app = model.AppType{
+		GrpcClient:     grpcClient,
+		Host:           host,
+		Fiber:          fiberApp,
+		DataManagerURL: "http://" + host + ":8090",
+	}
+
+	fiberApp.Use(logger.New())
 
 	// Add routes to the app instance for the data-manager ical service
 	service.AddFeedRoutes(app)
 
-	log.Fatal(app.Listen(":8091"))
+	log.Fatal(fiberApp.Listen(":8091"))
 }

services/ical/model/appModel.go

@@ -0,0 +1,13 @@
+package model
+
+import (
+	"github.com/gofiber/fiber/v3"
+	googleGRPC "google.golang.org/grpc"
+)
+
+type AppType struct {
+	GrpcClient     *googleGRPC.ClientConn
+	Host           string
+	Fiber          *fiber.App
+	DataManagerURL string
+}

services/ical/model/icalModel.go

@@ -19,10 +19,14 @@ package model
 import (
 	"encoding/json"
 	"fmt"
+	"log/slog"
 	"strings"
 	"time"
 )
 
+// DefaultDateLayout specifies the default app date strings layout.
+const DefaultDateLayout = "2006-01-02 15:04:05.000Z"
+
 // IcalModel local type for EmitICal function
 type IcalModel struct {
 	Events  Events
@@ -73,10 +77,19 @@ func (jt *JSONTime) UnmarshalJSON(b []byte) error {
 	if timeString == "null" || timeString == "" {
 		return nil
 	}
-	t, err := time.Parse("2006-01-02 15:04:05.000Z", timeString)
+	t, err := time.Parse(DefaultDateLayout, timeString)
 	if err == nil {
 		*jt = JSONTime(t)
 		return nil
 	}
 	return fmt.Errorf("error parsing time string %s: %w", timeString, err)
 }
+
+func ToJSONTime(timeString string) JSONTime {
+	t, err := time.Parse(DefaultDateLayout, timeString)
+	if err != nil {
+		slog.Error("error parsing time string: ", "error", err)
+		return JSONTime(time.Time{})
+	}
+	return JSONTime(t)
+}

services/ical/service/connector/feedConnector.go

@@ -7,12 +7,12 @@ import (
 	"log/slog"
 )
 
-func GetFeedByToken(token string) (model.FeedRecord, error) {
+func GetFeedByToken(host string, token string) (model.FeedRecord, error) {
 	var feed model.FeedRecord
 
 	// /api/collections/feeds/records/{id}
 
-	response, err := RequestApi("/api/collections/feeds/records/" + token)
+	response, err := RequestApi(host, "/api/collections/feeds/records/"+token)
 	if err != nil {
 		return model.FeedRecord{}, err
 	}
@@ -39,8 +39,8 @@ func parseResponse(response []byte) (model.FeedRecord, error) {
 	return feedRecord, nil
 }
 
-func DeleteFeedRecord(token string) error {
-	err := DeleteRequestApi("/api/feed?token=" + token)
+func DeleteFeedRecord(app model.AppType, token string) error {
+	err := DeleteRequestApi(app.DataManagerURL, "/api/feed?token="+token)
 	if err != nil {
 		return err
 	}
@@ -48,10 +48,10 @@ func DeleteFeedRecord(token string) error {
 	return nil
 }
 
-func GetModuleWithEvents(module model.FeedModule) (model.Module, error) {
+func GetModuleWithEvents(app model.AppType, module model.FeedModule) (model.Module, error) {
 	var modules model.Module
 
-	response, err := RequestApi("/api/module?uuid=" + module.UUID)
+	response, err := RequestApi(app.DataManagerURL, "/api/module?uuid="+module.UUID)
 	if err != nil {
 		return model.Module{}, err
 	}
@@ -77,10 +77,10 @@ func parseModuleResponse(body []byte) (model.Module, error) {
 	return module, nil
 }
 
-func SaveFeedRecord(modules []model.FeedCollection) (string, error) {
+func SaveFeedRecord(app model.AppType, modules []model.FeedCollection) (string, error) {
 	var token string
 
-	response, err := PostRequestApi("/api/feed", modules)
+	response, err := PostRequestApi(app.DataManagerURL, "/api/feed", modules)
 	if err != nil {
 		return "", err
 	}

services/ical/service/connector/grpc/client.go

@@ -0,0 +1,21 @@
+package grpc
+
+import (
+	"google.golang.org/grpc"
+	"log/slog"
+)
+
+func ConnectGRPCServer(host string) *grpc.ClientConn {
+	conn, err := grpc.Dial(host+":50051", grpc.WithInsecure(), grpc.WithBlock())
+	if err != nil {
+		slog.Error("could not connect to grpc server", "error", err)
+	}
+	return conn
+}
+
+func CloseGRPCServer(conn *grpc.ClientConn) {
+	err := conn.Close()
+	if err != nil {
+		slog.Error("could not close connection", "error", err)
+	}
+}

services/ical/service/connector/grpc/modules.go

@@ -0,0 +1,54 @@
+package grpc
+
+import (
+	"context"
+	"google.golang.org/grpc"
+	pb "htwkalender/common/genproto/modules"
+	"htwkalender/ical/model"
+	"log/slog"
+	"time"
+)
+
+func GetModuleWithEvents(module model.FeedModule, conn *grpc.ClientConn) (model.Module, error) {
+	c := pb.NewModuleServiceClient(conn)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	r, err := c.GetModule(ctx, &pb.GetModuleRequest{Uuid: module.UUID})
+	if err != nil {
+		slog.Error("could not get module: %v", "error", err)
+	}
+
+	events := make([]model.Event, 0)
+	for _, event := range r.GetModule().Events {
+		events = append(events, protoToEvent(event))
+	}
+
+	return model.Module{
+		UUID:     r.GetModule().Uuid,
+		Name:     r.GetModule().Name,
+		Prof:     r.GetModule().Prof,
+		Course:   r.GetModule().Course,
+		Semester: r.GetModule().Semester,
+		Events:   events,
+	}, nil
+}
+
+func protoToEvent(event *pb.Event) model.Event {
+
+	return model.Event{
+		UUID:       event.Uuid,
+		Day:        event.Day,
+		Week:       event.Week,
+		Start:      model.ToJSONTime(event.Start),
+		End:        model.ToJSONTime(event.End),
+		Name:       event.Name,
+		EventType:  event.EventType,
+		Compulsory: event.Compulsory,
+		Prof:       event.Prof,
+		Rooms:      event.Rooms,
+		Notes:      event.Notes,
+		BookedAt:   event.BookedAt,
+		Course:     event.Course,
+		Semester:   event.Semester,
+	}
+}

services/ical/service/connector/restHandler.go

@@ -6,9 +6,7 @@ import (
 	"time"
 )
 
-const host = "http://htwkalender-data-manager:8090"
-
-func RequestApi(path string) (*client.Response, error) {
+func RequestApi(host string, path string) (*client.Response, error) {
 
 	cc := client.New()
 	cc.SetTimeout(5 * time.Second)
@@ -22,7 +20,7 @@ func RequestApi(path string) (*client.Response, error) {
 	return response, nil
 }
 
-func DeleteRequestApi(path string) error {
+func DeleteRequestApi(host string, path string) error {
 
 	cc := client.New()
 	cc.SetTimeout(5 * time.Second)
@@ -36,7 +34,7 @@ func DeleteRequestApi(path string) error {
 	return nil
 }
 
-func PostRequestApi(path string, body []model.FeedCollection) (*client.Response, error) {
+func PostRequestApi(host string, path string, body []model.FeedCollection) (*client.Response, error) {
 
 	cc := client.New()
 	cc.SetTimeout(5 * time.Second)

services/ical/service/ical/ical.go

@@ -5,15 +5,16 @@ import (
 	"github.com/jordic/goics"
 	"htwkalender/ical/model"
 	"htwkalender/ical/service/connector"
+	htwkalenderGrpc "htwkalender/ical/service/connector/grpc"
 	"log/slog"
 	"time"
 )
 
 const expirationTime = 5 * time.Minute
 
-func Feed(token string) (string, error) {
+func Feed(app model.AppType, token string) (string, error) {
 	// get feed by token
-	feed, err := connector.GetFeedByToken(token)
+	feed, err := connector.GetFeedByToken(app.DataManagerURL, token)
 	if err != nil {
 		return "", err
 	}
@@ -21,7 +22,7 @@ func Feed(token string) (string, error) {
 	var events model.Events
 
 	for _, module := range feed.Modules {
-		moduleWithEvents, err := connector.GetModuleWithEvents(module)
+		moduleWithEvents, err := htwkalenderGrpc.GetModuleWithEvents(module, app.GrpcClient)
 		if err != nil {
 			return "", err
 		}
@@ -29,7 +30,7 @@ func Feed(token string) (string, error) {
 		events = append(events, moduleWithEvents.Events...)
 	}
 
-	// Sorte events by start date
+	// Sort events by start date
 	events.Sort()
 
 	modules := make(map[string]model.FeedCollection)
@@ -44,9 +45,9 @@ func Feed(token string) (string, error) {
 	return icalFeed.Content, nil
 }
 
-func FeedRecord(token string) (model.FeedRecord, error) {
+func FeedRecord(app model.AppType, token string) (model.FeedRecord, error) {
 
-	feedRecord, err := connector.GetFeedByToken(token)
+	feedRecord, err := connector.GetFeedByToken(app.DataManagerURL, token)
 	if err != nil {
 		return model.FeedRecord{}, err
 	}
@@ -55,18 +56,18 @@ func FeedRecord(token string) (model.FeedRecord, error) {
 
 }
 
-func DeleteFeedRecord(token string) error {
-	err := connector.DeleteFeedRecord(token)
+func DeleteFeedRecord(app model.AppType, token string) error {
+	err := connector.DeleteFeedRecord(app, token)
 	if err != nil {
 		return err
 	}
 	return nil
 }
 
-func CreateFeed(modules []model.FeedCollection) (string, error) {
+func CreateFeed(app model.AppType, modules []model.FeedCollection) (string, error) {
 
 	// Save feed
-	token, err := connector.SaveFeedRecord(modules)
+	token, err := connector.SaveFeedRecord(app, modules)
 	if err != nil {
 		slog.Error("Failed to save feed", "error", err)
 		return "", err

services/ical/service/routes.go

@@ -12,13 +12,13 @@ import (
 
 // AddFeedRoutes add routes to the app instance for the data-manager ical service
 // with golang fiber
-func AddFeedRoutes(app *fiber.App) {
+func AddFeedRoutes(app model.AppType) {
 
 	// Define a route for the GET method on the root path '/'
-	app.Get("/api/feed", func(c fiber.Ctx) error {
+	app.Fiber.Get("/api/feed", func(c fiber.Ctx) error {
 
 		token := c.Query("token")
-		results, err := ical.Feed(token)
+		results, err := ical.Feed(app, token)
 
 		if err != nil {
 			slog.Error("Failed to get feed", "error", err)
@@ -33,7 +33,7 @@ func AddFeedRoutes(app *fiber.App) {
 	})
 
 	// Define a route for the POST method on the root path '/api/feed'
-	app.Post("/api/feed", func(c fiber.Ctx) error {
+	app.Fiber.Post("/api/feed", func(c fiber.Ctx) error {
 		var modules []model.FeedCollection
 		//obtain the body of the request
 		err := json.Unmarshal(c.Body(), &modules)
@@ -43,7 +43,7 @@ func AddFeedRoutes(app *fiber.App) {
 		}
 
 		//create a new feed
-		token, err := ical.CreateFeed(modules)
+		token, err := ical.CreateFeed(app, modules)
 		if err != nil {
 			println(err)
 			log.Error("Failed to create feed", "error", err)
@@ -54,10 +54,10 @@ func AddFeedRoutes(app *fiber.App) {
 	})
 
 	// Define a route for the GET method on the root path '/'
-	app.Get("/api/collections/feeds/records/:token", func(c fiber.Ctx) error {
+	app.Fiber.Get("/api/collections/feeds/records/:token", func(c fiber.Ctx) error {
 
 		token := c.Params("token")
-		results, err := ical.FeedRecord(token)
+		results, err := ical.FeedRecord(app, token)
 
 		if err != nil {
 			slog.Error("Failed to get feed", "error", err)
@@ -68,10 +68,10 @@ func AddFeedRoutes(app *fiber.App) {
 		return c.JSON(results)
 	})
 
-	app.Delete("/api/feed", func(c fiber.Ctx) error {
+	app.Fiber.Delete("/api/feed", func(c fiber.Ctx) error {
 
 		token := c.Query("token")
-		err := ical.DeleteFeedRecord(token)
+		err := ical.DeleteFeedRecord(app, token)
 		if err != nil {
 			slog.Error("Feed could not be deleted", "error", err)
 			return c.JSON(http.StatusNotFound, "Feed could not be deleted")
@@ -80,28 +80,28 @@ func AddFeedRoutes(app *fiber.App) {
 		}
 	})
 
-	app.Put("/api/feed", func(c fiber.Ctx) error {
+	app.Fiber.Put("/api/feed", func(c fiber.Ctx) error {
 		token := c.Query("token")
 		return c.JSON(http.StatusOK, "token: "+token)
 	})
 
-	app.Head("/api/feed", func(c fiber.Ctx) error {
+	app.Fiber.Head("/api/feed", func(c fiber.Ctx) error {
 		return c.JSON(http.StatusOK, "")
 	})
 
-	app.Add([]string{"PROPFIND"}, "/api/feed", func(c fiber.Ctx) error {
+	app.Fiber.Add([]string{"PROPFIND"}, "/api/feed", func(c fiber.Ctx) error {
 		return c.JSON(http.StatusOK, "")
 	})
 
 	// Route for Thunderbird to get calendar server information
 	// Response is a 200 OK without additional content
-	app.Add([]string{"PROPFIND"}, "/.well-known/caldav", func(c fiber.Ctx) error {
+	app.Fiber.Add([]string{"PROPFIND"}, "/.well-known/caldav", func(c fiber.Ctx) error {
 		return c.JSON(http.StatusOK, "")
 	})
 
 	// Route for Thunderbird to get calendar server information
 	// Response is a 200 OK without additional content
-	app.Add([]string{"PROPFIND"}, "/", func(c fiber.Ctx) error {
+	app.Fiber.Add([]string{"PROPFIND"}, "/", func(c fiber.Ctx) error {
 		return c.JSON(http.StatusOK, "")
 	})