CLI for JFrog Artifactory

Storing Symlinks in Artifactory

JFrog CLI lets you upload and download artifacts from your local file-system to Artifactory, this also includes uploading symlinks (soft links).

Symlinks are stored in Artifactory as files with a zero size, with the following properties:
symlink.dest - The actual path on the original filesystem to which the symlink points
symlink.destsha1 - the SHA1 checksum of the value in the symlink.dest property

To upload symlinks, the upload command should be executed with the --symlinks option set to true. 

When downloading symlinks stored in Artifactory, the CLI can verify that the file to which the symlink points actually exists and that it has the correct SHA1 checksum. To add this validation, you should use the --validate-symlinks option with the download command.

Using Placeholders

The JFrog CLI offers enormous flexibility in how you download, upload, copy, or move files through use of wildcard or regular expressions with placeholders.

Any wildcard enclosed in parenthesis in the source path can be matched with a corresponding placeholder in the target path to determine the name of the artifact once uploaded.

Examples

Example 1: Upload all files to the target repository

For each .tgz file in the source directory, create a corresponding directory with the same name in the target repository and upload it there. For example, a file named froggy.tgz should be uploaded to my-local-rep/froggy. (froggy will be created a folder in Artifactory).

$ jfrog rt u "(*).tgz" my-local-repo/{1}/ --recursive=false

Example 2: Upload all files sharing the same prefix to the target repository

Upload all files whose name begins with "frog" to folder frogfiles in the target repository, but append its name with the text "-up". For example, a file called froggy.tgz should be renamed froggy.tgz-up.

$ jfrog rt u "(frog*)" my-local-repo/frogfiles/{1}-up --recursive=false

Example 3: Upload all files to corresponding directories according to extension type

Upload all files in the current directory to the my-local-repo repository and place them in directories which match their file extensions.

$ jfrog rt u "(*).(*)" my-local-repo/{2}/{1}.{2} --recursive=false

Example 4: Copy all zip files to target respository and append with an extension.

Copy all zip files under /rabbit in the source-frog-repo repository into the same path in the target-frog-repo repository and append the copied files' names with ".cp".

jfrog rt cp "source-frog-repo/rabbit/(*.zip)" target-frog-repo/rabbit/{1}.cp

General Commands

The following sections describe the commands available in the JFrog CLI for use with Artifactory. 

Configuration

This command is used to configure JFrog CLI with Artifactory servers, which can later be used in the other commands. The configured Artifactory servers details can be overridden per command by passing in alternative values for the Artifactory URL and login credentials. The values configured are saved in ~/.jfrog/jfrog-cli.conf. 

You can set a default Artifactory server by using the jfrog rt use command.

Examples

Example 1

Configure the Artifactory URL and credentials using the interactive prompt. The unique ID for the new Artifactory server configuration will be rt-server-1.

$ jfrog rt c rt-server-1

Example 2

Configure the Artifactory URL, user and password by passing them in as command options.

$ jfrog rt c rt-server-1 --url=http://domain/artifactory --user=admin --password=password

Example 3

Configure the Artifactory URL and API key by passing them in as command options.

$ jfrog rt c rt-server-1 --url=http://domain/artifactory --apikey=APIKEY

Example 4

Delete the rt-server-1 server configuration.

$ jfrog rt c delete rt-server-1

Example 5

Show details of the rt-server-1 Artifactory server.

$ jfrog rt c show rt-server-1

Example 6

Show all configured Artifactory servers.

$ jfrog rt c show

Example 7

Clear all configured servers.

$ jfrog rt c clear

Using a Predefined Artifactory Server

You can configure multiple Artifactory instances using the config command. The 'use' command is used for specifying which of the configured Artifactory instances should be used for the following CLI commands.  

Examples

Example 1

$ jfrog rt use artifactory-server-1

Verifying Artifactory is Accessible

This command can be used to verify that Artifactory is accessible by sending an applicative ping to Artifactory.

Examples

Example 1

Ping the configured default Artifactory server.

$ jfrog rt ping

Example 2

Ping the configured Artifactory server with ID rt-server-1.

$ jfrog rt ping --server-id=rt-server-1

Example 3

Ping the Artifactory server. accessible though the specified URL.

$ jfrog rt ping --url=http://my-rt-server.com/artifactory

Uploading Files 

This command is used to upload files to Artifactory.

Examples

Example 1

Upload a file called froggy.tgz to the root of the my-local-repo repository.

 $ jfrog rt u froggy.tgz my-local-repo

Example 2

Collect all the zip files located under the build directory (including sub-directories), and upload them to the my-local-repo repository, under the zipFiles folder, while maintaining the original names of the files.

