calcuate capacity before creating (#268)

Author: CMGS

.github/workflows/golangci-lint.yml

@@ -16,6 +16,8 @@ jobs:
         uses: actions/checkout@v2
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v1
+        env:
+          ACTIONS_ALLOW_UNSECURE_COMMANDS: 'true'
         with:
           # Required: the version of golangci-lint is required and must be specified without patch version: we always use the latest patch version.
           version: v1.29

cluster/calcium/capacity.go

@@ -0,0 +1,24 @@
+package calcium
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/projecteru2/core/types"
+)
+
+// CalculateCapacity calculates capacity
+func (c *Calcium) CalculateCapacity(ctx context.Context, opts *types.DeployOptions) (msg *types.CapacityMessage, err error) {
+	return msg, c.withNodesLocked(ctx, opts.Podname, opts.Nodenames, nil, true, func(nodeMap map[string]*types.Node) error {
+		var deployMap map[string]int
+		if _, deployMap, err = c.doAllocResource(ctx, nodeMap, opts); err != nil {
+			return errors.WithStack(err)
+		}
+
+		msg = &types.CapacityMessage{NodeCapacities: deployMap}
+		for _, capacity := range deployMap {
+			msg.Total += capacity
+		}
+		return nil
+	})
+}

cluster/calcium/capacity_test.go

@@ -0,0 +1,68 @@
+package calcium
+
+import (
+	"context"
+	"testing"
+
+	enginemocks "github.com/projecteru2/core/engine/mocks"
+	lockmocks "github.com/projecteru2/core/lock/mocks"
+	"github.com/projecteru2/core/scheduler"
+	schedulermocks "github.com/projecteru2/core/scheduler/mocks"
+	storemocks "github.com/projecteru2/core/store/mocks"
+	"github.com/projecteru2/core/strategy"
+	"github.com/projecteru2/core/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func TestCalculateCapacity(t *testing.T) {
+	c := NewTestCluster()
+	scheduler.InitSchedulerV1(c.scheduler)
+	ctx := context.Background()
+	store := c.store.(*storemocks.Store)
+	engine := &enginemocks.API{}
+
+	// pod1 := &types.Pod{Name: "p1"}
+	node1 := &types.Node{
+		Name:   "n1",
+		Engine: engine,
+		CPU:    types.CPUMap{"0": 100, "1": 100},
+	}
+	store.On("GetNode", mock.Anything, mock.Anything).Return(node1, nil)
+	lock := &lockmocks.DistributedLock{}
+	lock.On("Lock", mock.Anything).Return(nil)
+	lock.On("Unlock", mock.Anything).Return(nil)
+	store.On("CreateLock", mock.Anything, mock.Anything).Return(lock, nil)
+	// failed by wrong resource
+	opts := &types.DeployOptions{
+		ResourceOpts: types.ResourceOptions{
+			CPUBind:         true,
+			CPUQuotaRequest: 0,
+		},
+		DeployStrategy: strategy.Auto,
+		Nodenames:      []string{"n1"},
+	}
+	_, err := c.CalculateCapacity(ctx, opts)
+	assert.Error(t, err)
+	opts.ResourceOpts.CPUBind = false
+	opts.ResourceOpts.CPUQuotaRequest = 0.5
+	opts.Count = 5
+	sched := c.scheduler.(*schedulermocks.Scheduler)
+	// define nodesInfo
+	nodesInfo := []types.NodeInfo{
+		{
+			Name:     "n1",
+			MemCap:   100,
+			Deploy:   5,
+			Capacity: 10,
+			Count:    1,
+		},
+	}
+	sched.On("SelectMemoryNodes", mock.Anything, mock.Anything, mock.Anything).Return(nodesInfo, 5, nil)
+	sched.On("SelectStorageNodes", mock.Anything, mock.Anything).Return(nodesInfo, 5, nil)
+	sched.On("SelectVolumeNodes", mock.Anything, mock.Anything).Return(nodesInfo, nil, 5, nil)
+	store.On("MakeDeployStatus", mock.Anything, mock.Anything, mock.Anything).Return(nil)
+	r, err := c.CalculateCapacity(ctx, opts)
+	assert.NoError(t, err)
+	assert.Equal(t, r.Total, 5)
+}

cluster/cluster.go

@@ -57,6 +57,8 @@ type Cluster interface {
 	SetNode(ctx context.Context, opts *types.SetNodeOptions) (*types.Node, error)
 	// node resource
 	NodeResource(ctx context.Context, nodename string, fix bool) (*types.NodeResource, error)
+	// calculate capacity
+	CalculateCapacity(context.Context, *types.DeployOptions) (*types.CapacityMessage, error)
 	// meta containers
 	GetContainer(ctx context.Context, ID string) (*types.Container, error)
 	GetContainers(ctx context.Context, IDs []string) ([]*types.Container, error)