Merge pull request #12 from axieinfinity/split-bridge-into-small-repos

Remove migrated codes and import newly repositories (bridge-core, bridge-contracts, bridge-migrations)

Author: DNK90

adapters/prometheus/pusher.go

@@ -2,10 +2,12 @@ package main
 
 import (
 	"fmt"
+	bridgeCore "github.com/axieinfinity/bridge-core"
+	bridgeCoreStore "github.com/axieinfinity/bridge-core/stores"
+	bridgeCoreUtils "github.com/axieinfinity/bridge-core/utils"
 	"github.com/axieinfinity/bridge-v2/cmd/utils"
 	"github.com/axieinfinity/bridge-v2/internal/stores"
-	"github.com/axieinfinity/bridge-v2/internal/types"
-	utils2 "github.com/axieinfinity/bridge-v2/internal/utils"
+	"github.com/axieinfinity/bridge-v2/internal/task"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/go-co-op/gocron"
 	"gopkg.in/urfave/cli.v1"
@@ -29,25 +31,32 @@ var (
 	}
 )
 
+type cleanerStore struct {
+	stores.BridgeStore
+	bridgeCoreStore.MainStore
+}
+
 type cleaner struct{}
 
 func startCleaner(ctx *cli.Context) error {
 	cfg := prepare(ctx)
 	return start(cfg)
 }
 
