func config(c *cli.Context) {
if len(c.Args()) > 1 {
utils.Exit("Wrong number of arguments. Try 'art config --help'.")
} else if len(c.Args()) == 1 {
if c.Args()[0] == "show" {
commands.ShowConfig()
} else if c.Args()[0] == "clear" {
commands.ClearConfig()
} else {
utils.Exit("Unknown argument '" + c.Args()[0] + "'. Available arguments are 'show' and 'clear'.")
}
} else {
initFlags(c, "config")
commands.Config(flags.ArtDetails, flags.Interactive, flags.EncPassword)
}
}
func encryptPassword(details *utils.ArtifactoryDetails) *utils.ArtifactoryDetails {
if details.Password == "" {
return details
}
response, encPassword := utils.GetEncryptedPasswordFromArtifactory(details)
switch response.StatusCode {
case 409:
utils.Exit(utils.ExitCodeError, "\nYour Artifactory server is not configured to encrypt passwords.\n"+
"You may use \"art config --enc-password=false\"")
case 200:
details.Password = encPassword
default:
utils.Exit(utils.ExitCodeError, "\nArtifactory response: "+response.Status)
}
return details
}
func upload(c *cli.Context) {
initFlags(c, "upload")
size := len(c.Args())
if size != 2 {
utils.Exit(utils.ExitCodeError, "Wrong number of arguments. Try 'art upload --help'.")
}
localPath := c.Args()[0]
targetPath := c.Args()[1]
uploaded, failed := commands.Upload(localPath, targetPath, flags)
if failed > 0 {
if uploaded > 0 {
utils.Exit(utils.ExitCodeWarning, "")
}
utils.Exit(utils.ExitCodeError, "")
}
}
func download(c *cli.Context) {
initFlags(c, "download")
if len(c.Args()) != 1 {
utils.Exit("Wrong number of arguments. Try 'art download --help'.")
}
pattern := c.Args()[0]
commands.Download(pattern, flags)
}
func getConFilePath() string {
userDir := utils.GetHomeDir()
if userDir == "" {
utils.Exit(utils.ExitCodeError, "Couldn't find home directory. Make sure your HOME environment variable is set.")
}
confPath := userDir + "/.jfrog/"
os.MkdirAll(confPath, 0777)
return confPath + "art-cli.conf"
}
func upload(c *cli.Context) {
initFlags(c, "upload")
size := len(c.Args())
if size != 2 {
utils.Exit("Wrong number of arguments. Try 'art upload --help'.")
}
localPath := c.Args()[0]
targetPath := c.Args()[1]
commands.Upload(localPath, targetPath, flags)
}
func getFilesToUpload(localpath string, targetPath string, flags *utils.Flags) []Artifact {
if strings.Index(targetPath, "/") < 0 {
targetPath += "/"
}
rootPath := getRootPath(localpath, flags.UseRegExp)
if !utils.IsPathExists(rootPath) {
utils.Exit("Path does not exist: " + rootPath)
}
localpath = prepareLocalPath(localpath, flags.UseRegExp)
artifacts := []Artifact{}
// If the path is a single file then return it
if !utils.IsDir(rootPath) {
targetPath := prepareUploadPath(targetPath + rootPath)
artifacts = append(artifacts, Artifact{rootPath, targetPath})
return artifacts
}
r, err := regexp.Compile(localpath)
utils.CheckError(err)
var paths []string
if flags.Recursive {
paths = utils.ListFilesRecursive(rootPath)
} else {
paths = utils.ListFiles(rootPath)
}
for _, path := range paths {
if utils.IsDir(path) {
continue
}
groups := r.FindStringSubmatch(path)
size := len(groups)
target := targetPath
if size > 0 {
for i := 1; i < size; i++ {
group := strings.Replace(groups[i], "\\", "/", -1)
target = strings.Replace(target, "{"+strconv.Itoa(i)+"}", group, -1)
}
if strings.HasSuffix(target, "/") {
if flags.Flat {
target += utils.GetFileNameFromPath(path)
} else {
uploadPath := prepareUploadPath(path)
target += uploadPath
}
}
artifacts = append(artifacts, Artifact{path, target})
}
}
return artifacts
}
func initFlags(c *cli.Context, cmd string) {
if c.String("recursive") == "" {
flags.Recursive = true
} else {
flags.Recursive = c.Bool("recursive")
}
if c.String("interactive") == "" {
flags.Interactive = true
} else {
flags.Interactive = c.Bool("interactive")
}
if c.String("enc-password") == "" {
flags.EncPassword = true
} else {
flags.EncPassword = c.Bool("enc-password")
}
if cmd == "config" {
flags.ArtDetails = getArtifactoryDetails(c, false)
if !flags.Interactive && flags.ArtDetails.Url == "" {
utils.Exit("The --url option is mandatory when the --interactive option is set to false")
}
} else {
flags.ArtDetails = getArtifactoryDetails(c, true)
if flags.ArtDetails.Url == "" {
utils.Exit("The --url option is mandatory")
}
}
strFlat := c.String("flat")
if cmd == "upload" {
if strFlat == "" {
flags.Flat = true
} else {
flags.Flat, _ = strconv.ParseBool(strFlat)
}
} else {
if strFlat == "" {
flags.Flat = false
} else {
flags.Flat, _ = strconv.ParseBool(strFlat)
}
}
flags.Deb = c.String("deb")
if flags.Deb != "" && len(strings.Split(flags.Deb, "/")) != 3 {
utils.Exit("The --deb option should be in the form of distribution/component/architecture")
}
flags.Props = c.String("props")
flags.DryRun = c.Bool("dry-run")
flags.UseRegExp = c.Bool("regexp")
var err error
if c.String("threads") == "" {
flags.Threads = 3
} else {
flags.Threads, err = strconv.Atoi(c.String("threads"))
if err != nil || flags.Threads < 1 {
utils.Exit("The '--threads' option should have a numeric positive value.")
}
}
if c.String("min-split") == "" {
flags.MinSplitSize = 5120
} else {
flags.MinSplitSize, err = strconv.ParseInt(c.String("min-split"), 10, 64)
if err != nil {
utils.Exit("The '--min-split' option should have a numeric value. Try 'art download --help'.")
}
}
if c.String("split-count") == "" {
flags.SplitCount = 3
} else {
flags.SplitCount, err = strconv.Atoi(c.String("split-count"))
if err != nil {
utils.Exit("The '--split-count' option should have a numeric value. Try 'art download --help'.")
}
if flags.SplitCount > 15 {
utils.Exit("The '--split-count' option value is limitted to a maximum of 15.")
}
if flags.SplitCount < 0 {
utils.Exit("The '--split-count' option cannot have a negative value.")
}
}
}