deep-stack/ipld-eth-server
6
0
Fork 0
forked from cerc-io/ipld-eth-server
Code Pull Requests Activity

TransformerInitializer => EventTransformerInitializer reorganization

Browse Source
This commit is contained in:
Ian Norden 2019-03-14 11:59:39 -05:00
parent a9513c1af6
commit ff55e3ba7a
20 changed files with 75 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
README.md
View File

@ -350,11 +350,11 @@ type exporter string
var Exporter exporter var Exporter exporter
func (e exporter) Export() []interface1.TransformerInitializer, []interface1.StorageTransformerInitializer { func (e exporter) Export() []interface1.EventTransformerInitializer, []interface1.StorageTransformerInitializer {
return []interface1.TransformerInitializer{ return []interface1.EventTransformerInitializer{
transformer1.TransformerInitializer, transformer1.EventTransformerInitializer,
transformer2.TransformerInitializer, transformer2.EventTransformerInitializer,
transformer3.TransformerInitializer, transformer3.EventTransformerInitializer,
}, []interface1.StorageTransformerInitializer{ }, []interface1.StorageTransformerInitializer{
transformer4.StorageTransformerInitializer, transformer4.StorageTransformerInitializer,
} }
@ -365,7 +365,7 @@ func (e exporter) Export() []interface1.TransformerInitializer, []interface1.Sto
To plug in an external transformer we need to: To plug in an external transformer we need to:
* Create a [package](https://github.com/vulcanize/ens_transformers/blob/working/transformers/registry/new_owner/initializer/initializer.go) * Create a [package](https://github.com/vulcanize/ens_transformers/blob/working/transformers/registry/new_owner/initializer/initializer.go)
that exports a variable `TransformerInitializer` or `StorageTransformerInitializer` that are of type [TransformerInitializer](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/libraries/shared/transformer/event_transformer.go#L33) that exports a variable `EventTransformerInitializer` or `StorageTransformerInitializer` that are of type [EventTransformerInitializer](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/libraries/shared/transformer/event_transformer.go#L33)
or [StorageTransformerInitializer](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/libraries/shared/transformer/storage_transformer.go#L31), respectively or [StorageTransformerInitializer](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/libraries/shared/transformer/storage_transformer.go#L31), respectively
* Design the transformers to work in the context of their [event](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/libraries/shared/watcher/event_watcher.go#L83) * Design the transformers to work in the context of their [event](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/libraries/shared/watcher/event_watcher.go#L83)
or [storage](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/libraries/shared/watcher/storage_watcher.go#L58) watcher execution modes or [storage](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/libraries/shared/watcher/storage_watcher.go#L58) watcher execution modes

2
cmd/composeAndExecute.go
View File

@ -149,7 +149,7 @@ func composeAndExecute() {
os.Exit(1) os.Exit(1)
} }
// Use the Exporters export method to load the TransformerInitializer and StorageTransformerInitializer sets // Use the Exporters export method to load the EventTransformerInitializer and StorageTransformerInitializer sets
ethEventInitializers, ethStorageInitializers := exporter.Export() ethEventInitializers, ethStorageInitializers := exporter.Export()
// Setup bc and db objects // Setup bc and db objects

8
cmd/execute.go
View File

@ -99,7 +99,7 @@ func execute() {
os.Exit(1) os.Exit(1)
} }
// Use the Exporters export method to load the TransformerInitializer and StorageTransformerInitializer sets // Use the Exporters export method to load the EventTransformerInitializer and StorageTransformerInitializer sets
ethEventInitializers, ethStorageInitializers := exporter.Export() ethEventInitializers, ethStorageInitializers := exporter.Export()
// Setup bc and db objects // Setup bc and db objects
@ -132,12 +132,12 @@ func init() {
} }
type Exporter interface { type Exporter interface {
Export() ([]transformer.TransformerInitializer, []transformer.StorageTransformerInitializer) Export() ([]transformer.EventTransformerInitializer, []transformer.StorageTransformerInitializer)
} }
func watchEthEvents(w *watcher.EventWatcher, wg *syn.WaitGroup) { func watchEthEvents(w *watcher.EventWatcher, wg *syn.WaitGroup) {
defer wg.Done() defer wg.Done()
// Execute over the TransformerInitializer set using the watcher // Execute over the EventTransformerInitializer set using the watcher
log.Info("executing event transformers") log.Info("executing event transformers")
var recheck constants.TransformerExecution var recheck constants.TransformerExecution
if recheckHeadersArg { if recheckHeadersArg {
@ -157,7 +157,7 @@ func watchEthEvents(w *watcher.EventWatcher, wg *syn.WaitGroup) {
func watchEthStorage(w *watcher.StorageWatcher, wg *syn.WaitGroup) { func watchEthStorage(w *watcher.StorageWatcher, wg *syn.WaitGroup) {
defer wg.Done() defer wg.Done()
// Execute over the TransformerInitializer set using the watcher // Execute over the StorageTransformerInitializer set using the watcher
log.Info("executing storage transformers") log.Info("executing storage transformers")
ticker := time.NewTicker(pollingInterval) ticker := time.NewTicker(pollingInterval)
defer ticker.Stop() defer ticker.Stop()

4
libraries/shared/chunker/log_chunker.go
View File

@ -26,7 +26,7 @@ import (
) )
type Chunker interface { type Chunker interface {
AddConfigs(transformerConfigs []shared_t.TransformerConfig) AddConfigs(transformerConfigs []shared_t.EventTransformerConfig)
ChunkLogs(logs []types.Log) map[string][]types.Log ChunkLogs(logs []types.Log) map[string][]types.Log
} }
@ -45,7 +45,7 @@ func NewLogChunker() *LogChunker {
} }
// Configures the chunker by adding more addreses and topics to consider. // Configures the chunker by adding more addreses and topics to consider.
func (chunker *LogChunker) AddConfigs(transformerConfigs []shared_t.TransformerConfig) { func (chunker *LogChunker) AddConfigs(transformerConfigs []shared_t.EventTransformerConfig) {
for _, config := range transformerConfigs { for _, config := range transformerConfigs {
for _, address := range config.ContractAddresses { for _, address := range config.ContractAddresses {
var lowerCaseAddress = strings.ToLower(address) var lowerCaseAddress = strings.ToLower(address)

18
libraries/shared/chunker/log_chunker_test.go
View File

@ -28,29 +28,29 @@ import (
var _ = Describe("Log chunker", func() { var _ = Describe("Log chunker", func() {
var ( var (
configs []shared_t.TransformerConfig configs []shared_t.EventTransformerConfig
chunker *chunk.LogChunker chunker *chunk.LogChunker
) )
BeforeEach(func() { BeforeEach(func() {
configA := shared_t.TransformerConfig{ configA := shared_t.EventTransformerConfig{
TransformerName: "TransformerA", TransformerName: "TransformerA",
ContractAddresses: []string{"0x00000000000000000000000000000000000000A1", "0x00000000000000000000000000000000000000A2"}, ContractAddresses: []string{"0x00000000000000000000000000000000000000A1", "0x00000000000000000000000000000000000000A2"},
Topic: "0xA", Topic: "0xA",
} }
configB := shared_t.TransformerConfig{ configB := shared_t.EventTransformerConfig{
TransformerName: "TransformerB", TransformerName: "TransformerB",
ContractAddresses: []string{"0x00000000000000000000000000000000000000B1"}, ContractAddresses: []string{"0x00000000000000000000000000000000000000B1"},
Topic: "0xB", Topic: "0xB",
} }
configC := shared_t.TransformerConfig{ configC := shared_t.EventTransformerConfig{
TransformerName: "TransformerC", TransformerName: "TransformerC",
ContractAddresses: []string{"0x00000000000000000000000000000000000000A2"}, ContractAddresses: []string{"0x00000000000000000000000000000000000000A2"},
Topic: "0xC", Topic: "0xC",
} }
configs = []shared_t.TransformerConfig{configA, configB, configC} configs = []shared_t.EventTransformerConfig{configA, configB, configC}
chunker = chunk.NewLogChunker() chunker = chunk.NewLogChunker()
chunker.AddConfigs(configs) chunker.AddConfigs(configs)
}) })
@ -73,24 +73,24 @@ var _ = Describe("Log chunker", func() {
Describe("AddConfigs", func() { Describe("AddConfigs", func() {
It("can add more configs later", func() { It("can add more configs later", func() {
configD := shared_t.TransformerConfig{ configD := shared_t.EventTransformerConfig{
TransformerName: "TransformerD", TransformerName: "TransformerD",
ContractAddresses: []string{"0x000000000000000000000000000000000000000D"}, ContractAddresses: []string{"0x000000000000000000000000000000000000000D"},
Topic: "0xD", Topic: "0xD",
} }
chunker.AddConfigs([]shared_t.TransformerConfig{configD}) chunker.AddConfigs([]shared_t.EventTransformerConfig{configD})
Expect(chunker.AddressToNames).To(ContainElement([]string{"TransformerD"})) Expect(chunker.AddressToNames).To(ContainElement([]string{"TransformerD"}))
Expect(chunker.NameToTopic0).To(ContainElement(common.HexToHash("0xD"))) Expect(chunker.NameToTopic0).To(ContainElement(common.HexToHash("0xD")))
}) })
It("lower cases address", func() { It("lower cases address", func() {
configD := shared_t.TransformerConfig{ configD := shared_t.EventTransformerConfig{
TransformerName: "TransformerD", TransformerName: "TransformerD",
ContractAddresses: []string{"0x000000000000000000000000000000000000000D"}, ContractAddresses: []string{"0x000000000000000000000000000000000000000D"},
Topic: "0xD", Topic: "0xD",
} }
chunker.AddConfigs([]shared_t.TransformerConfig{configD}) chunker.AddConfigs([]shared_t.EventTransformerConfig{configD})
Expect(chunker.AddressToNames["0x000000000000000000000000000000000000000d"]).To(Equal([]string{"TransformerD"})) Expect(chunker.AddressToNames["0x000000000000000000000000000000000000000d"]).To(Equal([]string{"TransformerD"}))
}) })

18
libraries/shared/factories/README.md → libraries/shared/factories/event/README.md
View File

@ -28,8 +28,8 @@ Using the `compose` or `composeAndExecute` command, event watchers can be loaded
The event transformer is responsible for converting event logs into more useful data objects and storing them in Postgres. The event transformer is responsible for converting event logs into more useful data objects and storing them in Postgres.
The event transformer is composed of converter and repository interfaces and a config struct: The event transformer is composed of converter and repository interfaces and a config struct:
```go ```go
type Transformer struct { type EventTransformer struct {
Config transformer.TransformerConfig Config transformer.EventTransformerConfig
Converter Converter Converter Converter
Repository Repository Repository Repository
} }
@ -86,7 +86,7 @@ In order to watch events at a smart contract, for those events the developer mus
1. Model - struct representing the final data model we want to write to Postgres. 1. Model - struct representing the final data model we want to write to Postgres.
1. Converter - an interface which can unpack event logs into our entities and convert those entities to our models. 1. Converter - an interface which can unpack event logs into our entities and convert those entities to our models.
1. Repository - an interface to write our models to Postgres. 1. Repository - an interface to write our models to Postgres.
1. TransformerInitializer - a public variable which exports our configured transformer to be loaded as part of a plugin. 1. EventTransformerInitializer - a public variable which exports our configured transformer to be loaded as part of a plugin.
1. DB migrations - migrations to generate the Postgres schema, tables, views, function, etc that are needed to store and interface with the transformed data models. 1. DB migrations - migrations to generate the Postgres schema, tables, views, function, etc that are needed to store and interface with the transformed data models.
The example event we will use looks like: The example event we will use looks like:
@ -101,7 +101,7 @@ it is working at, the contract's ABI, the topic (e.g. event signature; topic0) t
and ending block numbers. and ending block numbers.
```go ```go
type TransformerConfig struct { type EventTransformerConfig struct {
TransformerName string TransformerName string
ContractAddresses []string ContractAddresses []string
ContractAbi string ContractAbi string
@ -318,14 +318,14 @@ func (repository ExampleRepository) RecheckHeaders(startingBlockNumber int64, en
} }
``` ```
### TransformerInitializer ### EventTransformerInitializer
A transformer initializer variable needs to be exported from somewhere within the transformer repository so that the transformer can be A transformer initializer variable needs to be exported from somewhere within the transformer repository so that the transformer can be
loaded as part of a plugin in the `compose` or `composeAndExecute` commands. It is important that this variable is named `TransformerInitializer` and loaded as part of a plugin in the `compose` or `composeAndExecute` commands. It is important that this variable is named `EventTransformerInitializer` and
it must be of `type TransformerInitializer func(db *postgres.DB) EventTransformer`. it must be of `type EventTransformerInitializer func(db *postgres.DB) EventTransformer`.
```go ```go
var TransformerInitializer transformer.TransformerInitializer = factories.Transformer{ var EventTransformerInitializer transformer.EventTransformerInitializer = factories.Transformer{
Config: exampleEventConfig, Config: exampleEventConfig,
Converter: ExampleConverter{}, Converter: ExampleConverter{},
Repository: &ExampleRepository{}, Repository: &ExampleRepository{},
@ -384,5 +384,5 @@ of which headers we have already filtered through for this event.
To create a transformer for a contract event we need to create entities for unpacking the raw log, models to represent To create a transformer for a contract event we need to create entities for unpacking the raw log, models to represent
the final data structure, a converter to mediate this unpacking and conversion between entities to models, a repository to write the final data structure, a converter to mediate this unpacking and conversion between entities to models, a repository to write
these models to Postgres, db migrations to accommodate these models in Postgres, and a TransformerInitializer to export the these models to Postgres, db migrations to accommodate these models in Postgres, and a EventTransformerInitializer to export the
configured transformer and load it as a plugin to the `compose` or `composeAndExecute` commands as described in the [main readme](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/README.md#composeandexecute-configuration). configured transformer and load it as a plugin to the `compose` or `composeAndExecute` commands as described in the [main readme](https://github.com/vulcanize/maker-vulcanizedb/blob/staging/README.md#composeandexecute-configuration).

2
libraries/shared/factories/converter.go → libraries/shared/factories/event/converter.go
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
package factories package event
import "github.com/ethereum/go-ethereum/core/types" import "github.com/ethereum/go-ethereum/core/types"

2
libraries/shared/factories/factories_suite_test.go → libraries/shared/factories/event/factories_suite_test.go
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
package factories_test package event_test
import ( import (
"testing" "testing"

2
libraries/shared/factories/log_note_converter.go → libraries/shared/factories/event/log_note_converter.go
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
package factories package event
import "github.com/ethereum/go-ethereum/core/types" import "github.com/ethereum/go-ethereum/core/types"

6
libraries/shared/factories/log_note_transformer.go → libraries/shared/factories/event/log_note_transformer.go
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
package factories package event
import ( import (
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
@ -27,7 +27,7 @@ import (
) )
type LogNoteTransformer struct { type LogNoteTransformer struct {
Config transformer.TransformerConfig Config transformer.EventTransformerConfig
Converter LogNoteConverter Converter LogNoteConverter
Repository Repository Repository Repository
} }
@ -68,6 +68,6 @@ func (tr LogNoteTransformer) GetName() string {
return tr.Config.TransformerName return tr.Config.TransformerName
} }
func (tr LogNoteTransformer) GetConfig() transformer.TransformerConfig { func (tr LogNoteTransformer) GetConfig() transformer.EventTransformerConfig {
return tr.Config return tr.Config
} }

6
libraries/shared/factories/log_note_transformer_test.go → libraries/shared/factories/event/log_note_transformer_test.go
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
package factories_test package event_test
import ( import (
"math/rand" "math/rand"
@ -24,7 +24,7 @@ import (
. "github.com/onsi/gomega" . "github.com/onsi/gomega"
"github.com/vulcanize/vulcanizedb/libraries/shared/constants" "github.com/vulcanize/vulcanizedb/libraries/shared/constants"
"github.com/vulcanize/vulcanizedb/libraries/shared/factories" "github.com/vulcanize/vulcanizedb/libraries/shared/factories/event"
"github.com/vulcanize/vulcanizedb/libraries/shared/mocks" "github.com/vulcanize/vulcanizedb/libraries/shared/mocks"
"github.com/vulcanize/vulcanizedb/libraries/shared/test_data" "github.com/vulcanize/vulcanizedb/libraries/shared/test_data"
"github.com/vulcanize/vulcanizedb/libraries/shared/transformer" "github.com/vulcanize/vulcanizedb/libraries/shared/transformer"
@ -46,7 +46,7 @@ var _ = Describe("LogNoteTransformer", func() {
BeforeEach(func() { BeforeEach(func() {
repository = mocks.MockRepository{} repository = mocks.MockRepository{}
converter = mocks.MockLogNoteConverter{} converter = mocks.MockLogNoteConverter{}
t = factories.LogNoteTransformer{ t = event.LogNoteTransformer{
Config: config, Config: config,
Converter: &converter, Converter: &converter,
Repository: &repository, Repository: &repository,

2
libraries/shared/factories/repository.go → libraries/shared/factories/event/repository.go
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
package factories package event
import ( import (
"github.com/vulcanize/vulcanizedb/pkg/core" "github.com/vulcanize/vulcanizedb/pkg/core"

6
libraries/shared/factories/transformer.go → libraries/shared/factories/event/transformer.go
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
package factories package event
import ( import (
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
@ -27,7 +27,7 @@ import (
) )
type Transformer struct { type Transformer struct {
Config transformer.TransformerConfig Config transformer.EventTransformerConfig
Converter Converter Converter Converter
Repository Repository Repository Repository
} }
@ -75,6 +75,6 @@ func (transformer Transformer) GetName() string {
return transformer.Config.TransformerName return transformer.Config.TransformerName
} }
func (transformer Transformer) GetConfig() transformer.TransformerConfig { func (transformer Transformer) GetConfig() transformer.EventTransformerConfig {
return transformer.Config return transformer.Config
} }

6
libraries/shared/factories/transformer_test.go → libraries/shared/factories/event/transformer_test.go
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU Affero General Public License // You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
package factories_test package event_test
import ( import (
"math/rand" "math/rand"
@ -24,7 +24,7 @@ import (
. "github.com/onsi/gomega" . "github.com/onsi/gomega"
"github.com/vulcanize/vulcanizedb/libraries/shared/constants" "github.com/vulcanize/vulcanizedb/libraries/shared/constants"
"github.com/vulcanize/vulcanizedb/libraries/shared/factories" "github.com/vulcanize/vulcanizedb/libraries/shared/factories/event"
"github.com/vulcanize/vulcanizedb/libraries/shared/mocks" "github.com/vulcanize/vulcanizedb/libraries/shared/mocks"
"github.com/vulcanize/vulcanizedb/libraries/shared/test_data" "github.com/vulcanize/vulcanizedb/libraries/shared/test_data"
"github.com/vulcanize/vulcanizedb/libraries/shared/transformer" "github.com/vulcanize/vulcanizedb/libraries/shared/transformer"
@ -46,7 +46,7 @@ var _ = Describe("Transformer", func() {
repository = mocks.MockRepository{} repository = mocks.MockRepository{}
converter = mocks.MockConverter{} converter = mocks.MockConverter{}
t = factories.Transformer{ t = event.Transformer{
Repository: &repository, Repository: &repository,
Converter: &converter, Converter: &converter,
Config: config, Config: config,

8
libraries/shared/mocks/transformer.go
View File

@ -30,7 +30,7 @@ type MockTransformer struct {
ExecuteError error ExecuteError error
PassedLogs []types.Log PassedLogs []types.Log
PassedHeader core.Header PassedHeader core.Header
config shared_t.TransformerConfig config shared_t.EventTransformerConfig
} }
func (mh *MockTransformer) Execute(logs []types.Log, header core.Header, recheckHeaders constants.TransformerExecution) error { func (mh *MockTransformer) Execute(logs []types.Log, header core.Header, recheckHeaders constants.TransformerExecution) error {
@ -43,11 +43,11 @@ func (mh *MockTransformer) Execute(logs []types.Log, header core.Header, recheck
return nil return nil
} }
func (mh *MockTransformer) GetConfig() shared_t.TransformerConfig { func (mh *MockTransformer) GetConfig() shared_t.EventTransformerConfig {
return mh.config return mh.config
} }
func (mh *MockTransformer) SetTransformerConfig(config shared_t.TransformerConfig) { func (mh *MockTransformer) SetTransformerConfig(config shared_t.EventTransformerConfig) {
mh.config = config mh.config = config
} }
@ -55,7 +55,7 @@ func (mh *MockTransformer) FakeTransformerInitializer(db *postgres.DB) shared_t.
return mh return mh
} }
var FakeTransformerConfig = shared_t.TransformerConfig{ var FakeTransformerConfig = shared_t.EventTransformerConfig{
TransformerName: "FakeTransformer", TransformerName: "FakeTransformer",
ContractAddresses: []string{"FakeAddress"}, ContractAddresses: []string{"FakeAddress"},
Topic: "FakeTopic", Topic: "FakeTopic",

2
libraries/shared/test_data/generic.go
View File

@ -39,7 +39,7 @@ var GenericTestLogs = []types.Log{{
BlockNumber: uint64(startingBlockNumber), BlockNumber: uint64(startingBlockNumber),
}} }}
var GenericTestConfig = transformer.TransformerConfig{ var GenericTestConfig = transformer.EventTransformerConfig{
TransformerName: "generic-test-transformer", TransformerName: "generic-test-transformer",
ContractAddresses: []string{address}, ContractAddresses: []string{address},
ContractAbi: randomString(100), ContractAbi: randomString(100),

8
libraries/shared/transformer/event_transformer.go
View File

@ -19,20 +19,20 @@ package transformer
import ( import (
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/core/types"
"github.com/vulcanize/vulcanizedb/pkg/core"
"github.com/vulcanize/vulcanizedb/libraries/shared/constants" "github.com/vulcanize/vulcanizedb/libraries/shared/constants"
"github.com/vulcanize/vulcanizedb/pkg/core"
"github.com/vulcanize/vulcanizedb/pkg/datastore/postgres" "github.com/vulcanize/vulcanizedb/pkg/datastore/postgres"
) )
type EventTransformer interface { type EventTransformer interface {
Execute(logs []types.Log, header core.Header, recheckHeaders constants.TransformerExecution) error Execute(logs []types.Log, header core.Header, recheckHeaders constants.TransformerExecution) error
GetConfig() TransformerConfig GetConfig() EventTransformerConfig
} }
type TransformerInitializer func(db *postgres.DB) EventTransformer type EventTransformerInitializer func(db *postgres.DB) EventTransformer
type TransformerConfig struct { type EventTransformerConfig struct {
TransformerName string TransformerName string
ContractAddresses []string ContractAddresses []string
ContractAbi string ContractAbi string

4
libraries/shared/watcher/event_watcher.go
View File

@ -52,10 +52,10 @@ func NewEventWatcher(db *postgres.DB, bc core.BlockChain) EventWatcher {
} }
// Adds transformers to the watcher and updates the chunker, so that it will consider the new transformers. // Adds transformers to the watcher and updates the chunker, so that it will consider the new transformers.
func (watcher *EventWatcher) AddTransformers(initializers []transformer.TransformerInitializer) { func (watcher *EventWatcher) AddTransformers(initializers []transformer.EventTransformerInitializer) {
var contractAddresses []common.Address var contractAddresses []common.Address
var topic0s []common.Hash var topic0s []common.Hash
var configs []transformer.TransformerConfig var configs []transformer.EventTransformerConfig
for _, initializer := range initializers { for _, initializer := range initializers {
t := initializer(watcher.DB) t := initializer(watcher.DB)

28
libraries/shared/watcher/event_watcher_test.go
View File

@ -52,7 +52,7 @@ var _ = Describe("Watcher", func() {
w := watcher.NewEventWatcher(nil, nil) w := watcher.NewEventWatcher(nil, nil)
fakeTransformer := &mocks.MockTransformer{} fakeTransformer := &mocks.MockTransformer{}
fakeTransformer.SetTransformerConfig(mocks.FakeTransformerConfig) fakeTransformer.SetTransformerConfig(mocks.FakeTransformerConfig)
w.AddTransformers([]transformer.TransformerInitializer{fakeTransformer.FakeTransformerInitializer}) w.AddTransformers([]transformer.EventTransformerInitializer{fakeTransformer.FakeTransformerInitializer})
Expect(len(w.Transformers)).To(Equal(1)) Expect(len(w.Transformers)).To(Equal(1))
Expect(w.Transformers).To(ConsistOf(fakeTransformer)) Expect(w.Transformers).To(ConsistOf(fakeTransformer))
@ -68,8 +68,8 @@ var _ = Describe("Watcher", func() {
fakeTransformer2 := &mocks.MockTransformer{} fakeTransformer2 := &mocks.MockTransformer{}
fakeTransformer2.SetTransformerConfig(mocks.FakeTransformerConfig) fakeTransformer2.SetTransformerConfig(mocks.FakeTransformerConfig)
w.AddTransformers([]transformer.TransformerInitializer{fakeTransformer1.FakeTransformerInitializer}) w.AddTransformers([]transformer.EventTransformerInitializer{fakeTransformer1.FakeTransformerInitializer})
w.AddTransformers([]transformer.TransformerInitializer{fakeTransformer2.FakeTransformerInitializer}) w.AddTransformers([]transformer.EventTransformerInitializer{fakeTransformer2.FakeTransformerInitializer})
Expect(len(w.Transformers)).To(Equal(2)) Expect(len(w.Transformers)).To(Equal(2))
Expect(w.Topics).To(Equal([]common.Hash{common.HexToHash("FakeTopic"), Expect(w.Topics).To(Equal([]common.Hash{common.HexToHash("FakeTopic"),
@ -80,13 +80,13 @@ var _ = Describe("Watcher", func() {
It("calculates earliest starting block number", func() { It("calculates earliest starting block number", func() {
fakeTransformer1 := &mocks.MockTransformer{} fakeTransformer1 := &mocks.MockTransformer{}
fakeTransformer1.SetTransformerConfig(transformer.TransformerConfig{StartingBlockNumber: 5}) fakeTransformer1.SetTransformerConfig(transformer.EventTransformerConfig{StartingBlockNumber: 5})
fakeTransformer2 := &mocks.MockTransformer{} fakeTransformer2 := &mocks.MockTransformer{}
fakeTransformer2.SetTransformerConfig(transformer.TransformerConfig{StartingBlockNumber: 3}) fakeTransformer2.SetTransformerConfig(transformer.EventTransformerConfig{StartingBlockNumber: 3})
w := watcher.NewEventWatcher(nil, nil) w := watcher.NewEventWatcher(nil, nil)
w.AddTransformers([]transformer.TransformerInitializer{ w.AddTransformers([]transformer.EventTransformerInitializer{
fakeTransformer1.FakeTransformerInitializer, fakeTransformer1.FakeTransformerInitializer,
fakeTransformer2.FakeTransformerInitializer, fakeTransformer2.FakeTransformerInitializer,
}) })
@ -123,7 +123,7 @@ var _ = Describe("Watcher", func() {
It("executes each transformer", func() { It("executes each transformer", func() {
fakeTransformer := &mocks.MockTransformer{} fakeTransformer := &mocks.MockTransformer{}
w.AddTransformers([]transformer.TransformerInitializer{fakeTransformer.FakeTransformerInitializer}) w.AddTransformers([]transformer.EventTransformerInitializer{fakeTransformer.FakeTransformerInitializer})
repository.SetMissingHeaders([]core.Header{fakes.FakeHeader}) repository.SetMissingHeaders([]core.Header{fakes.FakeHeader})
err := w.Execute(constants.HeaderMissing) err := w.Execute(constants.HeaderMissing)
@ -133,7 +133,7 @@ var _ = Describe("Watcher", func() {
It("returns an error if transformer returns an error", func() { It("returns an error if transformer returns an error", func() {
fakeTransformer := &mocks.MockTransformer{ExecuteError: errors.New("Something bad happened")} fakeTransformer := &mocks.MockTransformer{ExecuteError: errors.New("Something bad happened")}
w.AddTransformers([]transformer.TransformerInitializer{fakeTransformer.FakeTransformerInitializer}) w.AddTransformers([]transformer.EventTransformerInitializer{fakeTransformer.FakeTransformerInitializer})
repository.SetMissingHeaders([]core.Header{fakes.FakeHeader}) repository.SetMissingHeaders([]core.Header{fakes.FakeHeader})
err := w.Execute(constants.HeaderMissing) err := w.Execute(constants.HeaderMissing)
@ -145,10 +145,10 @@ var _ = Describe("Watcher", func() {
transformerA := &mocks.MockTransformer{} transformerA := &mocks.MockTransformer{}
transformerB := &mocks.MockTransformer{} transformerB := &mocks.MockTransformer{}
configA := transformer.TransformerConfig{TransformerName: "transformerA", configA := transformer.EventTransformerConfig{TransformerName: "transformerA",
ContractAddresses: []string{"0x000000000000000000000000000000000000000A"}, ContractAddresses: []string{"0x000000000000000000000000000000000000000A"},
Topic: "0xA"} Topic: "0xA"}
configB := transformer.TransformerConfig{TransformerName: "transformerB", configB := transformer.EventTransformerConfig{TransformerName: "transformerB",
ContractAddresses: []string{"0x000000000000000000000000000000000000000b"}, ContractAddresses: []string{"0x000000000000000000000000000000000000000b"},
Topic: "0xB"} Topic: "0xB"}
@ -163,7 +163,7 @@ var _ = Describe("Watcher", func() {
repository.SetMissingHeaders([]core.Header{fakes.FakeHeader}) repository.SetMissingHeaders([]core.Header{fakes.FakeHeader})
w = watcher.NewEventWatcher(db, &mockBlockChain) w = watcher.NewEventWatcher(db, &mockBlockChain)
w.AddTransformers([]transformer.TransformerInitializer{ w.AddTransformers([]transformer.EventTransformerInitializer{
transformerA.FakeTransformerInitializer, transformerB.FakeTransformerInitializer}) transformerA.FakeTransformerInitializer, transformerB.FakeTransformerInitializer})
err := w.Execute(constants.HeaderMissing) err := w.Execute(constants.HeaderMissing)
@ -182,9 +182,9 @@ var _ = Describe("Watcher", func() {
It("fetches logs for added transformers", func() { It("fetches logs for added transformers", func() {
addresses := []string{"0xA", "0xB"} addresses := []string{"0xA", "0xB"}
topic := "0x1" topic := "0x1"
fakeTransformer.SetTransformerConfig(transformer.TransformerConfig{ fakeTransformer.SetTransformerConfig(transformer.EventTransformerConfig{
Topic: topic, ContractAddresses: addresses}) Topic: topic, ContractAddresses: addresses})
w.AddTransformers([]transformer.TransformerInitializer{fakeTransformer.FakeTransformerInitializer}) w.AddTransformers([]transformer.EventTransformerInitializer{fakeTransformer.FakeTransformerInitializer})
err := w.Execute(constants.HeaderMissing) err := w.Execute(constants.HeaderMissing)
Expect(err).NotTo(HaveOccurred()) Expect(err).NotTo(HaveOccurred())
@ -201,7 +201,7 @@ var _ = Describe("Watcher", func() {
fetcherError := errors.New("FetcherError") fetcherError := errors.New("FetcherError")
mockBlockChain.SetGetEthLogsWithCustomQueryErr(fetcherError) mockBlockChain.SetGetEthLogsWithCustomQueryErr(fetcherError)
w.AddTransformers([]transformer.TransformerInitializer{fakeTransformer.FakeTransformerInitializer}) w.AddTransformers([]transformer.EventTransformerInitializer{fakeTransformer.FakeTransformerInitializer})
err := w.Execute(constants.HeaderMissing) err := w.Execute(constants.HeaderMissing)
Expect(err).To(MatchError(fetcherError)) Expect(err).To(MatchError(fetcherError))
}) })

6
pkg/plugin/writer/writer.go
View File

@ -72,12 +72,12 @@ func (w *writer) WritePlugin() error {
f.Type().Id("exporter").String() f.Type().Id("exporter").String()
f.Var().Id("Exporter").Id("exporter") f.Var().Id("Exporter").Id("exporter")
f.Func().Params(Id("e").Id("exporter")).Id("Export").Params().Parens(List( f.Func().Params(Id("e").Id("exporter")).Id("Export").Params().Parens(List(
Index().Qual("github.com/vulcanize/vulcanizedb/libraries/shared/transformer", "TransformerInitializer"), Index().Qual("github.com/vulcanize/vulcanizedb/libraries/shared/transformer", "EventTransformerInitializer"),
Index().Qual("github.com/vulcanize/vulcanizedb/libraries/shared/transformer", "StorageTransformerInitializer"), Index().Qual("github.com/vulcanize/vulcanizedb/libraries/shared/transformer", "StorageTransformerInitializer"),
)).Block(Return( )).Block(Return(
Index().Qual( Index().Qual(
"github.com/vulcanize/vulcanizedb/libraries/shared/transformer", "github.com/vulcanize/vulcanizedb/libraries/shared/transformer",
"TransformerInitializer").Values(code[config.EthEvent]...), "EventTransformerInitializer").Values(code[config.EthEvent]...),
Index().Qual( Index().Qual(
"github.com/vulcanize/vulcanizedb/libraries/shared/transformer", "github.com/vulcanize/vulcanizedb/libraries/shared/transformer",
"StorageTransformerInitializer").Values(code[config.EthStorage]...))) // Exports the collected event and storage transformer initializers "StorageTransformerInitializer").Values(code[config.EthStorage]...))) // Exports the collected event and storage transformer initializers
@ -97,7 +97,7 @@ func (w *writer) collectTransformers() (map[config.TransformerType][]Code, error
path := transformer.RepositoryPath + "/" + transformer.Path path := transformer.RepositoryPath + "/" + transformer.Path
switch transformer.Type { switch transformer.Type {
case config.EthEvent: case config.EthEvent:
code[config.EthEvent] = append(code[config.EthEvent], Qual(path, "TransformerInitializer")) code[config.EthEvent] = append(code[config.EthEvent], Qual(path, "EventTransformerInitializer"))
case config.EthStorage: case config.EthStorage:
code[config.EthStorage] = append(code[config.EthStorage], Qual(path, "StorageTransformerInitializer")) code[config.EthStorage] = append(code[config.EthStorage], Qual(path, "StorageTransformerInitializer"))
default: default: