Buy sell marketplace pre at blobber

README.md

@@ -61,6 +61,13 @@ docker network create --driver=bridge --subnet=198.18.0.0/15 --gateway=198.18.0.
 
 ```
 
+To link to local gosdk so that the changes are reflected on the blobber build please use the below command
+
+```
+
+$ ./docker.local/bin/build.blobber.dev.sh
+
+```
 For Apple M1 chip builds:
 
 ```

code/go/0chain.net/blobbercore/datastore/store.go

@@ -5,9 +5,9 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/0chain/blobber/code/go/0chain.net/blobbercore/config"
-	"github.com/0chain/blobber/code/go/0chain.net/blobbercore/errors"
+	"github.com/0chain/blobber/code/go/0chain.net/core/common"
 
+	"github.com/0chain/blobber/code/go/0chain.net/blobbercore/config"
 	"gorm.io/driver/postgres"
 	"gorm.io/gorm"
 
@@ -39,12 +39,12 @@ func (store *Store) Open() error {
 		config.Configuration.DBUserName, config.Configuration.DBName,
 		config.Configuration.DBPassword)), &gorm.Config{})
 	if err != nil {
-		return errors.DBOpenError
+		return common.NewErrorf("db_open_error", "Error opening the DB connection: %v", err)
 	}
 
 	sqldb, err := db.DB()
 	if err != nil {
-		return errors.DBOpenError
+		return common.NewErrorf("db_open_error", "Error opening the DB connection: %v", err)
 	}
 
 	sqldb.SetMaxIdleConns(100)

code/go/0chain.net/blobbercore/filestore/fs_store.go

