filterdb: add FilterData type

Add a new FilterData type that encapsulates the filter, blockhash and
type associated with a filter. This is done in order to prepare for a
commit that will enable batch writes of these filters.

Author: ellemouton

filterdb/db.go

@@ -34,15 +34,27 @@ const (
 	RegularFilter FilterType = iota
 )
 
+// FilterData holds all the info about a filter required to store it.
+type FilterData struct {
+	// Filter is the actual filter to be stored.
+	Filter *gcs.Filter
+
+	// BlockHash is the block header hash of the block associated with the
+	// Filter.
+	BlockHash *chainhash.Hash
+
+	// Type is the filter type.
+	Type FilterType
+}
+
 // FilterDatabase is an interface which represents an object that is capable of
 // storing and retrieving filters according to their corresponding block hash
 // and also their filter type.
 //
 // TODO(roasbeef): similar interface for headerfs?
 type FilterDatabase interface {
-	// PutFilter stores a filter with the given hash and type to persistent
-	// storage.
-	PutFilter(*chainhash.Hash, *gcs.Filter, FilterType) error
+	// PutFilter stores a filter to persistent storage.
+	PutFilter(*FilterData) error
 
 	// FetchFilter attempts to fetch a filter with the given hash and type
 	// from persistent storage. In the case that a filter matching the
@@ -155,30 +167,22 @@ func putFilter(bucket walletdb.ReadWriteBucket, hash *chainhash.Hash,
 // storage.
 //
 // NOTE: This method is a part of the FilterDatabase interface.
-func (f *FilterStore) PutFilter(hash *chainhash.Hash,
-	filter *gcs.Filter, fType FilterType) error {
-
+func (f *FilterStore) PutFilter(filterData *FilterData) error {
 	return walletdb.Update(f.db, func(tx walletdb.ReadWriteTx) error {
 		filters := tx.ReadWriteBucket(filterBucket)
 
 		var targetBucket walletdb.ReadWriteBucket
-		switch fType {
+		switch filterData.Type {
 		case RegularFilter:
 			targetBucket = filters.NestedReadWriteBucket(regBucket)
 		default:
-			return fmt.Errorf("unknown filter type: %v", fType)
+			return fmt.Errorf("unknown filter type: %v",
+				filterData.Type)
 		}
 
-		if filter == nil {
-			return targetBucket.Put(hash[:], nil)
-		}
-
-		bytes, err := filter.NBytes()
-		if err != nil {
-			return err
-		}
-
-		return targetBucket.Put(hash[:], bytes)
+		return putFilter(
+			targetBucket, filterData.BlockHash, filterData.Filter,
+		)
 	})
 }
 

filterdb/db_test.go

@@ -86,7 +86,13 @@ func TestFilterStorage(t *testing.T) {
 	// type for the block hash generate above.
 	regFilter := genRandFilter(t, 100)
 
-	err = database.PutFilter(&randHash, regFilter, RegularFilter)
+	filter := &FilterData{
+		Filter:    regFilter,
+		BlockHash: &randHash,
+		Type:      RegularFilter,
+	}
+
+	err = database.PutFilter(filter)
 	require.NoError(t, err)
 
 	// With the filter stored, we should be able to retrieve the filter

query.go

@@ -534,9 +534,13 @@ func (q *cfiltersQuery) handleResponse(req, resp wire.Message,
 	}
 
 	if q.cs.persistToDisk {
-		err = q.cs.FilterDB.PutFilter(
-			&response.BlockHash, filter, dbFilterType,
-		)
+		filterData := &filterdb.FilterData{
+			Filter:    filter,
+			BlockHash: &response.BlockHash,
+			Type:      dbFilterType,
+		}
+
+		err = q.cs.FilterDB.PutFilter(filterData)
 		if err != nil {
 			log.Warnf("Couldn't write filter to filterDB: %v", err)
 		}