ceremonyclient/node/app/node.go

177 lines
4.1 KiB
Go
Raw Normal View History

2023-09-03 23:47:09 +00:00
package app
import (
2024-03-08 05:05:04 +00:00
"bytes"
2023-09-03 23:47:09 +00:00
"errors"
"go.uber.org/zap"
2023-09-03 23:47:09 +00:00
"source.quilibrium.com/quilibrium/monorepo/node/consensus"
2024-03-04 03:20:24 +00:00
"source.quilibrium.com/quilibrium/monorepo/node/consensus/master"
2023-09-03 23:47:09 +00:00
"source.quilibrium.com/quilibrium/monorepo/node/execution"
2024-02-13 07:04:56 +00:00
"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/ceremony"
2024-03-08 05:05:04 +00:00
"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/ceremony/application"
2023-10-28 02:23:55 +00:00
"source.quilibrium.com/quilibrium/monorepo/node/keys"
"source.quilibrium.com/quilibrium/monorepo/node/p2p"
"source.quilibrium.com/quilibrium/monorepo/node/store"
2024-03-08 05:05:04 +00:00
"source.quilibrium.com/quilibrium/monorepo/node/tries"
2023-09-03 23:47:09 +00:00
)
type Node struct {
logger *zap.Logger
clockStore store.ClockStore
2023-10-28 02:23:55 +00:00
keyManager keys.KeyManager
pubSub p2p.PubSub
2023-09-03 23:47:09 +00:00
execEngines map[string]execution.ExecutionEngine
engine consensus.ConsensusEngine
}
func newNode(
logger *zap.Logger,
clockStore store.ClockStore,
2023-10-28 02:23:55 +00:00
keyManager keys.KeyManager,
pubSub p2p.PubSub,
2023-09-25 02:43:35 +00:00
ceremonyExecutionEngine *ceremony.CeremonyExecutionEngine,
2023-09-03 23:47:09 +00:00
engine consensus.ConsensusEngine,
) (*Node, error) {
if engine == nil {
return nil, errors.New("engine must not be nil")
}
execEngines := make(map[string]execution.ExecutionEngine)
2023-09-25 02:43:35 +00:00
if ceremonyExecutionEngine != nil {
execEngines[ceremonyExecutionEngine.GetName()] = ceremonyExecutionEngine
2023-09-03 23:47:09 +00:00
}
2024-03-08 05:05:04 +00:00
intrinsicFilter := append(
p2p.GetBloomFilter(application.CEREMONY_ADDRESS, 256, 3),
p2p.GetBloomFilterIndices(application.CEREMONY_ADDRESS, 65536, 24)...,
)
logger.Info("running compaction")
if err := clockStore.Compact(
bytes.Repeat([]byte{0xff}, 32),
intrinsicFilter,
); err != nil {
panic(err)
}
logger.Info("compaction complete")
2023-09-03 23:47:09 +00:00
return &Node{
logger,
clockStore,
2023-10-28 02:23:55 +00:00
keyManager,
pubSub,
2023-09-03 23:47:09 +00:00
execEngines,
engine,
}, nil
}
2024-03-08 05:05:04 +00:00
func (n *Node) RunRepair() {
intrinsicFilter := append(
p2p.GetBloomFilter(application.CEREMONY_ADDRESS, 256, 3),
p2p.GetBloomFilterIndices(application.CEREMONY_ADDRESS, 65536, 24)...,
)
n.logger.Info("check store and repair if needed, this may take a few minutes")
proverTrie := &tries.RollingFrecencyCritbitTrie{}
head, err := n.clockStore.GetLatestDataClockFrame(intrinsicFilter, proverTrie)
if err == nil && head != nil {
for head != nil && head.FrameNumber != 0 {
prev := head
head, err = n.clockStore.GetParentDataClockFrame(
intrinsicFilter,
head.FrameNumber-1,
head.ParentSelector,
true,
)
if err != nil {
panic(err)
}
compare, _, err := n.clockStore.GetDataClockFrame(
intrinsicFilter,
prev.FrameNumber-1,
true,
)
if err != nil {
panic(err)
}
if !bytes.Equal(head.Output, compare.Output) {
n.logger.Warn(
"repairing frame",
zap.Uint64("frame_number", head.FrameNumber),
)
head, err = n.clockStore.GetParentDataClockFrame(
intrinsicFilter,
prev.FrameNumber-1,
prev.ParentSelector,
false,
)
if err != nil {
panic(err)
}
txn, err := n.clockStore.NewTransaction()
if err != nil {
panic(err)
}
err = n.clockStore.PutDataClockFrame(head, proverTrie, txn, true)
if err != nil {
panic(err)
}
if err = txn.Commit(); err != nil {
panic(err)
}
}
}
}
n.logger.Info("check complete")
}
2023-09-03 23:47:09 +00:00
func (n *Node) Start() {
err := <-n.engine.Start()
if err != nil {
panic(err)
}
// TODO: add config mapping to engine name/frame registration
for _, e := range n.execEngines {
n.engine.RegisterExecutor(e, 0)
}
}
func (n *Node) Stop() {
err := <-n.engine.Stop(false)
if err != nil {
panic(err)
}
}
func (n *Node) GetLogger() *zap.Logger {
return n.logger
}
func (n *Node) GetClockStore() store.ClockStore {
return n.clockStore
}
2023-10-28 02:23:55 +00:00
func (n *Node) GetKeyManager() keys.KeyManager {
return n.keyManager
}
func (n *Node) GetPubSub() p2p.PubSub {
return n.pubSub
}
2024-03-04 03:20:24 +00:00
func (n *Node) GetMasterClock() *master.MasterClockConsensusEngine {
return n.engine.(*master.MasterClockConsensusEngine)
}
func (n *Node) GetExecutionEngines() []execution.ExecutionEngine {
list := []execution.ExecutionEngine{}
for _, e := range n.execEngines {
list = append(list, e)
}
return list
}