civilplcrvoting.go

// Code generated by 'gen/eventhandlergen.go'  DO NOT EDIT.
// IT SHOULD NOT BE EDITED BY HAND AS ANY CHANGES MAY BE OVERWRITTEN
// Please reference 'gen/filterergen_template.go' for more details
// File was generated at 2020-02-18 16:55:19.687159 +0000 UTC
package filterer

import (
	log "github.com/golang/glog"
	"runtime"
	"sync"

	"github.com/Jeffail/tunny"

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"

	specs "github.com/joincivil/civil-events-crawler/pkg/contractspecs"
	commongen "github.com/joincivil/civil-events-crawler/pkg/generated/common"
	"github.com/joincivil/civil-events-crawler/pkg/model"

	"github.com/joincivil/go-common/pkg/generated/contract"
	ctime "github.com/joincivil/go-common/pkg/time"

	"math/big"
)

func NewCivilPLCRVotingContractFilterers(contractAddress common.Address) *CivilPLCRVotingContractFilterers {
	contractFilterers := &CivilPLCRVotingContractFilterers{
		contractAddress:   contractAddress,
		eventTypes:        commongen.EventTypesCivilPLCRVotingContract(),
		eventToStartBlock: make(map[string]uint64),
		lastEvents:        make([]*model.Event, 0),
	}
	for _, eventType := range contractFilterers.eventTypes {
		contractFilterers.eventToStartBlock[eventType] = 0
	}
	return contractFilterers
}

type CivilPLCRVotingContractFilterers struct {
	contractAddress   common.Address
	contract          *contract.CivilPLCRVotingContract
	eventTypes        []string
	eventToStartBlock map[string]uint64
	lastEvents        []*model.Event
	lastEventsMutex   sync.Mutex
	pastEventsMutex   sync.Mutex
}

func (f *CivilPLCRVotingContractFilterers) ContractName() string {
	return "CivilPLCRVotingContract"
}

func (f *CivilPLCRVotingContractFilterers) ContractAddress() common.Address {
	return f.contractAddress
}

func (f *CivilPLCRVotingContractFilterers) StartFilterers(client bind.ContractBackend,
	pastEvents []*model.Event, nonSubOnly bool) ([]*model.Event, error) {
	return f.StartCivilPLCRVotingContractFilterers(client, pastEvents, nonSubOnly)
}

func (f *CivilPLCRVotingContractFilterers) EventTypes() []string {
	return f.eventTypes
}

func (f *CivilPLCRVotingContractFilterers) UpdateStartBlock(eventType string, startBlock uint64) {
	f.eventToStartBlock[eventType] = startBlock
}

func (f *CivilPLCRVotingContractFilterers) LastEvents() []*model.Event {
	return f.lastEvents
}

