Scealway upload to s3

uplaod.go

package main

import (
        "bytes"
        "io"
        "io/ioutil"
        // "net/http"
        "os"
        "io/fs"
        "path/filepath"
        "github.com/remeh/sizedwaitgroup"
        "github.com/aws/aws-sdk-go/aws"
        "github.com/aws/aws-sdk-go/aws/session"
        "github.com/aws/aws-sdk-go/service/s3"
        "github.com/aws/aws-sdk-go/aws/credentials"
        log "github.com/hiyali/logli"
)

const (
        S3_REGION = "fr-PAR"
        S3_BUCKET = "BUCKET_NAME"
        S3_ACL    = "public-read"
        S3_ENDPOINT = "https://BUCKET_NAME.s3.fr-par.scw.cloud"
        AwsAccessKey= ""
        AwsSecretKey=""
)

type S3Handler struct {
        Session *session.Session
        Bucket  string
}

func main() {
        swg := sizedwaitgroup.New(5)
        if len(os.Args) != 3 {
                log.FatalF("usage: %s <filename> <s3-filepath>\n", filepath.Base(os.Args[0]))
        }

        filename := os.Args[1]
        key := os.Args[2]

        fileInfo, err := os.Stat(filename)
        if err != nil {
                                log.FatalF("Not file or directory readable, err: %v", err)
        }

        if fileInfo.IsDir() {
                files, err := ioutil.ReadDir(filename)
                if err != nil {
                        log.FatalF("Directory not readable, err: %v", err)
                }
                for _, file := range files {
                        swg.Add()
                        go func(file fs.FileInfo) {
                        defer swg.Done()
                                if(!file.IsDir()){
                                        fileGet(filename+"/"+file.Name() , key+"/"+file.Name())
                                }
                        }(file)
                }
                swg.Wait()
        } else {
                fileGet(filename , key)
        }

}


func fileGet(filename string, key string){
        file, err := os.Open(filename)
        if err != nil {
                log.FatalF("os.Open - filename: %v, err: %v", filename, err)
        }
        defer file.Close()
  sess := session.Must(session.NewSession(&aws.Config{
    Region:   aws.String("fr-par"),
    Endpoint: aws.String("https://s3.fr-par.scw.cloud"),
    Credentials: credentials.NewStaticCredentials(AwsAccessKey, AwsSecretKey, ""),
  }))

        if err != nil {
                log.FatalF("session.NewSession - filename: %v, err: %v", filename, err)
        }
        handler := S3Handler{
                Session: sess,
                Bucket:  S3_BUCKET,
        }

        err = handler.UploadFile(key, filename)
        if err != nil {
                log.FatalF("UploadFile - filename: %v, err: %v", filename, err)
        }
        log.Info("UploadFile - success")
}


func (h S3Handler) UploadFile(key string, filename string) error {
        file, err := os.Open(filename)
        if err != nil {
                log.FatalF("os.Open - filename: %s, err: %v", filename, err)
        }
        defer file.Close()


        // buffer := []byte(body)

        _, err = s3.New(h.Session).PutObject(&s3.PutObjectInput{
                Bucket:             aws.String(h.Bucket),
                Key:                aws.String(key),
                ACL:                aws.String(S3_ACL),
                Body:               file, // bytes.NewReader(buffer),
                ContentDisposition: aws.String("attachment"),
                // ContentLength:      aws.Int64(int64(len(buffer))),
                // ContentType:        aws.String(http.DetectContentType(buffer)),
                // ServerSideEncryption: aws.String("AES256"),
        })

        // log.DebugF("s3.New - res: %v", res)
        return err
}



func (h S3Handler) ReadFile(key string) (string, error) {
        results, err := s3.New(h.Session).GetObject(&s3.GetObjectInput{
                Bucket: aws.String(h.Bucket),
                Key:    aws.String(key),
        })
        if err != nil {
                return "", err
        }
        defer results.Body.Close()

        buf := bytes.NewBuffer(nil)
        if _, err := io.Copy(buf, results.Body); err != nil {
                return "", err
        }
        return string(buf.Bytes()), nil
}