main.go

package main

import (
	"context"
	"fmt"
	"io"
	"log"
	"os"

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

func main() {
	endpoint := "localhost:9000"
	accessKeyID := "minioadmin"
	secretAccessKey := "minioadmin"
	useSSL := false
	//Intilising a new Minio Client
	minioClient, err := minio.New(endpoint, &minio.Options{
		Creds:  credentials.NewStaticV4(accessKeyID, secretAccessKey, ""),
		Secure: useSSL,
	})
	if err != nil {
		log.Println("error while creating a new minio client: ", err)
		return
	}

	log.Printf("%#v\n", minioClient)
}

func CreateBucket(minioClient *minio.Client) error {
	// Create a bucket at region 'us-east-1' with object locking enabled.
	err := minioClient.MakeBucket(context.Background(), "mybucket", minio.MakeBucketOptions{Region: "us-east-1", ObjectLocking: false})
	if err != nil {
		fmt.Println("error while creating a bucket: ", err)
		return err
	}
	fmt.Println("Successfully created mybucket.")
	return nil
}

func CreateBucketWithCheck(minioClient *minio.Client) error {
	bucketName := "test-bucket"
	location := "us-east-1"
	err := minioClient.MakeBucket(context.Background(), bucketName, minio.MakeBucketOptions{Region: location})
	if err != nil {
		exists, errBucketExists := minioClient.BucketExists(context.Background(), bucketName)
		if errBucketExists == nil && exists {
			fmt.Println("Bucket already exists")
		} else {
			log.Println("error while checking if the bucket exists: ", err)
			return err
		}
	}
	fmt.Println("Bucket created successfully!")
	return nil
}

func PutObject(minioClient *minio.Client, filepath string) error {
	file, err := os.Open(filepath)
	if err != nil {
		fmt.Println(err)
		return err
	}
	defer file.Close()

	fileStat, err := file.Stat()
	if err != nil {
		fmt.Println(err)
		return err
	}

	uploadInfo, err := minioClient.PutObject(context.Background(), "mybucket-1", "myobject", file, fileStat.Size(), minio.PutObjectOptions{ContentType: "application/octet-stream"})
	if err != nil {
		fmt.Println(err)
		return err
	}
	fmt.Println("Successfully uploaded bytes: ", uploadInfo)
	return nil
}

func GetObject(minioClient *minio.Client, bucketName string, objectName string) (err error) {
	object, err := minioClient.GetObject(context.Background(), bucketName, objectName, minio.GetObjectOptions{})
	if err != nil {
		log.Println("error while fetching the object "+objectName+" from the bucket "+bucketName+" :", err)
		return err
	}
	defer object.Close()

	localFile, err := os.Create("/tmp/local-file.txt") // Here considering we have a text file
	if err != nil {
		fmt.Println("error while creating the local file to add the data: ", err)
		return err
	}
	defer localFile.Close()

	if _, err = io.Copy(localFile, object); err != nil {
		fmt.Println("error while copying the objectdetails on the localfile: ", err)
		return err
	}
	fmt.Println("File downloaded successfully!")
	return nil
}

func ListObjects(minioClient *minio.Client, bucketName string) error {
	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	objectCh := minioClient.ListObjects(ctx, bucketName, minio.ListObjectsOptions{
		Prefix:    "myprefix",
		Recursive: true,
	})
	for object := range objectCh {
		if object.Err != nil {
			fmt.Println("error while streaming the response from the object: ", object.Err)
			return object.Err
		}
		fmt.Println(object)
	}
	return nil
}