New simplified User ReadPool related changes (#685)

* Updated related methods for new simplified read-pool * fixed lint error Co-authored-by: dabasov <yuderbasov@gmail.com>

Author: iamrz1

code/go/0chain.net/blobbercore/allocation/entity.go

@@ -193,13 +193,13 @@ func (Terms) TableName() string {
 return TableNameTerms
 }
 
+// ReadPool represents new trimmed down readPool consisting of two balances,
+// one for the allocations that the client (client_id) owns
+// and the other for the allocations that the client (client_id) doesn't own
 type ReadPool struct {
-PoolID string `gorm:"column:pool_id;size:64;primaryKey"`
-ClientID string `gorm:"column:client_id;size:64;not null;index:idx_read_pools_cab,priority:1"`
-AllocationID string `gorm:"column:allocation_id;size:64;not null;index:idx_read_pools_cab,priority:2"`
-// Cached balance in read pool. Might need update when balance - pending is less than 0
-Balance int64 `gorm:"column:balance;not null"`
-ExpireAt common.Timestamp `gorm:"column:expire_at;not null"`
+ClientID string `gorm:"column:client_id;size:64;primaryKey" json:"client_id"`
+OwnerBalance int64 `gorm:"column:owner_balance;not null" json:"owner_balance"`
+VisitorBalance int64 `gorm:"column:visitor_balance;not null" json:"visitor_balance"`
 }
 
 func (ReadPool) TableName() string {
@@ -218,57 +218,42 @@ func (WritePool) TableName() string {
 return "write_pools"
 }
 
-func GetReadPools(db *gorm.DB, allocationID, clientID string, until common.Timestamp) (rps []*ReadPool, err error) {
-err = db.Model(&ReadPool{}).Select("pool_id", "balance", "expire_at").
-Where(
-"allocation_id = ? AND "+
-"client_id = ? AND "+
-"expire_at > ?", allocationID, clientID, until).Find(&rps).Error
-
-if err != nil {
-return nil, err
-}
-return
+func GetReadPool(db *gorm.DB, clientID string) (*ReadPool, error) {
+var rp ReadPool
+return &rp, db.Model(&ReadPool{}).Where("client_id = ?", clientID).Scan(&rp).Error
 }
 
-func GetReadPoolsBalance(db *gorm.DB, allocationID, clientID string, until common.Timestamp) (balance int64, err error) {
-var b *int64 // pointer to int64 for possible total sum as null
-err = db.Model(&ReadPool{}).Select("sum(balance) as tot_balance").Where(
-"client_id = ? AND "+
-"allocation_id = ? AND "+
-"expire_at > ?", clientID, allocationID, until).Scan(&b).Error
-
+func GetReadPoolsBalance(db *gorm.DB, clientID string, isOwner bool) (int64, error) {
+rp, err := GetReadPool(db, clientID)
 if err != nil {
 return 0, err
 }
-if b == nil {
-return 0, nil
+
+if isOwner {
+return rp.OwnerBalance, nil
 }
-return *b, nil
+return rp.VisitorBalance, nil
 }
 
-func SetReadPools(db *gorm.DB, clientID, allocationID string, rps []*ReadPool) (err error) {
-// cleanup and batch insert (remove old pools, add / update new)
-const query = `client_id = ? AND
-allocation_id = ?`
-
-var stub []*ReadPool
-err = db.Model(&ReadPool{}).
-Where(query, clientID, allocationID).
-Delete(&stub).Error
+func SetReadPool(db *gorm.DB, rp *ReadPool) error {
+var erp ReadPool //find existing read pool
+err := db.Model(&ReadPool{}).Where("client_id = ?", rp.ClientID).FirstOrCreate(&erp, rp).Error
 if err != nil {
-return
+return err
 }
 
-if len(rps) == 0 {
-return
+if erp.OwnerBalance == rp.OwnerBalance && erp.VisitorBalance == rp.VisitorBalance {
+return nil
 }
+// update existing
+return UpdateReadPool(db, rp)
+}
 
-err = db.Model(&ReadPool{}).Clauses(clause.OnConflict{
-Columns: []clause.Column{{Name: "pool_id"}},
-DoUpdates: clause.AssignmentColumns([]string{"balance"}),
-}).Create(rps).Error
-return
+func UpdateReadPool(db *gorm.DB, rp *ReadPool) error {
+return db.Model(&ReadPool{}).Where("client_id = ?", rp.ClientID).Updates(map[string]interface{}{
+"owner_balance": rp.OwnerBalance,
+"visitor_balance": rp.VisitorBalance,
+}).Error
 }
 
 func SetWritePools(db *gorm.DB, clientID, allocationID string, wps []*WritePool) (err error) {
@@ -302,18 +287,3 @@ type ReadPoolRedeem struct {
 PoolID string `json:"pool_id"` // read pool ID
 Balance int64 `json:"balance"` // balance reduction
 }
-
-// SubReadRedeemed subtracts tokens redeemed from read pools.
-func SubReadRedeemed(rps []*ReadPool, redeems []ReadPoolRedeem) {
-var rm = make(map[string]int64)
-
-for _, rd := range redeems {
-rm[rd.PoolID] += rd.Balance
-}
-
-for _, rp := range rps {
-if sub, ok := rm[rp.PoolID]; ok {
-rp.Balance -= sub
-}
-}
-}

code/go/0chain.net/blobbercore/allocation/protocol.go

@@ -5,7 +5,6 @@ import (
 "encoding/json"
 "errors"
 "fmt"
-
 "github.com/0chain/blobber/code/go/0chain.net/blobbercore/datastore"
 "github.com/0chain/blobber/code/go/0chain.net/blobbercore/filestore"
 "github.com/0chain/blobber/code/go/0chain.net/core/chain"
@@ -193,47 +192,23 @@ type PoolStat struct {
 ExpireAt common.Timestamp `json:"expire_at"`
 }
 
-func RequestReadPools(clientID, allocationID string) (rps []*ReadPool, err error) {
+func RequestReadPoolStat(clientID string) (*ReadPool, error) {
 Logger.Info("request read pools")
 
-var (
-blobberID = node.Self.ID
-resp []byte
-)
-
 params := map[string]string{
-"client_id": clientID,
-"allocation_id": allocationID,
-"blobber_id": blobberID,
+"client_id": clientID,
 }
-resp, err = transaction.MakeSCRestAPICall(transaction.STORAGE_CONTRACT_ADDRESS, "/getReadPoolAllocBlobberStat", params, chain.GetServerChain())
+resp, err := transaction.MakeSCRestAPICall(transaction.STORAGE_CONTRACT_ADDRESS, "/getReadPoolStat", params, chain.GetServerChain())
 if err != nil {
 return nil, fmt.Errorf("requesting read pools stat: %v", err)
 }
 
-var pss []*PoolStat
-if err = json.Unmarshal(resp, &pss); err != nil {
-return nil, fmt.Errorf("decoding read pools stat response: %v", err)
+var readPool ReadPool
+if err = json.Unmarshal(resp, &readPool); err != nil {
+return nil, fmt.Errorf("decoding read pools stat response: %v, \n==> resp: %s", err, string(resp))
 }
 
-if len(pss) == 0 {
-return nil, nil // empty
-}
-
-rps = make([]*ReadPool, 0, len(pss))
-for _, ps := range pss {
-rps = append(rps, &ReadPool{
-PoolID: ps.PoolID,
-
-ClientID: clientID,
-AllocationID: allocationID,
-
-Balance: ps.Balance,
-ExpireAt: ps.ExpireAt,
-})
-}
-
-return // got them
+return &readPool, nil
 }
 
 func RequestWritePools(clientID, allocationID string) (wps []*WritePool, err error) {

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

@@ -498,8 +498,8 @@ func InsertShare(ctx context.Context, r *http.Request) (interface{}, error) {
 FilePathHash: authTicket.FilePathHash,
 ReEncryptionKey: authTicket.ReEncryptionKey,
 ClientEncryptionPublicKey: encryptionPublicKey,
-ExpiryAt: common.ToTime(authTicket.Expiration),
-AvailableAt: common.ToTime(availableAt),
+ExpiryAt: common.ToTime(authTicket.Expiration).UTC(),
+AvailableAt: common.ToTime(availableAt).UTC(),
 }
 
 existingShare, _ := reference.GetShareInfo(ctx, authTicket.ClientID, authTicket.FilePathHash)

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

@@ -6,10 +6,8 @@ import (
 "encoding/json"
 "errors"
 "fmt"
-
 "github.com/0chain/blobber/code/go/0chain.net/blobbercore/blobberhttp"
 "github.com/0chain/blobber/code/go/0chain.net/blobbercore/stats"
-
 "net/http"
 "path/filepath"
 "strconv"
@@ -52,45 +50,41 @@ func readPreRedeem(ctx context.Context, alloc *allocation.Allocation, numBlocks,
 var (
 db = datastore.GetStore().GetTransaction(ctx)
 blobberID = node.Self.ID
-until = common.Now() + common.Timestamp(config.Configuration.ReadLockTimeout)
-
-rps []*allocation.ReadPool
 )
 
 if alloc.GetRequiredReadBalance(blobberID, numBlocks) <= 0 {
 return // skip if read price is zero
 }
 
-readPoolsBalance, err := allocation.GetReadPoolsBalance(db, alloc.ID, payerID, until)
+isOwner := alloc.OwnerID == payerID
+readPoolsBalance, err := allocation.GetReadPoolsBalance(db, payerID, isOwner)
 if err != nil {
 return common.NewError("read_pre_redeem", "database error while reading read pools balance")
 }
 
 requiredBalance := alloc.GetRequiredReadBalance(blobberID, numBlocks+pendNumBlocks)
 
 if float64(readPoolsBalance) < requiredBalance {
-rps, err = allocation.RequestReadPools(payerID, alloc.ID)
+rp, err := allocation.RequestReadPoolStat(payerID)
 if err != nil {
 return common.NewErrorf("read_pre_redeem", "can't request read pools from sharders: %v", err)
 }
 
-err = allocation.SetReadPools(db, payerID, alloc.ID, rps)
+rp.ClientID = payerID
+err = allocation.UpdateReadPool(db, rp)
 if err != nil {
 return common.NewErrorf("read_pre_redeem", "can't save requested read pools: %v", err)
 }
 
-readPoolsBalance = 0
-for _, rp := range rps {
-if rp.ExpireAt < until {
-continue
-}
-readPoolsBalance += rp.Balance
+if isOwner {
+readPoolsBalance = rp.OwnerBalance
+} else {
+readPoolsBalance = rp.VisitorBalance
 }
 
 if float64(readPoolsBalance) < requiredBalance {
-return common.NewError("read_pre_redeem", "not enough "+
-"tokens in client's read pools associated with the"+
-" allocation->blobber")
+return common.NewError("read_pre_redeem",
+"not enough tokens in client's read pools associated with the allocation->blobber")
 }
 }