Files
mtusi2026lab5/internal/s3/client.go
T

296 lines
7.0 KiB
Go

package s3
import (
"context"
"errors"
"io"
"log/slog"
"net"
"net/http"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
awsconfig "github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/credentials"
awss3 "github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/smithy-go"
appconfig "mtusi2026-messenger/internal/config"
)
var (
ErrUnavailable = errors.New("s3 unavailable")
ErrLoadConfig = errors.New("load aws config")
ErrHeadBucket = errors.New("head bucket")
ErrCreateBucket = errors.New("create bucket")
ErrObjectNotFound = errors.New("object not found")
ErrPutObject = errors.New("put object")
ErrGetObject = errors.New("get object")
ErrListObjects = errors.New("list objects")
ErrDeleteObject = errors.New("delete object")
)
type Client struct {
bucket string
bootstrap *awss3.Client
api *awss3.Client
log *slog.Logger
}
type ObjectInfo struct {
Key string
Size int64
LastModified time.Time
}
type ListResult struct {
Objects []ObjectInfo
Pages int
}
func New(ctx context.Context, cfg appconfig.S3Config, log *slog.Logger) (*Client, error) {
c, err := NewAPI(ctx, cfg, log)
if err != nil {
return nil, err
}
bootstrapAccessKey, err := cfg.BootstrapAccessKey()
if err != nil {
log.Error("read s3 bootstrap access key", "error", err)
return nil, err
}
bootstrapSecretKey, err := cfg.BootstrapSecretKey()
if err != nil {
log.Error("read s3 bootstrap secret key", "error", err)
return nil, err
}
c.bootstrap, err = newS3Client(ctx, log, cfg.Endpoint, cfg.Region, bootstrapAccessKey, bootstrapSecretKey)
if err != nil {
return nil, err
}
return c, nil
}
func NewAPI(ctx context.Context, cfg appconfig.S3Config, log *slog.Logger) (*Client, error) {
apiAccessKey, err := cfg.APIAccessKey()
if err != nil {
log.Error("read s3 api access key", "error", err)
return nil, err
}
apiSecretKey, err := cfg.APISecretKey()
if err != nil {
log.Error("read s3 api secret key", "error", err)
return nil, err
}
api, err := newS3Client(ctx, log, cfg.Endpoint, cfg.Region, apiAccessKey, apiSecretKey)
if err != nil {
return nil, err
}
return &Client{
bucket: cfg.Bucket,
api: api,
log: log,
}, nil
}
func (c *Client) Bucket() string {
return c.bucket
}
func (c *Client) EnsureBucket(ctx context.Context) error {
_, err := c.bootstrap.HeadBucket(ctx, &awss3.HeadBucketInput{
Bucket: aws.String(c.bucket),
})
if err == nil {
return nil
}
if !isNotFound(err) {
c.log.Error("head bucket", "bucket", c.bucket, "error", err)
return ErrHeadBucket
}
_, err = c.bootstrap.CreateBucket(ctx, &awss3.CreateBucketInput{
Bucket: aws.String(c.bucket),
})
if err == nil || isAlreadyExists(err) {
return nil
}
c.log.Error("create bucket", "bucket", c.bucket, "error", err)
return ErrCreateBucket
}
func (c *Client) Ping(ctx context.Context) error {
_, err := c.api.HeadBucket(ctx, &awss3.HeadBucketInput{Bucket: aws.String(c.bucket)})
if err != nil {
c.log.Error("head bucket", "bucket", c.bucket, "error", err)
return operationError(ErrHeadBucket, err)
}
return nil
}
func (c *Client) Put(
ctx context.Context,
key string,
body io.ReadSeeker,
size int64,
contentType string,
) error {
_, err := c.api.PutObject(ctx, &awss3.PutObjectInput{
Bucket: aws.String(c.bucket),
Key: aws.String(key),
Body: body,
ContentLength: aws.Int64(size),
ContentType: aws.String(contentType),
})
if err != nil {
c.log.Error("put object", "bucket", c.bucket, "key", key, "error", err)
return operationError(ErrPutObject, err)
}
return nil
}
func (c *Client) Get(ctx context.Context, key string) (*awss3.GetObjectOutput, error) {
out, err := c.api.GetObject(ctx, &awss3.GetObjectInput{
Bucket: aws.String(c.bucket),
Key: aws.String(key),
})
if isNotFound(err) {
c.log.Warn("get object", "bucket", c.bucket, "key", key, "error", err)
return nil, ErrObjectNotFound
}
if err != nil {
c.log.Error("get object", "bucket", c.bucket, "key", key, "error", err)
return nil, operationError(ErrGetObject, err)
}
return out, nil
}
func (c *Client) ListAll(ctx context.Context, prefix string) (ListResult, error) {
result := ListResult{Objects: []ObjectInfo{}}
paginator := awss3.NewListObjectsV2Paginator(c.bootstrap, &awss3.ListObjectsV2Input{
Bucket: aws.String(c.bucket),
Prefix: aws.String(prefix),
})
for paginator.HasMorePages() {
page, err := paginator.NextPage(ctx)
if err != nil {
c.log.Error("list objects", "bucket", c.bucket, "prefix", prefix, "error", err)
return ListResult{}, ErrListObjects
}
result.Pages++
for _, obj := range page.Contents {
result.Objects = append(result.Objects, ObjectInfo{
Key: aws.ToString(obj.Key),
Size: aws.ToInt64(obj.Size),
LastModified: aws.ToTime(obj.LastModified),
})
}
}
return result, nil
}
func (c *Client) DeleteAdmin(ctx context.Context, key string) error {
return c.deleteObject(ctx, c.bootstrap, key)
}
func (c *Client) Delete(ctx context.Context, key string) error {
return c.deleteObject(ctx, c.api, key)
}
func (c *Client) deleteObject(ctx context.Context, client *awss3.Client, key string) error {
_, err := client.DeleteObject(ctx, &awss3.DeleteObjectInput{
Bucket: aws.String(c.bucket),
Key: aws.String(key),
})
if isNotFound(err) {
return nil
}
if err != nil {
c.log.Error("delete object", "bucket", c.bucket, "key", key, "error", err)
return ErrDeleteObject
}
return nil
}
func newS3Client(
ctx context.Context,
log *slog.Logger,
endpoint string,
region string,
accessKey string,
secretKey string,
) (*awss3.Client, error) {
cfg, err := awsconfig.LoadDefaultConfig(
ctx,
awsconfig.WithRegion(region),
awsconfig.WithCredentialsProvider(
credentials.NewStaticCredentialsProvider(accessKey, secretKey, ""),
),
)
if err != nil {
log.Error("load aws config", "endpoint", endpoint, "region", region, "error", err)
return nil, ErrLoadConfig
}
return awss3.NewFromConfig(cfg, func(o *awss3.Options) {
o.BaseEndpoint = aws.String(endpoint)
o.UsePathStyle = true
}), nil
}
func operationError(operation, err error) error {
var networkError net.Error
var responseError *awshttp.ResponseError
if errors.Is(err, context.DeadlineExceeded) || errors.As(err, &networkError) ||
(errors.As(err, &responseError) && responseError.HTTPStatusCode() >= 500) {
return ErrUnavailable
}
return operation
}
func isNotFound(err error) bool {
var responseErr *awshttp.ResponseError
if errors.As(err, &responseErr) && responseErr.HTTPStatusCode() == http.StatusNotFound {
return true
}
var apiErr smithy.APIError
if errors.As(err, &apiErr) {
switch apiErr.ErrorCode() {
case "NotFound", "NoSuchBucket", "NoSuchKey":
return true
}
}
return false
}
func isAlreadyExists(err error) bool {
var apiErr smithy.APIError
if errors.As(err, &apiErr) {
switch apiErr.ErrorCode() {
case "BucketAlreadyOwnedByYou", "BucketAlreadyExists":
return true
}
}
return false
}