// StartCivilPLCRVotingContractFilterers retrieves events for CivilPLCRVotingContract
func (f *CivilPLCRVotingContractFilterers) StartCivilPLCRVotingContractFilterers(client bind.ContractBackend,
	pastEvents []*model.Event, nonSubOnly bool) ([]*model.Event, error) {
	contract, err := contract.NewCivilPLCRVotingContract(f.contractAddress, client)
	if err != nil {
		log.Errorf("Error initializing StartCivilPLCRVotingContract: err: %v", err)
		return pastEvents, err
	}
	f.contract = contract

	workerMultiplier := 1
	numWorkers := runtime.NumCPU() * workerMultiplier
	pool := tunny.NewFunc(numWorkers, func(payload interface{}) interface{} {
		f := payload.(func())
		f()
		return nil
	})
	defer pool.Close()

	wg := sync.WaitGroup{}
	resultsChan := make(chan []*model.Event)
	done := make(chan struct{})
	filtsRun := 0

	if !specs.IsEventDisabled("CivilPLCRVotingContract", "PollCreated") && (!nonSubOnly || !specs.IsListenerEnabledForEvent("CivilPLCRVotingContract", "PollCreated")) {
		wg.Add(1)
		go func() {
			filterFunc := func() {
				startBlock := f.eventToStartBlock["PollCreated"]
				pevents, e := f.startFilterPollCreated(startBlock, []*model.Event{})
				if e != nil {
					log.Errorf("Error retrieving PollCreated: err: %v", e)
					return
				}
				if len(pevents) > 0 {
					f.lastEventsMutex.Lock()
					f.lastEvents = append(f.lastEvents, pevents[len(pevents)-1])
					f.lastEventsMutex.Unlock()
					resultsChan <- pevents
				}
			}
			pool.Process(filterFunc)
			wg.Done()
		}()
		filtsRun++
	}

	if !specs.IsEventDisabled("CivilPLCRVotingContract", "TokensRescued") && (!nonSubOnly || !specs.IsListenerEnabledForEvent("CivilPLCRVotingContract", "TokensRescued")) {
		wg.Add(1)
		go func() {
			filterFunc := func() {
				startBlock := f.eventToStartBlock["TokensRescued"]
				pevents, e := f.startFilterTokensRescued(startBlock, []*model.Event{})
				if e != nil {
					log.Errorf("Error retrieving TokensRescued: err: %v", e)
					return
				}
				if len(pevents) > 0 {
					f.lastEventsMutex.Lock()
					f.lastEvents = append(f.lastEvents, pevents[len(pevents)-1])
					f.lastEventsMutex.Unlock()
					resultsChan <- pevents
				}
			}
			pool.Process(filterFunc)
			wg.Done()
		}()
		filtsRun++
	}

	if !specs.IsEventDisabled("CivilPLCRVotingContract", "VoteCommitted") && (!nonSubOnly || !specs.IsListenerEnabledForEvent("CivilPLCRVotingContract", "VoteCommitted")) {
		wg.Add(1)
		go func() {
			filterFunc := func() {
				startBlock := f.eventToStartBlock["VoteCommitted"]
				pevents, e := f.startFilterVoteCommitted(startBlock, []*model.Event{})
				if e != nil {
					log.Errorf("Error retrieving VoteCommitted: err: %v", e)
					return
				}
				if len(pevents) > 0 {
					f.lastEventsMutex.Lock()
					f.lastEvents = append(f.lastEvents, pevents[len(pevents)-1])
					f.lastEventsMutex.Unlock()
					resultsChan <- pevents
				}
			}
			pool.Process(filterFunc)
			wg.Done()
		}()
		filtsRun++
	}

	if !specs.IsEventDisabled("CivilPLCRVotingContract", "VoteRevealed") && (!nonSubOnly || !specs.IsListenerEnabledForEvent("CivilPLCRVotingContract", "VoteRevealed")) {
		wg.Add(1)
		go func() {
			filterFunc := func() {
				startBlock := f.eventToStartBlock["VoteRevealed"]
				pevents, e := f.startFilterVoteRevealed(startBlock, []*model.Event{})
				if e != nil {
					log.Errorf("Error retrieving VoteRevealed: err: %v", e)
					return
				}
				if len(pevents) > 0 {
					f.lastEventsMutex.Lock()
					f.lastEvents = append(f.lastEvents, pevents[len(pevents)-1])
					f.lastEventsMutex.Unlock()
					resultsChan <- pevents
				}
			}
			pool.Process(filterFunc)
			wg.Done()
		}()
		filtsRun++
	}

	if !specs.IsEventDisabled("CivilPLCRVotingContract", "VotingRightsGranted") && (!nonSubOnly || !specs.IsListenerEnabledForEvent("CivilPLCRVotingContract", "VotingRightsGranted")) {
		wg.Add(1)
		go func() {
			filterFunc := func() {
				startBlock := f.eventToStartBlock["VotingRightsGranted"]
				pevents, e := f.startFilterVotingRightsGranted(startBlock, []*model.Event{})
				if e != nil {
					log.Errorf("Error retrieving VotingRightsGranted: err: %v", e)
					return
				}
				if len(pevents) > 0 {
					f.lastEventsMutex.Lock()
					f.lastEvents = append(f.lastEvents, pevents[len(pevents)-1])
					f.lastEventsMutex.Unlock()
					resultsChan <- pevents
				}
			}
			pool.Process(filterFunc)
			wg.Done()
		}()
		filtsRun++
	}

	if !specs.IsEventDisabled("CivilPLCRVotingContract", "VotingRightsWithdrawn") && (!nonSubOnly || !specs.IsListenerEnabledForEvent("CivilPLCRVotingContract", "VotingRightsWithdrawn")) {
		wg.Add(1)
		go func() {
			filterFunc := func() {
				startBlock := f.eventToStartBlock["VotingRightsWithdrawn"]
				pevents, e := f.startFilterVotingRightsWithdrawn(startBlock, []*model.Event{})
				if e != nil {
					log.Errorf("Error retrieving VotingRightsWithdrawn: err: %v", e)
					return
				}
				if len(pevents) > 0 {
					f.lastEventsMutex.Lock()
					f.lastEvents = append(f.lastEvents, pevents[len(pevents)-1])
					f.lastEventsMutex.Unlock()
					resultsChan <- pevents
				}
			}
			pool.Process(filterFunc)
			wg.Done()
		}()
		filtsRun++
	}

	go func() {
		wg.Wait()
		close(done)
		log.Info("Filtering routines complete")
	}()

Loop:
	for {
		select {
		case <-done:
			break Loop
		case pevents := <-resultsChan:
			f.pastEventsMutex.Lock()
			pastEvents = append(pastEvents, pevents...)
			f.pastEventsMutex.Unlock()
		}
	}
	log.Infof("Total filterers run: %v, events found: %v", filtsRun, len(pastEvents))
	return pastEvents, nil
}

