feat(files): add uploadings api (#30)

* fix(uploader, files/handlers): fix incorrect unlock, catch and check after calling api

* fix(uploader): fix uploader test

* feat(files): add uploadings api

* fix(files): register uploading handlers to api

Co-authored-by: Jia He <jiah@nvidia.com>

src/client/files.go

@@ -118,3 +118,24 @@ func (cl *FilesClient) List(dirPath string) (*http.Response, *fileshdr.ListResp,
 	}
 	return resp, lResp, nil
 }
+
+func (cl *FilesClient) ListUploadings() (*http.Response, *fileshdr.ListUploadingsResp, []error) {
+	resp, body, errs := cl.r.Get(cl.url("/v1/fs/uploadings")).
+		End()
+	if len(errs) > 0 {
+		return nil, nil, errs
+	}
+
+	lResp := &fileshdr.ListUploadingsResp{}
+	err := json.Unmarshal([]byte(body), lResp)
+	if err != nil {
+		return nil, nil, append(errs, err)
+	}
+	return resp, lResp, nil
+}
+
+func (cl *FilesClient) DelUploading(filepath string) (*http.Response, string, []error) {
+	return cl.r.Delete(cl.url("/v1/fs/uploadings")).
+		Param(fileshdr.FilePathQuery, filepath).
+		End()
+}

src/depidx/deps.go

