forked from mtusi2026/mtusi2026lab5
118 lines
2.8 KiB
Go
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
|
|
}
|