jfrogclient

package module
v1.46.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 29, 2024 License: Apache-2.0 Imports: 1 Imported by: 0

README

JFrog Go Client

Scanned by Frogbot

Branch Status
master Build status Static Analysis
dev Build status Static Analysis

Table of Contents

General

jfrog-client-go is a library which provides Go APIs to performs actions on JFrog Artifactory, Xray and Distribution from your Go application. The project is still relatively new, and its APIs may therefore change frequently between releases. The library can be used as a go-module, which should be added to your project's go.mod file. As a reference you may look at JFrog CLI' s go.mod file, which uses this library as a dependency.

Pull Requests

We welcome pull requests from the community.

Guidelines
  • If the existing tests do not already cover your changes, please add tests.
  • Pull requests should be created on the dev branch.
  • Please use gofmt for formatting the code before submitting the pull request.

Tests

To run the tests on the source code, you'll need a running JFrog instance. See the Prerequisites column in the Test Types section below for more information.

Use the following command with the below options to run the tests.

go test -v github.com/jfrog/jfrog-client-go/tests -timeout 0 [test-types] [flags]

If you'd like to run a specific test, add the test function name using the -run flag. For example:

go test -v github.com/jfrog/jfrog-client-go/tests -timeout 0 -run TestGetArtifactoryVersionWithCustomHttpClient -test.artifactory -rt.url=http://127.0.0.1:8081/artifactory -rt.user=admin -rt.password=password

Note: The tests create an Artifactory repository named jfrog-client-tests-repo1. Once the tests are completed, the content of this repository is deleted.

Flags
Test Types
Type Description Prerequisites
-test.artifactory Artifactory tests Artifactory Pro
-test.distribution Distribution tests Artifactory with Distribution
-test.xray Xray tests Artifactory with Xray
-test.xsc Xsc tests Xray with Xsc
-test.pipelines Pipelines tests JFrog Pipelines
-test.access Access tests Artifactory Pro
-test.repositories Repositories tests Artifactory Pro
-test.mpu Multipart upload tests Artifactory Pro with S3 storage
Connection Details
Flag Description
-rt.url [Default: http://localhost:8081/artifactory] Artifactory URL.
-ds.url [Optional] JFrog Distribution URL.
-xr.url [Optional] JFrog Xray URL.
-xsc.url [Optional] JFrog Xsc URL.
-pipe.url [Optional] JFrog Pipelines URL.
-access.url [Optional] JFrog Access URL.
-rt.user [Default: admin] Artifactory username.
-rt.password [Default: password] Artifactory password.
-rt.apikey [Optional] Artifactory API key.
-rt.sshKeyPath [Optional] Ssh key file path. Should be used only if the Artifactory URL format is ssh://[domain]:port
-rt.sshPassphrase [Optional] Ssh key passphrase.
-pipe.accessToken [Optional] Pipelines access token.
-pipe.vcsToken [Optional] Vcs token for Pipelines tests (should have admin permissions).
-pipe.vcsRepo [Optional] Vcs full repo path for Pipelines tests (ex: "domain/myrepo").
-pipe.vcsBranch [Optional] Vcs branch for Pipelines tests (ex: "main").
-access.token [Optional] Access access token.
-ci.runId [Optional] A unique identifier used as a suffix to create repositories in the tests.

General APIs

Setting the Logger

Default logger:

log.SetLogger(log.NewLogger(log.INFO, nil))

You may also log to a file, and/or add log prefixes as shown below:

var file *os.File
// Log flags as described in https://pkg.go.dev/log#pkg-constants.
logFlags := Ldate | Ltime
...
log.SetLogger(log.NewLoggerWithFlags(log.DEBUG, file, logFlags))
Setting the Temp Dir

The default temp dir used is 'os.TempDir()'. Use the following API to set a new temp dir:

fileutils.SetTempDirBase(filepath.Join("my", "temp", "path"))

Artifactory APIs

Creating Artifactory Service Manager
Creating Artifactory Details
rtDetails := auth.NewArtifactoryDetails()
rtDetails.SetUrl("http://localhost:8081/artifactory")
rtDetails.SetSshKeyPath("path/to/.ssh/")
rtDetails.SetApiKey("apikey")
rtDetails.SetUser("user")
rtDetails.SetPassword("password")
rtDetails.SetAccessToken("accesstoken")
// if client certificates are required
rtDetails.SetClientCertPath("path/to/.cer")
rtDetails.SetClientCertKeyPath("path/to/.key")
Creating Artifactory Details with Custom HTTP Client
proxyUrl, err := url.Parse("http://proxyIp:proxyPort")
myCustomClient := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}

rtDetails := auth.NewArtifactoryDetails()
rtDetails.SetUrl("http://localhost:8081/artifactory")
rtDetails.SetSshKeysPath("path/to/.ssh/")
rtDetails.SetApiKey("apikey")
rtDetails.SetUser("user")
rtDetails.SetPassword("password")
rtDetails.SetAccessToken("accesstoken")
serviceConfig, err := config.NewConfigBuilder().
    SetServiceDetails(rtDetails).
    SetDryRun(false).
    SetHttpClient(myCustomClient).
    Build()
Creating Artifactory Service Config
serviceConfig, err := config.NewConfigBuilder().
    SetServiceDetails(rtDetails).
    SetCertificatesPath(certPath).
    SetThreads(threads).
    SetDryRun(false).
    // Add [Context](https://golang.org/pkg/context/)
    SetContext(ctx).
    // Optionally overwrite the default dial timeout, which is set to 30 seconds.
    SetDialTimeout(180 * time.Second).
    // Optionally set the total HTTP request timeout.
    SetOverallRequestTimeout(10 * time.Minute).
    // Optionally overwrite the default HTTP retries, which is set to 3.
    SetHttpRetries(8).
    Build()
Creating New Artifactory Service Manager
rtManager, err := artifactory.New(serviceConfig)
Using Artifactory Services
Uploading Files to Artifactory

Using the UploadFiles() function, we can upload files and get the general statistics of the action (The actual number of successful and failed uploads), and the error value if it occurred.

params := services.NewUploadParams()
params.Pattern = "repo/*/*.zip"
params.Target = "repo/path/"
params.AddVcsProps = false
params.BuildProps = "build.name=buildName;build.number=17;build.timestamp=1600856623553"
params.Recursive = true
params.Regexp = false
params.IncludeDirs = false
params.Flat = true
params.ExplodeArchive = false
params.Archive = "zip"
params.Deb = ""
params.Symlink = false
params.Exclusions = "(.*)a.zip"
// Retries default value: 3
params.Retries = 5
// The maximum number of parts that can be concurrently uploaded per file during a multi-part upload. Set to 0 to disable multi-part upload.
// SplitCount default value: 5
params.SplitCount = 10
// The minimum file size in MiB required to attempt a multi-part upload.
// MinSplitSize default value: 200
params.MinSplitSize = 100
// The upload chunk size in MiB that can be concurrently uploaded during a multi-part upload.
params.ChunkSize = 5
// The min file size in bytes for "checksum deploy".
// "Checksum deploy" is the action of calculating the file checksum locally, before
// the upload, and skipping the actual file transfer if the file already
// exists in Artifactory.
// MinChecksumDeploy default value: 10400
params.MinChecksumDeploy = 15360
// Set to false to disable all checksum calculation, including "checksum deploy".
// ChecksumsCalcEnabled default value: true
params.ChecksumsCalcEnabled = false
// Attach properties to the uploaded files
targetProps := utils.NewProperties()
targetProps.AddProperty("key1", "val1")
params.TargetProps = targetProps
// When using the 'archive' option for upload, we can control the target path inside the uploaded archive using placeholders. This operation determines the TargetPathInArchive value.
TargetPathInArchive := "archive/path/"
// Size limit for files to be uploaded.
SizeLimit= &fspatterns.SizeThreshold{SizeInBytes: 10000, Condition: fspatterns.LessThan}
totalUploaded, totalFailed, err := rtManager.UploadFiles(params)
Downloading Files from Artifactory

Using the DownloadFiles() function, we can download files and get the general statistics of the action (The actual number of files downloaded, and the number of files we expected to download). In addition, we get the error value if it occurred.

params := services.NewDownloadParams()
params.Pattern = "repo/*/*.zip"
params.Target = "target/path/"
// Filter the downloaded files by properties.
params.Props = "key1=val1;key2=val2"
params.Recursive = true
params.IncludeDirs = false
params.Flat = false
params.Explode = false
params.Symlink = true
params.ValidateSymlink = false
params.Exclusions = "(.*)a.zip"
// Retries default value: 3
params.Retries = 5
// SplitCount default value: 3
params.SplitCount = 2
// MinSplitSize default value: 5120
params.MinSplitSize = 7168
// Optional fields to avoid AQL request
Sha256 = "5feceb66ffc86f38d952786c6d696c79c2dbc239dd4e91b46729d73a27fb57e9"
Size = 1000
totalDownloaded, totalFailed, err := rtManager.DownloadFiles(params)
Downloading Release Bundles v1 from Artifactory

Using the DownloadFiles() function, we can download release bundles v1 and get the general statistics of the action (The actual number of files downloaded, and the number of files we expected to download). In addition, we get the error value if it occurred.

It is possible to validate the downloaded release bundle's files by providing a local path to a GPG public key file (the public GPG key should of course correspond to the private GPG key which was used to sign the release bundle).

params := services.NewDownloadParams()
// Path on the local file system to which the files should be downloaded.
params.Target = "target/path/"
// Bundle's name and version should be separated with "/".
params.Bundle = "bundleName/10"
// Optional GPG validation
params.PublicGpgKey = "public/key/file/path"
totalDownloaded, totalFailed, err := rtManager.DownloadFiles(params)

