/**
   * Handles a next log entry producing corresponding xml.
   *
   * @param logEntry log entry
   * @throws SVNException
   */
  public void handleLogEntry(SVNLogEntry logEntry) throws SVNException {

    if (logEntry.getChangedPaths() != null && relativePath != null) {
      // convert external path reference to local relative path
      Map<String, SVNLogEntryPath> changedPaths = new HashMap<String, SVNLogEntryPath>();
      for (SVNLogEntryPath entry : logEntry.getChangedPaths().values()) {
        String localPath = entry.getPath().substring(1); // path in svn log start with a '/'
        if (localPath.startsWith(relativeUrl)) {
          localPath = relativePath + localPath.substring(relativeUrl.length());
        }
        // can't use entry.setPath(localPath) as FSPathChange duplicate myPath attribute then
        // setPath().getPath() don't return same value
        changedPaths.put(
            localPath,
            new SVNLogEntryPath(
                localPath, entry.getType(), entry.getCopyPath(), entry.getCopyRevision()));
      }
      logEntry.getChangedPaths().clear();
      logEntry.getChangedPaths().putAll(changedPaths);
    }

    try {
      if (filter == null || !filter.hasExclusionRule() || filter.isIncluded(logEntry)) {
        sendToHandler(logEntry);
      }
    } catch (SAXException e) {
      SVNErrorMessage err =
          SVNErrorMessage.create(SVNErrorCode.XML_MALFORMED, e.getLocalizedMessage());
      SVNErrorManager.error(err, e, SVNLogType.DEFAULT);
    }
  }
 protected SvnFileRevision createRevision(final SVNLogEntry logEntry, final String copyPath)
     throws SVNException {
   Date date = logEntry.getDate();
   String author = logEntry.getAuthor();
   String message = logEntry.getMessage();
   SVNRevision rev = SVNRevision.create(logEntry.getRevision());
   final SVNURL url = myRepositoryRoot.appendPath(myLastPath, true);
   return new SvnFileRevision(
       myVcs, myPegRevision, rev, url.toString(), author, date, message, copyPath, myCharset);
 }
Esempio n. 3
0
  /**
   * Method setLog
   *
   * @param history
   */
  public void setLog(List<SVNLogEntry> history) {
    data.clear();

    minRevision = Long.MAX_VALUE;
    maxRevision = Long.MIN_VALUE;

    for (SVNLogEntry entry : history) {
      minRevision = Math.min(minRevision, entry.getRevision());
      maxRevision = Math.max(maxRevision, entry.getRevision());

      data.add(entry);
    }

    tableModel.fireTableDataChanged();
  }
 @SuppressWarnings("unchecked")
 private List<ChangeInfo> logEntryToChangeInfos(
     final String rootPath,
     final String loggedPath,
     final SVNLogEntry entry,
     final boolean pathOnly) {
   final String fullLoggedPathFromAppend = SVNPathUtil.append(rootPath, loggedPath);
   final String fullLoggedPath =
       (!fullLoggedPathFromAppend.startsWith("/"))
           ? "/" + fullLoggedPathFromAppend
           : fullLoggedPathFromAppend;
   final List<ChangeInfo> results = new LinkedList<ChangeInfo>();
   for (String changedPath : (Iterable<String>) entry.getChangedPaths().keySet()) {
     if (SVNPathUtil.isAncestor(rootPath, changedPath)
         && (!pathOnly || fullLoggedPath.equals(changedPath))) {
       ChangeInfo change = classifiedChange(entry, rootPath, changedPath);
       // Might want to put this at a higher level if we can ever do
       // something useful with 'other' changes.
       if (change.getKind() != StoreKind.OTHER) {
         results.add(change);
       }
     }
   }
   return results;
 }
