Operation index for target

Author: kfangw

go.mod

@@ -30,7 +30,7 @@ require (
 	github.com/nullstyle/go-xdr v0.0.0-20170810174627-a875e7c9fa23 // indirect
 	github.com/nvellon/hal v0.3.0
 	github.com/oklog/run v1.0.0
-	github.com/onsi/ginkgo v1.6.0 // indirect
+	github.com/onsi/ginkgo v1.6.0
 	github.com/onsi/gomega v1.4.1 // indirect
 	github.com/pkg/errors v0.8.0
 	github.com/pmezard/go-difflib v1.0.0 // indirect

lib/block/operation.go

@@ -32,6 +32,7 @@ type BlockOperation struct {
 
 	// transaction will be used only for `Save` time.
 	transaction transaction.Transaction
+	operation   operation.Operation
 	isSaved     bool
 }
 
@@ -60,6 +61,7 @@ func NewBlockOperationFromOperation(op operation.Operation, tx transaction.Trans
 		Height: blockHeight,
 
 		transaction: tx,
+		operation:   op,
 	}, nil
 }
 
@@ -87,27 +89,35 @@ func (bo *BlockOperation) Save(st *storage.LevelDBBackend) (err error) {
 		return
 	}
 
+	targetEvent := ""
+	if pop, ok := bo.operation.B.(operation.Payable); ok {
+		target := pop.TargetAddress()
+		if err = st.New(bo.NewBlockOperationTargetKey(target), bo.Hash); err != nil {
+			return
+		}
+		if err = st.New(bo.NewBlockOperationTargetAndTypeKey(target), bo.Hash); err != nil {
+			return
+		}
+		targetEvent += " " + fmt.Sprintf("target-%s", target)
+		targetEvent += " " + fmt.Sprintf("target-type-%s%s", target, bo.Type)
+	}
+
 	if err = st.New(bo.NewBlockOperationSourceAndTypeKey(), bo.Hash); err != nil {
 		return
 	}
 