Read more about GPG signing release bundles v1 here.

Uploading and Downloading Files with Summary

The methods UploadFilesWithSummary() and DownloadFilesWithSummary() are similar to UploadFlies() and DownloadFlies(), but return an OperationSummary struct, which allows iterating over the details of the uploaded/downloaded files.
The OperationSummary struct contains:

  • TotalSucceeded - the number of successful uploads/downloads
  • TotalFailed - the number of failed uploads/downloads
  • TransferDetailsReader - a ContentReader of FileTransferDetails structs, with a struct for each successful transfer of file
  • ArtifactsDetailsReader - a ContentReader of ArtifactDetails structs, with a struct for each artifact in Artifactory that was uploaded/downloaded successfully

The ContentReaders can be closed separately by calling Close() on each of them, or they both can be closed at once by calling Close() on the OperationSummary struct.

params := services.NewUploadParams()
params.Pattern = "repo/*/*.zip"
params.Target = "repo/path/"

summary, err := rtManager.UploadFilesWithSummary(params)
defer summary.Close()
reader, totalDownloaded, totalExpected, err := rtManager.DownloadFilesWithResultReader(params)

// Iterate over each file
for currentFileInfo := new(utils.FileInfo); reader.NextRecord(currentFileInfo) == nil; currentFileInfo = new(utils.FileInfo) {
     fmt.Printf("File path: %s\n", currentFileInfo.LocalPath)
}

if err := reader.GetError(); err != nil {
    return err
}

Read more about ContentReader.

Copying Files in Artifactory
params := services.NewMoveCopyParams()
params.Pattern = "repo/*/*.zip"
params.Target = "target/path/"
// Filter the files by properties.
params.Props = "key1=val1;key2=val2"
params.Recursive = true
params.Flat = false

rtManager.Copy(params)
Moving Files in Artifactory
params := services.NewMoveCopyParams()
params.Pattern = "repo/*/*.zip"
params.Target = "target/path/"
// Filter the files by properties.
params.Props = "key1=val1;key2=val2"
params.Recursive = true
params.Flat = false

rtManager.Move(params)
Deleting Files from Artifactory
params := services.NewDeleteParams()
params.Pattern = "repo/*/*.zip"
// Filter the files by properties.
params.Props = "key1=val1;key2=val2"
params.Recursive = true

pathsToDelete, err := rtManager.GetPathsToDelete(params)
if err != nil {
    return err
}
defer pathsToDelete.Close()
rtManager.DeleteFiles(pathsToDelete)

Read more about ContentReader.

Searching Files in Artifactory
params := services.NewSearchParams()
params.Pattern = "repo/*/*.zip"
// Filter the files by properties.
params.Props = "key1=val1;key2=val2"
params.Recursive = true

reader, err := rtManager.SearchFiles(params)
if err != nil {
    return err
}
defer reader.Close()

Read more about ContentReader.

Setting Properties on Files in Artifactory
searchParams = services.NewSearchParams()
searchParams.Recursive = true
searchParams.IncludeDirs = false

reader, err = rtManager.SearchFiles(searchParams)
if err != nil {
    return err
}
defer reader.Close()
propsParams = services.NewPropsParams()
propsParams.Pattern = "repo/*/*.zip"
propsParams.Reader = reader
// Filter the files by properties.
propsParams.Props = "key=value"

rtManager.SetProps(propsParams)

Read more about ContentReader.

Deleting Properties from Files in Artifactory
searchParams = services.NewSearchParams()
searchParams.Recursive = true
searchParams.IncludeDirs = false

resultItems, err = rtManager.SearchFiles(searchParams)
if err != nil {
    return err
}
defer reader.Close()
propsParams = services.NewPropsParams()
propsParams.Pattern = "repo/*/*.zip"
propsParams.Reader = reader
// Filter the files by properties.
propsParams.Props = "key=value"

rtManager.DeleteProps(propsParams)
Getting Properties from Files in Artifactory
rtManager.GetItemProperties("repo/path/file")

Read more about ContentReader.

Publishing Build Info to Artifactory
buildInfo := &buildinfo.BuildInfo{}
// Optional Artifactory project key
projectKey := "my-project-key"
...
rtManager.PublishBuildInfo(buildInfo, projectKey)
Fetching Build Info from Artifactory
buildInfoParams := services.NewBuildInfoParams{}
buildInfoParams.BuildName = "buildName"
buildInfoParams.BuildNumber = "LATEST"
// Optional Artifactory project key
buildInfoParams.ProjectKey = "my-project-key"

rtManager.GetBuildInfo(buildInfoParams)
Promoting Published Builds in Artifactory
params := services.NewPromotionParams()
params.BuildName = "buildName"
params.BuildNumber = "10"
params.TargetRepo = "target-repo"
params.Status = "status"
params.Comment = "comment"
params.Copy = &trueValue
params.FailFast = true
params.IncludeDependencies = &falseValue
params.SourceRepo = "source-repo"
// Optional Artifactory project key
params.ProjectKey = "my-project-key"

rtManager.PromoteBuild(params)
Promoting a Docker Image in Artifactory
sourceDockerImage := "hello-world"
sourceRepo := "docker-local-1"
targetRepo := "docker-local-2"
params := services.NewDockerPromoteParams(sourceDockerImage, sourceRepo, targetRepo)

// Optional parameters:
params.TargetDockerImage = "target-docker-image"
params.SourceTag = "42"
params.TargetTag = "43"
params.Copy = true

rtManager.PromoteDocker(params)
Triggering Build Scanning with JFrog Xray
params := services.NewXrayScanParams()
params.BuildName = buildName
params.BuildNumber = buildNumber

rtManager.XrayScanBuild(params)
Discarding Old Builds
params := services.NewDiscardBuildsParams()
params.BuildName = "buildName"
params.MaxDays = "max-days"
params.MaxBuilds = "max-builds"
params.ExcludeBuilds = "1,2"
params.DeleteArtifacts = false
params.Async = false
// Optional Artifactory project key
projectKey := "my-project-key"

rtManager.DiscardBuilds(params)
Cleaning Unreferenced Git LFS Files from Artifactory
params := services.NewGitLfsCleanParams()
params.Refs = "refs/remotes/*"
params.Repo = "my-project-lfs"
params.GitPath = "path/to/git"

reader,err := rtManager.GetUnreferencedGitLfsFiles(params)

defer reader.Close()
rtManager.DeleteFiles(reader)
Executing AQLs
rtManager.Aql(aql string)
Reading Files in Artifactory
rtManager.ReadRemoteFile(FilePath string)
Creating an Artifactory Access Token
params := services.NewCreateTokenParams()
params.Scope = "api:* member-of-groups:readers"
params.Username = "user"
params.ExpiresIn = 3600 // default -1 (use server default)
params.GrantType = "client_credentials"
params.Refreshable = true
params.Audience = "jfrt@<serviceID1> jfrt@<serviceID2>"

results, err := rtManager.CreateToken(params)
Fetching Artifactory Access Tokens
results, err := rtManager.GetTokens()
Fetching Artifactory Access Tokens of a User
results, err := rtManager.GetUserTokens(username)
Refreshing an Artifactory Access Token
params := services.NewRefreshTokenParams()
params.AccessToken = "<access token>"
params.RefreshToken = "<refresh token>"
params.Token.Scope = "api:*"
params.Token.ExpiresIn = 3600
results, err := rtManager.RefreshToken(params)
Revoking an Artifactory Access Token
params := services.NewRevokeTokenParams()

// Provide either TokenId or Token
params.TokenId = "<token id>"
// params.Token = "access token"

err := rtManager.RevokeToken(params)
Create API Key
// Returns an error if API key already exists - use RegenerateAPIKey instead.
apiKey, err := rtManager.CreateAPIKey()
Regenerate API Key
apiKey, err := rtManager.RegenerateAPIKey()
Get API Key
apiKey, err := rtManager.GetAPIKey()
Creating and Updating Local Repository

You can create and update a local repository for the following package types:

Alpine, Bower, Cran, Cargo, Chef, Cocoapods, Composer, Conan, Conda, Debian, Docker, Gems, Generic, Gitlfs, Go, Gradle, Helm, Ivy, Maven, Npm, Nuget, Opkg, Puppet, Pypi, Rpm, Sbt, Swift, Terraform, Vagrant, and Yum.

Each package type has its own parameters struct, can be created using the method New<packageType>LocalRepositoryParams().

Example for creating local Generic repository:

params := services.NewGenericLocalRepositoryParams()
params.Key = "generic-repo"
params.Description = "This is a public description for generic-repo"
params.Notes = "These are internal notes for generic-repo"
params.RepoLayoutRef = "simple-default"
params.ArchiveBrowsingEnabled = true
params.XrayIndex = true
params.IncludesPattern = "**/*"
params.ExcludesPattern = "excludedDir/*"
params.DownloadRedirect = true

err = servicesManager.CreateLocalRepository().Generic(params)

You can also create a local repository with basic local params:

params := services.NewLocalRepositoryBaseParams()
params.Key = "generic-repo"
params.PackageType = "generic"
params.Description = "This is a public description for generic-repo"
err := servicesManager.CreateLocalRepository(params)

Updating local Generic repository:

err = servicesManager.UpdateLocalRepository().Generic(params)
Creating and Updating Remote Repository

You can create and update a remote repository for the following package types:

Alpine, Bower, Cran, Cargo, Chef, Cocoapods, Composer, Conan, Conda, Debian, Docker, Gems, Generic, Gitlfs, Go, Gradle, Helm, Ivy, Maven, Npm, Nuget, Opkg, P2, Puppet, Pypi, Rpm, Sbt, Swift, Terraform, Vcs, and Yum.

