github.com/sixexorg/magnetic-ring@v0.0.0-20191119090307-31705a21e419/miner/miner.go (about)

     1  package miner
     2  
     3  import (
     4  	"reflect"
     5  
     6  	"github.com/ontio/ontology-eventbus/actor"
     7  	"github.com/sixexorg/magnetic-ring/common"
     8  	"github.com/sixexorg/magnetic-ring/config"
     9  	"github.com/sixexorg/magnetic-ring/consense/poa"
    10  	"github.com/sixexorg/magnetic-ring/events/message"
    11  	"github.com/sixexorg/magnetic-ring/log"
    12  	"github.com/sixexorg/magnetic-ring/store/orgchain/storages"
    13  	common2 "github.com/sixexorg/magnetic-ring/txpool/orgchain"
    14  )
    15  
    16  type Miner struct {
    17  	coinbase    common.Address
    18  	mining      map[common.Address]int32
    19  	canStart    map[common.Address]int32   // can start indicates whether we can start the mining operation
    20  	shouldStart map[common.Address]int32   // should start indicates whether we should start after sync
    21  	workers     map[common.Address]*worker // key orgid
    22  	ledgerSet   map[common.Address]*storages.LedgerStoreImp
    23  }
    24  
    25  func New(coinbase common.Address) *Miner {
    26  	miner := &Miner{
    27  		ledgerSet:   make(map[common.Address]*storages.LedgerStoreImp),
    28  		workers:     make(map[common.Address]*worker, 0),
    29  		mining:      make(map[common.Address]int32, 0),
    30  		canStart:    make(map[common.Address]int32, 0),
    31  		shouldStart: make(map[common.Address]int32, 0),
    32  		coinbase:    coinbase,
    33  	}
    34  	return miner
    35  }
    36  
    37  func (srv *Miner) Halt(c actor.Context) {
    38  }
    39  
    40  func (srv *Miner) Receive(c actor.Context) {
    41  	switch msg := c.Message().(type) {
    42  	case *actor.Restarting:
    43  		log.Info("Miner actor restarting")
    44  	case *actor.Stopping:
    45  		log.Info("Miner actor stopping")
    46  	case *actor.Stopped:
    47  		log.Info("Miner actor stopped")
    48  	case *actor.Started:
    49  		log.Info("Miner actor started")
    50  	case *actor.Restart:
    51  		log.Info("Miner actor restart")
    52  	case *message.SaveOrgBlockCompleteMsg:
    53  		//if wk, ok := srv.workers[msg.Block.Header.LeagueId]; ok {
    54  		//	wk.commitNewWork()
    55  		//}
    56  
    57  	default:
    58  		log.Info("vbft actor: Unknown msg ", msg, "type", reflect.TypeOf(msg))
    59  	}
    60  }
    61  
    62  func (self *Miner) Start() {
    63  }
    64  
    65  func (self *Miner) Stop() {
    66  	for orgid, worker := range self.workers {
    67  		worker.stop()
    68  		self.mining[orgid] = 0
    69  		self.shouldStart[orgid] = 0
    70  	}
    71  }
    72  
    73  func (self *Miner) StartOrg(orgid common.Address) {
    74  	if _, ok := self.ledgerSet[orgid]; !ok {
    75  		return
    76  	}
    77  	self.workers[orgid].setEtherbase(self.coinbase)
    78  	self.shouldStart[orgid] = 1
    79  	if self.canStart[orgid] == 0 {
    80  		log.Info("Network syncing, will start miner afterwards")
    81  		return
    82  	}
    83  	self.mining[orgid] = 1
    84  
    85  	log.Info("Starting mining operation", orgid)
    86  	self.workers[orgid].start()
    87  	self.workers[orgid].commitNewWork()
    88  }
    89  
    90  func (self *Miner) StopOrg(orgid common.Address) {
    91  	self.workers[orgid].stop()
    92  	delete(self.workers, orgid)
    93  	self.mining[orgid] = 0
    94  	self.shouldStart[orgid] = 0
    95  }
    96  
    97  func (self *Miner) RegisterOrg(orgid common.Address, ledger *storages.LedgerStoreImp, config *config.CliqueConfig, poains *poa.Clique, txpool *common2.SubPool) {
    98  	if _, ok := self.ledgerSet[orgid]; ok {
    99  		return
   100  	}
   101  	self.ledgerSet[orgid] = ledger
   102  	self.workers[orgid] = newWorker(config, self.coinbase, ledger, orgid, poains, txpool)
   103  	self.workers[orgid].register(NewCpuAgent(poains))
   104  
   105  	self.mining[orgid] = 0
   106  	self.shouldStart[orgid] = 0
   107  	self.canStart[orgid] = 1
   108  }
   109  
   110  func (self *Miner) UnegisterOrg(orgid common.Address) {
   111  	if work, ok := self.workers[orgid]; ok {
   112  		work.unregister()
   113  		delete(self.workers, orgid)
   114  	}
   115  
   116  	delete(self.ledgerSet, orgid)
   117  	delete(self.mining, orgid)
   118  	delete(self.canStart, orgid)
   119  }
   120  
   121  func (self *Miner) Mining(orgid common.Address) bool {
   122  	return self.mining[orgid] > 0
   123  }
   124  
   125  func (self *Miner) SetEtherbase(addr common.Address) {
   126  	self.coinbase = addr
   127  	for _, worker := range self.workers {
   128  		worker.setEtherbase(addr)
   129  	}
   130  }