Exemplo n.º 1
0
  public static Commandline createCommandLine(
      SvnScmProviderRepository repository,
      File workingDirectory,
      ScmVersion version,
      String url,
      String outputSirectory) {
    if (version != null && StringUtils.isEmpty(version.getName())) {
      version = null;
    }

    Commandline cl = SvnCommandLineUtils.getBaseSvnCommandLine(workingDirectory, repository);

    cl.createArg().setValue("export");

    if (version != null && StringUtils.isNotEmpty(version.getName())) {
      if (version instanceof ScmRevision) {
        cl.createArg().setValue("-r");

        cl.createArg().setValue(version.getName());
      }
    }

    // support exporting to an existing directory
    cl.createArg().setValue("--force");

    cl.createArg().setValue(url);

    if (StringUtils.isNotEmpty(outputSirectory)) {
      cl.createArg().setValue(outputSirectory);
    }

    return cl;
  }
Exemplo n.º 2
0
  /** {@inheritDoc} */
  protected ExportScmResult executeExportCommand(
      ScmProviderRepository repo, ScmFileSet fileSet, ScmVersion version, String outputDirectory)
      throws ScmException {

    if (outputDirectory == null) {
      outputDirectory = fileSet.getBasedir().getAbsolutePath();
    }

    SvnScmProviderRepository repository = (SvnScmProviderRepository) repo;

    String url = repository.getUrl();

    if (version != null && StringUtils.isNotEmpty(version.getName())) {
      if (version instanceof ScmTag) {
        url = SvnTagBranchUtils.resolveTagUrl(repository, (ScmTag) version);
      } else if (version instanceof ScmBranch) {
        url = SvnTagBranchUtils.resolveBranchUrl(repository, (ScmBranch) version);
      }
    }

    url = SvnCommandUtils.fixUrl(url, repository.getUser());

    Commandline cl =
        createCommandLine(
            (SvnScmProviderRepository) repo, fileSet.getBasedir(), version, url, outputDirectory);

    SvnUpdateConsumer consumer = new SvnUpdateConsumer(getLogger(), fileSet.getBasedir());

    CommandLineUtils.StringStreamConsumer stderr = new CommandLineUtils.StringStreamConsumer();

    if (getLogger().isInfoEnabled()) {
      getLogger().info("Executing: " + SvnCommandLineUtils.cryptPassword(cl));
      if (cl.getWorkingDirectory() != null) {
        getLogger().info("Working directory: " + cl.getWorkingDirectory().getAbsolutePath());
      }
    }

    int exitCode;

    try {
      exitCode = SvnCommandLineUtils.execute(cl, consumer, stderr, getLogger());
    } catch (CommandLineException ex) {
      throw new ScmException("Error while executing command.", ex);
    }

    if (exitCode != 0) {
      return new ExportScmResult(
          cl.toString(), "The svn command failed.", stderr.getOutput(), false);
    }

    return new ExportScmResultWithRevision(
        cl.toString(), consumer.getUpdatedFiles(), String.valueOf(consumer.getRevision()));
  }
  @Override
  protected ScmResult executeAccurevCommand(
      AccuRevScmProviderRepository repository, ScmFileSet fileSet, CommandParameters parameters)
      throws ScmException, AccuRevException {

    // Do we have a supplied branch. If not we default to the URL stream.
    ScmBranch branch = (ScmBranch) parameters.getScmVersion(CommandParameter.BRANCH, null);
    AccuRevVersion branchVersion = repository.getAccuRevVersion(branch);
    String stream = branchVersion.getBasisStream();
    String fromSpec = branchVersion.getTimeSpec();
    String toSpec = "highest";

    // Versions
    ScmVersion startVersion = parameters.getScmVersion(CommandParameter.START_SCM_VERSION, null);
    ScmVersion endVersion = parameters.getScmVersion(CommandParameter.END_SCM_VERSION, null);

    if (startVersion != null && StringUtils.isNotEmpty(startVersion.getName())) {
      AccuRevVersion fromVersion = repository.getAccuRevVersion(startVersion);
      // if no end version supplied then use same basis as startVersion
      AccuRevVersion toVersion =
          endVersion == null
              ? new AccuRevVersion(fromVersion.getBasisStream(), "now")
              : repository.getAccuRevVersion(endVersion);

      if (!StringUtils.equals(fromVersion.getBasisStream(), toVersion.getBasisStream())) {
        throw new AccuRevException(
            "Not able to provide change log between different streams "
                + fromVersion
                + ","
                + toVersion);
      }

      stream = fromVersion.getBasisStream();
      fromSpec = fromVersion.getTimeSpec();
      toSpec = toVersion.getTimeSpec();
    }

    Date startDate = parameters.getDate(CommandParameter.START_DATE, null);
    Date endDate = parameters.getDate(CommandParameter.END_DATE, null);
    int numDays = parameters.getInt(CommandParameter.NUM_DAYS, 0);

    if (numDays > 0) {
      if ((startDate != null || endDate != null)) {
        throw new ScmException("Start or end date cannot be set if num days is set.");
      }
      // Last x days.
      int day = 24 * 60 * 60 * 1000;
      startDate = new Date(System.currentTimeMillis() - (long) numDays * day);
      endDate = new Date(System.currentTimeMillis() + day);
    }

    if (endDate != null && startDate == null) {
      throw new ScmException("The end date is set but the start date isn't.");
    }

    // Date parameters override transaction ids in versions
    if (startDate != null) {
      fromSpec = AccuRevScmProviderRepository.formatTimeSpec(startDate);
    } else if (fromSpec == null) {
      fromSpec = "1";
    }

    // Convert the fromSpec to both a date AND a transaction id by looking up
    // the nearest transaction in the depot.
    Transaction fromTransaction = getDepotTransaction(repository, stream, fromSpec);

    long fromTranId = 1;
    if (fromTransaction != null) {
      // This tran id is less than or equal to the date/tranid we requested.
      fromTranId = fromTransaction.getTranId();
      if (startDate == null) {
        startDate = fromTransaction.getWhen();
      }
    }

    if (endDate != null) {
      toSpec = AccuRevScmProviderRepository.formatTimeSpec(endDate);
    } else if (toSpec == null) {
      toSpec = "highest";
    }

    Transaction toTransaction = getDepotTransaction(repository, stream, toSpec);
    long toTranId = 1;
    if (toTransaction != null) {
      toTranId = toTransaction.getTranId();
      if (endDate == null) {
        endDate = toTransaction.getWhen();
      }
    }
    startVersion = new ScmRevision(repository.getRevision(stream, fromTranId));
    endVersion = new ScmRevision(repository.getRevision(stream, toTranId));

    // TODO Split this method in two here. above to convert params to start and end
    // (stream,tranid,date) and test independantly

    List<Transaction> streamHistory = Collections.emptyList();
    List<Transaction> workspaceHistory = Collections.emptyList();
    List<FileDifference> streamDifferences = Collections.emptyList();

    StringBuilder errorMessage = new StringBuilder();

    AccuRev accurev = repository.getAccuRev();

    Stream changelogStream = accurev.showStream(stream);
    if (changelogStream == null) {
      errorMessage.append("Unknown accurev stream -").append(stream).append(".");
    } else {

      String message =
          "Changelog on stream "
              + stream
              + "("
              + changelogStream.getStreamType()
              + ") from "
              + fromTranId
              + " ("
              + startDate
              + "), to "
              + toTranId
              + " ("
              + endDate
              + ")";

      if (startDate != null && startDate.after(endDate) || fromTranId >= toTranId) {
        getLogger().warn("Skipping out of range " + message);
      } else {

        getLogger().info(message);

        // In 4.7.2 and higher we have a diff command that will list all the file differences in a
        // stream
        // and thus can be used to detect upstream changes
        // Unfortunately diff -v -V -t does not work in workspaces.
        Stream diffStream = changelogStream;
        if (changelogStream.isWorkspace()) {

          workspaceHistory =
              accurev.history(
                  stream, Long.toString(fromTranId + 1), Long.toString(toTranId), 0, false, false);

          if (workspaceHistory == null) {
            errorMessage.append(
                "history on workspace "
                    + stream
                    + " from "
                    + fromTranId
                    + 1
                    + " to "
                    + toTranId
                    + " failed.");
          }

          // do the diff/hist on the basis stream instead.
          stream = changelogStream.getBasis();
          diffStream = accurev.showStream(stream);
        }

        if (AccuRevCapability.DIFF_BETWEEN_STREAMS.isSupported(accurev.getClientVersion())) {
          if (startDate.before(diffStream.getStartDate())) {
            getLogger().warn("Skipping diff of " + stream + " due to start date out of range");
          } else {
            streamDifferences =
                accurev.diff(stream, Long.toString(fromTranId), Long.toString(toTranId));
            if (streamDifferences == null) {
              errorMessage.append(
                  "Diff " + stream + "- " + fromTranId + " to " + toTranId + "failed.");
            }
          }
        }

        // History needs to start from the transaction after our starting transaction

        streamHistory =
            accurev.history(
                stream, Long.toString(fromTranId + 1), Long.toString(toTranId), 0, false, false);
        if (streamHistory == null) {
          errorMessage.append(
              "history on stream "
                  + stream
                  + " from "
                  + fromTranId
                  + 1
                  + " to "
                  + toTranId
                  + " failed.");
        }
      }
    }

    String errorString = errorMessage.toString();
    if (StringUtils.isBlank(errorString)) {
      ChangeLogSet changeLog =
          getChangeLog(
              changelogStream,
              streamDifferences,
              streamHistory,
              workspaceHistory,
              startDate,
              endDate);

      changeLog.setEndVersion(endVersion);
      changeLog.setStartVersion(startVersion);

      return new ChangeLogScmResult(accurev.getCommandLines(), changeLog);
    } else {
      return new ChangeLogScmResult(
          accurev.getCommandLines(),
          "AccuRev errors: " + errorMessage,
          accurev.getErrorOutput(),
          false);
    }
  }