-	var body operation.Body
-	var casted operation.CreateAccount
-	var ok bool
-
+	frozenEvent := ""
 	if bo.Type == operation.TypeCreateAccount {
-		if body, err = operation.UnmarshalBodyJSON(bo.Type, bo.Body); err != nil {
-			return err
-		}
-		if casted, ok = body.(operation.CreateAccount); !ok {
-			return errors.TypeOperationBodyNotMatched
-		}
-		if casted.Linked != "" {
-			if err = st.New(GetBlockOperationCreateFrozenKey(casted.Target, bo.Height), bo.Hash); err != nil {
-				return err
-			}
-			if err = st.New(bo.NewBlockOperationFrozenLinkedKey(casted.Linked), bo.Hash); err != nil {
-				return err
+		if createAccount, ok := bo.operation.B.(*operation.CreateAccount); ok {
+			if createAccount.Linked != "" {
+				if err = st.New(GetBlockOperationCreateFrozenKey(createAccount.Target, bo.Height), bo.Hash); err != nil {
+					return err
+				}
+				if err = st.New(bo.NewBlockOperationFrozenLinkedKey(createAccount.Linked), bo.Hash); err != nil {
+					return err
+				}
+				frozenEvent += " " + "frozen"
+				frozenEvent += " " + fmt.Sprintf("linked-%s", createAccount.Linked)
 			}
 		}
 	}
@@ -119,9 +129,8 @@ func (bo *BlockOperation) Save(st *storage.LevelDBBackend) (err error) {
 	event += " " + fmt.Sprintf("hash-%s", bo.Hash)
 	event += " " + fmt.Sprintf("txhash-%s", bo.TxHash)
 	event += " " + fmt.Sprintf("source-type-%s%s", bo.Source, bo.Type)
-	if casted.Linked != "" {
-		event += " frozen"
-		event += " " + fmt.Sprintf("linked-%s", casted.Linked)
+	if len(frozenEvent) > 0 {
+		event += frozenEvent
 	}
 	observer.BlockOperationObserver.Trigger(event, bo)
 
@@ -162,10 +171,18 @@ func GetBlockOperationKeyPrefixSource(source string) string {
 	return fmt.Sprintf("%s%s-", common.BlockOperationPrefixSource, source)
 }
 
+func GetBlockOperationKeyPrefixTarget(target string) string {
+	return fmt.Sprintf("%s%s-", common.BlockOperationPrefixTarget, target)
+}
+
 func GetBlockOperationKeyPrefixSourceAndType(source string, ty operation.OperationType) string {
 	return fmt.Sprintf("%s%s%s-", common.BlockOperationPrefixSource, source, string(ty))
 }
 
+func GetBlockOperationKeyPrefixTargetAndType(target string, ty operation.OperationType) string {
+	return fmt.Sprintf("%s%s%s-", common.BlockOperationPrefixTarget, target, string(ty))
+}
+
 func (bo BlockOperation) NewBlockOperationTxHashKey() string {
 	return fmt.Sprintf(
 		"%s%s%s%s",
@@ -204,6 +221,26 @@ func (bo BlockOperation) NewBlockOperationSourceAndTypeKey() string {
 	)
 }
 
+func (bo BlockOperation) NewBlockOperationTargetKey(target string) string {
+	return fmt.Sprintf(
+		"%s%s%s%s",
+		GetBlockOperationKeyPrefixTarget(target),
+		common.EncodeUint64ToByteSlice(bo.Height),
+		common.EncodeUint64ToByteSlice(bo.transaction.B.SequenceID),
+		common.GetUniqueIDFromUUID(),
+	)
+}
+
+func (bo BlockOperation) NewBlockOperationTargetAndTypeKey(target string) string {
+	return fmt.Sprintf(
+		"%s%s%s%s",
+		GetBlockOperationKeyPrefixTargetAndType(target, bo.Type),
+		common.EncodeUint64ToByteSlice(bo.Height),
+		common.EncodeUint64ToByteSlice(bo.transaction.B.SequenceID),
+		common.GetUniqueIDFromUUID(),
+	)
+}
+
 func ExistsBlockOperation(st *storage.LevelDBBackend, hash string) (bool, error) {
 	return st.Has(GetBlockOperationKey(hash))
 }
@@ -289,3 +326,20 @@ func GetBlockOperationsBySourceAndType(st *storage.LevelDBBackend, source string
 	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixSourceAndType(source, ty), options)
 	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
 }
+
+func GetBlockOperationsByTarget(st *storage.LevelDBBackend, target string, options storage.ListOptions) (
+	func() (BlockOperation, bool, []byte),
+	func(),
+) {
+	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixTarget(target), options)
+
+	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
+}
+
+func GetBlockOperationsByTargetAndType(st *storage.LevelDBBackend, target string, ty operation.OperationType, options storage.ListOptions) (
+	func() (BlockOperation, bool, []byte),
+	func(),
+) {
+	iterFunc, closeFunc := st.GetIterator(GetBlockOperationKeyPrefixTargetAndType(target, ty), options)
+	return LoadBlockOperationsInsideIterator(st, iterFunc, closeFunc)
+}

lib/node/runner/api/operation.go

@@ -39,34 +39,55 @@ func (api NetworkHandlerAPI) GetOperationsByAccountHandler(w http.ResponseWriter
 
 		var iterFunc func() (block.BlockOperation, bool, []byte)
 		var closeFunc func()
-		if len(oType) > 0 {
-			iterFunc, closeFunc = block.GetBlockOperationsBySourceAndType(api.storage, address, oType, options)
-		} else {
-			iterFunc, closeFunc = block.GetBlockOperationsBySource(api.storage, address, options)
+		{
+			if len(oType) > 0 {
+				iterFunc, closeFunc = block.GetBlockOperationsBySourceAndType(api.storage, address, oType, options)
+			} else {
+				iterFunc, closeFunc = block.GetBlockOperationsBySource(api.storage, address, options)
+			}
+			for {
+				t, hasNext, c := iterFunc()
+				cursor = c
+				if !hasNext {
+					break
+				}
+				txs = append(txs, resource.NewOperation(&t))
+			}
+			closeFunc()
 		}
-		for {
-			t, hasNext, c := iterFunc()
-			cursor = c
-			if !hasNext {
-				break
+		{
+			if len(oType) > 0 {
+				iterFunc, closeFunc = block.GetBlockOperationsByTargetAndType(api.storage, address, oType, options)
+			} else {
+				iterFunc, closeFunc = block.GetBlockOperationsByTarget(api.storage, address, options)
+			}
+			for {
+				t, hasNext, c := iterFunc()
+				cursor = c
+				if !hasNext {
+					break
+				}
+				txs = append(txs, resource.NewOperation(&t))
 			}
-			txs = append(txs, resource.NewOperation(&t))
+			closeFunc()
 		}
-		closeFunc()
 		return txs
 	}
 
 	if httputils.IsEventStream(r) {
-		event := fmt.Sprintf("source-%s", address)
+		var events []string
+		events = append(events, fmt.Sprintf("source-%s", address))
+		events = append(events, fmt.Sprintf("target-%s", address))
 		if len(oType) > 0 {
-			event = fmt.Sprintf("source-type-%s%s", address, oType)
+			events = append(events, fmt.Sprintf("source-type-%s%s", address, oType))
+			events = append(events, fmt.Sprintf("target-type-%s%s", address, oType))
 		}
 		es := NewEventStream(w, r, renderEventStream, DefaultContentType)
 		txs := readFunc()
 		for _, tx := range txs {
 			es.Render(tx)
 		}
-		es.Run(observer.BlockOperationObserver, event)
+		es.Run(observer.BlockOperationObserver, events...)
 		return
 	}