add connect, create & use commands

Author: FabianKramm

cmd/connect/cluster.go

@@ -0,0 +1,83 @@
+package connect
+
+import (
+	"github.com/devspace-cloud/devspace-cloud-plugin/pkg/cloud"
+	"github.com/devspace-cloud/devspace-cloud-plugin/pkg/factory"
+
+	"github.com/mgutz/ansi"
+	"github.com/spf13/cobra"
+)
+
+type clusterCmd struct {
+	Provider string
+
+	UseHostNetwork bool
+	Options        *cloud.ConnectClusterOptions
+}
+
+func newClusterCmd(f factory.Factory) *cobra.Command {
+	cmd := &clusterCmd{
+		Options: &cloud.ConnectClusterOptions{},
+	}
+
+	clusterCmd := &cobra.Command{
+		Use:   "cluster",
+		Short: "Connects an existing cluster to DevSpace Cloud",
+		Long: `
+#######################################################
+############ devspace connect cluster #################
+#######################################################
+Connects an existing cluster to DevSpace Cloud.
+
+Examples:
+devspace connect cluster 
+#######################################################
+	`,
+		Args: cobra.NoArgs,
+		RunE: func(cobraCmd *cobra.Command, args []string) error {
+			return cmd.RunConnectCluster(f, cobraCmd, args)
+		}}
+
+	clusterCmd.Flags().StringVar(&cmd.Provider, "provider", "", "The cloud provider to use")
+
+	clusterCmd.Flags().BoolVar(&cmd.Options.DeployAdmissionController, "admission-controller", true, "Deploy the admission controller")
+	clusterCmd.Flags().BoolVar(&cmd.Options.DeployGatekeeper, "gatekeeper", false, "Deploy the gatekeeper")
+	clusterCmd.Flags().BoolVar(&cmd.Options.DeployGatekeeperRules, "gatekeeper-rules", false, "Deploy the gatekeeper default rules")
+	clusterCmd.Flags().BoolVar(&cmd.Options.DeployIngressController, "ingress-controller", true, "Deploy an ingress controller")
+	clusterCmd.Flags().BoolVar(&cmd.UseHostNetwork, "use-hostnetwork", false, "Use the host network for the ingress controller instead of a loadbalancer")
+	clusterCmd.Flags().BoolVar(&cmd.Options.DeployCertManager, "cert-manager", true, "Deploy a cert manager")
+	clusterCmd.Flags().BoolVar(&cmd.Options.Public, "public", false, "Connects a new public cluster")
+	clusterCmd.Flags().StringVar(&cmd.Options.KubeContext, "context", "", "The kube context to use")
+	clusterCmd.Flags().StringVar(&cmd.Options.Key, "key", "", "The encryption key to use")
+	clusterCmd.Flags().StringVar(&cmd.Options.ClusterName, "name", "", "The cluster name to create")
+
+	clusterCmd.Flags().BoolVar(&cmd.Options.OpenUI, "open-ui", false, "Opens the UI and displays the cluster overview")
+	clusterCmd.Flags().BoolVar(&cmd.Options.UseDomain, "use-domain", false, "Use an automatic domain for the cluster")
+	clusterCmd.Flags().StringVar(&cmd.Options.Domain, "domain", "", "The domain to use")
+
+	return clusterCmd
+}
+
+// RunConnectCluster executes the connect cluster command logic
+func (cmd *clusterCmd) RunConnectCluster(f factory.Factory, cobraCmd *cobra.Command, args []string) error {
+	log := f.GetLog()
+	// Get provider
+	provider, err := f.GetProvider(cmd.Provider, log)
+	if err != nil {
+		return err
+	}
+
+	// Check if use host network was used
+	if cobraCmd.Flags().Changed("use-hostnetwork") {
+		cmd.Options.UseHostNetwork = &cmd.UseHostNetwork
+	}
+
+	// Connect cluster
+	err = provider.ConnectCluster(cmd.Options)
+	if err != nil {
+		return err
+	}
+
+	log.Donef("Successfully connected cluster to DevSpace Cloud. \n\nYou can now run:\n- `%s` to create a new space\n- `%s` to list all connected clusters", ansi.Color("devspace create space [NAME]", "white+b"), ansi.Color("devspace list clusters", "white+b"))
+	return nil
+}

cmd/connect/connect.go