Each package type has its own parameters struct, can be created using the method New<packageType>RemoteRepositoryParams().

Example for creating remote Maven repository:

params := services.NewMavenRemoteRepositoryParams()
params.Key = "maven-central-remote"
params.Url = "https://repo.maven.apache.org"
params.RepoLayoutRef = "maven-2-default"
params.Description = "A caching proxy repository for Maven central"
params.HandleSnapshot = false
params.HandleReleases = true
params.FetchJarsEagerly = true
params.XrayIndex = true
params.AssumedOfflinePeriodSecs = 600
params.SuppressPomConsistencyChecks = true
params.RemoteRepoChecksumPolicyType = "pass-thru"

err = servicesManager.CreateRemoteRepository().Maven(params)

Updating remote Maven repository:

err = servicesManager.UpdateRemoteRepository().Maven(params)

You can also create a remote repository with basic remote params:

params := services.NewRemoteRepositoryBaseParams()
params.Key = "remote-repo"
params.Url = "https://repo.maven.apache.org"
err := servicesManager.CreateRemoteRepository(params)
Creating and Updating Virtual Repository

You can create and update a virtual repository for the following package types:

Alpine, Bower, Cran, Chef, Conan, Conda, Debian, Docker, Gems, Generic, Gitlfs, Go, Gradle, Helm, Ivy, Maven, Npm, Nuget, P2, Puppet, Pypi, Rpm, Sbt, Swift, Terraform and Yum.

Each package type has its own parameters struct, can be created using the method New<packageType>VirtualRepositoryParams().

Example for creating virtual Go repository:

params := services.NewGoVirtualRepositoryParams()
params.Description = "This is an aggregated repository for several go repositories"
params.RepoLayoutRef = "go-default"
params.Repositories = {"gocenter-remote", "go-local"}
params.DefaultDeploymentRepo = "go-local"
params.ExternalDependenciesEnabled = true
params.ExternalDependenciesPatterns = {"**/github.com/**", "**/golang.org/**", "**/gopkg.in/**"}
params.ArtifactoryRequestsCanRetrieveRemoteArtifacts = true

err = servicesManager.CreateVirtualRepository().Go(params)

You can also create a virtual repository with basic virtual params:

params := services.NewVirtualRepositoryBaseParams()
params.Key = "generic-repo"
params.PackageType = "generic"
params.Description = "This is a public description for generic-repo"
params.Repositories = string[]{"remote-repo","local-repo"}
err := servicesManager.CreateVirtualRepository(params)

Updating virtual Go repository:

err = servicesManager.UpdateVirtualRepository().Go(params)
Creating and Updating Federated Repository

You can create and update a federated repository for the following package types:

Alpine, Bower, Cran, Cargo, Chef, Cocoapods, Composer, Conan, Conda, Debian, Docker, Gems, Generic, Gitlfs, Go, Gradle, Helm, Ivy, Maven, Npm, Nuget, Opkg, Puppet, Pypi, Rpm, Sbt, Swift, Terraform, Vagrant and Yum

Each package type has its own parameters struct, can be created using the method New<packageType>FederatedRepositoryParams().

Example for creating federated Generic repository:

params := services.NewGenericFederatedRepositoryParams()
params.Key = "generic-repo"
params.Description = "This is a public description for generic-repo"
params.Notes = "These are internal notes for generic-repo"
params.RepoLayoutRef = "simple-default"
params.ArchiveBrowsingEnabled = true
params.XrayIndex = true
params.IncludesPattern = "**/*"
params.ExcludesPattern = "excludedDir/*"
params.DownloadRedirect = true
params.Members = []services.FederatedRepositoryMemberParams{
		{Url: "http://targetartifactory/artifactory/federatedRepositoryName", Enabled: true},
	}
err = servicesManager.CreateFederatedRepository().Generic(params)

You can also create a federated repository with basic federated params:

params := services.NewFederatedRepositoryBaseParams()
params.Key = "generic-repo"
params.PackageType = "generic"
params.Description = "This is a public description for generic-repo"
params.Members = []services.FederatedRepositoryMemberParams{
		{Url: "http://targetartifactory/artifactory/federatedRepositoryName", Enabled: true},
	}
err := servicesManager.CreateFederatedRepository(params)

Updating federated Generic repository:

err = servicesManager.UpdateFederatedRepository().Generic(params)
Removing a Repository

You can remove a repository from Artifactory using its key:

servicesManager.DeleteRepository("generic-repo")
Getting Repository Details

You can get repository details from Artifactory using its key, and the desired params struct. The function expects to get the repo key (name) and a pointer to a param struct that will be filled up. The param struct should contain the desired params fields corresponded to the Artifactory REST API:

repoDetails = services.RepositoryDetails{}
err := servicesManager.GetRepository("maven-repo", &repoDetails)

repoDetails = services.LocalRepositoryBaseParams{}
err := servicesManager.GetRepository("maven-repo", &repoDetails)

repoDetails = services.MavenLocalRepositoryParams{}
err := servicesManager.GetRepository("maven-repo", &repoDetails)

services.RepositoryDetails

Getting All Repositories

You can get all repositories from Artifactory:

servicesManager.GetAllRepositories()

You can get all repositories from Artifactory filtered according to theirs type and/or theirs package type:

params := services.NewRepositoriesFilterParams()
params.RepoType = "remote"
params.PackageType = "maven"
params.ProjectKey = "project-key"
err := servicesManager.GetAllRepositoriesFiltered(params)
Check if Repository Exists

You can check whether a repository exists in Artifactory:

exists, err := servicesManager.IsRepoExists()
Creating and Updating Repository Replications

Example of creating a repository replication:

params := services.NewCreateReplicationParams()
// Source replication repository.
params.RepoKey = "my-repository"
params.CronExp = "0 0 12 * * ?"
params.Username = "admin"
params.Password = "password"
params.Url = "http://localhost:8081/artifactory/remote-repo"
params.Enabled = true
params.SocketTimeoutMillis = 15000
params.EnableEventReplication = true
params.SyncDeletes = true
params.SyncProperties = true
params.SyncStatistics = true
params.PathPrefix = "/path/to/repo"

err = servicesManager.CreateReplication(params)

Example of updating a local repository replication:

params := services.NewUpdateReplicationParams()
// Source replication repository.
params.RepoKey = "my-repository"
params.CronExp = "0 0 12 * * ?"
params.Enabled = true
params.SocketTimeoutMillis = 15000
params.EnableEventReplication = true
params.SyncDeletes = true
params.SyncProperties = true
params.SyncStatistics = true
params.PathPrefix = "/path/to/repo"

err = servicesManager.UpdateReplication(params)
Getting a Repository Replication

You can get a repository replication configuration from Artifactory using its key:

replicationConfiguration, err := servicesManager.GetReplication("my-repository")
Removing a Repository Replication

You can remove a repository replication configuration from Artifactory using its key:

err := servicesManager.DeleteReplication("my-repository")
Converting a Local Repository to a Federated Repository

You can convert a local repository to a federated repository using its key:

err := servicesManager.ConvertLocalToFederatedRepository("my-repository")
Triggering a Full Federated Repository Synchronisation

You can trigger a full federated repository synchronisation for all members using its key:

err := servicesManager.TriggerFederatedRepositoryFullSyncAll("my-repository")

You can also trigger a full federated repository synchronisation for a specific member using its key and the members URL

err := servicesManager.TriggerFederatedRepositoryFullSyncMirror("my-repository", "http://localhost:8081/artifactory/my-repository")
Creating and Updating Permission Targets

You can create or update a permission target in Artifactory. Permissions are set according to the following conventions: read, write, annotate, delete, manage, managedXrayMeta, distribute For repositories You can specify the name "ANY" in order to apply to all repositories, "ANY REMOTE" for all remote repositories or "ANY LOCAL" for all local repositories.

Creating a new permission target :

params := services.NewPermissionTargetParams()
params.Name = "java-developers"
params.Repo = &services.PermissionTargetSection{}
params.Repo.Repositories = []string{"ANY REMOTE", "local-repo1", "local-repo2"}
params.Repo.ExcludePatterns = []string{"dir/*"}
params.Repo.Actions = &services.Actions{}
params.Repo.Actions.Users = map[string][]string{
    "user1": {"read", "write"},
    "user2": {"write", "annotate", "read"},
}
params.Repo.Actions.Groups = map[string][]string{
    "group1": {"manage", "read", "annotate"},
}
// This is the default value that cannot be changed
params.Build = &services.PermissionTargetSection{}
params.Build.Repositories = []string{"artifactory-build-info"}
params.Build.Actions = &services.Actions{}
params.Build.Actions.Groups = map[string][]string{
    "group1": {"manage", "read", "write", "annotate", "delete"},
    "group2": {"read"},
}

err := testsPermissionTargetService.Create(params)

Updating an existing permission target :

err = servicesManager.UpdatePermissionTarget(params)
Removing a Permission Target

You can remove a permission target from Artifactory using its name:

err = servicesManager.DeletePermissionTarget("java-developers")
Fetching a Permission Target

You can fetch a permission target from Artifactory using its name:

permissionTargetParams, err = servicesManager.GetPermissionTarget("java-developers")

If the requested permission target does not exist, a nil value is returned for the permissionTargetParams param, with a nil error value

Fetching Artifactory's Version
version, err := servicesManager.GetVersion()
Fetching Running Artifactory Nodes in a Cluster
runningNodes, err := servicesManager.GetRunningNodes()
Fetching Artifactory's Service ID
serviceId, err := servicesManager.GetServiceId()
Fetching Artifactory's Config Descriptor

