Déploiements multiples dans maven

Question

Nous avons un référentiel artificiel interne. À l'heure actuelle, tous les instantanés seront déployés là-bas. Nous voulons aussi avoir un serveur différent avec une interface web, et que nous voulons copier les artefacts créés. Pour nos versions, nous utilisons Hudson, mais l'action de post-construction "Déployer des artefacts dans le référentiel Maven" avec scp ne fonctionne pas. Donc, il y a la question de le faire d'une autre manière élégante. Pourquoi maven n'est pas capable d'avoir plusieurs référentiels de distribution? Des idées?

La chose la plus intéressante serait que l'artefact supporte une exportation incrémentielle (automatique!) Vers un référentiel maven standard après chaque nouveau déploiement.

Answer 1

Je ne pense pas que maven supporte le déploiement dans plusieurs référentiels pour un seul profil, mais peut-être que les profils pourraient changer l'ID et l'URL du référentiel.

<distributionManagement> 
    <repository> 
     <id>${repo-id}</id> 
     <name>${repo-name}</name> 
     <url>${repo-url}</url> 
    </repository> 
    </distributionManagement> 

Maven Deployment

ensuite utiliser des profils pour choisir qui repo à déployer à:

<profiles> 
    <profile> 
    <id>repo1</id> 
    <activation> 
     <activeByDefault>true</activeByDefault> 
    </activation> 
    <properties> 
     <repo-id>repo1</repo-id> 
     <repo-name>Repo1 Name </repo-name> 
     <repo-url>http://url.com/maven2</repo-url> 
    </properties> 
    </profile> 
    <profile> 
    <id>repo2</id> 
    <properties> 
     <repo-id>repo2</repo-id> 
     <repo-name>Repo2 Name </repo-name> 
     <repo-url>http://url2.com/maven2</repo-url> 
    </properties> 
    </profile> 
</profiles> 

Maven profiles

Answer 2

Artifactory fait ont une fonction d'exportation automatique. De the documentation:

Vous pouvez sauvegarder automatiquement et périodiquement l'ensemble du système de Artifactory. Le processus de sauvegarde crée un répertoire horodaté (ou fichier zip) dans le répertoire de sauvegarde cible et est fondamentalement identique à l'exécution de l'exportation complète du système avec des métadonnées. [...] Chaque sauvegarde peut avoir son propre calendrier et exclure certains dépôts [...]