@@ -0,0 +1,25 @@
+package connect
+
+import (
+	"github.com/devspace-cloud/devspace-cloud-plugin/pkg/factory"
+
+	"github.com/spf13/cobra"
+)
+
+// NewConnectCmd creates a new cobra command
+func NewConnectCmd(f factory.Factory) *cobra.Command {
+	connectCmd := &cobra.Command{
+		Use:   "connect",
+		Short: "Connect an external cluster to devspace cloud",
+		Long: `
+#######################################################
+################# devspace connect ####################
+#######################################################
+	`,
+		Args: cobra.NoArgs,
+	}
+
+	connectCmd.AddCommand(newClusterCmd(f))
+
+	return connectCmd
+}

cmd/create/create.go

@@ -0,0 +1,24 @@
+package create
+
+import (
+	"github.com/devspace-cloud/devspace-cloud-plugin/pkg/factory"
+	"github.com/spf13/cobra"
+)
+
+// NewCreateCmd creates a new cobra command
+func NewCreateCmd(f factory.Factory) *cobra.Command {
+	createCmd := &cobra.Command{
+		Use:   "create",
+		Short: "Create spaces in the cloud",
+		Long: `
+#######################################################
+################## devspace create ####################
+#######################################################
+	`,
+		Args: cobra.NoArgs,
+	}
+
+	createCmd.AddCommand(newSpaceCmd(f))
+
+	return createCmd
+}

cmd/create/space.go

