Node local status

cmd/blockchaincmd/deploy.go

@@ -7,14 +7,14 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/ava-labs/avalanchego/api/info"
 	"os"
 	"path/filepath"
 	"strings"
 	"time"
 
-	"github.com/ava-labs/avalanche-cli/pkg/evm"
+	"github.com/ava-labs/avalanchego/api/info"
 
+	"github.com/ava-labs/avalanche-cli/pkg/evm"
 	"github.com/ava-labs/avalanche-cli/pkg/node"
 	"github.com/ava-labs/avalanchego/vms/platformvm/warp/message"
 	"github.com/ethereum/go-ethereum/common"
@@ -135,9 +135,10 @@ so you can take your locally tested Subnet and deploy it on Fuji or Mainnet.`,
 	cmd.Flags().StringVar(&icmSpec.RegistryBydecodePath, "teleporter-registry-bytecode-path", "", "path to an interchain messenger registry bytecode file")
 	cmd.Flags().StringVar(&bootstrapValidatorsJSONFilePath, "bootstrap-filepath", "", "JSON file path that provides details about bootstrap validators, leave Node-ID and BLS values empty if using --generate-node-id=true")
 	cmd.Flags().BoolVar(&generateNodeID, "generate-node-id", false, "whether to create new node id for bootstrap validators (Node-ID and BLS values in bootstrap JSON file will be overridden if --bootstrap-filepath flag is used)")
-	cmd.Flags().StringSliceVar(&bootstrapEndpoints, "bootstrap-enu dpoints", nil, "take validator node info from the given endpoints")
+	cmd.Flags().StringSliceVar(&bootstrapEndpoints, "bootstrap-endpoints", nil, "take validator node info from the given endpoints")
 	cmd.Flags().BoolVar(&useLocalMachine, "use-local-machine", false, "use local machine as a blockchain validator")
 	cmd.Flags().StringVar(&localMachineCluster, "local-machine-cluster", "", "existing local machine to be used as a blockchain validator")
+
 	return cmd
 }
 
@@ -489,21 +490,16 @@ func deployBlockchain(cmd *cobra.Command, args []string) error {
 			if localMachineCluster != "" {
 				// don't destroy cluster if local cluster name is provided
 				clusterName = localMachineCluster
-			} else {
-				// destroy any cluster with same name before we start local node
-				// we don't want to reuse snapshots from previous sessions
-				if utils.DirectoryExists(app.GetLocalDir(clusterName)) {
-					_ = node.DestroyLocalNode(app, clusterName)
-				}
+			} else if utils.DirectoryExists(app.GetLocalDir(clusterName)) {
+				_ = node.DestroyLocalNode(app, clusterName)
 			}
+			// destroy any cluster with same name before we start local node
+			// we don't want to reuse snapshots from previous sessions
 			// TODO: replace bootstrapEndpoints with dynamic port number
 			bootstrapEndpoints = []string{"http://127.0.0.1:9650"}
 			anrSettings := node.ANRSettings{}
 			avagoVersionSettings := node.AvalancheGoVersionSettings{}
-			useEtnaDevnet := false
-			if network.Kind == models.EtnaDevnet {
-				useEtnaDevnet = true
-			}
+			useEtnaDevnet := network.Kind == models.EtnaDevnet
 			if avagoBinaryPath == "" {
 				ux.Logger.PrintToUser("Local build of Avalanche Go is required to create an Avalanche node using local machine")
 				ux.Logger.PrintToUser("Please download Avalanche Go repo at https://github.com/ava-labs/avalanchego and build from source through ./scripts/build.sh")
@@ -519,7 +515,6 @@ func deployBlockchain(cmd *cobra.Command, args []string) error {
 				return err
 			}
 		}
-
 		if len(bootstrapEndpoints) > 0 {
 			var changeAddr string
 			for _, endpoint := range bootstrapEndpoints {
@@ -545,8 +540,7 @@ func deployBlockchain(cmd *cobra.Command, args []string) error {
 					ChangeOwnerAddr:      changeAddr,
 				})
 			}
-		}
-		if len(bootstrapValidators) == 0 {
+		} else {
 			bootstrapValidators, err = promptBootstrapValidators(network)
 			if err != nil {
 				return err

cmd/nodecmd/create.go

@@ -902,7 +902,7 @@ func addNodeToClustersConfig(network models.Network, nodeID, clusterName string,
 	}
 	clusterConfig := clustersConfig.Clusters[clusterName]
 	// if supplied network in argument is empty, don't change current cluster network in cluster_config.json
-	if network != models.UndefinedNetwork {
+	if !network.IsUndefined() {
 		clusterConfig.Network = network
 	}
 	clusterConfig.HTTPAccess = constants.HTTPAccess(publicHTTPPortAccess)

cmd/nodecmd/destroy.go

@@ -5,7 +5,6 @@ package nodecmd
 import (
 	"errors"
 	"fmt"
-	"github.com/ava-labs/avalanche-cli/pkg/models"
 	"os"
 	"strings"
 
@@ -325,36 +324,3 @@ func getClusterMonitoringNode(clusterName string) (string, error) {
 	}
 	return clustersConfig.Clusters[clusterName].MonitoringInstance, nil
 }
-
-func checkCluster(clusterName string) error {
-	_, err := getClusterNodes(clusterName)
-	return err
-}
-
-func checkClusterExists(clusterName string) (bool, error) {
-	clustersConfig := models.ClustersConfig{}
-	if app.ClustersConfigExists() {
-		var err error
-		clustersConfig, err = app.LoadClustersConfig()
-		if err != nil {
-			return false, err
-		}
-	}
-	_, ok := clustersConfig.Clusters[clusterName]
-	return ok, nil
-}
-
-func getClusterNodes(clusterName string) ([]string, error) {
-	if exists, err := checkClusterExists(clusterName); err != nil || !exists {
-		return nil, fmt.Errorf("cluster %q not found", clusterName)
-	}
-	clustersConfig, err := app.LoadClustersConfig()
-	if err != nil {
-		return nil, err
-	}
-	clusterNodes := clustersConfig.Clusters[clusterName].Nodes
-	if len(clusterNodes) == 0 {
-		return nil, fmt.Errorf("no nodes found in cluster %s", clusterName)
-	}
-	return clusterNodes, nil
-}

cmd/nodecmd/list.go

@@ -44,8 +44,9 @@ func list(_ *cobra.Command, _ []string) error {
 		if err := node.CheckCluster(app, clusterName); err != nil {
 			return err
 		}
+		cloudIDs := clusterConf.GetCloudIDs()
 		nodeIDs := []string{}
-		for _, cloudID := range clusterConf.GetCloudIDs() {
+		for _, cloudID := range cloudIDs {
 			nodeIDStr := "----------------------------------------"
 			if clusterConf.IsAvalancheGoHost(cloudID) {
 				if nodeID, err := getNodeID(app.GetNodeInstanceDirPath(cloudID)); err != nil {
@@ -56,11 +57,12 @@ func list(_ *cobra.Command, _ []string) error {
 			}
 			nodeIDs = append(nodeIDs, nodeIDStr)
 		}
-		if clusterConf.External {
+		switch {
+		case clusterConf.External:
 			ux.Logger.PrintToUser("cluster %q (%s) EXTERNAL", clusterName, clusterConf.Network.Kind.String())
-		} else if clusterConf.Local {
+		case clusterConf.Local:
 			ux.Logger.PrintToUser("cluster %q (%s) LOCAL", clusterName, clusterConf.Network.Kind.String())
-		} else {
+		default:
 			ux.Logger.PrintToUser("Cluster %q (%s)", clusterName, clusterConf.Network.Kind.String())
 		}
 		for i, cloudID := range clusterConf.GetCloudIDs() {

cmd/nodecmd/local.go

@@ -42,6 +42,8 @@ The node local command suite provides a collection of commands related to local
 	cmd.AddCommand(newLocalDestroyCmd())
 	// node local track
 	cmd.AddCommand(newLocalTrackCmd())
+	// node local status
+	cmd.AddCommand(newLocalStatusCmd())
 	return cmd
 }
 
@@ -110,6 +112,16 @@ func newLocalDestroyCmd() *cobra.Command {
 	}
 }
 
+func newLocalStatusCmd() *cobra.Command {
+	return &cobra.Command{
+		Use:   "status",
+		Short: "(ALPHA Warning) Get status of local node",
+		Long:  `Get status of local node.`,
+		Args:  cobra.MaximumNArgs(1),
+		RunE:  localStatus,
+	}
+}
+
 func localStartNode(_ *cobra.Command, args []string) error {
 	clusterName := args[0]
 	anrSettings := node.ANRSettings{
@@ -143,6 +155,14 @@ func localTrack(_ *cobra.Command, args []string) error {
 	return node.TrackSubnetWithLocalMachine(app, args[0], args[1])
 }
 
+func localStatus(_ *cobra.Command, args []string) error {
+	clusterName := ""
+	if len(args) > 0 {
+		clusterName = args[0]
+	}
+	return node.LocalStatus(app, clusterName)
+}
+
 func notImplementedForLocal(what string) error {
 	ux.Logger.PrintToUser("Unsupported cmd: %s is not supported by local clusters", logging.LightBlue.Wrap(what))
 	return nil

pkg/models/network.go

@@ -57,6 +57,10 @@ func NewNetwork(kind NetworkKind, id uint32, endpoint string, clusterName string
 	}
 }
 
+func (n Network) IsUndefined() bool {
+	return n.Kind == Undefined
+}
+
 func NewLocalNetwork() Network {
 	return NewNetwork(Local, constants.LocalNetworkID, constants.LocalAPIEndpoint, "")
 }

pkg/node/helper.go

@@ -6,11 +6,12 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"sync"
+	"time"
+
 	"github.com/ava-labs/avalanche-cli/pkg/binutils"
 	"github.com/ava-labs/avalanche-cli/pkg/subnet"
 	"github.com/ava-labs/avalanche-cli/pkg/vm"
-	"sync"
-	"time"
 
 	"github.com/ava-labs/avalanche-cli/pkg/ansible"
 
@@ -58,12 +59,12 @@ func GetClusterNodes(app *application.Avalanche, clusterName string) ([]string,
 	if exists, err := CheckClusterExists(app, clusterName); err != nil || !exists {
 		return nil, fmt.Errorf("cluster %q not found", clusterName)
 	}
-	clustersConfig, err := app.LoadClustersConfig()
+	clusterConfig, err := app.GetClusterConfig(clusterName)
 	if err != nil {
 		return nil, err
 	}
-	clusterNodes := clustersConfig.Clusters[clusterName].Nodes
-	if len(clusterNodes) == 0 {
+	clusterNodes := clusterConfig.Nodes
+	if len(clusterNodes) == 0 && !clusterConfig.Local {
 		return nil, fmt.Errorf("no nodes found in cluster %s", clusterName)
 	}
 	return clusterNodes, nil
@@ -416,7 +417,6 @@ func promptAvalancheGoVersionChoice(app *application.Avalanche, latestReleaseVer
 			ux.Logger.PrintToUser(fmt.Sprintf("no subnet named %s found", useAvalanchegoVersionFromSubnet))
 		}
 		return AvalancheGoVersionSettings{UseAvalanchegoVersionFromSubnet: useAvalanchegoVersionFromSubnet}, nil
-
 	}
 }
 

pkg/node/local.go

@@ -4,6 +4,10 @@ package node
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
+	"slices"
+
 	"github.com/ava-labs/avalanche-cli/pkg/application"
 	"github.com/ava-labs/avalanche-cli/pkg/binutils"
 	"github.com/ava-labs/avalanche-cli/pkg/constants"
@@ -16,9 +20,8 @@ import (
 	"github.com/ava-labs/avalanche-network-runner/client"
 	anrutils "github.com/ava-labs/avalanche-network-runner/utils"
 	"github.com/ava-labs/avalanchego/ids"
+	"github.com/ava-labs/avalanchego/utils/logging"
 	"github.com/ava-labs/avalanchego/utils/set"
-	"os"
-	"path/filepath"
 )
 
 func TrackSubnetWithLocalMachine(app *application.Avalanche, clusterName, blockchainName string) error {
@@ -296,7 +299,7 @@ func StartLocalNode(app *application.Avalanche, clusterName string, useEtnaDevne
 		spinner := spinSession.SpinToUser("Booting Network. Wait until healthy...")
 		if _, err := cli.Start(ctx, avalancheGoBinPath, anrOpts...); err != nil {
 			ux.SpinFailWithError(spinner, "", err)
-			DestroyLocalNode(app, clusterName)
+			_ = DestroyLocalNode(app, clusterName)
 			return fmt.Errorf("failed to start local avalanchego: %w", err)
 		}
 		ux.SpinComplete(spinner)
@@ -393,7 +396,7 @@ func addLocalClusterConfig(app *application.Avalanche, network models.Network) e
 }
 
 func DestroyLocalNode(app *application.Avalanche, clusterName string) error {
-	StopLocalNode(app)
+	_ = StopLocalNode(app)
 
 	rootDir := app.GetLocalDir(clusterName)
 	if err := os.RemoveAll(rootDir); err != nil {
@@ -447,3 +450,75 @@ func StopLocalNode(app *application.Avalanche) error {
 	ux.Logger.GreenCheckmarkToUser("avalanchego stopped")
 	return nil
 }
+
+func listLocalClusters(app *application.Avalanche, clusterNamesToInclude []string) (map[string]string, error) {
+	localClusters := map[string]string{} // map[clusterName]rootDir
+	clustersConfig, err := app.GetClustersConfig()
+	if err != nil {
+		return localClusters, err
+	}
+	for clusterName := range clustersConfig.Clusters {
+		if len(clusterNamesToInclude) == 0 || slices.Contains(clusterNamesToInclude, clusterName) {
+			if ok, err := checkClusterIsLocal(app, clusterName); err == nil && ok {
+				localClusters[clusterName] = app.GetLocalDir(clusterName)
+			}
+		}
+	}
+	return localClusters, nil
+}
+
+func LocalStatus(app *application.Avalanche, clusterName string) error {
+	clustersToList := make([]string, 0)
+	if clusterName != "" {
+		if ok, err := checkClusterIsLocal(app, clusterName); err != nil || !ok {
+			return fmt.Errorf("local cluster %q not found", clusterName)
+		}
+		clustersToList = append(clustersToList, clusterName)
+	}
+
+	// get currently running local cluster
+	ctx, cancel := utils.GetANRContext()
+	defer cancel()
+	currentlyRunningRootDir := ""
+	isHealthy := false
+	cli, _ := binutils.NewGRPCClientWithEndpoint( // ignore error as ANR might be not running
+		binutils.LocalClusterGRPCServerEndpoint,
+		binutils.WithAvoidRPCVersionCheck(true),
+		binutils.WithDialTimeout(constants.FastGRPCDialTimeout),
+	)
+	if cli != nil {
+		status, _ := cli.Status(ctx) // ignore error as ANR might be not running
+		if status != nil && status.ClusterInfo != nil {
+			if status.ClusterInfo.RootDataDir != "" {
+				currentlyRunningRootDir = status.ClusterInfo.RootDataDir
+			}
+			isHealthy = status.ClusterInfo.Healthy
+		}
+	}
+	localClusters, err := listLocalClusters(app, clustersToList)
+	if err != nil {
+		return fmt.Errorf("failed to list local clusters: %w", err)
+	}
+	if clusterName != "" {
+		ux.Logger.PrintToUser("%s %s", logging.LightBlue.Wrap("Local cluster:"), logging.Green.Wrap(clusterName))
+	} else {
+		ux.Logger.PrintToUser(logging.LightBlue.Wrap("Local clusters:"))
+	}
+	for clusterName, rootDir := range localClusters {
+		currenlyRunning := ""
+		healthStatus := ""
+		if rootDir == currentlyRunningRootDir {
+			currenlyRunning = fmt.Sprintf(" [%s]", logging.Blue.Wrap("Running"))
+			if isHealthy {
+				healthStatus = fmt.Sprintf(" [%s]", logging.Green.Wrap("Healthy"))
+			} else {
+				healthStatus = fmt.Sprintf(" [%s]", logging.Red.Wrap("Unhealthy"))
+			}
+		} else {
+			currenlyRunning = fmt.Sprintf(" [%s]", logging.Black.Wrap("Stopped"))
+		}
+		ux.Logger.PrintToUser("- %s: %s %s %s", clusterName, rootDir, currenlyRunning, healthStatus)
+	}
+
+	return nil
+}