msb-public
/
Open-IM-Server
mirror of https://github.com/OpenIMSDK/Open-IM-Server
2
0
Code Issues Projects Releases Wiki Activity

restore mini code

Browse Source
pull/1273/head
withchao 2 years ago
parent cd99922b8c
commit 2516964c4c
1 changed files with 50 additions and 112 deletions
Show Stats Download Patch File Download Diff File

162
pkg/common/db/s3/minio/minio.go
Unescape View File

@ -111,7 +111,6 @@ func NewMinio() (s3.Interface, error) {
if err := m.initMinio(ctx); err != nil { if err := m.initMinio(ctx); err != nil {
fmt.Println("init minio error:", err) fmt.Println("init minio error:", err)
} }
return m, nil return m, nil
} }
@ -142,9 +141,8 @@ func (m *Minio) initMinio(ctx context.Context) error {
return fmt.Errorf("check bucket exists error: %w", err) return fmt.Errorf("check bucket exists error: %w", err)
} }
if !exists { if !exists {
err2 := m.core.Client.MakeBucket(ctx, conf.Bucket, minio.MakeBucketOptions{}) if err := m.core.Client.MakeBucket(ctx, conf.Bucket, minio.MakeBucketOptions{}); err != nil {
if err2 != nil { return fmt.Errorf("make bucket error: %w", err)
return fmt.Errorf("make bucket error: %w", err2)
} }
} }
if conf.PublicRead { if conf.PublicRead {
@ -152,9 +150,8 @@ func (m *Minio) initMinio(ctx context.Context) error {
`{"Version": "2012-10-17","Statement": [{"Action": ["s3:GetObject","s3:PutObject"],"Effect": "Allow","Principal": {"AWS": ["*"]},"Resource": ["arn:aws:s3:::%s/*"],"Sid": ""}]}`, `{"Version": "2012-10-17","Statement": [{"Action": ["s3:GetObject","s3:PutObject"],"Effect": "Allow","Principal": {"AWS": ["*"]},"Resource": ["arn:aws:s3:::%s/*"],"Sid": ""}]}`,
conf.Bucket, conf.Bucket,
) )
err2 := m.core.Client.SetBucketPolicy(ctx, conf.Bucket, policy) if err := m.core.Client.SetBucketPolicy(ctx, conf.Bucket, policy); err != nil {
if err2 != nil { return err
return err2
} }
} }
m.location, err = m.core.Client.GetBucketLocation(ctx, conf.Bucket) m.location, err = m.core.Client.GetBucketLocation(ctx, conf.Bucket)
@ -194,6 +191,7 @@ func (m *Minio) Engine() string {
} }
func (m *Minio) PartLimit() *s3.PartLimit { func (m *Minio) PartLimit() *s3.PartLimit {
return &s3.PartLimit{ return &s3.PartLimit{
MinPartSize: minPartSize, MinPartSize: minPartSize,
MaxPartSize: maxPartSize, MaxPartSize: maxPartSize,
@ -358,16 +356,14 @@ func (m *Minio) IsNotFound(err error) bool {
if err == nil { if err == nil {
return false return false
} }
var minioErr minio.ErrorResponse switch e := err.(type) {
if errors.As(err, &minio.ErrorResponse{}) { case minio.ErrorResponse:
return minioErr.StatusCode == http.StatusNotFound || minioErr.Code == "NoSuchKey" return e.StatusCode == http.StatusNotFound || e.Code == "NoSuchKey"
} case *minio.ErrorResponse:
var minioErr2 *minio.ErrorResponse return e.StatusCode == http.StatusNotFound || e.Code == "NoSuchKey"
if errors.As(err, &minioErr2) { default:
return minioErr2.StatusCode == http.StatusNotFound || minioErr2.Code == "NoSuchKey" return false
} }
return false
} }
func (m *Minio) AbortMultipartUpload(ctx context.Context, uploadID string, name string) error { func (m *Minio) AbortMultipartUpload(ctx context.Context, uploadID string, name string) error {
@ -430,13 +426,11 @@ func (m *Minio) presignedGetObject(ctx context.Context, name string, expire time
return rawURL.String(), nil return rawURL.String(), nil
} }
func (m *Minio) getImageInfoForAccessURL( func (m *Minio) AccessURL(ctx context.Context, name string, expire time.Duration, opt *s3.AccessURLOption) (string, error) {
ctx context.Context, if err := m.initMinio(ctx); err != nil {
name string, return "", err
expire time.Duration, }
opt *s3.AccessURLOption, reqParams := make(url.Values)
reqParams url.Values,
) (fileInfo *s3.ObjectInfo, objectInfoPath, msg string, err error) {
if opt != nil { if opt != nil {
if opt.ContentType != "" { if opt.ContentType != "" {
reqParams.Set("response-content-type", opt.ContentType) reqParams.Set("response-content-type", opt.ContentType)
@ -446,47 +440,35 @@ func (m *Minio) getImageInfoForAccessURL(
} }
} }
if opt.Image == nil || (opt.Image.Width < 0 && opt.Image.Height < 0 && opt.Image.Format == "") || (opt.Image.Width > maxImageWidth || opt.Image.Height > maxImageHeight) { if opt.Image == nil || (opt.Image.Width < 0 && opt.Image.Height < 0 && opt.Image.Format == "") || (opt.Image.Width > maxImageWidth || opt.Image.Height > maxImageHeight) {
msg, err = m.presignedGetObject(ctx, name, expire, reqParams) return m.presignedGetObject(ctx, name, expire, reqParams)
return nil, "", msg, err
} }
fileInfo, err = m.StatObject(ctx, name) fileInfo, err := m.StatObject(ctx, name)
objectInfoPath = path.Join(pathInfo, fileInfo.ETag, "image.json")
if err != nil { if err != nil {
return nil, "", msg, err return "", err
} }
if fileInfo.Size > maxImageSize { if fileInfo.Size > maxImageSize {
return nil, "", "", errors.New("file size too large") return "", errors.New("file size too large")
} }
objectInfoPath := path.Join(pathInfo, fileInfo.ETag, "image.json")
return fileInfo, objectInfoPath, "", nil var (
} img image.Image
info minioImageInfo
func (m *Minio) loadImgDataForAccessURL(objectInfoPath string, ctx context.Context, name string, info *minioImageInfo) (img image.Image, msg string, err error) { )
var data []byte data, err := m.getObjectData(ctx, objectInfoPath, 1024)
data, err = m.getObjectData(ctx, objectInfoPath, 1024)
//nolint:nestif //easy enough to understand
if err == nil { if err == nil {
err = json.Unmarshal(data, &info) if err := json.Unmarshal(data, &info); err != nil {
if err != nil { return "", fmt.Errorf("unmarshal minio image info.json error: %w", err)
return nil, "", fmt.Errorf("unmarshal minio image info.json error: %w", err)
} }
if info.NotImage { if info.NotImage {
return nil, "", errors.New("not image") return "", errors.New("not image")
} }
} else if m.IsNotFound(err) { } else if m.IsNotFound(err) {
var reader *minio.Object reader, err := m.core.Client.GetObject(ctx, m.bucket, name, minio.GetObjectOptions{})
reader, err = m.core.Client.GetObject(ctx, m.bucket, name, minio.GetObjectOptions{})
if err != nil { if err != nil {
return img, msg, err return "", err
} }
defer reader.Close() defer reader.Close()
var ( imageInfo, format, err := ImageStat(reader)
imageInfo image.Image
format string
)
imageInfo, format, err = ImageStat(reader)
if err == nil { if err == nil {
info.NotImage = false info.NotImage = false
info.Format = format info.Format = format
@ -495,22 +477,16 @@ func (m *Minio) loadImgDataForAccessURL(objectInfoPath string, ctx context.Conte
} else { } else {
info.NotImage = true info.NotImage = true
} }
data, err := json.Marshal(&info)
data, err = json.Marshal(&info)
if err != nil { if err != nil {
return img, msg, err return "", err
} }
if _, err := m.core.Client.PutObject(ctx, m.bucket, objectInfoPath, bytes.NewReader(data), int64(len(data)), minio.PutObjectOptions{}); err != nil {
_, err = m.core.Client.PutObject(ctx, m.bucket, objectInfoPath, bytes.NewReader(data), int64(len(data)), minio.PutObjectOptions{}) return "", err
if err != nil {
return img, msg, err
} }
} else {
return "", err
} }
return img, msg, err
}
func (m *Minio) formatImgInfoForAccessURL(opt *s3.AccessURLOption, info *minioImageInfo, reqParams url.Values) {
if opt.Image.Width > info.Width || opt.Image.Width <= 0 { if opt.Image.Width > info.Width || opt.Image.Width <= 0 {
opt.Image.Width = info.Width opt.Image.Width = info.Width
} }
@ -533,24 +509,24 @@ func (m *Minio) formatImgInfoForAccessURL(opt *s3.AccessURLOption, info *minioIm
} }
} }
reqParams.Set("response-content-type", "image/"+opt.Image.Format) reqParams.Set("response-content-type", "image/"+opt.Image.Format)
} if opt.Image.Width == info.Width && opt.Image.Height == info.Height && opt.Image.Format == info.Format {
return m.presignedGetObject(ctx, name, expire, reqParams)
func (m *Minio) cacheImgInfoForAccessURL(ctx context.Context, name, cacheKey string, img image.Image, expire time.Duration, opt *s3.AccessURLOption, reqParams url.Values) (string, error) { }
_, err := m.core.Client.StatObject(ctx, m.bucket, cacheKey, minio.StatObjectOptions{}) cacheKey := filepath.Join(pathInfo, fileInfo.ETag, fmt.Sprintf("image_w%d_h%d.%s", opt.Image.Width, opt.Image.Height, opt.Image.Format))
if err == nil { if _, err := m.core.Client.StatObject(ctx, m.bucket, cacheKey, minio.StatObjectOptions{}); err == nil {
return m.presignedGetObject(ctx, cacheKey, expire, reqParams) return m.presignedGetObject(ctx, cacheKey, expire, reqParams)
} else if !m.IsNotFound(err) { } else if !m.IsNotFound(err) {
return "", err return "", err
} }
if img == nil { if img == nil {
reader, err2 := m.core.Client.GetObject(ctx, m.bucket, name, minio.GetObjectOptions{}) reader, err := m.core.Client.GetObject(ctx, m.bucket, name, minio.GetObjectOptions{})
if err2 != nil { if err != nil {
return "", err2 return "", err
} }
defer reader.Close() defer reader.Close()
img, _, err2 = ImageStat(reader) img, _, err = ImageStat(reader)
if err2 != nil { if err != nil {
return "", err2 return "", err
} }
} }
thumbnail := resizeImage(img, opt.Image.Width, opt.Image.Height) thumbnail := resizeImage(img, opt.Image.Width, opt.Image.Height)
@ -563,48 +539,10 @@ func (m *Minio) cacheImgInfoForAccessURL(ctx context.Context, name, cacheKey str
case formatGif: case formatGif:
err = gif.Encode(buf, thumbnail, nil) err = gif.Encode(buf, thumbnail, nil)
} }
if err != nil {
return "", err
}
if _, err := m.core.Client.PutObject(ctx, m.bucket, cacheKey, buf, int64(buf.Len()), minio.PutObjectOptions{}); err != nil { if _, err := m.core.Client.PutObject(ctx, m.bucket, cacheKey, buf, int64(buf.Len()), minio.PutObjectOptions{}); err != nil {
return "", err return "", err
} }
return "", nil
}
func (m *Minio) AccessURL(ctx context.Context, name string, expire time.Duration, opt *s3.AccessURLOption) (string, error) {
errInit := m.initMinio(ctx)
if errInit != nil {
return "", errInit
}
reqParams := make(url.Values)
fileInfo, objectInfoPath, msg, err := m.getImageInfoForAccessURL(ctx, name, expire, opt, reqParams)
if err != nil {
return msg, err
}
// load-cache img data
var (
img image.Image
info minioImageInfo
)
img, msg, err = m.loadImgDataForAccessURL(objectInfoPath, ctx, name, &info)
if err != nil {
return msg, err
}
// format img info
m.formatImgInfoForAccessURL(opt, &info, reqParams)
// no need resize
if opt.Image.Width == info.Width && opt.Image.Height == info.Height && opt.Image.Format == info.Format {
return m.presignedGetObject(ctx, name, expire, reqParams)
}
// cache img
cacheKey := filepath.Join(pathInfo, fileInfo.ETag, fmt.Sprintf("image_w%d_h%d.%s", opt.Image.Width, opt.Image.Height, opt.Image.Format))
msg, err = m.cacheImgInfoForAccessURL(ctx, name, cacheKey, img, expire, opt, reqParams)
if err != nil {
return msg, err
}
// return cache img
return m.presignedGetObject(ctx, cacheKey, expire, reqParams) return m.presignedGetObject(ctx, cacheKey, expire, reqParams)
} }

Write Preview
Loading…
Cancel
Save