Esempio n. 5
0
 public void testGetAndAdd() throws Exception {
   final ObjectCache cache = createMemoryCache();
   final RevisionCacheImpl revisionCache = new RevisionCacheImpl(cache);
   try {
     assertNull(revisionCache.get(123));
     revisionCache.add(TestUtils.getLogEntryStub());
     final SVNLogEntry result = revisionCache.get(123);
     assertNotNull(result);
     assertEquals(123, result.getRevision());
     assertEquals("TestAuthor", result.getAuthor());
     assertNotNull(result.getDate());
     assertEquals("TestMessage", result.getMessage());
   } finally {
     cache.shutdown();
   }
 }
    public void consume(Pair<SVNLogEntry, Integer> svnLogEntryIntegerPair) throws SVNException {
      final SVNLogEntry logEntry = svnLogEntryIntegerPair.getFirst();
      final Integer mergeLevel = svnLogEntryIntegerPair.getSecond();

      if (mergeLevel < 0) {
        if (myCurrentHierarchy != null) {
          myConsumer.consume(myCurrentHierarchy);
        }
        if (logEntry.hasChildren()) {
          myCurrentHierarchy = new TreeStructureNode<SVNLogEntry>(logEntry);
        } else {
          // just pass
          myCurrentHierarchy = null;
          myConsumer.consume(new TreeStructureNode<SVNLogEntry>(logEntry));
        }
      } else {
        addToLevel(myCurrentHierarchy, logEntry, mergeLevel);
      }
    }
Esempio n. 7
0
  /**
   * 获取svn日志
   *
   * @param repository repos对象
   * @param path svn目录(相对与repos根目录)
   * @param datumRevision 基准版本
   * @param expectRevision 目标版本
   * @return 日志记录集合
   * @throws Exception
   */
  private static Collection<SVNLog> getLog(
      SVNRepository repository, String path, long datumRevision, long expectRevision)
      throws Exception {
    Collection<SVNLogEntry> coll = new LinkedList<SVNLogEntry>();
    repository.log(new String[] {path}, coll, datumRevision + 1, expectRevision, true, true);
    Map<String, SVNLog> logMap = new HashMap<String, SVNLog>();
    for (SVNLogEntry e : coll) {
      Map<String, SVNLogEntryPath> map = e.getChangedPaths();
      if (map != null) {
        for (SVNLogEntryPath p : map.values()) {
          String sPath = p.getPath();
          if (sPath.startsWith(path)) {
            sPath = sPath.substring(path.length());
          }
          // 操作类型
          String opt = null;

          if (p.getType() == SVNLogEntryPath.TYPE_DELETED) {
            opt = "-";
          }

          if (p.getType() == SVNLogEntryPath.TYPE_ADDED
              || p.getType() == SVNLogEntryPath.TYPE_MODIFIED
              || p.getType() == SVNLogEntryPath.TYPE_REPLACED) {
            opt = "+";
          }

          int entryKind = 0;

          if (p.getKind() == SVNNodeKind.DIR) {
            entryKind = SVNLog.ENTRY_DIR;
          }

          if (p.getKind() == SVNNodeKind.FILE) {
            entryKind = SVNLog.ENTRY_FILE;
          }

          logMap.put(sPath, new SVNLog(e.getRevision(), sPath, opt, entryKind));
        }
      }
    }
    return logMap.values();
  }
 static ChangeInfo classifiedChange(final SVNLogEntry entry, String rootPath, final String path) {
   StoreKind kind = StoreKind.OTHER;
   // Be sure the root path ends with a slash because the 'path' will always have the slash.
   if (!rootPath.endsWith("/")) {
     rootPath = rootPath + "/";
   }
   String name = path.length() > rootPath.length() ? path.substring(rootPath.length()) : path;
   String page = null;
   Matcher matcher = PAGE_PATH.matcher(name);
   if (matcher.matches() && !name.endsWith("-attachments")) {
     kind = StoreKind.PAGE;
     page = name;
   } else {
     matcher = ATTACHMENT_PATH.matcher(name);
     if (matcher.matches()) {
       kind = StoreKind.ATTACHMENT;
       page = matcher.group(1);
       name = matcher.group(2);
     }
   }
   String user = entry.getAuthor();
   Date date = entry.getDate();
   SVNLogEntryPath logForPath = (SVNLogEntryPath) entry.getChangedPaths().get(path);
   String copiedFrom = logForPath.getCopyPath();
   long copiedFromRevision = -1;
   if (SVNPathUtil.isAncestor(rootPath, copiedFrom)) {
     copiedFrom = SVNPathUtil.tail(copiedFrom);
     copiedFromRevision = logForPath.getCopyRevision();
   } else {
     copiedFrom = null;
   }
   return new ChangeInfo(
       page,
       name,
       user,
       date,
       entry.getRevision(),
       entry.getMessage(),
       kind,
       ChangeType.forCode(logForPath.getType()),
       copiedFrom,
       copiedFromRevision);
 }
