opensource/podman
1
0
Fork 0
mirror of https://github.com/containers/podman.git synced 2025-05-17 06:59:07 +08:00
Code Issues Packages Projects Releases Wiki Activity

test/e2e: remove kernel version check

Browse Source 
We need something newer than 4.14 anyway now for most Podman functions.
This is breaking liniting on windows as the function doesn't work there.

Signed-off-by: Paul Holzinger <pholzing@redhat.com>
This commit is contained in:
Paul Holzinger
2024-08-15 14:59:22 +02:00
parent 6c0d94328f
commit cd2a4c7cac
8 changed files with 0 additions and 279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
test/e2e/run_privileged_test.go
View File

@ -137,13 +137,6 @@ var _ = Describe("Podman privileged container tests", func() {
})
It("run no-new-privileges test", func() {
// Check if our kernel is new enough
k, err := IsKernelNewerThan("4.14")
Expect(err).ToNot(HaveOccurred())
if !k {
Skip("Kernel is not new enough to test this feature")
}
cap := SystemExec("grep", []string{"NoNewPrivs", "/proc/self/status"})
if cap.ExitCode() != 0 {
Skip("Can't determine NoNewPrivs")

12
test/utils/common_function_test.go
View File

@ -56,18 +56,6 @@ var _ = Describe("Common functions test", func() {
Entry("Item empty with and without \"", "/tmp/os-release.test", "", "\"\"", false),
)
DescribeTable("Test IsKernelNewerThan",
func(kv string, expect, isNil bool) {
newer, err := IsKernelNewerThan(kv)
Expect(newer).To(Equal(expect), "Version compare results is not as expect.")
Expect(err == nil).To(Equal(isNil), "Error is not as expect.")
},
Entry("Invalid kernel version: 0", "0", false, false),
Entry("Older kernel version:0.0", "0.0", true, true),
Entry("Newer kernel version: 100.17.14", "100.17.14", false, true),
Entry("Invalid kernel version: I am not a kernel version", "I am not a kernel version", false, false),
)
DescribeTable("Test TestIsCommandAvailable",
func(cmd string, expect bool) {
cmdExist := IsCommandAvailable(cmd)

22
test/utils/utils.go
View File

@ -19,7 +19,6 @@ import (
"github.com/sirupsen/logrus"
"github.com/containers/storage/pkg/parsers/kernel"
. "github.com/onsi/ginkgo/v2" //nolint:revive,stylecheck
. "github.com/onsi/gomega" //nolint:revive,stylecheck
. "github.com/onsi/gomega/gexec" //nolint:revive,stylecheck
@ -455,27 +454,6 @@ func GetHostDistributionInfo() HostOS {
return host
}
// IsKernelNewerThan compares the current kernel version to one provided. If
// the kernel is equal to or greater, returns true
func IsKernelNewerThan(version string) (bool, error) {
inputVersion, err := kernel.ParseRelease(version)
if err != nil {
return false, err
}
kv, err := kernel.GetKernelVersion()
if err != nil {
return false, err
}
// CompareKernelVersion compares two kernel.VersionInfo structs.
// Returns -1 if a < b, 0 if a == b, 1 it a > b
result := kernel.CompareKernelVersion(*kv, *inputVersion)
if result >= 0 {
return true, nil
}
return false, nil
}
// IsCommandAvailable check if command exist
func IsCommandAvailable(command string) bool {
check := exec.Command("bash", "-c", strings.Join([]string{"command -v", command}, " "))

90
vendor/github.com/containers/storage/pkg/parsers/kernel/kernel.go generated vendored
View File

@ -1,90 +0,0 @@
//go:build !windows
// +build !windows
// Package kernel provides helper function to get, parse and compare kernel
// versions for different platforms.
package kernel
import (
"errors"
"fmt"
"github.com/sirupsen/logrus"
)
// VersionInfo holds information about the kernel.
type VersionInfo struct {
Kernel int // Version of the kernel (e.g. 4.1.2-generic -> 4)
Major int // Major part of the kernel version (e.g. 4.1.2-generic -> 1)
Minor int // Minor part of the kernel version (e.g. 4.1.2-generic -> 2)
Flavor string // Flavor of the kernel version (e.g. 4.1.2-generic -> generic)
}
func (k *VersionInfo) String() string {
return fmt.Sprintf("%d.%d.%d%s", k.Kernel, k.Major, k.Minor, k.Flavor)
}
// CompareKernelVersion compares two kernel.VersionInfo structs.
// Returns -1 if a < b, 0 if a == b, 1 it a > b
func CompareKernelVersion(a, b VersionInfo) int {
if a.Kernel < b.Kernel {
return -1
} else if a.Kernel > b.Kernel {
return 1
}
if a.Major < b.Major {
return -1
} else if a.Major > b.Major {
return 1
}
if a.Minor < b.Minor {
return -1
} else if a.Minor > b.Minor {
return 1
}
return 0
}
// CheckKernelVersion checks if current kernel is newer than (or equal to)
// the given version.
func CheckKernelVersion(k, major, minor int) bool {
if v, err := GetKernelVersion(); err != nil {
logrus.Warnf("Error getting kernel version: %s", err)
} else {
if CompareKernelVersion(*v, VersionInfo{Kernel: k, Major: major, Minor: minor}) < 0 {
return false
}
}
return true
}
// ParseRelease parses a string and creates a VersionInfo based on it.
func ParseRelease(release string) (*VersionInfo, error) {
var (
kernel, major, minor, parsed int
flavor, partial string
)
// Ignore error from Sscanf to allow an empty flavor. Instead, just
// make sure we got all the version numbers.
parsed, _ = fmt.Sscanf(release, "%d.%d%s", &kernel, &major, &partial)
if parsed < 2 {
return nil, errors.New("Can't parse kernel version " + release)
}
// sometimes we have 3.12.25-gentoo, but sometimes we just have 3.12-1-amd64
parsed, _ = fmt.Sscanf(partial, ".%d%s", &minor, &flavor)
if parsed < 1 {
flavor = partial
}
return &VersionInfo{
Kernel: kernel,
Major: major,
Minor: minor,
Flavor: flavor,
}, nil
}

57
vendor/github.com/containers/storage/pkg/parsers/kernel/kernel_darwin.go generated vendored
View File

@ -1,57 +0,0 @@
//go:build darwin
// +build darwin
// Package kernel provides helper function to get, parse and compare kernel
// versions for different platforms.
package kernel
import (
"fmt"
"os/exec"
"strings"
"github.com/mattn/go-shellwords"
)
// GetKernelVersion gets the current kernel version.
func GetKernelVersion() (*VersionInfo, error) {
release, err := getRelease()
if err != nil {
return nil, err
}
return ParseRelease(release)
}
// getRelease uses `system_profiler SPSoftwareDataType` to get OSX kernel version
func getRelease() (string, error) {
cmd := exec.Command("system_profiler", "SPSoftwareDataType")
osName, err := cmd.Output()
if err != nil {
return "", err
}
var release string
data := strings.Split(string(osName), "\n")
for _, line := range data {
if strings.Contains(line, "Kernel Version") {
// It has the format like ' Kernel Version: Darwin 14.5.0'
content := strings.SplitN(line, ":", 2)
if len(content) != 2 {
return "", fmt.Errorf("kernel version is invalid")
}
prettyNames, err := shellwords.Parse(content[1])
if err != nil {
return "", fmt.Errorf("kernel version is invalid: %w", err)
}
if len(prettyNames) != 2 {
return "", fmt.Errorf("kernel version needs to be 'Darwin x.x.x' ")
}
release = prettyNames[1]
}
}
return release, nil
}

20
vendor/github.com/containers/storage/pkg/parsers/kernel/kernel_unix.go generated vendored
View File

@ -1,20 +0,0 @@
//go:build unix && !darwin
// Package kernel provides helper function to get, parse and compare kernel
// versions for different platforms.
package kernel
import (
"golang.org/x/sys/unix"
)
// GetKernelVersion gets the current kernel version.
func GetKernelVersion() (*VersionInfo, error) {
uts := &unix.Utsname{}
if err := unix.Uname(uts); err != nil {
return nil, err
}
return ParseRelease(unix.ByteSliceToString(uts.Release[:]))
}

70
vendor/github.com/containers/storage/pkg/parsers/kernel/kernel_windows.go generated vendored
View File

@ -1,70 +0,0 @@
//go:build windows
// +build windows
package kernel
import (
"fmt"
"unsafe"
"golang.org/x/sys/windows"
)
// VersionInfo holds information about the kernel.
type VersionInfo struct {
kvi string // Version of the kernel (e.g. 6.1.7601.17592 -> 6)
major int // Major part of the kernel version (e.g. 6.1.7601.17592 -> 1)
minor int // Minor part of the kernel version (e.g. 6.1.7601.17592 -> 7601)
build int // Build number of the kernel version (e.g. 6.1.7601.17592 -> 17592)
}
func (k *VersionInfo) String() string {
return fmt.Sprintf("%d.%d %d (%s)", k.major, k.minor, k.build, k.kvi)
}
// GetKernelVersion gets the current kernel version.
func GetKernelVersion() (*VersionInfo, error) {
var (
h windows.Handle
dwVersion uint32
err error
)
KVI := &VersionInfo{"Unknown", 0, 0, 0}
if err = windows.RegOpenKeyEx(windows.HKEY_LOCAL_MACHINE,
windows.StringToUTF16Ptr(`SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\`),
0,
windows.KEY_READ,
&h); err != nil {
return KVI, err
}
defer windows.RegCloseKey(h)
var buf [1 << 10]uint16
var typ uint32
n := uint32(len(buf) * 2) // api expects array of bytes, not uint16
if err = windows.RegQueryValueEx(h,
windows.StringToUTF16Ptr("BuildLabEx"),
nil,
&typ,
(*byte)(unsafe.Pointer(&buf[0])),
&n); err != nil {
return KVI, err
}
KVI.kvi = windows.UTF16ToString(buf[:])
// Important - docker.exe MUST be manifested for this API to return
// the correct information.
if dwVersion, err = windows.GetVersion(); err != nil {
return KVI, err
}
KVI.major = int(dwVersion & 0xFF)
KVI.minor = int((dwVersion & 0xFF00) >> 8)
KVI.build = int((dwVersion & 0xFFFF0000) >> 16)
return KVI, nil
}

1
vendor/modules.txt vendored
View File

@ -389,7 +389,6 @@ github.com/containers/storage/pkg/longpath
github.com/containers/storage/pkg/loopback
github.com/containers/storage/pkg/mount
github.com/containers/storage/pkg/parsers
github.com/containers/storage/pkg/parsers/kernel
github.com/containers/storage/pkg/pools
github.com/containers/storage/pkg/promise
github.com/containers/storage/pkg/reexec