feat: add tree operation

api/custom_response.go

@@ -19,11 +19,21 @@ func (response *JiaozifsResponse) JSON(v interface{}) {
 	}
 }
 
+func (response *JiaozifsResponse) OK() {
+	response.WriteHeader(http.StatusOK)
+}
+
 func (response *JiaozifsResponse) Error(err error) {
 	response.WriteHeader(http.StatusInternalServerError)
 	_, _ = response.Write([]byte(err.Error()))
 }
 
+func (response *JiaozifsResponse) String(msg string) {
+	response.Header().Set("Content-Type", "text/plain;charset=UTF-8")
+	response.WriteHeader(http.StatusOK)
+	_, _ = response.Write([]byte(msg))
+}
+
 func (response *JiaozifsResponse) CodeMsg(code int, msg string) {
 	response.WriteHeader(code)
 	_, _ = response.Write([]byte(msg))

api/swagger.yml

@@ -132,7 +132,6 @@ components:
       type: object
       required:
         - checksum
-        - physical_address
         - path
         - path_type
         - mtime
@@ -142,22 +141,6 @@ components:
         path_mode:
           type: integer
           format: uint32
-        physical_address:
-          type: string
-          description: |
-            The location of the object on the underlying object store.
-            Formatted as a native URI with the object store type as scheme ("s3://...", "gs://...", etc.)
-            Or, in the case of presign=true, will be an HTTP URL to be consumed via regular HTTP GET
-        physical_address_expiry:
-          type: integer
-          format: int64
-          description: |
-            If present and nonzero, physical_address is a pre-signed URL and
-            will expire at this Unix Epoch time.  This will be shorter than
-            the pre-signed URL lifetime if an authentication token is about
-            to expire.
-
-            This field is *optional*.
         checksum:
           type: string
         size_bytes:

auth/auth_test.go

@@ -2,40 +2,19 @@ package auth
 
 import (
 	"context"
-	"fmt"
 	"testing"
 
+	"github.com/jiaozifs/jiaozifs/testhelper"
+
 	"github.com/brianvoe/gofakeit/v6"
-	embeddedpostgres "github.com/fergusstrange/embedded-postgres"
 	"github.com/jiaozifs/jiaozifs/config"
 	"github.com/jiaozifs/jiaozifs/models"
-	"github.com/jiaozifs/jiaozifs/models/migrations"
-	"github.com/phayes/freeport"
 	"github.com/stretchr/testify/require"
-	"github.com/uptrace/bun"
-	"go.uber.org/fx/fxtest"
 )
 
-var testConnTmpl = "postgres://postgres:postgres@localhost:%d/jiaozifs?sslmode=disable"
-
-func setup(ctx context.Context, t *testing.T) (*embeddedpostgres.EmbeddedPostgres, *bun.DB) {
-	port, err := freeport.GetFreePort()
-	require.NoError(t, err)
-	postgres := embeddedpostgres.NewDatabase(embeddedpostgres.DefaultConfig().Port(uint32(port)).Database("jiaozifs"))
-	err = postgres.Start()
-	require.NoError(t, err)
-
-	db, err := models.SetupDatabase(ctx, fxtest.NewLifecycle(t), &config.DatabaseConfig{Debug: true, Connection: fmt.Sprintf(testConnTmpl, port)})
-	require.NoError(t, err)
-
-	err = migrations.MigrateDatabase(ctx, db)
-	require.NoError(t, err)
-	return postgres, db
-}
-
 func TestLogin_Success(t *testing.T) {
 	ctx := context.Background()
-	postgres, db := setup(ctx, t)
+	postgres, _, db := testhelper.SetupDatabase(ctx, t)
 	defer postgres.Stop() //nolint
 	// repo
 	mockRepo := models.NewUserRepo(db)

auth/basic_auth.go

@@ -2,12 +2,15 @@ package auth
 
 import (
 	"context"
+	"fmt"
 	"time"
 
+	"github.com/jiaozifs/jiaozifs/utils"
+
 	"github.com/jiaozifs/jiaozifs/config"
 
 	"github.com/golang-jwt/jwt"
-	openapi_types "github.com/oapi-codegen/runtime/types"
+	openapitypes "github.com/oapi-codegen/runtime/types"
 
 	"github.com/go-openapi/swag"
 	logging "github.com/ipfs/go-log/v2"
@@ -24,18 +27,17 @@ type Login struct {
 }
 
 func (l *Login) Login(ctx context.Context, repo models.IUserRepo, config *config.Config) (token api.AuthenticationToken, err error) {
-	// Get user encryptedPassword by username
+	// get user encryptedPassword by username
 	ep, err := repo.GetEPByName(ctx, l.Username)
 	if err != nil {
-		log.Errorf("username err: %s", err)
-		return token, err
+		return token, fmt.Errorf("cannt get user %s encrypt password %w", l.Username, err)
 	}
 
 	// Compare ep and password
 	err = bcrypt.CompareHashAndPassword([]byte(ep), []byte(l.Password))
 	if err != nil {
 		log.Errorf("password err: %s", err)
-		return token, err
+		return token, fmt.Errorf("user %s password not match %w", l.Username, err)
 	}
 	// Generate user token
 	loginTime := time.Now()
@@ -44,15 +46,13 @@ func (l *Login) Login(ctx context.Context, repo models.IUserRepo, config *config
 
 	tokenString, err := GenerateJWTLogin(secretKey, l.Username, loginTime, expires)
 	if err != nil {
-		log.Errorf("generate token err: %s", err)
-		return token, err
+		return token, fmt.Errorf("generate token err: %w", err)
 	}
 
-	log.Info("login successful")
+	log.Infof("usert %s login successful", l.Username)
 
 	token.Token = tokenString
 	token.TokenExpiration = swag.Int64(expires.Unix())
-
 	return token, nil
 }
 
@@ -62,20 +62,25 @@ type Register struct {
 	Password string `json:"password"`
 }
 
-func (r *Register) Register(ctx context.Context, repo models.IUserRepo) (err error) {
+func (r *Register) Register(ctx context.Context, repo models.IUserRepo) error {
 	// check username, email
-	_, err1 := repo.GetUserByName(ctx, r.Username)
-	_, err2 := repo.GetUserByEmail(ctx, r.Email)
-	if err1 == nil || err2 == nil {
-		err = ErrInvalidNameEmail
-		log.Error(ErrInvalidNameEmail)
-		return
+	count1, err := repo.Count(ctx, &models.CountUserParams{Name: utils.String(r.Username)})
+	if err != nil {
+		return err
+	}
+	count2, err := repo.Count(ctx, &models.CountUserParams{Name: utils.String(r.Email)})
+	if err != nil {
+		return err
 	}
+
+	if count1+count2 > 0 {
+		return fmt.Errorf("username %s or email %s not found %w ", r.Username, r.Email, ErrInvalidNameEmail)
+	}
+
 	// reserve temporarily
 	password, err := bcrypt.GenerateFromPassword([]byte(r.Password), passwordCost)
 	if err != nil {
-		log.Error(ErrComparePassword)
-		return
+		return fmt.Errorf("invalid password %w", err)
 	}
 
 	// insert db
@@ -88,14 +93,13 @@ func (r *Register) Register(ctx context.Context, repo models.IUserRepo) (err err
 		CurrentSignInIP:   "",
 		LastSignInIP:      "",
 		CreatedAt:         time.Now(),
-		UpdatedAt:         time.Time{},
+		UpdatedAt:         time.Now(),
 	}
 	insertUser, err := repo.Insert(ctx, user)
 	if err != nil {
-		log.Error("create user error")
-		return
+		return fmt.Errorf("inser user %s user error %w", r.Username, err)
 	}
-	// return
+
 	log.Infof("%s registration success", insertUser.Name)
 	return nil
 }
@@ -111,32 +115,29 @@ func (u *UserInfo) UserProfile(ctx context.Context, repo models.IUserRepo, confi
 		return config.Auth.SecretKey, nil
 	})
 	if err != nil {
-		log.Error(ErrParseToken)
-		return userInfo, err
+		return userInfo, fmt.Errorf("cannot parse token %s %w", token, err)
 	}
-	// Check Token validity
+	// check token validity
 	if !token.Valid {
-		log.Error(ErrInvalidToken)
-		return userInfo, ErrInvalidToken
+		return userInfo, fmt.Errorf("token %s invalid %w", token, ErrInvalidToken)
 	}
 	// Get username by token
 	claims, ok := token.Claims.(jwt.MapClaims)
 	if !ok {
-		log.Error(ErrExtractClaims)
 		return userInfo, ErrExtractClaims
 	}
 	username := claims["sub"].(string)
 
 	// Get user by username
-	user, err := repo.GetUserByName(ctx, username)
+	user, err := repo.Get(ctx, &models.GetUserParam{Name: utils.String(username)})
 	if err != nil {
 		return userInfo, err
 	}
 	userInfo = api.UserInfo{
 		CreatedAt:       &user.CreatedAt,
 		CurrentSignInAt: &user.CurrentSignInAt,
 		CurrentSignInIP: &user.CurrentSignInIP,
-		Email:           openapi_types.Email(user.Email),
+		Email:           openapitypes.Email(user.Email),
 		LastSignInAt:    &user.LastSignInAt,
 		LastSignInIP:    &user.LastSignInIP,
 		UpdateAt:        &user.UpdatedAt,

block/azure/adapter.go

@@ -141,40 +141,18 @@ func resolveBlobURLInfo(obj block.ObjectPointer) (BlobURLInfo, error) {
 	return ResolveBlobURLInfoFromURL(parsedKey)
 }
 
-func (a *Adapter) translatePutOpts(_ context.Context, opts block.PutOpts) azblob.UploadStreamOptions {
-	res := azblob.UploadStreamOptions{}
-	if opts.StorageClass == nil {
-		return res
-	}
-
-	for _, t := range blob.PossibleAccessTierValues() {
-		if strings.EqualFold(*opts.StorageClass, string(t)) {
-			accessTier := t
-			res.AccessTier = &accessTier
-			break
-		}
-	}
-
-	if res.AccessTier == nil {
-		log.With("tier_type", *opts.StorageClass).Warn("Unknown Azure tier type")
-	}
-
-	return res
-}
-
-func (a *Adapter) Put(ctx context.Context, obj block.ObjectPointer, sizeBytes int64, reader io.Reader, opts block.PutOpts) error {
+func (a *Adapter) Put(ctx context.Context, obj block.ObjectPointer, sizeBytes int64, reader io.Reader, _ block.PutOpts) error {
 	var err error
 	defer reportMetrics("Put", time.Now(), &sizeBytes, &err)
 	qualifiedKey, err := resolveBlobURLInfo(obj)
 	if err != nil {
 		return err
 	}
-	o := a.translatePutOpts(ctx, opts)
 	containerClient, err := a.clientCache.NewContainerClient(qualifiedKey.StorageAccountName, qualifiedKey.ContainerName)
 	if err != nil {
 		return err
 	}
-	_, err = containerClient.NewBlockBlobClient(qualifiedKey.BlobURL).UploadStream(ctx, reader, &o)
+	_, err = containerClient.NewBlockBlobClient(qualifiedKey.BlobURL).UploadStream(ctx, reader, &azblob.UploadStreamOptions{})
 	return err
 }
 
@@ -491,7 +469,7 @@ func (a *Adapter) UploadPart(ctx context.Context, obj block.ObjectPointer, _ int
 	if err != nil {
 		return nil, err
 	}
-	hashReader := hash.NewHashingReader(reader, hash.HashFunctionMD5)
+	hashReader := hash.NewHashingReader(reader, hash.Md5)
 
 	multipartBlockWriter := NewMultipartBlockWriter(hashReader, *container, qualifiedKey.BlobURL)
 	_, err = copyFromReader(ctx, hashReader, multipartBlockWriter, blockblob.UploadStreamOptions{

block/local/adapter.go

@@ -243,7 +243,7 @@ func (l *Adapter) UploadCopyPart(ctx context.Context, sourceObj, destinationObj
 	if err != nil {
 		return nil, err
 	}
-	md5Read := hash.NewHashingReader(r, hash.HashFunctionMD5)
+	md5Read := hash.NewHashingReader(r, hash.Md5)
 	fName := uploadID + fmt.Sprintf("-%05d", partNumber)
 	err = l.Put(ctx, block.ObjectPointer{StorageNamespace: destinationObj.StorageNamespace, Identifier: fName}, -1, md5Read, block.PutOpts{})
 	if err != nil {
@@ -263,7 +263,7 @@ func (l *Adapter) UploadCopyPartRange(ctx context.Context, sourceObj, destinatio
 	if err != nil {
 		return nil, err
 	}
-	md5Read := hash.NewHashingReader(r, hash.HashFunctionMD5)
+	md5Read := hash.NewHashingReader(r, hash.Md5)
 	fName := uploadID + fmt.Sprintf("-%05d", partNumber)
 	err = l.Put(ctx, block.ObjectPointer{StorageNamespace: destinationObj.StorageNamespace, Identifier: fName}, -1, md5Read, block.PutOpts{})
 	if err != nil {
@@ -395,7 +395,7 @@ func (l *Adapter) UploadPart(ctx context.Context, obj block.ObjectPointer, _ int
 	if err := isValidUploadID(uploadID); err != nil {
 		return nil, err
 	}
-	md5Read := hash.NewHashingReader(reader, hash.HashFunctionMD5)
+	md5Read := hash.NewHashingReader(reader, hash.Md5)
 	fName := uploadID + fmt.Sprintf("-%05d", partNumber)
 	err := l.Put(ctx, block.ObjectPointer{StorageNamespace: obj.StorageNamespace, Identifier: fName}, -1, md5Read, block.PutOpts{})
 	etag := hex.EncodeToString(md5Read.Md5.Sum(nil))

block/mem/adapter.go

@@ -90,7 +90,6 @@ func (a *Adapter) Put(_ context.Context, obj block.ObjectPointer, _ int64, reade
 	}
 	key := getKey(obj)
 	a.data[key] = data
-	a.properties[key] = block.Properties(opts)
 	return nil
 }
 

block/s3/adapter.go

@@ -200,9 +200,7 @@ func (a *Adapter) Put(ctx context.Context, obj block.ObjectPointer, sizeBytes in
 	if sizeBytes == 0 {
 		putObject.Body = http.NoBody
 	}
-	if opts.StorageClass != nil {
-		putObject.StorageClass = types.StorageClass(*opts.StorageClass)
-	}
+
 	if a.ServerSideEncryption != "" {
 		putObject.ServerSideEncryption = types.ServerSideEncryption(a.ServerSideEncryption)
 	}
@@ -768,9 +766,7 @@ func (a *Adapter) managerUpload(ctx context.Context, obj block.ObjectPointer, re
 		Key:    aws.String(key),
 		Body:   reader,
 	}
-	if opts.StorageClass != nil {
-		input.StorageClass = types.StorageClass(*opts.StorageClass)
-	}
+
 	if a.ServerSideEncryption != "" {
 		input.ServerSideEncryption = types.ServerSideEncryption(a.ServerSideEncryption)
 	}