extbldr: added mock subcommand and testUtil

added mock subcommand to build RPM from SRPMs. This internally calls the
mock tool to build the RPM in the architecture specified.
works with default config as of now. quiet option added for mock.
Added a testUtil file to collate common test functions under util
package.

.github/workflows/extbldr.yml

@@ -4,6 +4,9 @@ on:   # yamllint disable-line rule:truthy
     branches:
       - 'main'
 
+env:
+  TEST_TAG: extbldr:test
+
 jobs:
   gobuild:
     name: Go lint and build
@@ -66,6 +69,24 @@ jobs:
           secrets: |
             GIT_AUTH_TOKEN=${{ secrets.GITHUB_TOKEN }}
 
+          load: true
+          tags: ${{ env.TEST_TAG }}
+          target: builder
+      - name: Test privileged
+        run: |
+          docker run --rm --privileged \
+          ${{ env.TEST_TAG }} sh -c 'go test ./... -tags=privileged'
+
+      - name: Dockerfile build without publish
+        uses: docker/build-push-action@v3
+        with:
+          # Dockerfile is within subdirectory
+          context: "{{defaultContext}}:extbldr"
+
+          # GIT_AUTH_TOKEN is unset for non-default context
+          secrets: |
+            GIT_AUTH_TOKEN=${{ secrets.GITHUB_TOKEN }}
           # Publish is done by Arista docker-library to push to on-prem registry
           # This just checks the docker build and can work off-prem.
+          target: deploy
           push: false

extbldr/Dockerfile

@@ -32,6 +32,7 @@ COPY *.go ./
 COPY cmd/ cmd/
 COPY impl/ impl/
 COPY util/ util/
+COPY testutil/ testutil/
 COPY manifest/ manifest/
 RUN go build -o  /home/extbldr-robot/bin/extbldr && \
     go test ./... && \

extbldr/cmd/mock.go

