Exemplo n.º 1
0
  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();
    }
  }
Exemplo n.º 2
0
  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);
    }
  }
Exemplo n.º 4
0
  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;
  }
Exemplo n.º 5
0
  /**
   * 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();
  }