@@ -0,0 +1,259 @@
+package create
+
+import (
+	"github.com/devspace-cloud/devspace-cloud-plugin/cmd/use"
+	"github.com/devspace-cloud/devspace-cloud-plugin/pkg/cloud"
+	"github.com/devspace-cloud/devspace-cloud-plugin/pkg/cloud/config/versions/latest"
+	"github.com/devspace-cloud/devspace-cloud-plugin/pkg/factory"
+
+	"github.com/devspace-cloud/devspace/pkg/devspace/config/loader"
+	"github.com/devspace-cloud/devspace/pkg/util/log"
+	"github.com/devspace-cloud/devspace/pkg/util/survey"
+	"sort"
+
+	"github.com/mgutz/ansi"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+// DevSpaceCloudHostedCluster is the option that is shown during cluster select to select the hosted devspace cloud clusters
+const DevSpaceCloudHostedCluster = "Clusters managed by DevSpace"
+
+type SpaceCmd struct {
+	Active   bool
+	Provider string
+	Cluster  string
+}
+
+func newSpaceCmd(f factory.Factory) *cobra.Command {
+	cmd := &SpaceCmd{}
+
+	SpaceCmd := &cobra.Command{
+		Use:   "space",
+		Short: "Create a new cloud space",
+		Long: `
+#######################################################
+############### devspace create space #################
+#######################################################
+Creates a new space
+
+Example:
+devspace create space myspace
+#######################################################
+	`,
+		Args: cobra.ExactArgs(1),
+		RunE: func(cobraCmd *cobra.Command, args []string) error {
+			return cmd.RunCreateSpace(f, cobraCmd, args)
+		},
+	}
+
+	SpaceCmd.Flags().BoolVar(&cmd.Active, "active", true, "Use the new Space as active Space for the current project")
+	SpaceCmd.Flags().StringVar(&cmd.Provider, "provider", "", "The cloud provider to use")
+	SpaceCmd.Flags().StringVar(&cmd.Cluster, "cluster", "", "The cluster to create a space in")
+
+	return SpaceCmd
+}
+
+// RunCreateSpace executes the "devspace create space" command logic
+func (cmd *SpaceCmd) RunCreateSpace(f factory.Factory, cobraCmd *cobra.Command, args []string) error {
+	// Set config root
+	logger := f.GetLog()
+	configLoader := loader.NewConfigLoader(nil, logger)
+	configExists, err := configLoader.SetDevSpaceRoot()
+	if err != nil {
+		return err
+	}
+
+	// Get provider
+	provider, err := f.GetProvider(cmd.Provider, logger)
+	if err != nil {
+		return err
+	}
+
+	logger.StartWait("Retrieving clusters")
+	defer logger.StopWait()
+
+	// Get projects
+	projects, err := provider.Client().GetProjects()
+	if err != nil {
+		return errors.Wrap(err, "get projects")
+	}
+
+	// Create project if needed
+	projectID := 0
+	if len(projects) == 0 {
+		projectID, err = createProject(provider)
+		if err != nil {
+			return err
+		}
+	} else {
+		projectID = projects[0].ProjectID
+	}
+
+	var cluster *latest.Cluster
+	if cmd.Cluster == "" {
+		cluster, err = getCluster(provider, logger)
+		if err != nil {
+			return err
+		}
+	} else {
+		cluster, err = provider.Client().GetClusterByName(cmd.Cluster)
+		if err != nil {
+			return err
+		}
+	}
+
+	logger.StartWait("Creating space " + args[0])
+	defer logger.StopWait()
+
+	key, err := provider.GetClusterKey(cluster)
+	if err != nil {
+		return errors.Wrap(err, "get cluster key")
+	}
+
+	// Create space
+	spaceID, err := provider.Client().CreateSpace(args[0], key, projectID, cluster)
+	if err != nil {
+		return errors.Wrap(err, "create space")
+	}
+
+	// Get Space
+	space, err := provider.Client().GetSpace(spaceID)
+	if err != nil {
+		return errors.Wrap(err, "get space")
+	}
+
+	// Get service account
+	serviceAccount, err := provider.Client().GetServiceAccount(space, key)
+	if err != nil {
+		return errors.Wrap(err, "get serviceaccount")
+	}
+
+	// Change kube context
+	kubeContext := cloud.GetKubeContextNameFromSpace(space.Name, space.ProviderName)
+	err = provider.UpdateKubeConfig(kubeContext, serviceAccount, spaceID, true)
+	if err != nil {
+		return errors.Wrap(err, "update kube context")
+	}
+
+	// Cache space
+	err = provider.CacheSpace(space, serviceAccount)
+	if err != nil {
+		return err
+	}
+
+	logger.StopWait()
+	logger.Infof("Successfully created space %s", space.Name)
+	logger.Infof("Your kubectl context has been updated automatically.")
+
+	if configExists {
+		logger.Infof("\r         \nYou can now run: \n- `%s` to deploy the app to the cloud\n- `%s` to develop the app in the cloud\n", ansi.Color("devspace deploy", "white+b"), ansi.Color("devspace dev", "white+b"))
+	}
+
+	// clear project kube context
+	err = use.ClearProjectKubeContext(configLoader)
+	if err != nil {
+		return errors.Wrap(err, "clear generated kube context")
+	}
+
+	return nil
+}
+
+func getCluster(p cloud.Provider, logger log.Logger) (*latest.Cluster, error) {
+	clusters, err := p.Client().GetClusters()
+	if err != nil {
+		return nil, errors.Wrap(err, "get clusters")
+	}
+	if len(clusters) == 0 {
+		return nil, errors.New("Cannot create space, because no cluster was found")
+	}
+
+	logger.StopWait()
+
+	// Check if the user has access to a connected cluster
+	connectedClusters := make([]*latest.Cluster, 0, len(clusters))
+	for _, cluster := range clusters {
+		if cluster.Owner != nil {
+			connectedClusters = append(connectedClusters, cluster)
+		}
+	}
+
+	// Check if user has connected clusters
+	if len(connectedClusters) > 0 {
+		clusterNames := []string{}
+		for _, cluster := range connectedClusters {
+			clusterNames = append(clusterNames, cluster.Name)
+		}
+
+		sort.Strings(clusterNames)
+
+		// Check if there are non connected clusters
+		for _, cluster := range clusters {
+			if cluster.Owner == nil {
+				// Add devspace cloud option
+				clusterNames = append(clusterNames, DevSpaceCloudHostedCluster)
+				break
+			}
+		}
+		if len(clusterNames) == 1 {
+			return connectedClusters[0], nil
+		}
+
+		// Choose cluster
+		chosenCluster, err := logger.Question(&survey.QuestionOptions{
+			Question:     "Which cluster should the space created in?",
+			DefaultValue: clusterNames[0],
+			Options:      clusterNames,
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		if chosenCluster != DevSpaceCloudHostedCluster {
+			for _, cluster := range connectedClusters {
+				if cluster.Name == chosenCluster {
+					return cluster, nil
+				}
+			}
+		}
+	}
+
+	// Select a devspace cluster
+	devSpaceClusters := make([]*latest.Cluster, 0, len(clusters))
+	for _, cluster := range clusters {
+		if cluster.Owner == nil {
+			devSpaceClusters = append(devSpaceClusters, cluster)
+		}
+	}
+
+	if len(devSpaceClusters) == 1 {
+		return devSpaceClusters[0], nil
+	}
+
+	clusterNames := []string{}
+	for _, cluster := range devSpaceClusters {
+		clusterNames = append(clusterNames, cluster.Name)
+	}
+
+	// Choose cluster
+	chosenCluster, err := logger.Question(&survey.QuestionOptions{
+		Question:     "Which hosted DevSpace cluster should the space created in?",
+		DefaultValue: clusterNames[0],
+		Options:      clusterNames,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	for _, cluster := range devSpaceClusters {
+		if cluster.Name == chosenCluster {
+			return cluster, nil
+		}
+	}
+
+	return nil, errors.New("No cluster selected")
+}
+
+func createProject(p cloud.Provider) (int, error) {
+	return p.Client().CreateProject("default")
+}