watch-daemon_ck/util/util.go

package util

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"os"
	"time"

	"github.com/minio/minio-go/v7"
)

func DrainChannelBuffer[T any](ch <-chan T) (ok bool) {
	for {
		select {
		case _, ok = <-ch:
			if !ok {
				return
			}
		default:
			return true
		}
	}
}

func FmtMyTime(t time.Time) string {
	return t.Format("2006-01-02 15:04:05.000")
}

func FmtMyDate(t time.Time) string {
	return t.Format("2006-01-02")
}

func MinioObjectExists(minioClient *minio.Client, bucketName string, filePath string) (bool, error) {
	_, err := minioClient.StatObject(context.Background(), bucketName, filePath, minio.StatObjectOptions{})
	if err != nil {
		if minio.ToErrorResponse(err).Code == "NoSuchKey" {
			return false, nil
		}
		return false, fmt.Errorf("stat object failed: %w", err)
	}
	return true, nil
}

func MinioCreateFolderIfNotExists(minioClient *minio.Client, bucketName string, filePath string) error {
	exists, err := MinioObjectExists(minioClient, bucketName, filePath)
	if err != nil {
		return fmt.Errorf("check object exists failed: %w", err)
	}
	if exists {
		return nil
	}

	_, err = minioClient.PutObject(context.Background(), bucketName, filePath, nil, 0, minio.PutObjectOptions{})
	if err != nil {
		return fmt.Errorf("put object failed: %w", err)
	}
	return nil
}

func MinioUploadFile(minioClient *minio.Client, bucketName string, objPath string, localPath string, overwrite bool) (uploaded bool, err error) {
	if !overwrite {
		// First check if the object exists
		exists, err := MinioObjectExists(minioClient, bucketName, objPath)
		if err != nil {
			return false, fmt.Errorf("check object exists failed: %w", err)
		}
		if exists {
			return false, nil
		}
	}

	// Then upload the file
	_, err = minioClient.FPutObject(context.Background(), bucketName, objPath, localPath,
		minio.PutObjectOptions{ContentType: "application/octet-stream"})
	if err != nil {
		return false, fmt.Errorf("fput object failed: %w", err)
	}
	return true, nil
}

// Should only be used for small files
func MinioUploadFileIfChanged(minioClient *minio.Client, bucketName string, objPath string, localPath string) (uploaded bool, err error) {
	// First check if the object exists
	exists, err := MinioObjectExists(minioClient, bucketName, objPath)
	if err != nil {
		return false, fmt.Errorf("check object exists failed: %w", err)
	}

	// Then check if the file has changed by comparing the content
	if exists {
		isUnchanged, err := func() (bool, error) {
			// Get the object
			obj, err := minioClient.GetObject(context.Background(), bucketName, objPath, minio.GetObjectOptions{})
			if err != nil {
				return false, fmt.Errorf("get object failed: %w", err)
			}
			defer obj.Close()

			// Compare the content (io.ReadAll)
			localFile, err := os.Open(localPath)
			if err != nil {
				return false, fmt.Errorf("open local file failed: %w", err)
			}
			defer localFile.Close()

			objContent, err := io.ReadAll(obj)
			if err != nil {
				return false, fmt.Errorf("read object content failed: %w", err)
			}

			localContent, err := io.ReadAll(localFile)
			if err != nil {
				return false, fmt.Errorf("read local content failed: %w", err)
			}

			if bytes.Equal(objContent, localContent) {
				return true, nil
			}

			return false, nil
		}()
		if err != nil {
			return false, err
		}
		if isUnchanged {
			return false, nil
		}
	}

	// Then upload the file
	_, err = minioClient.FPutObject(context.Background(), bucketName, objPath, localPath,
		minio.PutObjectOptions{ContentType: "application/octet-stream"})
	if err != nil {
		return false, fmt.Errorf("fput object failed: %w", err)
	}
	return true, nil
}