Le contenu de la sauvegarde (lorsqu'elle est extraite) est au format Maven standard et peut être chargé dans n'importe quel référentiel Maven externe [ ...]

Artifactory prend en charge la sauvegarde incrémentielle du même répertoire cible (nommé "current") dans le répertoire de sauvegarde cible. Ce type de sauvegarde écrit uniquement les deltas dans le répertoire de sortie, ce qui permet des sauvegardes extrêmement rapides.

N'est-ce pas exactement ce dont vous avez besoin? Pour transférer les fichiers, vous pouvez soit monter un répertoire partagé sur le serveur distant et y effectuer la sauvegarde, soit effectuer la sauvegarde localement puis la synchroniser.

Answer 3

Je pense que dans Artifactory, par défaut, il gère différents référentiels logiques pour le téléchargement de snapshots et de non-snapshots. En utilisant les autorisations, vous pouvez rendre le référentiel de clichés visible uniquement pour certains. Si cela ne suffit pas, une autre solution qui fonctionne avec Artifactory 2.0 est qu'Artifactory utilise une base de données MySQL qui effectue une réplication asynchrone vers une autre base de données MySQL, elle-même lue par une installation séparée d'Artifactory. Si c'est trop en temps réel, vous pouvez simplement avoir deux installations différentes qui effectuent des mises à jour basées sur des règles métier.

Answer 4

Si vous souhaitez utiliser un plugin personnalisé, vous pouvez configurer Maven pour qu'il se déploie dans une liste d'emplacements "miroir" en même temps que le déploiement standard. Je vous recommande de définir ceci dans un profil afin que vous puissiez contrôler quels déploiements sont mis en miroir (il peut ne pas être approprié de le faire à chaque génération).

Pour définir un nouveau plugin, vous devez créer un nouveau projet Maven et préciser le POM a emballage maven-plugin:

<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/maven-v4_0_0.xsd"> 
    <modelVersion>4.0.0</modelVersion> 
    <groupId>name.seller.rich</groupId> 
    <artifactId>maven-mirror-plugin</artifactId> 
    <packaging>maven-plugin</packaging> 
    <version>0.0.1</version> 
    <dependencies> 
    <dependency> 
     <groupId>org.apache.maven</groupId> 
     <artifactId>maven-plugin-api</artifactId> 
     <version>2.2.0</version> 
    </dependency> 
    <dependency> 
     <groupId>org.apache.maven.plugins</groupId> 
     <artifactId>maven-deploy-plugin</artifactId> 
     <version>2.4</version> 
    </dependency> 
    </dependencies> 
</project> 

src/main/java définir un Mojo. Le code ci-dessous déclare un objectif "miroir", il prend une liste d'éléments mirrorRepository (contenant un repositoryId et un url) pour refléter le déploiement d'artefacts. Le plugin utilise la même approche pour le déploiement que maven-deploy-plugin, et prend la plupart des mêmes paramètres.

Notez que vous devez toujours définir un serveur dans votre fichier settings.xml pour chaque référentiel avec les autorisations appropriées pour effectuer le déploiement ou la génération échouera!

package name.seller.rich; 

import java.io.File; 
import java.util.Iterator; 
import java.util.List; 
import java.util.Map; 

import org.apache.maven.artifact.Artifact; 
import org.apache.maven.artifact.deployer.ArtifactDeployer; 
import org.apache.maven.artifact.deployer.ArtifactDeploymentException; 
import org.apache.maven.artifact.metadata.ArtifactMetadata; 
import org.apache.maven.artifact.repository.ArtifactRepository; 
import org.apache.maven.artifact.repository.ArtifactRepositoryFactory; 
import org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout; 
import org.apache.maven.plugin.AbstractMojo; 
import org.apache.maven.plugin.MojoExecutionException; 
import org.apache.maven.plugin.MojoFailureException; 
import org.apache.maven.project.MavenProject; 
import org.apache.maven.project.artifact.ProjectArtifactMetadata; 

/** 
* @goal mirror 
* @phase deploy 
*/ 
public class MirrorMojo extends AbstractMojo { 
    /** 
    * @parameter expression= 
    *   "${component.org.apache.maven.artifact.deployer.ArtifactDeployer}" 
    * @required 
    * @readonly 
    */ 
    private ArtifactDeployer deployer; 

    /** 
    * Map that contains the layouts 
    * 
    * @component role= 
    *   "org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout" 
    */ 
    private Map repositoryLayouts; 

    /** 
    * Component used to create a repository 
    * 
    * @component 
    */ 
    private ArtifactRepositoryFactory repositoryFactory; 

    /** 
    * The type of remote repository layout to deploy to. Try <i>legacy</i> for 
    * a Maven 1.x-style repository layout. 
    * 
    * @parameter expression="${repositoryLayout}" default-value="default" 
    * @required 
    */ 
    private String repositoryLayout; 

    /** 
    * Parameter used to update the metadata to make the artifact as release. 
    * 
    * @parameter expression="${updateReleaseInfo}" default-value="false" 
    */ 
    private boolean updateReleaseInfo; 

    /** 
    * Whether to deploy snapshots with a unique version or not. 
    * 
    * @parameter expression="${uniqueVersion}" default-value="true" 
    */ 
    private boolean uniqueVersion; 

    /** 
    * @parameter expression="${mirrorRepositories}" 
    * @required 
    */ 
    private MirrorRepository[] mirrorRepositories; 

    /** 
    * @parameter expression="${localRepository}" 
    * @required 
    * @readonly 
    */ 
    private ArtifactRepository localRepository; 

    /** 
    * @parameter expression="${project}" 
    * @required 
    * @readonly 
    */ 
    private MavenProject project; 

    /** 
    * Deploy all artifacts for the project to each mirror repository. 
    */ 
    public void execute() throws MojoExecutionException, MojoFailureException { 
     ArtifactRepositoryLayout layout; 

     layout = (ArtifactRepositoryLayout) repositoryLayouts 
       .get(repositoryLayout); 

     for (int i = 0; i < mirrorRepositories.length; i++) { 
      MirrorRepository mirrorRepository = mirrorRepositories[i]; 

      ArtifactRepository deploymentRepository = repositoryFactory 
        .createDeploymentArtifactRepository(mirrorRepository 
          .getRepositoryId(), mirrorRepository.getUrl(), 
          layout, uniqueVersion); 

      String protocol = deploymentRepository.getProtocol(); 

      if ("".equals(protocol) || protocol == null) { 
       throw new MojoExecutionException("No transfer protocol found."); 
      } 

      deployToRepository(deploymentRepository); 
     } 

    } 

    /** 
    * Deploy all artifacts to the passed repository. 
    */ 
    private void deployToRepository(ArtifactRepository repo) 
      throws MojoExecutionException { 
     String protocol = repo.getProtocol(); 

     if (protocol.equalsIgnoreCase("scp")) { 
      File sshFile = new File(System.getProperty("user.home"), ".ssh"); 

      if (!sshFile.exists()) { 
       sshFile.mkdirs(); 
      } 
     } 

     File pomFile = project.getFile(); 
     Artifact artifact = project.getArtifact(); 
     // Deploy the POM 
     boolean isPomArtifact = "pom".equals(project.getPackaging()); 
     if (!isPomArtifact) { 
      ArtifactMetadata metadata = new ProjectArtifactMetadata(artifact, 
        pomFile); 
      artifact.addMetadata(metadata); 
     } 

     if (updateReleaseInfo) { 
      artifact.setRelease(true); 
     } 

     try { 
      List attachedArtifacts = project.getAttachedArtifacts(); 

      if (isPomArtifact) { 
       deployer.deploy(pomFile, artifact, repo, localRepository); 
      } else { 
       File file = artifact.getFile(); 

       if (file != null && !file.isDirectory()) { 
        deployer.deploy(file, artifact, repo, localRepository); 
       } else if (!attachedArtifacts.isEmpty()) { 
        getLog() 
          .info(
            "No primary artifact to deploy, deploy attached artifacts instead."); 
       } else { 
        String message = "The packaging for this project did not assign a file to the build artifact"; 
        throw new MojoExecutionException(message); 
       } 
      } 

      for (Iterator i = attachedArtifacts.iterator(); i.hasNext();) { 
       Artifact attached = (Artifact) i.next(); 

       deployer.deploy(attached.getFile(), attached, repo, 
         localRepository); 
      } 
     } catch (ArtifactDeploymentException e) { 
      throw new MojoExecutionException(e.getMessage(), e); 
     } 
    } 
} 

Mojo références type MirrorRepository pour encapsuler le repositoryId et l'url, il est un haricot simple:

package name.seller.rich; 

public class MirrorRepository { 
    private String repositoryId; 
    private String url; 

    public String getRepositoryId() { 
     return repositoryId; 
    } 

    public void setRepositoryId(String repositoryId) { 
     this.repositoryId = repositoryId; 
    } 

    public String getUrl() { 
     return url; 
    } 

    public void setUrl(String url) { 
     this.url = url; 
    } 
} 

Voici un exemple de configuration en utilisant le plug-in. Notez que tous les formats de déploiement sont pris en charge (http, scp, ftp):

<plugin> 
    <groupId>name.seller.rich</groupId> 
    <artifactId>maven-mirror-plugin</artifactId> 
    <executions> 
    <execution> 
     <id>mirror</id> 
     <phase>deploy</phase> 
     <goals> 
     <goal>mirror</goal> 
     </goals> 
    </execution> 
    </executions> 
    <configuration> 
    <mirrorRepositories> 
     <mirrorRepository> 
     <repositoryId>mirror</repositoryId> 
     <url>http://path/to/mirror</url> 
     </mirrorRepository> 
    </mirrorRepositories> 
    <!--any other deploy configuration needed--> 
    </configuration> 
</plugin>