$ jfrog rt u "build/*.zip" my-local-repo/zipFiles/

Example 3

Collect all the zip files located under the build directory (including sub-directories), and upload them to the my-local-repo repository, under the zipFiles folder, while maintaining the original names of the files. Also delete all files in the my-local-repo repository, under the zipFiles folder, except for the files which were uploaded by this command.

$ jfrog rt u "build/*.zip" my-local-repo/zipFiles/ --sync-deletes="my-local-repo/zipFiles/"

Example 4

Collect all files located under the build directory (including sub-directories), and upload them to the my-release-local repository, under the files folder, while maintaining the original names of the artifacts. Exclude (do not upload) files, which include install as part of their path, and have the pack extension. This example uses a wildcard pattern. See Example 5, which uses regular expressions instead.

jfrog rt u "build/" my-release-local/files/ --exclude-patterns="*install*pack*"

Example 5

Collect all files located under the build directory (including sub-directories), and upload them to the my-release-local repository, under the files folder, while maintaining the original names of the artifacts. Exclude (do not upload) files, which include install as part of their path, and have the pack extension. This example uses a regular expression. See Example 4, which uses a wildcard pattern instead.

jfrog rt u "build/" my-release-local/files/ --regexp --exclude-patterns="(.*)install.*pack$"

Downloading Files

This command is used to download files from Artifactory

Examples

Example 1

Download an artifact called cool-frog.zip located at the root of the my-local-repo repository to the current directory.

$ jfrog rt dl my-local-repo/cool-froggy.zip

Example 2

Download all artifacts located under the all-my-frogs directory in the my-local-repo repository to the all-my-frogs folder under the current directory.

$ jfrog rt dl my-local-repo/all-my-frogs/ all-my-frogs/

Example 3

Download all artifacts located in the my-local-repo repository with a jar extension to the all-my-frogs folder under the current directory.

$ jfrog rt dl "my-local-repo/*.jar" all-my-frogs/

Example 4

Download the latest file uploaded to the all-my-frogs folder in the my-local-repo repository.

jfrog rt dl  "my-local-repo/all-my-frogs/" --sort-by=created --sort-order=desc --limit=1

Copying Files

This command is used to copy files in Artifactory

Examples

Example 1

Copy all artifacts located under /rabbit in the source-frog-repo repository into the same path in the target-frog-repo repository.

jfrog rt cp source-frog-repo/rabbit/ target-frog-repo/rabbit/

Example 2

Copy all zip files located under /rabbit in the source-frog-repo repository into the same path in the target-frog-repo repository.

 jfrog rt cp "source-frog-repo/rabbit/*.zip" target-frog-repo/rabbit/

Example 3

Copy all artifacts located under /rabbit in the source-frog-repo repository and with property "Version=1.0" into the same path in the target-frog-repo repository  .

 jfrog rt cp "source-frog-repo/rabbit/*" target-frog-repo/rabbit/ --props=Version=1.0

Moving Files

This command is used to move files in Artifactory

Examples

Example 1

Move all artifacts located under /rabbit in the source-frog-repo repository into the same path in the target-frog-repo repository.

jfrog rt mv source-frog-repo/rabbit/ target-frog-repo/rabbit/

Example 2

Move all zip files located under /rabbit in the source-frog-repo repository into the same path in the target-frog-repo repository.

 jfrog rt mv "source-frog-repo/rabbit/*.zip" target-frog-repo/rabbit/

Example 3

Move all artifacts located under /rabbit in the source-frog-repo repository and with property "Version=1.0" into the same path in the target-frog-repo repository  .

 jfrog rt mv "source-frog-repo/rabbit/*" target-frog-repo/rabbit/ --props=Version=1.0

Deleting Files

This command is used to delete files in Artifactory

Examples

Example 1

Delete all artifacts located under /rabbit in the frog-repo repository.

 jfrog rt del frog-repo/rabbit/

Example 2

Delete all zip files located under /rabbit in the frog-repo repository.

  jfrog rt del "frog-repo/rabbit/*.zip"

Searching Files

This command is used to search and display files in Artifactory.

Examples

Example 1

Display a list of all artifacts located under /rabbit in the frog-repo repository.

 jfrog rt s frog-repo/rabbit/

Example 2

Display a list of all zip files located under /rabbit in the frog-repo repository.

  jfrog rt s "frog-repo/rabbit/*.zip"

Setting Properties on Files

This command is used for setting properties on existing files in Artifactory.

Example

Example 1

Set the properties on all the zip files in the generic-local repository. The command will set the property "a" with "1" value and the property "b" with two values: "2" and "3".