@@ -0,0 +1,30 @@
+// Copyright (c) 2022 Arista Networks, Inc.  All rights reserved.
+// Arista Networks, Inc. Confidential and Proprietary.
+
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"extbldr/impl"
+)
+
+var arch string
+
+// mockcmd represents the mock command
+var mockCmd = &cobra.Command{
+	Use:   "mock -t <Arch> -p <Package>",
+	Short: "Use mock to build the RPMS from the SRPMS built previously.",
+	Long:  `Use mock to build The RPMS for the specified architecture from the specified SRPM package in <SrcDir>/<package>/rpmbuild/SRPMS and output placed inside <WorkingDir>/<package>/RPMS.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		pkg, _ := cmd.Flags().GetString("package")
+		subpkg, _ := cmd.Flags().GetString("subpackage")
+		err := impl.Mock(arch, pkg, subpkg)
+		return err
+	},
+}
+
+func init() {
+	mockCmd.Flags().StringVarP(&arch, "target", "t", "", "target architecture for the RPM")
+	rootCmd.AddCommand(mockCmd)
+}

extbldr/cmd/mock_test.go

@@ -0,0 +1,88 @@
+// Copyright (c) 2022 Arista Networks, Inc.  All rights reserved.
+// Arista Networks, Inc. Confidential and Proprietary.
+
+//go:build privileged
+// +build privileged
+
+package cmd
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/assert"
+
+	"extbldr/testutil"
+)
+
+func testMock(t *testing.T, workingDir string, pkgName string, quiet bool) {
+	viper.Set("WorkingDir", workingDir)
+	viper.Set("SrcDir", "testData")
+	testutil.SetupManifest(t, workingDir, pkgName, filepath.Join(pkgName, "manifest.yml"))
+	defer viper.Reset()
+	args := []string{"mock", "--target", "x86_64", "--package", pkgName}
+	rescueStdout := os.Stdout
+	r, w, _ := os.Pipe()
+	if quiet {
+		args = append(args, "--quiet")
+		os.Stdout = w
+	}
+	rootCmd.SetArgs(args)
+
+	cmdErr := rootCmd.Execute()
+	assert.NoError(t, cmdErr)
+
+	if quiet {
+		w.Close()
+		out, err := ioutil.ReadAll(r)
+		if err != nil {
+			t.Fatal(err)
+		}
+		assert.Empty(t, out)
+		os.Stdout = rescueStdout
+	}
+}
+
+func TestMock(t *testing.T) {
+	t.Log("Create temporary working directory")
+
+	workingDir, err := os.MkdirTemp("", "mock-test")
+	if err != nil {
+		t.Fatal(err)
+	}
+	baseName := "debugedit-1"
+	basePkgName := "debugedit"
+	srpmPath := filepath.Join(workingDir, basePkgName, "rpmbuild", "SRPMS")
+	err = os.MkdirAll(srpmPath, os.ModePerm)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	sampleSRPMPath := filepath.Join("testData", "mock-1", "debugedit-5.0-3.el9.src.rpm")
+	_, statErr := os.Stat(sampleSRPMPath)
+	if statErr != nil {
+		t.Fatal(statErr)
+	}
+
+	targetPath, absErr := filepath.Abs(sampleSRPMPath)
+	if absErr != nil {
+		t.Fatal(absErr)
+	}
+	linkPath := filepath.Join(srpmPath, "debugedit-5.0-3.el9.src.rpm")
+	symlinkErr := os.Symlink(targetPath, linkPath)
+	if symlinkErr != nil {
+		t.Fatal(symlinkErr)
+	}
+
+	defer os.RemoveAll(workingDir)
+
+	t.Logf("WorkingDir: %s", workingDir)
+	t.Log("Test mock from SRPM")
+	testMock(t, workingDir, baseName, false)
+
+	t.Log("Test mock from SRPM quiet")
+	testMock(t, workingDir, baseName, true)
+}

extbldr/impl/mock.go

@@ -0,0 +1,103 @@
+// Copyright (c) 2022 Arista Networks, Inc.  All rights reserved.
+// Arista Networks, Inc. Confidential and Proprietary.
+
+package impl
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/spf13/viper"
+
+	"extbldr/manifest"
+	"extbldr/util"
+)
+
+func mockSubPkg(arch string, pkg string) error {
+	var mockErr error
+	baseDir := viper.GetString("WorkingDir")
+
+	rpmPath := filepath.Join(baseDir, pkg, "RPMS")
+	logPath := filepath.Join(baseDir, pkg, "logs")
+	srpmPath := filepath.Join(baseDir, pkg, "rpmbuild", "SRPMS")
+	scratchPath := filepath.Join(baseDir, pkg, "scratch")
+
+	targetArg := "--target=" + arch
+
+	srpmName, srpmErr := util.GetMatchingFileNamesFromDir(srpmPath, "(?i).*\\.src\\.rpm")
+	if srpmErr != nil {
+		return fmt.Errorf("impl.mockSubPkg: *.src.rpm file not found in %s , error: %s", srpmPath, srpmErr)
+	}
+	srpmFullPath := filepath.Join(srpmPath, srpmName[0]) ////expecting single file
+
+	// cleanup RPM, logs, scratch from previous run
+	for _, path := range []string{rpmPath, logPath, scratchPath} {
+		cleanupErr := util.RunSystemCmd("rm", "-rf", path)
+		if cleanupErr != nil {
+			return fmt.Errorf("impl.mockSubPkg: cleanup %s errored out with %s", path, cleanupErr)
+		}
+	}
+
+	creatErr := util.MaybeCreateDir("impl.mockSubPkg", rpmPath)
+	if creatErr != nil {
+		return creatErr
+	}
+	var mockArgs []string
+
+	if util.GlobalVar.Quiet {
+		mockArgs = append(mockArgs, "--quiet")
+	}
+	mockArgs = append(mockArgs, fmt.Sprintf("--resultdir=%s", rpmPath), targetArg, srpmFullPath)
+
+	mockErr = util.RunSystemCmd("mock", mockArgs...)
+	if mockErr != nil {
+		return fmt.Errorf("impl.mockSubPkg: mock on %s to arch %s errored out with %s",
+			pkg, arch, mockErr)
+	}
+
+	// move out logs, srpm from resultdir to logs and scratch respectively
+	movePathMap := make(map[string]string)
+	movePathMap[scratchPath] = "(?i).*\\.src\\.rpm"
+	movePathMap[logPath] = "(?i).*\\.log"
+	moveErr := filterAndMove(movePathMap, rpmPath)
+	if moveErr != nil {
+		return moveErr
+	}
+
+	return nil
+}
+
+func filterAndMove(movePathMap map[string]string, srcPath string) error {
+	for destPath, regexStr := range movePathMap {
+		name, err := util.GetMatchingFileNamesFromDir(srcPath, regexStr)
+		if err == nil {
+			err = util.CopyFilesToDir(name, srcPath, destPath)
+			if err != nil {
+				return fmt.Errorf("impl.filterAndMove moving %s errored out with %s", name, err)
+			}
+		}
+	}
+	return nil
+}
+
+// Mock calls fedora mock to build the RPMS for the specified target
+// from the already built SRPMs and places the results in {WorkingDir}/<pkg>/RPMS
+func Mock(arch string, pkg string, subPkg string) error {
+	pkgManifest, loadManifestErr := manifest.LoadManifest(pkg)
+	if loadManifestErr != nil {
+		return loadManifestErr
+	}
+	var subPkgSpecified bool = (subPkg != "")
+	for _, subPkgSpec := range pkgManifest.SubPackage {
+		thisSubPkgName := subPkgSpec.Name
+		if subPkgSpecified && (subPkg != thisSubPkgName) {
+			continue
+		}
+		subPkgErr := mockSubPkg(arch, subPkgSpec.Name)
+		if subPkgErr != nil {
+			return fmt.Errorf("impl.Mock: subPkg %s mock errored out  %s", subPkgSpec.Name, subPkgErr)
+		}
+	}
+
+	return nil
+}

extbldr/manifest/manifest_test.go

@@ -6,10 +6,11 @@ package manifest
 import (
 	"github.com/stretchr/testify/assert"
 	"os"
-	"path/filepath"
 	"testing"
 
 	"github.com/spf13/viper"
+
+	"extbldr/testutil"
 )
 
 func testLoad(t *testing.T, pkg string) {
@@ -18,29 +19,6 @@ func testLoad(t *testing.T, pkg string) {
 	assert.NotNil(t, manifest)
 }
 
-func setupManifest(t *testing.T, baseDir string, pkg string, sampleFile string) {
-	pkgDir := filepath.Join(baseDir, pkg)
-	os.RemoveAll(pkgDir)
-	os.Mkdir(pkgDir, 0775)
-
-	sampleManifestPath := filepath.Join("testData", sampleFile)
-	_, statErr := os.Stat(sampleManifestPath)
-	if statErr != nil {
-		t.Fatal(statErr)
-	}
-
-	targetPath, absErr := filepath.Abs(sampleManifestPath)
-	if absErr != nil {
-		t.Fatal(absErr)
-	}
-	linkPath := filepath.Join(pkgDir, "manifest.yml")
-	symlinkErr := os.Symlink(targetPath, linkPath)
-	if symlinkErr != nil {
-		t.Fatal(symlinkErr)
-	}
-
-}
-
 func TestManifest(t *testing.T) {
 	t.Log("Create temporary working directory")
 	dir, err := os.MkdirTemp("", "manifest-test")
@@ -53,7 +31,7 @@ func TestManifest(t *testing.T) {
 	defer viper.Reset()
 
 	t.Log("Copy sample manifest to test directory")
-	setupManifest(t, dir, "pkg1", "sampleManifest1.yml")
+	testutil.SetupManifest(t, dir, "pkg1", "sampleManifest1.yml")
 
 	t.Log("Testing Load")
 	testLoad(t, "pkg1")

extbldr/testutil/testutil.go

@@ -0,0 +1,34 @@
+// Copyright (c) 2022 Arista Networks, Inc.  All rights reserved.
+// Arista Networks, Inc. Confidential and Proprietary.
+
+package testutil
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// SetupManifest used to setup a test manifest from testdata for manifest functionality testing
+func SetupManifest(t *testing.T, baseDir string, pkg string, sampleFile string) {
+	pkgDir := filepath.Join(baseDir, pkg)
+	os.RemoveAll(pkgDir)
+	os.Mkdir(pkgDir, 0775)
+
+	sampleManifestPath := filepath.Join("testData", sampleFile)
+	_, statErr := os.Stat(sampleManifestPath)
+	if statErr != nil {
+		t.Fatal(statErr)
+	}
+
+	targetPath, absErr := filepath.Abs(sampleManifestPath)
+	if absErr != nil {
+		t.Fatal(absErr)
+	}
+	linkPath := filepath.Join(pkgDir, "manifest.yml")
+	symlinkErr := os.Symlink(targetPath, linkPath)
+	if symlinkErr != nil {
+		t.Fatal(symlinkErr)
+	}
+
+}