healthcheck: distinguish between agent/server/client

This is the first step towards formalizing the concept of "agent",
"server", and "client" nodes.

client/client.go

@@ -22,6 +22,7 @@ type Client struct {
 	Iscsi  *ISCSIService
 	Nfs    *NFSService
 	NvmeOf *NvmeOfService
+	Status *StatusService
 }
 
 type clientError string
@@ -81,6 +82,7 @@ func NewClient(options ...Option) (*Client, error) {
 	c.Iscsi = &ISCSIService{c}
 	c.Nfs = &NFSService{c}
 	c.NvmeOf = &NvmeOfService{c}
+	c.Status = &StatusService{c}
 	return c, nil
 }
 

client/status.go

@@ -0,0 +1,19 @@
+package client
+
+import (
+	"context"
+)
+
+type StatusService struct {
+	client *Client
+}
+
+type Status struct {
+	Status string `json:"status"`
+}
+
+func (s *StatusService) Get(ctx context.Context) (*Status, error) {
+	var status *Status
+	_, err := s.client.doGET(ctx, "/api/v2/status", &status)
+	return status, err
+}

cmd/check_health.go

@@ -9,12 +9,30 @@ import (
 )
 
 func checkHealthCommand() *cobra.Command {
+	var mode string
 	cmd := &cobra.Command{
 		Use:   "check-health",
 		Short: "Check if all requirements and dependencies are met on the current system",
+		Long: `Check if all requirements and dependencies are met on the current system.
+
+The "mode" argument can be used to specify the type of node this
+system is intended to be used as.
+
+An "agent" node is responsible for actually running the highly available storage
+endpoint (for example, an iSCSI target). Thus, the health check ensures the
+current system is correctly configured to host the different kinds of storage
+protocols supported by LINSTOR Gateway.
+
+A "server" node acts as a relay between the client and the LINSTOR controller.
+The only requirement is that the LINSTOR controller can be reached.
+
+A "client" node interacts with the LINSTOR Gateway API. Its only requirement is
+that a LINSTOR Gateway server can be reached.
+`,
+		Args: cobra.NoArgs,
 		Run: func(cmd *cobra.Command, args []string) {
 			controllers := viper.GetStringSlice("linstor.controllers")
-			err := healthcheck.CheckRequirements(controllers)
+			err := healthcheck.CheckRequirements(mode, controllers, cli)
 			if err != nil {
 				fmt.Println()
 				log.Fatalf("Health check failed: %v", err)
@@ -23,6 +41,7 @@ func checkHealthCommand() *cobra.Command {
 	}
 	cmd.Flags().StringSlice("controllers", nil, "List of LINSTOR controllers to try to connect to (default from $LS_CONTROLLERS, or localhost:3370)")
 	viper.BindPFlag("linstor.controllers", cmd.Flags().Lookup("controllers"))
+	cmd.Flags().StringVarP(&mode, "mode", "m", "agent", `Which type of node to check requirements for. Can be "agent", "server", or "client"`)
 
 	return cmd
 }

pkg/healthcheck/client.go

@@ -0,0 +1,38 @@
+package healthcheck
+
+import (
+	"context"
+	"fmt"
+	"github.com/LINBIT/linstor-gateway/client"
+	"github.com/fatih/color"
+	"strings"
+	"time"
+)
+
+type checkGatewayServerConnection struct {
+	cli *client.Client
+}
+
+func (c *checkGatewayServerConnection) check(bool) error {
+	ctx, done := context.WithTimeout(context.Background(), 5*time.Second)
+	defer done()
+	status, err := c.cli.Status.Get(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to connect to server: %w", err)
+	}
+	if status == nil {
+		return fmt.Errorf("received nil status from server")
+	}
+	if status.Status != "ok" {
+		return fmt.Errorf("received invalid status from server: %q", status.Status)
+	}
+	return nil
+}
+
+func (c *checkGatewayServerConnection) format(err error) string {
+	var b strings.Builder
+	fmt.Fprintf(&b, "    %s The LINSTOR Gateway server cannot be reached from this node\n", color.RedString("✗"))
+	fmt.Fprintf(&b, "      %s\n\n", err.Error())
+	fmt.Fprintf(&b, "      Make sure the %s command line option points to a running LINSTOR Gateway server.\n", bold("--connect"))
+	return b.String()
+}

pkg/healthcheck/healthcheck.go

@@ -3,6 +3,7 @@ package healthcheck
 import (
 	"errors"
 	"fmt"
+	"github.com/LINBIT/linstor-gateway/client"
 	"github.com/fatih/color"
 )
 
@@ -54,11 +55,10 @@ func contains(haystack []string, needle string) bool {
 	return false
 }
 
-func CheckRequirements(controllers []string) error {
+func checkAgent() error {
 	errs := 0
 	err := category(
 		"LINSTOR",
-		&checkLinstor{controllers},
 		&checkFileWhitelist{},
 	)
 	if err != nil {
@@ -107,3 +107,52 @@ func CheckRequirements(controllers []string) error {
 	}
 	return nil
 }
+
+func checkServer(controllers []string) error {
+	errs := 0
+	err := category(
+		"LINSTOR",
+		&checkLinstor{controllers},
+	)
+	if err != nil {
+		errs++
+	}
+	if errs > 0 {
+		return fmt.Errorf("found %d issues", errs)
+	}
+	return nil
+}
+
+func checkClient(cli *client.Client) error {
+	errs := 0
+	err := category(
+		"Server Connection",
+		&checkGatewayServerConnection{cli},
+	)
+	if err != nil {
+		errs++
+	}
+	if errs > 0 {
+		return fmt.Errorf("found %d issues", errs)
+	}
+	return nil
+}
+
+func CheckRequirements(mode string, controllers []string, cli *client.Client) error {
+	doPrint := func() {
+		fmt.Printf("Checking %s requirements.\n\n", bold(mode))
+	}
+	switch mode {
+	case "agent":
+		doPrint()
+		return checkAgent()
+	case "server":
+		doPrint()
+		return checkServer(controllers)
+	case "client":
+		doPrint()
+		return checkClient(cli)
+	default:
+		return fmt.Errorf("unknown mode %q. Expected \"agent\", \"server\", or \"client\"", mode)
+	}
+}