jfrog rt sp "generic-local/*.zip" "a=1;b=2,3"

Example 2

The command will set the property "a" with "1" value and the property "b" with two values: "2" and "3" on all files found by the File Spec my-spec.

jfrog rt sp "a=1;b=2,3" --spec my-spec

Deleting

code b Properties from Files

This command is used for deleting properties from existing files in Artifactory.

Example

Delete the "status" and "phase" properties from all the zip files in the generic-local repository.

jfrog rt delp "generic-local/*.zip" "status,phase"

Cleaning Up Unreferenced Files from a Git LFS Repository

This command is used to clean up files from a Git LFS repository. This deletes all files from a Git LFS repository, which are no longer referenced in a corresponding Git repository.

Examples

Example 1

Cleans up Git LFS files from Artifactory, using the configuration in the .git directory located at the current directory.

$ jfrog rt glc

Example 2

Cleans up Git LFS files from Artifactory, using the configuration in the .git directory located inside the path/to/git/config directory.

$ jfrog rt glc path/to/git/config

Running cUrl

Execute a cUrl command, using the configured Artifactory details. The command expects the cUrl client to be included in the PATH. 

Examples

Example 1

Execute the cUrl client, to sent a GET request to the /api/build endpoint to the default Artifactory server

jfrog rt curl -XGET /api/build

Example 2

Execute the cUrl client, to send a GET request to the /api/build endpoint to the configured my-rt-server server ID.

jfrog rt curl -XGET /api/build --server-id my-rt-server

Build Integration

Overview

JFrog CLI integrates with any development ecosystem allowing you to collect build information and then publish it to Artifactory. By publishing build information to Artifactory, JFrog CLI empowers Artifactory to provide visibility into artifacts deployed, dependencies used and exhaustive information on the build environment to allow fully traceable builds.

Many of JFrog CLI's commands accept two optional command options: --build-name and --build-number. When these options are added, JFrog CLI collects and records the build info locally for these commands. 
When running multiple commands using the same build and build number, JFrog CLI aggregates the collected build info into one build.
The recorded build-info can be later published to Artifactory using the build-publish command.

Collecting Build Information

Build information is collected by adding the --build-name and --build-number options to different CLI commands. The CLI commands can be run several times and cumulatively collect build information for the specified build name and number until it is published to Artifactory. For example, running the download command several times with the same build name and number will accumulate each downloaded file in the corresponding build information. 

Collecting Dependencies

Dependencies are collected by adding  the --build-name and --build-number options to the download command .

For example, the following command downloads the cool-froggy.zip file found in repository my-local-repo , but it also specifies this file as a dependency in build my-build-name with build number 18:

Collecting Build Artifacts

Build artifacts are collected by adding  the --build-name and --build-number options to the upload command. 

For example, the following command specifies that file froggy.tgz uploaded to repository my-local-repo is a build artifact of build my-build-name with build number 18:

jfrog rt u froggy.tgz my-local-repo --build-name=my-build-name --build-number=18

Collecting Environment Variables

This command is used to collect environment variables and attach them to a build.

Environment variables are collected using the build-collect-env (bce) command.

For example, the following command collects all currently known environment variables, and attaches them to the build information for build my-build-name with build number 18:

jfrog rt bce my-build-name 18

The following table lists the command arguments and flags:

Example

Collect environment variables for build name: frogger-build and build number: 17

 jfrog rt bce frogger-build 17

Collecting Information from Git

The build-add-git (bag) command collects the Git revision and URL from the local .git directory and adds it to the build-info. It can also collect the list of tracked project issues (for example, issues stored in JIRA or other bug tracking systems) and add them to the build-info. The issues are collected by reading the git commit messages from the local git log. Each commit message is matched against a pre-configured regular expression, which retrieves the issue ID and issue summary. The information required for collecting the issues is retrieved from a yaml configuration file provided to the command.

The following table lists the command arguments and flags:

Example

This is the configuration file structure.

version: 1
issues:
  serverID: my-artifactory-server
  trackerName: JIRA
  regexp: (.+-[0-9]+)\s-\s(.+)
  keyGroupIndex: 1
  summaryGroupIndex: 2
  trackerUrl: http://my-jira.com/issues
  aggregate: true
  aggregationStatus: RELEASED

Configuration file properties

Adding Local Files As Build Dependencies

The download command, as well as other commands which download dependencies from Artifactory accept the --build-name and --build-number command options. Adding these options records the downloaded files as build dependencies. In some cases however, you'd like to add file, which have been downloaded by another tool, to a build. Use this command to to this.