Notice: This API is enabled only on self-hosted Artifactory servers

serviceId, err := servicesManager.GetConfigDescriptor()
Activating Artifactory's Key Encryption

Notice: This API is enabled only on self-hosted Artifactory servers

err := servicesManager.ActivateKeyEncryption()
Deactivating Artifactory's Key Encryption

Notice: This API is enabled only on self-hosted Artifactory servers

wasEncrypted, err := servicesManager.DeactivateKeyEncryption()
Fetching Users Details
params := services.NewUserParams()
params.UserDetails.Name = "myUserName"

user, err := serviceManager.GetUser(params)

If the requested user does not exist, a nil value is returned for the User param, with a nil error value

Fetching All Users Details

You can get all users from Artifactory:

users, err := servicesManager.GetAllUsers()
Creating Inviting and Updating a User
params := services.NewUserParams()
params.UserDetails.Name = "myUserName"
params.UserDetails.Email = "myUser@jfrog.com"
params.UserDetails.Password = "Password1"
params.UserDetails.Admin = &falseValue
params.UserDetails.Realm = "internal"
params.UserDetails.ProfileUpdatable = &trueValue
params.UserDetails.DisableUIAccess = &falseValue
params.UserDetails.InternalPasswordDisabled = &falseValue
params.UserDetails.groups = []string{"GroupA", "GroupB"}
// Set to true to replace existing user with the same name.
params.ReplaceIfExists = false
err := serviceManager.CreateUser(params)

// Inviting user to the platform.
param.UserDetails.ShouldInvite = &trueValue
param.UserDetails.Source = "cli"
err := serviceManager.CreateUser(params)

params.UserDetails.groups = []string{"GroupA", "GroupB", "GroupC"}
err := serviceManager.UpdateUser(params)

// Set to true to remove a user from every group.
params.UserDetails.ClearGroups = true
err := serviceManager.UpdateUser(params)
Deleting a User
err := serviceManager.DeleteUser("myUserName")
Fetching Locked Out Users
lockedUsers, err := serviceManager.GetLockedUsers()
Unlock Locked Out User

Unlocks a locked out user. This function succeeds even if the user doesn't exist or not locked.

err := serviceManager.UnlockUser("userToUnlock")
Fetching All Groups

You can get all groups from Artifactory

groups, err := serviceManager.GetAllGroups()
Fetching Group Details
params := services.NewGroupParams()
params.GroupDetails.Name = "myGroupName"
// Set this param to true to receive the usernames associated with this group
params.IncludeUsers = true

group, err := serviceManager.GetGroup(params)

If the requested group does not exist, a nil value is returned for the Group param, with a nil error value

Creating and Updating a Group
params := services.NewGroupParams()
params.GroupDetails.Name = "myGroupName"
params.GroupDetails.Description = "Description"
params.GroupDetails.AutoJoin = &falseValue
params.GroupDetails.AdminPrivileges = &trueValue
params.GroupDetails.Realm = "internal"
params.GroupDetails.UsersNames = [2]string{"UserA", "UserB"}
// Set to true in order to replace exist group with the same name
params.ReplaceIfExists = false
err := serviceManager.CreateGroup(params)

params.GroupDetails.Description = "Newer Description"
// Will add UserC to the group (in addition to existing UserA and UserB)
params.GroupDetails.UsersNames = [1]string{"UserC"}

err := serviceManager.UpdateGroup(params)
Deleting a Group
err := serviceManager.DeleteGroup("myGroupName")
Generating Full System Export
params := services.NewExportParams("/tmp/")
err := serviceManager.Export(params)
Getting Info of a Folder in Artifactory
serviceManager.FolderInfo("repo/path/")
Getting Info of a File in Artifactory
serviceManager.FileInfo("repo/path/file")
Getting a listing of files and folders within a folder in Artifactory
optionalParams := servicesutils.NewFileListParams()
optionalParams.Deep=               true
optionalParams.Depth=              2
optionalParams.ListFolders=        true
optionalParams.MetadataTimestamps= true
optionalParams.IncludeRootPath=    true
serviceManager.FileList("repo/path/", optionalParams)
Getting Storage Summary Info of Artifactory
storageInfo, err := serviceManager.GetStorageInfo()
Triggering Storage Info Recalculation in Artifactory
err := serviceManager.CalculateStorageInfo()

Access APIs

Creating Access Service Manager
Creating Access Details
accessDetails := accessAuth.NewAccessDetails()
accessDetails.SetUrl("http://localhost:8081/access/")
accessDetails.SetSshKeyPath("path/to/.ssh/")
accessDetails.SetApiKey("apikey")
accessDetails.SetUser("user")
accessDetails.SetPassword("password")
accessDetails.SetAccessToken("accesstoken")
// if client certificates are required
accessDetails.SetClientCertPath("path/to/.cer")
accessDetails.SetClientCertKeyPath("path/to/.key")
Creating Access Service Config
serviceConfig, err := clientConfig.NewConfigBuilder().
SetServiceDetails(accessAuth).
SetCertificatesPath(certsPath).
SetInsecureTls(accessDetails.InsecureTls).
SetDryRun(isDryRun).
Build()
Creating New Access Service Manager
accessManager, err := access.New(serviceConfig)
Using Access Services
Creating a New Project
adminPriviligies := accessServices.AdminPrivileges{
	ManageMembers:   &trueValue,
	ManageResources: &trueValue,
	IndexResources:  &trueValue,
}
projectDetails := accessServices.Project{
	DisplayName:       "testProject",
	Description:       "My Test Project",
	AdminPrivileges:   &adminPriviligies,
	SoftLimit:         &falseValue,
	StorageQuotaBytes: 1073741825, // needs to be higher than 1073741824
	ProjectKey:        "tstprj",
}
projectParams = accessServices.NewProjectParams()
projectParams.ProjectDetails = projectDetails
err = accessManager.CreateProject(projectParams)
Updating a Project
adminPriviligies := accessServices.AdminPrivileges{
	ManageMembers:   true,
	ManageResources: true,
	IndexResources:  true,
}
projectDetails := accessServices.Project{
	DisplayName:       "testProject",
	Description:       "My Test Project",
	AdminPrivileges:   &adminPriviligies,
	SoftLimit:         &falseValue,
	StorageQuotaBytes: 1073741825, // needs to be higher than 1073741824
	ProjectKey:        "tstprj",
}
projectParams = accessServices.NewProjectParams()
projectParams.ProjectDetails = projectDetails
err = accessManager.UpdateProject(projectParams)
Deleting a Project
err = accessManager.DeleteProject("tstprj")
Getting a Project
err = accessManager.GetProject("tstprj")
Getting all Projects
err = accessManager.GetAllProjects()
Assigning Repository to Project
// Params: (repositoryName, projectKey string, isForce bool)
err = accessManager.AssignRepoToProject("repoName", "tstprj", true)
Un-assigning Repository from Project
err = accessManager.AssignRepoToProject("repoName")
Get all groups assigned to a project
err = accessManager.GetProjectsGroups("tstprj")
Get a specific group assigned to a project
err = accessManager.GetProjectsGroup("tstprj", "tstgroup")
Add or update a group assigned to a project
projectGroup := accessServices.ProjectGroup{
  Name:  "tstgroup",
  Roles: []string{"Contributor","Release Manager"},
}
err = accessManager.UpdateGroupInProject("tstprj", "tstgroup", projectGroup)
Remove a group from a project
err = accessManager.DeleteExistingProjectGroup("tstprj", "tstgroup")
Send Web Login Authentication Request
uuid := "09b34617-b48a-455d-8b05-25a6989fb76a"
err = accessManager.SendLoginAuthenticationRequest(uuid)
Get Web Login Authentication Token
uuid := "09b34617-b48a-455d-8b05-25a6989fb76a"
err = accessManager.GetLoginAuthenticationToken(uuid)
Creating an Access Token
params := CreateTokenParams{}
params.Scope = "applied-permissions/user"
params.Username = "my-user"
params.ExpiresIn = 12345 // nil = system default, 0 = no expiry.
params.Refreshable = true
params.Audience = "jfrt@<serviceID1>"
reference := true
params.IncludeReferenceToken = &reference
params.ProjectKey = "my-project"
params.Description = "my-token"

results, err := accessManager.CreateToken(params)
Refreshing an Access Token
params := accessServices.CreateTokenParams{}
params.RefreshToken = "<refresh token>"

results, err := accessManager.RefreshToken(params)

Distribution APIs

Creating Distribution Service Manager
Creating Distribution Details
distDetails := auth.NewDistributionDetails()
distDetails.SetUrl("http://localhost:8081/distribution")
distDetails.SetSshKeyPath("path/to/.ssh/")
distDetails.SetApiKey("apikey")
distDetails.SetUser("user")
distDetails.SetPassword("password")
distDetails.SetAccessToken("accesstoken")
// if client certificates are required
distDetails.SetClientCertPath("path/to/.cer")
distDetails.SetClientCertKeyPath("path/to/.key")
Creating Distribution Service Config
serviceConfig, err := config.NewConfigBuilder().
    SetServiceDetails(rtDetails).
    SetCertificatesPath(certPath).
    SetThreads(threads).
    SetDryRun(false).
    // Add [Context](https://golang.org/pkg/context/)
    SetContext(ctx).
    // Optionally overwrite the default HTTP retries, which is set to 3.
    SetHttpRetries(8).
    Build()
Creating New Distribution Service Manager
distManager, err := distribution.New(serviceConfig)
Using Distribution Services
Setting Distribution Signing Key
params := services.NewSetSigningKeyParams("private-gpg-key", "public-gpg-key")