@@ -45,9 +45,66 @@ type MinioConfiguration struct {
 
 var MinioConfig MinioConfiguration
 
+type IFileBlockGetter interface {
+	GetFileBlock(fsStore *FileFSStore, allocationID string, fileData *FileInputData, blockNum int64, numBlocks int64) ([]byte, error)
+}
+
+type FileBlockGetter struct {
+}
+
+func (FileBlockGetter) GetFileBlock(fs *FileFSStore, allocationID string, fileData *FileInputData, blockNum int64, numBlocks int64) ([]byte, error) {
+	allocation, err := fs.SetupAllocation(allocationID, true)
+	if err != nil {
+		return nil, common.NewError("invalid_allocation", "Invalid allocation. "+err.Error())
+	}
+	dirPath, destFile := GetFilePathFromHash(fileData.Hash)
+	fileObjectPath := filepath.Join(allocation.ObjectsPath, dirPath)
+	fileObjectPath = filepath.Join(fileObjectPath, destFile)
+
+	file, err := os.Open(fileObjectPath)
+	if err != nil {
+		if os.IsNotExist(err) && fileData.OnCloud {
+			err = fs.DownloadFromCloud(fileData.Hash, fileObjectPath)
+			if err != nil {
+				return nil, common.NewError("minio_download_failed", "Unable to download from minio with err "+err.Error())
+			}
+			file, err = os.Open(fileObjectPath)
+			if err != nil {
+				return nil, err
+			}
+		} else {
+			return nil, err
+		}
+	}
+	defer file.Close()
+	fileinfo, err := file.Stat()
+	if err != nil {
+		return nil, err
+	}
+
+	filesize := int(fileinfo.Size())
+	maxBlockNum := int64(filesize / CHUNK_SIZE)
+	// check for any left over bytes. Add one more go routine if required.
+	if remainder := filesize % CHUNK_SIZE; remainder != 0 {
+		maxBlockNum++
+	}
+
+	if blockNum > maxBlockNum || blockNum < 1 {
+		return nil, common.NewError("invalid_block_number", "Invalid block number")
+	}
+	buffer := make([]byte, CHUNK_SIZE*numBlocks)
+	n, err := file.ReadAt(buffer, ((blockNum - 1) * CHUNK_SIZE))
+	if err != nil && err != io.EOF {
+		return nil, err
+	}
+
+	return buffer[:n], nil
+}
+
 type FileFSStore struct {
-	RootDirectory string
-	Minio         *minio.Client
+	RootDirectory   string
+	Minio           *minio.Client
+	fileBlockGetter IFileBlockGetter
 }
 
 type StoreAllocation struct {
@@ -61,9 +118,14 @@ func SetupFSStore(rootDir string) (FileStore, error) {
 	if err := createDirs(rootDir); err != nil {
 		return nil, err
 	}
+	return SetupFSStoreI(rootDir, FileBlockGetter{})
+}
+
+func SetupFSStoreI(rootDir string, fileBlockGetter IFileBlockGetter) (FileStore, error) {
 	fsStore = &FileFSStore{
-		RootDirectory: rootDir,
-		Minio:         intializeMinio(),
+		RootDirectory:   rootDir,
+		Minio:           intializeMinio(),
+		fileBlockGetter: fileBlockGetter,
 	}
 	return fsStore, nil
 }
@@ -280,52 +342,7 @@ func (fs *FileFSStore) GetFileBlockForChallenge(allocationID string, fileData *F
 }
 
 func (fs *FileFSStore) GetFileBlock(allocationID string, fileData *FileInputData, blockNum int64, numBlocks int64) ([]byte, error) {
-	allocation, err := fs.SetupAllocation(allocationID, true)
-	if err != nil {
-		return nil, common.NewError("invalid_allocation", "Invalid allocation. "+err.Error())
-	}
-	dirPath, destFile := GetFilePathFromHash(fileData.Hash)
-	fileObjectPath := filepath.Join(allocation.ObjectsPath, dirPath)
-	fileObjectPath = filepath.Join(fileObjectPath, destFile)
-
-	file, err := os.Open(fileObjectPath)
-	if err != nil {
-		if os.IsNotExist(err) && fileData.OnCloud {
-			err = fs.DownloadFromCloud(fileData.Hash, fileObjectPath)
-			if err != nil {
-				return nil, common.NewError("minio_download_failed", "Unable to download from minio with err "+err.Error())
-			}
-			file, err = os.Open(fileObjectPath)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			return nil, err
-		}
-	}
-	defer file.Close()
-	fileinfo, err := file.Stat()
-	if err != nil {
-		return nil, err
-	}
-
-	filesize := int(fileinfo.Size())
-	maxBlockNum := int64(filesize / CHUNK_SIZE)
-	// check for any left over bytes. Add one more go routine if required.
-	if remainder := filesize % CHUNK_SIZE; remainder != 0 {
-		maxBlockNum++
-	}
-
-	if blockNum > maxBlockNum || blockNum < 1 {
-		return nil, common.NewError("invalid_block_number", "Invalid block number")
-	}
-	buffer := make([]byte, CHUNK_SIZE*numBlocks)
-	n, err := file.ReadAt(buffer, ((blockNum - 1) * CHUNK_SIZE))
-	if err != nil && err != io.EOF {
-		return nil, err
-	}
-
-	return buffer[:n], nil
+	return fs.fileBlockGetter.GetFileBlock(fs, allocationID, fileData, blockNum, numBlocks)
 }
 
 func (fs *FileFSStore) DeleteTempFile(allocationID string, fileData *FileInputData, connectionID string) error {

code/go/0chain.net/blobbercore/handler/handler.go

@@ -4,11 +4,18 @@ package handler
 
 import (
 	"context"
+	"encoding/json"
+	"errors"
 	"net/http"
 	"os"
 	"runtime/pprof"
 	"time"
 
+	"github.com/0chain/blobber/code/go/0chain.net/blobbercore/readmarker"
+	"github.com/0chain/blobber/code/go/0chain.net/blobbercore/reference"
+	"github.com/0chain/gosdk/zboxcore/fileref"
+	"gorm.io/gorm"
+
 	"go.uber.org/zap"
 
 	"github.com/0chain/blobber/code/go/0chain.net/blobbercore/config"
@@ -59,6 +66,9 @@ func SetupHandlers(r *mux.Router) {
 	r.HandleFunc("/_statsJSON", common.UserRateLimit(common.ToJSONResponse(stats.StatsJSONHandler)))
 	r.HandleFunc("/_cleanupdisk", common.UserRateLimit(common.ToJSONResponse(WithReadOnlyConnection(CleanupDiskHandler))))
 	r.HandleFunc("/getstats", common.UserRateLimit(common.ToJSONResponse(stats.GetStatsHandler)))
+
+	//marketplace related
+	r.HandleFunc("/v1/marketplace/shareinfo/{allocation}", common.UserRateLimit(common.ToJSONResponse(WithConnection(MarketPlaceShareInfoHandler))))
 }
 
 func WithReadOnlyConnection(handler common.JSONResponderF) common.JSONResponderF {
@@ -329,3 +339,138 @@ func CleanupDiskHandler(ctx context.Context, r *http.Request) (interface{}, erro
 	err := CleanupDiskFiles(ctx)
 	return "cleanup", err
 }
+
+func RevokeShare(ctx context.Context, r *http.Request) (interface{}, error) {
+	ctx = setupHandlerContext(ctx, r)
+
+	allocationID := ctx.Value(constants.ALLOCATION_CONTEXT_KEY).(string)
+	allocationObj, err := storageHandler.verifyAllocation(ctx, allocationID, true)
+	if err != nil {
+		return nil, common.NewError("invalid_parameters", "Invalid allocation id passed."+err.Error())
+	}
+
+	sign := r.Header.Get(common.ClientSignatureHeader)
+	allocation, ok := mux.Vars(r)["allocation"]
+	if !ok {
+		return false, common.NewError("invalid_params", "Missing allocation tx")
+	}
+	valid, err := verifySignatureFromRequest(allocation, sign, allocationObj.OwnerPublicKey)
+	if !valid || err != nil {
+		return nil, common.NewError("invalid_signature", "Invalid signature")
+	}
+
+	path := r.FormValue("path")
+	refereeClientID := r.FormValue("refereeClientID")
+	filePathHash := fileref.GetReferenceLookup(allocationID, path)
+	_, err = reference.GetReferenceFromLookupHash(ctx, allocationID, filePathHash)
+	if err != nil {
+		return nil, common.NewError("invalid_parameters", "Invalid file path. "+err.Error())
+	}
+	clientID := ctx.Value(constants.CLIENT_CONTEXT_KEY).(string)
+	if clientID != allocationObj.OwnerID {
+		return nil, common.NewError("invalid_operation", "Operation needs to be performed by the owner of the allocation")
+	}
+	err = reference.DeleteShareInfo(ctx, reference.ShareInfo{
+		ClientID:     refereeClientID,
+		FilePathHash: filePathHash,
+	})
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		resp := map[string]interface{}{
+			"status":  http.StatusNotFound,
+			"message": "Path not found",
+		}
+		return resp, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	resp := map[string]interface{}{
+		"status":  http.StatusNoContent,
+		"message": "Path successfully removed from allocation",
+	}
+	return resp, nil
+}
+
+func InsertShare(ctx context.Context, r *http.Request) (interface{}, error) {
+	ctx = setupHandlerContext(ctx, r)
+
+	allocationID := ctx.Value(constants.ALLOCATION_CONTEXT_KEY).(string)
+	allocationObj, err := storageHandler.verifyAllocation(ctx, allocationID, true)
+	if err != nil {
+		return nil, common.NewError("invalid_parameters", "Invalid allocation id passed."+err.Error())
+	}
+
+	sign := r.Header.Get(common.ClientSignatureHeader)
+	allocation, ok := mux.Vars(r)["allocation"]
+	if !ok {
+		return false, common.NewError("invalid_params", "Missing allocation tx")
+	}
+	valid, err := verifySignatureFromRequest(allocation, sign, allocationObj.OwnerPublicKey)
+	if !valid || err != nil {
+		return nil, common.NewError("invalid_signature", "Invalid signature")
+	}
+
+	encryptionPublicKey := r.FormValue("encryption_public_key")
+	authTicketString := r.FormValue("auth_ticket")
+	authTicket := &readmarker.AuthTicket{}
+
+	err = json.Unmarshal([]byte(authTicketString), &authTicket)
+	if err != nil {
+		return false, common.NewError("invalid_parameters", "Error parsing the auth ticket for download."+err.Error())
+	}
+
+	fileref, err := reference.GetReferenceFromLookupHash(ctx, allocationID, authTicket.FilePathHash)
+	if err != nil {
+		return nil, common.NewError("invalid_parameters", "Invalid file path. "+err.Error())
+	}
+
+	authTicketVerified, err := storageHandler.verifyAuthTicket(ctx, authTicketString, allocationObj, fileref, authTicket.ClientID)
+	if !authTicketVerified {
+		return nil, common.NewError("auth_ticket_verification_failed", "Could not verify the auth ticket. "+err.Error())
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	shareInfo := reference.ShareInfo{
+		OwnerID:                   authTicket.OwnerID,
+		ClientID:                  authTicket.ClientID,
+		FilePathHash:              authTicket.FilePathHash,
+		ReEncryptionKey:           authTicket.ReEncryptionKey,
+		ClientEncryptionPublicKey: encryptionPublicKey,
+		ExpiryAt:                  common.ToTime(authTicket.Expiration),
+	}
+
+	existingShare, err := reference.GetShareInfo(ctx, authTicket.ClientID, authTicket.FilePathHash)
+	if err != nil {
+		return nil, err
+	}
+
+	if existingShare != nil {
+		err = reference.UpdateShareInfo(ctx, shareInfo)
+	} else {
+		err = reference.AddShareInfo(ctx, shareInfo)
+	}
+	if err != nil {
+		return nil, err
+	}
+
+	resp := map[string]interface{}{
+		"message": "Share info added successfully",
+	}
+
+	return resp, nil
+}
+
+func MarketPlaceShareInfoHandler(ctx context.Context, r *http.Request) (interface{}, error) {
+	if r.Method == "DELETE" {
+		return RevokeShare(ctx, r)
+	}
+
+	if r.Method == "POST" {
+		return InsertShare(ctx, r)
+	}
+
+	return nil, errors.New("invalid request method, only POST is allowed")
+}