cmd

Documentation

Index

• Constants
• Variables
• func Execute()
• func Fatalf(msg string, args ...interface{})
• func NewTabWriter() *tabwriter.Writer
• func TablePrinter(firstTitle, secondTitle string, data map[string][]string)
• func TroubleshootClusterMesh(ctx context.Context, stdout io.Writer, dialer kvstore.EtcdDbgDialer, ...)
• func Usagef(cmd *cobra.Command, msg string, args ...interface{})
• type PolicyUpdateArgs
• type SubscriberData

Constants

const (
	STDOUT outputType = 0 + iota
	MARKDOWN
	HTML
	JSONOUTPUT
	JSONPATH
)

outputTypes enum values

const (
	PolicyEnabled  = "Enabled"
	PolicyDisabled = "Disabled"
	PolicyAudit    = "Disabled (Audit)"
	UnknownState   = "Unknown"
)

PolicyEnabled and PolicyDisabled represent the endpoint policy status

Variables

var BPFAuthCmd = &cobra.Command{
	Use:   "auth",
	Short: "Manage authenticated connections between identities",
}

BPFAuthCmd represents the bpf command

var BPFBandwidthCmd = &cobra.Command{
	Use:   "bandwidth",
	Short: "BPF datapath bandwidth settings",
}

BPFBandwidthCmd represents the bpf_bandwidth command

var BPFCmd = &cobra.Command{
	Use:   "bpf",
	Short: "Direct access to local BPF maps",
}

BPFCmd represents the bpf command

var BPFConfigCmd = &cobra.Command{
	Use:   "config",
	Short: "Manage runtime config",
}

BPFConfigCmd represents the bpf command

var BPFCtCmd = &cobra.Command{
	Use:   "ct",
	Short: "Connection tracking tables",
}

BPFCtCmd represents the bpf_ct command

var BPFEgressCmd = &cobra.Command{
	Use:   "egress",
	Short: "Manage the egress routing rules",
}

BPFEgressCmd represents the bpf command

var BPFEndpointCmd = &cobra.Command{
	Use:   "endpoint",
	Short: "Local endpoint map",
}

var BPFFragCmd = &cobra.Command{
	Use:     "frag",
	Aliases: []string{"fragments"},
	Short:   "Manage the IPv4 datagram fragments",
}

BPFFragCmd represents the bpf command

var BPFIPCacheCmd = &cobra.Command{
	Use:   "ipcache",
	Short: "Manage the IPCache mappings for IP/CIDR <-> Identity",
}

BPFIPCacheCmd represents the bpf command

var BPFIPMasqCmd = &cobra.Command{
	Use:   "ipmasq",
	Short: "ip-masq-agent CIDRs",
}

BPFIPMasqCmd represents the bpf command

var BPFLBCmd = &cobra.Command{
	Use:   "lb",
	Short: "Load-balancing configuration",
}

bpfCtCmd represents the bpf_ct command

var BPFMaglevCmd = &cobra.Command{
	Use:   "maglev",
	Short: "Maglev lookup table",
}

BPFMaglevCmd represents the bpf lb maglev command

var BPFMetricsCmd = &cobra.Command{
	Use:   "metrics",
	Short: "BPF datapath traffic metrics",
}

BPFMetricsCmd represents the bpf_metrics command

var BPFMountFSCmd = &cobra.Command{
	Use:   "fs",
	Short: "BPF filesystem mount",
}

var BPFNatCmd = &cobra.Command{
	Use:   "nat",
	Short: "NAT mapping tables",
}

BPFNatCmd represents the bpf_nat command

var BPFNodeIDCmd = &cobra.Command{
	Use:   "nodeid",
	Short: "Manage the node IDs",
}

BPFNodeIDCmd represents the bpf command

var BPFPolicyCmd = &cobra.Command{
	Use:   "policy",
	Short: "Manage policy related BPF maps",
}

BPFPolicyCmd represents the bpf_policy command

var BPFRecorderCmd = &cobra.Command{
	Use:   "recorder",
	Short: "PCAP recorder",
}

BPFRecorderCmd represents the bpf_recorder command

