Change blob to be queried by a random hash instead

This allows a better platform for the collab service to
persist/reconnect users through.

Author: WZWren

matching-service-api/mappings/client_mappings.go

@@ -0,0 +1,18 @@
+package mappings
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"io"
+)
+
+func GenerateMatchingHash() (string, error) {
+	bytes := make([]byte, 16)
+
+	if _, err := io.ReadFull(rand.Reader, bytes); err != nil {
+		return "", errors.New("Failed to generate random matching hash" + err.Error())
+	}
+
+	return hex.EncodeToString(bytes), nil
+}

matching-service-api/models/request.go

@@ -1,6 +1,8 @@
 package models
 
 type Request struct {
+	MatchHash string
+
 	UserId string `json:"userId"` 
 
 	TopicTags []string `json:"topicTags"`

matching-service-api/transport/request_handler.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"matching-service-api/models"
+	"matching-service-api/mappings"
 	"net/http"
 	"time"
 
@@ -29,6 +30,16 @@ func HandleRequest(channel *models.ProducerQueue, logger *models.Logger) gin.Han
 			return
 		}
 
+		// adding this matching hash to reserve user-id as a store for
+		// persistence.
+		matchHash, err := mappings.GenerateMatchingHash();
+		if err != nil {
+			logger.Log.Error("Error: " + err.Error())
+			ctx.JSON(http.StatusInternalServerError, "failed to generate query hash")
+			return
+		}
+		req.MatchHash = matchHash;
+
 		//current time is more than 30 seconds after request time, timeout
 		if time.Now().After(parsedTime.Add(30 * time.Second).Add(-8 * time.Hour)) {
 			logger.Log.Warn("request timeout")
@@ -59,6 +70,9 @@ func HandleRequest(channel *models.ProducerQueue, logger *models.Logger) gin.Han
 		}
 
 		logger.Log.Info(fmt.Sprintf("request from user %s successfully published", req.UserId))
-		ctx.JSON(http.StatusOK, "processing request")
+		ctx.JSON(http.StatusOK, gin.H{
+			"match_code": matchHash,
+			"message": "processing request",
+		})
 	}
 }

matching-service/models/matching_request.go

