xps-server-g5/cmd/file_server/minio_client.go

package file_server

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

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 nil, err
    }
    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"
    info, 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("http://%s/%s/%s", defaultConfig.EndPoint, defaultFileBucket, objectName)
    targetFile := &DestFile{
        FileName:     objectName,
        FileUrl:      url,
        FileSize:     info.Size,
        FileExt:      fileExt,
        FileMimeType: "",
    }

    return targetFile, nil
}