err := distManager.SetSigningKey(params)
Creating a Release Bundle v1
params := services.NewCreateReleaseBundleParams("bundle-name", "1")
params.Description = "Description"
params.ReleaseNotes = "Release notes"
params.ReleaseNotesSyntax = "plain_text"
targetProps := utils.NewProperties()
targetProps.AddProperty("key1", "val1")
params.SpecFiles = []*utils.CommonParams{{Pattern: "repo/*/*.zip", TargetProps: targetProps}}

// Be default, artifacts that are distributed as part of a release bundle v1, have the same path in their destination server
// (the edge node) as the path they had on the distributing Artifactory server.
// You have however the option for modifying the target path on edge node. You do this by defining the Target property as shown below.
// The Pattern property is a wildcard based pattern. Any wildcards enclosed in parentheses in the pattern (source)
// path can be matched with a corresponding placeholder in the target path, to determine the path and name
// of the artifact, once distributed to the edge node.
// In the following example, the path in the edge node is similar to the path in the source Artifactory server, except for the additional "dir" level at the root of the repository.
// Pattern: my-repo/(*)/a.zip
// Target: my-repo/dir/{1}/a.zip
pathMappingSpec := &utils.CommonParams{Pattern: "source-repo/(a)/(*.zip)", Target: "target-repo/{1}-{2}"}
params.SpecFiles = append(params.SpecFiles, pathMappingSpec)

// In case: params.SignImmediately == true, the summary contain the release bundle v1 details. Otherwise, summary is nil.
summary, err := distManager.CreateReleaseBundle(params)
Updating a Release Bundle v1
params := services.NewUpdateReleaseBundleParams("bundle-name", "1")
params.Description = "New Description"
params.ReleaseNotes = "New Release notes"
params.ReleaseNotesSyntax = "plain_text"
targetProps := utils.NewProperties()
targetProps.AddProperty("key1", "val1")
params.SpecFiles = []*utils.CommonParams{{Pattern: "repo/*/*.zip", TargetProps: targetProps}}

// The Target property defines the target path in the edge node, and can include replaceable in the form of {1}, {2}, ...
// Read more about it in the above "Creating a Release Bundle v1" section.
pathMappingSpec := &utils.CommonParams{Pattern: "source-repo/(a)/(*.zip)", Target: "target-repo/{1}-{2}"}
params.SpecFiles = append(params.SpecFiles, pathMappingSpec)

// In case: params.SignImmediately == true, the summary contain the release bundle v1 details. Otherwise, summary is nil.
summary, err := distManager.UpdateReleaseBundle(params)
Signing a Release Bundle v1
params := services.NewSignBundleParams("bundle-name", "1")
params.GpgPassphrase = "123456"

summary, err := distManager.SignReleaseBundle(params)
Async Distributing a Release Bundle v1
params := distribution.NewDistributeReleaseBundleParams("bundle-name", "1")
distributionRules := distribution.DistributionCommonParams{SiteName: "Swamp-1", "CityName": "Tel-Aviv", "CountryCodes": []string{"123"}}}
params.DistributionRules = []*distribution.DistributionCommonParams{distributionRules}
// Auto-creating repository if it does not exist
autoCreateRepo := true
err := distManager.DistributeReleaseBundle(params, autoCreateRepo)
Sync Distributing a Release Bundle v1
params := distribution.NewDistributeReleaseBundleParams("bundle-name", "1")
distributionRules := distribution.DistributionCommonParams{SiteName: "Swamp-1", "CityName": "Tel-Aviv", "CountryCodes": []string{"123"}}}
params.DistributionRules = []*distribution.DistributionCommonParams{distributionRules}
// Auto-creating repository if it does not exist
autoCreateRepo := true
// Wait up to 120 minutes for the release bundle v1 distribution
err := distManager.DistributeReleaseBundleSync(params, 120, autoCreateRepo)
Getting Distribution Status
params := services.NewDistributionStatusParams()
// Optional parameters:
// If missing, get status for all distributions
params.Name = "bundle-name"
// If missing, get status for all versions of "bundle-name"
params.Version = "1"
// If missing, get status for all "bundle-name" with version "1"
params.TrackerId = "123456789"

status, err := distributeBundleService.GetStatus(params)
Deleting a Remote Release Bundle v1
params := services.NewDeleteReleaseBundleParams("bundle-name", "1")
params.DeleteFromDistribution = true
distributionRules := distribution.DistributionCommonParams{SiteName: "Swamp-1", "CityName": "Tel-Aviv", "CountryCodes": []string{"123"}}}
params.DistributionRules = []*distribution.DistributionCommonParams{distributionRules}
// Set to true to enable sync deletion (the command execution will end when the deletion process ends).
param.Sync = true
// Max minutes to wait for sync deletion.
param.MaxWaitMinutes = 10
err := distManager.DeleteReleaseBundle(params)
Deleting a Local Release Bundle v1
params := services.NewDeleteReleaseBundleParams("bundle-name", "1")

err := distManager.DeleteLocalReleaseBundle(params)

Using ContentReader

Some APIs return a content.ContentReader struct, which allows reading the API's output. content.ContentReader provides access to large amounts of data safely, without loading all of it into the memory. Here's an example for how content.ContentReader should be used:

reader, err := servicesManager.SearchFiles(searchParams)
if err != nil {
    return err
}

// Remove the data file used by the reader.
defer func() {
    if reader != nil {
        err = reader.Close()
    }
}()

// Iterate over the results.
for currentResult := new(utils.ResultItem); reader.NextRecord(currentResult) == nil; currentResult = new(utils.ResultItem)  {
    fmt.Printf("Found artifact: %s of type: %s\n", currentResult.Name, currentResult.Type)
}
if err := resultReader.GetError(); err != nil {
    return err
}

// Resets the reader pointer back to the beginning of the output. Make sure not to call this method after the reader had been closed using ```reader.Close()```
reader.Reset()

  • reader.NextRecord(currentResult) reads the next record from the reader into currentResult of type utils.ResultItem.

  • reader.Close() removes the file used by the reader after it is used (preferably using defer).

  • reader.GetError() returns any error that might have occurred during NextRecord().

  • reader.Reset() resets the reader back to the beginning of the output.

Xray APIs

Creating Xray Service Manager
Creating Xray Details
xrayDetails := auth.NewXrayDetails()
xrayDetails.SetUrl("http://localhost:8081/xray")
xrayDetails.SetSshKeyPath("path/to/.ssh/")
xrayDetails.SetApiKey("apikey")
xrayDetails.SetUser("user")
xrayDetails.SetPassword("password")
xrayDetails.SetAccessToken("accesstoken")
// if client certificates are required
xrayDetails.SetClientCertPath("path/to/.cer")
xrayDetails.SetClientCertKeyPath("path/to/.key")
Creating Xray Service Config
serviceConfig, err := config.NewConfigBuilder().
    SetServiceDetails(xrayDetails).
    SetCertificatesPath(certPath).
    // Optionally overwrite the default HTTP retries, which is set to 3.
    SetHttpRetries(8).
    Build()
Creating New Xray Service Manager
xrayManager, err := xray.New(serviceConfig)
Using Xray Services
Fetching Xray's Version
version, err := xrayManager.GetVersion()
Creating an Xray Watch

This uses API version 2.

You are able to configure repositories and builds on a watch. However, bundles are not supported.

params := utils.NewWatchParams()
params.Name = "example-watch-all"
params.Description = "All Repos"
params.Active = true

params.Repositories.Type = utils.WatchRepositoriesAll
params.Repositories.All.Filters.PackageTypes = []string{"Npm", "maven"}
params.Repositories.ExcludePatterns = []string{"excludePath1", "excludePath2"}
params.Repositories.IncludePatterns = []string{"includePath1", "includePath2"}

params.Builds.Type = utils.WatchBuildAll
params.Builds.All.Bin_Mgr_ID = "default"

params.Policies = []utils.AssignedPolicy{
  {
    Name: policy1Name,
    Type: "security",
  },
  {
    Name: policy2Name,
    Type: "security",
  },
}

err := xrayManager.CreateWatch(*params)
Get an Xray Watch
watch, err := xrayManager.GetWatch("example-watch-all")
Update an Xray Watch
watch, err := xrayManager.GetWatch("example-watch-all")
watch.Description = "Updated description"

