forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-08-18 18:02:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

eth/filters,rpc,core,internal/ethapi: Fixed formating, linting, vet issues.

Browse source
This commit is contained in:
Domino Valdano 2018-03-31 15:23:25 -07:00
parent 23f0df9db6
commit 169c590b07
No known key found for this signature in database
GPG key ID: 3FDFE30EE92AC05E
15 changed files with 151 additions and 138 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
accounts/abi/bind/backends/simulated.go
View file

@ -461,6 +461,10 @@ func (fb *filterBackend) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscr
return fb.bc.SubscribeLogsEvent(ch)
}
func (fb *filterBackend) SubscribeTransactionEvent(ch chan<- *core.TransactionEvent) event.Subscription {
return fb.bc.SubscribeTransactionEvent(ch)
}
func (fb *filterBackend) BloomStatus() (uint64, uint64) { return 4096, 0 }
func (fb *filterBackend) ServiceFilter(ctx context.Context, ms *bloombits.MatcherSession) {
panic("not supported")

2
core/events.go
View file

@ -36,7 +36,7 @@ type PendingStateEvent struct{}
type NewMinedBlockEvent struct{ Block *types.Block }
// TransactionEvent is posted when a transaction completes execution
type TransactionEvent struct{
type TransactionEvent struct {
TxHash common.Hash
RetData types.ReturnData
}

4
core/state_processor.go
View file

@ -124,8 +124,8 @@ func ApplyTransaction(config *params.ChainConfig, bc *BlockChain, author *common
receipt.Logs = statedb.GetLogs(tx.Hash())
receipt.Bloom = types.CreateBloom(types.Receipts{receipt})
retData := types.ReturnData{receipt.TxHash,data,false}
txPostEvent := TransactionEvent{receipt.TxHash,retData}
retData := types.ReturnData{TxHash: receipt.TxHash, Data: data, Removed: false}
txPostEvent := TransactionEvent{TxHash: receipt.TxHash, RetData: retData}
go bc.txPostFeed.Send(&txPostEvent)
return receipt, gas, err

11
eth/filters/api.go
View file

@ -22,17 +22,17 @@ import (
"errors"
"fmt"
"math/big"
"reflect"
"sync"
"time"
"reflect"
ethereum "github.com/ethereum/go-ethereum"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/core/types"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/ethereum/go-ethereum/event"
"github.com/ethereum/go-ethereum/log"
"github.com/ethereum/go-ethereum/rpc"
)
@ -282,11 +282,11 @@ func (api *PublicFilterAPI) ReturnData(ctx context.Context) (*rpc.Subscription,
select {
case msg := <-rpcSub.Update():
// client submitted new tx, save hash for later
hash,ishash := msg.(common.Hash)
hash, ishash := msg.(common.Hash)
if ishash {
txListen[hash] = true
} else {
log.Warn(fmt.Sprintf("Received update msg of invalid type %s for ReturnData subscription",reflect.TypeOf(msg).String()))
log.Warn(fmt.Sprintf("Received update msg of invalid type %s for ReturnData subscription", reflect.TypeOf(msg).String()))
}
case retdata := <-retCh:
if txListen[retdata.TxHash] {
@ -306,7 +306,6 @@ func (api *PublicFilterAPI) ReturnData(ctx context.Context) (*rpc.Subscription,
return rpcSub, nil
}
// Logs creates a subscription that fires for all new log that match the given filter criteria.
func (api *PublicFilterAPI) Logs(ctx context.Context, crit FilterCriteria) (*rpc.Subscription, error) {
notifier, supported := rpc.NotifierFromContext(ctx)
@ -530,7 +529,7 @@ func returnRetData(rdata []types.ReturnData) []types.ReturnData {
if rdata == nil {
return []types.ReturnData{}
} else {
for _,r := range rdata {
for _, r := range rdata {
r.Data = []byte{}
}
}

4
eth/filters/bench_test.go
View file

@ -130,7 +130,7 @@ func benchmarkBloomBits(b *testing.B, sectionSize uint64) {
if i%20 == 0 {
db.Close()
db, _ = ethdb.NewLDBDatabase(benchDataDir, 128, 1024)
backend = &testBackend{mux, db, cnt, new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed)}
backend = &testBackend{mux, db, cnt, new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed)}
}
var addr common.Address
addr[0] = byte(i)
@ -191,7 +191,7 @@ func BenchmarkNoBloomBits(b *testing.B) {
fmt.Println("Running filter benchmarks...")
start := time.Now()
mux := new(event.TypeMux)
backend := &testBackend{mux, db, 0, new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed)}
backend := &testBackend{mux, db, 0, new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed), new(event.Feed)}
filter := New(backend, 0, int64(headNum), []common.Address{{}}, nil)
filter.Logs(context.Background())
d := time.Since(start)

23
eth/filters/filter_system_test.go
View file

@ -42,6 +42,7 @@ type testBackend struct {
db ethdb.Database
sections uint64
txFeed *event.Feed
txPostFeed *event.Feed
rmLogsFeed *event.Feed
logsFeed *event.Feed
chainFeed *event.Feed
@ -100,6 +101,10 @@ func (b *testBackend) SubscribeChainEvent(ch chan<- core.ChainEvent) event.Subsc
return b.chainFeed.Subscribe(ch)
}
func (b *testBackend) SubscribeTransactionEvent(ch chan<- *core.TransactionEvent) event.Subscription {
return b.txPostFeed.Subscribe(ch)
}
func (b *testBackend) BloomStatus() (uint64, uint64) {
return params.BloomBitsBlocks, b.sections
}
@ -143,10 +148,11 @@ func TestBlockSubscription(t *testing.T) {
mux = new(event.TypeMux)
db, _ = ethdb.NewMemDatabase()
txFeed = new(event.Feed)
txPostFeed = new(event.Feed)
rmLogsFeed = new(event.Feed)
logsFeed = new(event.Feed)
chainFeed = new(event.Feed)
backend = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
backend = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
api = NewPublicFilterAPI(backend, false)
genesis = new(core.Genesis).MustCommit(db)
chain, _ = core.GenerateChain(params.TestChainConfig, genesis, ethash.NewFaker(), db, 10, func(i int, gen *core.BlockGen) {})
@ -200,10 +206,11 @@ func TestPendingTxFilter(t *testing.T) {
mux = new(event.TypeMux)
db, _ = ethdb.NewMemDatabase()
txFeed = new(event.Feed)
txPostFeed = new(event.Feed)
rmLogsFeed = new(event.Feed)
logsFeed = new(event.Feed)
chainFeed = new(event.Feed)
backend = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
backend = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
api = NewPublicFilterAPI(backend, false)
transactions = []*types.Transaction{
@ -263,10 +270,11 @@ func TestLogFilterCreation(t *testing.T) {
mux = new(event.TypeMux)
db, _ = ethdb.NewMemDatabase()
txFeed = new(event.Feed)
txPostFeed = new(event.Feed)
rmLogsFeed = new(event.Feed)
logsFeed = new(event.Feed)
chainFeed = new(event.Feed)
backend = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
backend = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
api = NewPublicFilterAPI(backend, false)
testCases = []struct {
@ -312,10 +320,11 @@ func TestInvalidLogFilterCreation(t *testing.T) {
mux = new(event.TypeMux)
db, _ = ethdb.NewMemDatabase()
txFeed = new(event.Feed)
txPostFeed = new(event.Feed)
rmLogsFeed = new(event.Feed)
logsFeed = new(event.Feed)
chainFeed = new(event.Feed)
backend = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
backend = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
api = NewPublicFilterAPI(backend, false)
)
@ -342,10 +351,11 @@ func TestLogFilter(t *testing.T) {
mux = new(event.TypeMux)
db, _ = ethdb.NewMemDatabase()
txFeed = new(event.Feed)
txPostFeed = new(event.Feed)
rmLogsFeed = new(event.Feed)
logsFeed = new(event.Feed)
chainFeed = new(event.Feed)
backend = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
backend = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
api = NewPublicFilterAPI(backend, false)
firstAddr = common.HexToAddress("0x1111111111111111111111111111111111111111")
@ -461,10 +471,11 @@ func TestPendingLogsSubscription(t *testing.T) {
mux = new(event.TypeMux)
db, _ = ethdb.NewMemDatabase()
txFeed = new(event.Feed)
txPostFeed = new(event.Feed)
rmLogsFeed = new(event.Feed)
logsFeed = new(event.Feed)
chainFeed = new(event.Feed)
backend = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
backend = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
api = NewPublicFilterAPI(backend, false)
firstAddr = common.HexToAddress("0x1111111111111111111111111111111111111111")

6
eth/filters/filter_test.go
View file

@ -53,10 +53,11 @@ func BenchmarkFilters(b *testing.B) {
db, _ = ethdb.NewLDBDatabase(dir, 0, 0)
mux = new(event.TypeMux)
txFeed = new(event.Feed)
txPostFeed = new(event.Feed)
rmLogsFeed = new(event.Feed)
logsFeed = new(event.Feed)
chainFeed = new(event.Feed)
backend = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
backend = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
addr1 = crypto.PubkeyToAddress(key1.PublicKey)
addr2 = common.BytesToAddress([]byte("jeff"))
@ -118,10 +119,11 @@ func TestFilters(t *testing.T) {
db, _ = ethdb.NewLDBDatabase(dir, 0, 0)
mux = new(event.TypeMux)
txFeed = new(event.Feed)
txPostFeed = new(event.Feed)
rmLogsFeed = new(event.Feed)
logsFeed = new(event.Feed)
chainFeed = new(event.Feed)
backend = &testBackend{mux, db, 0, txFeed, rmLogsFeed, logsFeed, chainFeed}
backend = &testBackend{mux, db, 0, txFeed, txPostFeed, rmLogsFeed, logsFeed, chainFeed}
key1, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
addr = crypto.PubkeyToAddress(key1.PublicKey)

4
internal/ethapi/api.go
View file

@ -1185,12 +1185,12 @@ func submitTransaction(ctx context.Context, b Backend, tx *types.Transaction) (c
log.Info("Submitted transaction", "fullhash", tx.Hash().Hex(), "recipient", tx.To())
}
notifier,supported := rpc.NotifierFromContext(ctx)
notifier, supported := rpc.NotifierFromContext(ctx)
if supported {
// If this client has a returnData subscription, add tx hash to set of transactions
// whose return data should be sent back to rpc subscriber after transaction
// is sealed in a new block.
go notifier.UpdateSubscriptions(rpc.ReturnDataSubscription,tx.Hash())
go notifier.UpdateSubscriptions(rpc.ReturnDataSubscription, tx.Hash())
}
return tx.Hash(), nil

1
light/lightchain.go
View file

@ -494,7 +494,6 @@ func (self *LightChain) SubscribeTransactionEvent(ch chan<- *core.TransactionEve
return self.scope.Track(self.txPostFeed.Subscribe(ch))
}
// SubscribeLogsEvent implements the interface of filters.Backend
// LightChain does not send logs events, so return an empty subscription.
func (self *LightChain) SubscribeLogsEvent(ch chan<- []*types.Log) event.Subscription {

6
rpc/subscription.go
View file

@ -60,8 +60,6 @@ const (
LastIndexSubscription
)
// a Subscription is created by a notifier and tied to that notifier. The client can use
// this subscription to wait for an unsubscribe request for the client, see Err().
type Subscription struct {
@ -118,7 +116,7 @@ func NotifierFromContext(ctx context.Context) (*Notifier, bool) {
// are dropped until the subscription is marked as active. This is done
// by the RPC server after the subscription ID is send to the client.
func (n *Notifier) CreateSubscription() *Subscription {
s := &Subscription{ID: NewID(), update: make(chan interface{}),err: make(chan error)}
s := &Subscription{ID: NewID(), update: make(chan interface{}), err: make(chan error)}
n.subMu.Lock()
n.inactive[s.ID] = s
n.subMu.Unlock()
@ -172,7 +170,7 @@ func (n *Notifier) UpdateSubscription(id ID, message interface{}) error {
func (n *Notifier) UpdateSubscriptions(subType SubscriptionType, message interface{}) error {
n.subMu.RLock()
defer n.subMu.RUnlock()
for _,sub := range n.active {
for _, sub := range n.active {
if sub.Type == subType {
sub.update <- message
return nil