@@ -2,6 +2,7 @@ package depidx
 
 import (
 	"github.com/ihexxa/gocfg"
+
 	"github.com/ihexxa/quickshare/src/cryptoutil"
 	"github.com/ihexxa/quickshare/src/fs"
 	"github.com/ihexxa/quickshare/src/idgen"

src/handlers/fileshdr/handlers.go

@@ -18,6 +18,7 @@ import (
 
 	"github.com/ihexxa/quickshare/src/depidx"
 	q "github.com/ihexxa/quickshare/src/handlers"
+	"github.com/ihexxa/quickshare/src/handlers/singleuserhdr"
 )
 
 var (
@@ -93,6 +94,7 @@ func (lk *AutoLocker) Exec(handler func()) {
 		lk.c.JSON(q.ErrResp(lk.c, 500, errors.New("fail to lock the file")))
 		return
 	}
+	locked = true
 
 	locked = true
 	handler()
@@ -109,16 +111,17 @@ func (h *FileHandlers) Create(c *gin.Context) {
 		c.JSON(q.ErrResp(c, 500, err))
 		return
 	}
+	userName := c.MustGet(singleuserhdr.UserParam).(string)
 
-	tmpFilePath := h.GetTmpPath(req.Path)
+	tmpFilePath := getTmpPath(req.Path)
-	locker := h.NewAutoLocker(c, tmpFilePath)
+	locker := h.NewAutoLocker(c, lockName(userName, tmpFilePath))
 	locker.Exec(func() {
 		err := h.deps.FS().Create(tmpFilePath)
 		if err != nil {
 			c.JSON(q.ErrResp(c, 500, err))
 			return
 		}
-		err = h.uploadMgr.AddInfo(req.Path, tmpFilePath, req.FileSize, false)
+		err = h.uploadMgr.AddInfo(userName, req.Path, tmpFilePath, req.FileSize)
 		if err != nil {
 			c.JSON(q.ErrResp(c, 500, err))
 			return
@@ -252,13 +255,14 @@ func (h *FileHandlers) UploadChunk(c *gin.Context) {
 		c.JSON(q.ErrResp(c, 500, err))
 		return
 	}
+	userName := c.MustGet(singleuserhdr.UserParam).(string)
 
-	tmpFilePath := h.GetTmpPath(req.Path)
+	tmpFilePath := getTmpPath(req.Path)
-	locker := h.NewAutoLocker(c, tmpFilePath)
+	locker := h.NewAutoLocker(c, lockName(userName, tmpFilePath))
 	locker.Exec(func() {
 		var err error
 
-		_, fileSize, uploaded, err := h.uploadMgr.GetInfo(tmpFilePath)
+		_, fileSize, uploaded, err := h.uploadMgr.GetInfo(userName, tmpFilePath)
 		if err != nil {
 			c.JSON(q.ErrResp(c, 500, err))
 			return
@@ -273,15 +277,13 @@ func (h *FileHandlers) UploadChunk(c *gin.Context) {
 			return
 		}
 
-		fmt.Println("length", len([]byte(content)))
-
 		wrote, err := h.deps.FS().WriteAt(tmpFilePath, []byte(content), req.Offset)
 		if err != nil {
 			c.JSON(q.ErrResp(c, 500, err))
 			return
 		}
 
-		err = h.uploadMgr.SetUploaded(tmpFilePath, req.Offset+int64(wrote))
+		err = h.uploadMgr.SetInfo(userName, tmpFilePath, req.Offset+int64(wrote))
 		if err != nil {
 			c.JSON(q.ErrResp(c, 500, err))
 			return
@@ -295,7 +297,7 @@ func (h *FileHandlers) UploadChunk(c *gin.Context) {
 				c.JSON(q.ErrResp(c, 500, fmt.Errorf("%s error: %w", req.Path, err)))
 				return
 			}
-			err = h.uploadMgr.DelInfo(tmpFilePath)
+			err = h.uploadMgr.DelInfo(userName, tmpFilePath)
 			if err != nil {
 				c.JSON(q.ErrResp(c, 500, err))
 				return
@@ -323,11 +325,12 @@ func (h *FileHandlers) UploadStatus(c *gin.Context) {
 	if filePath == "" {
 		c.JSON(q.ErrResp(c, 400, errors.New("invalid file name")))
 	}
+	userName := c.MustGet(singleuserhdr.UserParam).(string)
 
-	tmpFilePath := h.GetTmpPath(filePath)
+	tmpFilePath := getTmpPath(filePath)
-	locker := h.NewAutoLocker(c, tmpFilePath)
+	locker := h.NewAutoLocker(c, lockName(userName, tmpFilePath))
 	locker.Exec(func() {
-		_, fileSize, uploaded, err := h.uploadMgr.GetInfo(tmpFilePath)
+		_, fileSize, uploaded, err := h.uploadMgr.GetInfo(userName, tmpFilePath)
 		if err != nil {
 			if os.IsNotExist(err) {
 				c.JSON(q.ErrResp(c, 404, err))
@@ -347,7 +350,6 @@ func (h *FileHandlers) UploadStatus(c *gin.Context) {
 }
 
 // TODO: support ETag
-// TODO: use correct content type
 func (h *FileHandlers) Download(c *gin.Context) {
 	rangeVal := c.GetHeader(rangeHeader)
 	ifRangeVal := c.GetHeader(ifRangeHeader)
@@ -391,7 +393,6 @@ func (h *FileHandlers) Download(c *gin.Context) {
 	//  :=	r.(*os.File)
 
 	// respond to normal requests
-	fmt.Println(ifRangeVal, rangeVal)
 	if ifRangeVal != "" || rangeVal == "" {
 		c.DataFromReader(200, info.Size(), contentType, r, map[string]string{})
 		return
@@ -463,10 +464,56 @@ func (h *FileHandlers) CopyDir(c *gin.Context) {
 	c.JSON(q.NewMsgResp(501, "Not Implemented"))
 }
 
-func (h *FileHandlers) GetTmpPath(filePath string) string {
+func getTmpPath(filePath string) string {
 	return path.Join(UploadDir, fmt.Sprintf("%x", sha1.Sum([]byte(filePath))))
 }
 
+func lockName(user, filePath string) string {
+	return fmt.Sprintf("%s/%s", user, filePath)
+}
+
 func (h *FileHandlers) FsPath(filePath string) string {
 	return path.Join(FsDir, filePath)
 }
+
+type ListUploadingsResp struct {
+	UploadInfos []*UploadInfo `json:"uploadInfos"`
+}
+
+func (h *FileHandlers) ListUploadings(c *gin.Context) {
+	userName := c.MustGet(singleuserhdr.UserParam).(string)
+
+	infos, err := h.uploadMgr.ListInfo(userName)
+	if err != nil {
+		c.JSON(q.ErrResp(c, 500, err))
+		return
+	}
+	c.JSON(200, &ListUploadingsResp{UploadInfos: infos})
+}
+
+func (h *FileHandlers) DelUploading(c *gin.Context) {
+	filePath := c.Query(FilePathQuery)
+	if filePath == "" {
+		c.JSON(q.ErrResp(c, 400, errors.New("invalid file path")))
+		return
+	}
+	userName := c.MustGet(singleuserhdr.UserParam).(string)
+
+	var err error
+	tmpFilePath := getTmpPath(filePath)
+	locker := h.NewAutoLocker(c, lockName(userName, tmpFilePath))
+	locker.Exec(func() {
+		err = h.deps.FS().Remove(tmpFilePath)
+		if err != nil {
+			c.JSON(q.ErrResp(c, 500, err))
+			return
+		}
+
+		err = h.uploadMgr.DelInfo(userName, tmpFilePath)
+		if err != nil {
+			c.JSON(q.ErrResp(c, 500, err))
+			return
+		}
+		c.JSON(q.Resp(200))
+	})
+}

src/handlers/fileshdr/upload_mgr.go

@@ -1,81 +1,121 @@
 package fileshdr
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
-	"os"
 
 	"github.com/ihexxa/quickshare/src/kvstore"
 )
 
 var (
-	isDirKey    = "isDir"
+	ErrCreateExisting  = errors.New("create upload info which already exists")
-	fileSizeKey = "fileSize"
+	ErrGreaterThanSize = errors.New("uploaded is greater than file size")
-	uploadedKey = "uploaded"
+	ErrNotFound        = errors.New("upload info not found")
-	filePathKey = "fileName"
+
+	uploadsPrefix = "uploads"
 )
 
+type UploadInfo struct {
+	RealFilePath string `json:"realFilePath"`
+	Size         int64  `json:"size"`
+	Uploaded     int64  `json:"uploaded"`
+}
+
 type UploadMgr struct {
 	kv kvstore.IKVStore
 }
 
+func UploadNS(user string) string {
+	return fmt.Sprintf("%s/%s", uploadsPrefix, user)
+}
+
 func NewUploadMgr(kv kvstore.IKVStore) *UploadMgr {
 	return &UploadMgr{
 		kv: kv,
 	}
 }
 
-func (um *UploadMgr) AddInfo(fileName, tmpName string, fileSize int64, isDir bool) error {
+func (um *UploadMgr) AddInfo(user, filePath, tmpPath string, fileSize int64) error {
-	err := um.kv.SetInt64(infoKey(tmpName, fileSizeKey), fileSize)
+	ns := UploadNS(user)
+	err := um.kv.AddNamespace(ns)
 	if err != nil {
 		return err
 	}
-	err = um.kv.SetInt64(infoKey(tmpName, uploadedKey), 0)
+
+	_, ok := um.kv.GetStringIn(ns, tmpPath)
+	if ok {
+		return ErrCreateExisting
+	}
+
+	info := &UploadInfo{
+		RealFilePath: filePath,
+		Size:         fileSize,
+		Uploaded:     0,
+	}
+	infoBytes, err := json.Marshal(info)
 	if err != nil {
 		return err
 	}
-	return um.kv.SetString(infoKey(tmpName, filePathKey), fileName)
+
+	return um.kv.SetStringIn(ns, tmpPath, string(infoBytes))
 }
 
-func (um *UploadMgr) SetUploaded(fileName string, newUploaded int64) error {
+func (um *UploadMgr) SetInfo(user, filePath string, newUploaded int64) error {
-	fileSize, ok := um.kv.GetInt64(infoKey(fileName, fileSizeKey))
+	realFilePath, fileSize, _, err := um.GetInfo(user, filePath)
-	if !ok {
+	if err != nil {
-		return fmt.Errorf("file size %s not found", fileName)
+		return err
-	}
+	} else if newUploaded > fileSize {
-	if newUploaded <= fileSize {
+		return ErrGreaterThanSize
-		um.kv.SetInt64(infoKey(fileName, uploadedKey), newUploaded)
-		return nil
-	}
-	return errors.New("uploaded is greater than file size")
-}
-
-func (um *UploadMgr) GetInfo(fileName string) (string, int64, int64, error) {
-	realFilePath, ok := um.kv.GetString(infoKey(fileName, filePathKey))
-	if !ok {
-		return "", 0, 0, os.ErrNotExist
-	}
-	fileSize, ok := um.kv.GetInt64(infoKey(fileName, fileSizeKey))
-	if !ok {
-		return "", 0, 0, os.ErrNotExist
-	}
-	uploaded, ok := um.kv.GetInt64(infoKey(fileName, uploadedKey))
-	if !ok {
-		return "", 0, 0, os.ErrNotExist
 	}
 
-	return realFilePath, fileSize, uploaded, nil
+	newInfo := &UploadInfo{
-}
+		RealFilePath: realFilePath,
-
+		Size:         fileSize,
-func (um *UploadMgr) DelInfo(fileName string) error {
+		Uploaded:     newUploaded,
-	if err := um.kv.DelInt64(infoKey(fileName, fileSizeKey)); err != nil {
+	}
+	newInfoBytes, err := json.Marshal(newInfo)
+	if err != nil {
 		return err
 	}
-	if err := um.kv.DelInt64(infoKey(fileName, uploadedKey)); err != nil {
+	return um.kv.SetStringIn(UploadNS(user), filePath, string(newInfoBytes))
-		return err
-	}
-	return um.kv.DelString(infoKey(fileName, filePathKey))
 }
 
-func infoKey(fileName, key string) string {
+func (um *UploadMgr) GetInfo(user, filePath string) (string, int64, int64, error) {
-	return fmt.Sprintf("%s:%s", fileName, key)
+	ns := UploadNS(user)
+	infoBytes, ok := um.kv.GetStringIn(ns, filePath)
+	if !ok {
+		return "", 0, 0, ErrNotFound
+	}
+
+	info := &UploadInfo{}
+	err := json.Unmarshal([]byte(infoBytes), info)
+	if err != nil {
+		return "", 0, 0, err
+	}
+
+	return info.RealFilePath, info.Size, info.Uploaded, nil
+}
+
+func (um *UploadMgr) DelInfo(user, filePath string) error {
+	return um.kv.DelInt64In(UploadNS(user), filePath)
+}
+
+func (um *UploadMgr) ListInfo(user string) ([]*UploadInfo, error) {
+	infoMap, err := um.kv.ListStringsIn(UploadNS(user))
+	if err != nil {
+		return nil, err
+	}
+
+	infos := []*UploadInfo{}
+	for _, infoStr := range infoMap {
+		info := &UploadInfo{}
+		err = json.Unmarshal([]byte(infoStr), info)
+		if err != nil {
+			return nil, err
+		}
+		infos = append(infos, info)
+	}
+
+	return infos, nil
 }

src/handlers/singleuserhdr/middlewares.go

@@ -53,11 +53,14 @@ func (h *SimpleUserHandlers) Auth() gin.HandlerFunc {
 				ExpireParam: "",
 			}
 
-			_, err = h.deps.Token().FromToken(token, claims)
+			claims, err = h.deps.Token().FromToken(token, claims)
 			if err != nil {
 				c.AbortWithStatusJSON(q.ErrResp(c, 401, err))
 				return
 			}
+			for key, val := range claims {
+				c.Set(key, val)
+			}
 
 			now := time.Now().Unix()
 			expire, err := strconv.ParseInt(claims[ExpireParam], 10, 64)
@@ -71,6 +74,9 @@ func (h *SimpleUserHandlers) Auth() gin.HandlerFunc {
 				c.AbortWithStatusJSON(q.ErrResp(c, 401, errors.New("not allowed")))
 				return
 			}
+		} else {
+			// this is for UploadMgr to get user info to get related namespace
+			c.Set(UserParam, "quickshare_anonymous")
 		}
 
 		c.Next()

src/kvstore/boltdbpvd/provider.go

@@ -2,6 +2,7 @@ package boltdbpvd
 
 import (
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"math"
 	"path"
@@ -12,6 +13,10 @@ import (
 	"github.com/ihexxa/quickshare/src/kvstore"
 )
 
+var (
+	ErrBucketNotFound = errors.New("bucket not found")
+)
+
 type BoltPvd struct {
 	dbPath    string
 	db        *bolt.DB
@@ -61,6 +66,12 @@ func (bp *BoltPvd) AddNamespace(nsName string) error {
 	})
 }
 
+func (bp *BoltPvd) DelNamespace(nsName string) error {
+	return bp.db.Update(func(tx *bolt.Tx) error {
+		return tx.DeleteBucket([]byte(nsName))
+	})
+}
+
 func (bp *BoltPvd) Close() error {
 	return bp.db.Close()
 }
@@ -112,10 +123,18 @@ func (bp *BoltPvd) DelInt(key string) error {
 }
 
 func (bp *BoltPvd) GetInt64(key string) (int64, bool) {
+	return bp.GetInt64In("int64s", key)
+}
+
+func (bp *BoltPvd) GetInt64In(ns, key string) (int64, bool) {
 	buf, ok := make([]byte, binary.MaxVarintLen64), false
 
 	bp.db.View(func(tx *bolt.Tx) error {
-		b := tx.Bucket([]byte("int64s"))
+		b := tx.Bucket([]byte(ns))
+		if b == nil {
+			return nil
+		}
+
 		v := b.Get([]byte(key))
 		copy(buf, v)
 		ok = v != nil
@@ -133,21 +152,57 @@ func (bp *BoltPvd) GetInt64(key string) (int64, bool) {
 }
 
 func (bp *BoltPvd) SetInt64(key string, val int64) error {
+	return bp.SetInt64In("int64s", key, val)
+}
+
+func (bp *BoltPvd) SetInt64In(ns, key string, val int64) error {
 	buf := make([]byte, binary.MaxVarintLen64)
 	n := binary.PutVarint(buf, val)
 
 	return bp.db.Update(func(tx *bolt.Tx) error {
-		b := tx.Bucket([]byte("int64s"))
+		b := tx.Bucket([]byte(ns))
+		if b == nil {
+			return ErrBucketNotFound
+		}
 		return b.Put([]byte(key), buf[:n])
 	})
 }
+
 func (bp *BoltPvd) DelInt64(key string) error {
+	return bp.DelInt64In("int64s", key)
+}
+
+func (bp *BoltPvd) DelInt64In(ns, key string) error {
 	return bp.db.Update(func(tx *bolt.Tx) error {
-		b := tx.Bucket([]byte("int64s"))
+		b := tx.Bucket([]byte(ns))
+		if b == nil {
+			return ErrBucketNotFound
+		}
 		return b.Delete([]byte(key))
 	})
 }
 
+func (bp *BoltPvd) ListInt64sIn(ns string) (map[string]int64, error) {
+	list := map[string]int64{}
+	err := bp.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(ns))
+		if b == nil {
+			return ErrBucketNotFound
+		}
+
+		b.ForEach(func(k, v []byte) error {
+			x, n := binary.Varint(v)
+			if n < 0 {
+				return fmt.Errorf("fail to parse int64 for key (%s)", k)
+			}
+			list[fmt.Sprintf("%s", k)] = x
+			return nil
+		})
+		return nil
+	})
+	return list, err
+}
+
 func float64ToBytes(num float64) []byte {
 	buf := make([]byte, 64)
 	binary.PutUvarint(buf, math.Float64bits(num))
@@ -211,8 +266,15 @@ func (bp *BoltPvd) SetString(key string, val string) error {
 }
 
 func (bp *BoltPvd) DelString(key string) error {
+	return bp.DelStringIn("strings", key)
+}
+
+func (bp *BoltPvd) DelStringIn(ns, key string) error {
 	return bp.db.Update(func(tx *bolt.Tx) error {
-		b := tx.Bucket([]byte("strings"))
+		b := tx.Bucket([]byte(ns))
+		if b == nil {
+			return ErrBucketNotFound
+		}
 		return b.Delete([]byte(key))
 	})
 }
@@ -237,25 +299,52 @@ func (bp *BoltPvd) Unlock(key string) error {
 	})
 }
 
-func (bp *BoltPvd) GetStringIn(namespace, key string) (string, bool) {
+func (bp *BoltPvd) GetStringIn(ns, key string) (string, bool) {
 	buf, ok, length := make([]byte, bp.maxStrLen), false, bp.maxStrLen
 	bp.db.View(func(tx *bolt.Tx) error {
-		b := tx.Bucket([]byte(namespace))
+		b := tx.Bucket([]byte(ns))
+		if b == nil {
+			return nil
+		}
+
 		v := b.Get([]byte(key))
 		length = copy(buf, v)
 		ok = v != nil
 		return nil
 	})
+
 	return string(buf[:length]), ok
 }
 
-func (bp *BoltPvd) SetStringIn(namespace, key, val string) error {
+func (bp *BoltPvd) SetStringIn(ns, key, val string) error {
 	if len(val) > bp.maxStrLen {
 		return fmt.Errorf("can not set string value longer than %d", bp.maxStrLen)
 	}
 
 	return bp.db.Update(func(tx *bolt.Tx) error {
-		b := tx.Bucket([]byte(namespace))
+		b := tx.Bucket([]byte(ns))
+		if b == nil {
+			return ErrBucketNotFound
+		}
+
 		return b.Put([]byte(key), []byte(val))
 	})
 }
+
+func (bp *BoltPvd) ListStringsIn(ns string) (map[string]string, error) {
+	kv := map[string]string{}
+	err := bp.db.View(func(tx *bolt.Tx) error {
+		b := tx.Bucket([]byte(ns))
+		if b == nil {
+			return ErrBucketNotFound
+		}
+
+		b.ForEach(func(k, v []byte) error {
+			kv[fmt.Sprintf("%s", k)] = fmt.Sprintf("%s", v)
+			return nil
+		})
+		return nil
+	})
+
+	return kv, err
+}

src/kvstore/kvstore_interface.go

@@ -7,6 +7,7 @@ var ErrNoLock = errors.New("no lock to unlock")
 
 type IKVStore interface {
 	AddNamespace(nsName string) error
+	DelNamespace(nsName string) error
 	GetBool(key string) (bool, bool)
 	SetBool(key string, val bool) error
 	DelBool(key string) error
@@ -15,15 +16,21 @@ type IKVStore interface {
 	DelInt(key string) error
 	GetInt64(key string) (int64, bool)
 	SetInt64(key string, val int64) error
+	GetInt64In(ns, key string) (int64, bool)
+	SetInt64In(ns, key string, val int64) error
+	ListInt64sIn(ns string) (map[string]int64, error)
 	DelInt64(key string) error
+	DelInt64In(ns, key string) error
 	GetFloat(key string) (float64, bool)
 	SetFloat(key string, val float64) error
 	DelFloat(key string) error
 	GetString(key string) (string, bool)
 	SetString(key, val string) error
 	DelString(key string) error
-	GetStringIn(namespace, key string) (string, bool)
+	DelStringIn(ns, key string) error
-	SetStringIn(namespace, key, val string) error
+	GetStringIn(ns, key string) (string, bool)
+	SetStringIn(ns, key, val string) error
+	ListStringsIn(ns string) (map[string]string, error)
 	TryLock(key string) error
 	Unlock(key string) error
 }

src/kvstore/memstore/provider.go

@@ -170,11 +170,26 @@ func (st *MemStore) AddNamespace(nsName string) error {
 	return errors.New("not implemented")
 }
 
+func (st *MemStore) GetInt64In(namespace, key string) (int64, bool) {
+	panic("not implemented")
+}
+
+func (st *MemStore) SetInt64In(namespace, key string, val int64) error {
+	panic("not implemented")
+}
+
+func (st *MemStore) ListInt64sIn(namespace, key string) (map[string]int64, error) {
+	panic("not implemented")
+}
+
 func (st *MemStore) GetStringIn(namespace, key string) (string, bool) {
 	panic("not implemented")
-	return "", false
 }
 
 func (st *MemStore) SetStringIn(namespace, key, val string) error {
-	return errors.New("not implemented")
+	panic("not implemented")
 }
+
+func (st *MemStore) ListStringsIn(namespace, key string) (map[string]string, error) {
+	panic("not implemented")
+}

src/kvstore/test/provider_test.go

@@ -8,7 +8,7 @@ import (
 
 	"github.com/ihexxa/quickshare/src/kvstore"
 	"github.com/ihexxa/quickshare/src/kvstore/boltdbpvd"
-	"github.com/ihexxa/quickshare/src/kvstore/memstore"
+	// "github.com/ihexxa/quickshare/src/kvstore/memstore"
 )
 
 func TestKVStoreProviders(t *testing.T) {
@@ -137,6 +137,35 @@ func TestKVStoreProviders(t *testing.T) {
 			t.Error("value should not exist")
 		}
 
+		// test strings in ns
+		ns := "str_namespace"
+		err = store.AddNamespace(ns)
+		if err != nil {
+			t.Errorf("there should be no error %v", err)
+		}
+		_, ok = store.GetStringIn(ns, key)
+		if ok {
+			t.Error("value should not exist")
+		}
+		err = store.SetStringIn(ns, key, stringV)
+		if err != nil {
+			t.Errorf("there should be no error %v", err)
+		}
+		stringVGot, ok = store.GetStringIn(ns, key)
+		if !ok {
+			t.Error("value should exit")
+		} else if stringVGot != stringV {
+			t.Error(fmt.Sprintln("value not equal", stringVGot, stringV))
+		}
+		err = store.DelStringIn(ns, key)
+		if err != nil {
+			t.Errorf("there should be no error %v", err)
+		}
+		_, ok = store.GetStringIn(ns, key)
+		if ok {
+			t.Error("value should not exist")
+		}
+
 		// test locks
 		err = store.TryLock(key)
 		if err != nil {
@@ -172,14 +201,14 @@ func TestKVStoreProviders(t *testing.T) {
 		kvstoreTest(store, t)
 	})
 
-	t.Run("test in-memory provider", func(t *testing.T) {
+	// t.Run("test in-memory provider", func(t *testing.T) {
-		rootPath, err := ioutil.TempDir("./", "quickshare_kvstore_test_")
+	// 	rootPath, err := ioutil.TempDir("./", "quickshare_kvstore_test_")
-		if err != nil {
+	// 	if err != nil {
-			t.Fatal(err)
+	// 		t.Fatal(err)
-		}
+	// 	}
-		defer os.RemoveAll(rootPath)
+	// 	defer os.RemoveAll(rootPath)
 
-		store := memstore.New()
+	// 	store := memstore.New()
-		kvstoreTest(store, t)
+	// 	kvstoreTest(store, t)
-	})
+	// })
 }

src/server/server.go

@@ -148,6 +148,9 @@ func initHandlers(router *gin.Engine, cfg gocfg.ICfg, deps *depidx.Deps) (*gin.E
 	filesAPI.POST("/dirs", fileHdrs.Mkdir)
 	// files.POST("/dirs/copy", fileHdrs.CopyDir)
 
+	filesAPI.GET("/uploadings", fileHdrs.ListUploadings)
+	filesAPI.DELETE("/uploadings", fileHdrs.DelUploading)
+
 	filesAPI.GET("/metadata", fileHdrs.Metadata)
 
 	settingsAPI := v1.Group("/settings")

src/server/server_files_test.go

@@ -389,4 +389,61 @@ func TestFileHandlers(t *testing.T) {
 
 		wg.Wait()
 	})
+
+	t.Run("test uploading APIs: Create, ListUploadings, DelUploading)", func(t *testing.T) {
+		files := map[string]string{
+			"uploadings/path1/f1":    "123456",
+			"uploadings/path1/path2": "12345678",
+		}
+
+		for filePath, content := range files {
+			fileSize := int64(len([]byte(content)))
+			res, _, errs := cl.Create(filePath, fileSize)
+			if len(errs) > 0 {
+				t.Fatal(errs)
+			} else if res.StatusCode != 200 {
+				t.Fatal(res.StatusCode)
+			}
+		}
+
+		res, lResp, errs := cl.ListUploadings()
+		if len(errs) > 0 {
+			t.Fatal(errs)
+		} else if res.StatusCode != 200 {
+			t.Fatal(res.StatusCode)
+		}
+
+		gotInfos := map[string]*fileshdr.UploadInfo{}
+		for _, info := range lResp.UploadInfos {
+			gotInfos[info.RealFilePath] = info
+		}
+		for filePath, content := range files {
+			info, ok := gotInfos[filePath]
+			if !ok {
+				t.Fatalf("uploading(%s) not found", filePath)
+			} else if info.Uploaded != 0 {
+				t.Fatalf("uploading(%s) uploaded is not correct", filePath)
+			} else if info.Size != int64(len([]byte(content))) {
+				t.Fatalf("uploading(%s) size is not correct", filePath)
+			}
+		}
+
+		for filePath := range files {
+			res, _, errs := cl.DelUploading(filePath)
+			if len(errs) > 0 {
+				t.Fatal(errs)
+			} else if res.StatusCode != 200 {
+				t.Fatal(res.StatusCode)
+			}
+		}
+
+		res, lResp, errs = cl.ListUploadings()
+		if len(errs) > 0 {
+			t.Fatal(errs)
+		} else if res.StatusCode != 200 {
+			t.Fatal(res.StatusCode)
+		} else if len(lResp.UploadInfos) != 0 {
+			t.Fatalf("info is not deleted, info len(%d)", len(lResp.UploadInfos))
+		}
+	})
 }