Implement file caching for faster retrieval and reduced database load

cache/cache.go

@@ -0,0 +1,178 @@
+package cache
+
+import (
+	"fmt"
+	"github.com/fossyy/filekeeper/db"
+	"github.com/fossyy/filekeeper/logger"
+	"github.com/fossyy/filekeeper/utils"
+	"github.com/google/uuid"
+	"sync"
+	"time"
+)
+
+type UserWithExpired struct {
+	UserID   uuid.UUID
+	Username string
+	Email    string
+	Password string
+	AccessAt time.Time
+	mu       sync.Mutex
+}
+
+type FileWithExpired struct {
+	ID            uuid.UUID
+	OwnerID       uuid.UUID
+	Name          string
+	Size          int64
+	Downloaded    int64
+	UploadedByte  int64
+	UploadedChunk int64
+	Done          bool
+	AccessAt      time.Time
+	mu            sync.Mutex
+}
+
+var log *logger.AggregatedLogger
+var userCache map[string]*UserWithExpired
+var fileCache map[string]*FileWithExpired
+
+func init() {
+	log = logger.Logger()
+
+	userCache = make(map[string]*UserWithExpired)
+	fileCache = make(map[string]*FileWithExpired)
+	ticker := time.NewTicker(time.Minute)
+
+	go func() {
+		for {
+			<-ticker.C
+			currentTime := time.Now()
+			cacheClean := 0
+			cleanID := utils.GenerateRandomString(10)
+			log.Info(fmt.Sprintf("Cache cleanup [user] [%s] initiated at %02d:%02d:%02d", cleanID, currentTime.Hour(), currentTime.Minute(), currentTime.Second()))
+
+			for _, user := range userCache {
+				user.mu.Lock()
+				if currentTime.Sub(user.AccessAt) > time.Hour*8 {
+					delete(userCache, user.Email)
+					cacheClean++
+				}
+				user.mu.Unlock()
+			}
+
+			log.Info(fmt.Sprintf("Cache cleanup [user] [%s] completed: %d entries removed. Finished at %s", cleanID, cacheClean, time.Since(currentTime)))
+		}
+	}()
+
+	go func() {
+		for {
+			<-ticker.C
+			currentTime := time.Now()
+			cacheClean := 0
+			cleanID := utils.GenerateRandomString(10)
+			log.Info(fmt.Sprintf("Cache cleanup [files] [%s] initiated at %02d:%02d:%02d", cleanID, currentTime.Hour(), currentTime.Minute(), currentTime.Second()))
+
+			for _, file := range fileCache {
+				file.mu.Lock()
+				if currentTime.Sub(file.AccessAt) > time.Minute*10 {
+					db.DB.UpdateUploadedByte(file.UploadedByte, file.ID.String())
+					db.DB.UpdateUploadedChunk(file.UploadedChunk, file.ID.String())
+					delete(fileCache, file.ID.String())
+					cacheClean++
+				}
+				file.mu.Unlock()
+			}
+
+			log.Info(fmt.Sprintf("Cache cleanup [files] [%s] completed: %d entries removed. Finished at %s", cleanID, cacheClean, time.Since(currentTime)))
+		}
+	}()
+}
+
+func GetUser(email string) (*UserWithExpired, error) {
+	if user, ok := userCache[email]; ok {
+		return user, nil
+	}
+
+	userData, err := db.DB.GetUser(email)
+	if err != nil {
+		return nil, err
+	}
+
+	userCache[email] = &UserWithExpired{
+		UserID:   userData.UserID,
+		Username: userData.Username,
+		Email:    userData.Email,
+		Password: userData.Password,
+		AccessAt: time.Now(),
+	}
+
+	return userCache[email], nil
+}
+
+func DeleteUser(email string) {
+	userCache[email].mu.Lock()
+	defer userCache[email].mu.Unlock()
+
+	delete(userCache, email)
+}
+
+func GetFile(id string) (*FileWithExpired, error) {
+	if file, ok := fileCache[id]; ok {
+		file.AccessAt = time.Now()
+		return file, nil
+	}
+
+	uploadData, err := db.DB.GetFile(id)
+	if err != nil {
+		return nil, err
+	}
+	fmt.Println("nih : ", uploadData)
+	fileCache[id] = &FileWithExpired{
+		ID:            uploadData.ID,
+		OwnerID:       uploadData.OwnerID,
+		Name:          uploadData.Name,
+		Size:          uploadData.Size,
+		Downloaded:    uploadData.Downloaded,
+		UploadedByte:  uploadData.UploadedByte,
+		UploadedChunk: uploadData.UploadedChunk,
+		Done:          uploadData.Done,
+		AccessAt:      time.Now(),
+	}
+
+	return fileCache[id], nil
+}
+
+func (file *FileWithExpired) UpdateProgress(index int64, size int64) {
+	file.UploadedChunk = index
+	file.UploadedByte = size
+	file.AccessAt = time.Now()
+}
+
+func GetUserFile(name, ownerID string) (*FileWithExpired, error) {
+	fileData, err := db.DB.GetUserFile(name, ownerID)
+	if err != nil {
+		return nil, err
+	}
+
+	file, err := GetFile(fileData.ID.String())
+	if err != nil {
+		return nil, err
+	}
+
+	return file, nil
+}
+
+func (file *FileWithExpired) FinalizeFileUpload() {
+	db.DB.UpdateUploadedByte(file.UploadedByte, file.ID.String())
+	db.DB.UpdateUploadedChunk(file.UploadedChunk, file.ID.String())
+	db.DB.FinalizeFileUpload(file.ID.String())
+	delete(fileCache, file.ID.String())
+	return
+}
+
+//func DeleteUploadInfo(id string) {
+//	filesUploadedCache[id].mu.Lock()
+//	defer filesUploadedCache[id].mu.Unlock()
+//
+//	delete(filesUploadedCache, id)
+//}