/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import org.apache.maven.model.Model;
import org.apache.maven.model.io.xpp3.MavenXpp3Reader;
import org.apache.maven.repository.internal.DefaultArtifactDescriptorReader;
import org.apache.maven.repository.internal.DefaultVersionRangeResolver;
import org.apache.maven.repository.internal.DefaultVersionResolver;
import org.apache.maven.repository.internal.MavenRepositorySystemUtils;
import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
import org.eclipse.aether.DefaultRepositorySystemSession;
import org.eclipse.aether.RepositorySystem;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.artifact.DefaultArtifact;
import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory;
import org.eclipse.aether.deployment.DeployRequest;
import org.eclipse.aether.deployment.DeploymentException;
import org.eclipse.aether.impl.*;
import org.eclipse.aether.installation.InstallationException;
import org.eclipse.aether.internal.impl.DefaultDependencyCollector;
import org.eclipse.aether.internal.impl.DefaultTransporterProvider;
import org.eclipse.aether.repository.Authentication;
import org.eclipse.aether.repository.LocalRepository;
import org.eclipse.aether.repository.RemoteRepository;
import org.eclipse.aether.spi.connector.RepositoryConnectorFactory;
import org.eclipse.aether.spi.connector.transport.TransporterFactory;
import org.eclipse.aether.spi.connector.transport.TransporterProvider;
import org.eclipse.aether.transport.file.FileTransporterFactory;
import org.eclipse.aether.transport.http.HttpTransporterFactory;
import org.eclipse.aether.transport.wagon.WagonTransporterFactory;
import org.eclipse.aether.util.repository.AuthenticationBuilder;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
/**
* Updated Version of the SDKDeployer which no longer relies on an installed Maven
* system and which performs the deployment inside the VM without having to spawn new
* VMs for each artifact in order to deploy the files using a Maven commandline
* execution.
*
* Created with IntelliJ IDEA.
* User: cdutz
* Date: 03.11.13
*
* @author Christofer Dutz
*/
public class SDKInVMDeployer {
private String directory;
private String url;
private String username;
private String password;
public SDKInVMDeployer(String[] parameters) {
this.directory = parameters[0];
this.url = parameters[1];
if (parameters.length > 2) {
this.username = parameters[2];
this.password = parameters[3];
}
}
public static void main(String[] args) {
if ((args.length != 2) && (args.length != 4)) {
printUsage();
System.exit(0);
}
final SDKInVMDeployer deployer = new SDKInVMDeployer(args);
deployer.start();
}
private static void printUsage() {
System.out.println("\nUsage: java -cp flex-sdk-converter-1.0.jar SDKInVMDeployer \"directory\" \"url\" [\"username\", \"password\"]\n");
System.out.println("The SDKDeployer needs at least 2 ordered parameters separated by spaces:");
System.out.println("\t1- directory: The path to the directory containing the artifacts that should be deployed.");
System.out.println("\t2- url: URL where the artifacts will be deployed.");
System.out.println("If the targeted repository requires authentication two more parameters have to be provided:");
System.out.println("\t3- username: The username used to authenticate on the target repository.");
System.out.println("\t4- password: The password used to authenticate on the target repository.");
}
private void start() {
try {
final DefaultServiceLocator locator = new DefaultServiceLocator();
locator.addService(RepositoryConnectorFactory.class, BasicRepositoryConnectorFactory.class);
locator.addService(VersionResolver.class, DefaultVersionResolver.class);
locator.addService(VersionRangeResolver.class, DefaultVersionRangeResolver.class);
locator.addService(ArtifactDescriptorReader.class, DefaultArtifactDescriptorReader.class);
locator.addService(DependencyCollector.class, DefaultDependencyCollector.class);
locator.addService(RepositoryConnectorFactory.class, BasicRepositoryConnectorFactory.class);
locator.addService(TransporterProvider.class, DefaultTransporterProvider.class);
locator.addService(TransporterFactory.class, FileTransporterFactory.class);
locator.addService(TransporterFactory.class, HttpTransporterFactory.class);
locator.addService(TransporterFactory.class, WagonTransporterFactory.class);
final RepositorySystem repositorySystem = locator.getService(RepositorySystem.class);
if (repositorySystem == null) {
System.out.println("Couldn't initialize local maven repository system.");
System.exit(0);
} else {
// Setup the repository system session based upon the current maven settings.xml.
final DefaultRepositorySystemSession session = MavenRepositorySystemUtils.newSession();
final LocalRepository localRepo = new LocalRepository(directory);
RemoteRepository.Builder repoBuilder = new RemoteRepository.Builder("repo", "default", url);
if ((username != null) && (password != null)) {
final Authentication authentication = new AuthenticationBuilder().addUsername(
username).addPassword(password).build();
repoBuilder.setAuthentication(authentication);
}
final RemoteRepository remoteRepository = repoBuilder.build();
session.setLocalRepositoryManager(repositorySystem.newLocalRepositoryManager(session, localRepo));
// Process all content of the mavenizer target directory.
final File rootDir = new File(directory);
processDir(rootDir, repositorySystem, session, remoteRepository);
}
} catch (Throwable e) {
e.printStackTrace();
}
}
private void processDir(File curDir, RepositorySystem repositorySystem, RepositorySystemSession session,
RemoteRepository remoteRepository)
throws IOException, XmlPullParserException, InstallationException, DeploymentException {
// If the current directory contained any poms,
// process them as artifacts.
final File[] poms = curDir.listFiles(new PomFilter());
if (poms != null) {
for (File pom : poms) {
processArtifact(pom, repositorySystem, session, remoteRepository);
}
}
// If the current directory contained any directories,
// continue processing their content.
final File[] dirs = curDir.listFiles(new DirFilter());
if (dirs != null) {
for (File dir : dirs) {
processDir(dir, repositorySystem, session, remoteRepository);
}
}
}
private void processArtifact(File pomFile, RepositorySystem repositorySystem, RepositorySystemSession session,
RemoteRepository remoteRepository)
throws IOException, XmlPullParserException, InstallationException, DeploymentException {
final Reader reader = new FileReader(pomFile);
try {
final File artifactDirectory = pomFile.getParentFile();
final MavenXpp3Reader xpp3Reader = new MavenXpp3Reader();
final Model model = xpp3Reader.read(reader);
// Make the deployer deploy the pom itself.
final DeployRequest artifactInstallRequest = new DeployRequest();
artifactInstallRequest.setRepository(remoteRepository);
Artifact pomArtifact = new DefaultArtifact(
model.getGroupId(), model.getArtifactId(), "pom", model.getVersion());
pomArtifact = pomArtifact.setFile(pomFile);
artifactInstallRequest.addArtifact(pomArtifact);
// Add any additional files to this installation.
final String artifactBaseName = model.getArtifactId() + "-" + model.getVersion();
final File artifactFiles[] = artifactDirectory.listFiles(new ArtifactFilter());
for (final File artifactFile : artifactFiles) {
final String fileName = artifactFile.getName();
final String classifier;
// This file has a classifier.
if (fileName.charAt(artifactBaseName.length()) == '-') {
classifier = fileName.substring(artifactBaseName.length() + 1,
fileName.indexOf(".", artifactBaseName.length()));
}
// This file doesn't have a classifier.
else {
classifier = "";
}
final String extension = fileName.substring(
artifactBaseName.length() + 1 + ((classifier.length() > 0) ? classifier.length() + 1 : 0));
Artifact fileArtifact = new DefaultArtifact(model.getGroupId(), model.getArtifactId(),
classifier, extension, model.getVersion());
fileArtifact = fileArtifact.setFile(artifactFile);
artifactInstallRequest.addArtifact(fileArtifact);
}
// Actually install the artifact.
System.out.println("Installing Artifact: " + pomArtifact.getGroupId() + ":" +
pomArtifact.getArtifactId() + ":" + pomArtifact.getVersion());
for (final Artifact artifact : artifactInstallRequest.getArtifacts()) {
System.out.println(" - File with extension " + artifact.getExtension() +
((artifact.getClassifier().length() > 0) ? " and classifier " + artifact.getClassifier() : ""));
}
repositorySystem.deploy(session, artifactInstallRequest);
} finally {
reader.close();
}
}
private class PomFilter implements java.io.FileFilter {
@Override
public boolean accept(File pathname) {
return pathname.getName().endsWith(".pom");
}
}
private class DirFilter implements java.io.FileFilter {
@Override
public boolean accept(File pathname) {
return pathname.isDirectory();
}
}
private class ArtifactFilter implements java.io.FileFilter {
@Override
public boolean accept(File pathname) {
return !pathname.getName().endsWith(".pom") && !pathname.isDirectory();
}
}
}