Esempio n. 9
0
  /**
   * @param logEntry Log entry
   * @param repositoryName Name
   * @param mailTemplate Template
   * @return Message
   * @throws MessagingException If a message exception occurs.
   * @throws IOException if a IO exception occurs while creating the data source.
   */
  private Message createMessage(
      final SVNLogEntry logEntry, RepositoryName repositoryName, String mailTemplate)
      throws MessagingException, IOException {
    final Message msg = new MimeMessage(session);
    msg.setFrom(new InternetAddress(from));
    msg.setRecipients(
        Message.RecipientType.BCC, receivers.toArray(new InternetAddress[receivers.size()]));
    msg.setSubject(formatSubject(subject, logEntry.getRevision(), repositoryName));

    msg.setDataHandler(
        new DataHandler(
            new ByteArrayDataSource(
                HTMLCreator.createRevisionDetailBody(
                    mailTemplate, logEntry, baseUrl, repositoryName, dateFormat, null),
                "text/html")));

    msg.setHeader("X-Mailer", "sventon");
    msg.setSentDate(new Date());
    return msg;
  }
    public void accept(final SVNLogEntry entry) {
      final Map changedPaths = entry.getChangedPaths();
      if (changedPaths == null) return;

      for (Object o : changedPaths.values()) {
        final SVNLogEntryPath entryPath = (SVNLogEntryPath) o;
        if (entryPath != null && 'A' == entryPath.getType() && entryPath.getCopyPath() != null) {
          if (myCurrentPath.equals(entryPath.getPath())) {
            myHadChanged = true;
            myCurrentPath = entryPath.getCopyPath();
            return;
          } else if (SVNPathUtil.isAncestor(entryPath.getPath(), myCurrentPath)) {
            final String relativePath =
                SVNPathUtil.getRelativePath(entryPath.getPath(), myCurrentPath);
            myCurrentPath = SVNPathUtil.append(entryPath.getCopyPath(), relativePath);
            myHadChanged = true;
            return;
          }
        }
      }
    }
  public void getCommits(SVNLogEntry svnlogEntry) {
    this.type = "SVN";
    this.date = Calendar.getInstance();
    if (svnlogEntry.getDate() != null) this.date.setTime(svnlogEntry.getDate());
    this.author = svnlogEntry.getAuthor();
    this.message = svnlogEntry.getMessage();
    if (this.message != null) this.message = this.message.replace(",", ".").replace("\n", "|");
    this.revision = svnlogEntry.getRevision();

    Map myChangedPaths = svnlogEntry.getChangedPaths();

    if (myChangedPaths != null && !myChangedPaths.isEmpty()) {
      for (Iterator paths = myChangedPaths.values().iterator(); paths.hasNext(); ) {
        SVNLogEntryPath path = (SVNLogEntryPath) paths.next();
        getDiff(this.revision, path.getPath(), path.getType(), 0);
      }
    }
    System.out.println("");
  }
  @Override
  public void handleLogEntry(SVNLogEntry logEntry) throws SVNException {
    Map<String, SVNLogEntryPath> map = logEntry.getChangedPaths();

    if (map != null && map.size() > 0) {
      getDBUtil()
          .insertIntoRevision(
              logEntry.getRevision(),
              logEntry.getAuthor(),
              sdfdb.format(logEntry.getDate()),
              logEntry.getMessage());
      for (String key : map.keySet()) {
        SVNLogEntryPath entry = map.get(key);
        if (isNeedStore(key)) {
          getDBUtil()
              .insertIntoFileInfo(
                  entry.getPath(),
                  logEntry.getRevision(),
                  getType(entry.getType()),
                  entry.getCopyPath());
        }
      }
    }
  }
  // unfortunately, the original method is private, so we need to copy / paste it
  // copied from SVNXMLLogHandler
  //
  protected void sendToHandler(SVNLogEntry logEntry) throws SAXException {
    if (logEntry.getRevision() == 0 && logEntry.getMessage() == null) {
      return;
    }
    addAttribute(REVISION_ATTR, logEntry.getRevision() + "");
    openTag(LOGENTRY_TAG);
    if (logEntry.getAuthor() != null) {
      addTag(AUTHOR_TAG, logEntry.getAuthor());
    }
    if (logEntry.getDate() != null && logEntry.getDate().getTime() != 0) {
      addTag(DATE_TAG, SVNDate.formatDate(logEntry.getDate()));
    }
    if (logEntry.getChangedPaths() != null && !logEntry.getChangedPaths().isEmpty()) {
      openTag(PATHS_TAG);
      for (Iterator<String> paths = logEntry.getChangedPaths().keySet().iterator();
          paths.hasNext(); ) {
        String key = paths.next();
        SVNLogEntryPath path = (SVNLogEntryPath) logEntry.getChangedPaths().get(key);
        addAttribute(ACTION_ATTR, path.getType() + "");
        if (path.getCopyPath() != null) {
          addAttribute(COPYFROM_PATH_ATTR, path.getCopyPath());
          addAttribute(COPYFROM_REV_ATTR, path.getCopyRevision() + "");
        }
        if (path.getKind() != null) {
          addAttribute(KIND_ATTR, path.getKind().toString());
        }
        addTag(PATH_TAG, path.getPath());
      }
      closeTag(PATHS_TAG);
    }

    if (!myIsOmitLogMessage) {
      String message = logEntry.getMessage();
      message = message == null ? "" : message;
      addTag(MSG_TAG, message);
    }

    if (myMergeStack != null && !myMergeStack.isEmpty()) {
      MergeFrame frame = (MergeFrame) myMergeStack.getLast();
      frame.myNumberOfChildrenRemaining--;
    }

    if (logEntry.hasChildren()) {
      MergeFrame frame = new MergeFrame();
      if (myMergeStack == null) {
        myMergeStack = new LinkedList<MergeFrame>();
      }
      myMergeStack.addLast(frame);
    } else {
      while (myMergeStack != null && !myMergeStack.isEmpty()) {
        MergeFrame frame = (MergeFrame) myMergeStack.getLast();
        if (frame.myNumberOfChildrenRemaining == 0) {
          closeTag(LOGENTRY_TAG);
          myMergeStack.removeLast();
        } else {
          break;
        }
      }
      closeTag(LOGENTRY_TAG);
    }
  }
