Building 70 Projects ranging from beginner to advanced so anyone can — learn from, build upon, use as a reference, or even copy directly. Owned by my cybersecurity company đŸ‘‡
Go aicertificationcloud-engineeringcybercybersecuritycybersecurity-analystcybersecurity-certificationcybersecurity-certificationscybersecurity-educationcybersecurity-jobscybersecurity-portfoliocybersecurity-projectscybersecurity-toolsgrchackinglearningpentestingproject-repositoryprojetcspython
// ©AngelaMos | 2026
// targets.go
package cli
import (
"context"
"fmt"
"io"
"github.com/CarterPerez-dev/khaos/internal/dockerx"
"github.com/CarterPerez-dev/khaos/internal/render"
"github.com/CarterPerez-dev/khaos/internal/theme"
"github.com/spf13/cobra"
)
const (
flagProject = "project"
flagAll = "all"
targetsShort = "discover containers that have consented to fault injection"
targetsLong = `targets lists every container carrying the ` + dockerx.LabelConsent + `=` + dockerx.ConsentValue + ` label,
and says for each one whether khaos would accept or refuse it as a target.
You never write a selector. You pick a name from this list.`
projectUsage = "only consider containers in this compose project"
allUsage = "also show containers khaos would refuse, and why"
headerName = "TARGET"
headerProject = "PROJECT"
headerImage = "IMAGE"
headerStatus = "STATUS"
statusReady = "ready"
colName = 26
colProject = 18
colImage = 30
emptyMessage = "no consenting containers found"
refusedHint = "re-run with --all to see containers khaos refuses and why"
refusedFormat = "%d refused. %s"
rowLayout = "%s%s%s%s%s\n"
noteLayout = "%s%s\n"
endpointNote = "daemon: %s"
dashMarker = "-"
)
func newTargetsCmd() *cobra.Command {
cmd := &cobra.Command{
Use: "targets",
Short: targetsShort,
Long: targetsLong,
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, _ []string) error {
project, err := cmd.Flags().GetString(flagProject)
if err != nil {
return err
}
all, err := cmd.Flags().GetBool(flagAll)
if err != nil {
return err
}
return runTargets(cmd.Context(), cmd.OutOrStdout(), project, all)
},
}
cmd.Flags().String(flagProject, "", projectUsage)
cmd.Flags().Bool(flagAll, false, allUsage)
return cmd
}
func runTargets(
ctx context.Context,
out io.Writer,
project string,
all bool,
) error {
client, err := dockerx.Open(ctx)
if err != nil {
return fmt.Errorf("%w (run `khaos doctor` for the fix)", err)
}
defer func() { _ = client.Close() }()
filter := dockerx.Filter{Project: project}
guard := dockerx.Guard{Project: project, SelfID: dockerx.SelfContainerID()}
targets, err := client.Targets(ctx, filter)
if err != nil {
return err
}
fmt.Fprintln(out)
fmt.Fprintf(
out,
noteLayout,
render.Indent,
theme.Fg(
theme.TextFaint,
fmt.Sprintf(endpointNote, client.Endpoint().Host),
),
)
if len(targets) == 0 {
printNoTargets(out)
return nil
}
refused := printTargetTable(out, targets, guard, all)
if refused > 0 && !all {
fmt.Fprintln(out)
fmt.Fprintf(
out,
noteLayout,
render.Indent,
theme.Fg(
theme.TextDim,
fmt.Sprintf(refusedFormat, refused, refusedHint),
),
)
}
fmt.Fprintln(out)
return nil
}
// printNoTargets is its own answer because an empty table carries no fix.
func printNoTargets(out io.Writer) {
fmt.Fprintf(
out,
noteLayout,
render.Indent,
theme.Fg(theme.TextNormal, emptyMessage),
)
fmt.Fprintf(
out,
noteLayout,
render.Indent,
theme.Fg(theme.TextDim, dockerx.FixNoTargets),
)
fmt.Fprintln(out)
}
// printTargetTable returns how many targets were REFUSED.
func printTargetTable(
out io.Writer,
targets []dockerx.Target,
guard dockerx.Guard,
all bool,
) int {
fmt.Fprintf(out, rowLayout, render.Indent,
theme.Fg(theme.TextFaint, render.Cell(headerName, colName)),
theme.Fg(theme.TextFaint, render.Cell(headerProject, colProject)),
theme.Fg(theme.TextFaint, render.Cell(headerImage, colImage)),
theme.Fg(theme.TextFaint, headerStatus))
refused := 0
for _, target := range targets {
refusal := dockerx.Refuse(target, guard)
if refusal != nil {
refused++
if !all {
continue
}
}
status := theme.Fg(theme.StateHeld, statusReady)
if refusal != nil {
status = theme.Fg(theme.StateDenied, refusal.Predicate)
}
fmt.Fprintf(
out,
rowLayout,
render.Indent,
theme.Fg(theme.TextBright, render.Cell(target.Name, colName)),
theme.Fg(
theme.TextNormal,
render.Cell(orDash(target.Project), colProject),
),
theme.Fg(theme.TextDim, render.Cell(target.Image, colImage)),
status,
)
if all && refusal != nil {
fmt.Fprintf(
out,
noteLayout,
render.FixIndent,
theme.Fg(theme.TextDim, refusal.Reason),
)
fixLine(out, refusal.Fix)
}
}
return refused
}
func orDash(s string) string {
if s == "" {
return dashMarker
}
return s
}