This is a work in progress API shift as the data structure has changed and I'm cleaning the interface.

internal/pkg/node/constructors.go

@@ -7,6 +7,7 @@ import (
 	"gopkg.in/yaml.v2"
 	"io/ioutil"
 	"regexp"
+	"strings"
 )
 
 func New() (nodeYaml, error) {
@@ -30,142 +31,104 @@ func New() (nodeYaml, error) {
 func (self *nodeYaml) FindAllNodes() ([]NodeInfo, error) {
 	var ret []NodeInfo
 
-	for controllername, controller := range self.Controllers {
-		for groupname, group := range controller.NodeGroups {
-			for nodename, node := range group.Nodes {
-				var n NodeInfo
-				var allProfiles []string
+	for nodename, node := range self.Nodes {
+		var n NodeInfo
 
-				if node.Disabled == true || group.Disabled == true {
-					wwlog.Printf(wwlog.VERBOSE, "Skipping disabled node: %s/%s\n", groupname, nodename)
-					continue
+		n.NetDevs = make(map[string]*NetDevEntry)
+		n.SystemOverlay.Set("default")
+		n.RuntimeOverlay.Set("default")
+		n.Ipxe.Set("default")
+
+		fullname := strings.SplitN(nodename, ".", 2)
+		if len(fullname) > 1 {
+			n.DomainName.Set(fullname[1])
+		}
+
+		if len(node.Profiles) == 0 {
+			n.Profiles = []string{"default"}
+		} else {
+			n.Profiles = node.Profiles
+		}
+
+		n.Id.Set(nodename)
+		n.Comment.Set(node.Comment)
+		n.Vnfs.Set(node.Vnfs)
+		n.KernelVersion.Set(node.KernelVersion)
+		n.KernelArgs.Set(node.KernelArgs)
+		n.DomainName.Set(node.DomainName)
+		n.Ipxe.Set(node.Ipxe)
+		n.IpmiIpaddr.Set(node.IpmiIpaddr)
+		n.IpmiNetmask.Set(node.IpmiNetmask)
+		n.IpmiUserName.Set(node.IpmiUserName)
+		n.IpmiPassword.Set(node.IpmiPassword)
+		n.SystemOverlay.Set(node.SystemOverlay)
+		n.RuntimeOverlay.Set(node.RuntimeOverlay)
+
+		for devname, netdev := range node.NetDevs {
+			if _, ok := n.NetDevs[devname]; !ok {
+				var netdev NetDevEntry
+				n.NetDevs[devname] = &netdev
+			}
+
+			n.NetDevs[devname].Ipaddr.Set(netdev.Ipaddr)
+			n.NetDevs[devname].Netmask.Set(netdev.Netmask)
+			n.NetDevs[devname].Hwaddr.Set(netdev.Hwaddr)
+			n.NetDevs[devname].Gateway.Set(netdev.Gateway)
+			n.NetDevs[devname].Type.Set(netdev.Type)
+			n.NetDevs[devname].Default.SetB(netdev.Default)
+		}
+
+		for _, p := range n.Profiles {
+			if _, ok := self.NodeProfiles[p]; !ok {
+				wwlog.Printf(wwlog.WARN, "Profile not found for node '%s': %s\n", nodename, p)
+				continue
+			}
+
+			wwlog.Printf(wwlog.VERBOSE, "Merging profile into node: %s <- %s\n", nodename, p)
+
+			pstring := fmt.Sprintf("%s", p)
+
+			n.Comment.SetAlt(self.NodeProfiles[p].Comment, pstring)
+			n.DomainName.SetAlt(self.NodeProfiles[p].DomainName, pstring)
+			n.Vnfs.SetAlt(self.NodeProfiles[p].Vnfs, pstring)
+			n.KernelVersion.SetAlt(self.NodeProfiles[p].KernelVersion, pstring)
+			n.KernelArgs.SetAlt(self.NodeProfiles[p].KernelArgs, pstring)
+			n.Ipxe.SetAlt(self.NodeProfiles[p].Ipxe, pstring)
+			n.IpmiIpaddr.SetAlt(self.NodeProfiles[p].IpmiIpaddr, pstring)
+			n.IpmiNetmask.SetAlt(self.NodeProfiles[p].IpmiNetmask, pstring)
+			n.IpmiUserName.SetAlt(self.NodeProfiles[p].IpmiUserName, pstring)
+			n.IpmiPassword.SetAlt(self.NodeProfiles[p].IpmiPassword, pstring)
+			n.SystemOverlay.SetAlt(self.NodeProfiles[p].SystemOverlay, pstring)
+			n.RuntimeOverlay.SetAlt(self.NodeProfiles[p].RuntimeOverlay, pstring)
+
+			for devname, netdev := range self.NodeProfiles[p].NetDevs {
+				if _, ok := n.NetDevs[devname]; !ok {
+					var netdev NetDevEntry
+					n.NetDevs[devname] = &netdev
 				}
 
-				n.Id.SetNode(nodename)
-				n.Gid.SetNode(groupname)
-				n.Cid.SetNode(controllername)
-				n.HostName.SetNode(node.Hostname)
-				n.IpmiIpaddr.SetNode(node.IpmiIpaddr)
-				n.IpmiNetmask.SetNode(node.IpmiNetmask)
-				n.DomainName.SetNode(node.DomainName)
-				n.Vnfs.SetNode(node.Vnfs)
-				n.KernelVersion.SetNode(node.KernelVersion)
-				n.KernelArgs.SetNode(node.KernelArgs)
-				n.Ipxe.SetNode(node.Ipxe)
-				n.IpmiUserName.SetNode(node.IpmiUserName)
-				n.IpmiPassword.SetNode(node.IpmiPassword)
-				n.SystemOverlay.SetNode(node.SystemOverlay)
-				n.RuntimeOverlay.SetNode(node.RuntimeOverlay)
-
-				n.DomainName.SetGroup(group.DomainName)
-				n.Vnfs.SetGroup(group.Vnfs)
-				n.KernelVersion.SetGroup(group.KernelVersion)
-				n.KernelArgs.SetGroup(group.KernelArgs)
-				n.Ipxe.SetGroup(group.Ipxe)
-				n.IpmiNetmask.SetGroup(group.IpmiNetmask)
-				n.IpmiUserName.SetGroup(group.IpmiUserName)
-				n.IpmiPassword.SetGroup(group.IpmiPassword)
-				n.SystemOverlay.SetGroup(group.SystemOverlay)
-				n.RuntimeOverlay.SetGroup(group.RuntimeOverlay)
-
-				n.RuntimeOverlay.SetDefault("default")
-				n.SystemOverlay.SetDefault("default")
-				n.Ipxe.SetDefault("default")
-				n.KernelArgs.SetDefault("crashkernel=no quiet")
-
-				n.GroupProfiles = group.Profiles
-				n.Profiles = node.Profiles
-
-				allProfiles = append(allProfiles, group.Profiles...)
-				allProfiles = append(allProfiles, node.Profiles...)
-
-				for _, p := range allProfiles {
-					if _, ok := self.NodeProfiles[p]; !ok {
-						wwlog.Printf(wwlog.WARN, "Profile not found for node '%s': %s\n", nodename, p)
-						continue
-					}
-
-					n.DomainName.SetProfile(self.NodeProfiles[p].DomainName)
-					n.Vnfs.SetProfile(self.NodeProfiles[p].Vnfs)
-					n.KernelVersion.SetProfile(self.NodeProfiles[p].KernelVersion)
-					n.KernelArgs.SetProfile(self.NodeProfiles[p].KernelArgs)
-					n.Ipxe.SetProfile(self.NodeProfiles[p].Ipxe)
-					n.IpmiNetmask.SetProfile(self.NodeProfiles[p].IpmiNetmask)
-					n.IpmiUserName.SetProfile(self.NodeProfiles[p].IpmiUserName)
-					n.IpmiPassword.SetProfile(self.NodeProfiles[p].IpmiPassword)
-					n.SystemOverlay.SetProfile(self.NodeProfiles[p].SystemOverlay)
-					n.RuntimeOverlay.SetProfile(self.NodeProfiles[p].RuntimeOverlay)
-				}
-
-				if n.DomainName.Defined() == true {
-					n.Fqdn.SetNode(node.Hostname + "." + n.DomainName.Get())
-				} else {
-					n.Fqdn.SetNode(node.Hostname)
-				}
-
-				n.NetDevs = node.NetDevs
-
-				ret = append(ret, n)
+				n.NetDevs[devname].Ipaddr.SetAlt(netdev.Ipaddr, pstring)
+				n.NetDevs[devname].Netmask.SetAlt(netdev.Netmask, pstring)
+				n.NetDevs[devname].Hwaddr.SetAlt(netdev.Hwaddr, pstring)
+				n.NetDevs[devname].Gateway.SetAlt(netdev.Gateway, pstring)
+				n.NetDevs[devname].Type.SetAlt(netdev.Type, pstring)
+				n.NetDevs[devname].Default.SetAltB(netdev.Default, pstring)
 			}
 		}
+
+		ret = append(ret, n)
+
 	}
 
 	return ret, nil
 }
 
-func (self *nodeYaml) FindAllGroups() ([]GroupInfo, error) {
-	var ret []GroupInfo
+/*
+func (self *nodeYaml) FindAllControllers() ([]ControllerConf, error) {
+	var ret []ControllerConf
 
 	for controllername, controller := range self.Controllers {
-		for groupname, group := range controller.NodeGroups {
-			var g GroupInfo
-
-			g.Id.SetGroup(groupname)
-			g.Cid.SetGroup(controllername)
-			g.DomainName.SetGroup(group.DomainName)
-			g.Comment.SetGroup(group.Comment)
-			g.Vnfs.SetGroup(group.Vnfs)
-			g.KernelVersion.SetGroup(group.KernelVersion)
-			g.KernelArgs.SetGroup(group.KernelArgs)
-			g.IpmiNetmask.SetGroup(group.IpmiNetmask)
-			g.IpmiPassword.SetGroup(group.IpmiPassword)
-			g.IpmiUserName.SetGroup(group.IpmiUserName)
-			g.SystemOverlay.SetGroup(group.SystemOverlay)
-			g.RuntimeOverlay.SetGroup(group.RuntimeOverlay)
-
-			g.Profiles = group.Profiles
-
-			for _, p := range group.Profiles {
-				if _, ok := self.NodeProfiles[p]; !ok {
-					wwlog.Printf(wwlog.WARN, "Profile not found for group '%s': %s\n", groupname, p)
-					continue
-				}
-
-				g.DomainName.SetProfile(self.NodeProfiles[p].DomainName)
-				g.Vnfs.SetProfile(self.NodeProfiles[p].Vnfs)
-				g.KernelVersion.SetProfile(self.NodeProfiles[p].KernelVersion)
-				g.KernelArgs.SetProfile(self.NodeProfiles[p].KernelArgs)
-				g.Ipxe.SetProfile(self.NodeProfiles[p].Ipxe)
-				g.IpmiNetmask.SetProfile(self.NodeProfiles[p].IpmiNetmask)
-				g.IpmiUserName.SetProfile(self.NodeProfiles[p].IpmiUserName)
-				g.IpmiPassword.SetProfile(self.NodeProfiles[p].IpmiPassword)
-				g.SystemOverlay.SetProfile(self.NodeProfiles[p].SystemOverlay)
-				g.RuntimeOverlay.SetProfile(self.NodeProfiles[p].RuntimeOverlay)
-			}
-
-			// TODO: Validate or die on all inputs
-
-			ret = append(ret, g)
-		}
-	}
-	return ret, nil
-}
-
-func (self *nodeYaml) FindAllControllers() ([]ControllerInfo, error) {
-	var ret []ControllerInfo
-
-	for controllername, controller := range self.Controllers {
-		var c ControllerInfo
+		var c ControllerConf
 
 		c.Id = controllername
 		c.Ipaddr = controller.Ipaddr
@@ -223,25 +186,39 @@ func (self *nodeYaml) FindAllControllers() ([]ControllerInfo, error) {
 	}
 	return ret, nil
 }
+*/
 
-func (self *nodeYaml) FindAllProfiles() ([]ProfileInfo, error) {
-	var ret []ProfileInfo
+func (self *nodeYaml) FindAllProfiles() ([]NodeInfo, error) {
+	var ret []NodeInfo
 
 	for name, profile := range self.NodeProfiles {
-		var p ProfileInfo
+		var p NodeInfo
 
-		p.Id = name
-		p.Comment = profile.Comment
-		p.Vnfs = profile.Vnfs
-		p.Ipxe = profile.Ipxe
-		p.KernelVersion = profile.KernelVersion
-		p.KernelArgs = profile.KernelArgs
-		p.IpmiNetmask = profile.IpmiNetmask
-		p.IpmiUserName = profile.IpmiUserName
-		p.IpmiPassword = profile.IpmiPassword
-		p.DomainName = profile.DomainName
-		p.RuntimeOverlay = profile.RuntimeOverlay
-		p.SystemOverlay = profile.SystemOverlay
+		p.Id.Set(name)
+		p.Comment.Set(profile.Comment)
+		p.Vnfs.Set(profile.Vnfs)
+		p.Ipxe.Set(profile.Ipxe)
+		p.KernelVersion.Set(profile.KernelVersion)
+		p.KernelArgs.Set(profile.KernelArgs)
+		p.IpmiNetmask.Set(profile.IpmiNetmask)
+		p.IpmiUserName.Set(profile.IpmiUserName)
+		p.IpmiPassword.Set(profile.IpmiPassword)
+		p.RuntimeOverlay.Set(profile.RuntimeOverlay)
+		p.SystemOverlay.Set(profile.SystemOverlay)
+
+		for devname, netdev := range profile.NetDevs {
+			if _, ok := p.NetDevs[devname]; !ok {
+				var netdev NetDevEntry
+				p.NetDevs[devname] = &netdev
+			}
+
+			p.NetDevs[devname].Ipaddr.Set(netdev.Ipaddr)
+			p.NetDevs[devname].Netmask.Set(netdev.Netmask)
+			p.NetDevs[devname].Hwaddr.Set(netdev.Hwaddr)
+			p.NetDevs[devname].Gateway.Set(netdev.Gateway)
+			p.NetDevs[devname].Type.Set(netdev.Type)
+			p.NetDevs[devname].Default.SetB(netdev.Default)
+		}
 
 		// TODO: Validate or die on all inputs
 
@@ -257,7 +234,7 @@ func (self *nodeYaml) FindByHwaddr(hwa string) (NodeInfo, error) {
 
 	for _, node := range n {
 		for _, dev := range node.NetDevs {
-			if dev.Hwaddr == hwa {
+			if dev.Hwaddr.Get() == hwa {
 				return node, nil
 			}
 		}
@@ -273,7 +250,7 @@ func (self *nodeYaml) FindByIpaddr(ipaddr string) (NodeInfo, error) {
 
 	for _, node := range n {
 		for _, dev := range node.NetDevs {
-			if dev.Ipaddr == ipaddr {
+			if dev.Ipaddr.Get() == ipaddr {
 				return node, nil
 			}
 		}
@@ -288,7 +265,7 @@ func (nodes *nodeYaml) SearchByName(search string) ([]NodeInfo, error) {
 	n, _ := nodes.FindAllNodes()
 
 	for _, node := range n {
-		b, _ := regexp.MatchString(search, node.Fqdn.Get())
+		b, _ := regexp.MatchString(search, node.Id.Get())
 		if b == true {
 			ret = append(ret, node)
 		}
@@ -304,7 +281,7 @@ func (nodes *nodeYaml) SearchByNameList(searchList []string) ([]NodeInfo, error)
 
 	for _, search := range searchList {
 		for _, node := range n {
-			b, _ := regexp.MatchString(search, node.Fqdn.Get())
+			b, _ := regexp.MatchString(search, node.Id.Get())
 			if b == true {
 				ret = append(ret, node)
 			}

internal/pkg/node/datastructure.go

@@ -11,22 +11,28 @@ import (
  ******/
 
 type nodeYaml struct {
-	NodeProfiles map[string]*ProfileConf
-	Controllers  map[string]*ControllerConf `yaml:"control"`
+	Controllers  map[string]*ControllerConf `yaml:"controlers"`
+	NodeProfiles map[string]*NodeConf
+	Nodes        map[string]*NodeConf
 }
 
-type ProfileConf struct {
-	Comment        string `yaml:"comment"`
-	Vnfs           string `yaml:"vnfs,omitempty"`
-	Ipxe           string `yaml:"ipxe template,omitempty"`
-	KernelVersion  string `yaml:"kernel version,omitempty"`
-	KernelArgs     string `yaml:"kernel args,omitempty"`
-	IpmiNetmask    string `yaml:"ipmi netmask,omitempty"`
-	IpmiUserName   string `yaml:"ipmi username,omitempty"`
-	IpmiPassword   string `yaml:"ipmi password,omitempty"`
-	DomainName     string `yaml:"domain name,omitempty"`
-	RuntimeOverlay string `yaml:"runtime overlay files,omitempty"`
-	SystemOverlay  string `yaml:"system overlay files,omitempty"`
+type NodeConf struct {
+	Comment  string `yaml:"comment,omitempty"`
+	Disabled bool   `yaml:"disabled,omitempty"`
+	//	Hostname       string   `yaml:"hostname,omitempty"`
+	DomainName     string   `yaml:"domain name,omitempty"`
+	Vnfs           string   `yaml:"vnfs,omitempty"`
+	Ipxe           string   `yaml:"ipxe template,omitempty"`
+	KernelVersion  string   `yaml:"kernel version,omitempty"`
+	KernelArgs     string   `yaml:"kernel args,omitempty"`
+	IpmiUserName   string   `yaml:"ipmi username,omitempty"`
+	IpmiPassword   string   `yaml:"ipmi password,omitempty"`
+	IpmiIpaddr     string   `yaml:"ipmi ipaddr,omitempty"`
+	IpmiNetmask    string   `yaml:"ipmi netmask,omitempty"`
+	RuntimeOverlay string   `yaml:"runtime overlay files,omitempty"`
+	SystemOverlay  string   `yaml:"system overlay files,omitempty"`
+	Profiles       []string `yaml:"profiles,omitempty"`
+	NetDevs        map[string]*NetDevs
 }
 
 type ControllerConf struct {
@@ -66,43 +72,6 @@ type ControllerConf struct {
 			EnableCmd  string   `yaml:"enable command,omitempty"`
 		} `yaml:"nfs,omitempty"`
 	} `yaml:"services"`
-	NodeGroups map[string]*GroupConf
-}
-
-type GroupConf struct {
-	Comment        string   `yaml:"comment"`
-	Disabled       bool     `yaml:"disabled,omitempty"`
-	DomainName     string   `yaml:"domain name"`
-	Vnfs           string   `yaml:"vnfs,omitempty"`
-	Ipxe           string   `yaml:"ipxe template,omitempty"`
-	KernelVersion  string   `yaml:"kernel version,omitempty"`
-	KernelArgs     string   `yaml:"kernel args,omitempty"`
-	IpmiNetmask    string   `yaml:"ipmi netmask,omitempty"`
-	IpmiUserName   string   `yaml:"ipmi username,omitempty"`
-	IpmiPassword   string   `yaml:"ipmi password,omitempty"`
-	RuntimeOverlay string   `yaml:"runtime overlay files,omitempty"`
-	SystemOverlay  string   `yaml:"system overlay files,omitempty"`
-	Profiles       []string `yaml:"profiles,omitempty"`
-	Nodes          map[string]*NodeConf
-}
-
-type NodeConf struct {
-	Comment        string   `yaml:"comment,omitempty"`
-	Disabled       bool     `yaml:"disabled,omitempty"`
-	Hostname       string   `yaml:"hostname,omitempty"`
-	DomainName     string   `yaml:"domain name,omitempty"`
-	Vnfs           string   `yaml:"vnfs,omitempty"`
-	Ipxe           string   `yaml:"ipxe template,omitempty"`
-	KernelVersion  string   `yaml:"kernel version,omitempty"`
-	KernelArgs     string   `yaml:"kernel args,omitempty"`
-	IpmiUserName   string   `yaml:"ipmi username,omitempty"`
-	IpmiPassword   string   `yaml:"ipmi password,omitempty"`
-	IpmiIpaddr     string   `yaml:"ipmi ipaddr,omitempty"`
-	IpmiNetmask    string   `yaml:"ipmi netmask,omitempty"`
-	RuntimeOverlay string   `yaml:"runtime overlay files,omitempty"`
-	SystemOverlay  string   `yaml:"system overlay files,omitempty"`
-	Profiles       []string `yaml:"profiles,omitempty"`
-	NetDevs        map[string]*NetDevs
 }
 
 type NetDevs struct {
@@ -115,24 +84,23 @@ type NetDevs struct {
 }
 
 /******
- * Code internal data representations
+ * Internal code data representations
  ******/
 
 type Entry struct {
-	Node       string
-	Profile    string
-	Group      string
-	Controller string
-	Default    string
+	value    string
+	altvalue string
+	bool     bool
+	altbool  bool
+	from     string
 }
 
 type NodeInfo struct {
-	Id             Entry
-	Gid            Entry
-	Cid            Entry
-	Comment        Entry
-	HostName       Entry
-	Fqdn           Entry
+	Id      Entry
+	Cid     Entry
+	Comment Entry
+	//	HostName       Entry
+	//	Fqdn           Entry
 	DomainName     Entry
 	Vnfs           Entry
 	Ipxe           Entry
@@ -146,80 +114,16 @@ type NodeInfo struct {
 	SystemOverlay  Entry
 	Profiles       []string
 	GroupProfiles  []string
-	NetDevs        map[string]*NetDevs
+	NetDevs        map[string]*NetDevEntry
 }
 
-type ControllerInfo struct {
-	Id         string
-	Comment    string
-	Ipaddr     string
-	Fqdn       string
-	DomainName string
-	Services   struct {
-		Warewulfd struct {
-			Port       string
-			Secure     bool
-			StartCmd   string
-			RestartCmd string
-			EnableCmd  string
-		}
-		Dhcp struct {
-			Enabled    bool
-			Template   string
-			RangeStart string
-			RangeEnd   string
-			ConfigFile string
-			StartCmd   string
-			RestartCmd string
-			EnableCmd  string
-		}
-		Tftp struct {
-			Enabled    bool
-			TftpRoot   string
-			StartCmd   string
-			RestartCmd string
-			EnableCmd  string
-		}
-		Nfs struct {
-			Enabled    bool
-			Exports    []string
-			StartCmd   string
-			RestartCmd string
-			EnableCmd  string
-		}
-	}
-}
-
-type GroupInfo struct {
-	Id             Entry
-	Cid            Entry
-	Comment        Entry
-	Vnfs           Entry
-	Ipxe           Entry
-	KernelVersion  Entry
-	KernelArgs     Entry
-	IpmiNetmask    Entry
-	IpmiUserName   Entry
-	IpmiPassword   Entry
-	DomainName     Entry
-	RuntimeOverlay Entry
-	SystemOverlay  Entry
-	Profiles       []string
-}
-
-type ProfileInfo struct {
-	Id             string
-	Comment        string
-	Vnfs           string
-	Ipxe           string
-	KernelVersion  string
-	KernelArgs     string
-	IpmiNetmask    string
-	IpmiUserName   string
-	IpmiPassword   string
-	DomainName     string
-	RuntimeOverlay string
-	SystemOverlay  string
+type NetDevEntry struct {
+	Type    Entry `yaml:"type,omitempty"`
+	Default Entry `yaml:"default"`
+	Hwaddr  Entry
+	Ipaddr  Entry
+	Netmask Entry
+	Gateway Entry `yaml:"gateway,omitempty"`
 }
 
 const ConfigFile = "/etc/warewulf/nodes.conf"

internal/pkg/node/methods.go

@@ -1,135 +1,103 @@
 package node
 
-import (
-	"strings"
-)
+import "strings"
+
+/**********
+ *
+ * Sets
+ *
+ *********/
+
+func (self *Entry) Set(val string) {
+	if val == "" {
+		return
+	}
+
+	if strings.ToUpper(val) == "DELETE" {
+		self.value = ""
+	} else {
+		self.value = val
+	}
+
+	return
+}
+
+func (self *Entry) SetB(val bool) {
+	self.bool = val
+	return
+}
+
+func (self *Entry) SetAlt(val string, from string) {
+	if val == "" {
+		return
+	}
+
+	self.altvalue = val
+	self.from = from
+
+	return
+}
+
+func (self *Entry) SetAltB(val bool, from string) {
+	self.altbool = val
+	self.from = from
+	return
+}
+
+/**********
+ *
+ * Gets
+ *
+ *********/
+
+func (self *Entry) Get() string {
+	if self.value != "" {
+		return self.value
+	}
+	if self.altvalue != "" {
+		return self.altvalue
+	}
+	return ""
+}
+
+func (self *Entry) GetB() bool {
+	return self.bool
+}
+
+func (self *Entry) GetReal() string {
+	return self.value
+}
+
+func (self *Entry) GetRealB() bool {
+	return self.bool
+}
+
+/**********
+ *
+ * Misc
+ *
+ *********/
 
 func (self *Entry) Print() string {
-	if self.Node != "" {
-		return self.Node
+	if self.value != "" {
+		return self.value
 	}
-	if self.Group != "" {
-		return self.Group
-	}
-	if self.Profile != "" {
-		return self.Profile
-	}
-	if self.Controller != "" {
-		return self.Controller
-	}
-	if self.Default != "" {
-		return self.Default
+	if self.altvalue != "" {
+		return self.altvalue
 	}
 	return "--"
 }
 
 func (self *Entry) Source() string {
-	if self.Node != "" {
-		return "node"
+	if self.from == "" {
+		return "--"
 	}
-	if self.Group != "" {
-		return "group"
-	}
-	if self.Profile != "" {
-		return "profile"
-	}
-	if self.Controller != "" {
-		return "controller"
-	}
-	if self.Default != "" {
-		return "default"
-	}
-	return ""
-}
-
-func (self *Entry) Get() string {
-	if self.Node != "" {
-		return self.Node
-	}
-	if self.Group != "" {
-		return self.Group
-	}
-	if self.Profile != "" {
-		return self.Profile
-	}
-	if self.Controller != "" {
-		return self.Controller
-	}
-	if self.Default != "" {
-		return self.Default
-	}
-	return ""
+	return self.from
 }
 
 func (self *Entry) Defined() bool {
-	if self.Get() == "" {
-		return false
+	if self.value != "" {
+		return true
 	}
-
-	return true
-}
-
-func (self *Entry) SetDefault(value string) {
-	if value == "" {
-		return
-	} else if strings.ToUpper(value) == "UNDEF" {
-		value = ""
-	}
-	self.Default = value
-}
-
-func (self *Entry) SetGroup(value string) {
-	if value == "" {
-		return
-	} else if strings.ToUpper(value) == "UNDEF" {
-		value = ""
-	}
-	self.Group = value
-}
-
-func (self *Entry) SetProfile(value string) {
-	if value == "" {
-		return
-	} else if strings.ToUpper(value) == "UNDEF" {
-		value = ""
-	}
-	self.Profile = value
-}
-
-func (self *Entry) SetController(value string) {
-	if value == "" {
-		return
-	} else if strings.ToUpper(value) == "UNDEF" {
-		value = ""
-	}
-	self.Controller = value
-}
-
-func (self *Entry) SetNode(value string) {
-	if value == "" {
-		return
-	} else if strings.ToUpper(value) == "UNDEF" {
-		value = ""
-	}
-	self.Node = value
-}
-
-func (self *Entry) GetNode() string {
-	return self.Node
-}
-
-func (self *Entry) GetGroup() string {
-	return self.Group
-}
-
-func (self *Entry) GetController() string {
-	return self.Controller
-}
-
-func (self *Entry) GetProfile() string {
-	return self.Profile
-}
-
-func (self *Entry) GetDefault() string {
-	return self.Default
+	return false
 }

internal/pkg/node/modifiers.go

@@ -3,244 +3,84 @@ package node
 import (
 	"github.com/hpcng/warewulf/internal/pkg/errors"
 	"github.com/hpcng/warewulf/internal/pkg/wwlog"
-	"strings"
-
 	"gopkg.in/yaml.v2"
 	"os"
 )
 
-func get2Set(input string) string {
-	if strings.ToUpper(input) == "UNDEF" {
-		return ""
-	}
-	return input
-}
-
 /****
  *
  * NODE MODIFIERS
  *
 ****/
 
-func (self *nodeYaml) AddNode(controllerID string, groupID string, nodeID string) error {
+func (self *nodeYaml) AddNode(nodeID string) (NodeInfo, error) {
 	var node NodeConf
+	var n NodeInfo
 
-	wwlog.Printf(wwlog.VERBOSE, "Adding new node: %s/%s\n", groupID, nodeID)
+	wwlog.Printf(wwlog.VERBOSE, "Adding new node: %s\n", nodeID)
 
-	if _, ok := self.Controllers[controllerID]; !ok {
-		return errors.New("Controller does not exist: " + controllerID)
+	if _, ok := self.Nodes[nodeID]; ok {
+		return n, errors.New("Nodename already exists: " + nodeID)
 	}
 
-	if _, ok := self.Controllers[controllerID].NodeGroups[groupID]; !ok {
-		return errors.New("Group does not exist: " + groupID)
-	}
+	self.Nodes[nodeID] = &node
+	self.Nodes[nodeID].Profiles = []string{"default"}
+	self.Nodes[nodeID].NetDevs = make(map[string]*NetDevs)
 
-	if _, ok := self.Controllers[controllerID].NodeGroups[groupID].Nodes[groupID]; ok {
-		return errors.New("Nodename already exists in group: " + nodeID)
-	}
+	n.Id.Set(nodeID)
+	n.Profiles = []string{"default"}
+	n.NetDevs = make(map[string]*NetDevEntry)
 
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID] = &node
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].Hostname = nodeID
-
-	return nil
+	return n, nil
 }
 
-func (self *nodeYaml) DelNode(controllerID string, groupID string, nodeID string) error {
+func (self *nodeYaml) DelNode(nodeID string) error {
 
-	if _, ok := self.Controllers[controllerID]; !ok {
-		return errors.New("Controller does not exist: " + controllerID)
+	if _, ok := self.Nodes[nodeID]; !ok {
+		return errors.New("Nodename does not exist: " + nodeID)
 	}
 
-	if _, ok := self.Controllers[controllerID].NodeGroups[groupID]; !ok {
-		return errors.New("Group does not exist: " + groupID)
-	}
-
-	if _, ok := self.Controllers[controllerID].NodeGroups[groupID].Nodes[groupID]; ok {
-		return errors.New("Nodename does not exist in group: " + nodeID)
-	}
-
-	wwlog.Printf(wwlog.VERBOSE, "Deleting node network device: %s/%s\n", groupID, nodeID)
-	delete(self.Controllers[controllerID].NodeGroups[groupID].Nodes, nodeID)
+	wwlog.Printf(wwlog.VERBOSE, "Deleting node: %s\n", nodeID)
+	delete(self.Nodes, nodeID)
 
 	return nil
 }
 
 func (self *nodeYaml) NodeUpdate(node NodeInfo) error {
-	controllerID := node.Cid.Get()
-	groupID := node.Gid.Get()
 	nodeID := node.Id.Get()
 
-	if _, ok := self.Controllers[controllerID]; !ok {
-		return errors.New("Controller does not exist: " + controllerID)
+	if _, ok := self.Nodes[nodeID]; !ok {
+		return errors.New("Nodename does not exist: " + nodeID)
 	}
 
-	if _, ok := self.Controllers[controllerID].NodeGroups[groupID]; !ok {
-		return errors.New("Group does not exist: " + groupID)
+	self.Nodes[nodeID].Comment = node.Comment.GetReal()
+	self.Nodes[nodeID].Vnfs = node.Vnfs.GetReal()
+	self.Nodes[nodeID].DomainName = node.DomainName.GetReal()
+	self.Nodes[nodeID].Ipxe = node.Ipxe.GetReal()
+	self.Nodes[nodeID].KernelVersion = node.KernelVersion.GetReal()
+	self.Nodes[nodeID].KernelArgs = node.KernelArgs.GetReal()
+	self.Nodes[nodeID].IpmiIpaddr = node.IpmiIpaddr.GetReal()
+	self.Nodes[nodeID].IpmiNetmask = node.IpmiNetmask.GetReal()
+	self.Nodes[nodeID].IpmiUserName = node.IpmiUserName.GetReal()
+	self.Nodes[nodeID].IpmiPassword = node.IpmiPassword.GetReal()
+	self.Nodes[nodeID].RuntimeOverlay = node.RuntimeOverlay.GetReal()
+	self.Nodes[nodeID].SystemOverlay = node.SystemOverlay.GetReal()
+	self.Nodes[nodeID].Profiles = node.Profiles
+
+	for devname, netdev := range node.NetDevs {
+		if _, ok := self.Nodes[nodeID].NetDevs[devname]; !ok {
+			var netdev NetDevs
+			self.Nodes[nodeID].NetDevs[devname] = &netdev
+		}
+
+		self.Nodes[nodeID].NetDevs[devname].Ipaddr = netdev.Ipaddr.GetReal()
+		self.Nodes[nodeID].NetDevs[devname].Netmask = netdev.Netmask.GetReal()
+		self.Nodes[nodeID].NetDevs[devname].Hwaddr = netdev.Hwaddr.GetReal()
+		self.Nodes[nodeID].NetDevs[devname].Gateway = netdev.Gateway.GetReal()
+		self.Nodes[nodeID].NetDevs[devname].Type = netdev.Type.GetReal()
+		self.Nodes[nodeID].NetDevs[devname].Default = netdev.Default.GetRealB()
 	}
 
-	if _, ok := self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID]; !ok {
-		return errors.New("Nodename does not exist in group: " + nodeID)
-	}
-
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].Hostname = get2Set(node.HostName.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].Vnfs = get2Set(node.Vnfs.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].DomainName = get2Set(node.DomainName.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].Ipxe = get2Set(node.Ipxe.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].KernelVersion = get2Set(node.KernelVersion.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].KernelArgs = get2Set(node.KernelArgs.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].IpmiIpaddr = get2Set(node.IpmiIpaddr.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].IpmiNetmask = get2Set(node.IpmiNetmask.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].IpmiUserName = get2Set(node.IpmiUserName.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].IpmiPassword = get2Set(node.IpmiPassword.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].RuntimeOverlay = get2Set(node.RuntimeOverlay.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].SystemOverlay = get2Set(node.SystemOverlay.GetNode())
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].Profiles = node.Profiles
-	self.Controllers[controllerID].NodeGroups[groupID].Nodes[nodeID].NetDevs = node.NetDevs
-
-	return nil
-}
-
-/****
- *
- * GROUP MODIFIERS
- *
-****/
-
-func (self *nodeYaml) AddGroup(controllerID string, groupID string) error {
-	var group GroupConf
-
-	wwlog.Printf(wwlog.VERBOSE, "Adding new group: %s/%s\n", groupID)
-
-	if _, ok := self.Controllers[controllerID]; !ok {
-		return errors.New("Controller does not exist: " + controllerID)
-	}
-
-	if _, ok := self.Controllers[controllerID].NodeGroups[groupID]; ok {
-		return errors.New("Group already exists: " + groupID)
-	}
-
-	self.Controllers[controllerID].NodeGroups[groupID] = &group
-	self.Controllers[controllerID].NodeGroups[groupID].DomainName = groupID
-	self.Controllers[controllerID].NodeGroups[groupID].Profiles = []string{"default"}
-
-	return nil
-}
-
-func (self *nodeYaml) DelGroup(controllerID string, groupID string) error {
-
-	if _, ok := self.Controllers[controllerID]; !ok {
-		return errors.New("Controller does not exist: " + controllerID)
-	}
-
-	if _, ok := self.Controllers[controllerID].NodeGroups[groupID]; !ok {
-		return errors.New("Group does not exist: " + groupID)
-	}
-
-	wwlog.Printf(wwlog.VERBOSE, "Deleting group: %s\n", groupID)
-	delete(self.Controllers[controllerID].NodeGroups, groupID)
-
-	return nil
-}
-
-func (self *nodeYaml) GroupUpdate(group GroupInfo) error {
-	controllerID := group.Cid.Get()
-	groupID := group.Id.Get()
-
-	if _, ok := self.Controllers[controllerID]; !ok {
-		return errors.New("Controller does not exist: " + controllerID)
-	}
-
-	if _, ok := self.Controllers[controllerID].NodeGroups[groupID]; !ok {
-		return errors.New("Group does not exist: " + groupID)
-	}
-
-	self.Controllers[controllerID].NodeGroups[groupID].DomainName = group.DomainName.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].Vnfs = group.Vnfs.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].KernelVersion = group.KernelVersion.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].KernelArgs = group.KernelArgs.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].Ipxe = group.Ipxe.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].IpmiNetmask = group.IpmiNetmask.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].IpmiUserName = group.IpmiUserName.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].IpmiPassword = group.IpmiPassword.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].RuntimeOverlay = group.RuntimeOverlay.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].SystemOverlay = group.SystemOverlay.Get()
-	self.Controllers[controllerID].NodeGroups[groupID].Profiles = group.Profiles
-
-	return nil
-}
-
-/****
- *
- * CONTROLLER MODIFIERS
- *
-****/
-
-func (self *nodeYaml) AddController(controllerID string) error {
-	var controller ControllerConf
-	var group GroupConf
-
-	wwlog.Printf(wwlog.VERBOSE, "Adding new controller: %s/%s\n", controllerID)
-
-	if _, ok := self.Controllers[controllerID]; ok {
-		return errors.New("Controller already exists: " + controllerID)
-	}
-
-	self.Controllers[controllerID] = &controller
-	self.Controllers[controllerID].NodeGroups = make(map[string]*GroupConf)
-	self.Controllers[controllerID].NodeGroups["default"] = &group
-
-	return nil
-}
-
-func (self *nodeYaml) DelController(controllerID string) error {
-
-	if _, ok := self.Controllers[controllerID]; !ok {
-		return errors.New("Controller does not exist: " + controllerID)
-	}
-
-	wwlog.Printf(wwlog.VERBOSE, "Deleting controller: %s\n", controllerID)
-	delete(self.Controllers, controllerID)
-
-	return nil
-}
-
-func (self *nodeYaml) ControllerUpdate(controller ControllerInfo) error {
-	controllerID := controller.Id
-
-	if _, ok := self.Controllers[controllerID]; !ok {
-		return errors.New("Controller does not exist: " + controllerID)
-	}
-
-	self.Controllers[controllerID].Ipaddr = controller.Ipaddr
-	self.Controllers[controllerID].Comment = controller.Comment
-	self.Controllers[controllerID].Fqdn = controller.Fqdn
-
-	self.Controllers[controllerID].Services.Warewulfd.Port = get2Set(controller.Services.Warewulfd.Port)
-	self.Controllers[controllerID].Services.Warewulfd.Secure = controller.Services.Warewulfd.Secure
-	self.Controllers[controllerID].Services.Warewulfd.StartCmd = get2Set(controller.Services.Warewulfd.StartCmd)
-	self.Controllers[controllerID].Services.Warewulfd.RestartCmd = get2Set(controller.Services.Warewulfd.RestartCmd)
-	self.Controllers[controllerID].Services.Warewulfd.EnableCmd = get2Set(controller.Services.Warewulfd.EnableCmd)
-
-	self.Controllers[controllerID].Services.Dhcp.Enabled = controller.Services.Dhcp.Enabled
-	self.Controllers[controllerID].Services.Dhcp.ConfigFile = get2Set(controller.Services.Dhcp.ConfigFile)
-	self.Controllers[controllerID].Services.Dhcp.RangeStart = get2Set(controller.Services.Dhcp.RangeStart)
-	self.Controllers[controllerID].Services.Dhcp.RangeEnd = get2Set(controller.Services.Dhcp.RangeEnd)
-	self.Controllers[controllerID].Services.Dhcp.StartCmd = get2Set(controller.Services.Dhcp.StartCmd)
-	self.Controllers[controllerID].Services.Dhcp.RestartCmd = get2Set(controller.Services.Dhcp.RestartCmd)
-	self.Controllers[controllerID].Services.Dhcp.EnableCmd = get2Set(controller.Services.Dhcp.EnableCmd)
-
-	self.Controllers[controllerID].Services.Nfs.Enabled = controller.Services.Nfs.Enabled
-	self.Controllers[controllerID].Services.Nfs.Exports = controller.Services.Nfs.Exports
-	self.Controllers[controllerID].Services.Nfs.StartCmd = get2Set(controller.Services.Nfs.StartCmd)
-	self.Controllers[controllerID].Services.Nfs.RestartCmd = get2Set(controller.Services.Nfs.RestartCmd)
-	self.Controllers[controllerID].Services.Nfs.EnableCmd = get2Set(controller.Services.Nfs.EnableCmd)
-
-	self.Controllers[controllerID].Services.Tftp.Enabled = controller.Services.Tftp.Enabled
-	self.Controllers[controllerID].Services.Tftp.TftpRoot = get2Set(controller.Services.Tftp.TftpRoot)
-	self.Controllers[controllerID].Services.Tftp.StartCmd = get2Set(controller.Services.Tftp.StartCmd)
-	self.Controllers[controllerID].Services.Tftp.RestartCmd = get2Set(controller.Services.Tftp.RestartCmd)
-	self.Controllers[controllerID].Services.Tftp.EnableCmd = get2Set(controller.Services.Tftp.EnableCmd)
-
 	return nil
 }
 
@@ -250,6 +90,74 @@ func (self *nodeYaml) ControllerUpdate(controller ControllerInfo) error {
  *
 ****/
 
+func (self *nodeYaml) AddProfile(profileID string) (NodeInfo, error) {
+	var node NodeConf
+	var n NodeInfo
+
+	wwlog.Printf(wwlog.VERBOSE, "Adding new profile: %s\n", profileID)
+
+	if _, ok := self.NodeProfiles[profileID]; ok {
+		return n, errors.New("Profile name already exists: " + profileID)
+	}
+
+	self.NodeProfiles[profileID] = &node
+
+	n.Id.Set(profileID)
+
+	return n, nil
+}
+
+func (self *nodeYaml) DelProfile(profileID string) error {
+
+	if _, ok := self.NodeProfiles[profileID]; !ok {
+		return errors.New("Profile does not exist: " + profileID)
+	}
+
+	wwlog.Printf(wwlog.VERBOSE, "Deleting profile: %s\n", profileID)
+	delete(self.NodeProfiles, profileID)
+
+	return nil
+}
+
+func (self *nodeYaml) ProfileUpdate(profile NodeInfo) error {
+	profileID := profile.Id.Get()
+
+	if _, ok := self.NodeProfiles[profileID]; !ok {
+		return errors.New("Profile name does not exist: " + profileID)
+	}
+	self.NodeProfiles[profileID].Comment = profile.Comment.GetReal()
+	self.NodeProfiles[profileID].Vnfs = profile.Vnfs.GetReal()
+	self.NodeProfiles[profileID].Ipxe = profile.Ipxe.GetReal()
+	self.NodeProfiles[profileID].KernelVersion = profile.KernelVersion.GetReal()
+	self.NodeProfiles[profileID].KernelArgs = profile.KernelArgs.GetReal()
+	self.NodeProfiles[profileID].IpmiIpaddr = profile.IpmiIpaddr.GetReal()
+	self.NodeProfiles[profileID].IpmiNetmask = profile.IpmiNetmask.GetReal()
+	self.NodeProfiles[profileID].IpmiUserName = profile.IpmiUserName.GetReal()
+	self.NodeProfiles[profileID].IpmiPassword = profile.IpmiPassword.GetReal()
+	self.NodeProfiles[profileID].RuntimeOverlay = profile.RuntimeOverlay.GetReal()
+	self.NodeProfiles[profileID].SystemOverlay = profile.SystemOverlay.GetReal()
+	self.NodeProfiles[profileID].Profiles = profile.Profiles
+
+	for devname, netdev := range profile.NetDevs {
+		if _, ok := self.NodeProfiles[profileID].NetDevs[devname]; !ok {
+			var netdev NetDevs
+			self.NodeProfiles[profileID].NetDevs[devname] = &netdev
+		}
+
+		self.NodeProfiles[profileID].NetDevs[devname].Ipaddr = netdev.Ipaddr.GetReal()
+		self.NodeProfiles[profileID].NetDevs[devname].Netmask = netdev.Netmask.GetReal()
+		self.NodeProfiles[profileID].NetDevs[devname].Hwaddr = netdev.Hwaddr.GetReal()
+		self.NodeProfiles[profileID].NetDevs[devname].Gateway = netdev.Gateway.GetReal()
+		self.NodeProfiles[profileID].NetDevs[devname].Type = netdev.Type.GetReal()
+		self.NodeProfiles[profileID].NetDevs[devname].Default = netdev.Default.GetRealB()
+	}
+
+	return nil
+}
+
+/*
+
+
 func (self *nodeYaml) AddProfile(profileID string) error {
 	var profile ProfileConf
 
@@ -295,6 +203,12 @@ func (self *nodeYaml) ProfileUpdate(profile ProfileInfo) error {
 	return nil
 }
 
+
+
+
+
+*/
+
 /****
  *
  * PERSISTENCE