aiforge/modules/storage/obs.go

// Copyright 2020 The Gitea Authors. All rights reserved.
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.

package storage

import (
	"io"
	"path"
	"strconv"
	"strings"

	"code.gitea.io/gitea/modules/log"
	"code.gitea.io/gitea/modules/obs"
	"code.gitea.io/gitea/modules/setting"
)

//check if has the object
func ObsHasObject(path string) (bool, error) {
	hasObject := false
	output, err := ObsCli.ListObjects(&obs.ListObjectsInput{Bucket:setting.Bucket})
	if err != nil {
		log.Error("ListObjects failed:%v", err)
		return hasObject, err
	}

	for _, obj := range output.Contents {
		if path == obj.Key {
			hasObject = true
			break
		}
	}

	return hasObject, nil
}

func GetObsPartInfos(uuid string, uploadID string) (string, error) {
	key := strings.TrimPrefix(path.Join(setting.BasePath, path.Join(uuid[0:1], uuid[1:2], uuid)), "/")

	output, err := ObsCli.ListParts(&obs.ListPartsInput{
		Bucket:		setting.Bucket,
		Key:		key,
		UploadId:	uploadID,
	})
	if err != nil {
		log.Error("ListParts failed:", err.Error())
		return "", err
	}

	var chunks string
	for _, partInfo := range output.Parts {
		chunks += strconv.Itoa(partInfo.PartNumber) + "-" + partInfo.ETag + ","
	}

	return chunks, nil
}

func NewObsMultiPartUpload(uuid string) (string, error) {
	input := &obs.InitiateMultipartUploadInput{}
	input.Bucket = setting.Bucket
	input.Key = strings.TrimPrefix(path.Join(setting.BasePath, path.Join(uuid[0:1], uuid[1:2], uuid)), "/")

	output, err := ObsCli.InitiateMultipartUpload(input)
	if err != nil {
		log.Error("InitiateMultipartUpload failed:", err.Error())
		return "", err
	}

	return output.UploadId, nil
}

func CompleteObsMultiPartUpload(uuid string, uploadID string) error {
	input := &obs.CompleteMultipartUploadInput{}
	input.Bucket = setting.Bucket
	input.Key = strings.TrimPrefix(path.Join(setting.BasePath, path.Join(uuid[0:1], uuid[1:2], uuid)), "/")
	input.UploadId = uploadID
	output, err := ObsCli.ListParts(&obs.ListPartsInput{
		Bucket:		setting.Bucket,
		Key:		input.Key,
		UploadId:	uploadID,
	})
	if err != nil {
		log.Error("ListParts failed:", err.Error())
		return err
	}

	for _, partInfo := range output.Parts {
		input.Parts = append(input.Parts, obs.Part{
			PartNumber: partInfo.PartNumber,
			ETag:       partInfo.ETag,
		})
	}

	_, err = ObsCli.CompleteMultipartUpload(input)
	if err != nil {
		log.Error("CompleteMultipartUpload failed:", err.Error())
		return err
	}

	return nil
}

func ObsUploadPart(uuid string, uploadId string, partNumber int, partSize int64, body io.Reader) (string, error) {
	input := &obs.UploadPartInput{}
	input.PartNumber = partNumber
	input.Key = strings.TrimPrefix(path.Join(setting.BasePath, path.Join(uuid[0:1], uuid[1:2], uuid)), "/")
	input.UploadId = uploadId
	input.Bucket = setting.Bucket
	input.PartSize = partSize
	input.Body = body
	output, err := ObsCli.UploadPart(input)
	if err != nil {
		log.Error("UploadPart failed:", err.Error())
		return "", err
	}

	return output.ETag, nil
}

func ObsGenMultiPartSignedUrl(uuid string, uploadId string, partNumber int, partSize int64) (string, error) {
	/*
	input := &obs.CreateSignedUrlInput{}
	input.Bucket = setting.Bucket
	input.Key = strings.TrimPrefix(path.Join(setting.BasePath, path.Join(uuid[0:1], uuid[1:2], uuid)), "/")
	input.Expires = int(PresignedUploadPartUrlExpireTime)
	input.Method = obs.HTTP_PUT

	input.QueryParams = map[string]string{
		"Bucket":	input.Bucket,
		"Key":		input.Key,
		"PartNumber": com.ToStr(partNumber,10),
		"UploadId":	uploadId,
		"PartSize":	com.ToStr(partSize,10),
	}

	input.Headers = map[string]string{

	}

	 */

	Key := strings.TrimPrefix(path.Join(setting.BasePath, path.Join(uuid[0:1], uuid[1:2], uuid)), "/")
	url, err := ObsCli.CreateUploadPartSignedUrl(setting.Bucket, Key, uploadId, partNumber, partSize)
	if err != nil {
		log.Error("CreateSignedUrl failed:", err.Error())
		return "", err
	}

	log.Info(url)

	return url, nil

}