Merge branch 'main' of github.com:hpcng/warewulf into netdev_refactor

Makefile

@@ -5,7 +5,7 @@ RELEASE ?= 1
 
 SRC ?= main
 
-VERSION_FULL ?= $(shell test -e .git && git describe --tags --long --first-parent)
+VERSION_FULL ?= $(shell test -e .git && git describe --tags --long --first-parent --always)
 ifeq ($(VERSION_FULL),)
 VERSION_FULL := $(VERSION)
 endif

internal/pkg/kernel/kernel.go

@@ -16,6 +16,16 @@ import (
 	"github.com/hpcng/warewulf/internal/pkg/wwlog"
 )
 
+var (
+	kernelSearchPaths = []string{
+		// This is a printf format where the %s will be the kernel version
+		"/boot/vmlinuz-%s",
+		"/boot/vmlinuz-%s.gz",
+		"/lib/mmodules/%s/vmlinuz",
+		"/lib/mmodules/%s/vmlinuz.gz",
+	}
+)
+
 func ParentDir() string {
 	return path.Join(config.LocalStateDir, "provision/kernel")
 }
@@ -100,12 +110,12 @@ func ListKernels() ([]string, error) {
 }
 
 func Build(kernelVersion string, kernelName string, root string) (string, error) {
-	kernelImage := path.Join(root, "/boot/vmlinuz-"+kernelVersion)
 	kernelDrivers := path.Join(root, "/lib/modules/"+kernelVersion)
   kernelDriversRelative := path.Join("/lib/modules/"+kernelVersion)
 	kernelDestination := KernelImage(kernelName)
 	driversDestination := KmodsImage(kernelName)
 	versionDestination := KernelVersion(kernelName)
+	var kernelSource string
 
 	// Create the destination paths just in case it doesn't exist
 	err := os.MkdirAll(path.Dir(kernelDestination), 0755)
@@ -123,21 +133,29 @@ func Build(kernelVersion string, kernelName string, root string) (string, error)
 		return "", fmt.Errorf("failed to create version dest: %s", err)
 	}
 