var BPFSRv6Cmd = &cobra.Command{
	Use:   "srv6",
	Short: "Manage the SRv6 routing rules",
}

BPFSRv6Cmd represents the bpf command

var BPFTemplateCmd = &cobra.Command{
	Use:     "sha",
	Aliases: []string{"template"},
	Short:   "Manage compiled BPF template objects",
}

BPFTemplateCmd represents the bpf-sha command

var BPFTunnelCmd = &cobra.Command{
	Use:   "tunnel",
	Short: "Tunnel endpoint map",
}

var BPFVtepCmd = &cobra.Command{
	Use:   "vtep",
	Short: "Manage the VTEP mappings for IP/CIDR <-> VTEP MAC/IP",
}

BPFVtepCmd represents the bpf command

var BgpCmd = &cobra.Command{
	Use:   "bgp",
	Short: "Access to BGP control plane",
}

BgpCmd represents the bgp command

var BgpPeersCmd = &cobra.Command{
	Use:     "peers",
	Aliases: []string{"neighbors"},
	Short:   "List current state of all peers",
	Long:    "List state of all peers defined in CiliumBGPPeeringPolicy",
	Run: func(cmd *cobra.Command, args []string) {
		res, err := client.Bgp.GetBgpPeers(nil)
		if err != nil {
			disabledErr := bgp.NewGetBgpPeersDisabled()
			if errors.As(err, &disabledErr) {
				fmt.Println("BGP Control Plane is disabled")
				return
			}
			Fatalf("cannot get peers list: %s\n", err)
		}

		if command.OutputOption() {
			if err := command.PrintOutput(res.GetPayload()); err != nil {
				Fatalf("error getting output in JSON: %s\n", err)
			}
		} else {
			printSummary(res.GetPayload())
		}
	},
}

var BgpRoutePoliciesCmd = &cobra.Command{
	Use:     "route-policies [vrouter <asn>]",
	Aliases: []string{"rps"},
	Short:   "List configured route policies",
	Long:    "List route policies configured in the underlying routing daemon",
	Run: func(cmd *cobra.Command, args []string) {
		var err error
		params := bgp.NewGetBgpRoutePoliciesParams()

		if len(args) > 0 {
			var asn int64
			asn, _, err = parseVRouterASN(args)
			if err != nil {
				Fatalf("failed to parse vrouter ASN: %s\n", err)
			}
			params.RouterAsn = ptr.To[int64](asn)
		}

		res, err := client.Bgp.GetBgpRoutePolicies(params)
		if err != nil {
			disabledErr := bgp.NewGetBgpRoutePoliciesDisabled()
			if errors.As(err, &disabledErr) {
				fmt.Println("BGP Control Plane is disabled")
				return
			}
			Fatalf("cannot get route policies list: %s\n", err)
		}

		if command.OutputOption() {
			if err := command.PrintOutput(res.GetPayload()); err != nil {
				Fatalf("error getting output in JSON: %s\n", err)
			}
		} else {
			printBGPRoutePoliciesTable(res.GetPayload())
		}
	},
}

