✨ Redefine commands depending on user permissions (#338)

<!--
Copyright (C) 2020-2022 Arm Limited or its affiliates and Contributors.
All rights reserved.
SPDX-License-Identifier: Apache-2.0
-->
### Description

- `[platform]` Added `WithPrivileges` so that commands are elevated with
privileges depending on the permissions of the current user
this is so that commands are redefined automatically to run with `sudo`
or `runas` depending on current user permissions



### Test Coverage

<!--
Please put an `x` in the correct box e.g. `[x]` to indicate the testing
coverage of this change.
-->

- [x]  This change is covered by existing or additional automated tests.
- [ ] Manual testing has been performed (and evidence provided) as
automated testing was not feasible.
- [ ] Additional tests are not required for this change (e.g.
documentation update).

---------

Co-authored-by: Josh Jennings <josh.jennings@arm.com>

Author: acabarbaye

changes/20231016164922.feature

@@ -0,0 +1 @@
+:sparkles: `[collection]` Added `AllNotEmpty` and `AnyEmpty` to check the content of string slices

changes/20231016173631.feature

@@ -0,0 +1 @@
+:sparkles: `[collection]` Added `FindInSlice` to extend `Find` search capabilities

changes/20231016175953.feature

@@ -0,0 +1 @@
+:sparkles: `[platform]` Added a way to determine if a user has admin rights (i.e. root or superuser on Linux and administrator on Windows) 

changes/20231016204910.feature

@@ -0,0 +1 @@
+:sparkles: `[command]` Added a way to prepend commands (using `Prepend()`) to command wrappers in order to chain command wrappers easily

changes/20231016234712.feature

@@ -0,0 +1 @@
+:sparkles: `[platform]` Added `WithPrivileges` so that commands are elevated with privileges depending on the permissions of the current user

utils/collection/search.go

@@ -4,31 +4,78 @@
  */
 package collection
 
+import "strings"
+
 // Find looks for an element in a slice. If found it will
 // return its index and true; otherwise it will return -1 and false.
 func Find(slice *[]string, val string) (int, bool) {
-	for i, item := range *slice {
-		if item == val {
-			return i, true
+	if slice == nil {
+		return -1, false
+	}
+	return FindInSlice(true, *slice, val)
+}
+
+// FindInSlice finds if any values val are present in the slice and if so returns the first index.
+// if strict, it check of an exact match; otherwise discard whitespaces and case.
+func FindInSlice(strict bool, slice []string, val ...string) (int, bool) {
+	if len(val) == 0 || len(slice) == 0 {
+		return -1, false
+	}
+
+	inSlice := make(map[string]int, len(slice))
+	for i := range slice {
+		item := slice[i]
+		if !strict {
+			item = strings.ToLower(strings.TrimSpace(item))
+		}
+		if _, ok := inSlice[item]; !ok {
+			inSlice[item] = i
+		}
+	}
+
+	for i := range val {
+		item := val[i]
+		if !strict {
+			item = strings.ToLower(strings.TrimSpace(item))
+		}
+		if idx, ok := inSlice[item]; ok {
+			return idx, true
 		}
 	}
+
 	return -1, false
 }
 
+// Any returns true if there is at least one element of the slice which is true.
 func Any(slice []bool) bool {
-	for _, v := range slice {
-		if v {
+	for i := range slice {
+		if slice[i] {
 			return true
 		}
 	}
 	return false
 }
 
+// AnyEmpty returns whether there is one entry in the slice which is empty.
+// If strict, then whitespaces are considered as empty strings
+func AnyEmpty(strict bool, slice []string) bool {
+	_, found := FindInSlice(!strict, slice, "")
+	return found
+}
+
+// All returns true if all items of the slice are true.
 func All(slice []bool) bool {
-	for _, v := range slice {
-		if !v {
+	for i := range slice {
+		if !slice[i] {
 			return false
 		}
 	}
 	return true
 }
+
+// AllNotEmpty returns whether all elements of the slice are not empty.
+// If strict, then whitespaces are considered as empty strings
+func AllNotEmpty(strict bool, slice []string) bool {
+	_, found := FindInSlice(!strict, slice, "")
+	return !found
+}

utils/collection/search_test.go

@@ -7,11 +7,15 @@ package collection
 import (
 	"testing"
 
+	"github.com/bxcodec/faker/v3"
 	"github.com/stretchr/testify/assert"
 )
 
 func TestFind(t *testing.T) {
-	index, found := Find(&[]string{"A", "b", "c"}, "D")
+	index, found := Find(nil, "D")
+	assert.False(t, found)
+	assert.Equal(t, -1, index)
+	index, found = Find(&[]string{"A", "b", "c"}, "D")
 	assert.False(t, found)
 	assert.Equal(t, -1, index)
 
@@ -20,6 +24,39 @@ func TestFind(t *testing.T) {
 	assert.Equal(t, 2, index)
 }
 
+func TestFindInSlice(t *testing.T) {
+	index, found := FindInSlice(true, nil, "D")
+	assert.False(t, found)
+	assert.Equal(t, -1, index)
+	index, found = FindInSlice(true, []string{"A", "b", "c"})
+	assert.False(t, found)
+	assert.Equal(t, -1, index)
+	index, found = FindInSlice(true, []string{"A", "b", "c"}, "D")
+	assert.False(t, found)
+	assert.Equal(t, -1, index)
+	index, found = FindInSlice(true, []string{"A", "b", "c"}, "D", "e", "f", "g", "H")
+	assert.False(t, found)
+	assert.Equal(t, -1, index)
+	index, found = FindInSlice(false, []string{"A", "b", "c"}, "D")
+	assert.False(t, found)
+	assert.Equal(t, -1, index)
+	index, found = FindInSlice(false, []string{"A", "b", "c"}, "D", "e", "f", "g", "H")
+	assert.False(t, found)
+	assert.Equal(t, -1, index)
+	index, found = FindInSlice(true, []string{"A", "B", "b", "c"}, "b")
+	assert.True(t, found)
+	assert.Equal(t, 2, index)
+	index, found = FindInSlice(false, []string{"A", "B", "b", "c"}, "b")
+	assert.True(t, found)
+	assert.Equal(t, 1, index)
+	index, found = FindInSlice(true, []string{"A", "B", "b", "c"}, "b", "D", "e", "f", "g", "H")
+	assert.True(t, found)
+	assert.Equal(t, 2, index)
+	index, found = FindInSlice(false, []string{"A", "B", "b", "c"}, "b", "D", "e", "f", "g", "H")
+	assert.True(t, found)
+	assert.Equal(t, 1, index)
+}
+
 func TestAny(t *testing.T) {
 	assert.True(t, Any([]bool{false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false}))
 	assert.False(t, Any([]bool{false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false}))
@@ -33,3 +70,23 @@ func TestAll(t *testing.T) {
 	assert.True(t, All([]bool{true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true}))
 	assert.False(t, All([]bool{true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true}))
 }
+
+func TestAnyEmpty(t *testing.T) {
+	assert.True(t, AnyEmpty(false, []string{faker.Username(), faker.Name(), faker.Sentence(), ""}))
+	assert.False(t, AnyEmpty(false, []string{faker.Username(), "         ", faker.Name(), faker.Sentence()}))
+	assert.True(t, AnyEmpty(true, []string{faker.Username(), "         ", faker.Name(), faker.Sentence()}))
+	assert.True(t, AnyEmpty(false, []string{"", faker.Name(), faker.Sentence()}))
+	assert.True(t, AnyEmpty(false, []string{faker.Username(), "", faker.Name(), faker.Sentence()}))
+	assert.True(t, AnyEmpty(false, []string{faker.Username(), "", faker.Name(), "", faker.Sentence()}))
+	assert.False(t, AnyEmpty(false, []string{faker.Username(), faker.Name(), faker.Sentence()}))
+}
+
+func TestAllNotEmpty(t *testing.T) {
+	assert.False(t, AllNotEmpty(false, []string{faker.Username(), faker.Name(), faker.Sentence(), ""}))
+	assert.False(t, AllNotEmpty(false, []string{"", faker.Name(), faker.Sentence()}))
+	assert.False(t, AllNotEmpty(false, []string{faker.Username(), "", faker.Name(), faker.Sentence()}))
+	assert.True(t, AllNotEmpty(false, []string{faker.Username(), "     ", faker.Name(), faker.Sentence()}))
+	assert.False(t, AllNotEmpty(true, []string{faker.Username(), "      ", faker.Name(), faker.Sentence()}))
+	assert.False(t, AllNotEmpty(false, []string{faker.Username(), "", faker.Name(), "", faker.Sentence()}))
+	assert.True(t, AllNotEmpty(false, []string{faker.Username(), faker.Name(), faker.Sentence()}))
+}

utils/platform/cmd.go

@@ -0,0 +1,22 @@
+package platform
+
+import "github.com/ARM-software/golang-utils/utils/subprocess/command"
+
+// WithPrivileges redefines a command so that it is run with elevated privileges.
+// For instance, on Linux, if the current user has enough privileges, the command will be run as is.
+// Otherwise, `sudo` will be used if defined as the sudo  (See `DefineSudoCommand`).
+// Similar scenario will happen on Windows, although the elevated command is defined using `DefineSudoCommand`.
+func WithPrivileges(cmd *command.CommandAsDifferentUser) (cmdWithPrivileges *command.CommandAsDifferentUser) {
+	cmdWithPrivileges = cmd
+	if cmdWithPrivileges == nil {
+		cmdWithPrivileges = command.NewCommandAsDifferentUser()
+	}
+	hasPrivileges, err := IsCurrentUserAnAdmin()
+	if err != nil {
+		return
+	}
+	if !hasPrivileges {
+		cmdWithPrivileges.Prepend(getRunCommandWithPrivileges())
+	}
+	return
+}

utils/platform/cmd_posix.go

@@ -11,15 +11,14 @@ var (
 	sudoCommand = command.Sudo()
 )
 
-// DefineSudoCommand defines the command to run to be `root` or a user with enough privileges to manage accounts.
+// DefineSudoCommand defines the command to run to be `root` or a user with enough privileges (superuser).
 // e.g.
 //   - args="sudo" to run commands as `root`
 //   - args="su", "tom" if `tom` has enough privileges to run the command
-//   - args="gosu", "tom" if `tom` has enough privileges to run the command in a container and `gosu` is installed
 func DefineSudoCommand(args ...string) {
 	sudoCommand = command.NewCommandAsDifferentUser(args...)
 }
 
-func defineCommandWithPrivileges(args ...string) (string, []string) {
-	return sudoCommand.RedefineCommand(args...)
+func getRunCommandWithPrivileges() *command.CommandAsDifferentUser {
+	return sudoCommand
 }

utils/platform/cmd_test.go

@@ -0,0 +1,33 @@
+package platform
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/bxcodec/faker/v3"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/ARM-software/golang-utils/utils/subprocess/command"
+)
+
+func TestWithPrivileges(t *testing.T) {
+	admin, err := IsCurrentUserAnAdmin()
+	require.NoError(t, err)
+	name := faker.Username()
+	cmd := WithPrivileges(command.Gosu(name)).RedefineInShellForm("test", "1", "2", "3")
+	if admin {
+		assert.Equal(t, fmt.Sprintf("gosu %v test 1 2 3", name), cmd)
+	} else {
+		assert.True(t, strings.Contains(cmd, fmt.Sprintf("gosu %v test 1 2 3", name)))
+		assert.False(t, strings.HasPrefix(cmd, fmt.Sprintf("gosu %v test 1 2 3", name)))
+	}
+	cmd = WithPrivileges(nil).RedefineInShellForm("test", "1", "2", "3")
+	if admin {
+		assert.Equal(t, "test 1 2 3", cmd)
+	} else {
+		assert.True(t, strings.Contains(cmd, "test 1 2 3"))
+		assert.False(t, strings.HasPrefix(cmd, "test 1 2 3"))
+	}
+}