kubectl-juneau に新コマンドを実装する¶

cmd/kubectl-juneau/main.go      プロセス境界のみ。ロジック禁止
   ↓
internal/cmd/<group>            cobra 配線、フラグ解析、orchestration
   ↓
internal/topology               純粋ロジック (View 越しにしか I/O しない)
internal/<future areas>          policy / reachability / prober など
   ↓
internal/factory                k8s と外界への唯一の seam
internal/output                 表示 (tree / json / yaml)

// internal/topology/types.go の末尾に追加
type VpcListContext struct {
    Vpcs []VpcSummary `json:"vpcs,omitempty"`
}

type VpcSummary struct {
    Name                  string `json:"name"`
    VpcID                 uint32 `json:"vpcID,omitempty"`
    EnableService         bool   `json:"enableService,omitempty"`
    EnforceSecurityGroups bool   `json:"enforceSecurityGroups,omitempty"`
    SubnetCount           int    `json:"subnetCount"`
}

// internal/topology/view.go
type View interface {
    // ...既存
    AllVpcs(ctx context.Context) ([]juneauv1alpha1.Vpc, error)
}

// internal/topology/kubeview.go
func (v *kubeView) AllVpcs(ctx context.Context) ([]juneauv1alpha1.Vpc, error) {
    var list juneauv1alpha1.VpcList
    if err := v.cl.List(ctx, &list); err != nil {
        return nil, err
    }
    return list.Items, nil
}

// internal/topology/vpc_list_context.go
package topology

import "context"

func ResolveVpcListContext(ctx context.Context, v View) (*VpcListContext, error) {
    vpcs, err := v.AllVpcs(ctx)
    if err != nil {
        return nil, err
    }
    out := &VpcListContext{Vpcs: make([]VpcSummary, 0, len(vpcs))}
    for i := range vpcs {
        subnets, err := v.SubnetsByVpc(ctx, vpcs[i].Name)
        if err != nil {
            return nil, err
        }
        out.Vpcs = append(out.Vpcs, VpcSummary{
            Name:                  vpcs[i].Name,
            VpcID:                 vpcs[i].Status.VpcID,
            EnableService:         vpcs[i].Spec.EnableService,
            EnforceSecurityGroups: vpcs[i].Spec.EnforceSecurityGroups,
            SubnetCount:           len(subnets),
        })
    }
    return out, nil
}

// internal/cmd/topology/list_vpcs.go
package topologycmd

import (
    "context"
    "fmt"
    "io"

    "github.com/spf13/cobra"

    "github.com/1outres/juneau/kubectl-juneau/internal/factory"
    "github.com/1outres/juneau/kubectl-juneau/internal/output"
    "github.com/1outres/juneau/kubectl-juneau/internal/topology"
)

type listVpcsOptions struct {
    Factory    factory.Factory
    PrintFlags *output.PrintFlags
}

func newListVpcsCommand(f factory.Factory) *cobra.Command {
    o := &listVpcsOptions{Factory: f, PrintFlags: output.NewPrintFlags()}
    cmd := &cobra.Command{
        Use:   "list-vpcs",
        Short: "List every Vpc in the cluster",
        Args:  cobra.NoArgs,
        RunE: func(c *cobra.Command, _ []string) error {
            if err := o.Validate(); err != nil {
                return err
            }
            return o.Run(c.Context())
        },
    }
    o.PrintFlags.AddFlags(cmd)
    return cmd
}

func (o *listVpcsOptions) Validate() error {
    _, err := o.PrintFlags.Format()
    return err
}

func (o *listVpcsOptions) Run(ctx context.Context) error {
    cl, err := o.Factory.Kube()
    if err != nil {
        return err
    }
    view := topology.NewKubeView(cl)

    ctxData, err := topology.ResolveVpcListContext(ctx, view)
    if err != nil {
        return err
    }

    renderer, err := output.ResolveRenderer[*topology.VpcListContext](
        o.PrintFlags,
        output.RendererFunc[*topology.VpcListContext](presentVpcListTree),
    )
    if err != nil {
        return err
    }
    return renderer.Render(o.Factory.Streams().Out, ctxData)
}

func presentVpcListTree(w io.Writer, c *topology.VpcListContext) error {
    root := output.NewNode(fmt.Sprintf("Vpcs  (%d)", len(c.Vpcs)))
    for _, v := range c.Vpcs {
        flags := ""
        if v.EnableService {
            flags += " enableService"
        }
        if v.EnforceSecurityGroups {
            flags += " enforceSecurityGroups"
        }
        root.Childf("%s  (vpcID: %d, subnets: %d%s)", v.Name, v.VpcID, v.SubnetCount, flags)
    }
    return output.WriteTree(w, root)
}

// internal/cmd/describe/describe.go
cmd.AddCommand(newPodCommand(f))
// ...
cmd.AddCommand(newListVpcsCommand(f)) // 例

// internal/cmd/topology/topology.go
package topologycmd

import (
    "github.com/spf13/cobra"

    "github.com/1outres/juneau/kubectl-juneau/internal/factory"
)

func NewCommand(f factory.Factory) *cobra.Command {
    cmd := &cobra.Command{
        Use:   "topology",
        Short: "List Juneau resources across the cluster",
        Args:  cobra.NoArgs,
    }
    cmd.AddCommand(newListVpcsCommand(f))
    return cmd
}

// internal/cmd/root.go
import topologycmd "github.com/1outres/juneau/kubectl-juneau/internal/cmd/topology"
// ...
root.AddCommand(topologycmd.NewCommand(f))

func TestResolveVpcListContext(t *testing.T) {
    view := &stubView{
        // 必要なフィールドだけ埋める
    }
    got, err := ResolveVpcListContext(context.Background(), view)
    if err != nil { t.Fatal(err) }
    // ... assertions
}