var BgpRoutesCmd = &cobra.Command{
	Use:   "routes <available | advertised> <afi> <safi> [vrouter <asn>] [peer|neighbor <address>]",
	Short: "List routes in the BGP Control Plane's RIBs",
	Long:  "List routes in the BGP Control Plane's Routing Information Bases (RIBs)",
	Example: `  Get all IPv4 unicast routes available:
    cilium-dbg bgp routes available ipv4 unicast

  Get all IPv6 unicast routes available for a specific vrouter:
    cilium-dbg bgp routes available ipv6 unicast vrouter 65001

  Get IPv4 unicast routes advertised to a specific peer:
    cilium-dbg bgp routes advertised ipv4 unicast peer 10.0.0.1`,

	Run: func(cmd *cobra.Command, args []string) {
		var err error
		params := bgp.NewGetBgpRoutesParams()

		params.TableType, params.Afi, params.Safi, args, err = parseBGPRoutesMandatoryArgs(args, command.OutputOption())
		if err != nil {
			Fatalf("invalid argument: %s\n", err)
		}

		if len(args) > 0 && args[0] == vRouterKW {
			var asn int64
			asn, args, err = parseVRouterASN(args)
			if err != nil {
				Fatalf("failed to parse vrouter ASN: %s\n", err)
			}
			params.RouterAsn = ptr.To[int64](asn)
		}

		if params.TableType == adjRIBOutTableType && len(args) > 0 {
			addr, err := parseBGPPeerAddr(args)
			if err != nil {
				Fatalf("failed to parse peer address: %s\n", err)
			}
			params.Neighbor = &addr
		}

		res, err := client.Bgp.GetBgpRoutes(params)
		if err != nil {
			disabledErr := bgp.NewGetBgpRoutesDisabled()
			if errors.As(err, &disabledErr) {
				fmt.Println("BGP Control Plane is disabled")
				return
			}
			Fatalf("failed retrieving routes: %s\n", err)
		}

		if command.OutputOption() {
			if err := command.PrintOutput(res.GetPayload()); err != nil {
				Fatalf("failed getting output in JSON: %s\n", err)
			}
		} else {

			printPeer := (params.TableType == adjRIBOutTableType) && (params.Neighbor == nil || *params.Neighbor == "")
			printBGPRoutesTable(res.GetPayload(), printPeer)
		}
	},
}

var BpfMcastCmd = &cobra.Command{
	Use:     "multicast",
	Aliases: []string{"mcast"},
	Short:   "Manage multicast BPF programs",
}

BpfMcastCmd represents the bpf command

var BpfMcastGroupCmd = &cobra.Command{
	Use:   "group",
	Short: "Manage the multicast groups.",
}

var BpfMcastSubscriberCmd = &cobra.Command{
	Use:     "subscriber",
	Aliases: []string{"sub"},
	Short:   "Manage the multicast subscribers.",
}

var CgroupsCmd = &cobra.Command{
	Use:   "cgroups",
	Short: "Cgroup metadata",
}

CgroupsCmd represents the cgroups command

var EncryptCmd = &cobra.Command{
	Use:   "encrypt",
	Short: "Manage transparent encryption",
}

EncryptCmd represents the encrypt command

var EndpointCmd = &cobra.Command{
	Use:   "endpoint",
	Short: "Manage endpoints",
}

EndpointCmd represents the endpoint command

var EnvoyAdminCertsCmd = &cobra.Command{
	Use:   "certs",
	Short: "List configured TLS certificates of Envoy Proxy",
	Run: func(cmd *cobra.Command, args []string) {
		envoyAdminClient := newEnvoyAdminClient()

		certs, err := envoyAdminClient.GetCerts()
		if err != nil {
			Fatalf("cannot get certificates: %s\n", err)
		}

		cmd.Println(certs)
	},
}

var EnvoyAdminClustersCmd = &cobra.Command{
	Use:   "clusters",
	Short: "List configured clusters of Envoy Proxy",
	Run: func(cmd *cobra.Command, args []string) {
		envoyAdminClient := newEnvoyAdminClient()

		clusters, err := envoyAdminClient.GetClusters(strings.ToLower(command.OutputOptionString()))
		if err != nil {
			Fatalf("cannot get clusters: %s\n", err)
		}

		cmd.Println(clusters)
	},
}

var EnvoyAdminCmd = &cobra.Command{
	Use:   "admin",
	Short: "Access Envoy Admin Interface",
}

EnvoyAdminCmd represents the Envoy Proxy admin interface command

var EnvoyAdminConfigCmd = &cobra.Command{
	Use:       fmt.Sprintf("config %s", envoyResourceTypeOptionsString()),
	Short:     "View config dump of Envoy Proxy",
	Args:      cobra.OnlyValidArgs,
	ValidArgs: slices.Collect(maps.Keys(envoyResourceTypeMappings)),
	Run: func(cmd *cobra.Command, args []string) {
		resourceType := "all"
		if len(args) > 0 {
			resourceType = args[0]
		}

		envoyAdminClient := newEnvoyAdminClient()

		configDump, err := envoyAdminClient.GetConfigDump(envoyResourceTypeMappings[resourceType], envoyResourceNameFlag)
		if err != nil {
			Fatalf("cannot get config dump: %s\n", err)
		}

		cmd.Println(configDump)
	},
}

