Mirroristas/kaspad
2
0
Fork 0
mirror of https://github.com/kaspanet/kaspad.git synced 2025-03-30 15:08:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

[NOD-1488] Get rid of dbaccess (#973)

Browse Source 
* [NOD-1488] Get rid of dbaccess

* [NOD-1488] Rename dbwrapper to dbmanager

* [NOD-1488] Create DBWriter interface

* [NOD-1488] Fix block header store

* [NOD-1488] Rename dbwrapper.go to dbmanager.go
This commit is contained in:
Ori Newman 2020-10-28 02:34:06 -07:00 committed by GitHub
parent 4fbe130592
commit be56fb7e8b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
37 changed files with 218 additions and 167 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
domain/consensus/database/dbcontext.go
View File

@ -1,34 +0,0 @@
package database
import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
)
// DomainDBContext is a proxy over a dbaccess.DatabaseContext
type DomainDBContext struct {
dbContext *dbaccess.DatabaseContext
}
// FetchBlockRelation retrieves the BlockRelation for the given blockHash
func (ddc *DomainDBContext) FetchBlockRelation(blockHash *externalapi.DomainHash) (*model.BlockRelations, error) {
// TODO: return dbaccess.FetchBlockRelations(ddc.dbContext, blockHash)
return nil, nil
}
// NewTx returns an instance of DomainTxContext with a new database transaction
func (ddc *DomainDBContext) NewTx() (*DomainTxContext, error) {
txContext, err := ddc.dbContext.NewTx()
if err != nil {
return nil, err
}
return NewDomainTxContext(txContext), nil
}
// NewDomainDBContext creates a new DomainDBContext
func NewDomainDBContext(dbContext *dbaccess.DatabaseContext) *DomainDBContext {
return &DomainDBContext{dbContext: dbContext}
}

28
domain/consensus/database/txcontext.go
View File

@ -1,28 +0,0 @@
package database
import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
)
// DomainTxContext is a proxy over a dbaccess.TxContext
type DomainTxContext struct {
dbTx *dbaccess.TxContext
}
// StoreBlockRelation stores the given BlockRelation
func (dtc *DomainTxContext) StoreBlockRelation(blockHash *externalapi.DomainHash, blockRelationData *model.BlockRelations) error {
// TODO: return dbaccess.StoreBlockRelation(ddc.dbTx, blockHash, blockRelationData)
return nil
}
// NewDomainTxContext creates a new DomainTXContext
func NewDomainTxContext(dbTx *dbaccess.TxContext) *DomainTxContext {
return &DomainTxContext{dbTx: dbTx}
}
// Commit commits this database transaction
func (dtc *DomainTxContext) Commit() error {
return dtc.dbTx.Commit()
}

6
domain/consensus/datastructures/acceptancedatastore/acceptancedatastore.go
View File

