Factor out common RHEL parts and RHEL-10 from RHEL-9 (COMPOSER-2185)

pkg/distro/fedora/distro_test.go

@@ -255,11 +255,11 @@ func TestFilenameFromType(t *testing.T) {
 					dist := dist.distro
 					arch, _ := dist.GetArch("x86_64")
 					imgType, err := arch.GetImageType(tt.args.outputFormat)
-					if (err != nil) != tt.want.wantErr {
-						t.Errorf("Arch.GetImageType() error = %v, wantErr %v", err, tt.want.wantErr)
-						return
-					}
-					if !tt.want.wantErr {
+					if tt.want.wantErr {
+						require.Error(t, err)
+					} else {
+						require.NoError(t, err)
+						require.NotNil(t, imgType)
 						gotFilename := imgType.Filename()
 						gotMIMEType := imgType.MIMEType()
 						if gotFilename != tt.want.filename {

pkg/distro/rhel9/arch.go → pkg/distro/rhel/arch.go

@@ -1,26 +1,31 @@
-package rhel9
+package rhel
 
 import (
 	"errors"
 	"fmt"
 	"sort"
 
+	"github.com/osbuild/images/pkg/arch"
 	"github.com/osbuild/images/pkg/distro"
 	"github.com/osbuild/images/pkg/platform"
 )
 
-type architecture struct {
-	distro           *distribution
-	name             string
+type Architecture struct {
+	distro           *Distribution
+	arch             arch.Arch
 	imageTypes       map[string]distro.ImageType
 	imageTypeAliases map[string]string
 }
 
-func (a *architecture) Name() string {
-	return a.name
+func (a *Architecture) Name() string {
+	return a.arch.String()
 }
 
-func (a *architecture) ListImageTypes() []string {
+func (a *Architecture) Distro() distro.Distro {
+	return a.distro
+}
+
+func (a *Architecture) ListImageTypes() []string {
 	itNames := make([]string, 0, len(a.imageTypes))
 	for name := range a.imageTypes {
 		itNames = append(itNames, name)
@@ -29,7 +34,7 @@ func (a *architecture) ListImageTypes() []string {
 	return itNames
 }
 
-func (a *architecture) GetImageType(name string) (distro.ImageType, error) {
+func (a *Architecture) GetImageType(name string) (distro.ImageType, error) {
 	t, exists := a.imageTypes[name]
 	if !exists {
 		aliasForName, exists := a.imageTypeAliases[name]
@@ -44,16 +49,16 @@ func (a *architecture) GetImageType(name string) (distro.ImageType, error) {
 	return t, nil
 }
 
-func (a *architecture) addImageTypes(platform platform.Platform, imageTypes ...imageType) {
+func (a *Architecture) AddImageTypes(platform platform.Platform, imageTypes ...*ImageType) {
 	if a.imageTypes == nil {
 		a.imageTypes = map[string]distro.ImageType{}
 	}
 	for idx := range imageTypes {
 		it := imageTypes[idx]
 		it.arch = a
 		it.platform = platform
-		a.imageTypes[it.name] = &it
-		for _, alias := range it.nameAliases {
+		a.imageTypes[it.name] = it
+		for _, alias := range it.NameAliases {
 			if a.imageTypeAliases == nil {
 				a.imageTypeAliases = map[string]string{}
 			}
@@ -65,6 +70,9 @@ func (a *architecture) addImageTypes(platform platform.Platform, imageTypes ...i
 	}
 }
 
-func (a *architecture) Distro() distro.Distro {
-	return a.distro
+func NewArchitecture(distro *Distribution, arch arch.Arch) *Architecture {
+	return &Architecture{
+		distro: distro,
+		arch:   arch,
+	}
 }

pkg/distro/rhel/defaults.go

@@ -0,0 +1,32 @@
+package rhel
+
+import (
+	"github.com/osbuild/images/internal/common"
+	"github.com/osbuild/images/pkg/distro"
+	"github.com/osbuild/images/pkg/osbuild"
+)
+
+const (
+	// location for saving openscap remediation data
+	oscapDataDir = "/oscap_data"
+
+	UEFIVendor = "redhat"
+)
+
+// CentOS- and RHEL-based OS image configuration defaults
+var defaultDistroImageConfig = &distro.ImageConfig{
+	Timezone: common.ToPtr("America/New_York"),
+	Locale:   common.ToPtr("C.UTF-8"),
+	Sysconfig: []*osbuild.SysconfigStageOptions{
+		{
+			Kernel: &osbuild.SysconfigKernelOptions{
+				UpdateDefault: true,
+				DefaultKernel: "kernel",
+			},
+			Network: &osbuild.SysconfigNetworkOptions{
+				Networking: true,
+				NoZeroConf: true,
+			},
+		},
+	},
+}

pkg/distro/rhel/distribution.go

@@ -0,0 +1,135 @@
+package rhel
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/osbuild/images/pkg/distro"
+	"github.com/osbuild/images/pkg/runner"
+)
+
+type Distribution struct {
+	name               string
+	product            string
+	osVersion          string
+	releaseVersion     string
+	modulePlatformID   string
+	vendor             string
+	ostreeRefTmpl      string
+	runner             runner.Runner
+	arches             map[string]distro.Arch
+	defaultImageConfig *distro.ImageConfig
+
+	// distro specific function to check options per image type
+	CheckOptions CheckOptionsFunc
+}
+
+func (d *Distribution) Name() string {
+	return d.name
+}
+
+func (d *Distribution) Releasever() string {
+	return d.releaseVersion
+}
+
+func (d *Distribution) OsVersion() string {
+	return d.osVersion
+}
+
+func (d *Distribution) Product() string {
+	return d.product
+}
+
+func (d *Distribution) ModulePlatformID() string {
+	return d.modulePlatformID
+}
+
+func (d *Distribution) OSTreeRef() string {
+	return d.ostreeRefTmpl
+}
+
+func (d *Distribution) Vendor() string {
+	return d.vendor
+}
+
+func (d *Distribution) ListArches() []string {
+	archNames := make([]string, 0, len(d.arches))
+	for name := range d.arches {
+		archNames = append(archNames, name)
+	}
+	sort.Strings(archNames)
+	return archNames
+}
+
+func (d *Distribution) GetArch(name string) (distro.Arch, error) {
+	arch, exists := d.arches[name]
+	if !exists {
+		return nil, errors.New("invalid architecture: " + name)
+	}
+	return arch, nil
+}
+
+func (d *Distribution) AddArches(arches ...*Architecture) {
+	if d.arches == nil {
+		d.arches = map[string]distro.Arch{}
+	}
+
+	// Do not make copies of architectures, as opposed to image types,
+	// because architecture definitions are not used by more than a single
+	// distro definition.
+	for idx := range arches {
+		d.arches[arches[idx].Name()] = arches[idx]
+	}
+}
+
+func (d *Distribution) IsRHEL() bool {
+	return strings.HasPrefix(d.name, "rhel")
+}
+
+func (d *Distribution) GetDefaultImageConfig() *distro.ImageConfig {
+	return d.defaultImageConfig
+}
+
+func NewDistribution(name string, major, minor int) (*Distribution, error) {
+	var rd *Distribution
+	switch name {
+	case "rhel":
+		if minor == -1 {
+			return nil, errors.New("RHEL requires a minor version")
+		}
+
+		rd = &Distribution{
+			name:               fmt.Sprintf("rhel-%d.%d", major, minor),
+			product:            "Red Hat Enterprise Linux",
+			osVersion:          fmt.Sprintf("%d.%d", major, minor),
+			releaseVersion:     fmt.Sprintf("%d", major),
+			modulePlatformID:   fmt.Sprintf("platform:el%d", major),
+			vendor:             "redhat",
+			ostreeRefTmpl:      fmt.Sprintf("rhel/%d/%%s/edge", major),
+			runner:             &runner.RHEL{Major: uint64(major), Minor: uint64(minor)},
+			defaultImageConfig: defaultDistroImageConfig,
+		}
+	case "centos":
+		if minor != -1 {
+			return nil, fmt.Errorf("CentOS does not have minor versions, but got %d", minor)
+		}
+
+		rd = &Distribution{
+			name:               fmt.Sprintf("centos-%d", major),
+			product:            "CentOS Stream",
+			osVersion:          fmt.Sprintf("%d-stream", major),
+			releaseVersion:     fmt.Sprintf("%d", major),
+			modulePlatformID:   fmt.Sprintf("platform:el%d", major),
+			vendor:             "centos",
+			ostreeRefTmpl:      fmt.Sprintf("centos/%d/%%s/edge", major),
+			runner:             &runner.CentOS{Version: uint64(major)},
+			defaultImageConfig: defaultDistroImageConfig,
+		}
+	default:
+		return nil, fmt.Errorf("unknown distro name: %s", name)
+	}
+
+	return rd, nil
+}