cmd

Documentation

Index

• Variables
• func Execute()
• func RunCNPNodeStatusGC(ctx context.Context, wg *sync.WaitGroup, clientset k8sClient.Clientset, ...)
• func RunCNPStatusNodesCleaner(ctx context.Context, clientset k8sClient.Clientset, rateLimit *rate.Limiter)
• func WithLeaderLifecycle(cells ...cell.Cell) cell.Cell
• type LeaderLifecycle

Variables

var (

	// IsLeader is an atomic boolean value that is true when the Operator is
	// elected leader. Otherwise, it is false.
	IsLeader atomic.Value

	// OperatorCell are the operator specific cells without infrastructure cells.
	// Used also in tests.
	OperatorCell = cell.Module(
		"operator",
		"Cilium Operator",

		cell.Invoke(
			registerOperatorHooks,
		),

		cell.Provide(func() *option.DaemonConfig {
			return option.Config
		}),

		cell.Provide(func() *operatorOption.OperatorConfig {
			return operatorOption.Config
		}),

		cell.Provide(func(
			daemonCfg *option.DaemonConfig,
			operatorCfg *operatorOption.OperatorConfig,
		) identitygc.SharedConfig {
			return identitygc.SharedConfig{
				IdentityAllocationMode: daemonCfg.IdentityAllocationMode,
				EnableMetrics:          operatorCfg.EnableMetrics,
				ClusterName:            daemonCfg.LocalClusterName(),
				K8sNamespace:           daemonCfg.CiliumNamespaceName(),
				ClusterID:              daemonCfg.LocalClusterID(),
			}
		}),

		WithLeaderLifecycle(
			k8s.SharedResourcesCell,
			lbipam.Cell,
			identitygc.Cell,

			legacyCell,
		),
	)

	Vp *viper.Viper = operatorHive.Viper()
)

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

MetricsCmd represents the metrics command for the operator.

var MetricsListCmd = &cobra.Command{
	Use:   "list",
	Short: "List all metrics for the operator",
	Run: func(cmd *cobra.Command, args []string) {
		c := client.NewHTTPClientWithConfig(
			strfmt.Default, client.DefaultTransportConfig().WithHost(operatorAddr))

		res, err := c.Metrics.GetMetrics(nil)
		if err != nil {
			log.Fatalf("Cannot get metrics list: %s", err)
		}

		re, err := regexp.Compile(matchPattern)
		if err != nil {
			log.Fatalf("Cannot compile regex: %s", err)
		}

		metrics := make([]*models.Metric, 0, len(res.Payload))
		for _, metric := range res.Payload {
			if re.MatchString(metric.Name) {
				metrics = append(metrics, metric)
			}
		}

		if command.OutputOption() {
			if err := command.PrintOutput(metrics); err != nil {
				os.Exit(1)
			}
			return
		}

		w := tabwriter.NewWriter(os.Stdout, 5, 0, 3, ' ', 0)

		fmt.Fprintln(w, "Metric\tLabels\tValue")
		for _, metric := range metrics {
			label := ""
			if len(metric.Labels) > 0 {
				labelArray := []string{}
				for key, value := range metric.Labels {
					labelArray = append(labelArray, fmt.Sprintf(`%s="%s"`, key, value))
				}
				label = strings.Join(labelArray, " ")
			}
			fmt.Fprintf(w, "%s\t%s\t%f\n", metric.Name, label, metric.Value)
		}
		w.Flush()
	},
}

MetricsListCmd dumps all metrics into stdout

Functions

func Execute

func Execute()

func RunCNPNodeStatusGC

func RunCNPNodeStatusGC(ctx context.Context, wg *sync.WaitGroup, clientset k8sClient.Clientset, nodeStore cache.Store)

func RunCNPStatusNodesCleaner

func RunCNPStatusNodesCleaner(ctx context.Context, clientset k8sClient.Clientset, rateLimit *rate.Limiter)

func WithLeaderLifecycle

func WithLeaderLifecycle(cells ...cell.Cell) cell.Cell

Types

type LeaderLifecycle

type LeaderLifecycle struct {
	hive.DefaultLifecycle
}

LeaderLifecycle is the inner lifecycle of the operator that is started when this operator instance is elected leader. It implements hive.Lifecycle allowing cells to use it.