gocommon/session/impl_redis.go

package session

import (
	"context"
	"time"

	"github.com/go-redis/redis/v8"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"repositories.action2quare.com/ayo/gocommon"
	"repositories.action2quare.com/ayo/gocommon/logger"
)

type sessionRedis struct {
	*Authorization
	expireAt time.Time
}

type provider_redis struct {
	redisClient   *redis.Client
	updateChannel string
	deleteChannel string
	ttl           time.Duration
	ctx           context.Context
}

func newProviderWithRedis(ctx context.Context, redisUrl string, ttl time.Duration) (Provider, error) {
	redisClient, err := gocommon.NewRedisClient(redisUrl)
	if err != nil {
		return nil, err
	}

	return &provider_redis{
		redisClient:   redisClient,
		updateChannel: communication_channel_name_prefix + "_u",
		deleteChannel: communication_channel_name_prefix + "_d",
		ttl:           ttl,
		ctx:           ctx,
	}, nil
}

func (p *provider_redis) New(input *Authorization) (string, error) {
	bt, err := bson.Marshal(input)
	if err != nil {
		return "", err
	}

	sk := make_storagekey(input.Account)
	_, err = p.redisClient.SetEX(p.ctx, string(sk), bt, p.ttl).Result()
	if err != nil {
		return "", err
	}

	_, err = p.redisClient.Publish(p.ctx, p.updateChannel, string(sk)).Result()
	return string(storagekey_to_publickey(sk)), err
}

func (p *provider_redis) Delete(account primitive.ObjectID) error {
	prefix := account.Hex()
	sks, err := p.redisClient.Keys(p.ctx, prefix+"*").Result()
	if err != nil {
		return err
	}

	for _, sk := range sks {
		p.redisClient.Del(p.ctx, sk).Result()
		p.redisClient.Publish(p.ctx, p.deleteChannel, sk).Result()
	}

	return nil
}

func (p *provider_redis) Query(pk string) (*Authorization, error) {
	sk := publickey_to_storagekey(publickey(pk))
	payload, err := p.redisClient.Get(p.ctx, string(sk)).Result()
	if err == redis.Nil {
		return nil, nil
	} else if err != nil {
		return nil, err
	}

	var auth Authorization
	if err := bson.Unmarshal([]byte(payload), &auth); err != nil {
		return nil, err
	}

	return &auth, nil
}

type consumer_redis struct {
	consumer_common[*sessionRedis]
	redisClient *redis.Client
}

func newConsumerWithRedis(ctx context.Context, redisUrl string, ttl time.Duration) (Consumer, error) {
	redisClient, err := gocommon.NewRedisClient(redisUrl)
	if err != nil {
		return nil, err
	}

	consumer := &consumer_redis{
		consumer_common: consumer_common[*sessionRedis]{
			ttl:       ttl,
			ctx:       ctx,
			stages:    [2]*cache_stage[*sessionRedis]{make_cache_stage[*sessionRedis](), make_cache_stage[*sessionRedis]()},
			startTime: time.Now(),
		},
		redisClient: redisClient,
	}

	updateChannel := communication_channel_name_prefix + "_u"
	deleteChannel := communication_channel_name_prefix + "_d"
	sub := redisClient.Subscribe(ctx, updateChannel, deleteChannel)

	go func() {
		stageswitch := time.Now().Add(ttl)
		tickTimer := time.After(ttl)

		for {
			select {
			case <-ctx.Done():
				return

			case <-tickTimer:
				consumer.changeStage()
				stageswitch = stageswitch.Add(ttl)
				tempttl := time.Until(stageswitch)
				tickTimer = time.After(tempttl)

			case msg := <-sub.Channel():
				if msg == nil {
					return
				}

				if len(msg.Payload) == 0 {
					continue
				}

				switch msg.Channel {
				case updateChannel:
					sk := storagekey(msg.Payload)
					raw, err := redisClient.Get(ctx, string(sk)).Result()
					if err != nil {
						logger.Println(err)
					} else if len(raw) > 0 {
						var si Authorization
						if bson.Unmarshal([]byte(raw), &si) == nil {
							consumer.add(sk, &sessionRedis{
								Authorization: &si,
								expireAt:      time.Now().Add(consumer.ttl),
							})
						}
					}
				case deleteChannel:
					sk := storagekey(msg.Payload)
					consumer.delete(sk)
				}
			}
		}
	}()

	return consumer, nil
}

func (c *consumer_redis) query_internal(sk storagekey) (*sessionRedis, bool, error) {
	if _, deleted := c.stages[0].deleted[sk]; deleted {
		return nil, false, nil
	}

	if _, deleted := c.stages[1].deleted[sk]; deleted {
		return nil, false, nil
	}

	found, ok := c.stages[0].cache[sk]
	if !ok {
		found, ok = c.stages[1].cache[sk]
	}

	if ok {
		return found, false, nil
	}

	payload, err := c.redisClient.Get(c.ctx, string(sk)).Result()
	if err == redis.Nil {
		return nil, false, nil
	} else if err != nil {
		logger.Println("consumer Query :", err)
		return nil, false, err
	}

	if len(payload) == 0 {
		return nil, false, nil
	}

	var auth Authorization
	if err := bson.Unmarshal([]byte(payload), &auth); err != nil {
		return nil, false, err
	}

	ttl, err := c.redisClient.TTL(c.ctx, string(sk)).Result()
	if err != nil {
		logger.Println("consumer Query :", err)
		return nil, false, err
	}

	si := &sessionRedis{
		Authorization: &auth,
		expireAt:      time.Now().Add(ttl),
	}
	c.add_internal(sk, si)

	return si, true, nil
}

func (c *consumer_redis) Query(pk string) (*Authorization, error) {
	c.lock.Lock()
	defer c.lock.Unlock()

	sk := publickey_to_storagekey(publickey(pk))
	si, _, err := c.query_internal(sk)
	if err != nil {
		return nil, err
	}

	if si == nil {
		return nil, nil
	}

	if time.Now().After(si.expireAt) {
		return nil, nil
	}

	return si.Authorization, nil
}

func (c *consumer_redis) Touch(pk string) (*Authorization, error) {
	c.lock.Lock()
	defer c.lock.Unlock()

	sk := publickey_to_storagekey(publickey(pk))
	ok, err := c.redisClient.Expire(c.ctx, string(sk), c.ttl).Result()
	if err == redis.Nil {
		return nil, nil
	} else if err != nil {
		logger.Println("consumer Touch :", err)
		return nil, err
	}

	if ok {
		// redis에 살아있다.
		si, added, err := c.query_internal(sk)
		if err != nil {
			return nil, err
		}

		if si == nil {
			return nil, nil
		}

		if !added {
			si.expireAt = time.Now().Add(c.ttl)
			// stage 0으로 옮기기 위해 add_internal을 다시 부름
			c.add_internal(sk, si)
		}

		return si.Authorization, nil
	}

	return nil, nil
}