first commit

cmd/backup.go

@@ -0,0 +1,69 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"os"
+	"path/filepath"
+	"playbookctl/internal/space_worker"
+	"playbookctl/internal/types"
+	"playbookctl/internal/utils/logger"
+)
+
+func NewCommandBackup() *cobra.Command {
+	backupCmd := &cobra.Command{
+		Use:               "backup [role1, role2, ...]",
+		Short:             "выполнить резервное копирование пространства",
+		Args:              backupCheckArgsE,
+		ValidArgsFunction: ArgRoleCompletion,
+		RunE:              backupRunE,
+	}
+
+	backupCmd.Flags().Uint8Var(&flagAnsibleVerbose, "ansible-verbose", 0, "ansible verbose mode (0-3)")
+	backupCmd.Flags().StringVar(&flagAnsibleBin, "ansible-bin", "/usr/bin/ansible-playbook", "путь к ansible-playbook")
+	backupCmd.Flags().BoolVar(&flagGenOnly, "generate-only", false, "только сгенерировать исполняемую команду")
+	backupCmd.Flags().StringVar(&flagTargetHost, "target", "", "имя целевого хоста")
+
+	if err := backupCmd.MarkFlagFilename("ansible-bin"); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	return backupCmd
+}
+
+func backupCheckArgsE(_ *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		return nil
+	}
+
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	playbook, err := types.ReadPlaybook(workDir)
+	if err != nil {
+		return err
+	}
+
+	for _, roleName := range args {
+		if !containsInSlice(roleName, playbook.Roles) {
+			return fmt.Errorf("роли \"%s\" не существует или она не добавлена в playbook.yml", roleName)
+		}
+	}
+
+	return nil
+}
+
+func backupRunE(_ *cobra.Command, args []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceWorker := space_worker.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	spaceWorker.AnsibleBin = flagAnsibleBin
+	spaceWorker.AnsibleVerbose = flagAnsibleVerbose
+	return spaceWorker.Backup(flagGenOnly, flagTargetHost, args...)
+}

cmd/hosts.go