func (f *CivilPLCRVotingContractFilterers) startFilterPollCreated(startBlock uint64, pastEvents []*model.Event) ([]*model.Event, error) {
	var opts = &bind.FilterOpts{
		Start: startBlock,
	}

	var itr *contract.CivilPLCRVotingContractPollCreatedIterator
	var err error
	maxRetries := 3
	retry := 0
	for {
		itr, err = f.contract.FilterPollCreated(
			opts,
			[]*big.Int{},
			[]common.Address{},
		)
		if err == nil {
			break
		}
		if retry >= maxRetries {
			log.Errorf("Failed filter: CivilPLCRVotingContract PollCreated for %v: err: %v", f.contractAddress.Hex(), err)
			return pastEvents, err
		}
		log.Infof("Retrying filter: CivilPLCRVotingContract PollCreated for %v: err: %v", f.contractAddress.Hex(), err)
		retry++
	}
	nextEvent := itr.Next()
	for nextEvent {
		modelEvent, err := model.NewEventFromContractEvent("PollCreated", f.ContractName(), f.contractAddress, itr.Event, ctime.CurrentEpochSecsInInt64(), model.Filterer)
		if err != nil {
			log.Errorf("Error creating new event: event: %v, err: %v", itr.Event, err)
			continue
		}
		pastEvents = append(pastEvents, modelEvent)
		nextEvent = itr.Next()
	}
	return pastEvents, nil
}

func (f *CivilPLCRVotingContractFilterers) startFilterTokensRescued(startBlock uint64, pastEvents []*model.Event) ([]*model.Event, error) {
	var opts = &bind.FilterOpts{
		Start: startBlock,
	}

	var itr *contract.CivilPLCRVotingContractTokensRescuedIterator
	var err error
	maxRetries := 3
	retry := 0
	for {
		itr, err = f.contract.FilterTokensRescued(
			opts,
			[]*big.Int{},
			[]common.Address{},
		)
		if err == nil {
			break
		}
		if retry >= maxRetries {
			log.Errorf("Failed filter: CivilPLCRVotingContract TokensRescued for %v: err: %v", f.contractAddress.Hex(), err)
			return pastEvents, err
		}
		log.Infof("Retrying filter: CivilPLCRVotingContract TokensRescued for %v: err: %v", f.contractAddress.Hex(), err)
		retry++
	}
	nextEvent := itr.Next()
	for nextEvent {
		modelEvent, err := model.NewEventFromContractEvent("TokensRescued", f.ContractName(), f.contractAddress, itr.Event, ctime.CurrentEpochSecsInInt64(), model.Filterer)
		if err != nil {
			log.Errorf("Error creating new event: event: %v, err: %v", itr.Event, err)
			continue
		}
		pastEvents = append(pastEvents, modelEvent)
		nextEvent = itr.Next()
	}
	return pastEvents, nil
}

func (f *CivilPLCRVotingContractFilterers) startFilterVoteCommitted(startBlock uint64, pastEvents []*model.Event) ([]*model.Event, error) {
	var opts = &bind.FilterOpts{
		Start: startBlock,
	}

	var itr *contract.CivilPLCRVotingContractVoteCommittedIterator
	var err error
	maxRetries := 3
	retry := 0
	for {
		itr, err = f.contract.FilterVoteCommitted(
			opts,
			[]*big.Int{},
			[]common.Address{},
		)
		if err == nil {
			break
		}
		if retry >= maxRetries {
			log.Errorf("Failed filter: CivilPLCRVotingContract VoteCommitted for %v: err: %v", f.contractAddress.Hex(), err)
			return pastEvents, err
		}
		log.Infof("Retrying filter: CivilPLCRVotingContract VoteCommitted for %v: err: %v", f.contractAddress.Hex(), err)
		retry++
	}
	nextEvent := itr.Next()
	for nextEvent {
		modelEvent, err := model.NewEventFromContractEvent("VoteCommitted", f.ContractName(), f.contractAddress, itr.Event, ctime.CurrentEpochSecsInInt64(), model.Filterer)
		if err != nil {
			log.Errorf("Error creating new event: event: %v, err: %v", itr.Event, err)
			continue
		}
		pastEvents = append(pastEvents, modelEvent)
		nextEvent = itr.Next()
	}
	return pastEvents, nil
}

