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

package file_server

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

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

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

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

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

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

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"
	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
}

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

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

func UploadFileToMinio(fileName, filePath string) (*DestFile, error) {
	m := acquireMinioServer()

	client, err := defaultConfig.getClient()
	if err != nil {
		return nil, err
	}
	defer func() {
		releaseMinioServer(m)
	}()
	m.Client = client
	return m.uploadFile(fileName, filePath)
}