github.com/rumpl/bof@v23.0.0-rc.2+incompatible/libnetwork/config/config.go (about) 1 package config 2 3 import ( 4 "os" 5 "strings" 6 7 "github.com/docker/docker/libnetwork/cluster" 8 "github.com/docker/docker/libnetwork/datastore" 9 "github.com/docker/docker/libnetwork/ipamutils" 10 "github.com/docker/docker/libnetwork/netlabel" 11 "github.com/docker/docker/libnetwork/osl" 12 "github.com/docker/docker/pkg/plugingetter" 13 "github.com/docker/libkv/store" 14 "github.com/pelletier/go-toml" 15 "github.com/sirupsen/logrus" 16 ) 17 18 const ( 19 warningThNetworkControlPlaneMTU = 1500 20 minimumNetworkControlPlaneMTU = 500 21 ) 22 23 // Config encapsulates configurations of various Libnetwork components 24 type Config struct { 25 Daemon DaemonCfg 26 Scopes map[string]*datastore.ScopeCfg 27 ActiveSandboxes map[string]interface{} 28 PluginGetter plugingetter.PluginGetter 29 } 30 31 // DaemonCfg represents libnetwork core configuration 32 type DaemonCfg struct { 33 Debug bool 34 Experimental bool 35 DataDir string 36 ExecRoot string 37 DefaultNetwork string 38 DefaultDriver string 39 Labels []string 40 DriverCfg map[string]interface{} 41 ClusterProvider cluster.Provider 42 NetworkControlPlaneMTU int 43 DefaultAddressPool []*ipamutils.NetworkToSplit 44 } 45 46 // LoadDefaultScopes loads default scope configs for scopes which 47 // doesn't have explicit user specified configs. 48 func (c *Config) LoadDefaultScopes(dataDir string) { 49 for k, v := range datastore.DefaultScopes(dataDir) { 50 if _, ok := c.Scopes[k]; !ok { 51 c.Scopes[k] = v 52 } 53 } 54 } 55 56 // ParseConfig parses the libnetwork configuration file 57 func ParseConfig(tomlCfgFile string) (*Config, error) { 58 cfg := &Config{ 59 Scopes: map[string]*datastore.ScopeCfg{}, 60 } 61 data, err := os.ReadFile(tomlCfgFile) 62 if err != nil { 63 return nil, err 64 } 65 if err := toml.Unmarshal(data, cfg); err != nil { 66 return nil, err 67 } 68 69 cfg.LoadDefaultScopes(cfg.Daemon.DataDir) 70 return cfg, nil 71 } 72 73 // ParseConfigOptions parses the configuration options and returns 74 // a reference to the corresponding Config structure 75 func ParseConfigOptions(cfgOptions ...Option) *Config { 76 cfg := &Config{ 77 Daemon: DaemonCfg{ 78 DriverCfg: make(map[string]interface{}), 79 }, 80 Scopes: make(map[string]*datastore.ScopeCfg), 81 } 82 83 cfg.ProcessOptions(cfgOptions...) 84 cfg.LoadDefaultScopes(cfg.Daemon.DataDir) 85 86 return cfg 87 } 88 89 // Option is an option setter function type used to pass various configurations 90 // to the controller 91 type Option func(c *Config) 92 93 // OptionDefaultNetwork function returns an option setter for a default network 94 func OptionDefaultNetwork(dn string) Option { 95 return func(c *Config) { 96 logrus.Debugf("Option DefaultNetwork: %s", dn) 97 c.Daemon.DefaultNetwork = strings.TrimSpace(dn) 98 } 99 } 100 101 // OptionDefaultDriver function returns an option setter for default driver 102 func OptionDefaultDriver(dd string) Option { 103 return func(c *Config) { 104 logrus.Debugf("Option DefaultDriver: %s", dd) 105 c.Daemon.DefaultDriver = strings.TrimSpace(dd) 106 } 107 } 108 109 // OptionDefaultAddressPoolConfig function returns an option setter for default address pool 110 func OptionDefaultAddressPoolConfig(addressPool []*ipamutils.NetworkToSplit) Option { 111 return func(c *Config) { 112 c.Daemon.DefaultAddressPool = addressPool 113 } 114 } 115 116 // OptionDriverConfig returns an option setter for driver configuration. 117 func OptionDriverConfig(networkType string, config map[string]interface{}) Option { 118 return func(c *Config) { 119 c.Daemon.DriverCfg[networkType] = config 120 } 121 } 122 123 // OptionLabels function returns an option setter for labels 124 func OptionLabels(labels []string) Option { 125 return func(c *Config) { 126 for _, label := range labels { 127 if strings.HasPrefix(label, netlabel.Prefix) { 128 c.Daemon.Labels = append(c.Daemon.Labels, label) 129 } 130 } 131 } 132 } 133 134 // OptionDataDir function returns an option setter for data folder 135 func OptionDataDir(dataDir string) Option { 136 return func(c *Config) { 137 c.Daemon.DataDir = dataDir 138 } 139 } 140 141 // OptionExecRoot function returns an option setter for exec root folder 142 func OptionExecRoot(execRoot string) Option { 143 return func(c *Config) { 144 c.Daemon.ExecRoot = execRoot 145 osl.SetBasePath(execRoot) 146 } 147 } 148 149 // OptionPluginGetter returns a plugingetter for remote drivers. 150 func OptionPluginGetter(pg plugingetter.PluginGetter) Option { 151 return func(c *Config) { 152 c.PluginGetter = pg 153 } 154 } 155 156 // OptionExperimental function returns an option setter for experimental daemon 157 func OptionExperimental(exp bool) Option { 158 return func(c *Config) { 159 logrus.Debugf("Option Experimental: %v", exp) 160 c.Daemon.Experimental = exp 161 } 162 } 163 164 // OptionNetworkControlPlaneMTU function returns an option setter for control plane MTU 165 func OptionNetworkControlPlaneMTU(exp int) Option { 166 return func(c *Config) { 167 logrus.Debugf("Network Control Plane MTU: %d", exp) 168 if exp < warningThNetworkControlPlaneMTU { 169 logrus.Warnf("Received a MTU of %d, this value is very low, the network control plane can misbehave,"+ 170 " defaulting to minimum value (%d)", exp, minimumNetworkControlPlaneMTU) 171 if exp < minimumNetworkControlPlaneMTU { 172 exp = minimumNetworkControlPlaneMTU 173 } 174 } 175 c.Daemon.NetworkControlPlaneMTU = exp 176 } 177 } 178 179 // ProcessOptions processes options and stores it in config 180 func (c *Config) ProcessOptions(options ...Option) { 181 for _, opt := range options { 182 if opt != nil { 183 opt(c) 184 } 185 } 186 } 187 188 // IsValidName validates configuration objects supported by libnetwork 189 func IsValidName(name string) bool { 190 return strings.TrimSpace(name) != "" 191 } 192 193 // OptionLocalKVProvider function returns an option setter for kvstore provider 194 func OptionLocalKVProvider(provider string) Option { 195 return func(c *Config) { 196 logrus.Debugf("Option OptionLocalKVProvider: %s", provider) 197 if _, ok := c.Scopes[datastore.LocalScope]; !ok { 198 c.Scopes[datastore.LocalScope] = &datastore.ScopeCfg{} 199 } 200 c.Scopes[datastore.LocalScope].Client.Provider = strings.TrimSpace(provider) 201 } 202 } 203 204 // OptionLocalKVProviderURL function returns an option setter for kvstore url 205 func OptionLocalKVProviderURL(url string) Option { 206 return func(c *Config) { 207 logrus.Debugf("Option OptionLocalKVProviderURL: %s", url) 208 if _, ok := c.Scopes[datastore.LocalScope]; !ok { 209 c.Scopes[datastore.LocalScope] = &datastore.ScopeCfg{} 210 } 211 c.Scopes[datastore.LocalScope].Client.Address = strings.TrimSpace(url) 212 } 213 } 214 215 // OptionLocalKVProviderConfig function returns an option setter for kvstore config 216 func OptionLocalKVProviderConfig(config *store.Config) Option { 217 return func(c *Config) { 218 logrus.Debugf("Option OptionLocalKVProviderConfig: %v", config) 219 if _, ok := c.Scopes[datastore.LocalScope]; !ok { 220 c.Scopes[datastore.LocalScope] = &datastore.ScopeCfg{} 221 } 222 c.Scopes[datastore.LocalScope].Client.Config = config 223 } 224 } 225 226 // OptionActiveSandboxes function returns an option setter for passing the sandboxes 227 // which were active during previous daemon life 228 func OptionActiveSandboxes(sandboxes map[string]interface{}) Option { 229 return func(c *Config) { 230 c.ActiveSandboxes = sandboxes 231 } 232 }