var EnvoyAdminListenersCmd = &cobra.Command{
	Use:   "listeners",
	Short: "List configured listeners of Envoy Proxy",
	Run: func(cmd *cobra.Command, args []string) {
		envoyAdminClient := newEnvoyAdminClient()

		listeners, err := envoyAdminClient.GetListeners(strings.ToLower(command.OutputOptionString()))
		if err != nil {
			Fatalf("cannot get listeners: %s\n", err)
		}

		cmd.Println(listeners)
	},
}

var EnvoyAdminLoggingCmd = &cobra.Command{
	Use:   "logging",
	Short: "List and change logging levels of Envoy Proxy",
}

var EnvoyAdminLoggingListCmd = &cobra.Command{
	Use:   "list",
	Short: "List logging levels of Envoy Proxy",
	Args:  cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {
		envoyAdminClient := newEnvoyAdminClient()

		loggingLevels, err := envoyAdminClient.ListLoggingLevels()
		if err != nil {
			Fatalf("failed to get logging levels: %s\n", err)
		}
		cmd.Println(loggingLevels)
	},
}

var EnvoyAdminLoggingSetCmd = &cobra.Command{
	Use:   "set",
	Short: "Change logging levels of Envoy Proxy",
}

var EnvoyAdminLoggingSetGlobalCmd = &cobra.Command{
	Use:   "global <level>",
	Short: "Change global logging level for all loggers of Envoy Proxy",
	Args:  cobra.ExactArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		envoyAdminClient := newEnvoyAdminClient()

		response, err := envoyAdminClient.SetLoggingLevelForAllLoggers(args[0])
		if err != nil {
			Fatalf("failed to set global logging level: %s\n", err)
		}
		cmd.Println(response)
	},
}

var EnvoyAdminLoggingSetLoggersCmd = &cobra.Command{
	Use:   "loggers <logger_name>=<level>...",
	Short: "Change logging level of a list of loggers of Envoy Proxy",
	Args:  cobra.MinimumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		envoyAdminClient := newEnvoyAdminClient()

		loggingLevels := map[string]string{}

		for _, arg := range args {
			s := strings.Split(arg, "=")
			if len(s) == 2 {
				loggingLevels[s[0]] = s[1]
			}
		}

		if _, globalKeyExists := loggingLevels["level"]; globalKeyExists {
			Fatalf("please use logger set global to change the global log level\n")
		}

		response, err := envoyAdminClient.SetLoggingLevelForLoggers(loggingLevels)
		if err != nil {
			Fatalf("failed to set logging levels: %s\n", err)
		}
		cmd.Println(response)
	},
}

var EnvoyAdminMetricsCmd = &cobra.Command{
	Use:   "metrics",
	Short: "List Prometheus statistics of Envoy Proxy",
	Run: func(cmd *cobra.Command, args []string) {
		envoyAdminClient := newEnvoyAdminClient()

		metrics, err := envoyAdminClient.GetPrometheusStatistics(envoyMetricsFilterRegexFlag)
		if err != nil {
			Fatalf("cannot get metrics: %s\n", err)
		}

		cmd.Println(metrics)
	},
}

var EnvoyAdminServerinfoCmd = &cobra.Command{
	Use:   "serverinfo",
	Short: "View server info of Envoy Proxy",
	Run: func(cmd *cobra.Command, args []string) {
		envoyAdminClient := newEnvoyAdminClient()

		serverInfo, err := envoyAdminClient.GetServerInfo()
		if err != nil {
			Fatalf("cannot get server info: %s\n", err)
		}

		cmd.Println(serverInfo)
	},
}

var EnvoyCmd = &cobra.Command{
	Use:   "envoy",
	Short: "Manage Envoy Proxy",
}

EnvoyCmd represents the envoy command

var IPCmd = &cobra.Command{
	Use:   "ip",
	Short: "Manage IP addresses and associated information",
}

