120 lines
3.6 KiB
Go
120 lines
3.6 KiB
Go
package cmd
|
|
|
|
import (
|
|
"os"
|
|
"os/user"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/spf13/cobra"
|
|
"gitlab.sweetwater.com/it/devops/tools/gitlab-project-manager/internal/cache"
|
|
"gitlab.sweetwater.com/it/devops/tools/gitlab-project-manager/internal/config"
|
|
"gitlab.sweetwater.com/it/devops/tools/gitlab-project-manager/internal/remotes"
|
|
gitearemote "gitlab.sweetwater.com/it/devops/tools/gitlab-project-manager/internal/remotes/gitea"
|
|
gitlabremote "gitlab.sweetwater.com/it/devops/tools/gitlab-project-manager/internal/remotes/gitlab"
|
|
"gitlab.sweetwater.com/it/devops/tools/gitlab-project-manager/internal/remotes/remote"
|
|
"golang.org/x/sys/unix"
|
|
)
|
|
|
|
// This file contains init methods that may be used by
|
|
// multiple sub-commands. For instance, the cach and projects
|
|
// sub-commands both depend on a cache and may both call the initProjectCache
|
|
// func from their PersistentPreRun commands
|
|
|
|
func initProjectCache(cmd *cobra.Command, args []string) {
|
|
var err error
|
|
plog.Debug("Running pre-run for cacheCmd")
|
|
conf.Cache.File = conf.ProjectPath + "/.cache.yaml"
|
|
|
|
gitRemotes := remotes.NewRemotes()
|
|
gitRemotes.AddRemotes(*getRemotes(cmd)...)
|
|
|
|
cacheOpts := &cache.CacheOpts{
|
|
ProjectsPath: conf.ProjectPath,
|
|
Path: conf.Cache.File,
|
|
TTL: conf.Cache.Ttl,
|
|
Logger: plog,
|
|
Remotes: gitRemotes,
|
|
Config: &conf,
|
|
}
|
|
if projectCache, err = cache.NewProjectCache(cacheOpts); err != nil {
|
|
plog.Error("Failed to prepare project cache", plog.Args("error", err))
|
|
os.Exit(1)
|
|
}
|
|
|
|
if err := projectCache.Read(); err != nil {
|
|
plog.Error("Cache load failed", plog.Args("error", err))
|
|
os.Exit(1)
|
|
}
|
|
|
|
plog.Debug("Remotes Loaded", plog.Args("remotes", cacheOpts.Remotes))
|
|
}
|
|
|
|
// Generically loads remotes from info.RemoteInfo in config.Remotes
|
|
func getRemotes(cmd *cobra.Command) *remotes.Remotes {
|
|
gitRemotes := new(remotes.Remotes)
|
|
*gitRemotes = make([]remote.Remote, 0)
|
|
for _, r := range conf.Remotes {
|
|
// Create a copy, set context
|
|
gitRemoteInfo := r
|
|
gitRemoteInfo.SetContext(cmd.Context())
|
|
var gitRemote remote.Remote
|
|
var err error
|
|
switch r.Type {
|
|
case "gitlab":
|
|
gitRemote, err = gitlabremote.NewGitlabRemote(&gitRemoteInfo)
|
|
case "gitea":
|
|
gitRemote, err = gitearemote.NewGiteaRemote(&gitRemoteInfo)
|
|
}
|
|
if err != nil {
|
|
plog.Error("Failed to prepare remote", plog.Args(
|
|
"error", err,
|
|
"type", r.Type))
|
|
} else {
|
|
*gitRemotes = append(*gitRemotes, gitRemote)
|
|
}
|
|
}
|
|
return gitRemotes
|
|
}
|
|
|
|
func postProjectCache(cmd *cobra.Command, args []string) {
|
|
projectCache.Write()
|
|
}
|
|
|
|
func initProjectPath(cmd *cobra.Command, args []string) {
|
|
plog.Debug("Running persistent pre-run for rootCmd")
|
|
var err error
|
|
if conf.ProjectPath == "" {
|
|
conf.ProjectPath = config.DefaultConfig.ProjectPath
|
|
return
|
|
}
|
|
if conf.ProjectPath, err = resolvePath(conf.ProjectPath); err != nil {
|
|
plog.Error("Failed to determine project path", plog.Args("error", err))
|
|
os.Exit(1)
|
|
}
|
|
_, err = os.Stat(conf.ProjectPath)
|
|
if err != nil {
|
|
plog.Error("Failed to stat project path, trying to create", plog.Args("error", err))
|
|
if err := os.MkdirAll(conf.ProjectPath, 0750); err != nil {
|
|
plog.Error("Failed to create project path", plog.Args("error", err))
|
|
os.Exit(1)
|
|
}
|
|
plog.Info("Project path created", plog.Args("path", conf.ProjectPath))
|
|
} else {
|
|
if err = unix.Access(conf.ProjectPath, unix.W_OK); err != nil {
|
|
plog.Error("Unable to write to project path", plog.Args(
|
|
"path", conf.ProjectPath,
|
|
"error", err))
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
}
|
|
|
|
func resolvePath(path string) (string, error) {
|
|
if strings.HasPrefix(path, "~/") {
|
|
usr, _ := user.Current()
|
|
path = filepath.Join(usr.HomeDir, path[2:])
|
|
}
|
|
return filepath.Abs(path)
|
|
}
|