cmd

Documentation

Index

• Variables
• func Execute()

Variables

var ClusterAddCmd = &cobra.Command{
	Use:     "add [NAME] [ENDPOINT]",
	Short:   "Add cluster",
	Example: clusterAddExample,
	Args:    cobra.ExactArgs(2),
	PreRunE: func(cmd *cobra.Command, args []string) error {
		local, _ := cmd.Flags().GetBool("local")
		if !local {
			return errors.New("method allowed with local flag")
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {

		name := args[0]
		endpoint := args[1]

		local, err := cmd.Flags().GetBool("local")
		if err != nil {
			panic(err)
		}

		token, err := cmd.Flags().GetString("token")
		if err != nil {
			panic(err)
		}

		err = storage.AddLocalCluster(name, endpoint, token, local)
		switch true {
		case err == nil:
		case err.Error() == "already exists":
			fmt.Println(fmt.Sprintf("Cluster `%s` already exists", name))
		default:
			panic(err)
		}

	},
}

var ClusterDelCmd = &cobra.Command{
	Use:     "del [NAME]",
	Short:   "Remove cluster",
	Example: clusterDelExample,
	Args:    cobra.ExactArgs(1),
	PreRunE: func(cmd *cobra.Command, args []string) error {
		local, _ := cmd.Flags().GetBool("local")
		if !local {
			return errors.New("method allowed with local flag")
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]

		err := storage.DelLocalCluster(name)
		if err != nil {
			panic(err)
		}

	},
}

var ClusterInspectCmd = &cobra.Command{
	Use:     "inspect",
	Short:   "Get cluster info",
	Example: clusterInspectExample,
	Args:    cobra.NoArgs,
	Run: func(_ *cobra.Command, _ []string) {
		cli := envs.Get().GetClient()
		response, err := cli.Cluster.V1().Cluster().Get(envs.Background())
		if err != nil {
			fmt.Println(err)
			return
		}
		view.FromLbApiClusterView(response).Print()
	},
}

var ClusterListCmd = &cobra.Command{
	Use:     "ls",
	Short:   "Get available cluster list",
	Example: clusterListExample,
	Args:    cobra.NoArgs,
	Run: func(cmd *cobra.Command, args []string) {

		fmt.Println("Remotely clusters list:")

		cli := envs.Get().GetClient()

		ritems, err := cli.Genesis.V1().Cluster().List(envs.Background())
		if err != nil {
			fmt.Println(err)
		}

		vg := view.FromGenesisApiClusterListView(ritems)
		vg.Print()

		fmt.Print("\n")
		fmt.Println("Locally clusters list:")

		litems, err := storage.ListLocalCluster()
		if err != nil {
			fmt.Println(err)
			return
		}

		vs := view.FromStorageClusterList(litems)
		vs.Print()
	},
}

var ClusterSelectCmd = &cobra.Command{
	Use:     "select [NAME]",
	Short:   "Select cluster",
	Example: clusterSelectExample,
	PreRunE: func(cmd *cobra.Command, args []string) error {
		if len(args) < 1 {
			return cmd.Help()
		}
		return nil
	},
	Run: func(cmd *cobra.Command, args []string) {

		name := args[0]

		local, _ := cmd.Flags().GetBool("local")
		if local {

			item, err := storage.GetLocalCluster(name)
			if err != nil {
				fmt.Println(err)
			}

			if item == nil {
				fmt.Println(fmt.Sprintf("Cluster `%s` not found", name))
			}

			err = storage.SetCluster(fmt.Sprintf("l.%s", item.Name))
			if err != nil {
				fmt.Println(err)
			}

			fmt.Println(fmt.Sprintf("Cluster `%s` selected", name))

			return
		}

		cli := envs.Get().GetClient()

		cl, err := cli.Genesis.V1().Cluster().Get(envs.Background(), name)
		if err != nil {
			fmt.Println(err)
			return
		}

		if cl == nil {
			fmt.Println(fmt.Sprintf("Cluster `%s` not found", name))
			return
		}

		err = storage.SetCluster(fmt.Sprintf("r.%s", cl.Meta.SelfLink))
		if err != nil {
			panic(err)
		}

		fmt.Println(fmt.Sprintf("Cluster `%s` selected", name))
	},
}

var RootCmd = &cobra.Command{
	Use:   "lb",
	Short: "Apps cloud hosting with integrated deployment tools",
	PersistentPreRun: func(cmd *cobra.Command, args []string) {

		var err error

		cfg.Debug, err = cmd.Flags().GetBool("debug")
		if err != nil {
			fmt.Println("Invalid debug flag")
			return
		}

		token, err := storage.GetToken()
		if err != nil {
			fmt.Println("There is no token in .lastbackend in homedir")
			return
		}

		if cmd.Flag("token").Value != nil && len(cmd.Flag("token").Value.String()) != 0 {
			token = cmd.Flag("token").Value.String()
		}

		host := defaultHost
		config := &client.Config{Token: token}

		tls, err := cmd.Flags().GetBool("tls")
		if err != nil {
			fmt.Println("Invalid tls flag")
			return
		}

		if tls {
			config.TLS = new(client.TLSConfig)
			config.TLS.Insecure = false
			config.TLS.CAFile = cmd.Flag("tlscacert").Value.String()
			config.TLS.CertFile = cmd.Flag("tlscert").Value.String()
			config.TLS.KeyFile = cmd.Flag("tlskey").Value.String()
		}

		cli := &client.Client{}
		cli.Genesis = client.NewGenesisCluster(host, config)
		cli.Registry = client.NewRegistryClient(host, config)

		config.Headers = make(map[string]string, 0)

		cn := cmd.Flag("cluster").Value.String()
		if len(cn) != 0 {
			match := strings.Split(cn, ":")

			switch len(match) {
			case 1:
				cluster, err := storage.GetLocalCluster(cn)
				if err != nil {
					panic(err)
				}
				if cluster == nil {
					fmt.Println("cluster not found")
					return
				}
				host = cluster.Endpoint
			case 2:
				config.Headers["X-Cluster-Name"] = cn
			default:
				fmt.Println("invalid data")
				return

			}

			cli.Cluster = client.NewClusterClient(host, config)
			ctx.SetClient(cli)
			return
		}

		cluster, err := storage.GetCluster()
		if err != nil {
			panic(err)
		}

		if cluster != "" {
			switch cluster[:2] {
			case "l.":
				cluster, err := storage.GetLocalCluster(cluster[2:])
				if err != nil {
					log.Error(err.Error())
					return
				}
				if cluster == nil {
					fmt.Println("can not read cluster info: check cache data ($HOME/.lastbackend)")
					return
				}
				host = cluster.Endpoint
			case "r.":
				config.Headers = make(map[string]string, 0)
				config.Headers["X-Cluster-Name"] = cluster[2:]
			default:
				fmt.Println("can not read cluster info: check cache data ($HOME/.lastbackend)")
			}
		}

		cli.Cluster = client.NewClusterClient(host, config)
		ctx.SetClient(cli)
	},
}

RootCmd represents the base command when called without any subcommands

Functions

func Execute

func Execute()

Execute adds all child commands to the root command