IPCmd represents the ip command

var IdentityCmd = &cobra.Command{
	Use:   "identity",
	Short: "Manage security identities",
}

IdentityCmd represents the identity command

var LRPCmd = &cobra.Command{
	Use:   "lrp",
	Short: "Manage local redirect policies",
}

LRPCmd represents the lrp command

var LoadInfoCmd = &cobra.Command{
	Use:   "loadinfo",
	Short: "Show load information",
	Run: func(cmd *cobra.Command, args []string) {
		loadinfo.LogCurrentSystemLoad(printFunc)
	},
}

LoadInfoCmd represents the loadinfo command

var MAPCmd = &cobra.Command{
	Use:   "map",
	Short: "Access userspace cached content of BPF maps",
}

MAPCmd represents the map command

var MetricsCmd = &cobra.Command{
	Use:   "metrics",
	Short: "Access metric status",
}

MetricsCmd represents the metrics command.

var MetricsListCmd = &cobra.Command{
	Use:   "list",
	Short: "List all metrics",
	Run: func(cmd *cobra.Command, args []string) {
		format := "table"
		if command.OutputOption() {
			format = strings.ToLower(command.OutputOptionString())
		}
		shellExchange(os.Stdout, "metrics -format=%s '%s'", format, matchPattern)
	},
}

MetricsListCmd dumps all metrics into stdout

var MulticastGroupAddCmd = &cobra.Command{
	Use:   "add <group>",
	Short: "Add a multicast group.",
	Long:  "Add a multicast group to the node.",
	Example: `The following command adds group 229.0.0.1 to BPF multicast map of the node:
cilium-dbg bpf multicast group add 229.0.0.1`,

	Run: func(cmd *cobra.Command, args []string) {
		common.RequireRootPrivilege("cilium-dbg bpf multicast group add")

		group, err := parseMulticastGroupArgs(args)
		if err != nil {
			Fatalf("Invalid arguments: %s", err)
		}

		groupV4Map, err := getMulticastGroupMap()
		if err != nil {
			Fatalf("failed to get multicast bpf map: %s", err)
		}

		err = groupV4Map.Insert(group)
		if err != nil {
			Fatalf("Error adding multicast group: %s", err)
		}
	},
}

var MulticastGroupDelCmd = &cobra.Command{
	Use:     "delete <group>",
	Aliases: []string{"del"},
	Short:   "Delete a multicast group.",
	Long:    "Delete a multicast group from the node.",
	Example: `The following command deletes group 229.0.0.1 from BPF multicast map of the node:
cilium-dbg bpf multicast group delete 229.0.0.1`,

	Run: func(cmd *cobra.Command, args []string) {
		common.RequireRootPrivilege("cilium-dbg bpf multicast group delete")

		group, err := parseMulticastGroupArgs(args)
		if err != nil {
			Fatalf("Invalid arguments: %s", err)
		}

		groupV4Map, err := getMulticastGroupMap()
		if err != nil {
			Fatalf("failed to get multicast bpf map: %s", err)
		}

		err = groupV4Map.Delete(group)
		if err != nil {
			Fatalf("Error deleting multicast group: %s", err)
		}
	},
}

var MulticastGroupListCmd = &cobra.Command{
	Use:     "list",
	Aliases: []string{"ls"},
	Short:   "List the multicast groups.",
	Long:    "List the multicast groups configured on the node.",
	Run: func(cmd *cobra.Command, args []string) {
		common.RequireRootPrivilege("cilium bpf multicast group list")

		groupV4Map, err := getMulticastGroupMap()
		if err != nil {
			Fatalf("failed to get multicast bpf map: %s", err)
		}

		groups, err := groupV4Map.List()
		if err != nil {
			Fatalf("Error listing multicast groups: %s", err)
		}

		if command.OutputOption() {
			if err := command.PrintOutput(groups); err != nil {
				Fatalf("error getting output of map in %s: %s", command.OutputOptionString(), err)
			}
			return
		}
		printGroupList(groups)
	},
}

