CovenantSQL · auxten · Jan 23, 2019 · Jan 16, 2019 · Jan 16, 2019 · Jan 17, 2019
diff --git a/blockproducer/interfaces/transaction.go b/blockproducer/interfaces/transaction.go
@@ -129,6 +129,23 @@ const (
 	TransactionStateNotFound
 )
 
+func (s TransactionState) String() string {
+	switch s {
+	case TransactionStatePending:
+		return "Pending"
+	case TransactionStatePacked:
+		return "Packed"
+	case TransactionStateConfirmed:
+		return "Confirmed"
+	case TransactionStateExpired:
+		return "Expired"
+	case TransactionStateNotFound:
+		return "Not Found"
+	default:
+		return "Unknown"
+	}
+}
+
 // Transaction is the interface implemented by an object that can be verified and processed by
 // block producers.
 type Transaction interface {

diff --git a/blockproducer/metastate.go b/blockproducer/metastate.go
@@ -729,15 +729,17 @@ func (s *metaState) matchProvidersWithUser(tx *types.CreateDatabase) (err error)
 
 	// create sqlchain
 	sp := &types.SQLChainProfile{
-		ID:             dbID,
-		Address:        dbAddr,
-		Period:         sqlchainPeriod,
-		GasPrice:       tx.GasPrice,
-		TokenType:      types.Particle,
-		Owner:          sender,
-		Users:          users,
-		EncodedGenesis: enc.Bytes(),
-		Miners:         miners,
+		ID:                dbID,
+		Address:           dbAddr,
+		Period:            sqlchainPeriod,
+		GasPrice:          tx.GasPrice,
+		LastUpdatedHeight: 0,
+		TokenType:         types.Particle,
+		Owner:             sender,
+		Miners:            miners,
+		Users:             users,
+		EncodedGenesis:    enc.Bytes(),
+		Meta:              tx.ResourceMeta,
 	}
 
 	if _, loaded := s.loadSQLChainObject(dbID); loaded {

diff --git a/client/driver.go b/client/driver.go
@@ -31,6 +31,7 @@ import (
 	"github.com/CovenantSQL/CovenantSQL/conf"
 	"github.com/CovenantSQL/CovenantSQL/crypto"
 	"github.com/CovenantSQL/CovenantSQL/crypto/asymmetric"
+	"github.com/CovenantSQL/CovenantSQL/crypto/hash"
 	"github.com/CovenantSQL/CovenantSQL/crypto/kms"
 	"github.com/CovenantSQL/CovenantSQL/proto"
 	"github.com/CovenantSQL/CovenantSQL/route"
@@ -260,7 +261,7 @@ func GetTokenBalance(tt types.TokenType) (balance uint64, err error) {
 
 // UpdatePermission sends UpdatePermission transaction to chain.
 func UpdatePermission(targetUser proto.AccountAddress,
-	targetChain proto.AccountAddress, perm types.UserPermission) (err error) {
+	targetChain proto.AccountAddress, perm types.UserPermission) (txHash hash.Hash, err error) {
 	if atomic.LoadUint32(&driverInitialized) == 0 {
 		err = ErrNotInitialized
 		return
@@ -307,11 +308,14 @@ func UpdatePermission(targetUser proto.AccountAddress,
 		return
 	}
 
+	txHash = up.Hash()
 	return
 }
 
 // TransferToken send Transfer transaction to chain.
-func TransferToken(targetUser proto.AccountAddress, amount uint64, tokenType types.TokenType) (err error) {
+func TransferToken(targetUser proto.AccountAddress, amount uint64, tokenType types.TokenType) (
+	txHash hash.Hash, err error,
+) {
 	if atomic.LoadUint32(&driverInitialized) == 0 {
 		err = ErrNotInitialized
 		return
@@ -359,6 +363,53 @@ func TransferToken(targetUser proto.AccountAddress, amount uint64, tokenType typ
 		return
 	}
 
+	txHash = tran.Hash()
+	return
+}
+
+// WaitTxConfirmation waits for the transaction with target hash txHash to be confirmed. It also
+// returns if any error occurs or a final state is returned from BP.
+func WaitTxConfirmation(
+	ctx context.Context, txHash hash.Hash) (state interfaces.TransactionState, err error,
+) {
+	var (
+		ticker = time.NewTicker(1 * time.Second)
+		method = route.MCCQueryTxState
+		req    = &types.QueryTxStateReq{Hash: txHash}
+		resp   = &types.QueryTxStateResp{}
+	)
+	defer ticker.Stop()
+	for {
+		if err = requestBP(method, req, resp); err != nil {
+			err = errors.Wrapf(err, "failed to call %s", method)
+			return
+		}
+
+		state = resp.State
+		log.WithFields(log.Fields{
+			"tx_hash":  txHash,
+			"tx_state": state,
+		}).Debug("waiting for tx confirmation")
+
+		switch state {
+		case interfaces.TransactionStatePending:
+		case interfaces.TransactionStatePacked:
+		case interfaces.TransactionStateConfirmed,
+			interfaces.TransactionStateExpired,
+			interfaces.TransactionStateNotFound:
+			return
+		default:
+			err = errors.Errorf("unknown transaction state %d", state)
+			return
+		}
+
+		select {
+		case <-ticker.C:
+		case <-ctx.Done():
+			err = ctx.Err()
+			return
+		}
+	}
 	return
 }
 

diff --git a/client/helper_test.go b/client/helper_test.go
@@ -18,6 +18,7 @@ package client
 
 import (
 	"bytes"
+	"database/sql"
 	"fmt"
 	"io/ioutil"
 	"math/rand"
@@ -149,8 +150,11 @@ func startTestService() (stopTestService func(), tempDir string, err error) {
 	req = new(types.UpdateService)
 	req.Header.Op = types.CreateDB
 	req.Header.Instance = types.ServiceInstance{
-		DatabaseID:   dbID,
-		Peers:        peers,
+		DatabaseID: dbID,
+		Peers:      peers,
+		ResourceMeta: types.ResourceMeta{
+			IsolationLevel: int(sql.LevelReadUncommitted),
+		},
 		GenesisBlock: block,
 	}
 	if req.Header.Signee, err = kms.GetLocalPublicKey(); err != nil {

diff --git a/client/tx.go b/client/tx.go
@@ -21,6 +21,8 @@ import (
 	"context"
 	"database/sql"
 	"database/sql/driver"
+
+	"github.com/pkg/errors"
 )
 
 // ExecuteTx starts a transaction, and runs fn in it
@@ -39,11 +41,11 @@ func ExecuteTx(
 func ExecuteInTx(tx driver.Tx, fn func() error) (err error) {
 	err = fn()
 	if err == nil {
-		// Ignore commit errors. The tx has already been committed by RELEASE.
 		err = tx.Commit()
+		if err != nil {
+			err = errors.Wrapf(err, "exec in tx")
+		}
 	} else {
-		// We always need to execute a Rollback() so sql.DB releases the
-		// connection.
 		_ = tx.Rollback()
 	}
 	return

diff --git a/cmd/cql-fuse/block.go b/cmd/cql-fuse/block.go
@@ -40,7 +40,7 @@ import (
 
 // BlockSize is the size of each data block. It must not
 // change throughout the lifetime of the filesystem.
-const BlockSize = 4 << 10 // 4KB
+const BlockSize = 128 << 10 // 128KB
 
 func min(a, b uint64) uint64 {
 	if a < b {

diff --git a/cmd/cql-fuse/block_test.go b/cmd/cql-fuse/block_test.go
@@ -423,6 +423,9 @@ func TestShrinkGrow(t *testing.T) {
 	if data, err = tryGrow(db, data, id, BlockSize*5); err != nil {
 		log.Fatal(err)
 	}
+	if data, err = tryGrow(db, data, id, BlockSize*999); err != nil {
+		log.Fatal(err)
+	}
 
 	// Shrink it down to 0.
 	if data, err = tryShrink(db, data, id, 0); err != nil {

diff --git a/cmd/cql-fuse/main.go b/cmd/cql-fuse/main.go
@@ -80,18 +80,24 @@ import (
 )
 
 var usage = func() {
-	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
-	fmt.Fprintf(os.Stderr, "  %s -config <config> -dsn <dsn> -mount <mountpoint>\n\n", os.Args[0])
+	_, _ = fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
+	_, _ = fmt.Fprintf(os.Stderr, "  %s -config <config> -dsn <dsn> -mount <mountpoint>\n\n", os.Args[0])
 	flag.PrintDefaults()
 }
 
 func main() {
-	var config, dsn, mountPoint, password string
-
+	var (
+		config     string
+		dsn        string
+		mountPoint string
+		password   string
+		readOnly   bool
+	)
 	flag.StringVar(&config, "config", "./conf/config.yaml", "config file path")
 	flag.StringVar(&mountPoint, "mount", "./", "dir to mount")
 	flag.StringVar(&dsn, "dsn", "", "database url")
 	flag.StringVar(&password, "password", "", "master key password for covenantsql")
+	flag.BoolVar(&readOnly, "readonly", false, "mount read only volume")
 	flag.Usage = usage
 	flag.Parse()
 
@@ -102,11 +108,12 @@ func main() {
 		log.Fatal(err)
 	}
 
+	cfg, err := client.ParseDSN(dsn)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	db, err := sql.Open("covenantsql", dsn)
+	db, err := sql.Open("covenantsql", cfg.FormatDSN())
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -118,13 +125,18 @@ func main() {
 	}
 
 	cfs := CFS{db}
+	opts := make([]fuse.MountOption, 0, 5)
+	opts = append(opts, fuse.FSName("CovenantFS"))
+	opts = append(opts, fuse.Subtype("CovenantFS"))
+	opts = append(opts, fuse.LocalVolume())
+	opts = append(opts, fuse.VolumeName(cfg.DatabaseID))
+	if readOnly {
+		opts = append(opts, fuse.ReadOnly())
+	}
 	// Mount filesystem.
 	c, err := fuse.Mount(
 		mountPoint,
-		fuse.FSName("CovenantFS"),
-		fuse.Subtype("CovenantFS"),
-		fuse.LocalVolume(),
-		fuse.VolumeName(""),
+		opts...,
 	)
 	if err != nil {
 		log.Fatal(err)

diff --git a/cmd/cql-minerd/bench.sh b/cmd/cql-minerd/bench.sh
@@ -8,4 +8,10 @@ go test -bench=^BenchmarkMinerOneNoSign$ -benchtime=10s -run ^$ && \
 go test -bench=^BenchmarkMinerTwo$ -benchtime=10s -run ^$ && \
 go test -bench=^BenchmarkMinerTwoNoSign$ -benchtime=10s -run ^$ && \
 go test -bench=^BenchmarkMinerThree$ -benchtime=10s -run ^$ && \
-go test -bench=^BenchmarkMinerThreeNoSign$ -benchtime=10s -run ^$
+go test -bench=^BenchmarkMinerThreeNoSign$ -benchtime=10s -run ^$ && \
+go test -bench=^BenchmarkMinerOneWithEventualConsistency$ -benchtime=10s -run ^$ && \
+go test -bench=^BenchmarkMinerOneNoSignWithEventualConsistency$ -benchtime=10s -run ^$ && \
+go test -bench=^BenchmarkMinerTwoWithEventualConsistency$ -benchtime=10s -run ^$ && \
+go test -bench=^BenchmarkMinerTwoNoSignWithEventualConsistency$ -benchtime=10s -run ^$ && \
+go test -bench=^BenchmarkMinerThreeWithEventualConsistency$ -benchtime=10s -run ^$ && \
+go test -bench=^BenchmarkMinerThreeNoSignWithEventualConsistency$ -benchtime=10s -run ^$