package clustersconfig import ( "fmt" "io" "io/ioutil" "net" "strings" "text/template" yaml "gopkg.in/yaml.v2" ) type Config struct { Hosts []*Host Groups []*Group Clusters []*Cluster Configs []*Template StaticPods []*Template `yaml:"static_pods"` Addons map[string][]*Template SSLConfig string `yaml:"ssl_config"` CertRequests []*CertRequest `yaml:"cert_requests"` } func FromBytes(data []byte) (*Config, error) { config := &Config{Addons: make(map[string][]*Template)} if err := yaml.Unmarshal(data, config); err != nil { return nil, err } return config, nil } func FromFile(path string) (*Config, error) { ba, err := ioutil.ReadFile(path) if err != nil { return nil, err } return FromBytes(ba) } func (c *Config) Host(name string) *Host { for _, host := range c.Hosts { if host.Name == name { return host } } return nil } func (c *Config) HostByIP(ip string) *Host { for _, host := range c.Hosts { if host.IP == ip { return host } for _, otherIP := range host.IPs { if otherIP == ip { return host } } } return nil } func (c *Config) HostByMAC(mac string) *Host { // a bit of normalization mac = strings.Replace(strings.ToLower(mac), "-", ":", -1) for _, host := range c.Hosts { if strings.ToLower(host.MAC) == mac { return host } } return nil } func (c *Config) Group(name string) *Group { for _, group := range c.Groups { if group.Name == name { return group } } return nil } func (c *Config) Cluster(name string) *Cluster { for _, cluster := range c.Clusters { if cluster.Name == name { return cluster } } return nil } func (c *Config) ConfigTemplate(name string) *Template { for _, cfg := range c.Configs { if cfg.Name == name { return cfg } } return nil } func (c *Config) StaticPodsTemplate(name string) *Template { for _, s := range c.StaticPods { if s.Name == name { return s } } return nil } func (c *Config) CSR(name string) *CertRequest { for _, s := range c.CertRequests { if s.Name == name { return s } } return nil } func (c *Config) SaveTo(path string) error { ba, err := yaml.Marshal(c) if err != nil { return err } return ioutil.WriteFile(path, ba, 0600) } type Template struct { Name string Template string parsedTemplate *template.Template } func (t *Template) Execute(wr io.Writer, data interface{}, extraFuncs map[string]interface{}) error { if t.parsedTemplate == nil { var templateFuncs = map[string]interface{}{ "indent": func(indent, s string) (indented string) { indented = indent + strings.Replace(s, "\n", "\n"+indent, -1) return }, } for name, f := range extraFuncs { templateFuncs[name] = f } tmpl, err := template.New(t.Name). Funcs(templateFuncs). Parse(t.Template) if err != nil { return err } t.parsedTemplate = tmpl } return t.parsedTemplate.Execute(wr, data) } // Host represents a host served by this server. type Host struct { WithRev Name string MAC string IP string IPs []string Cluster string Group string Vars Vars } // Group represents a group of hosts and provides their configuration. type Group struct { WithRev Name string Master bool IPXE string Kernel string Initrd string Config string StaticPods string `yaml:"static_pods"` Versions map[string]string Vars Vars } // Vars store user-defined key-values type Vars map[string]interface{} // Cluster represents a cluster of hosts, allowing for cluster-wide variables. type Cluster struct { WithRev Name string Domain string Addons string Subnets struct { Services string Pods string } Vars Vars } func (c *Cluster) KubernetesSvcIP() net.IP { return c.NthSvcIP(1) } func (c *Cluster) DNSSvcIP() net.IP { return c.NthSvcIP(2) } func (c *Cluster) NthSvcIP(n byte) net.IP { _, cidr, err := net.ParseCIDR(c.Subnets.Services) if err != nil { panic(fmt.Errorf("Invalid services CIDR: %v", err)) } ip := cidr.IP ip[len(ip)-1] += n return ip }