// New creates the internal data structures, and subscribes to // consensus for changes to the blockchain func New(cs modules.ConsensusSet, persistDir string) (*Explorer, error) { // Check that input modules are non-nil if cs == nil { return nil, errNilCS } // Initialize the explorer. e := &Explorer{ currentBlock: cs.GenesisBlock(), genesisBlockID: cs.GenesisBlock().ID(), seenTimes: make([]time.Time, types.MaturityDelay+1), startTime: time.Now(), cs: cs, persistDir: persistDir, } e.blockchainHeight-- // Set to -1 so the genesis block sets the height to 0. // Intialize the persistent structures, including the database. err := e.initPersist() if err != nil { return nil, err } cs.ConsensusSetSubscribe(e) return e, nil }
// New creates the internal data structures, and subscribes to // consensus for changes to the blockchain func New(cs modules.ConsensusSet, persistDir string) (*Explorer, error) { // Check that input modules are non-nil if cs == nil { return nil, errNilCS } // Initialize the explorer. e := &Explorer{ blocksDifficulty: types.RootDepth, blockHashes: make(map[types.BlockID]types.BlockHeight), blockTargets: make(map[types.BlockID]types.Target), transactionHashes: make(map[types.TransactionID]types.BlockHeight), unlockHashes: make(map[types.UnlockHash]map[types.TransactionID]struct{}), siacoinOutputIDs: make(map[types.SiacoinOutputID]map[types.TransactionID]struct{}), siacoinOutputs: make(map[types.SiacoinOutputID]types.SiacoinOutput), fileContractIDs: make(map[types.FileContractID]map[types.TransactionID]struct{}), fileContractHistories: make(map[types.FileContractID]*fileContractHistory), siafundOutputIDs: make(map[types.SiafundOutputID]map[types.TransactionID]struct{}), siafundOutputs: make(map[types.SiafundOutputID]types.SiafundOutput), cs: cs, persistDir: persistDir, } e.blockchainHeight-- // Set to -1 so the genesis block sets the height to 0. // Intialize the persistent structures, including the database. err := e.initPersist() if err != nil { return nil, err } cs.ConsensusSetSubscribe(e) return e, nil }
// New creates a transaction pool that is ready to receive transactions. func New(cs modules.ConsensusSet, g modules.Gateway) (*TransactionPool, error) { // Check that the input modules are non-nil. if cs == nil { return nil, errNilCS } if g == nil { return nil, errNilGateway } // Initialize a transaction pool. tp := &TransactionPool{ consensusSet: cs, gateway: g, knownObjects: make(map[ObjectID]TransactionSetID), transactionSets: make(map[TransactionSetID][]types.Transaction), transactionSetDiffs: make(map[TransactionSetID]modules.ConsensusChange), // The consensus change index is intialized to '-1', which indicates // that no consensus changes have been sent yet. The first consensus // change will then have an index of '0'. consensusChangeIndex: -1, mu: sync.New(modules.SafeMutexDelay, 5), } // Register RPCs g.RegisterRPC("RelayTransactionSet", tp.RelayTransactionSet) g.RegisterRPC("RelayTransaction", tp.RelayTransaction) // COMPAT v0.3.3.3 // Subscribe the transaction pool to the consensus set. cs.ConsensusSetSubscribe(tp) return tp, nil }
// New creates the internal data structures, and subscribes to // consensus for changes to the blockchain func New(cs modules.ConsensusSet, persistDir string) (*Explorer, error) { // Check that input modules are non-nil if cs == nil { return nil, errNilCS } // Initialize the explorer. e := &Explorer{ cs: cs, persistDir: persistDir, } // Initialize the persistent structures, including the database. err := e.initPersist() if err != nil { return nil, err } // retrieve the current ConsensusChangeID var recentChange modules.ConsensusChangeID err = e.db.View(dbGetInternal(internalRecentChange, &recentChange)) if err != nil { return nil, err } err = cs.ConsensusSetSubscribe(e, recentChange) if err != nil { // TODO: restart from 0 return nil, errors.New("explorer subscription failed: " + err.Error()) } return e, nil }
// newAnnouncementFinder will create and return an announcement finder. func newAnnouncementFinder(cs modules.ConsensusSet) (*announcementFinder, error) { af := &announcementFinder{ cs: cs, } err := cs.ConsensusSetSubscribe(af, modules.ConsensusChangeBeginning) if err != nil { return nil, err } return af, nil }
// New returns an empty renter. func New(cs modules.ConsensusSet, hdb modules.HostDB, wallet modules.Wallet, tpool modules.TransactionPool, persistDir string) (*Renter, error) { if cs == nil { return nil, ErrNilCS } if hdb == nil { return nil, ErrNilHostDB } if wallet == nil { return nil, ErrNilWallet } if tpool == nil { return nil, ErrNilTpool } r := &Renter{ cs: cs, hostDB: hdb, wallet: wallet, tpool: tpool, files: make(map[string]*file), contracts: make(map[types.FileContractID]types.FileContract), repairSet: make(map[string]string), persistDir: persistDir, mu: sync.New(modules.SafeMutexDelay, 1), } _, err := rand.Read(r.entropy[:]) if err != nil { return nil, err } err = r.initPersist() if err != nil { return nil, err } cs.ConsensusSetSubscribe(r) go r.threadedRepairUploads() return r, nil }
// New creates and starts up a hostdb. The hostdb that gets returned will not // have finished scanning the network or blockchain. func New(cs modules.ConsensusSet, wallet modules.Wallet, tpool modules.TransactionPool, persistDir string) (*HostDB, error) { if cs == nil { return nil, errNilCS } if wallet == nil { return nil, errNilWallet } if tpool == nil { return nil, errNilTpool } hdb := &HostDB{ cs: cs, wallet: wallet, tpool: tpool, contracts: make(map[types.FileContractID]hostContract), activeHosts: make(map[modules.NetAddress]*hostNode), allHosts: make(map[modules.NetAddress]*hostEntry), scanPool: make(chan *hostEntry, scanPoolSize), persistDir: persistDir, } err := hdb.initPersist() if err != nil { return nil, err } // Begin listening to consensus and looking for hosts. for i := 0; i < scanningThreads; i++ { go hdb.threadedProbeHosts() } go hdb.threadedScan() cs.ConsensusSetSubscribe(hdb) return hdb, nil }
// New creates the internal data structures, and subscribes to // consensus for changes to the blockchain func New(cs modules.ConsensusSet) (be *BlockExplorer, err error) { // Check that input modules are non-nil if cs == nil { err = errors.New("Blockchain explorer cannot use a nil ConsensusSet") return } // Initilize the module state be = &BlockExplorer{ currentBlock: cs.GenesisBlock(), genesisBlockID: cs.GenesisBlock().ID(), blockchainHeight: 0, currencySent: types.NewCurrency64(0), activeContractCost: types.NewCurrency64(0), totalContractCost: types.NewCurrency64(0), cs: cs, mu: sync.New(modules.SafeMutexDelay, 1), } cs.ConsensusSetSubscribe(be) return }
// New creates a transaction pool that is ready to receive transactions. func New(cs modules.ConsensusSet, g modules.Gateway) (tp *TransactionPool, err error) { // Check that the input modules are non-nil. if cs == nil { err = errors.New("transaction pool cannot use a nil state") return } if g == nil { err = errors.New("transaction pool cannot use a nil gateway") return } // Initialize a transaction pool. tp = &TransactionPool{ consensusSet: cs, gateway: g, transactions: make(map[crypto.Hash]struct{}), siacoinOutputs: make(map[types.SiacoinOutputID]types.SiacoinOutput), fileContracts: make(map[types.FileContractID]types.FileContract), siafundOutputs: make(map[types.SiafundOutputID]types.SiafundOutput), referenceSiacoinOutputs: make(map[types.SiacoinOutputID]types.SiacoinOutput), referenceFileContracts: make(map[types.FileContractID]types.FileContract), referenceSiafundOutputs: make(map[types.SiafundOutputID]types.SiafundOutput), mu: sync.New(modules.SafeMutexDelay, 1), } // Register RPCs g.RegisterRPC("RelayTransaction", tp.RelayTransaction) // Subscribe the transaction pool to the consensus set. cs.ConsensusSetSubscribe(tp) return }
// New creates and starts up a hostdb. The hostdb that gets returned will not // have finished scanning the network or blockchain. func New(cs modules.ConsensusSet, g modules.Gateway, persistDir string) (*HostDB, error) { // Check for nil dependencies. if cs == nil { return nil, errNilConsensusSet } if g == nil { return nil, errNilGateway } // Build an empty hostdb. hdb := &HostDB{ consensusSet: cs, gateway: g, activeHosts: make(map[modules.NetAddress]*hostNode), allHosts: make(map[modules.NetAddress]*hostEntry), scanPool: make(chan *hostEntry, scanPoolSize), persistDir: persistDir, mu: sync.New(modules.SafeMutexDelay, 1), } err := hdb.initPersist() if err != nil { return nil, err } // Begin listening to consensus and looking for hosts. for i := 0; i < scanningThreads; i++ { go hdb.threadedProbeHosts() } go hdb.threadedScan() cs.ConsensusSetSubscribe(hdb) return hdb, nil }