refactor: make pandora great (#657)

This commit allows to easily write ammos with custom conditions.
Not to be able to add a new ammo the only logic required is to implement `Ammo` interface.

Also simultaneous loading to ETH and DWH available (but not recommended).

Author: 3Hren

cmd/pandora/ammo.go

@@ -1,60 +1,40 @@
 package main
 
 import (
-	"fmt"
+	"context"
 	"sync"
 
 	"github.com/yandex/pandora/core"
 )
 
-type AmmoFactory interface {
-	New(id int) core.Ammo
-}
-
-type orderInfoAmmoFactory struct {
-	orderIDs []int64
-	pool     *sync.Pool
-}
-
-func newOrderInfoAmmoFactory(orderIDs []int64, pool *sync.Pool) AmmoFactory {
-	return &orderInfoAmmoFactory{
-		orderIDs: orderIDs,
-		pool:     pool,
-	}
-}
-
-func (m *orderInfoAmmoFactory) New(id int) core.Ammo {
-	orderID := m.orderIDs[id%len(m.orderIDs)]
-
-	ammo := m.pool.Get().(*OrderInfoAmmo)
-	ammo.Message = fmt.Sprintf(`Job #%d %d"`, id, orderID)
-	ammo.OrderID = orderID
+type AmmoType uint8
 
-	return ammo
-}
+type Ammo interface {
+	core.Ammo
 
-type OrderInfoAmmo struct {
-	Message string
-	OrderID int64
+	// Type describes an ammo type used for pooling.
+	// The returned value must be unique across the entire application and also
+	// must be constant.
+	Type() AmmoType
+	Execute(ctx context.Context, ext interface{}) error
 }
 
-type OrderPlaceAmmo struct {
-	Message string
+type AmmoFactory interface {
+	New(id int) Ammo
+	NewDefault() Ammo
+	Pool() *sync.Pool
 }
 
-type orderPlaceAmmoFactory struct {
+type PoolAmmoFactory struct {
 	pool *sync.Pool
 }
 
-func newOrderPlaceAmmoFactory(pool *sync.Pool) AmmoFactory {
-	return &orderPlaceAmmoFactory{
-		pool: pool,
+func newPoolAmmoFactory(fn func() interface{}) PoolAmmoFactory {
+	return PoolAmmoFactory{
+		pool: &sync.Pool{New: fn},
 	}
 }
 
-func (m *orderPlaceAmmoFactory) New(id int) core.Ammo {
-	ammo := m.pool.Get().(*OrderPlaceAmmo)
-	ammo.Message = fmt.Sprintf(`Job #%d"`, id)
-
-	return ammo
+func (m *PoolAmmoFactory) Pool() *sync.Pool {
+	return m.pool
 }

cmd/pandora/ammo_dwh.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"context"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/sonm-io/core/proto"
+	"go.uber.org/zap"
+)
+
+type DWHOrdersAmmo struct {
+	order *sonm.OrdersRequest
+}
+
+func (m *DWHOrdersAmmo) Type() AmmoType {
+	return DWHOrders
+}
+
+func (m *DWHOrdersAmmo) Execute(ctx context.Context, ext interface{}) error {
+	mExt := ext.(*dwhExt)
+	orders, err := mExt.dwh.GetOrders(ctx, m.order)
+	if err != nil {
+		return err
+	}
+
+	mExt.log.Debug("OK", zap.String("ammo", "DWHOrders"), zap.Any("count", len(orders.Orders)))
+
+	return nil
+}
+
+type dwhOrdersAmmoFactory struct {
+	PoolAmmoFactory
+	Orders []*sonm.OrdersRequest
+}
+
+func newDWHOrdersAmmoFactory(cfg interface{}) (AmmoFactory, error) {
+	config := struct {
+		Orders []*sonm.OrdersRequest
+	}{}
+	if err := mapstructure.Decode(cfg, &config); err != nil {
+		return nil, err
+	}
+
+	m := &dwhOrdersAmmoFactory{
+		PoolAmmoFactory: newPoolAmmoFactory(func() interface{} {
+			return &DWHOrdersAmmo{}
+		}),
+		Orders: config.Orders,
+	}
+
+	return m, nil
+}
+
+func (m *dwhOrdersAmmoFactory) New(id int) Ammo {
+	ammo := m.pool.Get().(*DWHOrdersAmmo)
+	ammo.order = m.Orders[id%len(m.Orders)]
+
+	return ammo
+}
+
+func (m *dwhOrdersAmmoFactory) NewDefault() Ammo {
+	return &DWHOrdersAmmo{}
+}

cmd/pandora/ammo_marketplace.go

@@ -0,0 +1,131 @@
+package main
+
+import (
+	"context"
+	"math/big"
+	"math/rand"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/sonm-io/core/proto"
+	"go.uber.org/zap"
+)
+
+const (
+	MarketplaceOrderInfo AmmoType = iota
+	MarketplaceOrderPlace
+	DWHOrders
+)
+
+type OrderInfoAmmo struct {
+	OrderID int64
+}
+
+func (m *OrderInfoAmmo) Type() AmmoType {
+	return MarketplaceOrderInfo
+}
+
+func (m *OrderInfoAmmo) Execute(ctx context.Context, ext interface{}) error {
+	mExt := ext.(*marketplaceExt)
+	order, err := mExt.market.GetOrderInfo(ctx, big.NewInt(m.OrderID))
+	if err != nil {
+		return err
+	}
+
+	mExt.log.Debug("OK", zap.String("ammo", "GetOrderInfo"), zap.Any("order", *order))
+
+	return nil
+}
+
+type orderInfoAmmoFactory struct {
+	PoolAmmoFactory
+	orderIDs []int64
+}
+
+func newOrderInfoAmmoFactory(cfg interface{}) (AmmoFactory, error) {
+	config := struct {
+		OrderIDs []int64 `mapstructure:"order_ids"`
+	}{}
+
+	if err := mapstructure.Decode(cfg, &config); err != nil {
+		return nil, err
+	}
+
+	m := &orderInfoAmmoFactory{
+		PoolAmmoFactory: newPoolAmmoFactory(func() interface{} {
+			return &OrderInfoAmmo{}
+		}),
+		orderIDs: config.OrderIDs,
+	}
+
+	return m, nil
+}
+
+func (m *orderInfoAmmoFactory) New(id int) Ammo {
+	ammo := m.pool.Get().(*OrderInfoAmmo)
+	ammo.OrderID = m.orderIDs[id%len(m.orderIDs)]
+
+	return ammo
+}
+
+func (m *orderInfoAmmoFactory) NewDefault() Ammo {
+	return &OrderInfoAmmo{}
+}
+
+type OrderPlaceAmmo struct{}
+
+func (m *OrderPlaceAmmo) Type() AmmoType {
+	return MarketplaceOrderPlace
+}
+
+func (m *OrderPlaceAmmo) Execute(ctx context.Context, ext interface{}) error {
+	mExt := ext.(*marketplaceExt)
+	orderOrError := <-mExt.market.PlaceOrder(ctx, mExt.privateKey, order())
+	if orderOrError.Err != nil {
+		return orderOrError.Err
+	}
+
+	mExt.log.Debug("OK", zap.String("ammo", "PlaceOrder"), zap.Any("order", *orderOrError.Order))
+
+	return nil
+}
+
+type orderPlaceAmmoFactory struct {
+	PoolAmmoFactory
+}
+
+func newOrderPlaceAmmoFactory(cfg interface{}) (AmmoFactory, error) {
+	m := &orderPlaceAmmoFactory{
+		PoolAmmoFactory: newPoolAmmoFactory(func() interface{} {
+			return &OrderPlaceAmmo{}
+		}),
+	}
+
+	return m, nil
+}
+
+func (m *orderPlaceAmmoFactory) New(id int) Ammo {
+	return m.pool.Get().(*OrderPlaceAmmo)
+}
+
+func (m *orderPlaceAmmoFactory) NewDefault() Ammo {
+	return &OrderPlaceAmmo{}
+}
+
+func order() *sonm.Order {
+	order := &sonm.Order{
+		OrderType:      sonm.OrderType_BID,
+		OrderStatus:    sonm.OrderStatus_ORDER_ACTIVE,
+		CounterpartyID: "0x0",
+		Duration:       3600 + uint64(rand.Int63n(3600)),
+		Price:          sonm.NewBigIntFromInt(1000 + rand.Int63n(1000)),
+		Netflags:       sonm.NetflagsToUint([3]bool{true, true, (rand.Int() % 2) == 0}),
+		IdentityLevel:  sonm.IdentityLevel_ANONYMOUS,
+		Blacklist:      "0x0",
+		Tag:            []byte("00000"),
+		Benchmarks: &sonm.Benchmarks{
+			Values: []uint64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12},
+		},
+	}
+
+	return order
+}

cmd/pandora/common.go

@@ -0,0 +1,60 @@
+package main
+
+import (
+	"context"
+	"crypto/ecdsa"
+	"sync"
+
+	"github.com/sonm-io/core/accounts"
+	"github.com/sonm-io/core/insonmnia/logging"
+	"github.com/sonm-io/core/util"
+	"go.uber.org/zap"
+	"google.golang.org/grpc/credentials"
+)
+
+var (
+	privateKeyGlobal         *ecdsa.PrivateKey
+	privateKeyOnce           sync.Once
+	transportCredentials     credentials.TransportCredentials
+	transportCredentialsOnce sync.Once
+)
+
+func PrivateKey(cfg EthereumConfig) *ecdsa.PrivateKey {
+	privateKeyOnce.Do(func() {
+		ethConfig := accounts.EthConfig{
+			Keystore:   cfg.AccountPath,
+			Passphrase: cfg.AccountPass,
+		}
+
+		privateKey, err := ethConfig.LoadKey(accounts.Silent())
+		if err != nil {
+			panic(err)
+		}
+
+		privateKeyGlobal = privateKey
+	})
+
+	return privateKeyGlobal
+}
+
+func TransportCredentials(privateKey *ecdsa.PrivateKey) credentials.TransportCredentials {
+	transportCredentialsOnce.Do(func() {
+		_, TLSConfig, err := util.NewHitlessCertRotator(context.Background(), privateKey)
+		if err != nil {
+			panic(err)
+		}
+
+		transportCredentials = util.NewTLS(TLSConfig)
+	})
+
+	return transportCredentials
+}
+
+func NewLogger(cfg LoggingConfig) (*zap.Logger, error) {
+	level, err := logging.NewLevelFromString(cfg.Level)
+	if err != nil {
+		return nil, err
+	}
+
+	return logging.BuildLogger(*level), nil
+}

cmd/pandora/config.go

@@ -0,0 +1,11 @@
+package main
+
+type LoggingConfig struct {
+	Level string `config:"level"`
+}
+
+type EthereumConfig struct {
+	Endpoint    string `config:"endpoint"`
+	AccountPath string `config:"account_path"`
+	AccountPass string `config:"account_pass"`
+}