@ -27,16 +27,16 @@ func (ads *acceptanceDataStore) Discard() {
panic("implement me")
}
func (ads *acceptanceDataStore) Commit(dbTx model.DBTxProxy) error {
func (ads *acceptanceDataStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// Get gets the acceptanceData associated with the given blockHash
func (ads *acceptanceDataStore) Get(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) ([]*model.BlockAcceptanceData, error) {
func (ads *acceptanceDataStore) Get(dbContext model.DBReader, blockHash *externalapi.DomainHash) ([]*model.BlockAcceptanceData, error) {
return nil, nil
}
// Delete deletes the acceptanceData associated with the given blockHash
func (ads *acceptanceDataStore) Delete(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash) error {
func (ads *acceptanceDataStore) Delete(dbTx model.DBTransaction, blockHash *externalapi.DomainHash) error {
return nil
}

10
domain/consensus/datastructures/blockheaderstore/blockheaderstore.go
View File

@ -27,26 +27,26 @@ func (bms *blockHeaderStore) Discard() {
panic("implement me")
}
func (bms *blockHeaderStore) Commit(dbTx model.DBTxProxy) error {
func (bms *blockHeaderStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// BlockHeader gets the block header associated with the given blockHash
func (bms *blockHeaderStore) BlockHeader(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (*externalapi.DomainBlockHeader, error) {
func (bms *blockHeaderStore) BlockHeader(dbContext model.DBReader, blockHash *externalapi.DomainHash) (*externalapi.DomainBlockHeader, error) {
panic("implement me")
}
// HasBlock returns whether a block header with a given hash exists in the store.
func (bms *blockHeaderStore) HasBlockHeader(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (bool, error) {
func (bms *blockHeaderStore) HasBlockHeader(dbContext model.DBReader, blockHash *externalapi.DomainHash) (bool, error) {
panic("implement me")
}
// BlockHeaders gets the block headers associated with the given blockHashes
func (bms *blockHeaderStore) BlockHeaders(dbContext model.DBContextProxy, blockHashes []*externalapi.DomainHash) ([]*externalapi.DomainBlockHeader, error) {
func (bms *blockHeaderStore) BlockHeaders(dbContext model.DBReader, blockHashes []*externalapi.DomainHash) ([]*externalapi.DomainBlockHeader, error) {
panic("implement me")
}
// Delete deletes the block associated with the given blockHash
func (bms *blockHeaderStore) Delete(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash) error {
func (bms *blockHeaderStore) Delete(dbTx model.DBTransaction, blockHash *externalapi.DomainHash) error {
panic("implement me")
}

6
domain/consensus/datastructures/blockrelationstore/blockrelationstore.go
View File

@ -30,14 +30,14 @@ func (brs *blockRelationStore) Discard() {
panic("implement me")
}
func (brs *blockRelationStore) Commit(dbTx model.DBTxProxy) error {
func (brs *blockRelationStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
func (brs *blockRelationStore) BlockRelation(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (*model.BlockRelations, error) {
func (brs *blockRelationStore) BlockRelation(dbContext model.DBReader, blockHash *externalapi.DomainHash) (*model.BlockRelations, error) {
panic("implement me")
}
func (brs *blockRelationStore) Tips(dbContext model.DBContextProxy) ([]*externalapi.DomainHash, error) {
func (brs *blockRelationStore) Tips(dbContext model.DBReader) ([]*externalapi.DomainHash, error) {
panic("implement me")
}

6
domain/consensus/datastructures/blockstatusstore/blockstatusstore.go
View File

@ -27,16 +27,16 @@ func (bss *blockStatusStore) Discard() {
panic("implement me")
}
func (bss *blockStatusStore) Commit(dbTx model.DBTxProxy) error {
func (bss *blockStatusStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// Get gets the blockStatus associated with the given blockHash
func (bss *blockStatusStore) Get(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (model.BlockStatus, error) {
func (bss *blockStatusStore) Get(dbContext model.DBReader, blockHash *externalapi.DomainHash) (model.BlockStatus, error) {
return 0, nil
}
// Exists returns true if the blockStatus for the given blockHash exists
func (bss *blockStatusStore) Exists(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (bool, error) {
func (bss *blockStatusStore) Exists(dbContext model.DBReader, blockHash *externalapi.DomainHash) (bool, error) {
return false, nil
}

10
domain/consensus/datastructures/blockstore/blockstore.go
View File

@ -27,26 +27,26 @@ func (bms *blockStore) Discard() {
panic("implement me")
}
func (bms *blockStore) Commit(dbTx model.DBTxProxy) error {
func (bms *blockStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// Block gets the block associated with the given blockHash
func (bms *blockStore) Block(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, error) {
func (bms *blockStore) Block(dbContext model.DBReader, blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, error) {
panic("implement me")
}
// HasBlock returns whether a block with a given hash exists in the store.
func (bms *blockStore) HasBlock(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (bool, error) {
func (bms *blockStore) HasBlock(dbContext model.DBReader, blockHash *externalapi.DomainHash) (bool, error) {
panic("implement me")
}
// Blocks gets the blocks associated with the given blockHashes
func (bms *blockStore) Blocks(dbContext model.DBContextProxy, blockHashes []*externalapi.DomainHash) ([]*externalapi.DomainBlock, error) {
func (bms *blockStore) Blocks(dbContext model.DBReader, blockHashes []*externalapi.DomainHash) ([]*externalapi.DomainBlock, error) {
panic("implement me")
}
// Delete deletes the block associated with the given blockHash
func (bms *blockStore) Delete(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash) error {
func (bms *blockStore) Delete(dbTx model.DBTransaction, blockHash *externalapi.DomainHash) error {
panic("implement me")
}

4
domain/consensus/datastructures/consensusstatestore/consensusstatestore.go
View File

@ -27,11 +27,11 @@ func (css *consensusStateStore) Discard() {
panic("implement me")
}
func (css *consensusStateStore) Commit(dbTx model.DBTxProxy) error {
func (css *consensusStateStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// UTXOByOutpoint gets the utxoEntry associated with the given outpoint
func (css *consensusStateStore) UTXOByOutpoint(dbContext model.DBContextProxy, outpoint *externalapi.DomainOutpoint) (*externalapi.UTXOEntry, error) {
func (css *consensusStateStore) UTXOByOutpoint(dbContext model.DBReader, outpoint *externalapi.DomainOutpoint) (*externalapi.UTXOEntry, error) {
return nil, nil
}

4
domain/consensus/datastructures/ghostdagdatastore/ghostdagdatastore.go
View File

@ -27,11 +27,11 @@ func (gds *ghostdagDataStore) Discard() {
panic("implement me")
}
func (gds *ghostdagDataStore) Commit(dbTx model.DBTxProxy) error {
func (gds *ghostdagDataStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// Get gets the blockGHOSTDAGData associated with the given blockHash
func (gds *ghostdagDataStore) Get(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (*model.BlockGHOSTDAGData, error) {
func (gds *ghostdagDataStore) Get(dbContext model.DBReader, blockHash *externalapi.DomainHash) (*model.BlockGHOSTDAGData, error) {
return nil, nil
}

6
domain/consensus/datastructures/multisetstore/multisetstore.go
View File

@ -27,16 +27,16 @@ func (ms *multisetStore) Discard() {
panic("implement me")
}
func (ms *multisetStore) Commit(dbTx model.DBTxProxy) error {
func (ms *multisetStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// Get gets the multiset associated with the given blockHash
func (ms *multisetStore) Get(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (model.Multiset, error) {
func (ms *multisetStore) Get(dbContext model.DBReader, blockHash *externalapi.DomainHash) (model.Multiset, error) {
return nil, nil
}
// Delete deletes the multiset associated with the given blockHash
func (ms *multisetStore) Delete(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash) error {
func (ms *multisetStore) Delete(dbTx model.DBTransaction, blockHash *externalapi.DomainHash) error {
return nil
}

6
domain/consensus/datastructures/pruningstore/pruningstore.go
View File

@ -27,16 +27,16 @@ func (pps *pruningStore) Discard() {
panic("implement me")
}
func (pps *pruningStore) Commit(dbTx model.DBTxProxy) error {
func (pps *pruningStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// PruningPoint gets the current pruning point
func (pps *pruningStore) PruningPoint(dbContext model.DBContextProxy) (*externalapi.DomainHash, error) {
func (pps *pruningStore) PruningPoint(dbContext model.DBReader) (*externalapi.DomainHash, error) {
return nil, nil
}
// PruningPointSerializedUTXOSet returns the serialized UTXO set of the current pruning point
func (pps *pruningStore) PruningPointSerializedUTXOSet(dbContext model.DBContextProxy) ([]byte, error) {
func (pps *pruningStore) PruningPointSerializedUTXOSet(dbContext model.DBReader) ([]byte, error) {
return nil, nil
}

6
domain/consensus/datastructures/reachabilitydatastore/reachabilitydatastore.go
View File

@ -32,18 +32,18 @@ func (rds *reachabilityDataStore) Discard() {
panic("implement me")
}
func (rds *reachabilityDataStore) Commit(dbTx model.DBTxProxy) error {
func (rds *reachabilityDataStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// ReachabilityData returns the reachabilityData associated with the given blockHash
func (rds *reachabilityDataStore) ReachabilityData(dbContext model.DBContextProxy,
func (rds *reachabilityDataStore) ReachabilityData(dbContext model.DBReader,
blockHash *externalapi.DomainHash) (*model.ReachabilityData, error) {
panic("implement me")
}
// ReachabilityReindexRoot returns the current reachability reindex root
func (rds *reachabilityDataStore) ReachabilityReindexRoot(dbContext model.DBContextProxy) (*externalapi.DomainHash, error) {
func (rds *reachabilityDataStore) ReachabilityReindexRoot(dbContext model.DBReader) (*externalapi.DomainHash, error) {
panic("implement me")
}

8
domain/consensus/datastructures/utxodiffstore/utxodiffstore.go
View File

@ -27,21 +27,21 @@ func (uds *utxoDiffStore) Discard() {
panic("implement me")
}
func (uds *utxoDiffStore) Commit(dbTx model.DBTxProxy) error {
func (uds *utxoDiffStore) Commit(dbTx model.DBTransaction) error {
panic("implement me")
}
// UTXODiff gets the utxoDiff associated with the given blockHash
func (uds *utxoDiffStore) UTXODiff(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (*model.UTXODiff, error) {
func (uds *utxoDiffStore) UTXODiff(dbContext model.DBReader, blockHash *externalapi.DomainHash) (*model.UTXODiff, error) {
return nil, nil
}
// UTXODiffChild gets the utxoDiff child associated with the given blockHash
func (uds *utxoDiffStore) UTXODiffChild(dbContext model.DBContextProxy, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error) {
func (uds *utxoDiffStore) UTXODiffChild(dbContext model.DBReader, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error) {
return nil, nil
}
// Delete deletes the utxoDiff associated with the given blockHash
func (uds *utxoDiffStore) Delete(dbTx model.DBTxProxy, blockHash *externalapi.DomainHash) error {
func (uds *utxoDiffStore) Delete(dbTx model.DBTransaction, blockHash *externalapi.DomainHash) error {
return nil
}

35
domain/consensus/dbmanager/dbmanager.go Normal file
View File

@ -0,0 +1,35 @@
package dbmanager
import (
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/infrastructure/db/database"
)
type dbManager struct {
db database.Database
}
func (dbw *dbManager) Get(key model.DBKey) ([]byte, error) {
panic("unimplemented")
}
func (dbw *dbManager) Has(key model.DBKey) (bool, error) {
panic("unimplemented")
}
func (dbw *dbManager) Delete(key model.DBKey) error {
panic("unimplemented")
}
func (dbw *dbManager) Cursor(bucket model.DBBucket) (model.DBCursor, error) {
panic("unimplemented")
}
func (dbw *dbManager) Begin() (model.DBTransaction, error) {
panic("unimplemented")
}
// New returns wraps the given database as an instance of model.DBManager
func New(db database.Database) model.DBManager {
return &dbManager{db: db}
}

26
domain/consensus/factory.go
View File

@ -1,7 +1,6 @@
package consensus
import (
"github.com/kaspanet/kaspad/domain/consensus/database"
"github.com/kaspanet/kaspad/domain/consensus/datastructures/acceptancedatastore"
"github.com/kaspanet/kaspad/domain/consensus/datastructures/blockheaderstore"
"github.com/kaspanet/kaspad/domain/consensus/datastructures/blockrelationstore"
@ -13,6 +12,7 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/datastructures/pruningstore"
"github.com/kaspanet/kaspad/domain/consensus/datastructures/reachabilitydatastore"
"github.com/kaspanet/kaspad/domain/consensus/datastructures/utxodiffstore"
"github.com/kaspanet/kaspad/domain/consensus/dbmanager"
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/consensus/processes/blockprocessor"
@ -28,18 +28,18 @@ import (
"github.com/kaspanet/kaspad/domain/consensus/processes/reachabilitytree"
"github.com/kaspanet/kaspad/domain/consensus/processes/transactionvalidator"
"github.com/kaspanet/kaspad/domain/dagconfig"
"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
"github.com/kaspanet/kaspad/infrastructure/db/database"
)
// Factory instantiates new Consensuses
type Factory interface {
NewConsensus(dagParams *dagconfig.Params, databaseContext *dbaccess.DatabaseContext) Consensus
NewConsensus(dagParams *dagconfig.Params, db database.Database) Consensus
}
type factory struct{}
// NewConsensus instantiates a new Consensus
func (f *factory) NewConsensus(dagParams *dagconfig.Params, databaseContext *dbaccess.DatabaseContext) Consensus {
func (f *factory) NewConsensus(dagParams *dagconfig.Params, db database.Database) Consensus {
// Data Structures
acceptanceDataStore := acceptancedatastore.New()
blockStore := blockstore.New()
@ -53,23 +53,23 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, databaseContext *dba
consensusStateStore := consensusstatestore.New()
ghostdagDataStore := ghostdagdatastore.New()
domainDBContext := database.NewDomainDBContext(databaseContext)
dbManager := dbmanager.New(db)
// Processes
reachabilityTree := reachabilitytree.New(
blockRelationStore,
reachabilityDataStore)
dagTopologyManager := dagtopologymanager.New(
domainDBContext,
dbManager,
reachabilityTree,
blockRelationStore)
ghostdagManager := ghostdagmanager.New(
databaseContext,
dbManager,
dagTopologyManager,
ghostdagDataStore,
model.KType(dagParams.K))
dagTraversalManager := dagtraversalmanager.New(
domainDBContext,
dbManager,
dagTopologyManager,
ghostdagDataStore)
pruningManager := pruningmanager.New(
@ -79,7 +79,7 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, databaseContext *dba
blockStatusStore,
consensusStateStore)
consensusStateManager := consensusstatemanager.New(
domainDBContext,
dbManager,
dagParams,
ghostdagManager,
dagTopologyManager,
@ -97,11 +97,11 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, databaseContext *dba
ghostdagManager)
pastMedianTimeManager := pastmediantimemanager.New(
dagParams.TimestampDeviationTolerance,
domainDBContext,
dbManager,
dagTraversalManager,
blockHeaderStore)
transactionValidator := transactionvalidator.New(dagParams.BlockCoinbaseMaturity,
domainDBContext,
dbManager,
pastMedianTimeManager,
ghostdagDataStore)
coinbaseManager := coinbasemanager.New(
@ -117,7 +117,7 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, databaseContext *dba
dagParams.DifficultyAdjustmentWindowSize,
uint64(dagParams.FinalityDuration/dagParams.TargetTimePerBlock),
domainDBContext,
dbManager,
consensusStateManager,
difficultyManager,
pastMedianTimeManager,
@ -132,7 +132,7 @@ func (f *factory) NewConsensus(dagParams *dagconfig.Params, databaseContext *dba
)
blockProcessor := blockprocessor.New(
dagParams,
domainDBContext,
dbManager,
consensusStateManager,
pruningManager,
blockValidator,

97
domain/consensus/model/database.go
View File

@ -1,14 +1,97 @@
package model
import "github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
// DBCursor iterates over database entries given some bucket.
type DBCursor interface {
// Next moves the iterator to the next key/value pair. It returns whether the
// iterator is exhausted. Panics if the cursor is closed.
Next() bool
// DBContextProxy defines a proxy over domain data access
type DBContextProxy interface {
FetchBlockRelation(blockHash *externalapi.DomainHash) (*BlockRelations, error)
// First moves the iterator to the first key/value pair. It returns false if
// such a pair does not exist. Panics if the cursor is closed.
First() bool
// Seek moves the iterator to the first key/value pair whose key is greater
// than or equal to the given key. It returns ErrNotFound if such pair does not
// exist.
Seek(key DBKey) error
// Key returns the key of the current key/value pair, or ErrNotFound if done.
// The caller should not modify the contents of the returned key, and
// its contents may change on the next call to Next.
Key() (DBKey, error)
// Value returns the value of the current key/value pair, or ErrNotFound if done.
// The caller should not modify the contents of the returned slice, and its
// contents may change on the next call to Next.
Value() ([]byte, error)
// Close releases associated resources.
Close() error
}
// DBTxProxy is a proxy over domain data
// DBReader defines a proxy over domain data access
type DBReader interface {
// Get gets the value for the given key. It returns
// ErrNotFound if the given key does not exist.
Get(key DBKey) ([]byte, error)
// Has returns true if the database does contains the
// given key.
Has(key DBKey) (bool, error)
// Cursor begins a new cursor over the given bucket.
Cursor(bucket DBBucket) (DBCursor, error)
}
// DBWriter is an interface to write to the database
type DBWriter interface {
// Put sets the value for the given key. It overwrites
// any previous value for that key.
Put(key []byte, value []byte) error
// Delete deletes the value for the given key. Will not
// return an error if the key doesn't exist.
Delete(key []byte) error
}
// DBTransaction is a proxy over domain data
// access that requires an open database transaction
type DBTxProxy interface {
StoreBlockRelation(blockHash *externalapi.DomainHash, blockRelationData *BlockRelations) error
type DBTransaction interface {
DBWriter
// Rollback rolls back whatever changes were made to the
// database within this transaction.
Rollback() error
// Commit commits whatever changes were made to the database
// within this transaction.
Commit() error
// RollbackUnlessClosed rolls back changes that were made to
// the database within the transaction, unless the transaction
// had already been closed using either Rollback or Commit.
RollbackUnlessClosed() error
}
// DBManager defines the interface of a database that can begin
// transactions and read data.
type DBManager interface {
DBReader
// Begin begins a new database transaction.
Begin() (DBTransaction, error)
}
// DBKey is an interface for a database key
type DBKey interface {
Bytes() []byte
Bucket() DBBucket
Suffix() []byte
}
// DBBucket is an interface for a database bucket
type DBBucket interface {
Bucket(bucketBytes []byte) DBBucket
Key() DBKey
Path() []byte
}

4
domain/consensus/model/interface_datastructures_acceptancedatastore.go
View File

@ -7,6 +7,6 @@ type AcceptanceDataStore interface {
Store
Stage(blockHash *externalapi.DomainHash, acceptanceData []*BlockAcceptanceData)
IsStaged() bool
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) ([]*BlockAcceptanceData, error)
Delete(dbTx DBTxProxy, blockHash *externalapi.DomainHash) error
Get(dbContext DBReader, blockHash *externalapi.DomainHash) ([]*BlockAcceptanceData, error)
Delete(dbTx DBTransaction, blockHash *externalapi.DomainHash) error
}

8
domain/consensus/model/interface_datastructures_blockheaderstore.go
View File

@ -7,8 +7,8 @@ type BlockHeaderStore interface {
Store
Stage(blockHash *externalapi.DomainHash, blockHeader *externalapi.DomainBlockHeader)
IsStaged() bool
BlockHeader(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*externalapi.DomainBlockHeader, error)
HasBlockHeader(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (bool, error)
BlockHeaders(dbContext DBContextProxy, blockHashes []*externalapi.DomainHash) ([]*externalapi.DomainBlockHeader, error)
Delete(dbTx DBTxProxy, blockHash *externalapi.DomainHash) error
BlockHeader(dbContext DBReader, blockHash *externalapi.DomainHash) (*externalapi.DomainBlockHeader, error)
HasBlockHeader(dbContext DBReader, blockHash *externalapi.DomainHash) (bool, error)
BlockHeaders(dbContext DBReader, blockHashes []*externalapi.DomainHash) ([]*externalapi.DomainBlockHeader, error)
Delete(dbTx DBTransaction, blockHash *externalapi.DomainHash) error
}

4
domain/consensus/model/interface_datastructures_blockrelationstore.go
View File

@ -8,6 +8,6 @@ type BlockRelationStore interface {
StageBlockRelation(blockHash *externalapi.DomainHash, parentHashes []*externalapi.DomainHash)
StageTips(tipHashess []*externalapi.DomainHash)
IsAnythingStaged() bool
BlockRelation(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*BlockRelations, error)
Tips(dbContext DBContextProxy) ([]*externalapi.DomainHash, error)
BlockRelation(dbContext DBReader, blockHash *externalapi.DomainHash) (*BlockRelations, error)
Tips(dbContext DBReader) ([]*externalapi.DomainHash, error)
}

4
domain/consensus/model/interface_datastructures_blockstatusstore.go
View File

@ -7,6 +7,6 @@ type BlockStatusStore interface {
Store
Stage(blockHash *externalapi.DomainHash, blockStatus BlockStatus)
IsStaged() bool
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (BlockStatus, error)
Exists(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (bool, error)
Get(dbContext DBReader, blockHash *externalapi.DomainHash) (BlockStatus, error)
Exists(dbContext DBReader, blockHash *externalapi.DomainHash) (bool, error)
}

8
domain/consensus/model/interface_datastructures_blockstore.go
View File

@ -7,8 +7,8 @@ type BlockStore interface {
Store
Stage(blockHash *externalapi.DomainHash, block *externalapi.DomainBlock)
IsStaged() bool
Block(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, error)
HasBlock(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (bool, error)
Blocks(dbContext DBContextProxy, blockHashes []*externalapi.DomainHash) ([]*externalapi.DomainBlock, error)
Delete(dbTx DBTxProxy, blockHash *externalapi.DomainHash) error
Block(dbContext DBReader, blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, error)
HasBlock(dbContext DBReader, blockHash *externalapi.DomainHash) (bool, error)
Blocks(dbContext DBReader, blockHashes []*externalapi.DomainHash) ([]*externalapi.DomainBlock, error)
Delete(dbTx DBTransaction, blockHash *externalapi.DomainHash) error
}

2
domain/consensus/model/interface_datastructures_consensusstatestore.go
View File

@ -7,5 +7,5 @@ type ConsensusStateStore interface {
Store
Stage(consensusStateChanges *ConsensusStateChanges)
IsStaged() bool
UTXOByOutpoint(dbContext DBContextProxy, outpoint *externalapi.DomainOutpoint) (*externalapi.UTXOEntry, error)
UTXOByOutpoint(dbContext DBReader, outpoint *externalapi.DomainOutpoint) (*externalapi.UTXOEntry, error)
}

2
domain/consensus/model/interface_datastructures_ghostdagdatastore.go
View File

@ -7,5 +7,5 @@ type GHOSTDAGDataStore interface {
Store
Stage(blockHash *externalapi.DomainHash, blockGHOSTDAGData *BlockGHOSTDAGData)
IsStaged() bool
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*BlockGHOSTDAGData, error)
Get(dbContext DBReader, blockHash *externalapi.DomainHash) (*BlockGHOSTDAGData, error)
}

4
domain/consensus/model/interface_datastructures_multisetstore.go
View File

@ -7,6 +7,6 @@ type MultisetStore interface {
Store
Stage(blockHash *externalapi.DomainHash, multiset Multiset)
IsStaged() bool
Get(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (Multiset, error)
Delete(dbTx DBTxProxy, blockHash *externalapi.DomainHash) error
Get(dbContext DBReader, blockHash *externalapi.DomainHash) (Multiset, error)
Delete(dbTx DBTransaction, blockHash *externalapi.DomainHash) error
}

4
domain/consensus/model/interface_datastructures_pruningstore.go
View File

@ -7,6 +7,6 @@ type PruningStore interface {
Store
Stage(pruningPointBlockHash *externalapi.DomainHash, pruningPointUTXOSet ReadOnlyUTXOSet)
IsStaged() bool
PruningPoint(dbContext DBContextProxy) (*externalapi.DomainHash, error)
PruningPointSerializedUTXOSet(dbContext DBContextProxy) ([]byte, error)
PruningPoint(dbContext DBReader) (*externalapi.DomainHash, error)
PruningPointSerializedUTXOSet(dbContext DBReader) ([]byte, error)
}

4
domain/consensus/model/interface_datastructures_reachabilitydatastore.go
View File

@ -8,6 +8,6 @@ type ReachabilityDataStore interface {
StageReachabilityData(blockHash *externalapi.DomainHash, reachabilityData *ReachabilityData)
StageReachabilityReindexRoot(reachabilityReindexRoot *externalapi.DomainHash)
IsAnythingStaged() bool
ReachabilityData(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*ReachabilityData, error)
ReachabilityReindexRoot(dbContext DBContextProxy) (*externalapi.DomainHash, error)
ReachabilityData(dbContext DBReader, blockHash *externalapi.DomainHash) (*ReachabilityData, error)
ReachabilityReindexRoot(dbContext DBReader) (*externalapi.DomainHash, error)
}

6
domain/consensus/model/interface_datastructures_utxodiffstore.go
View File

@ -7,7 +7,7 @@ type UTXODiffStore interface {
Store
Stage(blockHash *externalapi.DomainHash, utxoDiff *UTXODiff, utxoDiffChild *externalapi.DomainHash)
IsStaged() bool
UTXODiff(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*UTXODiff, error)
UTXODiffChild(dbContext DBContextProxy, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error)
Delete(dbTx DBTxProxy, blockHash *externalapi.DomainHash) error
UTXODiff(dbContext DBReader, blockHash *externalapi.DomainHash) (*UTXODiff, error)
UTXODiffChild(dbContext DBReader, blockHash *externalapi.DomainHash) (*externalapi.DomainHash, error)
Delete(dbTx DBTransaction, blockHash *externalapi.DomainHash) error
}

2
domain/consensus/model/store.go
View File

@ -3,5 +3,5 @@ package model
// Store is a common interface for data stores
type Store interface {
Discard()
Commit(dbTx DBTxProxy) error
Commit(dbTx DBTransaction) error
}

5
domain/consensus/processes/blockprocessor/blockprocessor.go
View File

@ -1,7 +1,6 @@
package blockprocessor
import (
"github.com/kaspanet/kaspad/domain/consensus/database"
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/dagconfig"
@ -12,7 +11,7 @@ import (
// and creating blocks from the current state
type blockProcessor struct {
dagParams *dagconfig.Params
databaseContext *database.DomainDBContext
databaseContext model.DBManager
consensusStateManager model.ConsensusStateManager
pruningManager model.PruningManager
@ -42,7 +41,7 @@ type blockProcessor struct {
// New instantiates a new BlockProcessor
func New(
dagParams *dagconfig.Params,
databaseContext *database.DomainDBContext,
databaseContext model.DBManager,
consensusStateManager model.ConsensusStateManager,
pruningManager model.PruningManager,
blockValidator model.BlockValidator,

2
domain/consensus/processes/blockprocessor/validateandinsertblock.go
View File

@ -93,7 +93,7 @@ func (bp *blockProcessor) discardAllChanges() {
}
func (bp *blockProcessor) commitAllChanges() error {
dbTx, err := bp.databaseContext.NewTx()
dbTx, err := bp.databaseContext.Begin()
if err != nil {
return err
}

4
domain/consensus/processes/blockvalidator/blockvalidator.go
View File

@ -19,7 +19,7 @@ type blockValidator struct {
difficultyAdjustmentWindowSize uint64
finalityDepth uint64
databaseContext model.DBContextProxy
databaseContext model.DBReader
consensusStateManager model.ConsensusStateManager
difficultyManager model.DifficultyManager
pastMedianTimeManager model.PastMedianTimeManager
@ -41,7 +41,7 @@ func New(powMax *big.Int,
disableDifficultyAdjustment bool,
difficultyAdjustmentWindowSize uint64,
finalityDepth uint64,
databaseContext model.DBContextProxy,
databaseContext model.DBReader,
consensusStateManager model.ConsensusStateManager,
difficultyManager model.DifficultyManager,

5
domain/consensus/processes/consensusstatemanager/consensusstatemanager.go
View File

@ -1,7 +1,6 @@
package consensusstatemanager
import (
"github.com/kaspanet/kaspad/domain/consensus/database"
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
"github.com/kaspanet/kaspad/domain/dagconfig"
@ -10,7 +9,7 @@ import (
// consensusStateManager manages the node's consensus state
type consensusStateManager struct {
dagParams *dagconfig.Params
databaseContext *database.DomainDBContext
databaseContext model.DBReader
ghostdagManager model.GHOSTDAGManager
dagTopologyManager model.DAGTopologyManager
@ -29,7 +28,7 @@ type consensusStateManager struct {
// New instantiates a new ConsensusStateManager
func New(
databaseContext *database.DomainDBContext,
databaseContext model.DBReader,
dagParams *dagconfig.Params,
ghostdagManager model.GHOSTDAGManager,
dagTopologyManager model.DAGTopologyManager,

5
domain/consensus/processes/dagtopologymanager/dagtopologymanager.go
View File

@ -1,7 +1,6 @@
package dagtopologymanager
import (
"github.com/kaspanet/kaspad/domain/consensus/database"
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
)
@ -11,12 +10,12 @@ import (
type dagTopologyManager struct {
reachabilityTree model.ReachabilityTree
blockRelationStore model.BlockRelationStore
databaseContext *database.DomainDBContext
databaseContext model.DBReader
}
// New instantiates a new DAGTopologyManager
func New(
databaseContext *database.DomainDBContext,
databaseContext model.DBReader,
reachabilityTree model.ReachabilityTree,
blockRelationStore model.BlockRelationStore) model.DAGTopologyManager {

4
domain/consensus/processes/dagtraversalmanager/dagtraversalmanager.go
View File

@ -8,7 +8,7 @@ import (
// dagTraversalManager exposes methods for travering blocks
// in the DAG
type dagTraversalManager struct {
databaseContext model.DBContextProxy
databaseContext model.DBReader
dagTopologyManager model.DAGTopologyManager
ghostdagDataStore model.GHOSTDAGDataStore
@ -16,7 +16,7 @@ type dagTraversalManager struct {
// New instantiates a new DAGTraversalManager
func New(
databaseContext model.DBContextProxy,
databaseContext model.DBReader,
dagTopologyManager model.DAGTopologyManager,
ghostdagDataStore model.GHOSTDAGDataStore) model.DAGTraversalManager {
return &dagTraversalManager{

8
domain/consensus/processes/ghostdagmanager/ghostdagmanager.go
View File

@ -1,14 +1,12 @@
package ghostdagmanager
import (
"github.com/kaspanet/kaspad/domain/consensus/database"
"github.com/kaspanet/kaspad/domain/consensus/model"
"github.com/kaspanet/kaspad/infrastructure/db/dbaccess"
)
// ghostdagManager resolves and manages GHOSTDAG block data
type ghostdagManager struct {
databaseContext *database.DomainDBContext
databaseContext model.DBReader
dagTopologyManager model.DAGTopologyManager
ghostdagDataStore model.GHOSTDAGDataStore
k model.KType
@ -16,13 +14,13 @@ type ghostdagManager struct {
// New instantiates a new GHOSTDAGManager
func New(
databaseContext *dbaccess.DatabaseContext,
databaseContext model.DBReader,
dagTopologyManager model.DAGTopologyManager,
ghostdagDataStore model.GHOSTDAGDataStore,
k model.KType) model.GHOSTDAGManager {
return &ghostdagManager{
databaseContext: database.NewDomainDBContext(databaseContext),
databaseContext: databaseContext,
dagTopologyManager: dagTopologyManager,
ghostdagDataStore: ghostdagDataStore,
k: k,

4
domain/consensus/processes/pastmediantimemanager/pastmediantimemanager.go
View File

@ -12,7 +12,7 @@ import (
type pastMedianTimeManager struct {
timestampDeviationTolerance uint64
databaseContext model.DBContextProxy
databaseContext model.DBReader
dagTraversalManager model.DAGTraversalManager
@ -21,7 +21,7 @@ type pastMedianTimeManager struct {
// New instantiates a new PastMedianTimeManager
func New(timestampDeviationTolerance uint64,
databaseContext model.DBContextProxy,
databaseContext model.DBReader,
dagTraversalManager model.DAGTraversalManager,
blockHeaderStore model.BlockHeaderStore) model.PastMedianTimeManager {
return &pastMedianTimeManager{

4
domain/consensus/processes/transactionvalidator/transactionvalidator.go
View File

@ -8,14 +8,14 @@ import (
// it's possible to determine whether either a transaction is valid
type transactionValidator struct {
blockCoinbaseMaturity uint64
databaseContext model.DBContextProxy
databaseContext model.DBReader
pastMedianTimeManager model.PastMedianTimeManager
ghostdagDataStore model.GHOSTDAGDataStore
}
// New instantiates a new TransactionValidator
func New(blockCoinbaseMaturity uint64,
databaseContext model.DBContextProxy,
databaseContext model.DBReader,
pastMedianTimeManager model.PastMedianTimeManager,
ghostdagDataStore model.GHOSTDAGDataStore) model.TransactionValidator {
return &transactionValidator{blockCoinbaseMaturity: blockCoinbaseMaturity,