wings/config/config_docker.go
Matthew Penner eadbe920fe
config: fix docker Go API deprecation
Signed-off-by: Matthew Penner <me@matthewp.io>
2024-03-12 21:42:58 -06:00

186 lines
6.9 KiB
Go

package config
import (
"encoding/base64"
"sort"
"github.com/docker/docker/api/types/container"
"github.com/docker/docker/api/types/registry"
"github.com/goccy/go-json"
)
type dockerNetworkInterfaces struct {
V4 struct {
Subnet string `default:"172.18.0.0/16"`
Gateway string `default:"172.18.0.1"`
}
V6 struct {
Subnet string `default:"fdba:17c8:6c94::/64"`
Gateway string `default:"fdba:17c8:6c94::1011"`
}
}
type DockerNetworkConfiguration struct {
// The interface that should be used to create the network. Must not conflict
// with any other interfaces in use by Docker or on the system.
Interface string `default:"172.18.0.1" json:"interface" yaml:"interface"`
// The DNS settings for containers.
Dns []string `default:"[\"1.1.1.1\", \"1.0.0.1\"]"`
// The name of the network to use. If this network already exists it will not
// be created. If it is not found, a new network will be created using the interface
// defined.
Name string `default:"pterodactyl_nw"`
ISPN bool `default:"false" yaml:"ispn"`
Driver string `default:"bridge"`
Mode string `default:"pterodactyl_nw" yaml:"network_mode"`
IsInternal bool `default:"false" yaml:"is_internal"`
EnableICC bool `default:"true" yaml:"enable_icc"`
NetworkMTU int64 `default:"1500" yaml:"network_mtu"`
Interfaces dockerNetworkInterfaces `yaml:"interfaces"`
}
// DockerConfiguration defines the docker configuration used by the daemon when
// interacting with containers and networks on the system.
type DockerConfiguration struct {
// Network configuration that should be used when creating a new network
// for containers run through the daemon.
Network DockerNetworkConfiguration `json:"network" yaml:"network"`
// Domainname is the Docker domainname for all containers.
Domainname string `default:"" json:"domainname" yaml:"domainname"`
// Registries .
Registries map[string]RegistryConfiguration `json:"registries" yaml:"registries"`
// TmpfsSize specifies the size for the /tmp directory mounted into containers. Please be
// aware that Docker utilizes the host's system memory for this value, and that we do not
// keep track of the space used there, so avoid allocating too much to a server.
TmpfsSize uint `default:"100" json:"tmpfs_size" yaml:"tmpfs_size"`
// ContainerPidLimit sets the total number of processes that can be active in a container
// at any given moment. This is a security concern in shared-hosting environments where a
// malicious process could create enough processes to cause the host node to run out of
// available pids and crash.
ContainerPidLimit int64 `default:"512" json:"container_pid_limit" yaml:"container_pid_limit"`
// InstallerLimits defines the limits on the installer containers that prevents a server's
// installation process from unintentionally consuming more resources than expected. This
// is used in conjunction with the server's defined limits. Whichever value is higher will
// take precedence in the installer containers.
InstallerLimits struct {
Memory int64 `default:"1024" json:"memory" yaml:"memory"`
Cpu int64 `default:"100" json:"cpu" yaml:"cpu"`
} `json:"installer_limits" yaml:"installer_limits"`
// Overhead controls the memory overhead given to all containers to circumvent certain
// software such as the JVM not staying below the maximum memory limit.
Overhead Overhead `json:"overhead" yaml:"overhead"`
UsePerformantInspect bool `default:"true" json:"use_performant_inspect" yaml:"use_performant_inspect"`
// Sets the user namespace mode for the container when user namespace remapping option is
// enabled.
//
// If the value is blank, the daemon's user namespace remapping configuration is used,
// if the value is "host", then the pterodactyl containers are started with user namespace
// remapping disabled
UsernsMode string `default:"" json:"userns_mode" yaml:"userns_mode"`
LogConfig struct {
Type string `default:"local" json:"type" yaml:"type"`
Config map[string]string `default:"{\"max-size\":\"5m\",\"max-file\":\"1\",\"compress\":\"false\",\"mode\":\"non-blocking\"}" json:"config" yaml:"config"`
} `json:"log_config" yaml:"log_config"`
}
func (c DockerConfiguration) ContainerLogConfig() container.LogConfig {
if c.LogConfig.Type == "" {
return container.LogConfig{}
}
return container.LogConfig{
Type: c.LogConfig.Type,
Config: c.LogConfig.Config,
}
}
// RegistryConfiguration defines the authentication credentials for a given
// Docker registry.
type RegistryConfiguration struct {
Username string `yaml:"username"`
Password string `yaml:"password"`
}
// Base64 returns the authentication for a given registry as a base64 encoded
// string value.
func (c RegistryConfiguration) Base64() (string, error) {
b, err := json.Marshal(registry.AuthConfig{
Username: c.Username,
Password: c.Password,
})
if err != nil {
return "", err
}
return base64.URLEncoding.EncodeToString(b), nil
}
// Overhead controls the memory overhead given to all containers to circumvent certain
// software such as the JVM not staying below the maximum memory limit.
type Overhead struct {
// Override controls if the overhead limits should be overridden by the values in the config file.
Override bool `default:"false" json:"override" yaml:"override"`
// DefaultMultiplier sets the default multiplier for if no Multipliers are able to be applied.
DefaultMultiplier float64 `default:"1.05" json:"default_multiplier" yaml:"default_multiplier"`
// Multipliers allows overriding DefaultMultiplier depending on the amount of memory
// configured for a server.
//
// Default values (used if Override is `false`)
// - Less than 2048 MB of memory, multiplier of 1.15 (15%)
// - Less than 4096 MB of memory, multiplier of 1.10 (10%)
// - Otherwise, multiplier of 1.05 (5%) - specified in DefaultMultiplier
//
// If the defaults were specified in the config they would look like:
// ```yaml
// multipliers:
// 2048: 1.15
// 4096: 1.10
// ```
Multipliers map[int]float64 `json:"multipliers" yaml:"multipliers"`
}
func (o Overhead) GetMultiplier(memoryLimit int64) float64 {
// Default multiplier values.
if !o.Override {
if memoryLimit <= 2048 {
return 1.15
} else if memoryLimit <= 4096 {
return 1.10
}
return 1.05
}
// This plucks the keys of the Multipliers map, so they can be sorted from
// smallest to largest in order to correctly apply the proper multiplier.
i := 0
multipliers := make([]int, len(o.Multipliers))
for k := range o.Multipliers {
multipliers[i] = k
i++
}
sort.Ints(multipliers)
// Loop through the memory values in order (smallest to largest)
for _, m := range multipliers {
// If the server's memory limit exceeds the modifier's limit, don't apply it.
if memoryLimit > int64(m) {
continue
}
return o.Multipliers[m]
}
return o.DefaultMultiplier
}