var MulticastGroupSubscriberAddCmd = &cobra.Command{
	Use:   "add <group> <subscriber-address>",
	Short: "Add a remote subscriber to the multicast group.",
	Long: `Add a remote subscriber to the multicast group.
Only remote subscribers are added via command line. Local subscribers will be automatically populated in the map based on IGMP messages.
Remote subscribers are typically other Cilium nodes, identified by internal IP of the node.
To add remote subscriber, following information is required:
- group: multicast group address to which subscriber is added.
- subscriber-address: subscriber IP address.
`,
	Example: `To add a remote node 10.100.0.1 to multicast group 229.0.0.1, use the following command:
cilium-dbg bpf multicast subscriber add 229.0.0.1 10.100.0.1
`,
	Run: func(cmd *cobra.Command, args []string) {
		common.RequireRootPrivilege("cilium bpf multicast subscriber add")

		link, err := safenetlink.LinkByName(defaults.VxlanDevice)
		if err != nil {
			Fatalf("Failed to get cilium_vxlan device %q: %s", defaults.VxlanDevice, err)
		}

		groupAddr, subIP, err := parseMulticastGroupSubscriberArgs(args)
		if err != nil {
			Fatalf("invalid argument: %s", err)
		}

		subscriberMap, err := getMulticastSubscriberMap(groupAddr)
		if err != nil {
			Fatalf("Failed to get subscriber map for group %s: %s", groupAddr, err)
		}

		subscriber := &maps_multicast.SubscriberV4{
			SAddr:    subIP,
			Ifindex:  uint32(link.Attrs().Index),
			IsRemote: true,
		}

		if err := subscriberMap.Insert(subscriber); err != nil {
			Fatalf("Failed to add subscriber %s to multicast group %s: %s", subIP, groupAddr, err)
		}
	},
}

var MulticastGroupSubscriberDelCmd = &cobra.Command{
	Use:     "delete <group> <subscriber-address>",
	Aliases: []string{"del"},
	Short:   "Delete a subscriber from the multicast group.",
	Long: `Delete a subscriber from the given multicast group.
To delete remote subscriber, following information is required:
- group: multicast group address from which subscriber is deleted.
- subscriber-address: subscriber IP address
`,
	Example: `To delete a remote node 10.100.0.1 from multicast group 229.0.0.1, use the following command:
cilium-dbg bpf multicast subscriber delete 229.0.0.1 10.100.0.1
`,
	Run: func(cmd *cobra.Command, args []string) {
		common.RequireRootPrivilege("cilium bpf multicast subscriber delete")

		groupAddr, subIP, err := parseMulticastGroupSubscriberArgs(args)
		if err != nil {
			Fatalf("invalid argument: %s\n", err)
		}

		subscriberMap, err := getMulticastSubscriberMap(groupAddr)
		if err != nil {
			Fatalf("Failed to get subscriber map for group %s: %s", groupAddr, err)
		}

		if err := subscriberMap.Delete(subIP); err != nil {
			Fatalf("Failed to delete subscriber %s from multicast group %s: %s", subIP, groupAddr, err)
		}
	},
}

var MulticastGroupSubscriberListCmd = &cobra.Command{
	Use:     "list < group | all >",
	Aliases: []string{"ls"},
	Short:   "List the multicast subscribers for the given group.",
	Long: `List the multicast subscribers for the given group. 
	To get the subscribers for all the groups, use 'cilium-dbg bpf multicast subscriber list all'.`,
	Run: func(cmd *cobra.Command, args []string) {
		common.RequireRootPrivilege("cilium bpf multicast subscriber list")

		groupAddr, all, err := parseMulticastGroupSubscriberListArgs(args)
		if err != nil {
			Fatalf("invalid argument: %s", err)
		}

		groupV4Map, err := getMulticastGroupMap()
		if err != nil {
			Fatalf("Failed to get multicast bpf map: %s", err)
		}

		var groups []netip.Addr
		if all {
			groups, err = groupV4Map.List()
			if err != nil {
				Fatalf("Failed to list multicast groups: %s", err)
			}
		} else {
			groups = append(groups, groupAddr)
		}

		err = outputGroups(groups)
		if err != nil {
			Fatalf("Failed to list multicast subscribers: %s", err)
		}
	},
}