@@ -0,0 +1,181 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"os"
+	"path/filepath"
+	"playbookctl/internal/space_worker"
+	"playbookctl/internal/types"
+	"playbookctl/internal/utils/logger"
+	"strconv"
+	"strings"
+)
+
+func NewCommandHosts() *cobra.Command {
+	hostsCmd := &cobra.Command{
+		Use:   "hosts",
+		Short: "работа с хостами",
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
+		},
+	}
+
+	hostsCmd.AddCommand(newCommandHostsList())
+	hostsCmd.AddCommand(newCommandHostsAdd())
+	hostsCmd.AddCommand(newCommandHostsRemove())
+	hostsCmd.AddCommand(newCommandHostsDefault())
+
+	return hostsCmd
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+func newCommandHostsList() *cobra.Command {
+	listCmd := &cobra.Command{
+		Use:     "list",
+		Aliases: []string{"ls"},
+		Short:   "список хостов",
+		RunE:    hostsListRunE,
+	}
+
+	return listCmd
+}
+
+func hostsListRunE(_ *cobra.Command, _ []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+	spaceWorker := space_worker.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	return spaceWorker.ListHosts()
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+func newCommandHostsAdd() *cobra.Command {
+	addCmd := &cobra.Command{
+		Use:     "add <name> <host[:port]> [user]",
+		Aliases: []string{"new"},
+		Short:   "добавить новый хост",
+		Args:    cobra.MinimumNArgs(2),
+		RunE:    hostsAddRunE,
+	}
+
+	return addCmd
+}
+
+func hostsAddRunE(_ *cobra.Command, args []string) error {
+	var (
+		name string
+		host string
+		port uint16
+		user string
+	)
+
+	name = args[0]
+
+	if idx := strings.Index(args[1], ":"); idx > 0 {
+		split := strings.Split(args[1], ":")
+		host = split[0]
+
+		parsedInt, err := strconv.ParseInt(split[1], 0, 16)
+		if err != nil {
+			return err
+		}
+		port = uint16(parsedInt)
+	} else {
+		host = args[1]
+		port = 22
+	}
+
+	if len(args) == 2 {
+		user = "root"
+	} else if len(args) == 3 {
+		user = args[2]
+	}
+
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceWorker := space_worker.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	return spaceWorker.HostsAdd(name, host, port, user)
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+func newCommandHostsRemove() *cobra.Command {
+	listCmd := &cobra.Command{
+		Use:               "remove <name>",
+		Aliases:           []string{"delete", "del", "rm"},
+		Short:             "удалить хост",
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: hostsRemoveValidateArgs,
+		RunE:              hostsRemoveRunE,
+	}
+
+	return listCmd
+}
+
+func hostsRemoveValidateArgs(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	exitApp := func(err error) {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	var suggestions []string
+
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		exitApp(err)
+	}
+
+	hosts, err := types.ReadHosts(workDir)
+	if err != nil {
+		exitApp(err)
+	}
+
+	for host := range *hosts {
+		if toComplete == "" || len(host) >= len(toComplete) && host[:len(toComplete)] == toComplete {
+			suggestions = append(suggestions, host)
+		}
+	}
+
+	return suggestions, cobra.ShellCompDirectiveDefault
+}
+
+func hostsRemoveRunE(_ *cobra.Command, args []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceWorker := space_worker.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	return spaceWorker.HostRemove(args[0])
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+func newCommandHostsDefault() *cobra.Command {
+	command := &cobra.Command{
+		Use:               "set-default",
+		Short:             "установка хоста по-умолчанию",
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: ArgHostCompletion,
+		RunE:              hostsDefaultRunE,
+	}
+
+	return command
+}
+
+func hostsDefaultRunE(_ *cobra.Command, args []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceWorker := space_worker.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	return spaceWorker.SetDefaultHost(args[0])
+}

cmd/install.go

@@ -0,0 +1,79 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"os"
+	"path/filepath"
+	"playbookctl/internal/space_worker"
+	"playbookctl/internal/types"
+	"playbookctl/internal/utils/logger"
+)
+
+func NewCommandInstall() *cobra.Command {
+	installCmd := &cobra.Command{
+		Use:               "install [role1, role2, ...]",
+		Short:             "применить настройки пространства к серверу",
+		Args:              installCheckArgsE,
+		ValidArgsFunction: ArgRoleCompletion,
+		RunE:              installRunE,
+	}
+
+	installCmd.Flags().Uint8Var(&flagAnsibleVerbose, "ansible-verbose", 0, "ansible verbose mode (0-3)")
+	installCmd.Flags().StringVar(&flagAnsibleBin, "ansible-bin", "/usr/bin/ansible-playbook", "путь к ansible-playbook")
+	installCmd.Flags().BoolVar(&flagGenOnly, "generate-only", false, "только сгенерировать исполняемую команду")
+	installCmd.Flags().StringVar(&flagTargetHost, "target", "", "имя целевого хоста")
+
+	if err := installCmd.MarkFlagFilename("ansible-bin"); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	return installCmd
+}
+
+func installCheckArgsE(_ *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		return nil
+	}
+
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	playbook, err := types.ReadPlaybook(workDir)
+	if err != nil {
+		return err
+	}
+
+	for _, roleName := range args {
+		if !containsInSlice(roleName, playbook.Roles) {
+			return fmt.Errorf("роли \"%s\" не существует или она не добавлена в playbook.yml", roleName)
+		}
+	}
+
+	return nil
+}
+
+func installRunE(_ *cobra.Command, args []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceWorker := space_worker.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	spaceWorker.AnsibleBin = flagAnsibleBin
+	spaceWorker.AnsibleVerbose = flagAnsibleVerbose
+	return spaceWorker.Install(flagGenOnly, flagTargetHost, args...)
+}
+
+func containsInSlice(element string, slice []string) bool {
+	for _, item := range slice {
+		if item == element {
+			return true
+		}
+	}
+
+	return false
+}

cmd/restore.go

@@ -0,0 +1,76 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"os"
+	"path/filepath"
+	"playbookctl/internal/space_worker"
+	"playbookctl/internal/types"
+	"playbookctl/internal/utils/logger"
+)
+
+var (
+	flagRestoreTimestamp string
+	flagRestoreInventory string
+)
+
+func NewCommandRestore() *cobra.Command {
+	restoreCmd := &cobra.Command{
+		Use:               "restore [role1, role2, ...]",
+		Short:             "восстановить резервную копированию пространства",
+		Args:              restoreCheckArgsE,
+		ValidArgsFunction: ArgRoleCompletion,
+		RunE:              restoreRunE,
+	}
+
+	restoreCmd.Flags().Uint8Var(&flagAnsibleVerbose, "ansible-verbose", 0, "ansible verbose mode (0-3)")
+	restoreCmd.Flags().StringVar(&flagAnsibleBin, "ansible-bin", "/usr/bin/ansible-playbook", "путь к ansible-playbook")
+	restoreCmd.Flags().BoolVar(&flagGenOnly, "generate-only", false, "только сгенерировать исполняемую команду")
+	restoreCmd.Flags().StringVar(&flagTargetHost, "target", "", "имя целевого хоста")
+	restoreCmd.Flags().StringVar(&flagRestoreTimestamp, "timestamp", "latest", "выбор времени бекапа")
+	restoreCmd.Flags().StringVar(&flagRestoreInventory, "inventory", "", "выбор хост бекапа")
+
+	if err := restoreCmd.MarkFlagFilename("ansible-bin"); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	return restoreCmd
+}
+
+func restoreCheckArgsE(_ *cobra.Command, args []string) error {
+	if len(args) == 0 {
+		return nil
+	}
+
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	playbook, err := types.ReadPlaybook(workDir)
+	if err != nil {
+		return err
+	}
+
+	for _, roleName := range args {
+		if !containsInSlice(roleName, playbook.Roles) {
+			return fmt.Errorf("роли \"%s\" не существует или она не добавлена в playbook.yml", roleName)
+		}
+	}
+
+	return nil
+}
+
+func restoreRunE(_ *cobra.Command, args []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceWorker := space_worker.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	spaceWorker.AnsibleBin = flagAnsibleBin
+	spaceWorker.AnsibleVerbose = flagAnsibleVerbose
+	return spaceWorker.Restore(flagTargetHost, flagRestoreTimestamp, flagRestoreInventory, args...)
+}

