feat: Add edge commands

.gitignore

@@ -8,6 +8,7 @@
 # Testing files
 context.yaml
 workspace.yaml
+cloud-config.yaml
 
 # Build files and binaries
 dist/
@@ -19,6 +20,7 @@ testout/
 *.so
 *.o
 *.dylib
+*.img
 __debug_bin
 
 # Test binary, built with `go test -c`

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/bootstrap.go

@@ -0,0 +1,98 @@
+package edge
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	gqlclient "github.com/pluralsh/console/go/client"
+	"github.com/pluralsh/plural-cli/pkg/utils"
+	"github.com/samber/lo"
+	"github.com/urfave/cli"
+	"k8s.io/apimachinery/pkg/util/wait"
+)
+
+func (p *Plural) handleEdgeBootstrap(c *cli.Context) error {
+	machineID := c.String("machine-id")
+
+	if err := p.InitConsoleClient(consoleToken, consoleURL); err != nil {
+		return err
+	}
+
+	utils.Highlight("registering new cluster on %s machine\n", machineID)
+	if _, err := p.ConsoleClient.CreateClusterRegistration(gqlclient.ClusterRegistrationCreateAttributes{MachineID: machineID}); err != nil {
+		if !strings.Contains(err.Error(), "machine_id has already been taken") {
+			return err
+		}
+		utils.Highlight("cluster registration already exists\n")
+	}
+
+	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", lo.FromPtr(registration.Name))
+	cluster, err := p.ConsoleClient.CreateCluster(*clusterAttributes)
+	if err != nil {
+		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", lo.FromPtr(registration.Name), p.ConsoleClient.Url())
+	return p.DoInstallOperator(url, *cluster.CreateCluster.DeployToken, "")
+}
+
+func (p *Plural) getClusterAttributes(registration *gqlclient.ClusterRegistrationFragment) (*gqlclient.ClusterAttributes, error) {
+	attributes := gqlclient.ClusterAttributes{
+		Handle: registration.Handle,
+	}
+
+	if registration.Name != nil {
+		attributes.Name = *registration.Name
+	}
+
+	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/edge/edge.go

@@ -0,0 +1,110 @@
+package edge
+
+import (
+	"github.com/pluralsh/plural-cli/pkg/client"
+	"github.com/urfave/cli"
+	"helm.sh/helm/v3/pkg/action"
+)
+
+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:  "output-dir",
+					Usage: "output directory where the image will be stored",
+					Value: "image",
+				},
+				cli.StringFlag{
+					Name:  "project",
+					Usage: "name of the project to use",
+					Value: "default",
+				},
+				cli.StringFlag{
+					Name:  "user",
+					Usage: "email of the user to be the user identity for bootstrap token in audit logs",
+				},
+				cli.StringFlag{
+					Name:  "plural-config",
+					Usage: "optional path to plural configuration file",
+				},
+				cli.StringFlag{
+					Name:  "cloud-config",
+					Usage: "optional path to cloud configuration file, if provided templating will be skipped",
+				},
+				cli.StringFlag{
+					Name:  "username",
+					Usage: "name for the initial user account, used during cloud config templating",
+					Value: "plural",
+				},
+				cli.StringFlag{
+					Name:  "password",
+					Usage: "password for the initial user account, used during cloud config templating",
+				},
+				cli.StringFlag{
+					Name:  "wifi-ssid",
+					Usage: "ssid of the wifi network, needs to be used with wifi-password, used during cloud config templating",
+				},
+				cli.StringFlag{
+					Name:  "wifi-password",
+					Usage: "password for the wifi network, needs to be used with wifi-ssid, used during cloud config templating",
+				},
+			},
+		},
+		{
+			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,
+				},
+			},
+		},
+	}
+}