var NodeCmd = &cobra.Command{
	Use:   "node",
	Short: "Manage cluster nodes",
}

NodeCmd represents the node command

var NodeIDCmd = &cobra.Command{
	Use:   "nodeid",
	Short: "List node IDs and associated information",
}

nodeidCmd represents the nodeid command

var PolicyCmd = &cobra.Command{
	Use:   "policy",
	Short: "Manage security policies",
}

PolicyCmd represents the policy command

var PreFilterCmd = &cobra.Command{
	Use:   "prefilter",
	Short: "Manage XDP CIDR filters",
}

PreFilterCmd represents the prefilter command

var PreflightCmd = &cobra.Command{
	Use:   "preflight",
	Short: "Cilium upgrade helper",
	Long:  `CLI to help upgrade cilium`,
}

PreflightCmd is the command used to manage preflight tasks for upgrades

var RecorderCmd = &cobra.Command{
	Use:   "recorder",
	Short: "Introspect or mangle pcap recorder",
}

RecorderCmd represents the recorder command

var RootCmd = &cobra.Command{
	Use:   "cilium-dbg",
	Short: "CLI",
	Long:  `CLI for interacting with the local Cilium Agent`,
}

RootCmd represents the base command when called without any subcommands

var ServiceCmd = &cobra.Command{
	Use:   "service",
	Short: "Manage services & loadbalancers",
}

ServiceCmd represents the service command

var StatedbCmd = &cobra.Command{
	Use:   "statedb",
	Short: "Inspect StateDB (deprecated)",
	Run: func(cmd *cobra.Command, args []string) {
		Fatalf(`This command has been deprecated and will be removed in the next Cilium release.

StateDB tables can now be inspected via the Cilium shell:

$ cilium-dbg shell
cilium> help db
(shows help for 'db' command)

cilium> db
(shows all registered tables)

cilium> db/show health
(shows contents of health table)

$ cilium-dbg shell -- db/show health
(shows contents of health table)

$ cilium-dbg shell -- db/show -format=json health
(shows contents as JSON)
`)
	},
}

var TroubleshootCmd = &cobra.Command{
	Use:   "troubleshoot",
	Short: "Run troubleshooting utilities to check control-plane connectivity",
}

TroubleshootCmd represents the troubleshoot command. Note that this command is additionally registered as a subcommand of the Cilium operator.

Functions

func Execute

func Execute()

Execute adds all child commands to the root command sets flags appropriately. This is called by main.main(). It only needs to happen once to the rootCmd.

func Fatalf

func Fatalf(msg string, args ...interface{})

Fatalf prints the Printf formatted message to stderr and exits the program Note: os.Exit(1) is not recoverable

func NewTabWriter

func NewTabWriter() *tabwriter.Writer

NewTabWriter initialises tabwriter.Writer with following defaults width 5 and padding 3

func TablePrinter

func TablePrinter(firstTitle, secondTitle string, data map[string][]string)

TablePrinter prints the map[string][]string, which is an usual representation of dumped BPF map, using tabwriter.

func TroubleshootClusterMesh

func TroubleshootClusterMesh(
	ctx context.Context, stdout io.Writer, dialer kvstore.EtcdDbgDialer,
	cfgdir string, timeout time.Duration, local string, clusters ...string,
)

func Usagef

func Usagef(cmd *cobra.Command, msg string, args ...interface{})

Usagef prints the Printf formatted message to stderr, prints usage help and exits the program Note: os.Exit(1) is not recoverable

Types

type PolicyUpdateArgs

type PolicyUpdateArgs struct {
	// contains filtered or unexported fields
}

PolicyUpdateArgs is the parsed representation of a bpf policy {add,delete} command.

type SubscriberData

type SubscriberData struct {
	GroupAddr   netip.Addr                     `json:"group_address"`
	Subscribers []*maps_multicast.SubscriberV4 `json:"subscribers"`
}

SubscriberData is used to store the subscribers of a multicast group as well as for json output.