err := xrayManager.UpdateWatch(*watch)
Delete an Xray Watch
err := xrayManager.DeleteWatch("example-watch-all")
Creating a Security Xray Policy
params := utils.NewPolicyParams()
params.Name = "example-security-policy"
params.Type = utils.Security
params.Description = "Security policy with 2 rules"
params.Rules = []utils.PolicyRule{
params.Rules = []utils.PolicyRule{
	{
		Name:     "min-severity-rule",
		Criteria: *utils.CreateSeverityPolicyCriteria(utils.Low),
		Priority: 1,
	},
	{
		Name:     "cvss-range-rule",
		Criteria: *utils.CreateCvssRangePolicyCriteria(5.7, 8.9),
		Priority: 2,
		Actions: &utils.PolicyAction{
			Webhooks: []string{"sec_webhook"},
			BlockDownload: utils.PolicyBlockDownload{
				Active:    &trueValue,
				Unscanned: &falseValue,
			},
			BlockReleaseBundleDistribution: &falseValue,
			FailBuild:                      &trueValue,
			NotifyDeployer:                 &falseValue,
			NotifyWatchRecipients:          &trueValue,
			CustomSeverity:                 utils.Medium,
		},
	},
}
err := xrayManager.CreatePolicy(params)
Creating a License Xray Policy
params := utils.NewPolicyParams()
params.Name = "example-licence-policy"
params.Type = utils.License
params.Description = "License policy with 2 rules"
params.Rules = []utils.PolicyRule{
	{
		Name:     "allowed-licenses",
		Criteria: *utils.CreateLicensePolicyCriteria(true, true, false, "MIT", "Apache-2.0"),
		Priority: 1,
	},
	{
		Name:     "baned-licenses",
		Criteria: *utils.CreateLicensePolicyCriteria(false, true, false, "GPL"),
		Priority: 2,
	},
}
err := xrayManager.CreatePolicy(params)
Get an Xray Policy
policy, err := xrayManager.GetPolicy("example-policy")
Update an Xray Policy
policy, err := xrayManager.GetPolicy("example-policy")
policy.Description = "Updated description"

err := xrayManager.UpdatePolicy(*policy)
Delete an Xray Policy
err := xrayManager.DeletePolicy("example-policy")
Create an Xray Ignore Rule
params := utils.NewIgnoreRuleParams()
params.Notes := "random-notes-for-ignore-rules"
params.ExpiredAt := time.Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location)
params.IgnoreFilters := IgnoreFilters{
  Vulnerabilities: []string{"XRAY-12345", "XRAY-67891"},
  Licenses: []string{"MIT", "BSD"},
  CVEs: []string{"CVE-2021-1234", "CVE-2022-5678"},
  Policies: []string{"policy-name-1", "policy-name-2"},
  Watches: []string{"watch-name-1", "watch-name-2"},
  DockerLayers: []string{"0503825856099e6adb39c8297af09547f69684b7016b7f3680ed801aa310baaa"},
  OperationalRisks: []string{"any"},
  Exposures: []ExposuresFilterName{
    {
      FilePath: []string{"/path/to/file1", "/path/to/file2"},
      Scanners: []string{"EXP-12345"},
      Catagories: []ExposuresCatagories{
        {
          Secrets: true,
          Services: true,
          Applications: true,
          Iac: true,
        },
      },
    },
  },
  ReleaseBundles: []IgnoreFilterNameVersion{
    {
      Name: "RB-name",
      Version: "0.0.0",
    },
    {
      Name: "RB-name-2",
      Version: "1.2.3",
    },
  },
  Builds: []IgnoreFilterNameVersion{
    {
      Name: "build-name",
      Version: "0.0.0",
    },
    {
      Name: "build-name-2",
      Version: "1.2.3",
    },
  },
  Components: []IgnoreFilterNameVersion{
    {
      Name: "component-name",
      Version: "0.0.0",
    },
    {
      Name: "component-name-2",
      Version: "1.2.3",
    },
  },
  Arti: []IgnoreFilterNameVersion{
    {
      Name: "artifact-name",
      Version: "0.0.0",
    },
    {
      Name: "artifact-name-2",
      Version: "1.2.3",
    },
  },
}

ignoreRuleIgnoreId, err := xrayManager.CreateIgnoreRule(params)
Get an Xray Ignore Rule
ignoreRule, err := xrayManager.GetIgnoreRule("ignore-rule-id")
Delete an Xray Ignore Rule
err := xrayManager.DeleteIgnoreRule("ignore-rule-id")
Add Builds to Indexing Configuration
buildsToIndex := []string{"buildName1", "buildName2"}
err := xrayManager.AddBuildsToIndexing(buildsToIndex)
Request Graph Scan
graphScanParams := &XrayGraphScanParams{}
// Dependency tree. Each node must have a component identifier, see https://www.jfrog.com/confluence/display/JFROG/Xray+REST+API#XrayRESTAPI-ComponentIdentifiers.
graphScanParams.Graph = &GraphNode{
  Id: "gav://org.jfrog.buildinfo:build-info-extractor-gradle:4.24.5",
  Nodes: []*GraphNode{{Id: "gav://junit:junit:4.13.2"}, {Id: "gav://commons-lang:commons-lang:2.6"}}}
scanId, err := xrayManager.ScanGraph(graphScanParams)
Retrieve the Graph Scan Results
// scanId should be received from xrayManager.ScanGraph(graphScanParams) request.
scanResults, err := xrayManager.GetScanGraphResults(scanId)
Request Graph Enrich
graphImportParams := &XrayGraphImportParams{}
// Dependency tree. Each node must have a component identifier, see https://www.jfrog.com/confluence/display/JFROG/Xray+REST+API#XrayRESTAPI-ComponentIdentifiers.
graphScanParams.SBOMInput = "{
  "bomFormat": "CycloneDX",
  "specVersion": "1.4",
  "serialNumber": "urn:uuid:3c94db59-0dbf-41cd-49e8-c4518ac2ef3c",
  "version": 1,
  "metadata": {
    "timestamp": "2024-05-22T14:52:40Z",
    "tools": [
      {
      "vendor": "JFrog Inc.",
      "name": "Xray",
      "version": "3.95.7"
      }
    ],
    "component": {
      "type": "container",
      "name": "jfrog/artifactory-pro:sha256",
      "version": "2e774ffb112bcaef62804d97e6db3dc67b9169b440838b12ba12584cba2c5251"
	}
  },
  "components": [
    {
    "bom-ref": "pkg:Oci/jfrog%2Fartifactory-pro:sha256@2e774ffb112bcaef62804d97e6db3dc67b9169b440838b12ba12584cba2c5251",
    "type": "application",
    "name": "jfrog/artifactory-pro:sha256",
    "version": "2e774ffb112bcaef62804d97e6db3dc67b9169b440838b12ba12584cba2c5251",
    "hashes": [
      {
      "alg": "SHA-256",
      "content": "2e774ffb112bcaef62804d97e6db3dc67b9169b440838b12ba12584cba2c5251"
      }
    ],
    "licenses": [],
    "purl": "pkg:Oci/jfrog%2Fartifactory-pro:sha256@2e774ffb112bcaef62804d97e6db3dc67b9169b440838b12ba12584cba2c5251"
    }
  ],
  "dependencies": []
  }

"
scanId, err := xrayManager.ImportGraph(graphImportParams)
Retrieve the Graph Enrich Results
// scanId should be received from xrayManager.ImportGraph(graphImportParams) request.
enrichResults, err := xrayManager.GetImportGraphResults(scanId)
Get Token Validation Status
isEnabled, err := xrayManager.IsTokenValidationEnabled()
Generate Vulnerabilities Report
vulnerabilitiesReportRequest := services.VulnerabilitiesReportRequestParams{
  Name: "example-report",
  Filters: services.VulnerabilitiesFilter{
    VulnerableComponent: "*vulnerable:component*",
    ImpactedArtifact: "some://impacted*artifact",
    HasRemediation: &falseValue,
    Cve: "CVE-1234-1234",
    IssueId: "XRAY-1234",
    Severity: []string{
        "High",
        "Medium"
      },
    CvssScore: services.CvssScore {
        MinScore: float64(6.3),
        MaxScore: float64(9)
    },
    Published: services.DateTimeRange {
        Start: "2020-06-29T12:22:16Z",
        End: "2020-06-29T12:22:16Z"
    },
    ScanDate: services.DateTimeRange {
        Start: "2020-06-29T12:22:16Z",
        End: "2020-06-29T12:22:16Z"
    }
  },
  Resources: services.Resource{
    IncludePathPatterns: []string{ "/example-sub-dir/**" },
    Repositories: []services.Repository{
      {
        Name: "example-repository",
      },
    },
  },
}

// The reportRequestResponse will contain the report ID to use in subsequent requests
reportRequestResponse, err := xrayManager.GenerateVulnerabilitiesReport(vulnerabilitiesReportRequest)
Get Vulnerabilities Report Details
// The reportId argument value is returned as part of the xrayManager.GenerateVulnerabilitiesReport API response.
reportDetails, err := xrayManager.ReportDetails(reportId)
Get Vulnerabilities Report Content
// The ReportId value is returned as part of the xrayManager.GenerateVulnerabilitiesReport API response.
reportContentRequest := services.ReportContentRequestParams{
  ReportId:  "example-report-id",
  Direction: "asc",
  PageNum:   0,
  NumRows:   0,
  OrderBy:   "severity",
}
reportContent, err := xrayManager.ReportContent(reportContentRequest)
Delete Vulnerabilities Report
// The reportId argument value is returned as part of the xrayManager.GenerateVulnerabilitiesReport API response.
err := xrayManager.DeleteReport(reportId)
Generate Licences Report
licensesReportRequest := services.LicensesReportRequestParams{
  Name: "example-report",
  Filters: services.LicensesFilter{
    Component: "*gav:component*",
    Artifact: "some://impacted*artifact",
    Unknown: &falseValue,
    Unrecognized: &trueValue,
    LicenseNames: []string{
        "Apache",
        "MIT",
        "AFL"
    },
    LicensePatterns: []string{
        "*Apache*",
        "The Apache*",
        "AFL*"
    },
    ScanDate: services.DateTimeRange {
        Start: "2020-06-29T12:22:16Z",
        End: "2020-06-29T12:22:16Z"
    }
  },
  Resources: services.Resource{
    IncludePathPatterns: []string{ "/example-sub-dir/**" },
    Repositories: []services.Repository{
      {
        Name: "example-repository",
      },
    },
  },
}

