private void updateVersionFile(final Wagon wagon)
      throws IOException, TransferFailedException, ResourceDoesNotExistException,
          AuthorizationException {

    // update the version.txt accordingly
    final File versionOldFile = File.createTempFile("version-old", "txt");
    final File versionNewFile = File.createTempFile("version-new", "txt");
    wagon.get("version.txt", versionOldFile);

    boolean updated = false;

    // look for our artifactId entry
    final BufferedReader reader = new BufferedReader(new FileReader(versionOldFile));
    final BufferedWriter writer = new BufferedWriter(new FileWriter(versionNewFile));
    for (String line = reader.readLine(); null != line; line = reader.readLine()) {
      if (line.equals(project.getArtifactId())) {
        updateArtifactEntry(reader, writer);
        updated = true;
      } else {
        // line remains the same
        writer.write(line);
        writer.newLine();
      }
    }
    if (!updated) {
      writer.newLine();
      updateArtifactEntry(reader, writer);
    }
    reader.close();
    writer.close();
    wagon.put(versionNewFile, "version.txt");
  }
  private void executeServerDeploy(final Wagon wagon) throws MojoExecutionException {

    // alpha|nuclei|beta|electron|gamma|production deployment goes through scpexe
    try {
      if (ensureNoLocalModifications()) {

        @SuppressWarnings("unchecked")
        final List<ArtifactItem> theArtifactItems = getProcessedArtifactItems(stripVersion);

        for (ArtifactItem item : theArtifactItems) {

          final Artifact artifact =
              factory.createArtifactWithClassifier(
                  item.getGroupId(),
                  item.getArtifactId(),
                  item.getVersion(),
                  item.getType(),
                  profile);

          resolver.resolve(artifact, getRemoteRepos(), getLocal());

          final String sesamSite = project.getProperties().getProperty("sesam.site");
          final String destName = null != sesamSite ? sesamSite : project.getBuild().getFinalName();

          // tag the code
          final boolean tagOnDeploy =
              Boolean.parseBoolean(
                  System.getProperty(
                      TAG_ON_DEPLOY, project.getProperties().getProperty("tag.on.deploy")));

          if (tagOnDeploy && !Boolean.getBoolean(DRY_RUN)) {
            tagDeploy();
          }

          // do the upload
          getLog()
              .info(
                  "Uploading "
                      + artifact.getFile().getAbsolutePath()
                      + " to "
                      + wagon.getRepository().getUrl()
                      + '/'
                      + destName
                      + ".war");

          if (!Boolean.getBoolean(DRY_RUN)) {
            wagon.put(artifact.getFile(), destName + ".war");
          }

          // update the version.txt
          getLog().info("Updating " + wagon.getRepository().getUrl() + "/version.txt");

          if (Boolean.getBoolean(DRY_RUN)) {

            final StringWriter sb = new StringWriter();
            final BufferedWriter w = new BufferedWriter(sb);
            updateArtifactEntry(new BufferedReader(new StringReader("")), w);
            w.flush();
            getLog().info("version.txt entry will be \n" + sb.toString());

          } else {

            updateVersionFile(wagon);
          }
        }
      }

    } catch (TransferFailedException ex) {
      getLog().error(ex);
      throw new MojoExecutionException("transfer failed", ex);
    } catch (ResourceDoesNotExistException ex) {
      getLog().error(ex);
      throw new MojoExecutionException("resource does not exist", ex);
    } catch (AuthorizationException ex) {
      getLog().error(ex);
      throw new MojoExecutionException("authorisation exception", ex);
    } catch (ArtifactNotFoundException ex) {
      getLog().error(ex);
      throw new MojoExecutionException("artifact not found", ex);
    } catch (ArtifactResolutionException ex) {
      getLog().error(ex);
      throw new MojoExecutionException("artifact resolution exception", ex);
    } catch (ScmException ex) {
      getLog().error(ex);
      throw new MojoExecutionException("scm exception", ex);
    } catch (ComponentLookupException ex) {
      getLog().error(ex);
      throw new MojoExecutionException("failed to lookup ScmManager", ex);
    } catch (IOException ex) {
      getLog().error(ex);
      throw new MojoExecutionException("IOException", ex);
    }
  }
  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();
  }