ctl: replace doRequest with HTTP client to get health status

client/http/api.go

@@ -41,6 +41,7 @@ const (
 	membersPrefix             = "/pd/api/v1/members"
 	leaderPrefix              = "/pd/api/v1/leader"
 	transferLeader            = "/pd/api/v1/leader/transfer"
+	health                    = "/pd/api/v1/health"
 	// Config
 	Config          = "/pd/api/v1/config"
 	ClusterVersion  = "/pd/api/v1/config/cluster-version"

client/http/interface.go

@@ -50,6 +50,7 @@
 	GetStores(context.Context) (*StoresInfo, error)
 	GetStore(context.Context, uint64) (*StoreInfo, error)
 	SetStoreLabels(context.Context, int64, map[string]string) error
+	GetHealthStatus(context.Context) ([]Health, error)
 	/* Config-related interfaces */
 	GetConfig(context.Context) (map[string]any, error)
 	SetConfig(context.Context, map[string]any, ...float64) error
@@ -337,6 +338,20 @@
 		WithBody(jsonInput))
 }
 
+// GetHealthStatus gets the health status of the cluster.
+func (c *client) GetHealthStatus(ctx context.Context) ([]Health, error) {
+	var healths []Health
+	err := c.request(ctx, newRequestInfo().
+		WithName(getHealthStatusName).
+		WithURI(health).
+		WithMethod(http.MethodGet).
+		WithResp(&healths))
+	if err != nil {
+		return nil, err
+	}
+	return healths, nil
+}
+
 // GetConfig gets the configurations.
 func (c *client) GetConfig(ctx context.Context) (map[string]any, error) {
 	var config map[string]any

client/http/request_info.go

@@ -39,6 +39,7 @@ const (
 	getStoresName                           = "GetStores"
 	getStoreName                            = "GetStore"
 	setStoreLabelsName                      = "SetStoreLabels"
+	getHealthStatusName                     = "GetHealthStatus"
 	getConfigName                           = "GetConfig"
 	setConfigName                           = "SetConfig"
 	getScheduleConfigName                   = "GetScheduleConfig"

client/http/types.go

@@ -661,3 +661,12 @@ func stringToKeyspaceState(str string) (keyspacepb.KeyspaceState, error) {
 		return keyspacepb.KeyspaceState(0), fmt.Errorf("invalid KeyspaceState string: %s", str)
 	}
 }
+
+// Health reflects the cluster's health.
+// NOTE: This type is moved from `server/api/health.go`, maybe move them to the same place later.
+type Health struct {
+	Name       string   `json:"name"`
+	MemberID   uint64   `json:"member_id"`
+	ClientUrls []string `json:"client_urls"`
+	Health     bool     `json:"health"`
+}

pkg/dashboard/uiserver/embedded_assets_rewriter.go

@@ -28,6 +28,7 @@ import (
 var once sync.Once
 
 // Assets returns the Assets FileSystem of the dashboard UI
+// NOTE: if you see "undefined: assets" error, please run `make dashboard-ui` in the root directory of the repository.
 func Assets(cfg *config.Config) http.FileSystem {
 	once.Do(func() {
 		resPath := distroutil.MustGetResPath()

tests/integrations/client/http_client_test.go

@@ -811,3 +811,22 @@ func (suite *httpClientTestSuite) checkUpdateKeyspaceGCManagementType(mode mode,
 	re.True(ok)
 	re.Equal(expectGCManagementType, val)
 }
+
+func (suite *httpClientTestSuite) TestGetHealthStatus() {
+	suite.RunTestInTwoModes(suite.checkGetHealthStatus)
+}
+
+func (suite *httpClientTestSuite) checkGetHealthStatus(mode mode, client pd.Client) {
+	re := suite.Require()
+	env := suite.env[mode]
+
+	healths, err := client.GetHealthStatus(env.ctx)
+	re.NoError(err)
+	re.Len(healths, 2)
+	sort.Slice(healths, func(i, j int) bool {
+		return healths[i].Name < healths[j].Name
+	})
+	re.Equal("pd1", healths[0].Name)
+	re.Equal("pd2", healths[1].Name)
+	re.True(healths[0].Health && healths[1].Health)
+}

tools/pd-ctl/pdctl/command/health_command.go

@@ -15,30 +15,25 @@
 package command
 
 import (
-	"net/http"
-
 	"github.com/spf13/cobra"
 )
 
-var (
-	healthPrefix = "pd/api/v1/health"
-)
-
 // NewHealthCommand return a health subcommand of rootCmd
 func NewHealthCommand() *cobra.Command {
 	m := &cobra.Command{
-		Use:   "health",
-		Short: "show all node's health information of the pd cluster",
-		Run:   showHealthCommandFunc,
+		Use:               "health",
+		Short:             "show all node's health information of the PD cluster",
+		PersistentPreRunE: requirePDClient,
+		Run:               showHealthCommandFunc,
 	}
 	return m
 }
 
 func showHealthCommandFunc(cmd *cobra.Command, _ []string) {
-	r, err := doRequest(cmd, healthPrefix, http.MethodGet, http.Header{})
+	health, err := PDCli.GetHealthStatus(cmd.Context())
 	if err != nil {
 		cmd.Println(err)
 		return
 	}
-	cmd.Println(r)
+	jsonPrint(cmd, health)
 }

tools/pd-ctl/tests/global_test.go

@@ -16,34 +16,51 @@ package tests
 
 import (
 	"context"
-	"fmt"
+	"encoding/json"
 	"net/http"
 	"testing"
 
+	"github.com/pingcap/kvproto/pkg/metapb"
 	"github.com/pingcap/log"
 	"github.com/stretchr/testify/require"
 	"github.com/tikv/pd/pkg/utils/apiutil"
 	"github.com/tikv/pd/pkg/utils/assertutil"
 	"github.com/tikv/pd/pkg/utils/testutil"
 	"github.com/tikv/pd/server"
+	"github.com/tikv/pd/server/api"
 	cmd "github.com/tikv/pd/tools/pd-ctl/pdctl"
 	"go.uber.org/zap"
 )
 
-const pdControlCallerID = "pd-ctl"
+const pdControlCallerID = "pd-http-client"
 
 func TestSendAndGetComponent(t *testing.T) {
 	re := require.New(t)
 	handler := func(context.Context, *server.Server) (http.Handler, apiutil.APIServiceGroup, error) {
 		mux := http.NewServeMux()
+		mux.HandleFunc("/pd/api/v1/cluster", func(w http.ResponseWriter, _ *http.Request) {
+			cluster := &metapb.Cluster{
+				Id: 0,
+			}
+			clusterBytes, err := json.Marshal(cluster)
+			re.NoError(err)
+			w.Write(clusterBytes)
+		})
 		mux.HandleFunc("/pd/api/v1/health", func(w http.ResponseWriter, r *http.Request) {
 			callerID := apiutil.GetCallerIDOnHTTP(r)
 			for k := range r.Header {
 				log.Info("header", zap.String("key", k))
 			}
 			log.Info("caller id", zap.String("caller-id", callerID))
 			re.Equal(pdControlCallerID, callerID)
-			fmt.Fprint(w, callerID)
+			healths := []api.Health{
+				{
+					Name: "test",
+				},
+			}
+			healthsBytes, err := json.Marshal(healths)
+			re.NoError(err)
+			w.Write(healthsBytes)
 		})
 		info := apiutil.APIServiceGroup{
 			IsCore: true,
@@ -67,5 +84,13 @@ func TestSendAndGetComponent(t *testing.T) {
 	args := []string{"-u", pdAddr, "health"}
 	output, err := ExecuteCommand(cmd, args...)
 	re.NoError(err)
-	re.Equal(fmt.Sprintf("%s\n", pdControlCallerID), string(output))
+	re.Equal(`[
+  {
+    "name": "test",
+    "member_id": 0,
+    "client_urls": null,
+    "health": false
+  }
+]
+`, string(output))
 }