cmd/role.go

@@ -0,0 +1,130 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+	"path/filepath"
+	sw "playbookctl/internal/space_worker"
+	"playbookctl/internal/utils/logger"
+)
+
+var (
+	flagBackupAdd bool
+)
+
+func NewCommandRole() *cobra.Command {
+	roleCmd := &cobra.Command{
+		Use:   "role",
+		Short: "работа с ролями в пространстве",
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
+		},
+	}
+
+	roleCmd.AddCommand(newCommandRoleCreate())
+	roleCmd.AddCommand(newCommandRoleRemove())
+	roleCmd.AddCommand(newCommandRoleList())
+	roleCmd.AddCommand(newCommandRoleModify())
+
+	return roleCmd
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+func newCommandRoleCreate() *cobra.Command {
+	createCmd := &cobra.Command{
+		Use:     "create <name>",
+		Aliases: []string{"new"},
+		Short:   "создать роль в пространстве",
+		Args:    cobra.ExactArgs(1),
+		RunE:    roleCreateRunE,
+	}
+
+	return createCmd
+}
+
+func roleCreateRunE(_ *cobra.Command, args []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceWorker := sw.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	return spaceWorker.CreateRole(args[0])
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+func newCommandRoleRemove() *cobra.Command {
+	createCmd := &cobra.Command{
+		Use:               "remove <name>",
+		Aliases:           []string{"delete", "rm", "del"},
+		Short:             "удаляет роль из пространства",
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: ArgRoleCompletion,
+		RunE:              roleRemoveRunE,
+	}
+
+	return createCmd
+}
+
+func roleRemoveRunE(_ *cobra.Command, args []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceWorker := sw.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	return spaceWorker.RemoveRole(args[0])
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+func newCommandRoleList() *cobra.Command {
+	listCmd := &cobra.Command{
+		Use:     "list",
+		Aliases: []string{"ls"},
+		Short:   "список ролей в пространстве",
+		RunE:    roleListRunE,
+	}
+
+	return listCmd
+}
+
+func roleListRunE(_ *cobra.Command, _ []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+	spaceWorker := sw.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	return spaceWorker.ListRoles()
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+func newCommandRoleModify() *cobra.Command {
+	modifyCmd := &cobra.Command{
+		Use:               "modify <name>",
+		Short:             "модифицировать роль",
+		Args:              cobra.ExactArgs(1),
+		ValidArgsFunction: ArgRoleCompletion,
+		RunE:              roleModifyRunE,
+	}
+
+	modifyCmd.Flags().BoolVar(&flagBackupAdd, "backup-add", false, "добавить backup функцию")
+
+	return modifyCmd
+}
+
+func roleModifyRunE(_ *cobra.Command, args []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceWorker := sw.NewSpaceWorker(logger.LogVerbose(flagVerbose), workDir)
+	if flagBackupAdd {
+		return spaceWorker.ModifyRoleBackupAdd(args[0])
+	}
+
+	return nil
+}

cmd/root.go

@@ -0,0 +1,52 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"os"
+)
+
+var (
+	flagVerbose uint8
+	flagWorkdir string
+)
+
+var (
+	flagAnsibleVerbose uint8
+	flagAnsibleBin     string
+	flagGenOnly        bool
+	flagTargetHost     string
+)
+
+var rootCmd = &cobra.Command{
+	Use:     "playbookctl",
+	Short:   "Ansible Playbook Dedic2 Control",
+	Version: "4.0",
+	RunE: func(cmd *cobra.Command, _ []string) error {
+		return cmd.Help()
+	},
+}
+
+func init() {
+	rootCmd.PersistentFlags().Uint8Var(&flagVerbose, "verbose", 1, "verbose mode (0-3)")
+	rootCmd.PersistentFlags().StringVar(&flagWorkdir, "workdir", ".", "рабочая директория")
+
+	if err := rootCmd.MarkPersistentFlagDirname("workdir"); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	rootCmd.AddCommand(NewCommandSpace())
+	rootCmd.AddCommand(NewCommandRole())
+	rootCmd.AddCommand(NewCommandInstall())
+	rootCmd.AddCommand(NewCommandHosts())
+	rootCmd.AddCommand(NewCommandBackup())
+	rootCmd.AddCommand(NewCommandRestore())
+}
+
+func Execute() {
+	if err := rootCmd.Execute(); err != nil {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+}

cmd/space.go

@@ -0,0 +1,70 @@
+package cmd
+
+import (
+	_ "embed"
+	"errors"
+	"github.com/spf13/cobra"
+	"path/filepath"
+	sc "playbookctl/internal/space_creator"
+	"playbookctl/internal/utils/logger"
+)
+
+var (
+	flagName string
+	flagHost string
+	flagPort uint16
+	flagUser string
+)
+
+func NewCommandSpace() *cobra.Command {
+	spaceCmd := &cobra.Command{
+		Use:   "space",
+		Short: "работа с пространствами",
+		RunE: func(cmd *cobra.Command, _ []string) error {
+			return cmd.Help()
+		},
+	}
+
+	spaceCmd.AddCommand(newCommandSpaceCreate())
+
+	return spaceCmd
+}
+
+func newCommandSpaceCreate() *cobra.Command {
+	createCmd := &cobra.Command{
+		Use:     "create <name>",
+		Aliases: []string{"new"},
+		Short:   "создать пространство",
+		Args:    spaceCreateCheckArgsE,
+		RunE:    spaceCreateRunE,
+	}
+
+	createCmd.Flags().StringVar(&flagName, "name", "default", "псевдоним сервера")
+	createCmd.Flags().StringVar(&flagHost, "host", "127.0.0.1", "SSH адрес")
+	createCmd.Flags().Uint16Var(&flagPort, "port", 22, "SSH порт")
+	createCmd.Flags().StringVar(&flagUser, "user", "root", "SSH пользователь")
+
+	return createCmd
+}
+
+func spaceCreateCheckArgsE(_ *cobra.Command, args []string) error {
+	if len(args) != 1 {
+		return errors.New("должен быть указан один аргумент")
+	}
+	return nil
+}
+
+func spaceCreateRunE(_ *cobra.Command, args []string) error {
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		return err
+	}
+
+	spaceCreator := sc.NewSpaceCreator(logger.LogVerbose(flagVerbose), workDir)
+	return spaceCreator.CreateSpace(args[0], &sc.ServerProps{
+		Name: flagName,
+		Host: flagHost,
+		Port: flagPort,
+		User: flagUser,
+	})
+}

cmd/utils.go

@@ -0,0 +1,63 @@
+package cmd
+
+import (
+	"fmt"
+	"github.com/spf13/cobra"
+	"os"
+	"path/filepath"
+	"playbookctl/internal/types"
+)
+
+func ArgRoleCompletion(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	exitApp := func(err error) {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	var suggestions []string
+
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		exitApp(err)
+	}
+
+	playbook, err := types.ReadPlaybook(workDir)
+	if err != nil {
+		exitApp(err)
+	}
+
+	for _, role := range playbook.Roles {
+		if toComplete == "" || len(role) >= len(toComplete) && role[:len(toComplete)] == toComplete {
+			suggestions = append(suggestions, role)
+		}
+	}
+
+	return suggestions, cobra.ShellCompDirectiveDefault
+}
+
+func ArgHostCompletion(_ *cobra.Command, _ []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+	exitApp := func(err error) {
+		fmt.Println(err)
+		os.Exit(1)
+	}
+
+	var suggestions []string
+
+	workDir, err := filepath.Abs(flagWorkdir)
+	if err != nil {
+		exitApp(err)
+	}
+
+	hosts, err := types.ReadHosts(workDir)
+	if err != nil {
+		exitApp(err)
+	}
+
+	for host := range *hosts {
+		if toComplete == "" || len(host) >= len(toComplete) && host[:len(toComplete)] == toComplete {
+			suggestions = append(suggestions, host)
+		}
+	}
+
+	return suggestions, cobra.ShellCompDirectiveDefault
+}