@@ -1,6 +1,7 @@
 package models
 
 type IncomingRequests struct {
+	MatchHash   string	 `json:"matchHash"`
 	UserId      string   `json:"userId"`
 	TopicTags   []string `json:"topicTags"`
 	Difficulty  string   `json:"difficulty"`

matching-service/models/room.go

@@ -1,7 +1,11 @@
 package models
 
 type Room struct {
+	// stores what key to ship the resulting blob to
+	MatchHash1 string `json:"matchHash1"`
+	MatchHash2 string `json:"matchHash2"`
 
+	// user information
 	RoomId     string	`json:"roomId"`
 	User1      string	`json:"user1"`
 	User2      string	`json:"user2"`

matching-service/storage/client_mappings.go

@@ -33,7 +33,8 @@ func InitialiseClientMappings(addr string, db_num int) *ClientMappings {
 
 func (db *ClientMappings) HandleRequest(request models.IncomingRequests) (*models.Room, error){
 	ctx := context.Background()
-	user2, user2_difficulty, user2_topics, user2_requestTime := request.UserId, request.Difficulty, request.TopicTags, request.RequestTime
+	user2, user2_difficulty, user2_topics := request.UserId, request.Difficulty, request.TopicTags
+	user2_requestTime, user2_matchHash := request.RequestTime, request.MatchHash
 
 	currMappings, err := db.Conn.Keys(ctx, "*").Result()
 
@@ -67,17 +68,20 @@ func (db *ClientMappings) HandleRequest(request models.IncomingRequests) (*model
 		if len(overlappingTopics) == 0 {
 			continue
 		}	
-
 
 		roomId, err := generateRoomId()
 
 		if err != nil {
 			return nil, err
 		} 
 
+		user1_matchHash := result["matchHash"]
+		
 		db.Conn.Del(ctx, user1)
 
 		room := models.Room{
+			MatchHash1: user1_matchHash,
+			MatchHash2: user2_matchHash,
 			RoomId: roomId,
 			User1: user1,
 			User2: user2,
@@ -106,6 +110,7 @@ func (db *ClientMappings) HandleRequest(request models.IncomingRequests) (*model
 	}
 
 	err = db.Conn.HSet(ctx, user2, map[string]interface{}{
+		"matchHash": user2_matchHash,
 		"topicTags": user2_topics_json,
 		"difficulty": user2_difficulty,
 		"requestTime": user2_requestTime,

matching-service/storage/room_mappings.go

@@ -40,8 +40,10 @@ func (db *RoomMappings) SendToStorageBlob(room *models.Room) error {
 		return fmt.Errorf("error marshling topics: %s", err.Error())
 	}
 
+	// this is where the value is being set
 	user1_info := map[string]interface{}{
 		"roomId":      room.RoomId,
+		"thisUser":    room.User1,
 		"otherUser":   room.User2,
 		"requestTime": room.RequestTime,
 
@@ -56,6 +58,7 @@ func (db *RoomMappings) SendToStorageBlob(room *models.Room) error {
 
 	user2_info := map[string]interface{}{
 		"roomId":      room.RoomId,
+		"thisUser":    room.User2,
 		"otherUser":   room.User1,
 		"requestTime": room.RequestTime,
 
@@ -68,11 +71,12 @@ func (db *RoomMappings) SendToStorageBlob(room *models.Room) error {
 		"id":         room.QuestionId,
 	}
 
-	if err1 := db.Conn.HSet(ctx, room.User1, user1_info).Err(); err1 != nil {
+	// TODO: Modify this - this is where the key-value is being set
+	if err1 := db.Conn.HSet(ctx, room.MatchHash1, user1_info).Err(); err1 != nil {
 		return fmt.Errorf("error setting user1's room to storage: %s", err1.Error())
 	}
 
-	if err2 := db.Conn.HSet(ctx, room.User2, user2_info).Err(); err2 != nil {
+	if err2 := db.Conn.HSet(ctx, room.MatchHash2, user2_info).Err(); err2 != nil {
 		return fmt.Errorf("error setting user2's room to storage: %s", err2.Error())
 	}
 
@@ -86,11 +90,11 @@ func (db *RoomMappings) SendToStorageBlob(room *models.Room) error {
 
 	diff := int(time.Until(expiryTime).Seconds())
 
-	if err1 := db.Conn.Expire(ctx, room.User1, time.Duration(diff)*time.Second).Err(); err1 != nil {
+	if err1 := db.Conn.Expire(ctx, room.MatchHash1, time.Duration(diff)*time.Second).Err(); err1 != nil {
 		return fmt.Errorf("error setting expiry time on room data: %s", err1.Error())
 	}
 
-	if err2 := db.Conn.Expire(ctx, room.User2, time.Duration(diff)*time.Second).Err(); err2 != nil {
+	if err2 := db.Conn.Expire(ctx, room.MatchHash2, time.Duration(diff)*time.Second).Err(); err2 != nil {
 		return fmt.Errorf("error setting expiry time on room data: %s", err2.Error())
 	}
 

storage-blob-api/transport/endpoint.go

@@ -10,7 +10,7 @@ import (
 )
 
 func SetAllEndpoints(router *gin.Engine, db *storage.RoomMappings, logger *models.Logger) {
-	router.GET("/request/:userId", HandleRequest(db, logger))
+	router.GET("/request/:matchHash", HandleRequest(db, logger))
 }
 
 func SetCors(router *gin.Engine, origin string) {

storage-blob-api/transport/request_handler.go

@@ -15,17 +15,17 @@ import (
 
 func HandleRequest(db *storage.RoomMappings, logger *models.Logger) (gin.HandlerFunc){
 	return func(ctx *gin.Context) {
-		userId := ctx.Param("userId")
+		matchHash := ctx.Param("matchHash")
 
-		result, err := db.Conn.HGetAll(context.Background(), userId).Result()
+		result, err := db.Conn.HGetAll(context.Background(), matchHash).Result()
 
 		if err == redis.Nil {
-			logger.Log.Warn(fmt.Sprintf("userId %s expired: ", userId))
-			ctx.JSON(http.StatusGone, "userId has expired")
+			logger.Log.Warn(fmt.Sprintf("matchHash %s expired: ", matchHash))
+			ctx.JSON(http.StatusGone, "matchHash has expired")
 			return
 		} else if err != nil {
-			logger.Log.Error(fmt.Errorf("error retrieving userId from database: %s", err.Error()))
-			ctx.JSON(http.StatusBadGateway, "error retriving userId from database")
+			logger.Log.Error(fmt.Errorf("error retrieving matchHash from database: %s", err.Error()))
+			ctx.JSON(http.StatusBadGateway, "error retriving matchHash from database")
 			return
 		}
 
@@ -49,10 +49,12 @@ func HandleRequest(db *storage.RoomMappings, logger *models.Logger) (gin.Handler
 			return
 		}
 
-		roomId, user2, requestTime, title, titleSlug, difficulty, content, questionId_string := 
-			result["roomId"], result["otherUser"], result["requestTime"], 
-			result["title"], result["titleSlug"], result["difficulty"], result["content"], result["id"]
-
+		roomId, user1, user2, requestTime := 
+			result["roomId"], result["thisUser"], result["otherUser"], result["requestTime"]
+			
+		
+		title, titleSlug, difficulty, content, questionId_string :=
+		result["title"], result["titleSlug"], result["difficulty"], result["content"], result["id"]
 		questionId, err := strconv.Atoi(questionId_string)
 
 		if err != nil {
@@ -63,7 +65,7 @@ func HandleRequest(db *storage.RoomMappings, logger *models.Logger) (gin.Handler
 
 		room := models.Room{
 			RoomId: roomId,
-			User1: userId,
+			User1: user1,
 			User2: user2,
 			RequestTime: requestTime,