Files
filekeeper/cache/user.go

87 lines
1.8 KiB
Go

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
}
type UserCache struct {
users map[string]*UserWithExpired
mu sync.Mutex
}
var log *logger.AggregatedLogger
var userCache *UserCache
func init() {
log = logger.Logger()
userCache = &UserCache{users: make(map[string]*UserWithExpired)}
ticker := time.NewTicker(time.Hour * 8)
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()))
userCache.mu.Lock()
for _, user := range userCache.users {
if currentTime.Sub(user.AccessAt) > time.Hour*8 {
DeleteUser(user.Email)
cacheClean++
}
}
userCache.mu.Unlock()
log.Info(fmt.Sprintf("Cache cleanup [user] [%s] completed: %d entries removed. Finished at %s", cleanID, cacheClean, time.Since(currentTime)))
}
}()
}
func GetUser(email string) (*UserWithExpired, error) {
userCache.mu.Lock()
defer userCache.mu.Unlock()
if user, ok := userCache.users[email]; ok {
return user, nil
}
userData, err := db.DB.GetUser(email)
if err != nil {
return nil, err
}
userCache.users[email] = &UserWithExpired{
UserID: userData.UserID,
Username: userData.Username,
Email: userData.Email,
Password: userData.Password,
AccessAt: time.Now(),
}
return userCache.users[email], nil
}
func DeleteUser(email string) {
userCache.mu.Lock()
defer userCache.mu.Unlock()
delete(userCache.users, email)
}