Example

jfrog rt bad my-build-name 7 "path/to/build/dependencies/dir/"

Publishing Build Information

This command is used to publish build info to Artifactory. To publish the accumulated build information for a build to Artifactory, use the build-publish (bp) command. For example, the following command publishes all the build information collected for build my-build-name with build number 18:

jfrog rt bp my-build-name 18

This command is used to publish build info to Artifactory.

Example

Promoting a Build

This command is used to promote build in Artifactory.

Example

Distributing a Build

This command is used to deploy builds from Artifactory to Bintray, and creates an entry in the corresponding Artifactory distribution repository specified.

Example

Scanning a Published Build

JFrog CLI is integrated with JFrog Xray through JFrog Artifactory allowing you to have build artifacts scanned for vulnerabilities and other issues. This integration requires JFrog Artifactory v4.16 and above and JFrog Xray v1.6 and above. For more information, see CI-CD build integration.

This command allows scanning a build, which had already been published to Artifactory using the build-publish command.

Example

Cleaning up the Build

Build information is accumulated by the CLI according to the commands you apply until you publish the build information to Artifactory. If, for any reason, you wish to "reset" the build information and cleanup (i.e. delete) any information accumulated so far, you can use the build-clean (bc) command.

The following table lists the command arguments and flags:

For example, the following command cleans up any build information collected for build my-build-name with build number 18:

Discarding Old Builds from Artifactory

This command is used to discard builds previously published to Artifactory using the build-publish command.

The following table lists the command arguments and flags:

Example

Example 1

Discard the oldest build numbers of build my-build-name from Artifactory, leaving only the 10 most recent builds.

Example 2

Discard the oldest build numbers of build my-build-name from Artifactory, leaving only builds published during the last 7 days.

Example 3

Discard the oldest build numbers of build my-build-name from Artifactory, leaving only builds published during the last 7 days. b20 and b21 will not be discarded.

Running Maven Builds

JFrog CLI includes integration with Maven, allowing you to to resolve dependencies and deploy build artifacts from and to Artifactory, while collecting build-info and storing it in Artifactory.

Setting maven repositories

Before using using the mvn command, the project needs to be pre-configured with the Artifactory server and repositories, to be used for building and publishing the project. The mvn-config command should be used once to add the configuration to the project. The command should run while inside the root directory of the project. The configuration is stored by the command in the in the .jfrog directory at the root directory of the project.  

Running maven

The mvn command triggers the maven client, while resolving dependencies and deploying artifactds from and to Artofactory.

The following table lists the command arguments and flags:

Examples

Example 1

Run clean sna install with maven.

jfrog rt mvn clean install -f path/to/pom-file

Running Gradle Builds

JFrog CLI includes integration with Gradle, allowing you to to resolve dependencies and deploy build artifacts from and to Artifactory, while collecting build-info and storing it in Artifactory.

Setting gradle repositories

Before using using the gradle command, the project needs to be pre-configured with the Artifactory server and repositories, to be used for building and publishing the project. The mvn-config command should be used once to add the configuration to the project. The command should run while inside the root directory of the project. The configuration is stored by the command in the in the .jfrog directory at the root directory of the project.  

Running gradle

The gradle command triggers the gradle client, while resolving dependencies and deploying artifactds from and to Artofactory.

The following table lists the command arguments and flags:

Examples

Example 1

Build the project using the artifactoryPublish task, while resolving and deploying artifacts from and to Artifactory.

jfrog rt gradle clean artifactoryPublish -b path/to/build.gradle

Running Builds with MSBuild

JFrog CLI includes integration with MSBuild and Artifactory, allowing you to resolve dependencies and deploy build artifacts from and to Artifactory, while collecting build-info and storing it in Artifactory. This is done by having JFrog CLI in your search path and adding JFrog CLI commands to the MSBuild csproj file.

For detailed instructions, please refer to our  MSBuild Project Example on GitHub.

Building Docker Images

JFrog CLI provides full support for publishing docker images to Artifactory using the docker client running on the same machine. This allows you to to collect build-info for your docker build and then publish it to Artifactory. 

To build and push your docker images to Artifactory, follow these steps:

1. Make sure Artifactory can be used as docker registry. Please refer to Getting Started with Docker and Artifactory in the JFrog Artifactory User Guide.
   
2. Make sure that the installed docker client has version 17.07.0-ce (2017-08-29) or above. To verify this, run docker -v