// The reportRequestResponse will contain the report ID to use in subsequent requests
reportRequestResponse, err := xrayManager.GenerateLicencesReport(licensesReportRequest)
Get Licences Report Details
// The reportId argument value is returned as part of the xrayManager.GenerateLicencesReport API response.
reportDetails, err := xrayManager.ReportDetails(reportId)
Get Licences Report Content
// The ReportId value is returned as part of the xrayManager.GenerateLicencesReport API response.
reportContentRequest := services.ReportContentRequestParams{
  ReportId:  "example-report-id",
  Direction: "asc",
  PageNum:   0,
  NumRows:   0,
  OrderBy:   "severity",
}
reportContent, err := xrayManager.ReportContent(reportContentRequest)
Delete Licences Report
// The reportId argument value is returned as part of the xrayManager.GenerateLicencesReport API response.
err := xrayManager.DeleteReport(reportId)
Generate Violations Report
violationsReportRequest := services.ViolationsReportRequestParams{
  Name: "example-report",
  Filters: 		Type: "security|license|operational_risk",
    WatchNames: []string{
      "NameOfWatch1",
      "NameOfWatch2"
    },
    WatchPatterns: []string{
      "WildcardWatch*"
    },
    Component: "*vulnerable:component*",
    Artifact: "some://impacted*artifact",
    PolicyNames: []string{
      "NameOfPolicy"
    },
    Severities: []string{
      "High",
      "Medium"
    },
    Updated: services.DateTimeRange {
      Start: "2020-01-02T15:00:00Z",
      End: "2020-12-15T00:00:00Z"
    },
    SecurityFilters: services.VulnerabilitiesFilter{
      Cve: "CVE-2020-10693",
      IssueId: "XRAY-87343",
      Severity: []string{
          "High",
          "Medium"
        },
      CvssScore: services.CvssScore {
          MinScore: float64(6.3),
          MaxScore: float64(9)
      },
      Published: services.DateTimeRange {
          Start: "2020-06-29T12:22:16Z",
          End: "2020-06-29T12:22:16Z"
      },
      ScanDate: services.DateTimeRange {
          Start: "2020-06-29T12:22:16Z",
          End: "2020-06-29T12:22:16Z"
      },
      SummaryContains: "kernel",
      HasRemediation: &falseValue,
    },
    LicenseFilters: services.LicensesFilter {
      Unknown: &falseValue,
      Unrecognized: &trueValue,
		LicenseNames: []string{
	    "Apache",
	    "MIT",
	    "AFL"
		},
    LicensePatterns: []string{
      "*Apache*",
      "AFL*"
    },
  }
  Resources: services.Resource{
    IncludePathPatterns: []string{ "/example-sub-dir/**" },
    Repositories: []services.Repository{
      {
        Name: "example-repository",
      },
    },
  },
}

// The reportRequestResponse will contain the report ID to use in subsequent requests
reportRequestResponse, err := xrayManager.GenerateViolationsReport(violationsReportRequest)
Get Violations Report Details
// The reportId argument value is returned as part of the xrayManager.GenerateViolationsReport API response.
reportDetails, err := xrayManager.ReportDetails(reportId)
Get Violations Report Content
// The ReportId value is returned as part of the xrayManager.GenerateViolationsReport API response.
reportContentRequest := services.ReportContentRequestParams{
  ReportId:  "example-report-id",
  Direction: "asc",
  PageNum:   0,
  NumRows:   0,
  OrderBy:   "severity",
}
reportContent, err := xrayManager.ReportContent(reportContentRequest)
Delete Violations Report
// The reportId argument value is returned as part of the xrayManager.GenerateViolationsReport API response.
err := xrayManager.DeleteReport(reportId)
Get Artifact Summary
artifactSummaryRequest := services.ArtifactSummaryParams{
  Checksums: []string{"a96370b18b3d7e70b7b34d49dcb621a805c15cf71217ee8c77be5a98cc793fd3"},
  Paths:     []string{"default/example-repository/example-folder/example-artifact"},
}
artifactSummary, err := xrayManager.ArtifactSummary(artifactSummaryRequest)
Get Entitlement Info
    // The featureId is the requested feature ID to check, for instance: "contextual_analysis"
    isEntitled, err := xrayManager.IsEntitled(featureId)

XSC APIs

Creating XSC Service Manager
Creating XSC Details
xscDetails := auth.NewXscDetails()
xscDetails.SetUrl("http://localhost:8081/xsc")
xscDetails.SetSshKeyPath("path/to/.ssh/")
xscDetails.SetApiKey("apikey")
xscDetails.SetUser("user")
xscDetails.SetPassword("password")
xscDetails.SetAccessToken("accesstoken")
// if client certificates are required
xscDetails.SetClientCertPath("path/to/.cer")
xscDetails.SetClientCertKeyPath("path/to/.key")
Creating XSC Service Config
serviceConfig, err := config.NewConfigBuilder().
    SetServiceDetails(xscDetails).
    SetCertificatesPath(certPath).
    // Optionally overwrite the default HTTP retries, which is set to 3.
    SetHttpRetries(8).
    Build()
Creating New XSC Service Manager
xscManager, err := xsc.New(serviceConfig)
Using XSC Services
Fetching XSC's Version
version, err := xscManager.GetVersion()
Report XSC Analytics Metrics
Add Analytics General Event

Sent XSC a new event which contains analytics data, and get multi-scan id back from XSC.

event := services.XscAnalyticsGeneralEvent{
	XscAnalyticsBasicGeneralEvent: services.XscAnalyticsBasicGeneralEvent{
            EventType:              services.CliEventType,
            Product:                services.CliProduct,
            ProductVersion:         "2.53.1",
            IsDefaultConfig:        false,
            JfrogUser:              "gail",
            OsPlatform:             "mac",
            OsArchitecture:         "arm64",
            AnalyzerManagerVersion: "1.1.1",
            EventStatus:            services.Started,
}}
msi, err := xscManager.AddAnalyticsGeneralEvent(event)
Update Analytics General Event

Sent XSC a finalized analytics metrics event with information matching an existing event's msi.

finalizeEvent := services.XscAnalyticsGeneralEventFinalize{
    MultiScanId: msi,
    XscAnalyticsBasicGeneralEvent: services.XscAnalyticsBasicGeneralEvent{
        EventStatus:          services.Completed,
        TotalFindings:        10,
        TotalIgnoredFindings: 5,
        TotalScanDuration:    "15s",
    },
}
err := xscManager.UpdateAnalyticsGeneralEvent(finalizeEvent)
Get Analytics General Event

Get a general event from XSC matching the provided msi.

event, err := xscManager.GetAnalyticsGeneralEvent(msi)

Pipelines APIs

Creating Pipelines Service Manager
Creating Pipelines Details
pipelinesDetails := auth.NewPipelinesDetails()
pipelinesDetails.SetUrl("http://localhost:8081/pipelines")
pipelinesDetails.SetAccessToken("accesstoken")
// if client certificates are required
pipelinesDetails.SetClientCertPath("path/to/.cer")
pipelinesDetails.SetClientCertKeyPath("path/to/.key")
Creating Pipelines Service Config
serviceConfig, err := config.NewConfigBuilder().
    SetServiceDetails(pipelinesDetails).
    SetCertificatesPath(pipelinesDetails.GetClientCertPath()).
    // Optionally overwrite the default HTTP retries, which is set to 3.
    SetHttpRetries(8).
    Build()
Creating New Pipelines Service Manager
pipelinesManager, err := pipelines.New(serviceConfig)
Using Pipelines Services
Fetching Pipelines' System Info
systemInfo, err := pipelinesManager.GetSystemInfo()
Creating GitHub Integration
id, err := pipelinesManager.CreateGithubIntegration("integrationName", "token")
Creating GitHub Enterprise Integration
id, err := pipelinesManager.CreateGithubEnterpriseIntegration("integrationName", "url", "token")
Creating Bitbucket Integration
id, err := pipelinesManager.CreateBitbucketIntegration("integrationName", "username", "token")
Creating Bitbucket Server Integration
id, err := pipelinesManager.CreateBitbucketServerIntegration("integrationName", "url", "username", "passwordOrToken")
Creating Gitlab Integration
id, err := pipelinesManager.CreateGitlabIntegration("integrationName", "url", "token")
Creating Artifactory Integration
id, err := pipelinesManager.CreateArtifactoryIntegration("integrationName", "url", "username", "apikey")
Get Integration by Id
integrationId := 1234
integration, err := pipelinesManager.GetIntegrationById(integrationId)
Get Integration by Name
integration, err := pipelinesManager.GetIntegrationByName("integrationName")
Get All Integrations
integrations, err := pipelinesManager.GetAllIntegrations()
Get All Raw Integrations
integrations, err := pipelinesManager.GetAllRawIntegrations()
Delete Integration
integrationId := 1234
err := pipelinesManager.DeleteIntegration(integrationId)
Add Pipeline Source
projectIntegrationId := 1234
err := pipelinesManager.AddSource(projectIntegrationId, "domain/repo", "master", "pipelines.yml", "pipelineSourceName")
Get Recent Pipeline Run Status
branch := "master"
pipeline := "pipeline_name"
response, err := pipelinesManager.GetPipelineRunStatusByBranch(branch, pipeline)
Trigger Pipeline Run
branch := "master"
pipeline := "pipeline_name"
status, err := pipelinesManager.TriggerPipelineRun(branch, pipeline)
Trigger Pipeline Sync
branch := "master"
repoName := "jfrog/pipelines" // repository full path
err := pipelinesManager.SyncPipelineResource(branch, repoFullName)
Get Pipeline Sync Status
branch := "master"
repoName := "jfrog/pipelines" // repository full path
err := pipelinesManager.GetSyncStatusForPipelineResource(branch, repoFullName)
Cancel Run
runID := 234 // run id of pipeline
err := pipelinesManager.CancelRun(runID)

Lifecycle APIs

