feat: support get instanceType from node anno

daemon/builder.go

@@ -171,22 +171,39 @@
 }
 
 func (b *NetworkServiceBuilder) initInstanceLimit() error {
-	instanceType := instance.GetInstanceMeta().InstanceType
-
+	node := b.service.k8s.Node()
+	if node == nil {
+		return fmt.Errorf("k8s node not found")
+	}
 	provider := client.LimitProviders["ecs"]
 	if os.Getenv("TERWAY_DEPLOY_ENV") == envEFLO {
-		instanceType = instance.GetInstanceMeta().InstanceID
-
 		provider = client.LimitProviders["eflo"]
+		limit, err := provider.GetLimitFromAnno(node.Annotations)
+		if err != nil {
+			return err
+		}
+		if limit == nil {
+			limit, err = provider.GetLimit(b.aliyunClient, instance.GetInstanceMeta().InstanceID)
+			if err != nil {
+				return fmt.Errorf("upable get instance limit, %w", err)
+			}
+		}
+		b.limit = limit
+	} else {
+		limit, err := provider.GetLimitFromAnno(node.Annotations)
+		if err != nil {
+			return err
+		}
+		if limit == nil || instance.GetInstanceMeta().InstanceType != limit.InstanceTypeID {
+			limit, err = provider.GetLimit(b.aliyunClient, instance.GetInstanceMeta().InstanceType)
+			if err != nil {
+				return fmt.Errorf("upable get instance limit, %w", err)
+			}
+		}
+		b.limit = limit
 	}
-	limit, err := provider.GetLimit(b.aliyunClient, instanceType)
-	if err != nil {
-		return fmt.Errorf("upable get instance limit, %w", err)
-	}
-
-	b.limit = limit
 
-	b.service.enableIPv4, b.service.enableIPv6 = checkInstance(limit, b.daemonMode, b.config)
+	b.service.enableIPv4, b.service.enableIPv6 = checkInstance(b.limit, b.daemonMode, b.config)
 	return nil
 }
 

pkg/aliyun/client/ecs.go

@@ -461,14 +461,14 @@
 		resp, err := a.ClientSet.ECS().DescribeInstanceTypes(req)
 		metric.OpenAPILatency.WithLabelValues("DescribeInstanceTypes", fmt.Sprint(err != nil)).Observe(metric.MsSince(start))
 
-		l := logf.FromContext(ctx).WithValues(
-			LogFieldAPI, "DescribeInstanceTypes",
-		)
+		l := LogFields(logf.FromContext(ctx), req)
+
 		if err != nil {
 			err = apiErr.WarpError(err)
 			l.WithValues(LogFieldRequestID, apiErr.ErrRequestID(err)).Error(err, "describe instance types failed")
 			return nil, err
 		}
+		l.WithValues(LogFieldRequestID, resp.RequestId).Info("success")
 
 		result = append(result, resp.InstanceTypes.InstanceType...)
 

pkg/aliyun/client/limit.go

@@ -4,15 +4,19 @@
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"time"
 
+	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
 	"k8s.io/apimachinery/pkg/util/cache"
 	logf "sigs.k8s.io/controller-runtime/pkg/log"
 )
 
 // Limits specifies the IPAM relevant instance limits
 type Limits struct {
+	InstanceTypeID string
+
 	// Adapters specifies the maximum number of interfaces that can be
 	// attached to the instance
 	Adapters int
@@ -71,6 +75,7 @@
 
 type LimitProvider interface {
 	GetLimit(client interface{}, instanceType string) (*Limits, error)
+	GetLimitFromAnno(anno map[string]string) (*Limits, error)
 }
 
 type EfloLimitProvider struct{}
@@ -96,6 +101,10 @@
 	}, nil
 }
 
