Merge pull request #669 from threefoldtech/development_farmerbot_vali…

…dations

check farmer twin id

farmerbot/README.md

@@ -6,6 +6,8 @@ Farmerbot is a service that farmers can run allowing them to automatically manag
 
 ## How to use
 
+> :warning: **Be careful**: Make sure to run one farmerbot for each farm, otherwise the relay connection will close in all instances.
+
 > :warning: **Be careful**: The timezone of the farmerbot will be the same as the time zone of the machine the farmerbot running inside.
 
 - add your [configurations](#config)
@@ -90,7 +92,7 @@ make build
 
 ```yml
 farm_id: "<your farm ID, required>"
-included_nodes:
+included_nodes: [optional, if no nodes are added then the farmerbot will include all nodes in the farm, farm should contain at least 2 nodes]
   - "<your node ID to be included, required at least 2>"
 excluded_nodes:
   - "<your node ID to be excluded, optional>"

farmerbot/internal/farmerbot.go

@@ -25,6 +25,7 @@ type FarmerBot struct {
 	mnemonicOrSeed   string
 	keyType          string
 	identity         substrate.Identity
+	twinID           uint32
 }
 
 // NewFarmerBot generates a new farmer bot
@@ -55,7 +56,13 @@ func NewFarmerBot(ctx context.Context, config Config, network, mnemonicOrSeed, k
 	}
 	defer subConn.Close()
 
-	state, err := newState(ctx, subConn, farmerbot.rmbNodeClient, config)
+	twinID, err := subConn.GetTwinByPubKey(identity.PublicKey())
+	if err != nil {
+		return FarmerBot{}, err
+	}
+	farmerbot.twinID = twinID
+
+	state, err := newState(ctx, subConn, farmerbot.rmbNodeClient, config, twinID)
 	if err != nil {
 		return FarmerBot{}, err
 	}
@@ -122,11 +129,6 @@ func (f *FarmerBot) serve(ctx context.Context) error {
 		log.Warn().Float64("current balance", balance).Msgf("Recommended balance to run farmerbot is %v tft", recommendedBalanceToRun)
 	}
 
-	farmerTwinID, err := subConn.GetTwinByPubKey(f.identity.PublicKey())
-	if err != nil {
-		return err
-	}
-
 	farmRouter.WithHandler("version", func(ctx context.Context, payload []byte) (interface{}, error) {
 		return version.Version, nil
 	})
@@ -152,7 +154,7 @@ func (f *FarmerBot) serve(ctx context.Context) error {
 	})
 
 	powerRouter.WithHandler("includenode", func(ctx context.Context, payload []byte) (interface{}, error) {
-		err := authorize(ctx, farmerTwinID)
+		err := authorize(ctx, f.twinID)
 		if err != nil {
 			return nil, err
 		}
@@ -183,7 +185,7 @@ func (f *FarmerBot) serve(ctx context.Context) error {
 	})
 
 	powerRouter.WithHandler("poweroff", func(ctx context.Context, payload []byte) (interface{}, error) {
-		err := authorize(ctx, farmerTwinID)
+		err := authorize(ctx, f.twinID)
 		if err != nil {
 			return nil, err
 		}
@@ -209,7 +211,7 @@ func (f *FarmerBot) serve(ctx context.Context) error {
 	})
 
 	powerRouter.WithHandler("poweron", func(ctx context.Context, payload []byte) (interface{}, error) {
-		err := authorize(ctx, farmerTwinID)
+		err := authorize(ctx, f.twinID)
 		if err != nil {
 			return nil, err
 		}

farmerbot/internal/farmerbot_test.go

@@ -14,7 +14,10 @@ import (
 	"github.com/threefoldtech/zos/pkg/gridtypes"
 )
 
-const aliceSeed = "0xe5be9a5092b81bca64be81d212e7f2f9eba183bb7a90954f7b76361f6edb5c0a"
+const (
+	aliceSeed  = "0xe5be9a5092b81bca64be81d212e7f2f9eba183bb7a90954f7b76361f6edb5c0a"
+	farmTwinID = 1
+)
 
 func TestFarmerbot(t *testing.T) {
 	ctrl := gomock.NewController(t)
@@ -38,7 +41,7 @@ func TestFarmerbot(t *testing.T) {
 	resources := gridtypes.Capacity{HRU: 1, SRU: 1, CRU: 1, MRU: 1}
 	mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 
-	state, err := newState(ctx, sub, rmb, inputs)
+	state, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 	assert.NoError(t, err)
 	farmerbot.state = state
 

farmerbot/internal/find_node_test.go

@@ -36,7 +36,7 @@ func TestFindNode(t *testing.T) {
 	resources := gridtypes.Capacity{HRU: gridtypes.Unit(convertGBToBytes(1)), SRU: gridtypes.Unit(convertGBToBytes(1)), CRU: 1, MRU: gridtypes.Unit(convertGBToBytes(1))}
 	mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 
-	state, err := newState(ctx, sub, rmb, inputs)
+	state, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 	assert.NoError(t, err)
 	farmerbot.state = state
 

farmerbot/internal/power_test.go

@@ -36,7 +36,7 @@ func TestPower(t *testing.T) {
 	resources := gridtypes.Capacity{HRU: 1, SRU: 1, CRU: 1, MRU: 1}
 	mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 
-	state, err := newState(ctx, sub, rmb, inputs)
+	state, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 	assert.NoError(t, err)
 	farmerbot.state = state
 

farmerbot/internal/state.go

@@ -21,7 +21,7 @@ type state struct {
 }
 
 // NewState creates new state from configs
-func newState(ctx context.Context, sub Substrate, rmbNodeClient RMB, cfg Config) (*state, error) {
+func newState(ctx context.Context, sub Substrate, rmbNodeClient RMB, cfg Config, twinID uint32) (*state, error) {
 	s := state{config: cfg}
 
 	// required from power for nodes
@@ -38,6 +38,10 @@ func newState(ctx context.Context, sub Substrate, rmbNodeClient RMB, cfg Config)
 		return nil, err
 	}
 
+	if twinID != uint32(farm.TwinID) {
+		return nil, fmt.Errorf("you are not authorized to run the farmerbot on farm %d. your twin id is `%d`, only the farm owner with twin id `%d` is authorized", farm.ID, twinID, farm.TwinID)
+	}
+
 	s.farm = *farm
 
 	nodes, err := fetchNodes(ctx, sub, rmbNodeClient, cfg, farm.DedicatedFarm)

farmerbot/internal/state_test.go

@@ -26,7 +26,7 @@ func mockRMBAndSubstrateCalls(
 
 	// farm calls
 	if !noFarm {
-		sub.EXPECT().GetFarm(inputs.FarmID).Return(&substrate.Farm{ID: 1, DedicatedFarm: true, PublicIPs: []substrate.PublicIP{{IP: "1.1.1.1"}}}, farmErr)
+		sub.EXPECT().GetFarm(inputs.FarmID).Return(&substrate.Farm{ID: 1, TwinID: farmTwinID, DedicatedFarm: true, PublicIPs: []substrate.PublicIP{{IP: "1.1.1.1"}}}, farmErr)
 		if farmErr != nil {
 			return
 		}
@@ -123,7 +123,7 @@ func TestSetConfig(t *testing.T) {
 	t.Run("test valid state: no periodic wake up start, wakeup threshold (< min => min)", func(t *testing.T) {
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 
-		state, err := newState(ctx, sub, rmb, inputs)
+		state, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.NoError(t, err)
 		assert.Equal(t, uint32(state.farm.ID), uint32(1))
 		assert.True(t, state.nodes[1].dedicated)
@@ -144,7 +144,7 @@ func TestSetConfig(t *testing.T) {
 
 		inputs.Power.WakeUpThreshold = 100
 
-		state, err := newState(ctx, sub, rmb, inputs)
+		state, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.NoError(t, err)
 		assert.Equal(t, state.config.Power.WakeUpThreshold, maxWakeUpThreshold)
 	})
@@ -154,7 +154,7 @@ func TestSetConfig(t *testing.T) {
 
 		inputs.Power.WakeUpThreshold = 0
 
-		state, err := newState(ctx, sub, rmb, inputs)
+		state, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.NoError(t, err)
 		assert.Equal(t, state.config.Power.WakeUpThreshold, defaultWakeUpThreshold)
 	})
@@ -163,7 +163,7 @@ func TestSetConfig(t *testing.T) {
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 		inputs.Power.WakeUpThreshold = 110
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.Error(t, err)
 
 		inputs.Power.WakeUpThreshold = defaultWakeUpThreshold
@@ -172,14 +172,14 @@ func TestSetConfig(t *testing.T) {
 	t.Run("test valid state: nodes are off in substrate", func(t *testing.T) {
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, false, false, resources, []string{}, false, false)
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.NoError(t, err)
 	})
 
 	t.Run("test invalid state: cpu provision out of range", func(t *testing.T) {
 		inputs.Power.OverProvisionCPU = 6
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.Error(t, err)
 
 		inputs.Power.OverProvisionCPU = 0
@@ -191,15 +191,15 @@ func TestSetConfig(t *testing.T) {
 		for _, call := range calls {
 			mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{call}, false, false)
 
-			_, err := newState(ctx, sub, rmb, inputs)
+			_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 			assert.Error(t, err)
 		}
 	})
 
 	t.Run("test invalid state: rent contract doesn't exist", func(t *testing.T) {
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{"rentNotExist"}, false, false)
 
-		state, err := newState(ctx, sub, rmb, inputs)
+		state, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.NoError(t, err)
 		assert.False(t, state.nodes[1].hasActiveRentContract)
 	})
@@ -209,7 +209,7 @@ func TestSetConfig(t *testing.T) {
 
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.NoError(t, err)
 
 		inputs.ExcludedNodes = []uint32{}
@@ -221,56 +221,56 @@ func TestSetConfig(t *testing.T) {
 
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.Error(t, err)
 
 		inputs.ExcludedNodes = []uint32{}
 		inputs.IncludedNodes = []uint32{1, 2}
 	})
 
 	t.Run("test invalid state no farm ID", func(t *testing.T) {
-		sub.EXPECT().GetFarm(inputs.FarmID).Return(&substrate.Farm{ID: 0}, nil)
+		sub.EXPECT().GetFarm(inputs.FarmID).Return(&substrate.Farm{ID: 0, TwinID: farmTwinID}, nil)
 		sub.EXPECT().GetNodes(inputs.FarmID).Return([]uint32{}, nil)
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.Error(t, err)
 	})
 
 	t.Run("test invalid state no node ID", func(t *testing.T) {
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, true, false)
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.Error(t, err)
 	})
 
 	t.Run("test invalid state no twin ID", func(t *testing.T) {
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, true)
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.Error(t, err)
 	})
 
 	t.Run("test invalid state no node sru", func(t *testing.T) {
 		resources := gridtypes.Capacity{HRU: 1, SRU: 0, CRU: 1, MRU: 1}
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.Error(t, err)
 	})
 
 	t.Run("test invalid state no cru", func(t *testing.T) {
 		resources := gridtypes.Capacity{HRU: 1, SRU: 1, CRU: 0, MRU: 1}
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.Error(t, err)
 	})
 
 	t.Run("test invalid state no mru", func(t *testing.T) {
 		resources := gridtypes.Capacity{HRU: 1, SRU: 1, CRU: 1, MRU: 0}
 		mockRMBAndSubstrateCalls(ctx, sub, rmb, inputs, true, false, resources, []string{}, false, false)
 
-		_, err := newState(ctx, sub, rmb, inputs)
+		_, err := newState(ctx, sub, rmb, inputs, farmTwinID)
 		assert.Error(t, err)
 	})
 }