BackGo/cmd/root.go

package cmd

import (
    "context"
    "flag"
    "fmt"
    "git.pixelridgesoftworks.com/BackGo/pkg/backup"
    "git.pixelridgesoftworks.com/BackGo/pkg/logger"
)

type Command struct {
    Name        string
    Description string
    FlagSet     *flag.FlagSet
    SubCommands map[string]*Command
    Execute     func(ctx context.Context, cmd *Command, args []string)
}

var RootCmd = NewCommand("backup", "Main entry point for backup utility", nil)

func init() {
    remoteCmd := NewCommand("interface", "Remote node management", nil)

    triggerCmd := NewCommand("trigger", "Trigger an action on a node", handleTrigger)
    getInfoCmd := NewCommand("getinfo", "Get information from a node", handleGetInfo)
    addNodeCmd := NewCommand("addnode", "Add a new node to the cluster", handleAddNode)
    genCertCmd := NewCommand("gencert", "Generate a certificate for a node", handleGenCert)

    remoteCmd.AddSubCommand(triggerCmd)
    remoteCmd.AddSubCommand(getInfoCmd)
    remoteCmd.AddSubCommand(addNodeCmd)
    remoteCmd.AddSubCommand(genCertCmd)

    RootCmd.AddSubCommand(remoteCmd)
}

func handleTrigger(ctx context.Context, cmd *Command, args []string) {
    log := ctx.Value("logger").(*logger.Logger)
    dbManager := ctx.Value("dbManager").(*backup.DBManager)
    nodeFlag := cmd.FlagSet.String("node", "", "Specify the node hostname")
    actionFlag := cmd.FlagSet.String("action", "", "Specify the action to trigger")
    cmd.FlagSet.Parse(args)

    if *nodeFlag == "" || *actionFlag == "" {
        log.Println("Both node hostname and action are required")
        return
    }

    cli := NewInterfaceCLI(*nodeFlag, dbManager)
    if err := cli.TriggerCommand(*actionFlag, ""); err != nil {
        log.Printf("Error triggering command on node %s: %v\n", *nodeFlag, err)
    } else {
        log.Printf("Command '%s' triggered successfully on node %s\n", *actionFlag, *nodeFlag)
    }
}

func handleGetInfo(ctx context.Context, cmd *Command, args []string) {
    log := ctx.Value("logger").(*logger.Logger)
    nodeFlag := cmd.FlagSet.String("node", "", "Specify the node address")
    valueFlag := cmd.FlagSet.String("value", "", "Specify the value for get_info")
    cmd.FlagSet.Parse(args)

    if *nodeFlag == "" {
        log.Println("Node address is required")
        return
    }

    dbManager := ctx.Value("dbManager").(*backup.DBManager)
    cli := NewInterfaceCLI(*nodeFlag, dbManager)
    if err := cli.GetInfo(*valueFlag); err != nil {
        log.Printf("Error getting info from node %s: %v\n", *nodeFlag, err)
    } else {
        log.Printf("Successfully got info from node %s\n", *nodeFlag)
    }
}

func handleAddNode(ctx context.Context, cmd *Command, args []string) {
    dbManager := ctx.Value("dbManager").(*backup.DBManager)
    nodeName := cmd.FlagSet.String("node", "", "Specify the node name")
    cmd.FlagSet.Parse(args)

    if *nodeName == "" {
        fmt.Println("Node name is required")
        return
    }

    token := "some_generated_token"
    if err := dbManager.CreateToken(*nodeName, token); err != nil {
        fmt.Printf("Error adding new node %s: %v\n", *nodeName, err)
    } else {
        fmt.Printf("New node %s added successfully with token %s\n", *nodeName, token)
    }
}

func handleGenCert(ctx context.Context, cmd *Command, args []string) {
    log := ctx.Value("logger").(*logger.Logger)
    dbManager := ctx.Value("dbManager").(*backup.DBManager)
    nodeNameFlag := cmd.FlagSet.String("node", "", "Specify the node name for which to generate a certificate")
    cmd.FlagSet.Parse(args)

    if *nodeNameFlag == "" {
        log.Println("Node name is required")
        return
    }

    cli := NewInterfaceCLI(*nodeNameFlag, dbManager)
    if err := cli.GenCert(*nodeNameFlag); err != nil {
        log.Printf("Error generating certificate for node %s: %v\n", *nodeNameFlag, err)
    } else {
        log.Printf("Certificate generated successfully for node %s\n", *nodeNameFlag)
    }
}

func NewCommand(name, description string, execute func(ctx context.Context, cmd *Command, args []string)) *Command {
    return &Command{
        Name:        name,
        Description: description,
        FlagSet:     flag.NewFlagSet(name, flag.ExitOnError),
        SubCommands: make(map[string]*Command),
        Execute:     execute,
    }
}

func (c *Command) AddSubCommand(subCmd *Command) {
    c.SubCommands[subCmd.Name] = subCmd
}

func (c *Command) FindSubCommand(name string) (*Command, bool) {
    subCmd, found := c.SubCommands[name]
    return subCmd, found
}

func ExecuteCommandWithContext(ctx context.Context, rootCmd *Command, args []string) error {
    if len(args) < 1 {
        fmt.Println("No command provided")
        return nil
    }

    cmdName := args[0]
    subArgs := args[1:]

    cmd, found := rootCmd.FindSubCommand(cmdName)
    if !found {
        fmt.Printf("Unknown command: %s\n", cmdName)
        return nil
    }

    if cmd.Execute != nil {
        cmd.Execute(ctx, cmd, subArgs)
    } else {
        fmt.Println("No execute function provided for command:", cmdName)
    }

    return nil
}