Esempio n. 14
0
  public ArrayList<SVNCommit> getAllRevisions() {
    if (latestRevision < 1l) return revisions;
    try {
      final Collection<SVNLogEntry> logEntries =
          repository.log(
              new String[] {""}, null, lastSeenRevision + 1l, latestRevision, true, true);

      for (final SVNLogEntry logEntry : logEntries) {
        final SVNCommit revision = new SVNCommit(repository, this, logEntry);

        revision.setId("" + logEntry.getRevision());
        if (logEntry.getAuthor() == null) revision.setCommitter(logEntry.getAuthor());
        else revision.setCommitter("anonymous");
        revision.setDate(logEntry.getDate());
        revision.setMessage(logEntry.getMessage());

        if (logEntry.getChangedPaths() != null && logEntry.getChangedPaths().size() > 0) {
          final HashMap<String, String> rChangedPaths = new HashMap<String, String>();
          final HashMap<String, String> rRemovedPaths = new HashMap<String, String>();
          final HashMap<String, String> rAddedPaths = new HashMap<String, String>();
          for (final Iterator changedPaths = logEntry.getChangedPaths().keySet().iterator();
              changedPaths.hasNext(); ) {
            final SVNLogEntryPath entryPath =
                (SVNLogEntryPath) logEntry.getChangedPaths().get(changedPaths.next());
            if (repository.checkPath(entryPath.getPath(), logEntry.getRevision())
                == SVNNodeKind.FILE) {
              if (entryPath.getType() == SVNLogEntryPath.TYPE_DELETED)
                rRemovedPaths.put(entryPath.getPath(), entryPath.getCopyPath());
              else if (entryPath.getType() == SVNLogEntryPath.TYPE_ADDED)
                rAddedPaths.put(entryPath.getPath(), entryPath.getCopyPath());
              else rChangedPaths.put(entryPath.getPath(), entryPath.getCopyPath());
            }
          }
          revision.setChangedPaths(rChangedPaths);
          revision.setRemovedPaths(rRemovedPaths);
          revision.setAddedPaths(rAddedPaths);
        }

        this.revisions.add(revision);
      }
    } catch (final SVNException e) {
      e.printStackTrace();
    }
    return revisions;
  }
  @Override
  protected String getChangeFileNames(String lastFinishDateTimeString) throws Exception {
    /*
     * Default values:
     */
    String url = Globals.getProperty("svn.url");
    String name = Globals.getProperty("svn.user");
    String password = Globals.getProperty("svn.password");

    long startRevision = 0;
    long endRevision = -1; // HEAD (the latest) revision

    setupLibrary();

    SVNRepository repository = null;

    try {
      repository = SVNRepositoryFactory.create(SVNURL.parseURIEncoded(url));
    } catch (SVNException svne) {
      /*
       * Perhaps a malformed URL is the cause of this exception.
       */
      System.err.println(
          "error while creating an SVNRepository for the location '"
              + url
              + "': "
              + svne.getMessage());
      System.exit(1);
    }

    ISVNAuthenticationManager authManager =
        SVNWCUtil.createDefaultAuthenticationManager(name, password);
    repository.setAuthenticationManager(authManager);

    /*
     * Gets the latest revision number of the repository
     */
    try {
      endRevision = repository.getLatestRevision();
      startRevision = endRevision;
    } catch (SVNException svne) {
      System.err.println(
          "error while fetching the latest repository revision: " + svne.getMessage());
      System.exit(1);
    }

    Collection logEntries = null;
    try {
      /*
       * Collects SVNLogEntry objects for all revisions in the range
       * defined by its start and end points [startRevision, endRevision].
       * For each revision commit information is represented by
       * SVNLogEntry.
       *
       * the 1st parameter (targetPaths - an array of path strings) is set
       * when restricting the [startRevision, endRevision] range to only
       * those revisions when the paths in targetPaths were changed.
       *
       * the 2nd parameter if non-null - is a user's Collection that will
       * be filled up with found SVNLogEntry objects; it's just another
       * way to reach the scope.
       *
       * startRevision, endRevision - to define a range of revisions you are
       * interested in; by default in this program - startRevision=0, endRevision=
       * the latest (HEAD) revision of the repository.
       *
       * the 5th parameter - a boolean flag changedPath - if true then for
       * each revision a corresponding SVNLogEntry will contain a map of
       * all paths which were changed in that revision.
       *
       * the 6th parameter - a boolean flag strictNode - if false and a
       * changed path is a copy (branch) of an existing one in the repository
       * then the history for its origin will be traversed; it means the
       * history of changes of the target URL (and all that there's in that
       * URL) will include the history of the origin path(s).
       * Otherwise if strictNode is true then the origin path history won't be
       * included.
       *
       * The return value is a Collection filled up with SVNLogEntry Objects.
       */
      logEntries = repository.log(new String[] {""}, null, startRevision, endRevision, true, true);

    } catch (SVNException svne) {
      System.out.println(
          "error while collecting log information for '" + url + "': " + svne.getMessage());
      System.exit(1);
    }
    for (Iterator entries = logEntries.iterator(); entries.hasNext(); ) {
      /*
       * gets a next SVNLogEntry
       */
      SVNLogEntry logEntry = (SVNLogEntry) entries.next();
      System.out.println("---------------------------------------------");
      /*
       * gets the revision number
       */
      System.out.println("revision: " + logEntry.getRevision());
      /*
       * gets the author of the changes made in that revision
       */
      System.out.println("author: " + logEntry.getAuthor());
      /*
       * gets the time moment when the changes were committed
       */
      System.out.println("date: " + logEntry.getDate());
      /*
       * gets the commit log message
       */
      System.out.println("log message: " + logEntry.getMessage());
      /*
       * displaying all paths that were changed in that revision; cahnged
       * path information is represented by SVNLogEntryPath.
       */
      if (logEntry.getChangedPaths().size() > 0) {
        System.out.println();
        System.out.println("changed paths:");
        /*
         * keys are changed paths
         */
        Set changedPathsSet = logEntry.getChangedPaths().keySet();

        for (Iterator changedPaths = changedPathsSet.iterator(); changedPaths.hasNext(); ) {
          /*
           * obtains a next SVNLogEntryPath
           */
          SVNLogEntryPath entryPath =
              (SVNLogEntryPath) logEntry.getChangedPaths().get(changedPaths.next());
          /*
           * SVNLogEntryPath.getPath returns the changed path itself;
           *
           * SVNLogEntryPath.getType returns a charecter describing
           * how the path was changed ('A' - added, 'D' - deleted or
           * 'M' - modified);
           *
           * If the path was copied from another one (branched) then
           * SVNLogEntryPath.getCopyPath &
           * SVNLogEntryPath.getCopyRevision tells where it was copied
           * from and what revision the origin path was at.
           */
          System.out.println(
              " "
                  + entryPath.getType()
                  + "	"
                  + entryPath.getPath()
                  + ((entryPath.getCopyPath() != null)
                      ? " (from "
                          + entryPath.getCopyPath()
                          + " revision "
                          + entryPath.getCopyRevision()
                          + ")"
                      : ""));
        }
      }
    }
    return "";
  }