Creating Lifecycle Service Manager
Creating Lifecycle Details
lcDetails := auth.NewLifecycleDetails()
lcDetails.SetUrl("http://localhost:8081/lifecycle")
lcDetails.SetAccessToken("access-token")
// if client certificates are required
lcDetails.SetClientCertPath("path/to/.cer")
lcDetails.SetClientCertKeyPath("path/to/.key")
Creating Lifecycle Service Config
serviceConfig, err := config.NewConfigBuilder().
    SetServiceDetails(lcDetails).
    SetCertificatesPath(lcDetails.GetClientCertPath()).
    // Optionally overwrite the default HTTP retries, which is set to 3.
    SetHttpRetries(8).
    Build()
Creating New Lifecycle Service Manager
lifecycleManager, err := lifecycle.New(serviceConfig)
Using Lifecycle Services
Creating a Release Bundle From AQL
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
queryParams := CommonOptionalQueryParams{}
queryParams.ProjectKey = "project"
queryParams.Async = true

// The GPG/RSA key-pair name given in Artifactory.
signingKeyName = "key-pair"

aqlQuery := `items.find({"repo": "my-repo","path": ".","name": "a2.in"})`
serviceManager.CreateReleaseBundleFromAql(rbDetails, queryParams, signingKeyName, aqlQuery)
Creating a Release Bundle From Artifacts
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
queryParams := CommonOptionalQueryParams{}
queryParams.ProjectKey = "project"
queryParams.Async = true

// The GPG/RSA key-pair name given in Artifactory.
signingKeyName = "key-pair"

artifacts := CreateFromArtifacts{Artifacts: []ArtifactSource{
	{
        Path:   "repo/path/file",
        Sha256: "3e3deb6628658a48cf0d280a2210211f9d977ec2e10a4619b95d5fb85cb10450",
	},
}}

serviceManager.CreateReleaseBundleFromArtifacts(rbDetails, queryParams, signingKeyName, artifacts)
Creating a Release Bundle From Published Builds
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
queryParams := CommonOptionalQueryParams{}
queryParams.ProjectKey = "project"
queryParams.Async = true

// The GPG/RSA key-pair name given in Artifactory.
signingKeyName = "key-pair"

source := CreateFromBuildsSource{Builds: []BuildSource{
    {
        BuildName:       "name",
        BuildNumber:     "number",
		// Optional:
        BuildRepository: "artifactory-build-info",
    },
}}
serviceManager.CreateReleaseBundleFromBuilds(rbDetails, queryParams, signingKeyName, source)
Creating a Release Bundle From Release Bundles
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
queryParams := CommonOptionalQueryParams{}
queryParams.ProjectKey = "project"
queryParams.Async = true

// The GPG/RSA key-pair name given in Artifactory.
signingKeyName = "key-pair"

source := CreateFromReleaseBundlesSource{ReleaseBundles: []ReleaseBundleSource{
    {
       ReleaseBundleName:    "name",
       ReleaseBundleVersion: "version",
       ProjectKey:           "default",
    },
}}
serviceManager.CreateReleaseBundleFromBundles(rbDetails, params, signingKeyName, source)
Promoting a Release Bundle
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
queryParams := CommonOptionalQueryParams{}
queryParams.ProjectKey = "project"
queryParams.Async = true

// The GPG/RSA key-pair name given in Artifactory.
signingKeyName = "key-pair"

promotionParams := RbPromotionParams{}
promotionParams.Environment := "target-env"
promotionParams.IncludedRepositoryKeys := []string{"generic-local"}

resp, err := serviceManager.PromoteReleaseBundle(rbDetails, queryParams, signingKeyName, promotionParams)
Get Release Bundle Creation Status
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
sync := true
// Optional:
projectKey := "default"
resp, err := serviceManager.GetReleaseBundleCreationStatus(rbDetails, projectKey, sync)
Get Release Bundle Promotion Status
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
createdMillis := "1668073165322"
sync := true
// Optional:
projectKey := "default"
resp, err := serviceManager.GetReleaseBundlePromotionStatus(rbDetails, projectKey, createdMillis, sync)
Get Release Bundle Promotions
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}

optionalQueryParams := lifecycle.GetPromotionsOptionalQueryParams{
    Include:    "MSG",
    Offset:     1,
    Limit:      10,
    FilterBy:   "DEV",
    OrderBy:    "created",
    OrderAsc:   true,
    ProjectKey: "default",
}

resp, err := serviceManager.GetReleaseBundleVersionPromotions(rbDetails, optionalQueryParams)
Get Release Bundle Specification
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
resp, err := serviceManager.GetReleaseBundleSpecification(rbDetails)
Distribute Release Bundle
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
pathMappings := []services.PathMapping{
    {
        Pattern: "(*)/(*)",
        Target:  "{1}/target/{2}",
    },
}

rules := &distribution.DistributionCommonParams{
    SiteName:     "*",
    CityName:     "*",
    CountryCodes: []string{"*"},
}
dsParams := DistributeReleaseBundleParams{
    Sync:           true,
    AutoCreateRepo: true,
    MaxWaitMinutes: 60,
    PathMappings:   pathMappings,
    DistributionRules: []*dmUtils.DistributionCommonParams{
        rules,
    },
}

resp, err := serviceManager.DistributeReleaseBundle(rbDetails, dsParams)
Export Release Bundle Archive
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
queryParams := CommonOptionalQueryParams{}
queryParams.ProjectKey = "project"
// Specifies the path mapping for the artifacts
// in the form of input and output regular expressions.
// These expressions define where the artifacts are located
// and where they should be exported.
modifictions:= []utils.PathMapping{{
            Input:  "(.*)/(.*)",
            Output: "$1/mapping/$2",
}}
// Export & Download
res,err:= serviceManager.ExportReleaseBundle(rbDetails, modifications, queryParams)
Import Release Bundle Archive
// Imports an exported release bundle archive
res,err:= serviceManager.releaseService.ImportReleaseBundle(filePath)
Delete Release Bundle Version
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}
queryParams := CommonOptionalQueryParams{}
queryParams.ProjectKey = "project"
queryParams.Async = true

resp, err := serviceManager.DeleteReleaseBundleVersion(rbDetails, queryParams)
Delete Release Bundle Version Promotion
rbDetails := ReleaseBundleDetails{"rbName", "rbVersion"}

queryParams := CommonOptionalQueryParams{}
queryParams.ProjectKey = "project"
queryParams.Async = true

created := "1708612052952"
resp, err := serviceManager.DeleteReleaseBundleVersionPromotion(rbDetails, queryParams, created)
Remote Delete Release Bundle
rules := &distribution.DistributionCommonParams{
    SiteName:     "*",
    CityName:     "*",
    CountryCodes: []string{"*"},
}
params := distribution.NewDistributeReleaseBundleParams("rbName", "rbVersion")
params.DistributionRules = append(params.DistributionRules, rules)

dryRun := true

resp, err := serviceManager.RemoteDeleteReleaseBundle(params, dryRun)

Evidence APIs

Creating Evidence Service Manager
Creating Evidence Details
evdDetails := auth.NewEvidenceDetails()
evdDetails.SetUrl("http://localhost:8081/evidence")
evdDetails.SetAccessToken("access-token")
// if client certificates are required
evdDetails.SetClientCertPath("path/to/.cer")
evdDetails.SetClientCertKeyPath("path/to/.key")
Creating Evidence Service Config
serviceConfig, err := config.NewConfigBuilder().
    SetServiceDetails(evdDetails).
    SetCertificatesPath(evdDetails.GetClientCertPath()).
    // Optionally overwrite the default HTTP retries, which is set to 3.
    SetHttpRetries(3).
    Build()
Creating New Evidence Service Manager
evidenceManager, err := evidence.New(serviceConfig)
Using Evidence Services
Upload Evidence
envelopeBytes := []byte("envelope")

evidenceDetails := evidenceService.EvidenceDetails{
  SubjectUri:  "subjectUri",
  DSSEFileRaw: &envelopeBytes,
}
body, err = evideceManager.UploadEvidence(evidenceDetails)

Metadata APIs

Creating Metadata Service Manager
Creating Metadata Details
mdDetails := auth.NewMetadataDetails()
mdDetails.SetUrl("http://localhost:8081/metadata")
mdDetails.SetAccessToken("access-token")
// if client certificates are required
mdDetails.SetClientCertPath("path/to/.cer")
mdDetails.SetClientCertKeyPath("path/to/.key")
Creating Metadata Service Config
serviceConfig, err := config.NewConfigBuilder().
    SetServiceDetails(mdDetails).
    SetCertificatesPath(mdDetails.GetClientCertPath()).
    // Optionally overwrite the default HTTP retries, which is set to 3.
    SetHttpRetries(3).
    Build()
Creating New Metadata Service Manager
metadataManager, err := metadata.NewManager(serviceConfig)
Using Metadata Services
Graphql query
queryBytes := []byte(`{"query":"someGraphqlQuery"}`)

queryDetails := metadataService.QueryDetails{
  Body:  queryBytes,
}

body, err = metadataManager.GraphqlQuery(queryDetails)

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func GetName 

func GetName() string

func GetUserAgent 

func GetUserAgent() string

func GetVersion 

func GetVersion() string

func SetAgentName 

func SetAgentName(name string)

Types

This section is empty.

Source Files

View all Source files

Directories

Path Synopsis
auth
services
auth
buildinfo
services
services/fspatterns
services/go
services/utils
services/utils/tests
services/utils/tests/xray
usage
cert
auth
services
services/utils
auth
services
http
httpclient
jfroghttpclient
auth
services
auth
services
auth
services
distribution
errorutils
io
io/content
io/fileutils
io/httputils
log
tests
usage
auth
services
services/utils
usage
xsc
auth
services

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.