-	if !util.IsFile(kernelImage) {
+	for _, path := range kernelSearchPaths {
-		if !util.IsFile(kernelImage + ".gz") {
+		testPath := fmt.Sprintf(path, kernelVersion)
-			return "", errors.New("Could not locate kernel image")
+		wwlog.Printf(wwlog.VERBOSE, "Looking for kernel at: %s\n", testPath)
-		} else {
+		if util.IsFile(testPath) {
-			kernelImage = kernelImage + ".gz"
+			kernelSource = testPath
+			break
 		}
 	}
 
+	if kernelSource == "" {
+		wwlog.Printf(wwlog.ERROR, "Could not locate kernel image\n")
+		return "", errors.New("could not locate kernel image")
+	} else {
+		wwlog.Printf(wwlog.INFO, "Found kernel at: %s\n", kernelSource)
+	}
+
 	if !util.IsDir(kernelDrivers) {
 		return "", errors.New("Could not locate kernel drivers")
 	}
 
 	wwlog.Printf(wwlog.VERBOSE, "Setting up Kernel\n")
-	if _, err := os.Stat(kernelImage); err == nil {
+	if _, err := os.Stat(kernelSource); err == nil {
-		kernel, err := os.Open(kernelImage)
+		kernel, err := os.Open(kernelSource)
 		if err != nil {
 			return "", errors.Wrap(err, "could not open kernel")
 		}
@@ -160,7 +178,7 @@ func Build(kernelVersion string, kernelName string, root string) (string, error)
 
 		} else {
 
-			err := util.CopyFile(kernelImage, kernelDestination)
+			err := util.CopyFile(kernelSource, kernelDestination)
 			if err != nil {
 				return "", errors.Wrap(err, "could not copy kernel")
 			}

internal/pkg/node/constructors.go

@@ -2,7 +2,6 @@ package node
 
 import (
 	"errors"
-	"fmt"
 	"io/ioutil"
 	"sort"
 	"strings"
@@ -16,10 +15,9 @@ var ConfigFile = "/etc/warewulf/nodes.conf"
 func New() (nodeYaml, error) {
 	var ret nodeYaml
 
-	wwlog.Printf(wwlog.DEBUG, "Opening node configuration file: %s\n", ConfigFile)
+	wwlog.Printf(wwlog.VERBOSE, "Opening node configuration file: %s\n", ConfigFile)
 	data, err := ioutil.ReadFile(ConfigFile)
 	if err != nil {
-		fmt.Printf("error reading node configuration file\n")
 		return ret, err
 	}
 

internal/pkg/warewulfd/util.go

@@ -36,10 +36,11 @@ func daemonLogf(message string, a ...interface{}) {
 			}
 			log.SetOutput(logwriter)
 			loginit = true
+
+			log.SetFlags(0)
+			log.SetPrefix("")
 		}
 
-		log.SetFlags(0)
-		log.SetPrefix("")
 		log.Printf(message, a...)
 
 	} else {

internal/pkg/wwlog/wwlog.go

@@ -1,8 +1,8 @@
 package wwlog
 
 import (
-	"log"
+	"fmt"
-	"strings"
+	"os"
 )
 
 const (
@@ -16,55 +16,48 @@ const (
 
 var (
 	logLevel = INFO
-	Indent   string
 )
 
 func SetLevel(level int) {
 	logLevel = level
 
-	if level == DEBUG {
-		log.SetFlags(log.LstdFlags | log.Lmicroseconds | log.Lmsgprefix)
-	} else {
-		log.SetFlags(0)
-	}
-
 	Printf(DEBUG, "Set log level to: %d\n", logLevel)
 }
 
-func SetIndent(i int) {
+func prefixGen(level int) string {
-	Indent = strings.Repeat(" ", i)
+	switch level {
+	case DEBUG:
+		return "[DEBUG]   : "
+	case VERBOSE:
+		return "[VERBOSE] : "
+	case INFO:
+		return "[INFO]    : "
+	case WARN:
+		return "[WARNING] : "
+	case ERROR:
+		return "[ERROR]   : "
+	case CRITICAL:
+		return "[CRITICAL]: "
+	}
+	return "[UNDEF]   : "
 }
 
-func prefixLevel(level int) {
+func printlog(level int, message string) {
-	if level == DEBUG {
+	if level == INFO && logLevel <= INFO {
-		log.SetPrefix("[DEBUG]    " + Indent)
+		fmt.Print(message)
-	} else if level == VERBOSE {
+	} else if level <= logLevel {
-		log.SetPrefix("[VERBOSE]  " + Indent)
+		if level < INFO {
-	} else if level == INFO {
+			fmt.Fprintf(os.Stderr, prefixGen(level)+message)
-		log.SetPrefix("[INFO]     " + Indent)
+		} else {
-	} else if level == WARN {
+			fmt.Printf(prefixGen(level) + message)
-		log.SetPrefix("[WARN]     " + Indent)
+		}
-	} else if level == ERROR {
-		log.SetPrefix("[ERROR] 	  " + Indent)
-	} else if level == CRITICAL {
-		log.SetPrefix("[CRITICAL] " + Indent)
 	}
 }
 
 func Println(level int, message string) {
-	if level <= logLevel {
+	printlog(level, message)
-		prefixLevel(level)
-		log.Println(message)
-	}
-
-	log.SetPrefix("[LOG]      " + Indent)
 }
 
 func Printf(level int, message string, a ...interface{}) {
-	if level <= logLevel {
+	printlog(level, fmt.Sprintf(message, a...))
-		prefixLevel(level)
-		log.Printf(message, a...)
-	}
-
-	log.SetPrefix("[LOG]      " + Indent)
 }