3. To ensure that the docker client and your Artifactory docker registry are correctly configured to work together, run the following code snippet.

   docker pull hello-world
   docker tag hello-world:latest <artifactoryDockerRegistry>/hello-world:latest
   docker login <artifactoryDockerRegistry>
   docker push <artifactoryDockerRegistry>/hello-world:latest

   If everything is configured correctly, pushing any image including the hello-world image should be successfully uploaded to Artifactory.

Pulling Docker Images

Running docker-pull command allows pulling docker images from Artifactory, while collecting the build-info and storing it locally, so that it can be later published to Artifactory, using the build-publish command.

 The following table lists the command arguments and flags:

Examples

jfrog rt docker-pull my-docker-registry.io/my-docker-image:latest docker-local --build-name=my-build-name --build-number=7

You can then publish the build-info collected by the docker-pull command to Artifactory using the build-publish command.

Pushing Docker Images

After building your image using the docker client, the docker-push command pushes the image layers to Artifactory, while collecting the build-info and storing it locally, so that it can be later published to Artifactory, using the build-publish command.

The following table lists the command arguments and flags:

Examples

jfrog rt docker-push my-docker-registry.io/my-docker-image:latest docker-local --build-name=my-build-name --build-number=7

You can then publish the build-info collected by the docker-push command to Artifactory using the build-publish command.

Building Npm Packages

JFrog CLI provides full support for building npm packages using the npm client. This allows you to resolve npm dependencies, and publish your npm packages from and to Artifactory, while collecting build-info and storing it in Artifactory. 

 Follow these guidelines when building npm packages:

• You can download npm packages from any npm repository type - local, remote or virtual, but you can only publish to a local or virtual Artifactory repository, containing local repositories. To publish to a virtual repository, you first need to set a default local repository. For more details, please refer to  Deploying to a Virtual Repository.

• When the npm-publish command runs, JFrog CLI runs the pack command in the background. The pack action is followed by an upload, which is not based on the npm  client's publish command. Therefore, If your npm package includes the prepublish or postpublish scripts, rename them to prepack and postpack, respectively.

Requirements

Npm client version 5.4.0 and above.

Artifactory version 5.5.2 and above.

Setting npm repositories

Before using using the npm-install, npm-ci and npm-publish commands, the project needs to be pre-configured with the Artifactory server and repositories, to be used for building and publishing the project. The npm-config command should be used once to add the configuration to the project. The command should run while inside the root directory of the project. The configuration is stored by the command in the in the .jfrog directory at the root directory of the project.  

Installing Npm Packages

The npm-install and npm-ci commands execute npm's install and ci commands respectively, to fetches the npm dependencies from the npm repositories.

The following table lists the command arguments and flags:

Examples

Example 1

The following example installs the dependencies and records them locally as part of build my-build-name/1. The build-info can later be published to Artifactory using the build-publish command. The dependencies are resolved from the Artifactory server and repository configured by npm-config command. 

jfrog rt npm-install --build-name=my-build-name --build-number=1

Example 2

The following example installs the dependencies. The dependencies are resolved from the Artifactory server and repository configured by npm-config command.

jfrog rt npm-install

Example 3

The following example installs the dependencies using the npm-ci command. The dependencies are resolved from the Artifactory server and repository configured by npm-config command.

jfrog rt npm-ci

Publishing the Npm Packages into Artifactory

The npm-publish command packs and deploys the npm package to the designated npm repository.

The following table lists the command arguments and flags: 

Example

To pack and publish the npm package and also record it locally as part of build my-build-name/1, run the following command. The build-info can later be published to Artifactory using the build-publish command. The package is published to the Artifactory server and repository configured by npm-config command.

jfrog rt npm-publish --build-name=my-build-name --build-number=1

Building Go Packages

General

JFrog CLI provides full support for building Go packages using the Go client. This allows resolving Go dependencies from and publish your Go packages to Artifactory, while collecting build-info and storing it in Artifactory. 

Build Process

When building your go project using the jfrog rt go build command, JFrog CLI does the following:
1. Downloads the dependencies from Artifactory.

2. Dependencies which are missing in Artifactory are downloaded from the source control.

3. if the --publish-deps option is provided,  the missing dependencies downloaded from the source control are published to Artifactory. This requires deploy permissions.

3. Builds the project.

Using JFrog CLI vs. the Native Go Client

The native go client can be used to build packages with Artifactory. To set the go client to use Artifactory, the GOPROXY environment variable needs to be set and include the Artifactory instance details as follows:

<protocol>://<username>:<password>@<artifactory domain>/api/go/<go repository>

Some go packages however have not yet been converted to use go-modules and therefore cannot be proxied by Artifactory. It is recommended to use a virtual go repository, which includes a local repository, set as the default deployment repository. The virtual repository can include one or more remote repositories, to proxy remote sources such as GoCenter or github.