func (f *CivilPLCRVotingContractFilterers) startFilterVoteRevealed(startBlock uint64, pastEvents []*model.Event) ([]*model.Event, error) {
	var opts = &bind.FilterOpts{
		Start: startBlock,
	}

	var itr *contract.CivilPLCRVotingContractVoteRevealedIterator
	var err error
	maxRetries := 3
	retry := 0
	for {
		itr, err = f.contract.FilterVoteRevealed(
			opts,
			[]*big.Int{},
			[]*big.Int{},
			[]common.Address{},
		)
		if err == nil {
			break
		}
		if retry >= maxRetries {
			log.Errorf("Failed filter: CivilPLCRVotingContract VoteRevealed for %v: err: %v", f.contractAddress.Hex(), err)
			return pastEvents, err
		}
		log.Infof("Retrying filter: CivilPLCRVotingContract VoteRevealed for %v: err: %v", f.contractAddress.Hex(), err)
		retry++
	}
	nextEvent := itr.Next()
	for nextEvent {
		modelEvent, err := model.NewEventFromContractEvent("VoteRevealed", f.ContractName(), f.contractAddress, itr.Event, ctime.CurrentEpochSecsInInt64(), model.Filterer)
		if err != nil {
			log.Errorf("Error creating new event: event: %v, err: %v", itr.Event, err)
			continue
		}
		pastEvents = append(pastEvents, modelEvent)
		nextEvent = itr.Next()
	}
	return pastEvents, nil
}

func (f *CivilPLCRVotingContractFilterers) startFilterVotingRightsGranted(startBlock uint64, pastEvents []*model.Event) ([]*model.Event, error) {
	var opts = &bind.FilterOpts{
		Start: startBlock,
	}

	var itr *contract.CivilPLCRVotingContractVotingRightsGrantedIterator
	var err error
	maxRetries := 3
	retry := 0
	for {
		itr, err = f.contract.FilterVotingRightsGranted(
			opts,
			[]common.Address{},
		)
		if err == nil {
			break
		}
		if retry >= maxRetries {
			log.Errorf("Failed filter: CivilPLCRVotingContract VotingRightsGranted for %v: err: %v", f.contractAddress.Hex(), err)
			return pastEvents, err
		}
		log.Infof("Retrying filter: CivilPLCRVotingContract VotingRightsGranted for %v: err: %v", f.contractAddress.Hex(), err)
		retry++
	}
	nextEvent := itr.Next()
	for nextEvent {
		modelEvent, err := model.NewEventFromContractEvent("VotingRightsGranted", f.ContractName(), f.contractAddress, itr.Event, ctime.CurrentEpochSecsInInt64(), model.Filterer)
		if err != nil {
			log.Errorf("Error creating new event: event: %v, err: %v", itr.Event, err)
			continue
		}
		pastEvents = append(pastEvents, modelEvent)
		nextEvent = itr.Next()
	}
	return pastEvents, nil
}

func (f *CivilPLCRVotingContractFilterers) startFilterVotingRightsWithdrawn(startBlock uint64, pastEvents []*model.Event) ([]*model.Event, error) {
	var opts = &bind.FilterOpts{
		Start: startBlock,
	}

	var itr *contract.CivilPLCRVotingContractVotingRightsWithdrawnIterator
	var err error
	maxRetries := 3
	retry := 0
	for {
		itr, err = f.contract.FilterVotingRightsWithdrawn(
			opts,
			[]common.Address{},
		)
		if err == nil {
			break
		}
		if retry >= maxRetries {
			log.Errorf("Failed filter: CivilPLCRVotingContract VotingRightsWithdrawn for %v: err: %v", f.contractAddress.Hex(), err)
			return pastEvents, err
		}
		log.Infof("Retrying filter: CivilPLCRVotingContract VotingRightsWithdrawn for %v: err: %v", f.contractAddress.Hex(), err)
		retry++
	}
	nextEvent := itr.Next()
	for nextEvent {
		modelEvent, err := model.NewEventFromContractEvent("VotingRightsWithdrawn", f.ContractName(), f.contractAddress, itr.Event, ctime.CurrentEpochSecsInInt64(), model.Filterer)
		if err != nil {
			log.Errorf("Error creating new event: event: %v, err: %v", itr.Event, err)
			continue
		}
		pastEvents = append(pastEvents, modelEvent)
		nextEvent = itr.Next()
	}
	return pastEvents, nil
}