mirror of
https://github.com/psviderski/uncloud.git
synced 2026-11-10 04:34:17 +00:00
77 lines
2.6 KiB
Go
77 lines
2.6 KiB
Go
package api
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"github.com/docker/docker/api/types/container"
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/google/go-cmp/cmp/cmpopts"
|
|
)
|
|
|
|
const (
|
|
MilliCore = 1_000_000
|
|
Core = 1000 * MilliCore
|
|
)
|
|
|
|
type ContainerResources struct {
|
|
// CPU is the maximum amount of CPU nanocores (1000000000 = 1 CPU core) the container can use.
|
|
CPU int64
|
|
// Memory is the maximum amount of memory (in bytes) the container can use.
|
|
Memory int64
|
|
// MemoryReservation is the minimum amount of memory (in bytes) the container needs to run efficiently.
|
|
// TODO: implement a placement constraint that checks available memory on machines.
|
|
MemoryReservation int64
|
|
// Devices provides direct access to host devices.
|
|
Devices []DeviceMapping
|
|
// DeviceReservations requests for access to things like GPUs.
|
|
DeviceReservations []container.DeviceRequest
|
|
// SharedMemory is the size of the shared memory (in bytes) mounted at /dev/shm in the container.
|
|
SharedMemory int64
|
|
// Ulimits defines the resource limits for the container.
|
|
Ulimits map[string]Ulimit
|
|
}
|
|
|
|
// Equals returns true if the resources are equal, treating nil and empty slices and maps as equal.
|
|
func (r ContainerResources) Equals(other ContainerResources) bool {
|
|
return cmp.Equal(r, other, cmpopts.EquateEmpty())
|
|
}
|
|
|
|
// ValidateUpdateInPlace returns an error explaining why a container created with these resources can't be updated
|
|
// to the new resources without recreating it. It returns nil if the container can be updated in place.
|
|
// Docker can only change the CPU and memory limits of an existing container and can't remove a limit once it's set.
|
|
func (r ContainerResources) ValidateUpdateInPlace(new ContainerResources) error {
|
|
// Docker treats zero values as unchanged when updating a container.
|
|
if r.CPU != 0 && new.CPU == 0 {
|
|
return errors.New("CPU limit can't be removed")
|
|
}
|
|
if r.Memory != 0 && new.Memory == 0 {
|
|
return errors.New("memory limit can't be removed")
|
|
}
|
|
if r.MemoryReservation != 0 && new.MemoryReservation == 0 {
|
|
return errors.New("memory reservation can't be removed")
|
|
}
|
|
|
|
r.CPU = new.CPU
|
|
r.Memory = new.Memory
|
|
r.MemoryReservation = new.MemoryReservation
|
|
if !r.Equals(new) {
|
|
return errors.New("only CPU and memory limits can be changed")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// DeviceMapping represents a device mapping between host and container.
|
|
type DeviceMapping struct {
|
|
// HostPath is the path to the device on the host.
|
|
HostPath string
|
|
// ContainerPath is the path to the device in the container.
|
|
ContainerPath string
|
|
// CgroupPermissions is the cgroup permissions for the device (e.g., "rwm").
|
|
CgroupPermissions string
|
|
}
|
|
|
|
type Ulimit struct {
|
|
Soft int64
|
|
Hard int64
|
|
}
|