protected void setupRepositories() throws Exception {
resource = "test-resource";
// ----------------------------------------------------------------------
// Create the test repository for the wagon we are testing.
// ----------------------------------------------------------------------
testRepository = new Repository();
testRepository.setUrl(getTestRepositoryUrl());
testRepository.setPermissions(getPermissions());
// ----------------------------------------------------------------------
// Create a test local repository.
// ----------------------------------------------------------------------
localRepositoryPath = FileTestUtils.createDir("local-repository").getPath();
localRepository = createFileRepository("file://" + localRepositoryPath);
message("Local repository: " + localRepository);
File f = new File(localRepositoryPath);
if (!f.exists()) {
f.mkdirs();
}
}
protected Repository createFileRepository(String url) {
File path = new File(url.substring(7));
path.mkdirs();
Repository repository = new Repository();
repository.setUrl(url);
return repository;
}
/**
* @return the wagon (already connected) to use against the profile's serverDeployLocation or null
* if in development profile
* @throws org.apache.maven.plugin.MojoExecutionException
*/
private Wagon getWagon() throws MojoExecutionException {
loadProfile();
try {
Wagon wagon = null;
if (null != profile) {
final String serverDeployLocation =
System.getProperty(
SERVER_DEPLOY_LOCATION,
project.getProperties().getProperty("serverDeployLocation"));
final String protocol =
serverDeployLocation.substring(0, serverDeployLocation.indexOf(':'));
final Repository wagonRepository = new Repository();
wagonRepository.setUrl(serverDeployLocation);
final RepositoryPermissions permissions = new RepositoryPermissions();
permissions.setFileMode("g+w");
wagonRepository.setPermissions(permissions);
wagon = (Wagon) container.lookup(Wagon.ROLE, protocol);
wagon.connect(wagonRepository);
}
return wagon;
} catch (ConnectionException ex) {
getLog().error(ex);
throw new MojoExecutionException("repository wagon not connected", ex);
} catch (AuthenticationException ex) {
getLog().error(ex);
throw new MojoExecutionException("repository wagon not authenticated", ex);
} catch (ComponentLookupException ex) {
getLog().error(ex);
throw new MojoExecutionException("repository wagon not found", ex);
}
}
public String getURL(Repository repository) {
String url = repository.getUrl();
// Process mappings first.
for (String[] entry : protocolMap) {
String protocol = entry[0];
if (url.startsWith(protocol)) {
return entry[1] + url.substring(protocol.length());
}
}
// No mapping trigger? then just return as-is.
return url;
}
/**
* Create directories in server as needed. They are created one at a time until the whole path
* exists.
*
* @param dir path to be created in server from repository basedir
* @throws IOException
* @throws HttpException
* @throws TransferFailedException
*/
protected void mkdirs(String dir) throws IOException {
Repository repository = getRepository();
String basedir = repository.getBasedir();
String baseUrl = repository.getProtocol() + "://" + repository.getHost();
if (repository.getPort() != WagonConstants.UNKNOWN_PORT) {
baseUrl += ":" + repository.getPort();
}
// create relative path that will always have a leading and trailing slash
String relpath = FileUtils.normalize(getPath(basedir, dir) + "/");
PathNavigator navigator = new PathNavigator(relpath);
// traverse backwards until we hit a directory that already exists (OK/NOT_ALLOWED), or that we
// were able to
// create (CREATED), or until we get to the top of the path
int status = SC_NULL;
do {
String url = baseUrl + "/" + navigator.getPath();
status = doMkCol(url);
if (status == HttpStatus.SC_OK
|| status == HttpStatus.SC_CREATED
|| status == HttpStatus.SC_METHOD_NOT_ALLOWED) {
break;
}
} while (navigator.backward());
// traverse forward creating missing directories
while (navigator.forward()) {
String url = baseUrl + "/" + navigator.getPath();
status = doMkCol(url);
if (status != HttpStatus.SC_OK && status != HttpStatus.SC_CREATED) {
throw new IOException("Unable to create collection: " + url + "; status code = " + status);
}
}
}
public void copy(Repository sourceRepository, Repository targetRepository, String version)
throws WagonException, IOException {
String prefix = "staging-plugin";
String fileName = prefix + "-" + version + ".zip";
String tempdir = System.getProperty("java.io.tmpdir");
logger.debug("Writing all output to " + tempdir);
// Create the renameScript script
String renameScriptName = prefix + "-" + version + "-rename.sh";
File renameScript = new File(tempdir, renameScriptName);
// Work directory
File basedir = new File(tempdir, prefix + "-" + version);
FileUtils.deleteDirectory(basedir);
basedir.mkdirs();
Wagon sourceWagon = wagonManager.getWagon(sourceRepository);
AuthenticationInfo sourceAuth = wagonManager.getAuthenticationInfo(sourceRepository.getId());
sourceWagon.connect(sourceRepository, sourceAuth);
logger.info("Looking for files in the source repository.");
List<String> files = new ArrayList<String>();
scan(sourceWagon, "", files);
logger.info("Downloading files from the source repository to: " + basedir);
for (String s : files) {
if (s.contains(".svn")) {
continue;
}
File f = new File(basedir, s);
FileUtils.mkdir(f.getParentFile().getAbsolutePath());
logger.info("Downloading file from the source repository: " + s);
sourceWagon.get(s, f);
}
// ----------------------------------------------------------------------------
// Now all the files are present locally and now we are going to grab the
// metadata files from the targetRepositoryUrl and pull those down locally
// so that we can merge the metadata.
// ----------------------------------------------------------------------------
logger.info("Downloading metadata from the target repository.");
Wagon targetWagon = wagonManager.getWagon(targetRepository);
if (!(targetWagon instanceof CommandExecutor)) {
throw new CommandExecutionException(
"Wagon class '"
+ targetWagon.getClass().getName()
+ "' in use for target repository is not a CommandExecutor");
}
AuthenticationInfo targetAuth = wagonManager.getAuthenticationInfo(targetRepository.getId());
targetWagon.connect(targetRepository, targetAuth);
PrintWriter rw = new PrintWriter(new FileWriter(renameScript));
File archive = new File(tempdir, fileName);
for (String s : files) {
if (s.startsWith("/")) {
s = s.substring(1);
}
if (s.endsWith(MAVEN_METADATA)) {
File emf = new File(basedir, s + IN_PROCESS_MARKER);
try {
targetWagon.get(s, emf);
} catch (ResourceDoesNotExistException e) {
// We don't have an equivalent on the targetRepositoryUrl side because we have something
// new on the sourceRepositoryUrl side so just skip the metadata merging.
continue;
}
try {
mergeMetadata(emf);
} catch (XmlPullParserException e) {
throw new IOException("Metadata file is corrupt " + s + " Reason: " + e.getMessage());
}
}
}
Set moveCommands = new TreeSet();
// ----------------------------------------------------------------------------
// Create the Zip file that we will deploy to the targetRepositoryUrl stage
// ----------------------------------------------------------------------------
logger.info("Creating zip file.");
OutputStream os = new FileOutputStream(archive);
ZipOutputStream zos = new ZipOutputStream(os);
scanDirectory(basedir, basedir, zos, version, moveCommands);
// ----------------------------------------------------------------------------
// Create the renameScript script. This is as atomic as we can
// ----------------------------------------------------------------------------
logger.info("Creating rename script.");
for (Object moveCommand : moveCommands) {
String s = (String) moveCommand;
// We use an explicit unix '\n' line-ending here instead of using the println() method.
// Using println() will cause files and folders to have a '\r' at the end if the plugin is run
// on Windows.
rw.print(s + "\n");
}
IOUtil.close(rw);
ZipEntry e = new ZipEntry(renameScript.getName());
zos.putNextEntry(e);
InputStream is = new FileInputStream(renameScript);
IOUtil.copy(is, zos);
IOUtil.close(is);
IOUtil.close(zos);
sourceWagon.disconnect();
// Push the Zip to the target system
logger.info("Uploading zip file to the target repository.");
targetWagon.put(archive, fileName);
logger.info("Unpacking zip file on the target machine.");
String targetRepoBaseDirectory = targetRepository.getBasedir();
// We use the super quiet option here as all the noise seems to kill/stall the connection
String command =
"unzip -o -qq -d "
+ targetRepoBaseDirectory
+ " "
+ targetRepoBaseDirectory
+ "/"
+ fileName;
((CommandExecutor) targetWagon).executeCommand(command);
logger.info("Deleting zip file from the target repository.");
command = "rm -f " + targetRepoBaseDirectory + "/" + fileName;
((CommandExecutor) targetWagon).executeCommand(command);
logger.info("Running rename script on the target machine.");
command = "cd " + targetRepoBaseDirectory + "; sh " + renameScriptName;
((CommandExecutor) targetWagon).executeCommand(command);
logger.info("Deleting rename script from the target repository.");
command = "rm -f " + targetRepoBaseDirectory + "/" + renameScriptName;
((CommandExecutor) targetWagon).executeCommand(command);
targetWagon.disconnect();
}