func prepareLicenseFile(filepath string, overrideFile bool) (err error) {
if filepath == "" {
return
}
var dir bool
dir, err = ioutils.IsDir(filepath)
if err != nil {
return
}
if dir {
err = cliutils.CheckError(errors.New(filepath + " is a directory."))
if err != nil {
return
}
}
var exists bool
exists, err = ioutils.IsFileExists(filepath)
if err != nil {
return
}
if !overrideFile && exists {
err = cliutils.CheckError(errors.New("File already exist, in case you wish to override the file use --override flag"))
if err != nil {
return
}
}
_, directory := ioutils.GetFileAndDirFromPath(filepath)
isPathExists := ioutils.IsPathExists(directory)
if !isPathExists {
os.MkdirAll(directory, 0700)
}
err = ioutil.WriteFile(filepath, nil, 0777)
err = cliutils.CheckError(err)
return
}
func AddInstance(instanceName string, flags *AddInstanceFlags) error {
data := AddInstanceRequestContent{
Name: instanceName,
Url: flags.ArtifactoryInstanceDetails.Url,
User: flags.ArtifactoryInstanceDetails.User,
Password: flags.ArtifactoryInstanceDetails.Password,
Description: flags.Description,
Location: flags.Location}
requestContent, err := json.Marshal(data)
if err != nil {
return cliutils.CheckError(errors.New("Failed to execute request. " + cliutils.GetDocumentationMessage()))
}
missionControlUrl := flags.MissionControlDetails.Url + "api/v1/instances"
httpClientDetails := utils.GetMissionControlHttpClientDetails(flags.MissionControlDetails)
resp, body, err := ioutils.SendPost(missionControlUrl, requestContent, httpClientDetails)
if err != nil {
return err
}
if resp.StatusCode == 201 || resp.StatusCode == 204 {
fmt.Println("Mission Control response: " + resp.Status)
} else {
return cliutils.CheckError(errors.New(resp.Status + ". " + utils.ReadMissionControlHttpMessage(body)))
}
return nil
}
func getFilesList(flags *OfflineUpdatesFlags) ([]string, []string, int64, error) {
log.Info("Getting updates...")
headers := make(map[string]string)
headers["X-Xray-License"] = flags.License
httpClientDetails := ioutils.HttpClientDetails{
Headers: headers,
}
resp, body, _, err := ioutils.SendGet(updatesUrl, false, httpClientDetails)
if err != nil {
cliutils.CheckError(err)
return nil, nil, 0, err
}
if resp.StatusCode != 200 {
err := errors.New("Response: " + resp.Status)
cliutils.CheckError(err)
return nil, nil, 0, err
}
var urls FilesList
json.Unmarshal(body, &urls)
var vulnerabilities, components []string
for _, v := range urls.Urls {
if strings.Contains(v, VULNERABILITY) {
vulnerabilities = append(vulnerabilities, v)
} else if strings.Contains(v, COMPONENT) {
components = append(components, v)
}
}
return vulnerabilities, components, urls.Last_update, nil
}
func SaveBuildGeneralDetails(buildName, buildNumber string) error {
path, err := GetBuildDir(buildName, buildNumber)
if err != nil {
return err
}
path += BUILD_INFO_DETAILS
var exists bool
exists, err = ioutils.IsFileExists(path)
if err != nil {
return err
}
if exists {
return nil
}
meta := BuildGeneralDetails{
Timestamp: time.Now(),
}
b, err := json.Marshal(&meta)
err = cliutils.CheckError(err)
var content bytes.Buffer
err = json.Indent(&content, b, "", " ")
err = cliutils.CheckError(err)
if err != nil {
return err
}
err = ioutil.WriteFile(path, []byte(content.String()), 0600)
return err
}
func GetFileDetails(filePath string) (*FileDetails, error) {
var err error
details := new(FileDetails)
details.Md5, err = calcMd5(filePath)
if err != nil {
return nil, err
}
details.Sha1, err = calcSha1(filePath)
if err != nil {
return nil, err
}
file, err := os.Open(filePath)
err = cliutils.CheckError(err)
if err != nil {
return nil, err
}
defer file.Close()
fileInfo, err := file.Stat()
err = cliutils.CheckError(err)
if err != nil {
return nil, err
}
details.Size = fileInfo.Size()
return details, nil
}
func DownloadFileConcurrently(flags ConcurrentDownloadFlags, logMsgPrefix string, httpClientsDetails HttpClientDetails) error {
var wg sync.WaitGroup
chunkSize := flags.FileSize / int64(flags.SplitCount)
mod := flags.FileSize % int64(flags.SplitCount)
var err error
for i := 0; i < flags.SplitCount; i++ {
if err != nil {
break
}
wg.Add(1)
start := chunkSize * int64(i)
end := chunkSize * (int64(i) + 1)
if i == flags.SplitCount-1 {
end += mod
}
requestClientDetails := httpClientsDetails.Clone()
go func(start, end int64, i int) {
e := downloadFileRange(flags, start, end, i, logMsgPrefix, *requestClientDetails)
if e != nil {
err = e
}
wg.Done()
}(start, end, i)
}
wg.Wait()
if err != nil {
return err
}
if !flags.Flat && flags.LocalPath != "" {
os.MkdirAll(flags.LocalPath, 0777)
flags.FileName = flags.LocalPath + "/" + flags.FileName
}
if IsPathExists(flags.FileName) {
err := os.Remove(flags.FileName)
err = cliutils.CheckError(err)
if err != nil {
return err
}
}
destFile, err := os.Create(flags.FileName)
err = cliutils.CheckError(err)
if err != nil {
return err
}
defer destFile.Close()
for i := 0; i < flags.SplitCount; i++ {
tempFilePath, err := GetTempDirPath()
if err != nil {
return err
}
tempFilePath += "/" + flags.FileName + "_" + strconv.Itoa(i)
AppendFile(tempFilePath, destFile)
}
fmt.Println(logMsgPrefix + "Done downloading.")
return nil
}
func DownloadVersion(versionDetails *utils.VersionDetails, targetPath string, flags *utils.DownloadFlags) (totalDownloded, totalFailed int, err error) {
ioutils.CreateTempDirPath()
defer ioutils.RemoveTempDir()
if flags.BintrayDetails.User == "" {
flags.BintrayDetails.User = versionDetails.Subject
}
path := BuildDownloadVersionUrl(versionDetails, flags.BintrayDetails, flags.IncludeUnpublished)
httpClientsDetails := utils.GetBintrayHttpClientDetails(flags.BintrayDetails)
resp, body, _, _ := ioutils.SendGet(path, true, httpClientsDetails)
if resp.StatusCode != 200 {
err = cliutils.CheckError(errors.New(resp.Status + ". " + utils.ReadBintrayMessage(body)))
return
}
var results []VersionFilesResult
err = json.Unmarshal(body, &results)
if cliutils.CheckError(err) != nil {
return
}
totalDownloded, err = downloadFiles(results, versionDetails, targetPath, flags)
log.Info("Downloaded", strconv.Itoa(totalDownloded), "artifacts.")
totalFailed = len(results) - totalDownloded
return
}
func getOfflineUpdatesFlag(c *cli.Context) (flags *commands.OfflineUpdatesFlags, err error) {
flags = new(commands.OfflineUpdatesFlags)
flags.License = c.String("license-id")
if len(flags.License) < 1 {
cliutils.Exit(cliutils.ExitCodeError, "The --license-id option is mandatory")
}
from := c.String("from")
to := c.String("to")
if len(to) > 0 && len(from) < 1 {
cliutils.Exit(cliutils.ExitCodeError, "The --from option is mandatory, when the --to option is sent.")
}
if len(from) > 0 && len(to) < 1 {
cliutils.Exit(cliutils.ExitCodeError, "The --to option is mandatory, when the --from option is sent.")
}
if len(from) > 0 && len(to) > 0 {
flags.From, err = dateToMilliseconds(from)
cliutils.CheckError(err)
if err != nil {
return
}
flags.To, err = dateToMilliseconds(to)
cliutils.CheckError(err)
}
return
}
func Config(details, defaultDetails *config.MissionControlDetails, interactive bool) (conf *config.MissionControlDetails, err error) {
conf = details
if conf == nil {
conf = new(config.MissionControlDetails)
}
if interactive {
if defaultDetails == nil {
defaultDetails, err = config.ReadMissionControlConf()
if err != nil {
return
}
}
if conf.Url == "" {
ioutils.ScanFromConsole("Mission Control URL", &conf.Url, defaultDetails.Url)
var u *url.URL
u, err = url.Parse(conf.Url)
err = cliutils.CheckError(err)
if err != nil {
return
}
if u.Scheme != "http" && u.Scheme != "https" {
err = cliutils.CheckError(errors.New("URL scheme is not valid " + u.Scheme))
if err != nil {
return
}
}
}
ioutils.ReadCredentialsFromConsole(conf, defaultDetails)
}
conf.Url = cliutils.AddTrailingSlashIfNeeded(conf.Url)
config.SaveMissionControlConf(conf)
return
}
func saveConfig(config *Config) error {
b, err := json.Marshal(&config)
err = cliutils.CheckError(err)
if err != nil {
return err
}
var content bytes.Buffer
err = json.Indent(&content, b, "", " ")
err = cliutils.CheckError(err)
if err != nil {
return err
}
path, err := getConFilePath()
if err != nil {
return err
}
var exists bool
exists, err = ioutils.IsFileExists(path)
if err != nil {
return err
}
if exists {
err := os.Remove(path)
err = cliutils.CheckError(err)
if err != nil {
return err
}
}
path, err = getConFilePath()
if err != nil {
return err
}
ioutil.WriteFile(path, []byte(content.String()), 0600)
return nil
}
func parseUrl(url string) (protocol, host string, port int, err error) {
pattern1 := "^(.+)://(.+):([0-9].+)/$"
pattern2 := "^(.+)://(.+)$"
var r *regexp.Regexp
r, err = regexp.Compile(pattern1)
err = cliutils.CheckError(err)
if err != nil {
return
}
groups := r.FindStringSubmatch(url)
if len(groups) == 4 {
protocol = groups[1]
host = groups[2]
port, err = strconv.Atoi(groups[3])
if err != nil {
err = cliutils.CheckError(errors.New("URL: " + url + " is invalid. Expecting ssh://<host>:<port> or http(s)://..."))
}
return
}
r, err = regexp.Compile(pattern2)
err = cliutils.CheckError(err)
if err != nil {
return
}
groups = r.FindStringSubmatch(url)
if len(groups) == 3 {
protocol = groups[1]
host = groups[2]
port = 80
}
return
}
func prepareBuildInfoData(artifactsDataWrapper utils.BuildInfo, includeFilter, excludeFilter filterFunc) ([]utils.ArtifactBuildInfo, []utils.DependenciesBuildInfo, utils.BuildEnv, error) {
var artifacts []utils.ArtifactBuildInfo
var dependencies []utils.DependenciesBuildInfo
var env utils.BuildEnv
env = make(map[string]string)
for _, buildInfoData := range artifactsDataWrapper {
switch {
case buildInfoData.Artifacts != nil:
for _, v := range buildInfoData.Artifacts {
artifacts = append(artifacts, v)
}
case buildInfoData.Dependencies != nil:
for _, v := range buildInfoData.Dependencies {
dependencies = append(dependencies, v)
}
case buildInfoData.Env != nil:
envAfterIncludeFilter, e := includeFilter(buildInfoData.Env)
if cliutils.CheckError(e) != nil {
return artifacts, dependencies, env, e
}
envAfterExcludeFilter, e := excludeFilter(envAfterIncludeFilter)
if cliutils.CheckError(e) != nil {
return artifacts, dependencies, env, e
}
for k, v := range envAfterExcludeFilter {
env[k] = v
}
}
}
return artifacts, dependencies, env, nil
}
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 zipFolderFiles(source, target string) (err error) {
zipfile, err := os.Create(target)
if err != nil {
cliutils.CheckError(err)
return
}
defer func() {
if cerr := zipfile.Close(); cerr != nil && err == nil {
err = cerr
}
}()
archive := zip.NewWriter(zipfile)
defer func() {
if cerr := archive.Close(); cerr != nil && err == nil {
err = cerr
}
}()
filepath.Walk(source, func(path string, info os.FileInfo, err error) (currentErr error) {
if info.IsDir() {
return
}
if err != nil {
currentErr = err
return
}
header, currentErr := zip.FileInfoHeader(info)
if currentErr != nil {
cliutils.CheckError(currentErr)
return
}
header.Method = zip.Deflate
writer, currentErr := archive.CreateHeader(header)
if currentErr != nil {
cliutils.CheckError(currentErr)
return
}
file, currentErr := os.Open(path)
if currentErr != nil {
cliutils.CheckError(currentErr)
return
}
defer func() {
if cerr := file.Close(); cerr != nil && currentErr == nil {
currentErr = cerr
}
}()
_, currentErr = io.Copy(writer, file)
return
})
return
}
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 validateDates(from, to int64) (err error) {
if from < 0 || to < 0 {
err = errors.New("Invalid dates")
cliutils.CheckError(err)
return
}
if from > to {
err = errors.New("Invalid dates range.")
cliutils.CheckError(err)
return
}
return
}
func CreateTempDirPath() error {
if tempDirPath != "" {
err := cliutils.CheckError(errors.New("'tempDirPath' has already been initialized."))
if err != nil {
return err
}
}
path, err := ioutil.TempDir("", "jfrog.cli.")
err = cliutils.CheckError(err)
if err != nil {
return err
}
tempDirPath = path
return nil
}
func Config(details, defaultDetails *config.BintrayDetails, interactive bool) (*config.BintrayDetails, error) {
if details == nil {
details = new(config.BintrayDetails)
}
if interactive {
if defaultDetails == nil {
var err error
defaultDetails, err = config.ReadBintrayConf()
if err != nil {
return nil, err
}
}
if details.User == "" {
ioutils.ScanFromConsole("User", &details.User, defaultDetails.User)
}
if details.Key == "" {
print("Key: ")
byteKey, err := terminal.ReadPassword(int(syscall.Stdin))
err = cliutils.CheckError(err)
if err != nil {
return nil, err
}
details.Key = string(byteKey)
if details.Key == "" {
details.Key = defaultDetails.Key
}
}
if details.DefPackageLicenses == "" {
ioutils.ScanFromConsole("\nDefault package licenses",
&details.DefPackageLicenses, defaultDetails.DefPackageLicenses)
}
}
config.SaveBintrayConf(details)
return details, 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 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 checkSingleAuthMethod(details *config.ArtifactoryDetails) (err error) {
boolArr := []bool{details.User != "" && details.Password != "", details.ApiKey != "", details.SshKeyPath != ""}
if cliutils.SumTrueValues(boolArr) > 1 {
err = cliutils.CheckError(errors.New("Only one authentication method is allowd: Username/Password, API key or RSA tokens."))
}
return
}
func getPackageFiles(packageName string) []tests.PackageSearchResultItem {
apiUrl := bintrayConfig.ApiUrl + path.Join("packages", bintrayConfig.User, tests.BintrayRepo1, packageName, "files?include_unpublished=1")
clientDetails := ioutils.HttpClientDetails{
User: bintrayConfig.User,
Password: bintrayConfig.Key,
Headers: map[string]string{"Content-Type": "application/json"}}
resp, body, _, err := ioutils.SendGet(apiUrl, true, clientDetails)
if cliutils.CheckError(err) != nil {
os.Exit(1)
}
if resp.StatusCode != 200 {
log.Error(resp.Status)
log.Error(string(body))
os.Exit(1)
}
var result []tests.PackageSearchResultItem
err = json.Unmarshal(body, &result)
if err != nil {
log.Error(err)
os.Exit(1)
}
return result
}
func MoveFilesWrapper(moveSpec *SpecFiles, flags *MoveFlags, moveType MoveType) (err error) {
err = PreCommandSetup(flags)
if err != nil {
return
}
var successCount int
var failedCount int
for i := 0; i < len(moveSpec.Files); i++ {
var successPartial, failedPartial int
switch moveSpec.Get(i).GetSpecType() {
case WILDCARD:
successPartial, failedPartial, err = moveWildcard(moveSpec.Get(i), flags, moveType)
case SIMPLE:
successPartial, failedPartial, err = moveSimple(moveSpec.Get(i), flags, moveType)
case AQL:
successPartial, failedPartial, err = moveAql(moveSpec.Get(i), flags, moveType)
}
successCount += successPartial
failedCount += failedPartial
if err != nil {
return
}
}
log.Info(moveMsgs[moveType].MovedMsg, strconv.Itoa(successCount), "artifacts.")
if failedCount > 0 {
err = cliutils.CheckError(errors.New("Failed " + moveMsgs[moveType].MovingMsg + " " + strconv.Itoa(failedCount) + " artifacts."))
}
return
}
func CreateVersionDetails(versionStr string) (*VersionDetails, error) {
parts := strings.Split(versionStr, "/")
size := len(parts)
if size < 1 || size > 4 {
err := cliutils.CheckError(errors.New("Unexpected format for argument: " + versionStr))
if err != nil {
return nil, err
}
}
var subject, repo, pkg, version string
if size >= 2 {
subject = parts[0]
repo = parts[1]
}
if size >= 3 {
pkg = parts[2]
}
if size == 4 {
version = parts[3]
}
return &VersionDetails{
Subject: subject,
Repo: repo,
Package: pkg,
Version: version}, nil
}
func Send(method string, url string, content []byte, allowRedirect bool,
closeBody bool, httpClientsDetails HttpClientDetails) (resp *http.Response, respBody []byte, redirectUrl string, err error) {
var req *http.Request
if content != nil {
req, err = http.NewRequest(method, url, bytes.NewBuffer(content))
} else {
req, err = http.NewRequest(method, url, nil)
}
err = cliutils.CheckError(err)
if err != nil {
return
}
req.Close = true
setAuthentication(req, httpClientsDetails)
addUserAgentHeader(req)
if httpClientsDetails.Headers != nil {
for name := range httpClientsDetails.Headers {
req.Header.Set(name, httpClientsDetails.Headers[name])
}
}
client := getHttpClient(httpClientsDetails.Transport)
if !allowRedirect {
client.CheckRedirect = func(req *http.Request, via []*http.Request) error {
redirectUrl = req.URL.String()
return errors.New("redirect")
}
}
resp, err = client.Do(req)
if !allowRedirect && err != nil {
return
}
err = cliutils.CheckError(err)
if err != nil {
return
}
if closeBody {
defer resp.Body.Close()
respBody, _ = ioutil.ReadAll(resp.Body)
}
return
}
func saveLicense(filepath string, content []byte) (err error) {
if filepath == "" {
return
}
err = ioutil.WriteFile(filepath, content, 0777)
err = cliutils.CheckError(err)
return
}
func calcSha1(filePath string) (string, error) {
file, err := os.Open(filePath)
cliutils.CheckError(err)
if err != nil {
return "", err
}
defer file.Close()
var resSha1 []byte
hashSha1 := sha1.New()
_, err = io.Copy(hashSha1, file)
err = cliutils.CheckError(err)
if err != nil {
return "", err
}
return hex.EncodeToString(hashSha1.Sum(resSha1)), nil
}
func AttachLic(instanceName string, flags *AttachLicFlags) error {
prepareLicenseFile(flags.LicensePath, flags.Override)
postContent := utils.LicenseRequestContent{
Name: instanceName,
NodeID: flags.NodeId,
Deploy: flags.Deploy}
requestContent, err := json.Marshal(postContent)
if err != nil {
return cliutils.CheckError(errors.New("Failed to marshal json. " + cliutils.GetDocumentationMessage()))
}
missionControlUrl := flags.MissionControlDetails.Url + "api/v1/buckets/" + flags.BucketId + "/licenses"
httpClientDetails := utils.GetMissionControlHttpClientDetails(flags.MissionControlDetails)
resp, body, err := ioutils.SendPost(missionControlUrl, requestContent, httpClientDetails)
if err != nil {
return err
}
if resp.StatusCode != 200 {
if flags.LicensePath != "" {
os.Remove(flags.LicensePath)
}
return cliutils.CheckError(errors.New(resp.Status + ". " + utils.ReadMissionControlHttpMessage(body)))
}
fmt.Println("Mission Control response: " + resp.Status)
if flags.LicensePath == "" {
var m Message
m, err = extractJsonValue(body)
if err != nil {
return err
}
requestContent, err = json.Marshal(m)
err = cliutils.CheckError(err)
if err != nil {
return err
}
fmt.Println(string(requestContent))
} else {
var licenseKey []byte
licenseKey, err = getLicenseFromJson(body)
if err != nil {
return err
}
err = saveLicense(flags.LicensePath, licenseKey)
}
return nil
}
func GetBuildDir(buildName, buildNumber string) (string, error) {
tempDir := os.TempDir()
buildsDir := tempDir + "/jfrog/builds/" + buildName + "_" + buildNumber + "/"
err := os.MkdirAll(buildsDir, 0777)
if cliutils.CheckError(err) != nil {
return "", err
}
return buildsDir, nil
}
