Merge pull request #4 from supercontainers/add-mpi-extractor

add mpi extractor

Author: vsoch

README.md

@@ -81,15 +81,16 @@ The list command lists each extractor, and sections available for it.
 $ ./bin/compspec list
 ```
 ```console
- Compatibility Plugins              
-        TYPE      NAME    SECTION   
-        extrator  kernel  boot      
-        extrator  kernel  config    
-        extrator  kernel  modules   
-        extrator  system  cpu       
-        extrator  system  processor 
-        extrator  system  os        
- TOTAL  6
+ Compatibility Plugins               
+        TYPE      NAME     SECTION   
+        extrator  kernel   boot      
+        extrator  kernel   config    
+        extrator  kernel   modules   
+        extrator  system   cpu       
+        extrator  system   processor 
+        extrator  system   os        
+        extrator  library  mpi       
+ TOTAL  7                            
 ```
 
 Note that we will eventually add a description column - it's not really warranted yet!

pkg/utils/terminal.go

@@ -0,0 +1,19 @@
+package utils
+
+import (
+	"os/exec"
+)
+
+// RunCommand runs an executable (name)
+func RunCommand(args []string) (string, error) {
+
+	executable := args[0]
+	args = args[1:]
+
+	cmd := exec.Command(executable, args...)
+	out, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	return string(out), nil
+}

plugins/extractors/library/extractors.go

@@ -0,0 +1,75 @@
+package library
+
+import (
+	"fmt"
+	"os/exec"
+	"regexp"
+	"strings"
+
+	"github.com/supercontainers/compspec-go/pkg/extractor"
+	"github.com/supercontainers/compspec-go/pkg/utils"
+)
+
+const (
+	MPIRunExec = "mpirun"
+)
+
+var (
+	regexIntelMPIVersion = regexp.MustCompile(`Version (.*) `)
+)
+
+// getMPIInformation returns info on mpi versions and variant
+// yes, fairly janky, please improve upon! This is for a prototype
+func getMPIInformation() (extractor.ExtractorSection, error) {
+	info := extractor.ExtractorSection{}
+
+	// Do we even have mpirun?
+	path, err := exec.LookPath(MPIRunExec)
+	if err != nil {
+		return info, nil
+	}
+
+	// Get output from the tool
+	command := []string{MPIRunExec, "--version"}
+	output, err := utils.RunCommand(command)
+	if err != nil {
+		return info, err
+	}
+
+	// This is really simple - if we find Open MPI in a line, that's the variant
+	lines := strings.Split(output, "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if strings.Contains(line, "Open MPI") {
+			info["mpi.variant"] = "OpenMPI"
+			parts := strings.Split(line, " ")
+			info["mpi.version"] = parts[len(parts)-1]
+			return info, nil
+		}
+
+		// Intel(R) MPI Library for Linux* OS, Version 2021.8 Build 20221129 (id: 339ec755a1)
+		if strings.Contains(line, "Intel") {
+			info["mpi.variant"] = "intel-mpi"
+			match := regexIntelMPIVersion.FindStringSubmatch(line)
+			if match != nil {
+				parts := strings.Split(match[0], " ")
+				info["mpi.version"] = parts[1]
+			}
+			return info, nil
+		}
+
+		// Note that for mpich there is a LOT more metadata
+		// Right now I'm assuming if we find Version: it's for Open MPI
+		if strings.Contains(line, "Version:") {
+			info["mpi.variant"] = "mpich"
+			parts := strings.Split(line, " ")
+			info["mpi.version"] = parts[len(parts)-1]
+			return info, nil
+		}
+
+	}
+
+	fmt.Println(output)
+	fmt.Printf("%s is available at %s\n", MPIRunExec, path)
+	return info, nil
+}

plugins/extractors/library/library.go

@@ -0,0 +1,70 @@
+package library
+
+import (
+	"fmt"
+
+	"github.com/supercontainers/compspec-go/pkg/extractor"
+	"github.com/supercontainers/compspec-go/pkg/utils"
+)
+
+const (
+	ExtractorName = "library"
+	MPISection    = "mpi"
+)
+
+var (
+	validSections = []string{MPISection}
+)
+
+type LibraryExtractor struct {
+	sections []string
+}
+
+func (e LibraryExtractor) Name() string {
+	return ExtractorName
+}
+
+func (e LibraryExtractor) Sections() []string {
+	return e.sections
+}
+
+// Validate ensures that the sections provided are in the list we know
+func (e LibraryExtractor) Validate() bool {
+	invalids, valid := utils.StringArrayIsSubset(e.sections, validSections)
+	for _, invalid := range invalids {
+		fmt.Printf("Sections %s is not known for extractor plugin %s\n", invalid, e.Name())
+	}
+	return valid
+}
+
+// Extract returns library metadata, for a set of named sections
+func (e LibraryExtractor) Extract(interface{}) (extractor.ExtractorData, error) {
+
+	sections := map[string]extractor.ExtractorSection{}
+	data := extractor.ExtractorData{}
+
+	// Only extract the sections we asked for
+	for _, name := range e.sections {
+		if name == MPISection {
+			section, err := getMPIInformation()
+			if err != nil {
+				return data, err
+			}
+			sections[MPISection] = section
+		}
+	}
+	data.Sections = sections
+	return data, nil
+}
+
+// NewPlugin validates and returns a new plugin
+func NewPlugin(sections []string) (extractor.Extractor, error) {
+	if len(sections) == 0 {
+		sections = validSections
+	}
+	e := LibraryExtractor{sections: sections}
+	if !e.Validate() {
+		return nil, fmt.Errorf("plugin %s is not valid\n", e.Name())
+	}
+	return e, nil
+}

plugins/extractors/system/os.go

@@ -22,6 +22,7 @@ const (
 	versionDebianFile = "/etc/debian_version"
 	versionCentosFile = "/etc/centos-release"
 	versionRHELFile   = "/etc/redhat-release"
+	versionRockyFile  = "/etc/rocky-release"
 )
 
 var (
@@ -30,6 +31,7 @@ var (
 	regexVersion = regexp.MustCompile(`^VERSION_ID=(.*)$`)
 	regexUbuntu  = regexp.MustCompile(`[\( ]([\d\.]+)`)
 	regexCentos  = regexp.MustCompile(`^CentOS( Linux)? release ([\d\.]+)`)
+	regexRocky   = regexp.MustCompile(`^Rocky( Linux)? release ([\d\.]+)`)
 	regexRHEL    = regexp.MustCompile(`[\( ]([\d\.]+)`)
 	linkerPaths  = map[string]string{"amd64": linkerAMD64, "i386": linkeri386}
 )
@@ -112,6 +114,17 @@ func readOsRelease(prettyName string, vendor string) (string, error) {
 		if match != nil {
 			return match[2], nil
 		}
+	case "rocky":
+		raw, err := os.ReadFile(versionRockyFile)
+		if err != nil {
+			return "", err
+		}
+		match := regexRocky.FindStringSubmatch(string(raw))
+		if match != nil {
+			// Rocky Linux release 9.3 (Blue Onyx)
+			parts := strings.Split(match[2], " ")
+			return parts[0], nil
+		}
 	case "rhel":
 		raw, err := os.ReadFile(versionRHELFile)
 		if err != nil {

plugins/plugins.go

@@ -3,6 +3,7 @@ package plugins
 import (
 	"strings"
 
+	"github.com/supercontainers/compspec-go/plugins/extractors/library"
 	"github.com/supercontainers/compspec-go/plugins/extractors/kernel"
 	"github.com/supercontainers/compspec-go/plugins/extractors/system"
 )
@@ -11,7 +12,8 @@ import (
 var (
 	KernelExtractor = "kernel"
 	SystemExtractor = "system"
-	pluginNames     = []string{KernelExtractor, SystemExtractor}
+	LibraryExtractor = "library"
+	pluginNames     = []string{KernelExtractor, SystemExtractor, LibraryExtractor}
 )
 
 // parseSections will return sections from the name string
@@ -72,6 +74,16 @@ func GetPlugins(names []string) (PluginsRequest, error) {
 			pr := PluginRequest{Name: name, Extractor: p, Sections: sections}
 			request = append(request, pr)
 		}
+
+		if strings.HasPrefix(name, LibraryExtractor) {
+			p, err := library.NewPlugin(sections)
+			if err != nil {
+				return request, err
+			}
+			// Save the name, the instantiated interface, and sections
+			pr := PluginRequest{Name: name, Extractor: p, Sections: sections}
+			request = append(request, pr)
+		}
 	}
 	return request, nil
 }