cmd/container.go

@@ -1,65 +1,39 @@
-// Copyright 2024 Mikhail Klementev. All rights reserved.
+// Copyright 2023 Mikhail Klementev. All rights reserved.
 // Use of this source code is governed by a AGPLv3 license
 // (or later) that can be found in the LICENSE file.
 
 package cmd
 
 import (
-	"errors"
 	"fmt"
 	"os/exec"
 	"path/filepath"
+	"strings"
 
 	"github.com/rs/zerolog/log"
 
 	"code.dumpstack.io/tools/out-of-tree/container"
-	"code.dumpstack.io/tools/out-of-tree/distro"
 )
 
 type ContainerCmd struct {
-	DistroID      string `help:"filter by distribution"`
+	Filter string `help:"filter by name"`
-	DistroRelease string `help:"filter by distribution release"`
 
 	List    ContainerListCmd    `cmd:"" help:"list containers"`
-	Update  ContainerUpdateCmd  `cmd:"" help:"update containers"`
 	Save    ContainerSaveCmd    `cmd:"" help:"save containers"`
 	Cleanup ContainerCleanupCmd `cmd:"" help:"cleanup containers"`
 }
 
-func (cmd ContainerCmd) Containers() (diis []container.Image, err error) {
+func (cmd ContainerCmd) Containers() (names []string) {
 	images, err := container.Images()
 	if err != nil {
-		return
+		log.Fatal().Err(err).Msg("")
-	}
-
-	var dt distro.Distro
-	if cmd.DistroID != "" {
-		dt.ID, err = distro.NewID(cmd.DistroID)
-		if err != nil {
-			return
-		}
-
-		if cmd.DistroRelease != "" {
-			dt.Release = cmd.DistroRelease
-		}
-	} else if cmd.DistroRelease != "" {
-		err = errors.New("--distro-release has no use on its own")
-		return
 	}
 
 	for _, img := range images {
-		if dt.ID != distro.None && dt.ID != img.Distro.ID {
+		if cmd.Filter != "" && !strings.Contains(img.Name, cmd.Filter) {
-			log.Debug().Msgf("skip %s", img.Name)
 			continue
 		}
-
+		names = append(names, img.Name)
-		if dt.Release != "" && dt.Release != img.Distro.Release {
-			log.Debug().Msgf("skip %s", img.Name)
-			continue
-		}
-
-		log.Debug().Msgf("append %s", img.Name)
-		diis = append(diis, img)
 	}
 	return
 }
@@ -67,40 +41,9 @@ func (cmd ContainerCmd) Containers() (diis []container.Image, err error) {
 type ContainerListCmd struct{}
 
 func (cmd ContainerListCmd) Run(containerCmd *ContainerCmd) (err error) {
-	images, err := containerCmd.Containers()
+	for _, name := range containerCmd.Containers() {
-	if err != nil {
+		fmt.Println(name)
-		return
 	}
-
-	for _, img := range images {
-		fmt.Printf("%s\n", img.Distro.String())
-	}
-	return
-}
-
-type ContainerUpdateCmd struct{}
-
-func (cmd ContainerUpdateCmd) Run(g *Globals, containerCmd *ContainerCmd) (err error) {
-	images, err := containerCmd.Containers()
-	if err != nil {
-		return
-	}
-
-	container.UseCache = false
-	container.UsePrebuilt = false
-
-	// TODO move from all commands to main command line handler
-	container.Commands = g.Config.Docker.Commands
-	container.Registry = g.Config.Docker.Registry
-	container.Timeout = g.Config.Docker.Timeout.Duration
-
-	for _, img := range images {
-		_, err = img.Distro.Packages()
-		if err != nil {
-			return
-		}
-	}
-
 	return
 }
 
@@ -109,18 +52,13 @@ type ContainerSaveCmd struct {
 }
 
 func (cmd ContainerSaveCmd) Run(containerCmd *ContainerCmd) (err error) {
-	images, err := containerCmd.Containers()
+	for _, name := range containerCmd.Containers() {
-	if err != nil {
+		nlog := log.With().Str("name", name).Logger()
-		return
-	}
 
-	for _, img := range images {
+		output := filepath.Join(cmd.OutDir, name+".tar")
-		nlog := log.With().Str("name", img.Name).Logger()
-
-		output := filepath.Join(cmd.OutDir, img.Name+".tar")
 		nlog.Info().Msgf("saving to %v", output)
 
-		err = container.Save(img.Name, output)
+		err = container.Save(name, output)
 		if err != nil {
 			return
 		}
@@ -143,14 +81,9 @@ func (cmd ContainerSaveCmd) Run(containerCmd *ContainerCmd) (err error) {
 type ContainerCleanupCmd struct{}
 
 func (cmd ContainerCleanupCmd) Run(containerCmd *ContainerCmd) (err error) {
-	images, err := containerCmd.Containers()
-	if err != nil {
-		return
-	}
-
 	var output []byte
-	for _, img := range images {
+	for _, name := range containerCmd.Containers() {
-		output, err = exec.Command(container.Runtime, "image", "rm", img.Name).
+		output, err = exec.Command(container.Runtime, "image", "rm", name).
 			CombinedOutput()
 		if err != nil {
 			log.Error().Err(err).Str("output", string(output)).Msg("")

config/out-of-tree.go

@@ -35,12 +35,9 @@ type OutOfTree struct {
 		Timeout  artifact.Duration
 		Registry string
 
-		// Commands that are executed before (prepend) and after (append) the
+		// Commands that will be executed before
-		// base layer of the Dockerfile.
+		// the base layer of Dockerfile
-		Commands struct {
+		Commands []distro.Command
-			Prepend []distro.Command
-			Append  []distro.Command
-		}
 	}
 }
 

container/container.go

@@ -32,12 +32,7 @@ var Registry = ""
 
 var Timeout time.Duration
 
-// Commands that are executed before (prepend) and after (append) the
+var Commands []distro.Command
-// base layer of the Dockerfile.
-var Commands struct {
-	Prepend []distro.Command
-	Append  []distro.Command
-}
 
 var UseCache = true
 
@@ -102,23 +97,13 @@ func Load(localpath string, name string) (err error) {
 		return
 	}
 
-	if strings.Contains(Runtime, "docker") {
-		var err2 error
 	cmd = exec.Command(Runtime, "tag", "localhost/"+name, name)
 	log.Debug().Msgf("%v", cmd)
 
-		raw, err2 = cmd.CombinedOutput()
+	raw, err = cmd.CombinedOutput()
-		if err2 != nil {
+	if err != nil {
-			log.Debug().Err(err2).Msg(string(raw))
+		log.Debug().Err(err).Msg(string(raw))
-		}
+		return
-
-		cmd = exec.Command(Runtime, "rmi", "localhost/"+name)
-		log.Debug().Msgf("%v", cmd)
-
-		raw, err2 = cmd.CombinedOutput()
-		if err2 != nil {
-			log.Debug().Err(err2).Msg(string(raw))
-		}
 	}
 
 	return
@@ -301,15 +286,9 @@ func (c Container) Build(image string, envs, runs []string) (err error) {
 	}
 	cf += image + "\n"
 
-	for _, cmd := range Commands.Prepend {
+	for _, c := range Commands {
-		if cmd.Distro.ID != distro.None && cmd.Distro.ID != c.dist.ID {
+		// TODO check for distro type
-			continue
+		cf += "RUN " + c.Command + "\n"
-		}
-		if cmd.Distro.Release != "" && cmd.Distro.Release != c.dist.Release {
-			continue
-		}
-
-		cf += "RUN " + cmd.Command + "\n"
 	}
 
 	for _, e := range envs {
@@ -320,17 +299,6 @@ func (c Container) Build(image string, envs, runs []string) (err error) {
 		cf += "RUN " + c + "\n"
 	}
 
-	for _, cmd := range Commands.Append {
-		if cmd.Distro.ID != distro.None && cmd.Distro.ID != c.dist.ID {
-			continue
-		}
-		if cmd.Distro.Release != "" && cmd.Distro.Release != c.dist.Release {
-			continue
-		}
-
-		cf += "RUN " + cmd.Command + "\n"
-	}
-
 	buf, err := os.ReadFile(cfile)
 	if err != nil {
 		err = os.WriteFile(cfile, []byte(cf), os.ModePerm)

main.go

@@ -35,13 +35,13 @@ type CLI struct {
 	cmd.Globals
 
 	Pew       cmd.PewCmd       `cmd:"" help:"build, run, and test module/exploit"`
-	Kernel    cmd.KernelCmd    `cmd:"" aliases:"kernels" help:"manipulate kernels"`
+	Kernel    cmd.KernelCmd    `cmd:"" help:"manipulate kernels"`
 	Debug     cmd.DebugCmd     `cmd:"" help:"debug environment"`
 	Log       cmd.LogCmd       `cmd:"" help:"query logs"`
 	Pack      cmd.PackCmd      `cmd:"" help:"exploit pack test"`
 	Gen       cmd.GenCmd       `cmd:"" help:"generate .out-of-tree.toml skeleton"`
-	Image     cmd.ImageCmd     `cmd:"" aliases:"images" help:"manage images"`
+	Image     cmd.ImageCmd     `cmd:"" help:"manage images"`
-	Container cmd.ContainerCmd `cmd:"" aliases:"containers" help:"manage containers"`
+	Container cmd.ContainerCmd `cmd:"" help:"manage containers"`
 	Distro    cmd.DistroCmd    `cmd:"" help:"distro-related helpers"`
 
 	Daemon cmd.DaemonCmd `cmd:"" help:"run daemon"`