-func start(cfg *types.Config) error {
-	db, err := stores.MustConnectDatabase(cfg)
+func start(cfg *bridgeCore.Config) error {
+	db, err := bridgeCoreStore.MustConnectDatabase(cfg.DB, false)
 	if err != nil {
 		return err
 	}
-	mainStore := stores.NewMainStore(db)
-	u := &utils2.Utils{}
+	listenHandlerStore := stores.NewBridgeStore(db)
+	bridgeStore := bridgeCoreStore.NewMainStore(db)
+	store := &cleanerStore{listenHandlerStore, bridgeStore}
+	u := bridgeCoreUtils.NewUtils()
 	s := gocron.NewScheduler(time.UTC)
 	s.TagsUnique()
 	// start read the configuration and create cleaning schedule
 	for name, cleanerCfg := range cfg.Cleaner {
-		val, err := u.Invoke(&cleaner{}, fmt.Sprintf("Exec%s", name), s, mainStore, cleanerCfg)
+		val, err := u.Invoke(&cleaner{}, fmt.Sprintf("Exec%s", name), s, store, cleanerCfg)
 		if err != nil || !val.IsNil() {
 			log.Error("[startCleaner] error while executing a cleaner", "err", err, "returnedErr", val.Interface(), "name", name)
 		}
@@ -67,31 +76,31 @@ func start(cfg *types.Config) error {
 	return nil
 }
 
-func (c *cleaner) ExecClearSuccessTasks(scheduler *gocron.Scheduler, store types.IMainStore, cfg *types.CleanerConfig) error {
+func (c *cleaner) ExecClearSuccessTasks(scheduler *gocron.Scheduler, store *cleanerStore, cfg *bridgeCore.CleanerConfig) error {
 	_, err := scheduler.Cron(cfg.Cron).Do(func() {
 		if store.GetTaskStore().Count() <= int64(cfg.SkipIfLessThan) {
 			return
 		}
-		if err := store.GetTaskStore().DeleteTasks([]string{types.STATUS_DONE}, uint64(time.Now().Unix())-cfg.RemoveAfter); err != nil {
+		if err := store.GetTaskStore().DeleteTasks([]string{task.STATUS_DONE}, uint64(time.Now().Unix())-cfg.RemoveAfter); err != nil {
 			log.Error("[ExecClearSuccessTask] error while deleting done tasks", "err", err)
 		}
 	})
 	return err
 }
 
-func (c *cleaner) ExecClearFailedTasks(scheduler *gocron.Scheduler, store types.IMainStore, cfg *types.CleanerConfig) error {
+func (c *cleaner) ExecClearFailedTasks(scheduler *gocron.Scheduler, store *cleanerStore, cfg *bridgeCore.CleanerConfig) error {
 	_, err := scheduler.Cron(cfg.Cron).Do(func() {
 		if store.GetTaskStore().Count() <= int64(cfg.SkipIfLessThan) {
 			return
 		}
-		if err := store.GetTaskStore().DeleteTasks([]string{types.STATUS_FAILED}, uint64(time.Now().Unix())-cfg.RemoveAfter); err != nil {
+		if err := store.GetTaskStore().DeleteTasks([]string{task.STATUS_FAILED}, uint64(time.Now().Unix())-cfg.RemoveAfter); err != nil {
 			log.Error("[ExecClearFailedTask] error while deleting failed tasks", "err", err)
 		}
 	})
 	return err
 }
 
-func (c *cleaner) ExecClearEvents(scheduler *gocron.Scheduler, store types.IMainStore, cfg *types.CleanerConfig) error {
+func (c *cleaner) ExecClearEvents(scheduler *gocron.Scheduler, store *cleanerStore, cfg *bridgeCore.CleanerConfig) error {
 	_, err := scheduler.Cron(cfg.Cron).Do(func() {
 		if store.GetEventStore().Count() <= int64(cfg.SkipIfLessThan) {
 			return
@@ -103,24 +112,24 @@ func (c *cleaner) ExecClearEvents(scheduler *gocron.Scheduler, store types.IMain
 	return err
 }
 
-func (c *cleaner) ExecClearSuccessJobs(scheduler *gocron.Scheduler, store types.IMainStore, cfg *types.CleanerConfig) error {
+func (c *cleaner) ExecClearSuccessJobs(scheduler *gocron.Scheduler, store *cleanerStore, cfg *bridgeCore.CleanerConfig) error {
 	_, err := scheduler.Cron(cfg.Cron).Do(func() {
 		if store.GetJobStore().Count() <= int64(cfg.SkipIfLessThan) {
 			return
 		}
-		if err := store.GetJobStore().DeleteJobs([]string{types.STATUS_DONE}, uint64(time.Now().Unix())-cfg.RemoveAfter); err != nil {
+		if err := store.GetJobStore().DeleteJobs([]string{task.STATUS_DONE}, uint64(time.Now().Unix())-cfg.RemoveAfter); err != nil {
 			log.Error("[ExecClearSuccessTask] error while deleting done tasks", "err", err)
 		}
 	})
 	return err
 }
 
-func (c *cleaner) ExecClearFailedJobs(scheduler *gocron.Scheduler, store types.IMainStore, cfg *types.CleanerConfig) error {
+func (c *cleaner) ExecClearFailedJobs(scheduler *gocron.Scheduler, store *cleanerStore, cfg *bridgeCore.CleanerConfig) error {
 	_, err := scheduler.Cron(cfg.Cron).Do(func() {
 		if store.GetJobStore().Count() <= int64(cfg.SkipIfLessThan) {
 			return
 		}
-		if err := store.GetJobStore().DeleteJobs([]string{types.STATUS_FAILED}, uint64(time.Now().Unix())-cfg.RemoveAfter); err != nil {
+		if err := store.GetJobStore().DeleteJobs([]string{task.STATUS_FAILED}, uint64(time.Now().Unix())-cfg.RemoveAfter); err != nil {
 			log.Error("[ExecClearFailedJobs] error while deleting ExecCleanFailedJobs tasks", "err", err)
 		}
 	})

cmd/bridge/cleaner.go

@@ -1,7 +1,8 @@
 package main
 
 import (
-	"github.com/axieinfinity/bridge-v2/internal/types"
+	bridgeCore "github.com/axieinfinity/bridge-core"
+	bridgeCoreStores "github.com/axieinfinity/bridge-core/stores"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/go-co-op/gocron"
 	"os"
@@ -13,9 +14,9 @@ var wg sync.WaitGroup
 
 func TestCleaner(t *testing.T) {
 	log.Root().SetHandler(log.LvlFilterHandler(log.LvlInfo, log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
-	cfg := &types.Config{
-		Cleaner: types.Cleaner{
-			"TestCleaner": &types.CleanerConfig{
+	cfg := &bridgeCore.Config{
+		Cleaner: bridgeCore.Cleaner{
+			"TestCleaner": &bridgeCore.CleanerConfig{
 				Cron:           "0/1 * * * *",
 				RemoveAfter:    100,
 				SkipIfLessThan: 10,
@@ -34,7 +35,7 @@ func TestCleaner(t *testing.T) {
 	wg.Wait()
 }
 
-func (c *cleaner) ExecTestCleaner(scheduler *gocron.Scheduler, store types.IMainStore, cfg *types.CleanerConfig) error {
+func (c *cleaner) ExecTestCleaner(scheduler *gocron.Scheduler, store bridgeCoreStores.MainStore, cfg *bridgeCore.CleanerConfig) error {
 	_, err := scheduler.Cron(cfg.Cron).Do(func() {
 		println("test cleaner has been reached, cancelling...")
 		wg.Done()