isolated device add attribute reserved resource

cmd/climc/shell/compute/hosts.go

@@ -815,4 +815,20 @@ func init() {
 		printObject(result)
 		return nil
 	})
+
+	type HostSetReservedResourceForIsolatedDevice struct {
+		ID              []string `help:"ID or name of host" json:"-"`
+		ReservedCpu     *int     `help:"reserved cpu count"`
+		ReservedMem     *int     `help:"reserved mem count"`
+		ReservedStorage *int     `help:"reserved storage count"`
+	}
+	R(&HostSetReservedResourceForIsolatedDevice{},
+		"host-set-reserved-resource-for-isolated-device",
+		"Set reserved resource for isolated device",
+		func(s *mcclient.ClientSession, args *HostSetReservedResourceForIsolatedDevice) error {
+			res := modules.Hosts.BatchPerformAction(s, args.ID, "set-reserved-resource-for-isolated-device", jsonutils.Marshal(args))
+			printBatchResults(res, modules.Hosts.GetColumns(s))
+			return nil
+		},
+	)
 }

cmd/climc/shell/compute/isolatedevices.go

@@ -84,4 +84,16 @@ func init() {
 		printObject(result)
 		return nil
 	})
+
+	type DeviceUpdateOptions struct {
+		ID              []string `help:"ID of the isolated device" json:"-"`
+		ReservedCpu     *int     `help:"reserved cpu for isolated device"`
+		ReservedMem     *int     `help:"reserved mem for isolated device"`
+		ReservedStorage *int     `help:"reserved storage for isolated device"`
+	}
+	R(&DeviceUpdateOptions{}, "isolated-device-update", "Update a isolated device", func(s *mcclient.ClientSession, args *DeviceUpdateOptions) error {
+		res := modules.IsolatedDevices.BatchUpdate(s, args.ID, jsonutils.Marshal(args))
+		printBatchResults(res, modules.IsolatedDevices.GetColumns(s))
+		return nil
+	})
 }

pkg/apis/compute/host.go

@@ -166,6 +166,9 @@ type HostDetails struct {
 	// 允许开启宿主机健康检查
 	AllowHealthCheck bool `json:"allow_health_check"`
 
+	// reserved resource for isolated device
+	ReservedResourceForGpu IsolatedDeviceReservedResourceInput `json:"reserved_resource_for_gpu"`
+
 	// 标签
 	Metadata map[string]string `json:"metadata"`
 }

pkg/apis/compute/isolated_device.go

