Method Get

cache/redis_cache.go:97–143

(key *Key)

}

func (r *redisCache) Get(key *Key) (*CachedData, error) {
	ctx, cancelFunc := context.WithTimeout(context.Background(), getTimeout)
	defer cancelFunc()
	nbBytesToFetch := int64(100 * 1024)
	stringKey := key.String()
	// fetching 100kBytes from redis to be sure to have the full metadata and,
	//  for most of the queries that fetch a few data, the cached results
	val, err := r.client.GetRange(ctx, stringKey, 0, nbBytesToFetch).Result()

	// errors, such as timeouts
	if err != nil {
		log.Errorf("failed to get key %s with error: %s", stringKey, err)
		return nil, ErrMissing
	}
	// if key not found in cache
	if len(val) == 0 {
		return nil, ErrMissing
	}

	ttl, err := r.client.TTL(ctx, stringKey).Result()
	if err != nil {
		return nil, fmt.Errorf("failed to ttl of key %s with error: %w", stringKey, err)
	}
	b := []byte(val)
	metadata, offset, err := r.decodeMetadata(b)
	if err != nil {
		if errors.Is(err, &RedisCacheCorruptionError{}) {
			log.Errorf("an error happened while handling redis key =%s, err=%s", stringKey, err)
		}
		return nil, err
	}
	if (int64(offset) + metadata.Length) < nbBytesToFetch {
		// the condition is true ony if the bytes fetched contain the metadata + the cached results
		// so we extract from the remaining bytes the cached results
		payload := b[offset:]
		reader := &ioReaderDecorator{Reader: bytes.NewReader(payload)}
		value := &CachedData{
			ContentMetadata: *metadata,
			Data:            reader,
			Ttl:             ttl,
		}

		return value, nil
	}

	return r.readResultsAboveLimit(offset, stringKey, metadata, ttl)
}

func (r *redisCache) readResultsAboveLimit(offset int, stringKey string, metadata *ContentMetadata, ttl time.Duration) (*CachedData, error) {
	// since the cached results in redis are too big, we can't fetch all of them because of the memory overhead.