feat: add ops count to manifest api

ProtoconNet · May 9, 2023 · e3cefd2 · e3cefd2
1 parent a608e36
commit e3cefd2
Show file tree

Hide file tree

Showing 6 changed files with 91 additions and 32 deletions.
diff --git a/digest/block_session.go b/digest/block_session.go
@@ -150,7 +150,7 @@ func (bs *BlockSession) prepareBlock() error {
 		bs.block.Manifest().ProposedAt(),
 	)
 
-	doc, err := NewManifestDoc(manifest, bs.st.database.Encoder(), bs.block.Manifest().Height(), bs.block.SignedAt())
+	doc, err := NewManifestDoc(manifest, bs.st.database.Encoder(), bs.block.Manifest().Height(), bs.ops, bs.block.SignedAt())
 	if err != nil {
 		return err
 	}

diff --git a/digest/database.go b/digest/database.go
@@ -272,7 +272,7 @@ func (st *Database) Manifests(
 	reverse bool,
 	offset base.Height,
 	limit int64,
-	callback func(base.Height, base.Manifest) (bool, error),
+	callback func(base.Height, base.Manifest, uint64) (bool, error),
 ) error {
 	var filter bson.M
 	if offset > base.NilHeight {
@@ -305,11 +305,11 @@ func (st *Database) Manifests(
 		defaultColNameBlock,
 		filter,
 		func(cursor *mongo.Cursor) (bool, error) {
-			va, err := LoadManifest(cursor.Decode, st.database.Encoders())
+			va, ops, err := LoadManifest(cursor.Decode, st.database.Encoders())
 			if err != nil {
 				return false, err
 			}
-			return callback(va.Height(), va)
+			return callback(va.Height(), va, ops)
 		},
 		opt,
 	)
@@ -691,55 +691,59 @@ func (st *Database) currencies() ([]string, error) {
 	return cids, nil
 }
 
-func (st *Database) ManifestByHeight(height base.Height) (base.Manifest, error) {
+func (st *Database) ManifestByHeight(height base.Height) (base.Manifest, uint64, error) {
 	q := util.NewBSONFilter("height", height).D()
 
 	var m base.Manifest
+	var operations uint64
 	if err := st.database.Client().GetByFilter(
 		defaultColNameBlock,
 		q,
 		func(res *mongo.SingleResult) error {
-			v, err := LoadManifest(res.Decode, st.database.Encoders())
+			v, ops, err := LoadManifest(res.Decode, st.database.Encoders())
 			if err != nil {
 				return err
 			}
 			m = v
+			operations = ops
 			return nil
 		},
 	); err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 
 	if m != nil {
-		return m, nil
+		return m, operations, nil
 	} else {
-		return nil, errors.Errorf("manifest is nil")
+		return nil, 0, errors.Errorf("manifest is nil")
 	}
 }
 
-func (st *Database) ManifestByHash(hash mitumutil.Hash) (base.Manifest, error) {
+func (st *Database) ManifestByHash(hash mitumutil.Hash) (base.Manifest, uint64, error) {
 	q := util.NewBSONFilter("block", hash).D()
 
 	var m base.Manifest
+	var operations uint64
 	if err := st.database.Client().GetByFilter(
 		defaultColNameBlock,
 		q,
 		func(res *mongo.SingleResult) error {
-			v, err := LoadManifest(res.Decode, st.database.Encoders())
+			v, ops, err := LoadManifest(res.Decode, st.database.Encoders())
 			if err != nil {
 				return err
 			}
 			m = v
+			operations = ops
 			return nil
 		},
 	); err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 
 	if m != nil {
-		return m, nil
+		return m, operations, nil
 	} else {
-		return nil, errors.Errorf("manifest is nil")
+		return nil, 0, errors.Errorf("manifest is nil")
 	}
 }
 

diff --git a/digest/decode.go b/digest/decode.go
@@ -86,18 +86,18 @@ func LoadCurrency(decoder func(interface{}) error, encs *encoder.Encoders) (base
 	}
 }
 
-func LoadManifest(decoder func(interface{}) error, encs *encoder.Encoders) (base.Manifest, error) {
+func LoadManifest(decoder func(interface{}) error, encs *encoder.Encoders) (base.Manifest, uint64, error) {
 	var b bson.Raw
 
 	if err := decoder(&b); err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 
-	if _, hinter, err := mongodbstorage.LoadDataFromDoc(b, encs); err != nil {
-		return nil, err
+	if _, hinter, operations, err := mongodbstorage.LoadManifestDataFromDoc(b, encs); err != nil {
+		return nil, 0, err
 	} else if m, ok := hinter.(base.Manifest); !ok {
-		return nil, errors.Errorf("not base.Manifest: %T", hinter)
+		return nil, 0, errors.Errorf("not base.Manifest: %T", hinter)
 	} else {
-		return m, nil
+		return m, operations, nil
 	}
 }
diff --git a/digest/doc_manifest.go b/digest/doc_manifest.go
@@ -11,14 +11,16 @@ import (
 
 type ManifestDoc struct {
 	mongodbstorage.BaseDoc
-	va     base.Manifest
-	height base.Height
+	va         base.Manifest
+	operations []base.Operation
+	height     base.Height
 }
 
 func NewManifestDoc(
 	manifest base.Manifest,
 	enc encoder.Encoder,
 	height base.Height,
+	operations []base.Operation,
 	confirmedAt time.Time,
 ) (ManifestDoc, error) {
 	b, err := mongodbstorage.NewBaseDoc(nil, manifest, enc)
@@ -27,9 +29,10 @@ func NewManifestDoc(
 	}
 
 	return ManifestDoc{
-		BaseDoc: b,
-		va:      manifest,
-		height:  height,
+		BaseDoc:    b,
+		va:         manifest,
+		operations: operations,
+		height:     height,
 	}, nil
 }
 
@@ -40,6 +43,7 @@ func (doc ManifestDoc) MarshalBSON() ([]byte, error) {
 	}
 
 	m["block"] = doc.va.Hash()
+	m["operations"] = len(doc.operations)
 	m["height"] = doc.height
 
 	return bsonenc.Marshal(m)

diff --git a/digest/handler_manifest.go b/digest/handler_manifest.go
@@ -39,12 +39,12 @@ func (hd *Handlers) handleManifestByHeight(w http.ResponseWriter, r *http.Reques
 func (hd *Handlers) handleManifestByHeightInGroup(
 	height base.Height,
 ) ([]byte, error) {
-	m, err := hd.database.ManifestByHeight(height)
+	m, ops, err := hd.database.ManifestByHeight(height)
 	if err != nil {
 		return nil, err
 	}
 
-	hal, err := hd.buildManifestHal(m)
+	hal, err := hd.buildManifestHal(m, ops)
 	if err != nil {
 		return nil, err
 	}
@@ -76,12 +76,12 @@ func (hd *Handlers) handleManifestByHash(w http.ResponseWriter, r *http.Request)
 func (hd *Handlers) handleManifestByHashInGroup(
 	hash mitumutil.Hash,
 ) ([]byte, error) {
-	m, err := hd.database.ManifestByHash(hash)
+	m, ops, err := hd.database.ManifestByHash(hash)
 	if err != nil {
 		return nil, err
 	}
 
-	hal, err := hd.buildManifestHal(m)
+	hal, err := hd.buildManifestHal(m, ops)
 	if err != nil {
 		return nil, err
 	}
@@ -90,14 +90,22 @@ func (hd *Handlers) handleManifestByHashInGroup(
 	return b, err
 }
 
-func (hd *Handlers) buildManifestHal(manifest base.Manifest) (Hal, error) {
+func (hd *Handlers) buildManifestHal(manifest base.Manifest, ops uint64) (Hal, error) {
 	height := manifest.Height()
 
 	var hal Hal
 	h, err := hd.combineURL(HandlerPathManifestByHeight, "height", height.String())
 	if err != nil {
 		return nil, err
 	}
+
+	var m struct {
+		base.Manifest
+		Operations uint64 `json:"operations"`
+	}
+
+	m.Manifest = manifest
+	m.Operations = ops
 	hal = NewBaseHal(manifest, NewHalLink(h, nil))
 
 	// h, err = hd.combineURL(HandlerPathManifestByHash, "hash", manifest.Hash().String())
@@ -190,12 +198,12 @@ func (hd *Handlers) handleManifestsInGroup(
 	var vas []Hal
 	if err := hd.database.Manifests(
 		true, reverse, height, limit,
-		func(height base.Height, va base.Manifest) (bool, error) {
+		func(height base.Height, va base.Manifest, ops uint64) (bool, error) {
 			if height <= base.GenesisHeight {
 				return !reverse, nil
 			}
 
-			hal, err := hd.buildManifestHal(va)
+			hal, err := hd.buildManifestHal(va, ops)
 			if err != nil {
 				return false, err
 			}

diff --git a/digest/mongodb/doc_base.go b/digest/mongodb/doc_base.go
@@ -90,3 +90,46 @@ func LoadDataFromDoc(b []byte, encs *encoder.Encoders) (bson.Raw /* id */, inter
 
 	return bd.I, data, nil
 }
+
+type BaseManifestDocBSONUnMarshaler struct {
+	I bson.Raw      `bson:"_id,omitempty"`
+	E string        `bson:"_e"`
+	D bson.RawValue `bson:"d"`
+	H bool          `bson:"_hinted"`
+	O uint64        `bson:"operations"`
+}
+
+func LoadManifestDataFromDoc(b []byte, encs *encoder.Encoders) (bson.Raw /* id */, interface{} /* data */, uint64 /* operations */, error) {
+	var bd BaseManifestDocBSONUnMarshaler
+	if err := bsonenc.Unmarshal(b, &bd); err != nil {
+		return nil, nil, 0, err
+	}
+
+	ht, err := hint.ParseHint(bd.E)
+	if err != nil {
+		return nil, nil, 0, err
+	}
+
+	enc := encs.Find(ht)
+	if enc == nil {
+		return nil, nil, 0, util.ErrNotFound.Errorf("encoder not found for %q", bsonenc.BSONEncoderHint)
+	}
+
+	if !bd.H {
+		return bd.I, bd.D, 0, nil
+	}
+
+	doc, ok := bd.D.DocumentOK()
+	if !ok {
+		return nil, nil, 0, errors.Errorf("hinted should be mongodb Document")
+	}
+
+	var data interface{}
+	if i, err := enc.Decode([]byte(doc)); err != nil {
+		return nil, nil, 0, err
+	} else {
+		data = i
+	}
+
+	return bd.I, data, bd.O, nil
+}