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  }