feat: Add edge commands

cmd/command/cd/cd.go

@@ -3,19 +3,15 @@ package cd
 import (
 	"fmt"
 	"os"
-	"strings"
 
 	"github.com/pluralsh/plural-cli/pkg/cd"
 	"github.com/pluralsh/plural-cli/pkg/client"
 	"github.com/pluralsh/plural-cli/pkg/common"
 	"github.com/pluralsh/plural-cli/pkg/config"
 	"github.com/pluralsh/plural-cli/pkg/console"
 	"github.com/pluralsh/plural-cli/pkg/utils"
-	"github.com/pluralsh/polly/algorithms"
 	"github.com/urfave/cli"
 	"helm.sh/helm/v3/pkg/action"
-	apierrors "k8s.io/apimachinery/pkg/api/errors"
-	"sigs.k8s.io/yaml"
 )
 
 func init() {
@@ -140,7 +136,7 @@ func (p *Plural) handleInstallDeploymentsOperator(c *cli.Context) error {
 	// we don't care if this fails to init as this command can be auth-less
 	_ = p.InitConsoleClient(consoleToken, consoleURL)
 
-	return p.doInstallOperator(c.String("url"), c.String("token"), c.String("values"))
+	return p.DoInstallOperator(c.String("url"), c.String("token"), c.String("values"))
 }
 
 func (p *Plural) handleUninstallOperator(_ *cli.Context) error {
@@ -151,54 +147,6 @@ func (p *Plural) handleUninstallOperator(_ *cli.Context) error {
 	return console.UninstallAgent(console.OperatorNamespace)
 }
 
-func (p *Plural) doInstallOperator(url, token, values string) error {
-	err := p.InitKube()
-	if err != nil {
-		return err
-	}
-	alreadyExists, err := console.IsAlreadyAgentInstalled(p.Kube.GetClient())
-	if err != nil {
-		return err
-	}
-	if alreadyExists && !common.Confirm("the deployment operator is already installed. Do you want to replace it", "PLURAL_INSTALL_AGENT_CONFIRM_IF_EXISTS") {
-		utils.Success("deployment operator is already installed, skip installation\n")
-		return nil
-	}
-
-	err = p.Kube.CreateNamespace(console.OperatorNamespace, false)
-	if err != nil && !apierrors.IsAlreadyExists(err) {
-		return err
-	}
-
-	vals := map[string]interface{}{}
-	globalVals := map[string]interface{}{}
-	version := ""
-
-	if p.ConsoleClient != nil {
-		settings, err := p.ConsoleClient.GetGlobalSettings()
-		if err == nil && settings != nil {
-			version = strings.Trim(settings.AgentVsn, "v")
-			if settings.AgentHelmValues != nil {
-				if err := yaml.Unmarshal([]byte(*settings.AgentHelmValues), &globalVals); err != nil {
-					return err
-				}
-			}
-		}
-	}
-
-	if values != "" {
-		if err := utils.YamlFile(values, &vals); err != nil {
-			return err
-		}
-	}
-	vals = algorithms.Merge(vals, globalVals)
-	err = console.InstallAgent(url, token, console.OperatorNamespace, version, vals)
-	if err == nil {
-		utils.Success("deployment operator installed successfully\n")
-	}
-	return err
-}
-
 func confirmCluster(url, token string) (bool, error) {
 	consoleClient, err := console.NewConsoleClient(token, url)
 	if err != nil {

cmd/command/cd/cd_clusters.go

@@ -415,22 +415,6 @@ func (p *Plural) handleClusterReinstall(c *cli.Context) error {
 	return p.ReinstallOperator(c, id, name)
 }
 
-func (p *Plural) ReinstallOperator(c *cli.Context, id, handle *string) error {
-	deployToken, err := p.ConsoleClient.GetDeployToken(id, handle)
-	if err != nil {
-		return err
-	}
-
-	url := p.ConsoleClient.ExtUrl()
-	if cluster, err := p.ConsoleClient.GetCluster(id, handle); err == nil {
-		if agentUrl, err := p.ConsoleClient.AgentUrl(cluster.ID); err == nil {
-			url = agentUrl
-		}
-	}
-
-	return p.doInstallOperator(url, deployToken, c.String("values"))
-}
-
 func (p *Plural) handleClusterBootstrap(c *cli.Context) error {
 	if err := p.InitConsoleClient(consoleToken, consoleURL); err != nil {
 		return err
@@ -444,7 +428,7 @@ func (p *Plural) handleClusterBootstrap(c *cli.Context) error {
 	if c.String("project") != "" {
 		project, err := p.ConsoleClient.GetProject(c.String("project"))
 		if err != nil {
-			return nil
+			return err
 		}
 		if project == nil {
 			return fmt.Errorf("Could not find project %s", c.String("project"))
@@ -491,5 +475,5 @@ func (p *Plural) handleClusterBootstrap(c *cli.Context) error {
 
 	deployToken := *existing.CreateCluster.DeployToken
 	utils.Highlight("installing agent on %s with url %s\n", c.String("name"), p.ConsoleClient.Url())
-	return p.doInstallOperator(url, deployToken, c.String("values"))
+	return p.DoInstallOperator(url, deployToken, c.String("values"))
 }

cmd/command/edge/edge.go

@@ -0,0 +1,243 @@
+package edge
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	gqlclient "github.com/pluralsh/console/go/client"
+	"github.com/pluralsh/plural-cli/pkg/client"
+	"github.com/pluralsh/plural-cli/pkg/console/errors"
+	"github.com/pluralsh/plural-cli/pkg/utils"
+	"github.com/samber/lo"
+	"github.com/urfave/cli"
+	"helm.sh/helm/v3/pkg/action"
+	"k8s.io/apimachinery/pkg/util/wait"
+)
+
+var consoleToken string
+var consoleURL string
+
+type Plural struct {
+	client.Plural
+	HelmConfiguration *action.Configuration
+}
+
+func init() {
+	consoleToken = ""
+	consoleURL = ""
+}
+
+func Command(clients client.Plural, helmConfiguration *action.Configuration) cli.Command {
+	return cli.Command{
+		Name:        "edge",
+		Usage:       "manage edge clusters",
+		Subcommands: Commands(clients, helmConfiguration),
+		Flags: []cli.Flag{
+			cli.StringFlag{
+				Name:        "token",
+				Usage:       "console token",
+				EnvVar:      "PLURAL_CONSOLE_TOKEN",
+				Destination: &consoleToken,
+			},
+			cli.StringFlag{
+				Name:        "url",
+				Usage:       "console url address",
+				EnvVar:      "PLURAL_CONSOLE_URL",
+				Destination: &consoleURL,
+			},
+		},
+		Category: "Edge",
+	}
+}
+
+func Commands(clients client.Plural, helmConfiguration *action.Configuration) []cli.Command {
+	p := Plural{
+		HelmConfiguration: helmConfiguration,
+		Plural:            clients,
+	}
+	return []cli.Command{
+		{
+			Name:   "image",
+			Action: p.handleEdgeImage,
+			Usage:  "prepares image ready to be used on Raspberry Pi 4",
+			Flags: []cli.Flag{
+				cli.StringFlag{
+					Name:     "username",
+					Usage:    "name for the initial user account",
+					Required: true,
+				},
+				cli.StringFlag{
+					Name:     "password",
+					Usage:    "password for the initial user account",
+					Required: true,
+				},
+			},
+		},
+		{
+			Name:   "bootstrap",
+			Action: p.handleEdgeBootstrap,
+			Usage:  "registers edge cluster and installs agent onto it using the current kubeconfig",
+			Flags: []cli.Flag{
+				cli.StringFlag{
+					Name:     "machine-id",
+					Usage:    "the unique id of the edge device on which this cluster runs",
+					Required: true,
+				},
+				cli.StringFlag{
+					Name:     "project",
+					Usage:    "the project this cluster will belong to",
+					Required: false,
+				},
+			},
+		},
+	}
+}
+
+func (p *Plural) handleEdgeImage(c *cli.Context) error {
+	username := c.String("username")
+	password := c.String("password")
+
+	cloudConfig, err := p.getCloudConfig(username, password)
+	if err != nil {
+		return err
+	}
+
+	fmt.Println(cloudConfig) // TODO
+
+	return nil
+}
+
+func (p *Plural) getCloudConfig(username, password string) (string, error) {
+	response, err := http.Get("https://raw.githubusercontent.com/pluralsh/edge/main/hack/cloud-config.yaml")
+	if err != nil {
+		return "", err
+	}
+
+	defer response.Body.Close()
+	buffer := new(bytes.Buffer)
+	if _, err = buffer.ReadFrom(response.Body); err != nil {
+		return "", err
+	}
+
+	template := buffer.String()
+	template = strings.ReplaceAll(template, "@USERNAME@", username)
+	template = strings.ReplaceAll(template, "@PASSWORD@", password)
+	template = strings.ReplaceAll(template, "@URL@", consoleURL)
+	template = strings.ReplaceAll(template, "@TOKEN@", consoleToken)
+
+	return template, nil
+}
+
+func (p *Plural) handleEdgeBootstrap(c *cli.Context) error {
+	machineID := c.String("machine-id")
+	project := c.String("project")
+
+	if err := p.InitConsoleClient(consoleToken, consoleURL); err != nil {
+		return err
+	}
+
+	registrationAttributes, err := p.getClusterRegistrationAttributes(machineID, project)
+	if err != nil {
+		return err
+	}
+
+	utils.Highlight("registering new cluster on %s machine\n", machineID)
+	_, err = p.ConsoleClient.CreateClusterRegistration(*registrationAttributes) // TODO: Handle the case when it already exists, i.e. after reboot.
+	if err != nil {
+		return err
+	}
+
+	utils.Highlight("waiting for registration to be completed\n")
+	var complete bool
+	var registration *gqlclient.ClusterRegistrationFragment
+	_ = wait.PollUntilContextCancel(context.Background(), 30*time.Second, true, func(_ context.Context) (done bool, err error) {
+		complete, registration = p.ConsoleClient.IsClusterRegistrationComplete(machineID)
+		return complete, nil
+	})
+
+	clusterAttributes, err := p.getClusterAttributes(registration)
+	if err != nil {
+		return err
+	}
+
+	utils.Highlight("creating %s cluster\n", registration.Name)
+	cluster, err := p.ConsoleClient.CreateCluster(*clusterAttributes)
+	if err != nil {
+		if errors.Like(err, "handle") {
+			handle := lo.ToPtr(clusterAttributes.Name)
+			if clusterAttributes.Handle != nil {
+				handle = clusterAttributes.Handle
+			}
+			return p.ReinstallOperator(c, nil, handle)
+		}
+		return err
+	}
+
+	if cluster.CreateCluster.DeployToken == nil {
+		return fmt.Errorf("could not fetch deploy token from cluster")
+	}
+
+	url := p.ConsoleClient.ExtUrl()
+	if agentUrl, err := p.ConsoleClient.AgentUrl(cluster.CreateCluster.ID); err == nil {
+		url = agentUrl
+	}
+
+	utils.Highlight("installing agent on %s cluster with %s URL\n", registration.Name, p.ConsoleClient.Url())
+	return p.DoInstallOperator(url, *cluster.CreateCluster.DeployToken, "")
+}
+
+func (p *Plural) getClusterRegistrationAttributes(machineID, project string) (*gqlclient.ClusterRegistrationCreateAttributes, error) {
+	attributes := gqlclient.ClusterRegistrationCreateAttributes{MachineID: machineID}
+
+	if project != "" {
+		proj, err := p.ConsoleClient.GetProject(project)
+		if err != nil {
+			return nil, err
+		}
+		if proj == nil {
+			return nil, fmt.Errorf("cannot find %s project", project)
+		}
+		attributes.ProjectID = lo.ToPtr(proj.ID)
+	}
+
+	return &attributes, nil
+}
+
+func (p *Plural) getClusterAttributes(registration *gqlclient.ClusterRegistrationFragment) (*gqlclient.ClusterAttributes, error) {
+	attributes := gqlclient.ClusterAttributes{
+		Name:   registration.Name,
+		Handle: &registration.Handle,
+	}
+
+	if registration.Tags != nil {
+		attributes.Tags = lo.Map(registration.Tags, func(tag *gqlclient.ClusterTags, index int) *gqlclient.TagAttributes {
+			if tag == nil {
+				return nil
+			}
+
+			return &gqlclient.TagAttributes{
+				Name:  tag.Name,
+				Value: tag.Value,
+			}
+		})
+	}
+
+	if registration.Metadata != nil {
+		metadata, err := json.Marshal(registration.Metadata)
+		if err != nil {
+			return nil, err
+		}
+		attributes.Metadata = lo.ToPtr(string(metadata))
+	}
+
+	if registration.Project != nil {
+		attributes.ProjectID = &registration.Project.ID
+	}
+
+	return &attributes, nil
+}

cmd/command/plural/plural.go

@@ -8,6 +8,7 @@ import (
 	"github.com/pluralsh/plural-cli/cmd/command/config"
 	cryptocmd "github.com/pluralsh/plural-cli/cmd/command/crypto"
 	"github.com/pluralsh/plural-cli/cmd/command/down"
+	"github.com/pluralsh/plural-cli/cmd/command/edge"
 	cmdinit "github.com/pluralsh/plural-cli/cmd/command/init"
 	"github.com/pluralsh/plural-cli/cmd/command/mgmt"
 	"github.com/pluralsh/plural-cli/cmd/command/pr"
@@ -108,6 +109,7 @@ func CreateNewApp(plural *Plural) *cli.App {
 		cryptocmd.Command(plural.Plural),
 		clone.Command(),
 		down.Command(),
+		edge.Command(plural.Plural, plural.HelmConfiguration),
 		mgmt.Command(plural.Plural),
 		profile.Command(),
 		stacks.Command(plural.Plural),

go.mod

@@ -39,7 +39,7 @@ require (
 	github.com/olekukonko/tablewriter v0.0.5
 	github.com/packethost/packngo v0.31.0
 	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c
-	github.com/pluralsh/console/go/client v1.25.4
+	github.com/pluralsh/console/go/client v1.26.0
 	github.com/pluralsh/console/go/controller v0.0.0-20250106171545-b65ee8bd2d2e
 	github.com/pluralsh/gqlclient v1.12.2
 	github.com/pluralsh/plural-operator v0.5.5