JFrog CLI provides a solution for this issue. It does this by attempting to download packages from Artifactory first and fall back to source control repositories if the packages cannot be fetched from Artifactory. JFrog CLI will publish these missing packages to Artifactory, so that they are available for the next builds.

Requirements

JFrog CLI client version 1.20.0 and above.

Artifactory version 6.2.0 and above.

Go client version 1.11.0 and above.

Example project

To help you get started, you can use this sample project on GitHub.

Setting Go repositories

Before you can use JFrog CLI to build your Go projects with Artifactory, you first need to set the resolutions and deployment repositories for the project.

Here's how you set the repositories.

1. CD to the root of the Go project.
2. Run the jfrog rt go-config command.

Examples

Example 1

Set repositories for for this go project.

jfrog rt go-config

Example 2

Set repositories for for all go projects on this machine.

jfrog rt go-config --global

Running Go commands

The go command triggers the go client.

The following table lists the command arguments and flags:

Examples

Example 1

The following example runs Go build command. The dependencies resolved from Artifactory via the go-virtual repository.

jfrog rt go build

Example 2

The following example runs Go build command, while recording the build-info locally under build name my-build and build number 1. The build-info can later be published to Artifactory using the build-publish command.

jfrog rt go build --build-name=my-build --build-number=1

Publishing Go Packages to Artifactory

The go-publish command packs and deploys the Go package to the designated Go repository in Artifactory.

The following table lists the command arguments and flags: 

Examples

Example 1

To pack and publish the Go package, run the following command:

jfrog rt gp go-virtual v1.2.3 

Example 2

To pack and publish the Go package and also record the build-info as part of build my-build-name/1, run the following command. The build-info can later be published to Artifactory using the build-publish command:

jfrog rt gp go-virtual v1.2.3 --build-name=my-build-name --build-number=1

Example 3

To pack and publish the Go package, the entire project dependencies and also record the build-info locally as part of build my-build-name/1, run the following command. The build-info can later be published to Artifactory using the build-publish command:

jfrog rt gp go-virtual v1.2.3 --deps=ALL --build-name=my-build-name --build-number=1

Example 4

To pack and publish the Go package, selected dependencies and also record the build-info locally as part of build my-build-name/1, run the following command. The build-info can later be published to Artifactory using the build-publish command:

jfrog rt gp go-virtual v1.2.3 --deps=rsc.io/quote:v1.5.2,rsc.io/sampler:v1.3.0 --build-name=my-build-name --build-number=1

Populating Artifactory with Go Packages

This command recursively discovers all project dependencies, both direct and indirect, and publishes them to Artifactory.

Example 1

jfrog rt grp go-local

Building Python Packages

JFrog CLI provides full support for building Python packages using the pip package installer. This allows resolving pip dependencies from Artifactory, while recording the downloaded packages. The downloaded packages are stored as dependencies in the build-info stored in Artifactory.

Once the packages are installed, the Python project can be then built and packaged using the the python client. Once built, the produced artifacts can be uploaded to Artifactory using JFrog CLI's upload command and registered as artifacts in the build-info.

Example project

To help you get started, you can use this sample project on GitHub.

Setting Python repository

Before you can use JFrog CLI to build your Python projects with Artifactory, you first need to set the repository for the project.

Here's how you set the repositories.

1. CD to the root of the Python project.
2. Run the jfrog rt pip-config command.

Examples

Example 1

Set repositories for this Python project.

jfrog rt pipc

Example 2

Set repositories for all Python projects on this machine.

jfrog rt pipc --global

Installing Python packages

The pip-install command uses the pip client to install the project dependencies from Artifactory. It can also record these packages as build dependencies as part of the build-info published to Artifactory.

Examples

The following are two examples from running pip install, while recording the build dependencies as part of build name my-build and build number 1.

jfrog rt pip-install . --build-name=my-build --build-number=1
jfrog rt pip-install -r requirements.txt --build-name=my-build --build-number=1

Building Nuget Packages

JFrog CLI provides full support for restoring Nuget packages using the Nuget client. This allows you to resolve Nuget dependencies from and publish your Nuget packages to Artifactory, while collecting build-info and storing it in Artifactory. 

Nuget dependencies resolution is supported by the jfrog rt nuget command.

To publish your nuget packages to Artifactory, use the jfrog rt upload command.

Setting Nuget repositories

Before using using the nuget command, the project needs to be pre-configured with the Artifactory server and repository, to be used for building the project. The nuget-config command should be used once to add the configuration to the project. The command should run while inside the root directory of the project. The configuration is stored by the command in the in the .jfrog directory at the root directory of the project.  

Running Nuget commands

The nuget command runs the nuget client.

The following table lists the command arguments and flags:

Examples

Example 1

Run nuget restore for the solution at the current directory, while resolving the nuget dependencies from the pre-configured Artifactory repository.

jfrog rt nuget restore

Example 2

Run nuget restore for the solution at the current directory, while resolving the nuget dependencies from the nuget-virtual Artifactory repository. 

In addition, record the build-info as part of build my-build-name/1. The build-info can later be published to Artifactory using the build-publish command:

jfrog rt nuget restore nuget-virtual --build-name=my-build-name --build-number=1

Using File Specs

To achieve complex file manipulations you may require several CLI commands. For example, you may need to upload several different sets of files to different repositories. To simplify the implementation of these complex manipulations, you can apply JFrog CLI download, upload, move, copy and delete commands with JFrog Artifactory using --spec option to replace the inline command arguments and options. Each command uses an array of file specifications in JSON format with a corresponding schema as described in the sections below. Note that if any of these commands are issued using both inline options as well as the file specs, then the inline options override their counterparts specified in the file specs.

File Spec Schemas

Copy and Move Commands Spec Schema

The file spec schema for the copy and move commands is as follows:

{
    "files": [
        {
            "pattern" or "aql": "[Mandatory]",
            "target": "[Mandatory]",
            "props": "[Optional]",
			"excludeProps": "[Optional]",
            "recursive": "[Optional, Default: 'true']",
            "flat" : "[Optional, Default: 'false']",
            "excludePatterns": ["[Optional, Applicable only when 'pattern' is specified]"],
            "archiveEntries": "[Optional]",
            "build": "[Optional]",
            "sortBy" : ["[Optional]"],
            "sortOrder": "[Optional, Default: 'asc']",
            "limit": [Optional],
            "offset": [Optional]
        }
    ]
}

Download Command Spec Schema

The file spec schema for the download command is as follows:

{
    "files": [
        {
            "pattern" or "aql": "[Mandatory]",
            "target": "[Optional]",
            "props": "[Optional]",
			"excludeProps": "[Optional]",
            "recursive": "[Optional, Default: 'true']",
            "flat" : "[Optional, Default: 'false']",
            "excludePatterns": ["[Optional, Applicable only when 'pattern' is specified]"],
            "archiveEntries": "[Optional]",
            "build": "[Optional]",
            "sortBy" : ["[Optional]"],
            "sortOrder": "[Optional, Default: 'asc']",
            "limit": [Optional],
            "offset": [Optional]
        }
    ]
}

Upload Command Spec Schema

The file spec schema for the upload command is as follows:

{
    "files": [
        {
            "pattern": "[Mandatory]",
            "target": "[Mandatory]",
            "props": "[Optional]",
            "recursive": "[Optional, Default: 'true']",
            "flat" : "[Optional, Default: 'true']",
            "regexp": "[Optional, Default: 'false']",
            "excludePatterns": ["[Optional]"],
			"syncDeletes": "[Optional]",
            "build": "[Optional]"
        }
    ]
}

Search, Set-Props and Delete Commands Spec Schema

The file spec schema for the search and delete commands are as follows:

{
    "files": [
        {
            "pattern" or "aql": "[Mandatory]",
            "props": "[Optional]",
			"excludeProps": "[Optional]",
            "recursive": "[Optional, Default: 'true']",
            "excludePatterns": ["[Optional, Applicable only when 'pattern' is specified]"],
            "archiveEntries": "[Optional]",
            "build": "[Optional]",
            "sortBy" : ["[Optional]"],
            "sortOrder": "[Optional, Default: 'asc']",
            "limit": [Optional],
            "offset": [Optional]
        }
    ]
}

Examples

The following examples can help you get started using File Specs.

Example 1:

Download all files located under the all-my-frogs directory in the my-local-repo repository to the froggy directory.

{
    "files": [
        {
            "pattern": "my-local-repo/all-my-frogs/",
            "target": "froggy/"
        }
    ]
}

Example 2: 

Download all files located under the all-my-frogs directory in the my-local-repo repository to the froggy directory. Download only files which are artifacts of build number 5 of build my-build.

{
    "files": [
        {
            "pattern": "my-local-repo/all-my-frogs/",
            "target": "froggy/",
            "build": "my-build/5"
        }
    ]
}

Example 3:

Download all files retrieved by the AQL query to the froggy directory.

{
  "files": [
    {
      "aql": {
        "items.find": {
          "repo": "my-local-repo",
          "$or": [
            {
              "$and": [
                {
                  "path": {
                    "$match": "."
                  },
                  "name": {
                    "$match": "a1.in"
                  }
                }
              ]
            },
            {
              "$and": [
                {
                  "path": {
                    "$match": "*"
                  },
                  "name": {
                    "$match": "a1.in"
                  }
                }
              ]
            }
          ]
        }
      },
      "target": "froggy/"
    }
  ]
}

Example 4: Upload

1. All zip files located under the resources directory to the zip folder, under the all-my-frogs repository.

   AND 

2. All TGZ files located under the resources directory to the tgz folder, under the all-my-frogs repository.

3. Tag all zip files with type = zip and status = ready.

4. Tag all tgz files with type = tgz and status = ready.

{
  "files": [
    {
      "pattern": "resources/*.zip",
      "target": "all-my-frogs/zip/",
      "props": "type=zip;status=ready"
    },
    {
      "pattern": "resources/*.tgz",
      "target": "all-my-frogs/tgz/",
      "props": "type=tgz;status=ready"
    }
  ]
}

Example 5:

Upload all zip files located under the resources directory to the zip folder, under the all-my-frogs repository.

AND

Delete all files the the zip folder, under the all-my-frogs repository, except for the files which were uploaded by this command execution.

{
  "files": [
    {
      "pattern": "resources/*.zip",
      "target": "all-my-frogs/zip/",
      "syncDeletes": "all-my-frogs/zip/"
    }
  ]
}

Example 6: 

Download all files located under the all-my-frogs directory in the my-local-repo repository except for files with .txt extension and all files inside the all-my-frogs directory with the props. prefix.

Notice that the exclude patterns do not include the repository.

{
    "files": [
     {
        "pattern": "my-local-repo/all-my-frogs/",
        "excludePatterns": ["*.txt","all-my-frog/props.*"]
     }
    ]
}

Example 7: 

Download The latest file uploaded to the all-my-frogs directory in the my-local-repo repository.

{
    "files": [
     {
        "pattern": "my-local-repo/all-my-frogs/",
        "target": "all-my-frogs/files/",
        "sortBy": ["created"],
        "sortOrder": "desc",
        "limit": 1
     }
    ]
}

Example 8: 

Search for the three largest files located under the all-my-frogs directory in the my-local-repo repository. If there are files with the same size, sort them "internally" by creation date.

{
    "files": [
     {
        "pattern": "my-local-repo/all-my-frogs/",
        "sortBy": ["size","created"],
        "sortOrder": "desc",
        "limit": 3
     }
    ]
}

Example 9: 

Download The second latest file uploaded to the all-my-frogs directory in the my-local-repo repository.

{
    "files": [
     {
        "pattern": "my-local-repo/all-my-frogs/",
        "target": "all-my-frogs/files/",
        "sortBy": ["created"],
        "sortOrder": "desc",
        "limit": 1,
        "offset": 1
     }
    ]
}

Example 10:

This example shows how to delete artifacts in artifactory under specified path based on how old they are. 

The following File Spec finds all the folders which match the following criteria:

1. They are under the my-repo repository.
2. They are inside a folder with a name that matches abc-*-xyz and is located at the root of the repository.
3. Their name matches ver_*
4. They were created more that 7 days ago.

{
  "files": [
    {
      "aql": {
        "items.find": {
          "repo": "myrepo",
          "path": {"$match":"abc-*-xyz"},
          "name": {"$match":"ver_*"},
          "type": "folder",
          "$or": [
            {
              "$and": [
                {
                  "created": { "$before":"7d" }
                }
              ]
            }
          ]
        }
      }
    }
  ]
}

Downloading the Maven and Gradle Extractor JARs

For integrating with Maven and Gradle, JFrog CLI uses the build-info-extractor jars files. These jar files are downloaded by JFrog CLI from jcenter the first time they are needed.

If you're using JFrog CLI on a machine which has no access to the internet, you can configure JFrog CLI to download these jar files from an Artifactory instance. Here's how to configure Artifactory and JFrog CLI to download the jars files.

1. Create a remote Maven repository in Artifactory and name it jcenter. When creating the repository, configure it to proxy https://jcenter.bintray.com

2. Make sure that this Artifactory server is known to JFrog CLI, using the jfrog rt c show command. If not, configure it using the jfrog rt c command.

3. Set the JFROG_CLI_JCENTER_REMOTE_SERVER environment variable with the server ID of the Artifactory server you configured.

4. If you prefer to use a remote repository with a name different than jcenter, you can configure this name as the value of the JFROG_CLI_JCENTER_REMOTE_REPO environment variable.