func (sm *StreamManager) parseStream(streamDecoder *json.Decoder, streamEncoder *json.Encoder) error { for { var decodedJson map[string]interface{} if e := streamDecoder.Decode(&decodedJson); e != nil { log.Debug(e) return e } if _, ok := sm.IncludeFilter[decodedJson["type"].(string)]; ok || len(sm.IncludeFilter) == 0 { if e := streamEncoder.Encode(&decodedJson); e != nil { log.Debug(e) return e } } } }
func downloadFile(downloadFileDetails *DownloadFileDetails, logMsgPrefix string, flags *DownloadFlags) error { httpClientsDetails := utils.GetArtifactoryHttpClientDetails(flags.ArtDetails) bulkDownload := flags.SplitCount == 0 || flags.MinSplitSize < 0 || flags.MinSplitSize*1000 > downloadFileDetails.Size if !bulkDownload { acceptRange, err := isFileAcceptRange(downloadFileDetails, flags) if err != nil { return err } bulkDownload = !acceptRange } if bulkDownload { resp, err := ioutils.DownloadFile(downloadFileDetails.DownloadPath, downloadFileDetails.LocalPath, downloadFileDetails.LocalFileName, httpClientsDetails) if err != nil { return err } log.Debug(logMsgPrefix, "Artifactory response:", resp.Status) } else { concurrentDownloadFlags := ioutils.ConcurrentDownloadFlags{ DownloadPath: downloadFileDetails.DownloadPath, FileName: downloadFileDetails.LocalFileName, LocalPath: downloadFileDetails.LocalPath, FileSize: downloadFileDetails.Size, SplitCount: flags.SplitCount} ioutils.DownloadFileConcurrently(concurrentDownloadFlags, logMsgPrefix, httpClientsDetails) } return nil }
func moveFile(sourcePath, destPath string, flags *MoveFlags, moveType MoveType) (bool, error) { message := moveMsgs[moveType].MovingMsg + " artifact: " + sourcePath + " to: " + destPath if flags.DryRun == true { log.Info("[Dry run] ", message) return true, nil } log.Info(message) moveUrl := flags.ArtDetails.Url restApi := "api/" + string(moveType) + "/" + sourcePath requestFullUrl, err := BuildArtifactoryUrl(moveUrl, restApi, map[string]string{"to": destPath}) if err != nil { return false, err } httpClientsDetails := GetArtifactoryHttpClientDetails(flags.ArtDetails) resp, body, err := ioutils.SendPost(requestFullUrl, nil, httpClientsDetails) if err != nil { return false, err } if resp.StatusCode != 200 { log.Error("Artifactory response: " + resp.Status + "\n" + cliutils.IndentJson(body)) } log.Debug("Artifactory response:", resp.Status) return resp.StatusCode == 200, nil }
func GpgSignFile(pathDetails *utils.PathDetails, passphrase string, bintrayDetails *config.BintrayDetails) error { if bintrayDetails.User == "" { bintrayDetails.User = pathDetails.Subject } url := bintrayDetails.ApiUrl + "gpg/" + pathDetails.Subject + "/" + pathDetails.Repo + "/" + pathDetails.Path var data string if passphrase != "" { data = "{ \"passphrase\": \"" + passphrase + "\" }" } log.Info("GPG signing file...") httpClientsDetails := utils.GetBintrayHttpClientDetails(bintrayDetails) resp, body, err := ioutils.SendPost(url, []byte(data), httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("GPG signed file", pathDetails.Path, ", details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func ShowVersion(versionDetails *utils.VersionDetails, bintrayDetails *config.BintrayDetails) error { if bintrayDetails.User == "" { bintrayDetails.User = versionDetails.Subject } version := versionDetails.Version if versionDetails.Version == "" { versionDetails.Version = "_latest" version = "latest" } url := bintrayDetails.ApiUrl + "packages/" + versionDetails.Subject + "/" + versionDetails.Repo + "/" + versionDetails.Package + "/versions/" + versionDetails.Version log.Info("Getting version details...") httpClientsDetails := utils.GetBintrayHttpClientDetails(bintrayDetails) resp, body, _, _ := ioutils.SendGet(url, true, httpClientsDetails) if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Version", version, "details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func DeleteFiles(resultItems []utils.AqlSearchResultItem, flags *DeleteFlags) error { for _, v := range resultItems { fileUrl, err := utils.BuildArtifactoryUrl(flags.ArtDetails.Url, v.GetFullUrl(), make(map[string]string)) if err != nil { return err } if flags.DryRun { log.Info("[Dry run] Deleting:", v.GetFullUrl()) continue } log.Info("Deleting:", v.GetFullUrl()) httpClientsDetails := utils.GetArtifactoryHttpClientDetails(flags.ArtDetails) resp, body, err := ioutils.SendDelete(fileUrl, nil, httpClientsDetails) if err != nil { return err } if resp.StatusCode != 204 { return cliutils.CheckError(errors.New("Artifactory response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Artifactory response:", resp.Status) } return nil }
func AqlSearch(aqlQuery string, flags AqlSearchFlag) ([]AqlSearchResultItem, error) { aqlUrl := flags.GetArtifactoryDetails().Url + "api/search/aql" log.Debug("Searching Artifactory using AQL query:", aqlQuery) httpClientsDetails := GetArtifactoryHttpClientDetails(flags.GetArtifactoryDetails()) resp, json, err := ioutils.SendPost(aqlUrl, []byte(aqlQuery), httpClientsDetails) if err != nil { return nil, err } if resp.StatusCode != 200 { return nil, cliutils.CheckError(errors.New("Artifactory response: " + resp.Status + "\n" + cliutils.IndentJson(json))) } log.Debug("Artifactory response: ", resp.Status) resultItems, err := parseAqlSearchResponse(json) return resultItems, err }
func BuildPublish(buildName, buildNumber string, flags *utils.BuildInfoFlags) error { err := utils.PreCommandSetup(flags) if err != nil { return err } buildData, err := utils.ReadBuildInfoFiles(buildName, buildNumber) if err != nil { return err } if len(buildData) == 0 { return cliutils.CheckError(fmt.Errorf("Can't find any files related to build name: %q, number: %q", buildName, buildNumber)) } sort.Sort(buildData) buildInfo := createNewBuildInfo() buildInfo.Name = buildName buildInfo.Number = buildNumber buildGeneralDetails, err := utils.ReadBuildInfoGeneralDetails(buildName, buildNumber) if err != nil { return err } buildInfo.Started = buildGeneralDetails.Timestamp.Format("2006-01-02T15:04:05.000-0700") artifactsSet, dependenciesSet, env, err := prepareBuildInfoData(buildData, createIncludeFilter(flags), createExcludeFilter(flags)) if err != nil { return err } if len(env) != 0 { buildInfo.Propertires = env } module := createModule(buildName, artifactsSet, dependenciesSet) buildInfo.Modules = append(buildInfo.Modules, module) marshaledBuildInfo, err := json.Marshal(buildInfo) if cliutils.CheckError(err) != nil { return err } if flags.IsDryRun() { fmt.Println(cliutils.IndentJson(marshaledBuildInfo)) return nil } httpClientsDetails := utils.GetArtifactoryHttpClientDetails(flags.ArtDetails) utils.SetContentType("application/vnd.org.jfrog.artifactory+json", &httpClientsDetails.Headers) log.Info("Deploying build info...") resp, body, err := utils.PublishBuildInfo(flags.ArtDetails.Url, marshaledBuildInfo, httpClientsDetails) if err != nil { return err } if resp.StatusCode != 204 { return cliutils.CheckError(errors.New("Artifactory response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Artifactory response:", resp.Status) log.Info("Build info successfully deployed. Browse it in Artifactory under " + flags.ArtDetails.Url + "webapp/builds/" + buildName + "/" + buildNumber) if err = utils.RemoveBuildDir(buildName, buildNumber); err != nil { return err } return nil }
func BuildDistribute(buildName, buildNumber, targetRepo string, flags *BuildDistributionFlags) error { err := utils.PreCommandSetup(flags) if err != nil { return err } dryRun := "" if flags.DryRun == true { dryRun = "[Dry run] " } message := "Destributing build..." log.Info(dryRun + message) distributeUrl := flags.ArtDetails.Url restApi := path.Join("api/build/distribute/", buildName, buildNumber) requestFullUrl, err := utils.BuildArtifactoryUrl(distributeUrl, restApi, make(map[string]string)) if err != nil { return err } data := BuildDistributionConfig{ SourceRepos: strings.Split(flags.SourceRepos, ","), TargetRepo: targetRepo, Publish: flags.Publish, OverrideExistingFiles: flags.OverrideExistingFiles, GpgPassphrase: flags.GpgPassphrase, Async: flags.Async, DryRun: flags.DryRun} requestContent, err := json.Marshal(data) if err != nil { return cliutils.CheckError(errors.New("Failed to execute request. " + cliutils.GetDocumentationMessage())) } httpClientsDetails := utils.GetArtifactoryHttpClientDetails(flags.ArtDetails) utils.SetContentType("application/json", &httpClientsDetails.Headers) resp, body, err := ioutils.SendPost(requestFullUrl, requestContent, httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Artifactory response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Artifactory response:", resp.Status) if flags.Async && !flags.DryRun { log.Info("Asynchronously distributed build", buildName, "#"+buildNumber, "to:", targetRepo, "repository, logs are avalable in Artifactory.") return nil } log.Info(dryRun+"Distributed build", buildName, "#"+buildNumber, "to:", targetRepo, "repository.") return nil }
func downloadAqlResult(dependecies []DownloadData, flags *DownloadFlags) (buildDependencies [][]utils.DependenciesBuildInfo, err error) { size := len(dependecies) buildDependencies = make([][]utils.DependenciesBuildInfo, flags.Threads) var wg sync.WaitGroup for i := 0; i < flags.Threads; i++ { wg.Add(1) go func(threadId int) { logMsgPrefix := cliutils.GetLogMsgPrefix(threadId, flags.DryRun) for j := threadId; j < size && err == nil; j += flags.Threads { downloadPath, e := utils.BuildArtifactoryUrl(flags.ArtDetails.Url, dependecies[j].Dependency.GetFullUrl(), make(map[string]string)) if e != nil { err = e break } log.Info(logMsgPrefix+"Downloading", dependecies[j].Dependency.GetFullUrl()) if flags.DryRun { continue } regexpPattern := cliutils.PathToRegExp(dependecies[j].DownloadPath) placeHolderTarget, e := cliutils.ReformatRegexp(regexpPattern, dependecies[j].Dependency.GetFullUrl(), dependecies[j].Target) if e != nil { err = e break } localPath, localFileName := ioutils.GetLocalPathAndFile(dependecies[j].Dependency.Name, dependecies[j].Dependency.Path, placeHolderTarget, dependecies[j].Flat) shouldDownload, e := shouldDownloadFile(path.Join(localPath, dependecies[j].Dependency.Name), dependecies[j].Dependency.Actual_Md5, dependecies[j].Dependency.Actual_Sha1) if e != nil { err = e break } dependency := createBuildDependencyItem(dependecies[j].Dependency) if !shouldDownload { buildDependencies[threadId] = append(buildDependencies[threadId], dependency) log.Debug(logMsgPrefix, "File already exists locally.") continue } downloadFileDetails := createDownloadFileDetails(downloadPath, localPath, localFileName, nil, dependecies[j].Dependency.Size) e = downloadFile(downloadFileDetails, logMsgPrefix, flags) if e != nil { err = e break } buildDependencies[threadId] = append(buildDependencies[threadId], dependency) } wg.Done() }(i) } wg.Wait() logDownloadTotals(buildDependencies) return }
func ShowAccessKey(flags *AccessKeyFlags, org string) (err error) { url := GetAccessKeyPath(flags.BintrayDetails, flags.Id, org) httpClientsDetails := utils.GetBintrayHttpClientDetails(flags.BintrayDetails) log.Info("Getting access key...") resp, body, _, _ := ioutils.SendGet(url, true, httpClientsDetails) if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Access keys details:") fmt.Println(cliutils.IndentJson(body)) return }
func ShowAccessKeys(bintrayDetails *config.BintrayDetails, org string) error { path := GetAccessKeysPath(bintrayDetails, org) httpClientsDetails := utils.GetBintrayHttpClientDetails(bintrayDetails) log.Info("Getting access keys...") resp, body, _, _ := ioutils.SendGet(path, true, httpClientsDetails) if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Access keys details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func CreateVersion(versionDetails *utils.VersionDetails, flags *utils.VersionFlags) error { log.Info("Creating version...") resp, body, err := doCreateVersion(versionDetails, flags, flags.BintrayDetails) if err != nil { return err } if resp.StatusCode != 201 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Created version", versionDetails.Version+", details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func CreatePackage(packageDetails *utils.VersionDetails, flags *utils.PackageFlags) error { log.Info("Creating package...") resp, body, err := DoCreatePackage(packageDetails, flags) if err != nil { return err } if resp.StatusCode != 201 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Created package", packageDetails.Package+", details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func (sm *StreamManager) handleStream(ioReader io.Reader, writer io.Writer, lastServerInteraction *time.Time) { bodyReader := bufio.NewReader(ioReader) pReader, pWriter := io.Pipe() defer pWriter.Close() go func() { defer pReader.Close() for { line, _, err := bodyReader.ReadLine() if err != nil { log.Debug(err) break } *lastServerInteraction = time.Now() _, err = pWriter.Write(line) if err != nil { log.Debug(err) break } } }() streamDecoder := json.NewDecoder(pReader) streamEncoder := json.NewEncoder(writer) sm.parseStream(streamDecoder, streamEncoder) }
func DeleteAccessKey(flags *AccessKeyFlags, org string) error { url := GetAccessKeyPath(flags.BintrayDetails, flags.Id, org) httpClientsDetails := utils.GetBintrayHttpClientDetails(flags.BintrayDetails) log.Info("Deleting access key...") resp, body, err := ioutils.SendDelete(url, nil, httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Deleted access key.") return nil }
func UpdateAccessKey(flags *AccessKeyFlags, org string) error { data := BuildAccessKeyJson(flags, false) url := GetAccessKeyPath(flags.BintrayDetails, flags.Id, org) httpClientsDetails := utils.GetBintrayHttpClientDetails(flags.BintrayDetails) log.Info("Updating access key...") resp, body, err := ioutils.SendPatch(url, []byte(data), httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Updated access key, details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func ShowPackage(packageDetails *utils.VersionDetails, bintrayDetails *config.BintrayDetails) (err error) { if bintrayDetails.User == "" { bintrayDetails.User = packageDetails.Subject } url := bintrayDetails.ApiUrl + "packages/" + packageDetails.Subject + "/" + packageDetails.Repo + "/" + packageDetails.Package log.Info("Getting package details...") httpClientsDetails := utils.GetBintrayHttpClientDetails(bintrayDetails) resp, body, _, _ := ioutils.SendGet(url, true, httpClientsDetails) if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Package", packageDetails.Package, "details:") fmt.Println(cliutils.IndentJson(body)) return }
func LogsList(packageDetails *utils.VersionDetails, details *config.BintrayDetails) error { if details.User == "" { details.User = packageDetails.Subject } path := details.ApiUrl + "packages/" + packageDetails.Subject + "/" + packageDetails.Repo + "/" + packageDetails.Package + "/logs/" httpClientsDetails := utils.GetBintrayHttpClientDetails(details) log.Info("Getting logs...") resp, body, _, _ := ioutils.SendGet(path, true, httpClientsDetails) if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Log details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func ShowEntitlement(flags *EntitlementFlags, details *utils.VersionDetails) error { url := BuildEntitlementUrl(flags.BintrayDetails, details, flags.Id) if flags.BintrayDetails.User == "" { flags.BintrayDetails.User = details.Subject } httpClientsDetails := utils.GetBintrayHttpClientDetails(flags.BintrayDetails) log.Info("Getting entitlement...") resp, body, _, err := ioutils.SendGet(url, true, httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Entitlement details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func DownloadLog(packageDetails *utils.VersionDetails, logName string, details *config.BintrayDetails) error { if details.User == "" { details.User = packageDetails.Subject } path := details.ApiUrl + "packages/" + packageDetails.Subject + "/" + packageDetails.Repo + "/" + packageDetails.Package + "/logs/" + logName httpClientsDetails := utils.GetBintrayHttpClientDetails(details) log.Info("Downloading logs...") resp, err := ioutils.DownloadFile(path, "", logName, httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status)) } log.Debug("Bintray response:", resp.Status) log.Info("Downloaded log.") return nil }
func uploadFile(artifact cliutils.Artifact, url, logMsgPrefix string, bintrayDetails *config.BintrayDetails) (bool, error) { log.Info(logMsgPrefix+"Uploading artifact:", artifact.LocalPath) f, err := os.Open(artifact.LocalPath) err = cliutils.CheckError(err) if err != nil { return false, err } defer f.Close() httpClientsDetails := utils.GetBintrayHttpClientDetails(bintrayDetails) resp, body, err := ioutils.UploadFile(f, url, httpClientsDetails) if err != nil { return false, err } log.Debug(logMsgPrefix+"Bintray response:", resp.Status) if resp.StatusCode != 201 && resp.StatusCode != 200 { log.Error(logMsgPrefix + "Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body)) } return resp.StatusCode == 201 || resp.StatusCode == 200, nil }
func UpdateEntitlement(flags *EntitlementFlags, details *utils.VersionDetails) error { path := BuildEntitlementUrl(flags.BintrayDetails, details, flags.Id) if flags.BintrayDetails.User == "" { flags.BintrayDetails.User = details.Subject } data := buildEntitlementJson(flags, true) httpClientsDetails := utils.GetBintrayHttpClientDetails(flags.BintrayDetails) log.Info("Updating entitlement...") resp, body, err := ioutils.SendPatch(path, []byte(data), httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Updated entitlement, details:") fmt.Println(cliutils.IndentJson(body)) return err }
func DeleteVersion(versionDetails *utils.VersionDetails, bintrayDetails *config.BintrayDetails) error { if bintrayDetails.User == "" { bintrayDetails.User = versionDetails.Subject } url := bintrayDetails.ApiUrl + "packages/" + versionDetails.Subject + "/" + versionDetails.Repo + "/" + versionDetails.Package + "/versions/" + versionDetails.Version log.Info("Deleting version...") httpClientsDetails := utils.GetBintrayHttpClientDetails(bintrayDetails) resp, body, err := ioutils.SendDelete(url, nil, httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Deleted version", versionDetails.Version+".") return nil }
func createVersionIfNeeded(versionDetails *utils.VersionDetails, uploadFlags *UploadFlags) error { log.Info("Verifying version", versionDetails.Version, "exists...") resp, err := utils.HeadVersion(versionDetails, uploadFlags.BintrayDetails) if err != nil { return err } if resp.StatusCode == 404 { log.Info("Creating version...") resp, body, err := DoCreateVersion(versionDetails, uploadFlags.BintrayDetails) if err != nil { return err } if resp.StatusCode != 201 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Created version", versionDetails.Version+".") } else if resp.StatusCode != 200 { err = cliutils.CheckError(errors.New("Bintray response: " + resp.Status)) } return err }
func PublishVersion(versionDetails *utils.VersionDetails, bintrayDetails *config.BintrayDetails) error { if bintrayDetails.User == "" { bintrayDetails.User = versionDetails.Subject } url := bintrayDetails.ApiUrl + "content/" + versionDetails.Subject + "/" + versionDetails.Repo + "/" + versionDetails.Package + "/" + versionDetails.Version + "/publish" log.Info("Publishing version...") httpClientsDetails := utils.GetBintrayHttpClientDetails(bintrayDetails) resp, body, err := ioutils.SendPost(url, nil, httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Published version", versionDetails.Version+", details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func UpdatePackage(packageDetails *utils.VersionDetails, flags *utils.PackageFlags) error { if flags.BintrayDetails.User == "" { flags.BintrayDetails.User = packageDetails.Subject } data := utils.CreatePackageJson(packageDetails.Package, flags) url := flags.BintrayDetails.ApiUrl + "packages/" + packageDetails.Subject + "/" + packageDetails.Repo + "/" + packageDetails.Package log.Info("Updating package...") httpClientsDetails := utils.GetBintrayHttpClientDetails(flags.BintrayDetails) resp, body, err := ioutils.SendPatch(url, []byte(data), httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Updated package", packageDetails.Package+".") return nil }
func SignVersion(urlSigningDetails *utils.PathDetails, flags *UrlSigningFlags) error { if flags.BintrayDetails.User == "" { flags.BintrayDetails.User = urlSigningDetails.Subject } path := urlSigningDetails.Subject + "/" + urlSigningDetails.Repo + "/" + urlSigningDetails.Path url := flags.BintrayDetails.ApiUrl + "signed_url/" + path data := builJson(flags) log.Info("Signing URL...") httpClientsDetails := utils.GetBintrayHttpClientDetails(flags.BintrayDetails) resp, body, err := ioutils.SendPost(url, []byte(data), httpClientsDetails) if err != nil { return err } if resp.StatusCode != 200 { return cliutils.CheckError(errors.New("Bintray response: " + resp.Status + "\n" + cliutils.IndentJson(body))) } log.Debug("Bintray response:", resp.Status) log.Info("Signed URL", path+", details:") fmt.Println(cliutils.IndentJson(body)) return nil }
func DownloadBintrayFile(bintrayDetails *config.BintrayDetails, pathDetails *PathDetails, targetPath string, flags *DownloadFlags, logMsgPrefix string) (err error) { cleanPath := strings.Replace(pathDetails.Path, "(", "", -1) cleanPath = strings.Replace(cleanPath, ")", "", -1) downloadPath := path.Join(pathDetails.Subject, pathDetails.Repo, cleanPath) fileName, filePath := ioutils.GetFileAndDirFromPath(cleanPath) url := bintrayDetails.DownloadServerUrl + downloadPath if flags.IncludeUnpublished { url += "?include_unpublished=1" } log.Info(logMsgPrefix+"Downloading", downloadPath) httpClientsDetails := GetBintrayHttpClientDetails(bintrayDetails) var details *ioutils.FileDetails details, err = ioutils.GetRemoteFileDetails(url, httpClientsDetails) if err != nil { err = cliutils.CheckError(errors.New("Bintray " + err.Error())) if err != nil { return } } regexpPattern := cliutils.PathToRegExp(pathDetails.Path) placeHolderTarget, e := cliutils.ReformatRegexp(regexpPattern, cleanPath, targetPath) if e != nil { err = e return } localPath, localFileName := ioutils.GetLocalPathAndFile(fileName, filePath, placeHolderTarget, flags.Flat) var shouldDownload bool shouldDownload, err = shouldDownloadFile(path.Join(localPath, localFileName), details) if err != nil { return } if !shouldDownload { log.Info(logMsgPrefix, "File already exists locally.") return } // Check if the file should be downloaded concurrently. if flags.SplitCount == 0 || flags.MinSplitSize < 0 || flags.MinSplitSize*1000 > details.Size { // File should not be downloaded concurrently. Download it as one block. resp, err := ioutils.DownloadFile(url, localPath, localFileName, httpClientsDetails) if err != nil { return err } log.Debug(logMsgPrefix, "Bintray response:", resp.Status) } else { // We should attempt to download the file concurrently, but only if it is provided through the DSN. // To check if the file is provided through the DSN, we first attempt to download the file // with 'follow redirect' disabled. var resp *http.Response var redirectUrl string resp, redirectUrl, err = ioutils.DownloadFileNoRedirect(url, localPath, localFileName, httpClientsDetails) // There are two options now. Either the file has just been downloaded as one block, or // we got a redirect to DSN download URL. In case of the later, we should download the file // concurrently from the DSN URL. // 'err' is not nil in case 'redirectUrl' was returned. if redirectUrl != "" { concurrentDownloadFlags := ioutils.ConcurrentDownloadFlags{ DownloadPath: redirectUrl, FileName: localFileName, LocalPath: localPath, FileSize: details.Size, SplitCount: flags.SplitCount, Flat: flags.Flat} ioutils.DownloadFileConcurrently(concurrentDownloadFlags, "", httpClientsDetails) } else { err = cliutils.CheckError(err) if err != nil { return } log.Info(logMsgPrefix, "Bintray response:", resp.Status) } } return }