Files
mtusi2026lab5/app/internal/objectstore/memory.go
T

118 lines
2.8 KiB
Go

package objectstore
import (
"bytes"
"context"
"fmt"
"io"
"strings"
"sync"
"sync/atomic"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/domain"
)
// Memory — хранилище для модульных тестов. В работающем приложении не используется.
type Memory struct {
mu sync.Mutex
objects map[string][]byte
modified map[string]time.Time
// Down имитирует недоступность S3.
Down atomic.Bool
}
var (
_ Store = (*Memory)(nil)
_ Lister = (*Memory)(nil)
)
func NewMemory() *Memory {
return &Memory{objects: make(map[string][]byte), modified: make(map[string]time.Time)}
}
func (m *Memory) check() error {
if m.Down.Load() {
return fmt.Errorf("%w: s3 down", domain.ErrUnavailable)
}
return nil
}
func (m *Memory) Put(_ context.Context, key, _ string, body io.Reader, size int64) error {
if err := m.check(); err != nil {
return err
}
data, err := io.ReadAll(body)
if err != nil {
return fmt.Errorf("%w: s3 put: %v", domain.ErrUnavailable, err)
}
if int64(len(data)) != size {
return fmt.Errorf("%w: s3 put: got %d of %d bytes", domain.ErrUnavailable, len(data), size)
}
m.PutAt(key, data, time.Now())
return nil
}
// PutAt кладёт объект с заданным временем: так тест получает объект нужного возраста.
func (m *Memory) PutAt(key string, data []byte, at time.Time) {
m.mu.Lock()
defer m.mu.Unlock()
m.objects[key] = bytes.Clone(data)
m.modified[key] = at
}
func (m *Memory) List(_ context.Context, prefix string, visit func(ObjectInfo) error) error {
if err := m.check(); err != nil {
return err
}
m.mu.Lock()
infos := make([]ObjectInfo, 0, len(m.objects))
for key := range m.objects {
if strings.HasPrefix(key, prefix) {
infos = append(infos, ObjectInfo{Key: key, LastModified: m.modified[key]})
}
}
m.mu.Unlock()
for _, info := range infos {
if err := visit(info); err != nil {
return err
}
}
return nil
}
func (m *Memory) Get(_ context.Context, key string) (io.ReadCloser, int64, error) {
if err := m.check(); err != nil {
return nil, 0, err
}
m.mu.Lock()
defer m.mu.Unlock()
data, ok := m.objects[key]
if !ok {
return nil, 0, ErrNotFound
}
return io.NopCloser(bytes.NewReader(data)), int64(len(data)), nil
}
func (m *Memory) Delete(_ context.Context, key string) error {
if err := m.check(); err != nil {
return err
}
m.mu.Lock()
defer m.mu.Unlock()
delete(m.objects, key)
delete(m.modified, key)
return nil
}
// Keys возвращает ключи объектов для проверок в тестах.
func (m *Memory) Keys() []string {
m.mu.Lock()
defer m.mu.Unlock()
out := make([]string, 0, len(m.objects))
for k := range m.objects {
out = append(out, k)
}
return out
}