+func (e *EfloLimitProvider) GetLimitFromAnno(anno map[string]string) (*Limits, error) {
+	return nil, nil
+}
+
 type ECSLimitProvider struct {
 	cache cache.LRUExpireCache
 	ttl   time.Duration
@@ -128,42 +137,11 @@
 
 	for _, instanceTypeInfo := range ins {
 		instanceTypeID := instanceTypeInfo.InstanceTypeId
-		adapterLimit := instanceTypeInfo.EniQuantity
-		ipv4PerAdapter := instanceTypeInfo.EniPrivateIpAddressQuantity
-		ipv6PerAdapter := instanceTypeInfo.EniIpv6AddressQuantity
-		memberAdapterLimit := instanceTypeInfo.EniTotalQuantity - instanceTypeInfo.EniQuantity
-		eRdmaLimit := instanceTypeInfo.EriQuantity
-		// exclude eth0 eth1
-		maxMemberAdapterLimit := instanceTypeInfo.EniTotalQuantity - 2
-		if !instanceTypeInfo.EniTrunkSupported {
-			memberAdapterLimit = 0
-			maxMemberAdapterLimit = 0
-		}
-
-		d.cache.Add(instanceTypeID, &Limits{
-			Adapters:              adapterLimit,
-			TotalAdapters:         instanceTypeInfo.EniTotalQuantity,
-			IPv4PerAdapter:        max(ipv4PerAdapter, 0),
-			IPv6PerAdapter:        max(ipv6PerAdapter, 0),
-			MemberAdapterLimit:    max(memberAdapterLimit, 0),
-			MaxMemberAdapterLimit: max(maxMemberAdapterLimit, 0),
-			ERdmaAdapters:         max(eRdmaLimit, 0),
-			InstanceBandwidthRx:   instanceTypeInfo.InstanceBandwidthRx,
-			InstanceBandwidthTx:   instanceTypeInfo.InstanceBandwidthTx,
-		}, d.ttl)
-		logf.Log.WithValues(
-			"instance-type", instanceType,
-			"adapters", adapterLimit,
-			"total-adapters", instanceTypeInfo.EniTotalQuantity,
-			"ipv4", ipv4PerAdapter,
-			"ipv6", ipv6PerAdapter,
-			"member-adapters", memberAdapterLimit,
-			"erdma-adapters", eRdmaLimit,
-			"max-member-adapters", maxMemberAdapterLimit,
-			"bandwidth-rx", instanceTypeInfo.InstanceBandwidthRx,
-			"bandwidth-tx", instanceTypeInfo.InstanceBandwidthTx,
-		).Info("instance limit")
 
+		limit := getInstanceType(&instanceTypeInfo)
+
+		d.cache.Add(instanceTypeID, limit, d.ttl)
+		logf.Log.Info("instance limit", instanceTypeID, limit)
 	}
 	if instanceType == "" {
 		return nil, nil
@@ -176,6 +154,47 @@
 	return v.(*Limits), nil
 }
 
+func (d *ECSLimitProvider) GetLimitFromAnno(anno map[string]string) (*Limits, error) {
+	v, ok := anno["alibabacloud.com/instance-type-info"]
+	if !ok {
+		return nil, nil
+	}
+
+	instanceType := &ecs.InstanceType{}
+	err := json.Unmarshal([]byte(v), instanceType)
+	if err != nil {
+		return nil, err
+	}
+
+	return getInstanceType(instanceType), nil
+}
+
+func getInstanceType(instanceTypeInfo *ecs.InstanceType) *Limits {
+	adapterLimit := instanceTypeInfo.EniQuantity
+	ipv4PerAdapter := instanceTypeInfo.EniPrivateIpAddressQuantity
+	ipv6PerAdapter := instanceTypeInfo.EniIpv6AddressQuantity
+	memberAdapterLimit := instanceTypeInfo.EniTotalQuantity - instanceTypeInfo.EniQuantity
+	eRdmaLimit := instanceTypeInfo.EriQuantity
+	// exclude eth0 eth1
+	maxMemberAdapterLimit := instanceTypeInfo.EniTotalQuantity - 2
+	if !instanceTypeInfo.EniTrunkSupported {
+		memberAdapterLimit = 0
+		maxMemberAdapterLimit = 0
+	}
+	return &Limits{
+		InstanceTypeID:        instanceTypeInfo.InstanceTypeId,
+		Adapters:              adapterLimit,
+		TotalAdapters:         instanceTypeInfo.EniTotalQuantity,
+		IPv4PerAdapter:        max(ipv4PerAdapter, 0),
+		IPv6PerAdapter:        max(ipv6PerAdapter, 0),
+		MemberAdapterLimit:    max(memberAdapterLimit, 0),
+		MaxMemberAdapterLimit: max(maxMemberAdapterLimit, 0),
+		ERdmaAdapters:         max(eRdmaLimit, 0),
+		InstanceBandwidthRx:   instanceTypeInfo.InstanceBandwidthRx,
+		InstanceBandwidthTx:   instanceTypeInfo.InstanceBandwidthTx,
+	}
+}
+
 var ecsProvider LimitProvider
 var efloProvider LimitProvider
 

pkg/aliyun/client/limit_test.go

@@ -0,0 +1,126 @@
+package client
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/aliyun/alibaba-cloud-sdk-go/services/ecs"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGetInstanceType(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    *ecs.InstanceType
+		expected *Limits
+	}{
+		{
+			name: "Basic instance type",
+			input: &ecs.InstanceType{
+				EniQuantity:                 4,
+				EniPrivateIpAddressQuantity: 5,
+				EniIpv6AddressQuantity:      10,
+				EniTotalQuantity:            6,
+				EriQuantity:                 2,
+				InstanceBandwidthRx:         1000,
+				InstanceBandwidthTx:         500,
+				EniTrunkSupported:           true,
+			},
+			expected: &Limits{
+				Adapters:              4,
+				TotalAdapters:         6,
+				IPv4PerAdapter:        5,
+				IPv6PerAdapter:        10,
+				MemberAdapterLimit:    2,
+				MaxMemberAdapterLimit: 4,
+				ERdmaAdapters:         2,
+				InstanceBandwidthRx:   1000,
+				InstanceBandwidthTx:   500,
+			},
+		},
+		{
+			name: "Trunk not supported",
+			input: &ecs.InstanceType{
+				EniQuantity:                 4,
+				EniPrivateIpAddressQuantity: 5,
+				EniIpv6AddressQuantity:      10,
+				EniTotalQuantity:            6,
+				EriQuantity:                 2,
+				InstanceBandwidthRx:         1000,
+				InstanceBandwidthTx:         500,
+				EniTrunkSupported:           false,
+			},
+			expected: &Limits{
+				Adapters:              4,
+				TotalAdapters:         6,
+				IPv4PerAdapter:        5,
+				IPv6PerAdapter:        10,
+				MemberAdapterLimit:    0,
+				MaxMemberAdapterLimit: 0,
+				ERdmaAdapters:         2,
+				InstanceBandwidthRx:   1000,
+				InstanceBandwidthTx:   500,
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			actual := getInstanceType(tt.input)
+			assert.Equal(t, tt.expected, actual)
+		})
+	}
+}
+
+func TestECSLimitProvider_GetLimitFromAnno(t *testing.T) {
+
+	type args struct {
+		anno map[string]string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    *Limits
+		wantErr assert.ErrorAssertionFunc
+	}{
+		{
+			name: "test value",
+			args: args{
+				anno: map[string]string{
+					"alibabacloud.com/instance-type-info": "{\"InstancePpsTx\":24000000,\"NvmeSupport\":\"unsupported\",\"PrimaryEniQueueNumber\":32,\"TotalEniQueueQuantity\":528,\"EniTrunkSupported\":true,\"InstanceTypeFamily\":\"ecs.ebmre7p\",\"InstancePpsRx\":24000000,\"EriQuantity\":0,\"InstanceBandwidthRx\":65536000,\"EnhancedNetwork\":{},\"InstanceBandwidthTx\":65536000,\"SecondaryEniQueueNumber\":16,\"LocalStorageCategory\":\"\",\"InstanceTypeId\":\"ecs.ebmre7p.32xlarge\",\"EniIpv6AddressQuantity\":1,\"EniTotalQuantity\":110,\"EniQuantity\":32,\"DiskQuantity\":17,\"EniPrivateIpAddressQuantity\":15}",
+				},
+			},
+			want: &Limits{
+				InstanceTypeID:        "ecs.ebmre7p.32xlarge",
+				Adapters:              32,
+				TotalAdapters:         110,
+				IPv4PerAdapter:        15,
+				IPv6PerAdapter:        1,
+				MemberAdapterLimit:    78,
+				MaxMemberAdapterLimit: 108,
+				ERdmaAdapters:         0,
+				InstanceBandwidthRx:   65536000,
+				InstanceBandwidthTx:   65536000,
+			},
+			wantErr: assert.NoError,
+		},
+		{
+			name: "test empty",
+			args: args{
+				anno: map[string]string{},
+			},
+			want:    nil,
+			wantErr: assert.NoError,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			d := &ECSLimitProvider{}
+			got, err := d.GetLimitFromAnno(tt.args.anno)
+			if !tt.wantErr(t, err, fmt.Sprintf("GetLimitFromAnno(%v)", tt.args.anno)) {
+				return
+			}
+			assert.Equalf(t, tt.want, got, "GetLimitFromAnno(%v)", tt.args.anno)
+		})
+	}
+}

pkg/eni/local_windows.go

@@ -1,6 +1,7 @@
 package eni
 
 import (
+	"context"
 	"strings"
 	"time"
 

pkg/eni/manager_test.go

@@ -243,3 +243,7 @@ func (f *FakeK8s) GetClient() client.Client {
 func (f *FakeK8s) PodExist(namespace, name string) (bool, error) {
 	panic("implement me")
 }
+
+func (f *FakeK8s) Node() *corev1.Node {
+	panic("implement me")
+}

pkg/k8s/k8s.go

@@ -105,6 +105,8 @@ type Kubernetes interface {
 	GetClient() client.Client
 
 	NodeName() string
+
+	Node() *corev1.Node
 }
 
 // NewK8S return Kubernetes service by pod spec and daemon mode
@@ -549,6 +551,10 @@ func (k *k8s) NodeName() string {
 	return k.nodeName
 }
 
+func (k *k8s) Node() *corev1.Node {
+	return k.node
+}
+
 func podNetworkType(daemonMode string, pod *corev1.Pod) string {
 	switch daemonMode {
 	case daemon.ModeENIMultiIP: