Comment télécharger le dernier artefact depuis Artifactory repository?

Quelque chose comme le script bash suivant récupérera le dernier instantané com.company:artifact du repo snapshot:

# Artifactory location
server=http://artifactory.company.com/artifactory
repo=snapshot

# Maven artifact location
name=artifact
artifact=com/company/$name
path=$server/$repo/$artifact
version=$(curl -s $path/maven-metadata.xml | grep latest | sed "s/.*<latest>\([^<]*\)<\/latest>.*/\1/")
build=$(curl -s $path/$version/maven-metadata.xml | grep '<value>' | head -1 | sed "s/.*<value>\([^<]*\)<\/value>.*/\1/")
jar=$name-$build.jar
url=$path/$version/$jar

# Download
echo $url
wget -q -N $url

, Il se sent un peu sale, oui, mais il fait le travail.

Utilisation des outils shell / unix

1. curl 'http://$artiserver/artifactory/api/storage/$repokey/$path/$version/?lastModified'

La commande ci-dessus répond avec un JSON avec deux éléments - " uri "et"lastModified"

1. Récupérer le lien dans l'uri renvoie un autre JSON qui a le "downloadUri" de l'artefact.

2. Récupérer le lien dans le "downloadUri" et vous avez le dernier artefact.

Utilisation du plugin Jenkins Artifactory

(nécessite Pro) pour résoudre et télécharger le dernier artefact, si Jenkins Le plugin Artifactory a été utilisé pour publier sur artifactory dans un autre travail:

1. Sélectionnez L'Intégration D'Artifactory Générique
2. Utiliser des artefacts résolus comme ${repokey}:**/${component}*.jar;status=${STATUS}@${PUBLISH_BUILDJOB}#LATEST=>${targetDir}

Vous pouvez utiliser le wget --user=USER --password=PASSWORD .. commande, mais avant que vous pouvez faire cela, vous devez autoriser artifactory pour forcer l'authentification, ce qui peut être fait par décochant le "Cacher l'Existence de Ressources non autorisées" boîte à Sécurité/Général onglet artifactory panneau d'admin. Sinon artifactory envoie une page 404 et wget ne peut pas s'authentifier à artifactory.

Le rôle D'Artifactory est de fournir des fichiers pour Maven (ainsi que d'autres outils de construction tels que Ivy, Gradle ou sbt). Vous pouvez simplement utiliser Maven avec le Maven-dependency-plugin pour copier les artefacts. Voici un plan pom pour commencer...

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>A group id</groupId>
    <artifactId>An artifact id</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>pom</packaging>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>2.3</version>
                <executions>
                    <execution>
                        <id>copy</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy</goal>
                        </goals>
                        <configuration>
                            <artifactItems>
                                <artifactItem>
                                    <groupId>The group id of your artifact</groupId>
                                    <artifactId>The artifact id</artifactId>
                                    <version>The snapshot version</version>
                                    <type>Whatever the type is, for example, JAR</type>
                                    <outputDirectory>Where you want the file to go</outputDirectory>
                                </artifactItem>
                            </artifactItems>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Exécutez simplement mvn install pour faire la copie.

Vous pouvez utiliser "Item last modified " de L'API REST. À partir des docs, il retourne quelque chose comme ceci:

GET /api/storage/libs-release-local/org/acme?lastModified
{
"uri": "http://localhost:8081/artifactory/api/storage/libs-release-local/org/acme/foo/1.0-SNAPSHOT/foo-1.0-SNAPSHOT.pom",
"lastModified": ISO8601
}

Exemple:

# Figure out the URL of the last item modified in a given folder/repo combination
url=$(curl \
    -H 'X-JFrog-Art-Api: XXXXXXXXXXXXXXXXXXXX' \
    'http://<artifactory-base-url>/api/storage/<repo>/<folder>?lastModified'  | jq -r '.uri')
# Figure out the name of the downloaded file
downloaded_filename=$(echo "${url}" | sed -e 's|[^/]*/||g')
# Download the file
curl -L -O "${url}"

Avec les versions récentes d'artifactory, vous pouvez l'interroger via l'api.

Https://www.jfrog.com/confluence/display/RTF/Artifactory+REST+API#ArtifactoryRESTAPI-RetrieveLatestArtifact

Si vous avez un artefact maven avec 2 instantanés

Nom => 'com.Acme.derp"
version = > 0.1.0
repo nom => 'foo'
cliché 1 => derp-0.1.0-20161121.183847-3.jar
cliché 2 => derp-0.1.0-20161122.00000-0.jar

Alors les chemins complets soit

Https://artifactory.example.com/artifactory/foo/com/acme/derp/0.1.0-SNAPSHOT/derp-0.1.0-20161121.183847-3.jar

Et

Https://artifactory.example.com/artifactory/foo/com/acme/derp/0.1.0-SNAPSHOT/derp-0.1.0-20161122.00000-0.jar

Vous récupéreriez le dernier comme ceci:

curl https://artifactory.example.com/artifactory/foo/com/acme/derp/0.1.0-SNAPSHOT/derp-0.1.0-SNAPSHOT.jar

Vous pouvez également utiliser Artifactory Langage de Requête pour obtenir le dernier artefact.

Le script shell suivant n'est qu'un exemple. Il utilise les " éléments.find()' (qui est disponible dans la version non-Pro), par exemple {[1] } qui recherche les fichiers dont le nom de référentiel est égal à "my-repo" et qui correspondent à tous les fichiers commençant par"My-file". Ensuite, il utilise l'analyseur JSON shell ./ jq pour extraire le dernier fichier en le triant par le champ date 'updated'. Ensuite, utilisez wget pour télécharger le artefact.

#!/bin/bash

# Artifactory settings
host="127.0.0.1"
username="downloader"
password="my-artifactory-token"

# Use Artifactory Query Language to get the latest scraper script (https://www.jfrog.com/confluence/display/RTF/Artifactory+Query+Language)
resultAsJson=$(curl -u$username:"$password" -X POST  http://$host/artifactory/api/search/aql -H "content-type: text/plain" -d 'items.find({ "repo": {"$eq":"my-repo"}, "name": {"$match" : "my-file*"}})')

# Use ./jq to pars JSON
latestFile=$(echo ${resultAsJson} |  jq -r '.results | sort_by(.updated) [-1].name'))

# Download the latest scraper script
wget -N -P ./libs/ --user $username --password $password http://$host/artifactory/my-repo/$latestFile

Cela peut être Nouveau:

Https://artifactory.example.com/artifactory/repo/com/example/foo/1.0.[RELEASE]/foo-1.0.[RELEASE].tgz

Pour charger le module foo à partir de example.com . Conservez les parties [RELEASE] verbatim. Ceci est mentionné dans les documents, mais il n'est pas très clair que vous pouvez réellement mettre [RELEASE] dans L'URL (par opposition à un modèle de substitution pour le développeur).

J'utilise Nexus et ce code fonctionne pour moi-peut récupérer à la fois release et last snaphsot , selon le type de référentiel:

server="http://example.com/nexus/content/repositories"
repo="snapshots"
name="com.exmple.server"
artifact="com/example/$name"
path=$server/$repo/$artifact
mvnMetadata=$(curl -s "$path/maven-metadata.xml")
echo "Metadata: $mvnMetadata"
jar=""
version=$( echo "$mvnMetadata" | xpath -e "//versioning/release/text()" 2> /dev/null)
if [[ $version = *[!\ ]* ]]; then
  jar=$name-$version.jar
else
  version=$(echo "$mvnMetadata" | xpath -e "//versioning/versions/version[last()]/text()")
  snapshotMetadata=$(curl -s "$path/$version/maven-metadata.xml")
  timestamp=$(echo "$snapshotMetadata" | xpath -e "//snapshot/timestamp/text()")
  buildNumber=$(echo "$snapshotMetadata" | xpath -e "//snapshot/buildNumber/text()")
  snapshotVersion=$(echo "$version" | sed 's/\(-SNAPSHOT\)*$//g')
  jar=$name-$snapshotVersion-$timestamp-$buildNumber.jar
fi
jarUrl=$path/$version/$jar
echo $jarUrl
mkdir -p /opt/server/
wget -O /opt/server/server.jar -q -N $jarUrl