@@ -59,6 +59,7 @@ type IsolatedDeviceCreateInput struct {
 	apis.StandaloneResourceCreateInput
 
 	HostResourceInput
+	IsolatedDeviceReservedResourceInput
 
 	// 设备类型USB/GPU
 	// example: GPU
@@ -75,3 +76,19 @@ type IsolatedDeviceCreateInput struct {
 	// 设备VendorId
 	VendorDeviceId string `json:"vendor_device_id"`
 }
+
+type IsolatedDeviceReservedResourceInput struct {
+	// GPU 预留内存
+	ReservedMemory *int `json:"reserved_memory"`
+
+	// GPU 预留CPU
+	ReservedCpu *int `json:"reserved_cpu"`
+
+	// GPU 预留磁盘
+	ReservedStorage *int `json:"reserved_storage"`
+}
+
+type IsolatedDeviceUpdateInput struct {
+	apis.StandaloneResourceBaseUpdateInput
+	IsolatedDeviceReservedResourceInput
+}

pkg/compute/models/hosts.go

@@ -2604,9 +2604,36 @@ func (self *SHost) getMoreDetails(ctx context.Context, out api.HostDetails, show
 	if self.EnableHealthCheck && hostHealthChecker != nil {
 		out.AllowHealthCheck = true
 	}
+
+	if rs := self.GetReservedResourceForIsolatedDevice(); rs != nil {
+		out.ReservedResourceForGpu = *rs
+	}
 	return out
 }
 
+func (self *SHost) GetReservedResourceForIsolatedDevice() *api.IsolatedDeviceReservedResourceInput {
+	if devs := IsolatedDeviceManager.FindByHost(self.Id); len(devs) == 0 {
+		return nil
+	} else {
+		return self.GetDevsReservedResource(devs)
+	}
+}
+
+func (self *SHost) GetDevsReservedResource(devs []SIsolatedDevice) *api.IsolatedDeviceReservedResourceInput {
+	reservedCpu, reservedMem, reservedStorage := 0, 0, 0
+	reservedResourceForGpu := api.IsolatedDeviceReservedResourceInput{
+		ReservedStorage: &reservedStorage,
+		ReservedMemory:  &reservedMem,
+		ReservedCpu:     &reservedCpu,
+	}
+	for _, dev := range devs {
+		reservedCpu += dev.ReservedCpu
+		reservedMem += dev.ReservedMemory
+		reservedStorage += dev.ReservedStorage
+	}
+	return &reservedResourceForGpu
+}
+
 func (self *SHost) GetMetadataHiddenKeys() []string {
 	return []string{}
 }
@@ -5153,6 +5180,66 @@ func (host *SHost) PerformPrivate(ctx context.Context, userCred mcclient.TokenCr
 	return host.SEnabledStatusInfrasResourceBase.PerformPrivate(ctx, userCred, query, input)
 }
 
+func (host *SHost) AllowPerformSetReservedResourceForIsolatedDevice(
+	ctx context.Context, userCred mcclient.TokenCredential,
+	query jsonutils.JSONObject, input api.IsolatedDeviceReservedResourceInput,
+) bool {
+	return db.IsDomainAllowPerform(userCred, host, "set-reserved-resource-for-isolated-device")
+}
+
+func (host *SHost) PerfromSetReservedResourceForIsolatedDevice(
+	ctx context.Context, userCred mcclient.TokenCredential,
+	query jsonutils.JSONObject, input api.IsolatedDeviceReservedResourceInput,
+) (jsonutils.JSONObject, error) {
+	if input.ReservedCpu != nil && *input.ReservedCpu < 0 {
+		return nil, httperrors.NewInputParameterError("reserved cpu must >= 0")
+	}
+	if input.ReservedMemory != nil && *input.ReservedMemory < 0 {
+		return nil, httperrors.NewInputParameterError("reserved memory must >= 0")
+	}
+	if input.ReservedStorage != nil && *input.ReservedStorage < 0 {
+		return nil, httperrors.NewInputParameterError("reserved storage must >= 0")
+	}
+	devs := IsolatedDeviceManager.FindByHost(host.Id)
+	if len(devs) == 0 {
+		return nil, nil
+	}
+	if input.ReservedCpu != nil && host.GetCpuCount() < *input.ReservedCpu*len(devs) {
+		return nil, httperrors.NewBadRequestError(
+			"host %s can't reserve %d cpu for each isolated device, not enough", host.Name, *input.ReservedCpu)
+	}
+	if input.ReservedMemory != nil && host.GetMemSize() < *input.ReservedMemory*len(devs) {
+		return nil, httperrors.NewBadRequestError(
+			"host %s can't reserve %dM memory for each isolated device, not enough", host.Name, *input.ReservedMemory)
+	}
+	caps := host.GetAttachedLocalStorageCapacity()
+	if input.ReservedStorage != nil && caps.Capacity < int64(*input.ReservedStorage*len(devs)) {
+		return nil, httperrors.NewBadRequestError(
+			"host %s can't reserve %dM storage for each isolated device, not enough")
+	}
+	defer func() {
+		go host.ClearSchedDescCache()
+	}()
+	for i := 0; i < len(devs); i++ {
+		_, err := db.Update(&devs[i], func() error {
+			if input.ReservedCpu != nil {
+				devs[i].ReservedCpu = *input.ReservedCpu
+			}
+			if input.ReservedMemory != nil {
+				devs[i].ReservedMemory = *input.ReservedMemory
+			}
+			if input.ReservedStorage != nil {
+				devs[i].ReservedStorage = *input.ReservedStorage
+			}
+			return nil
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "update isolated device")
+		}
+	}
+	return nil, nil
+}
+
 func (manager *SHostManager) ListItemExportKeys(ctx context.Context,
 	q *sqlchemy.SQuery,
 	userCred mcclient.TokenCredential,

pkg/compute/models/isolated_devices.go

@@ -94,6 +94,15 @@ type SIsolatedDevice struct {
 	Addr string `width:"16" charset:"ascii" nullable:"true" list:"domain" update:"domain" create:"domain_optional"`
 
 	VendorDeviceId string `width:"16" charset:"ascii" nullable:"true" list:"domain" create:"domain_optional"`
+
+	// reserved memory size for isolated device, default 8G
+	ReservedMemory int `nullable:"true" default:"8192" list:"domain" update:"domain" create:"domain_optional"`
+
+	// reserved cpu count for isolated device, default 8
+	ReservedCpu int `nullable:"true" default:"8" list:"domain" update:"domain" create:"domain_optional"`
+
+	// reserved storage size for isolated device, default 100G
+	ReservedStorage int `nullable:"true" default:"102400" list:"domain" update:"domain" create:"domain_optional"`
 }
 
 func (manager *SIsolatedDeviceManager) AllowListItems(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject) bool {
@@ -134,13 +143,48 @@ func (manager *SIsolatedDeviceManager) ValidateCreateData(ctx context.Context,
 		return input, errors.Wrap(err, "SStandaloneResourceBaseManager.ValidateCreateData")
 	}
 
+	if input.ReservedCpu != nil && *input.ReservedCpu < 0 {
+		return input, httperrors.NewInputParameterError("reserved cpu must >= 0")
+	}
+	if input.ReservedMemory != nil && *input.ReservedMemory < 0 {
+		return input, httperrors.NewInputParameterError("reserved memory must >= 0")
+	}
+	if input.ReservedStorage != nil && *input.ReservedStorage < 0 {
+		return input, httperrors.NewInputParameterError("reserved storage must >= 0")
+	}
 	return input, nil
 }
 
 func (self *SIsolatedDevice) AllowUpdateItem(ctx context.Context, userCred mcclient.TokenCredential) bool {
 	return db.IsAdminAllowUpdate(userCred, self)
 }
 
+func (self *SIsolatedDevice) ValidateUpdateData(
+	ctx context.Context, userCred mcclient.TokenCredential,
+	query jsonutils.JSONObject, input api.IsolatedDeviceUpdateInput,
+) (api.IsolatedDeviceUpdateInput, error) {
+	var err error
+	input.StandaloneResourceBaseUpdateInput, err = self.SStandaloneResourceBase.ValidateUpdateData(
+		ctx, userCred, query, input.StandaloneResourceBaseUpdateInput)
+	if err != nil {
+		return input, err
+	}
+	if input.ReservedCpu != nil && *input.ReservedCpu < 0 {
+		return input, httperrors.NewInputParameterError("reserved cpu must >= 0")
+	}
+	if input.ReservedMemory != nil && *input.ReservedMemory < 0 {
+		return input, httperrors.NewInputParameterError("reserved memory must >= 0")
+	}
+	if input.ReservedStorage != nil && *input.ReservedStorage < 0 {
+		return input, httperrors.NewInputParameterError("reserved storage must >= 0")
+	}
+	return input, nil
+}
+
+func (self *SIsolatedDevice) PostUpdate(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) {
+	HostManager.ClearSchedDescCache(self.HostId)
+}
+
 // 直通设备（GPU等）列表
 func (manager *SIsolatedDeviceManager) ListItemFilter(
 	ctx context.Context,