xps-server-go/three_party/minio.go

package three_party

import (
    "context"
    "errors"
    "fmt"
    "github.com/minio/minio-go/v7"
    "github.com/minio/minio-go/v7/pkg/credentials"
    "log"
    "path"
    "sync"
)

var defaultFileBucket = "file"
var defaultIconBucket = "icon"
var defaultLocation   = "us-east-1"
var minioServerPool *sync.Pool

var defaultConfig = &MinioConfig{
    EndPoint: "http://114.116.19.14:9000",
    AccessKey: "root",
    SecretKey: "Houyaf1!",
    UseSSL: false,
}

// client version and secret, it should be from client side
const (
    UploadDir    string = "./public/upload/"
    UrlBase      string = "/upload/"
)

// DestFile 文件
type DestFile struct {
    FileName     string
    FileUrl      string
    FileSize     int64
    FileExt      string
    FileMimeType string
}

func init() {
    minioServerPool = &sync.Pool{
        New: func() interface{}{
            return &MinioServe{}
        },
    }
}

type MinioFileObject struct {
    ObjectName  string
    FilePath    string
    ContentType string
}

type MinioConfig struct {
    EndPoint   string `json:"endPoint"`
    AccessKey  string `json:"accessKey"`
    SecretKey  string `json:"secretKey"`
    UseSSL     bool   `json:"useSSL"`
}



func (c *MinioConfig) Validate() error {
    if c.EndPoint == "" {
        return errors.New("EndPoint host not specified")
    }
    
    if c.AccessKey == "" {
        return errors.New("minio access key is not specified")
    }
    
    if c.SecretKey == "" {
        return errors.New("minio secret key is not specified")
    }
    return nil
}

func (c *MinioConfig) GetClient()(*minio.Client, error) {
    if err := c.Validate(); err != nil {
        return nil, err
    }
    
    minioClient, err := minio.New(
        c.EndPoint,
        &minio.Options{
            Creds: credentials.NewStaticV4(c.AccessKey, c.SecretKey, ""),
            Secure: c.UseSSL,
        })
    
    if err != nil {
        log.Fatalf("connect minio server fail %s url %s", err.Error(), c.EndPoint)
    }
    return minioClient, nil
}

type MinioServerOption func(*MinioServe)
type MinioServe struct {
    Client *minio.Client
}

func NewMinioServer(opts ...MinioServerOption)(*MinioServe, error){
    m := &MinioServe{}
    for _, opt := range opts {
        opt(m)
    }
    
    return m, nil
}

func (m *MinioServe) Reset() {
    m.Client = nil
}

func (m *MinioServe) checkBucket(ctx context.Context, bucketName string) bool {
    isExist, err1 := m.Client.BucketExists(ctx, bucketName)
    if err1 != nil {
        log.Fatalf("checkBucket error " + err1.Error())
        return false
    }
    
    if !isExist {
        err2 := m.Client.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{Region: defaultLocation})
        if err2 != nil {
            log.Fatalf("checkBucket error " + err2.Error())
            return false
        }
    }
    return true
}

func (m *MinioServe) CheckBuckets(ctx context.Context) bool {
    b1 := m.checkBucket(ctx, defaultFileBucket)
    b2 := m.checkBucket(ctx, defaultIconBucket)
    return b1&&b2
}

func (m *MinioServe) UploadFile(objectName, filePath string)(*DestFile, error) {
    ctx := context.Background()
    bBucketExist := m.CheckBuckets(ctx)
    if !bBucketExist {
        return nil , errors.New("Bucket不存在")
    }
    
    contentType := "application/octet-stream"
    uinfo, err := m.Client.FPutObject(ctx, defaultFileBucket, objectName, filePath, minio.PutObjectOptions{
        ContentType: contentType,
    })
    
    if err != nil {
        return nil, err
    }
    
    fileExt := path.Ext(objectName)
    
    url := fmt.Sprintf("%s/%s/%s", defaultConfig.EndPoint, defaultFileBucket, objectName)
    targetFile := &DestFile{
        FileName:     objectName,
        FileUrl:      url,
        FileSize:     uinfo.Size,
        FileExt:      fileExt,
        FileMimeType: "",
    }
    
    return targetFile, nil
}


func acquireMinioServer() *MinioServe {
    return minioServerPool.Get().(*MinioServe)
}

func releaseMinioServer(m *MinioServe) {
    m.Reset()
    minioServerPool.Put(m)
}


func UploadFile(fileName, filePath string) (*DestFile,error){
    m := acquireMinioServer()
    
    client, err := defaultConfig.GetClient()
    if err != nil {
        return nil, err
    }
    defer func() {
        releaseMinioServer(m)
    }()
    m.Client = client
    objName := ""
    return m.UploadFile(objName, filePath)
}