378 lines
13 KiB
Go
378 lines
13 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
clir "github.com/deranjer/clir"
|
|
clientcmd "github.com/deranjer/gvc/client/clientcmd"
|
|
clientconfig "github.com/deranjer/gvc/client/clientconfig"
|
|
config "github.com/deranjer/gvc/client/clientconfig"
|
|
"github.com/deranjer/store"
|
|
)
|
|
|
|
var version = "0.1.5"
|
|
var configPath = ".gvc" + string(filepath.Separator) + ".gvcconfig.toml"
|
|
var rootPath string
|
|
|
|
func main() {
|
|
// Sloppily inject a global variable //TODO maybe just path the variables manually or create a struct with them all in
|
|
injectVariables()
|
|
|
|
// Getting the root path
|
|
var err error
|
|
rootPath, err = os.Getwd()
|
|
if err != nil {
|
|
log.Fatalf("Can't get working dir, permissions issue? %s", err)
|
|
}
|
|
|
|
// Setting up a blank config to read the .toml file in if one exists
|
|
var conf clientconfig.Gvcconfig
|
|
isRepo := validateRepo()
|
|
if isRepo {
|
|
err := store.Load(configPath, &conf)
|
|
if err != nil {
|
|
fmt.Printf("Error loading config file into struct, please fix config, panic! \n%s", err)
|
|
os.Exit(0)
|
|
}
|
|
err = clientconfig.ValidateConfig(&conf, version)
|
|
if err != nil {
|
|
fmt.Println("Error validating config, your config file is corrupt! ", err)
|
|
os.Exit(0)
|
|
}
|
|
}
|
|
// Initialize our new cli
|
|
cli := clir.NewCli("gvcc", "Version control client for GVC", version)
|
|
|
|
// Adding the init command
|
|
initCommand(cli, &conf)
|
|
|
|
// Adding all the "add" commands
|
|
addCommands(cli, &conf)
|
|
|
|
// Adding the ignore commands
|
|
ignoreCommands(cli, &conf)
|
|
|
|
// Adding the test commands
|
|
infoCommands(cli, &conf)
|
|
|
|
err = cli.Run()
|
|
if err != nil {
|
|
fmt.Printf("Error occurred: %v\n", err)
|
|
}
|
|
err = store.Save(configPath, conf)
|
|
if err != nil {
|
|
fmt.Println("Error saving config to file, changes were not writted! Check config file... ", err)
|
|
}
|
|
}
|
|
|
|
// injectVariables just injects the global variables into the packages
|
|
func injectVariables() {
|
|
clientcmd.ConfigPath = configPath
|
|
config.ConfigPath = configPath
|
|
}
|
|
|
|
// validateRepo just ensures that the command is being run against an actual repo (bool yes or no)
|
|
func validateRepo() bool {
|
|
if _, err := os.Stat(configPath); os.IsNotExist(err) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func initCommand(cli *clir.Cli, conf *clientconfig.Gvcconfig) {
|
|
//The init subcommand
|
|
initCmd := cli.NewSubCommand("init", "initializes a new gvc repo")
|
|
initCmd.LongDescription("This will create the .gvcconfig.toml (with defaults) file in this directory. You can edit this file directly (unsafe) or with the client(safe)")
|
|
initCmd.Action(func() error {
|
|
isRepo := validateRepo()
|
|
if !isRepo {
|
|
clientcmd.InitializeRepo() // creates and checks the paths
|
|
newConf := clientconfig.Gvcconfig{
|
|
Version: version,
|
|
}
|
|
err := store.Save(configPath, &newConf)
|
|
if err != nil {
|
|
log.Fatalf("unable to create new config in .gvc %s", err)
|
|
}
|
|
return nil
|
|
}
|
|
fmt.Println("appears that this directory is already a gvc repo")
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func addCommands(cli *clir.Cli, conf *clientconfig.Gvcconfig) {
|
|
//All the add commands and subcommands
|
|
//The add subcommand
|
|
addCmd := cli.NewSubCommand("add", "adds file(s)/folder(s) (recursively for folder) to repo")
|
|
addCmd.LongDescription("You can add all: all, a -file (-f): file.txt, or a -folder (-fd): folder, or a -wildcard (-wc): *.txt")
|
|
//File/Folder/Wildcard adding
|
|
var file string
|
|
var folder string
|
|
var wildcard string
|
|
fileFlag := addCmd.StringFlag("file", "tracks a file to add to the repo", &file)
|
|
fileFlag.FlagShortCut("file", "f")
|
|
folderFlag := addCmd.StringFlag("folder", "tracks all contents of a folder to add to the repo", &folder)
|
|
folderFlag.FlagShortCut("folder", "fd")
|
|
wildCardFlag := addCmd.StringFlag("wildcard", "treats the input as a wildcard and tracks all files that match the wildcard", &wildcard)
|
|
wildCardFlag.FlagShortCut("wildcard", "wc")
|
|
addCmd.Action(func() error {
|
|
isRepo := validateRepo()
|
|
if !isRepo {
|
|
fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
|
|
os.Exit(0)
|
|
}
|
|
if len(addCmd.OtherArgs()) > 0 {
|
|
addCmd.PrintHelp()
|
|
return fmt.Errorf("incorrect input detected, please fix and retry")
|
|
}
|
|
if file != "" { // if the file flag was used it won't be empty
|
|
fmt.Println("adding file to tracked files: ", file)
|
|
err := clientcmd.AddFiles(file, "file", conf.Ignores)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
if folder != "" { // if the folder flag was used it won't be empty
|
|
fmt.Println("adding contents of folder to tracked files: ", folder)
|
|
err := clientcmd.AddFiles(folder, "folder", conf.Ignores)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
if wildcard != "" { // if the wildcard flag was used it won't be empty
|
|
fmt.Println("adding files with wildcard filter: ", wildcard)
|
|
err := clientcmd.AddFiles(wildcard, "wildcard", conf.Ignores)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
return nil
|
|
})
|
|
|
|
//Add all files recursively to repo
|
|
addall := addCmd.NewSubCommand("all", "add all of the file(s)/folders(s) recursively to repo")
|
|
addall.Action(func() error {
|
|
if len(addall.OtherArgs()) > 0 {
|
|
addCmd.PrintHelp()
|
|
return fmt.Errorf("the 'all' subcommand does not accept additional arguments")
|
|
}
|
|
fmt.Println("adding all files recursively in directory to tracked files")
|
|
err := clientcmd.AddFiles("", "all", conf.Ignores)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
|
|
//The add remote command
|
|
remoteCmd := addCmd.NewSubCommand("remote", "add/delete/show remotes")
|
|
var name string
|
|
var host string
|
|
var port int
|
|
remoteAddCmd := remoteCmd.NewSubCommand("add", "add a remote, requires -name -host and -port")
|
|
remoteAddCmd.LongDescription("Adds a remote to the .gvcconfig.toml. Requires the -name, -host and -port flags. Example: gvc remote add -name exampleRemote -host examplehost.com -port 8080")
|
|
nameFlag := remoteAddCmd.StringFlag("name", "the name you want for your remote server", &name)
|
|
nameFlag.FlagShortCut("name", "n")
|
|
remoteAddCmd.FlagRequired("name")
|
|
hostFlag := remoteAddCmd.StringFlag("host", "the hostname or IP Address of the remote", &host)
|
|
hostFlag.FlagShortCut("host", "h")
|
|
remoteAddCmd.FlagRequired("host")
|
|
portFlag := remoteAddCmd.IntFlag("port", "the port the remote server is listening on", &port)
|
|
portFlag.FlagShortCut("port", "p")
|
|
remoteAddCmd.FlagRequired("port")
|
|
remoteAddCmd.Action(func() error {
|
|
return nil
|
|
})
|
|
|
|
}
|
|
|
|
func ignoreCommands(cli *clir.Cli, conf *clientconfig.Gvcconfig) {
|
|
//All the ignore commands and subcommands
|
|
//The ignore subcommand
|
|
ignoreCmd := cli.NewSubCommand("ignore", "ignores file(s)/folder(s) (recursively for folder) to repo")
|
|
ignoreCmd.LongDescription("You can ignore all: all, a -file (-f): file.txt, or a -folder (-fd): folder, or a -wildcard (-wc): *.txt")
|
|
//File/Folder/Wildcard Ignoring
|
|
var file string
|
|
var folder string
|
|
var wildcard string
|
|
fileFlag := ignoreCmd.StringFlag("file", "adds a file to ignore to the config", &file)
|
|
fileFlag.FlagShortCut("file", "f")
|
|
folderFlag := ignoreCmd.StringFlag("folder", "tracks all contents of a folder to ignore", &folder)
|
|
folderFlag.FlagShortCut("folder", "fd")
|
|
wildCardFlag := ignoreCmd.StringFlag("wildcard", "treats the input as a wildcard and ignores all files that match the wildcard", &wildcard)
|
|
wildCardFlag.FlagShortCut("wildcard", "wc")
|
|
ignoreCmd.Action(func() error {
|
|
isRepo := validateRepo()
|
|
if !isRepo {
|
|
fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
|
|
os.Exit(0)
|
|
}
|
|
if len(ignoreCmd.OtherArgs()) > 0 {
|
|
ignoreCmd.PrintHelp()
|
|
return fmt.Errorf("incorrect input detected, please fix and retry")
|
|
}
|
|
if file != "" { // if the file flag was used it won't be empty
|
|
//fmt.Println("Ignoring file: ", file)
|
|
err := clientcmd.IgnoreFiles(file, "file", conf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
if folder != "" { // if the folder flag was used it won't be empty
|
|
fmt.Println("Ignoring contents of folder: ", folder)
|
|
err := clientcmd.IgnoreFiles(folder, "folder", conf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
if wildcard != "" { // if the wildcard flag was used it won't be empty
|
|
fmt.Println("Ignoring files with wildcard filter: ", wildcard)
|
|
err := clientcmd.IgnoreFiles(wildcard, "wildcard", conf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
return nil
|
|
})
|
|
// Adding the remove ignore command (remove from the ignore list)
|
|
removeIgnoreCmd(ignoreCmd, conf)
|
|
|
|
}
|
|
|
|
// removeIgnoreCmd removes files/folders/wildcard from the ignore list
|
|
func removeIgnoreCmd(ignoreCmd *clir.Command, conf *clientconfig.Gvcconfig) {
|
|
removeIgnoreCmd := ignoreCmd.NewSubCommand("remove", "remove from ignores file(s)/folder(s) (recursively for folder) to repo")
|
|
removeIgnoreCmd.LongDescription("You can remove from ignore all: all, a -file (-f): file.txt, or a -folder (-fd): folder, or a -wildcard (-wc): *.txt")
|
|
//File/Folder/Wildcard Ignoring
|
|
var file string
|
|
var folder string
|
|
var wildcard string
|
|
fileFlag := removeIgnoreCmd.StringFlag("file", "removes ignored file from config", &file)
|
|
fileFlag.FlagShortCut("file", "f")
|
|
folderFlag := removeIgnoreCmd.StringFlag("folder", "removes ignored folder", &folder)
|
|
folderFlag.FlagShortCut("folder", "fd")
|
|
wildCardFlag := removeIgnoreCmd.StringFlag("wildcard", "removes wildcard from ignores", &wildcard)
|
|
wildCardFlag.FlagShortCut("wildcard", "wc")
|
|
removeIgnoreCmd.Action(func() error {
|
|
isRepo := validateRepo()
|
|
if !isRepo {
|
|
fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
|
|
os.Exit(0)
|
|
}
|
|
if len(removeIgnoreCmd.OtherArgs()) > 0 {
|
|
removeIgnoreCmd.PrintHelp()
|
|
return fmt.Errorf("incorrect input detected, please fix and retry")
|
|
}
|
|
if file != "" { // if the file flag was used it won't be empty
|
|
//fmt.Println("Ignoring file: ", file)
|
|
err := clientcmd.RemoveIgnoreFiles(file, "file", conf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
if folder != "" { // if the folder flag was used it won't be empty
|
|
fmt.Println("Ignoring contents of folder: ", folder)
|
|
err := clientcmd.RemoveIgnoreFiles(folder, "folder", conf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
if wildcard != "" { // if the wildcard flag was used it won't be empty
|
|
fmt.Println("Ignoring files with wildcard filter: ", wildcard)
|
|
err := clientcmd.RemoveIgnoreFiles(wildcard, "wildcard", conf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func infoCommands(cli *clir.Cli, conf *clientconfig.Gvcconfig) {
|
|
//All the test commands
|
|
infoCmd := cli.NewSubCommand("info", "tests various aspects of the client/files/etc and server")
|
|
infoCmd.LongDescription("You can get information on remotes, files, etc")
|
|
|
|
remoteInfoCmd := infoCmd.NewSubCommand("remote", "takes the suppled server name and gets information about the server")
|
|
remoteInfoCmd.Action(func() error {
|
|
isRepo := validateRepo()
|
|
if !isRepo {
|
|
fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
|
|
os.Exit(0)
|
|
}
|
|
if len(remoteInfoCmd.OtherArgs()) == 0 {
|
|
remoteInfoCmd.PrintHelp()
|
|
return fmt.Errorf("Please supply a server name to test a remote")
|
|
}
|
|
server := remoteInfoCmd.OtherArgs()[0]
|
|
conn, err := clientcmd.ConnectToServer(server, "master", conf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = clientcmd.GetServerInfo(conn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
// //File/Folder/Wildcard Ignoring
|
|
// var file string
|
|
// var folder string
|
|
// var wildcard string
|
|
// fileFlag := ignoreCmd.StringFlag("file", "adds a file to ignore to the config", &file)
|
|
// fileFlag.FlagShortCut("file", "f")
|
|
// folderFlag := ignoreCmd.StringFlag("folder", "tracks all contents of a folder to ignore", &folder)
|
|
// folderFlag.FlagShortCut("folder", "fd")
|
|
// wildCardFlag := ignoreCmd.StringFlag("wildcard", "treats the input as a wildcard and ignores all files that match the wildcard", &wildcard)
|
|
// wildCardFlag.FlagShortCut("wildcard", "wc")
|
|
// ignoreCmd.Action(func() error {
|
|
// isRepo := validateRepo()
|
|
// if !isRepo {
|
|
// fmt.Println("no valid repo found.. please run 'init' to setup a repo first")
|
|
// os.Exit(0)
|
|
// }
|
|
// if len(ignoreCmd.OtherArgs()) > 0 {
|
|
// ignoreCmd.PrintHelp()
|
|
// return fmt.Errorf("incorrect input detected, please fix and retry")
|
|
// }
|
|
// if file != "" { // if the file flag was used it won't be empty
|
|
// //fmt.Println("Ignoring file: ", file)
|
|
// err := clientcmd.IgnoreFiles(file, "file", conf)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// return nil
|
|
// }
|
|
// if folder != "" { // if the folder flag was used it won't be empty
|
|
// fmt.Println("Ignoring contents of folder: ", folder)
|
|
// err := clientcmd.IgnoreFiles(folder, "folder", conf)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// return nil
|
|
// }
|
|
// if wildcard != "" { // if the wildcard flag was used it won't be empty
|
|
// fmt.Println("Ignoring files with wildcard filter: ", wildcard)
|
|
// err := clientcmd.IgnoreFiles(wildcard, "wildcard", conf)
|
|
// if err != nil {
|
|
// return err
|
|
// }
|
|
// return nil
|
|
// }
|
|
// return nil
|
|
// })
|
|
}
|