Add antctl check installation command to conduct connectivity checks (#6133)

.github/workflows/kind.yml

@@ -739,6 +739,48 @@ jobs:
           path: log.tar.gz
           retention-days: 30
 
+  conduct-connectivity-test:
+    name: Test connectivity using 'antctl check' command
+    needs: [ build-antrea-coverage-image ]
+    runs-on: [ ubuntu-latest ]
+    steps:
+      - name: Free disk space
+        run: |
+          sudo apt-get clean
+          df -h
+      - uses: actions/checkout@v4
+        with:
+          show-progress: false
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: 'go.mod'
+      - name: Download Antrea image from previous job
+        uses: actions/download-artifact@v4
+        with:
+          name: antrea-ubuntu-cov
+      - name: Load Antrea image
+        run: |
+          docker load -i antrea-ubuntu.tar
+      - name: Install Kind
+        run: |
+          KIND_VERSION=$(head -n1 ./ci/kind/version)
+          curl -Lo ./kind https://github.com/kubernetes-sigs/kind/releases/download/${KIND_VERSION}/kind-$(uname)-amd64
+          chmod +x ./kind
+          sudo mv kind /usr/local/bin
+      - name: Create Kind Cluster
+        run: |
+          kind create cluster --config ci/kind/config-3nodes.yml
+      - name: Load docker image into kind
+        run: |
+          kind load docker-image antrea/antrea-controller-ubuntu-coverage:latest antrea/antrea-agent-ubuntu-coverage:latest
+          kubectl apply -f build/yamls/antrea.yml
+      - name: Build antctl binary
+        run: |
+          make antctl-linux
+      - name: Run antctl command
+        run: |
+          ./bin/antctl-linux check installation
+
   validate-prometheus-metrics-doc:
     name: Validate metrics in Prometheus document match running deployment's
     needs: build-antrea-coverage-image

pkg/antctl/antctl.go

@@ -24,6 +24,7 @@ import (
 	"antrea.io/antrea/pkg/agent/apiserver/handlers/podinterface"
 	"antrea.io/antrea/pkg/agent/apiserver/handlers/serviceexternalip"
 	fallbackversion "antrea.io/antrea/pkg/antctl/fallback/version"
+	checkinstallation "antrea.io/antrea/pkg/antctl/raw/check/installation"
 	"antrea.io/antrea/pkg/antctl/raw/featuregates"
 	"antrea.io/antrea/pkg/antctl/raw/multicluster"
 	"antrea.io/antrea/pkg/antctl/raw/proxy"
@@ -639,6 +640,12 @@ $ antctl get podmulticaststats pod -n namespace`,
 		},
 	},
 	rawCommands: []rawCommand{
+		{
+			cobraCommand:      checkinstallation.Command(),
+			supportAgent:      false,
+			supportController: false,
+			commandGroup:      check,
+		},
 		{
 			cobraCommand:      supportbundle.Command,
 			supportAgent:      true,

pkg/antctl/command_definition.go

@@ -70,6 +70,7 @@ const (
 	query
 	mc
 	upgrade
+	check
 )
 
 var groupCommands = map[commandGroup]*cobra.Command{
@@ -93,6 +94,10 @@ var groupCommands = map[commandGroup]*cobra.Command{
 		Short: "Sub-commands for upgrade operations",
 		Long:  "Sub-commands for upgrade operations",
 	},
+	check: {
+		Use:   "check",
+		Short: "Performs pre and post installation checks",
+	},
 }
 
 type endpointResponder interface {

pkg/antctl/command_list.go

@@ -64,7 +64,8 @@ func (cl *commandList) applyToRootCommand(root *cobra.Command, client AntctlClie
 			(runtime.Mode == runtime.ModeController && cmd.supportController) ||
 			(runtime.Mode == runtime.ModeFlowAggregator && cmd.supportFlowAggregator) ||
 			(!runtime.InPod && cmd.commandGroup == mc) ||
-			(!runtime.InPod && cmd.commandGroup == upgrade) {
+			(!runtime.InPod && cmd.commandGroup == upgrade) ||
+			(!runtime.InPod && cmd.commandGroup == check) {
 			if groupCommand, ok := groupCommands[cmd.commandGroup]; ok {
 				groupCommand.AddCommand(cmd.cobraCommand)
 			} else {

pkg/antctl/raw/check/client.go

@@ -0,0 +1,132 @@
+// Copyright 2024 Antrea Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package check
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/client-go/kubernetes"
+	"k8s.io/client-go/kubernetes/scheme"
+	"k8s.io/client-go/rest"
+	"k8s.io/client-go/tools/clientcmd"
+	"k8s.io/client-go/tools/remotecommand"
+)
+
+type Client struct {
+	clientSet   kubernetes.Interface
+	config      *rest.Config
+	clusterName string
+}
+
+func NewClient() (*Client, error) {
+	rules := clientcmd.NewDefaultClientConfigLoadingRules()
+
+	nonInteractiveClient := clientcmd.NewNonInteractiveDeferredLoadingClientConfig(rules, &clientcmd.ConfigOverrides{})
+
+	config, err := nonInteractiveClient.ClientConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	rawConfig, err := nonInteractiveClient.RawConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	clientset, err := kubernetes.NewForConfig(config)
+	if err != nil {
+		return nil, err
+	}
+
+	contextName := rawConfig.CurrentContext
+
+	clusterName := ""
+	if context, ok := rawConfig.Contexts[contextName]; ok {
+		clusterName = context.Cluster
+	}
+
+	return &Client{
+		clientSet:   clientset,
+		config:      config,
+		clusterName: clusterName,
+	}, nil
+}
+
+func (c *Client) GetClientSet() kubernetes.Interface {
+	return c.clientSet
+}
+
+func (c *Client) ClusterName() (name string) {
+	return c.clusterName
+}
+
+func (c *Client) DeploymentIsReady(ctx context.Context, namespace, deploymentName string) (bool, error) {
+	deployment, err := c.clientSet.AppsV1().Deployments(namespace).Get(ctx, deploymentName, metav1.GetOptions{})
+	if err != nil {
+		return false, err
+	}
+
+	if deployment.Generation <= deployment.Status.ObservedGeneration {
+		for _, cond := range deployment.Status.Conditions {
+			if cond.Type == appsv1.DeploymentProgressing && cond.Reason == "ProgressDeadlineExceeded" {
+				return false, fmt.Errorf("deployment %q exceeded its progress deadline", deployment.Name)
+			}
+		}
+		if deployment.Spec.Replicas != nil && deployment.Status.UpdatedReplicas < *deployment.Spec.Replicas {
+			return false, nil
+		}
+		if deployment.Status.Replicas > deployment.Status.UpdatedReplicas {
+			return false, nil
+		}
+		if deployment.Status.AvailableReplicas < deployment.Status.UpdatedReplicas {
+			return false, nil
+		}
+		return true, nil
+	}
+	return false, nil
+}
+
+func (c *Client) ExecInPod(ctx context.Context, namespace, pod, container string, command []string) (bytes.Buffer, error) {
+	req := c.clientSet.CoreV1().RESTClient().Post().Resource("pods").Name(pod).Namespace(namespace).SubResource("exec")
+	req.VersionedParams(&corev1.PodExecOptions{
+		Command:   command,
+		Container: container,
+		Stdin:     false,
+		Stdout:    true,
+		Stderr:    true,
+		TTY:       false,
+	}, scheme.ParameterCodec)
+	exec, err := remotecommand.NewSPDYExecutor(c.config, "POST", req.URL())
+	if err != nil {
+		return bytes.Buffer{}, fmt.Errorf("error while creating executor: %w", err)
+	}
+	var stdout, stderr bytes.Buffer
+	err = exec.StreamWithContext(ctx, remotecommand.StreamOptions{
+		Stdin:  nil,
+		Stdout: &stdout,
+		Stderr: &stderr,
+		Tty:    false,
+	})
+	if err != nil {
+		return bytes.Buffer{}, fmt.Errorf("error in stream: %w", err)
+	}
+	fmt.Fprint(&stdout, stderr.String())
+	return stdout, nil
+}