Esempio n. 1
0
  private void scan(ByteArrayInputStream in, String path, SVNDirEntry dirEntry) {
    try {
      Metadata metadata = new Metadata();
      metadata.set(Metadata.RESOURCE_NAME_KEY, path);

      // The following code part is from an proposal of the Authors of
      // Tika:
      // https://issues.apache.org/jira/browse/TIKA-232
      TikaConfig config = TikaConfig.getDefaultConfig(); // without a
      // delegate
      // parser
      Parser parser = new AutoDetectParser(config);
      DefaultHandler handler = new BodyContentHandler();
      parser.parse(in, handler, metadata);
      getDocument().addTokenizedField(FieldNames.CONTENTS, handler.toString());

    } catch (Exception e) {
      LOGGER.error("We had an exception " + path + " (r" + dirEntry.getRevision() + ")", e);
    } finally {
      try {
        in.close();
      } catch (Exception e) {
        LOGGER.error("We had an exception " + path + " (r" + dirEntry.getRevision() + ")", e);
      }
    }
  }
  public static void listEntries(SVNRepository repository, String basePath, LrdNode root)
      throws SVNException {

    LrdProject project = root.getPath().getProject();

    Collection entries = repository.getDir(basePath, -1, null, (Collection) null);
    Iterator iterator = entries.iterator();
    while (iterator.hasNext()) {
      SVNDirEntry entry = (SVNDirEntry) iterator.next();
      String path = ((basePath.length() == 0) ? "" : basePath + "/") + entry.getRelativePath();

      if (entry.getKind() == SVNNodeKind.DIR) {
        int index = path.lastIndexOf('/');
        LrdNode node;
        if (index <= 0) {
          // ルート直下
          node = new LrdNode(new LrdPath(project, path), true);
          if (path.charAt(0) == '.') {
            // ルート直下の"."で始まるフォルダは無効とする
            node.setEnable(false);
          }
          root.addSubNode(node);
        } else {
          String baseDir = path.substring(0, index);
          StringTokenizer tokenizer = new StringTokenizer(baseDir, "/");
          //                    LrdNode now = root;
          //                    while (tokenizer.hasMoreTokens()) {
          //                        String token = tokenizer.nextToken();
          //                        now = now.searchSubNode(token);
          //                    }
          node = new LrdNode(new LrdPath(project, path), true);
          root.addSubNode(node);
        }
        listEntries(
            repository,
            (basePath.equals("")) ? entry.getName() : basePath + "/" + entry.getName(),
            node);
      } else {
        //                int index = path.lastIndexOf('/');
        //                LrdNode now = root;
        //                if (index >= 0) {
        //                    String baseDir = path.substring(0, index);
        //                    StringTokenizer tokenizer = new StringTokenizer(baseDir, "/");
        //                    while (tokenizer.hasMoreTokens()) {
        //                        String token = tokenizer.nextToken();
        //                        now = now.searchSubNode(token);
        //                    }
        //                }

        LrdNode node = new LrdNode(new LrdPath(project, path), false);
        root.addSubNode(node);
      }
    }
  }
Esempio n. 3
0
  private ObjectNode getMetaDataFromPath(int revision, String path)
      throws SVNException, IOException {
    org.tmatesoft.svn.core.io.SVNRepository repository = getSVNRepository();

    SVNNodeKind nodeKind = repository.checkPath(path, revision);

    if (nodeKind == SVNNodeKind.DIR) {
      ObjectNode result = Json.newObject();
      ObjectNode listData = Json.newObject();
      SVNProperties prop = new SVNProperties();
      Collection<SVNDirEntry> entries =
          repository.getDir(path, -1, prop, SVNDirEntry.DIRENT_ALL, (Collection) null);

      result.put("type", "folder");

      for (SVNDirEntry entry : entries) {
        ObjectNode data = Json.newObject();
        String author = entry.getAuthor();
        User user = User.findByLoginId(author);
        Long commitTime = entry.getDate().getTime();

        data.put("type", entry.getKind() == SVNNodeKind.DIR ? "folder" : "file");
        data.put("msg", entry.getCommitMessage());
        data.put("author", author);
        data.put("avatar", getAvatar(user));
        data.put("userName", user.name);
        data.put("userLoginId", user.loginId);
        data.put("createdDate", commitTime);
        data.put("commitMessage", entry.getCommitMessage());
        data.put("commiter", author);
        data.put("commitDate", commitTime);
        data.put("commitId", entry.getRevision());
        data.put(
            "commitUrl",
            routes.CodeHistoryApp.show(ownerName, projectName, String.valueOf(entry.getRevision()))
                .url());
        data.put("size", entry.getSize());

        listData.put(entry.getName(), data);
      }
      result.put("data", listData);

      return result;
    } else if (nodeKind == SVNNodeKind.FILE) {
      return fileAsJson(path, repository);
    } else {
      return null;
    }
  }
Esempio n. 4
0
  private ObjectNode fileAsJson(String path, org.tmatesoft.svn.core.io.SVNRepository repository)
      throws SVNException, IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    SVNProperties prop = new SVNProperties();
    repository.getFile(path, -1l, prop, baos);
    SVNDirEntry entry = repository.info(path, -1l);
    long size = entry.getSize();
    boolean isBinary;
    String mimeType;
    String data = null;

    if (size > MAX_FILE_SIZE_CAN_BE_VIEWED) {
      isBinary = true;
      mimeType = "application/octet-stream";
    } else {
      byte[] bytes = baos.toByteArray();
      isBinary = RawText.isBinary(bytes);
      if (!isBinary) {
        data = new String(bytes, FileUtil.detectCharset(bytes));
      }
      mimeType = new Tika().detect(bytes, path);
    }

    String author = prop.getStringValue(SVNProperty.LAST_AUTHOR);
    User user = User.findByLoginId(author);

    String commitDate = prop.getStringValue(SVNProperty.COMMITTED_DATE);
    DateTimeFormatter dateFormatter = ISODateTimeFormat.dateTime();
    Long commitTime = dateFormatter.parseMillis(commitDate);

    ObjectNode result = Json.newObject();
    result.put("type", "file");
    result.put("revisionNo", prop.getStringValue(SVNProperty.COMMITTED_REVISION));
    result.put("author", author);
    result.put("avatar", getAvatar(user));
    result.put("userName", user.name);
    result.put("userLoginId", user.loginId);
    result.put("createdDate", commitTime);
    result.put("commitMessage", entry.getCommitMessage());
    result.put("commiter", author);
    result.put("size", size);
    result.put("isBinary", isBinary);
    result.put("mimeType", mimeType);
    result.put("data", data);

    return result;
  }
 /*
  * Called recursively to obtain all entries that make up the repository tree
  * repository - an SVNRepository which interface is used to carry out the
  * request, in this case it's a request to get all entries in the directory
  * located at the path parameter;
  *
  * path is a directory path relative to the repository location path (that
  * is a part of the URL used to create an SVNRepository instance);
  */
 public static void listEntries(SVNRepository repository, String path) throws SVNException {
   Tokenizer tokenizer = new Tokenizer();
   /*
    * Gets the contents of the directory specified by path at the latest
    * revision (for this purpose -1 is used here as the revision number to
    * mean HEAD-revision) getDir returns a Collection of SVNDirEntry
    * elements. SVNDirEntry represents information about the directory
    * entry. Here this information is used to get the entry name, the name
    * of the person who last changed this entry, the number of the revision
    * when it was last changed and the entry type to determine whether it's
    * a directory or a file. If it's a directory listEntries steps into a
    * next recursion to display the contents of this directory. The third
    * parameter of getDir is null and means that a user is not interested
    * in directory properties. The fourth one is null, too - the user
    * doesn't provide its own Collection instance and uses the one returned
    * by getDir.
    */
   Collection entries = repository.getDir(path, -1, null, (Collection) null);
   Iterator iterator = entries.iterator();
   while (iterator.hasNext()) {
     SVNDirEntry entry = (SVNDirEntry) iterator.next();
     if (entry.getKind() == SVNNodeKind.DIR) {
       //				listEntries(repository, (path.equals("")) ? entry.getName()
       //						: path + "/" + entry.getName());
     } else {
       String tpath = (path.equals("") ? "" : path + "/") + entry.getName();
       ;
       String filename = url + "/" + tpath;
       if (Config.isSourceCode(filename)) {
         // System.out.println(filename);
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
         repository.getFile(tpath, -1, null, baos);
         InputStream is = new ByteArrayInputStream(baos.toByteArray());
         String content;
         try {
           content = tokenizer.readAll(is);
           long hash = tokenizer.getContentHash(filename, content);
           System.out.print(tpath + " " + hash + "\t");
         } catch (IOException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
         }
       }
     }
   }
 }
 public SVNDirEntry info(String path, long revision) throws SVNException {
   try {
     openConnection();
     String fullPath = getFullPath(path);
     SVNURL url = getLocation().setPath(fullPath, false);
     path = getRepositoryPath(path);
     Object[] buffer = new Object[] {"stat", path, getRevisionObject(revision)};
     write("(w(s(n)))", buffer);
     authenticate();
     read("[((?F))]", buffer, true);
     SVNDirEntry entry = (SVNDirEntry) buffer[0];
     if (entry != null) {
       entry =
           new SVNDirEntry(
               url,
               SVNPathUtil.tail(path),
               entry.getKind(),
               entry.getSize(),
               entry.hasProperties(),
               entry.getRevision(),
               entry.getDate(),
               entry.getAuthor());
     }
     return entry;
   } catch (SVNException e) {
     closeSession();
     handleUnsupportedCommand(e, "'stat' not implemented");
   } finally {
     closeConnection();
   }
   return null;
 }
Esempio n. 7
0
  public void findProjectRoots(String name, String path, List<SVNProjectRoot> list)
      throws SVNException {

    Collection<SVNDirEntry> entries = new ArrayList<>();
    SVNDirEntry directory =
        repository.getDir(path, DEFAULT_HEAD_REVISION, false, (Collection<SVNDirEntry>) entries);
    logger.debug("Inspecting directory " + path);

    if (isProjectRoot(directory, entries)) {
      logger.debug("Found project root at {} now looking for branches and tags", path);

      Set<SVNDirEntry> branches = new HashSet<>();
      String branchesPath = path + "/branches";
      SVNNodeKind branchesNode = repository.checkPath(branchesPath, -1);
      if (branchesNode == SVNNodeKind.DIR) {
        repository.getDir(branchesPath, -1, false, branches);
      }
      Set<String> branchNames = branches.stream().map(d -> d.getName()).collect(Collectors.toSet());
      logger.debug("Found {} branches: {}", branchNames.size(), branchNames);

      Set<SVNDirEntry> tags = new HashSet<>();
      String tagsPath = path + "/tags";
      SVNNodeKind tagsNode = repository.checkPath(tagsPath, -1);
      if (tagsNode == SVNNodeKind.DIR) {
        repository.getDir(tagsPath, -1, false, tags);
      }
      Set<String> tagNames = tags.stream().map(d -> d.getName()).collect(Collectors.toSet());
      logger.debug("Found {} tags: {}", tagNames.size(), tagNames);

      list.add(
          new SVNProjectRoot(
              name, path, directory.getURL().toDecodedString(), branchNames, tagNames));
      return;
    }

    for (SVNDirEntry entry : entries) {
      if (entry.getKind() == SVNNodeKind.DIR) {
        String dirPath =
            isRootPath(path) ? pathRelativeToRoot(path, entry) : pathRelativeToParent(path, entry);
        logger.debug("Moving into directory " + dirPath);
        findProjectRoots(entry.getName(), dirPath, list);
      }
    }
  }
Esempio n. 8
0
  private static boolean isProjectRoot(SVNDirEntry directory, Collection<SVNDirEntry> entries) {

    List<String> projectFolders = new ArrayList<>(Arrays.asList("trunk")); // ,
    // "branches"
    // ));
    // //,
    // "tags"));
    for (SVNDirEntry entry : entries) {
      if (!projectFolders.contains(entry.getName())) {
        // allow spurious extra folder names
        // return false;
      } else {
        projectFolders.remove(entry.getName());
      }
    }

    if (!projectFolders.isEmpty()) {
      return false;
    }

    return true;
  }
Esempio n. 9
0
 @Override
 public void indexDocument(
     Repository repository, SVNDirEntry dirEntry, String path, long revision) {
   LOGGER.debug("Scanning archive document");
   try {
     ByteArrayOutputStream baos = new ByteArrayOutputStream();
     // This means we get the contents of the file only. No properties.
     repository.getRepository().getFile(path, revision, null, baos);
     ByteArrayInputStream str = new ByteArrayInputStream(baos.toByteArray());
     scan(str, path, dirEntry);
   } catch (SVNException e) {
     LOGGER.error("Exception by SVN: ", e);
   } catch (Exception e) {
     LOGGER.error("We had an exception " + path + " (r" + dirEntry.getRevision() + ")", e);
   }
 }
Esempio n. 10
0
 /*
  * Called recursively to obtain all entries that make up the repository tree
  * repository - an SVNRepository which interface is used to carry out the
  * request, in this case it's a request to get all entries in the directory
  * located at the path parameter;
  *
  * path is a directory path relative to the repository location path (that
  * is a part of the URL used to create an SVNRepository instance);
  *
  */
 public static void listEntries(SVNRepository repository, String path) throws SVNException {
   /*
    * Gets the contents of the directory specified by path at the latest
    * revision (for this purpose -1 is used here as the revision number to
    * mean HEAD-revision) getDir returns a Collection of SVNDirEntry
    * elements. SVNDirEntry represents information about the directory
    * entry. Here this information is used to get the entry name, the name
    * of the person who last changed this entry, the number of the revision
    * when it was last changed and the entry type to determine whether it's
    * a directory or a file. If it's a directory listEntries steps into a
    * next recursion to display the contents of this directory. The third
    * parameter of getDir is null and means that a user is not interested
    * in directory properties. The fourth one is null, too - the user
    * doesn't provide its own Collection instance and uses the one returned
    * by getDir.
    */
   Collection entries = repository.getDir(path, -1, null, (Collection) null);
   Iterator iterator = entries.iterator();
   while (iterator.hasNext()) {
     SVNDirEntry entry = (SVNDirEntry) iterator.next();
     System.out.println(
         "/"
             + (path.equals("") ? "" : path + "/")
             + entry.getName()
             + " (author: '"
             + entry.getAuthor()
             + "'; revision: "
             + entry.getRevision()
             + "; date: "
             + entry.getDate()
             + ")");
     /*
      * Checking up if the entry is a directory.
      */
     if (entry.getKind() == SVNNodeKind.DIR) {
       listEntries(repository, (path.equals("")) ? entry.getName() : path + "/" + entry.getName());
     }
   }
 }
Esempio n. 11
0
  @Override
  public ObjectNode findFileInfo(String path) throws SVNException {
    org.tmatesoft.svn.core.io.SVNRepository repository = getSVNRepository();

    SVNNodeKind nodeKind = repository.checkPath(path, -1);

    if (nodeKind == SVNNodeKind.DIR) {
      // 폴더 내용 출력
      ObjectNode result = Json.newObject();

      result.put("type", "folder");
      ObjectNode listData = Json.newObject();

      SVNProperties prop = new SVNProperties();

      Collection<SVNDirEntry> entries =
          repository.getDir(path, -1, prop, SVNDirEntry.DIRENT_ALL, (Collection) null);

      Iterator<SVNDirEntry> iterator = entries.iterator();
      while (iterator.hasNext()) {
        SVNDirEntry entry = iterator.next();

        ObjectNode data = Json.newObject();
        String author = entry.getAuthor();
        User user = User.findByLoginId(author);

        data.put("type", entry.getKind() == SVNNodeKind.DIR ? "folder" : "file");
        data.put("msg", entry.getCommitMessage());
        data.put("author", author);
        data.put("avatar", getAvatar(user));
        data.put("userName", user.name);
        data.put("userLoginId", user.loginId);
        data.put("createdDate", entry.getDate().getTime());

        listData.put(entry.getName(), data);
      }
      result.put("data", listData);

      return result;

    } else if (nodeKind == SVNNodeKind.FILE) {
      // 파일 내용 출력
      return fileAsJson(path, repository);
    } else {
      return null;
    }
  }
    /** validate the value for a remote (repository) location. */
    public FormValidation doCheckCredentialsId(
        StaplerRequest req,
        @AncestorInPath SCMSourceOwner context,
        @QueryParameter String remoteBase,
        @QueryParameter String value) {
      // TODO suspiciously similar to
      // SubversionSCM.ModuleLocation.DescriptorImpl.checkCredentialsId; refactor into shared
      // method?
      // Test the connection only if we may use the credentials
      if (context == null && !Jenkins.getActiveInstance().hasPermission(Jenkins.ADMINISTER)
          || context != null && !context.hasPermission(CredentialsProvider.USE_ITEM)) {
        return FormValidation.ok();
      }

      // if check remote is reporting an issue then we don't need to
      String url = Util.fixEmptyAndTrim(remoteBase);
      if (url == null) return FormValidation.ok();

      if (!URL_PATTERN.matcher(url).matches()) return FormValidation.ok();

      try {
        String urlWithoutRevision = SvnHelper.getUrlWithoutRevision(url);

        SVNURL repoURL = SVNURL.parseURIDecoded(urlWithoutRevision);

        StandardCredentials credentials =
            value == null
                ? null
                : CredentialsMatchers.firstOrNull(
                    CredentialsProvider.lookupCredentials(
                        StandardCredentials.class,
                        context,
                        ACL.SYSTEM,
                        URIRequirementBuilder.fromUri(repoURL.toString()).build()),
                    CredentialsMatchers.withId(value));
        if (checkRepositoryPath(context, repoURL, credentials) != SVNNodeKind.NONE) {
          // something exists; now check revision if any

          SVNRevision revision = getRevisionFromRemoteUrl(url);
          if (revision != null && !revision.isValid()) {
            return FormValidation.errorWithMarkup(
                hudson.scm.subversion.Messages.SubversionSCM_doCheckRemote_invalidRevision());
          }

          return FormValidation.ok();
        }

        SVNRepository repository = null;
        try {
          repository =
              getRepository(
                  context, repoURL, credentials, Collections.<String, Credentials>emptyMap(), null);
          long rev = repository.getLatestRevision();
          // now go back the tree and find if there's anything that exists
          String repoPath = getRelativePath(repoURL, repository);
          String p = repoPath;
          while (p.length() > 0) {
            p = SVNPathUtil.removeTail(p);
            if (repository.checkPath(p, rev) == SVNNodeKind.DIR) {
              // found a matching path
              List<SVNDirEntry> entries = new ArrayList<SVNDirEntry>();
              repository.getDir(p, rev, false, entries);

              // build up the name list
              List<String> paths = new ArrayList<String>();
              for (SVNDirEntry e : entries)
                if (e.getKind() == SVNNodeKind.DIR) paths.add(e.getName());

              String head = SVNPathUtil.head(repoPath.substring(p.length() + 1));
              String candidate = EditDistance.findNearest(head, paths);

              return FormValidation.error(
                  hudson.scm.subversion.Messages.SubversionSCM_doCheckRemote_badPathSuggest(
                      p, head, candidate != null ? "/" + candidate : ""));
            }
          }

          return FormValidation.error(
              hudson.scm.subversion.Messages.SubversionSCM_doCheckRemote_badPath(repoPath));
        } finally {
          if (repository != null) repository.closeSession();
        }
      } catch (SVNException e) {
        LOGGER.log(Level.INFO, "Failed to access subversion repository " + url, e);
        String message =
            hudson.scm.subversion.Messages.SubversionSCM_doCheckRemote_exceptionMsg1(
                    Util.escape(url),
                    Util.escape(e.getErrorMessage().getFullMessage()),
                    "javascript:document.getElementById('svnerror').style.display='block';"
                        + "document.getElementById('svnerrorlink').style.display='none';"
                        + "return false;")
                + "<br/><pre id=\"svnerror\" style=\"display:none\">"
                + Functions.printThrowable(e)
                + "</pre>";
        return FormValidation.errorWithMarkup(message);
      }
    }
Esempio n. 13
0
 public void handleDirEntry(SVNDirEntry dirEntry) throws SVNException {
   getOperation().receive(SvnTarget.fromURL(dirEntry.getURL()), dirEntry);
 }
Esempio n. 14
0
 private String pathRelativeToRoot(String path, SVNDirEntry entry) {
   return path + entry.getName();
 }
Esempio n. 15
0
 private String pathRelativeToParent(String path, SVNDirEntry entry) {
   return path + PATH_SEPARATOR + entry.getName();
 }
Esempio n. 16
0
  private void doList(
      SVNRepository repos,
      long rev,
      final ISVNDirEntryHandler handler,
      boolean fetchLocks,
      SVNDepth depth,
      int entryFields,
      SVNURL externalParentUrl,
      String externalTarget)
      throws SVNException {
    boolean includeExternals = !getOperation().isIgnoreExternals();
    Map<SVNURL, SVNPropertyValue> externals =
        includeExternals ? new HashMap<SVNURL, SVNPropertyValue>() : null;
    SVNURL url = repos.getLocation();
    SVNURL reposRoot = repos.getRepositoryRoot(false);
    SVNDirEntry entry = null;
    SVNException error = null;
    try {
      entry = repos.info("", rev);
    } catch (SVNException svne) {
      if (svne.getErrorMessage().getErrorCode() == SVNErrorCode.RA_NOT_IMPLEMENTED) {
        error = svne;
      } else {
        throw svne;
      }
    }
    if (error != null) {
      SVNNodeKind kind = repos.checkPath("", rev);
      if (kind != SVNNodeKind.NONE) {
        if (!url.equals(reposRoot)) {
          String name = SVNPathUtil.tail(repos.getLocation().getPath());
          repos.setLocation(repos.getLocation().removePathTail(), false);
          Collection<SVNDirEntry> dirEntries =
              repos.getDir("", rev, null, entryFields, (Collection) null);
          repos.setLocation(url, false);
          for (Iterator<SVNDirEntry> ents = dirEntries.iterator(); ents.hasNext(); ) {
            SVNDirEntry dirEntry = (SVNDirEntry) ents.next();
            if (name.equals(dirEntry.getName())) {
              entry = dirEntry;
              break;
            }
          }
          if (entry != null) {
            entry.setRelativePath(kind == SVNNodeKind.FILE ? name : "");
          }
        } else {
          SVNProperties props = new SVNProperties();
          repos.getDir("", rev, props, entryFields, (Collection<SVNDirEntry>) null);
          SVNProperties revProps = repos.getRevisionProperties(rev, null);
          String author = revProps.getStringValue(SVNRevisionProperty.AUTHOR);
          String dateStr = revProps.getStringValue(SVNRevisionProperty.DATE);
          Date datestamp = null;
          if (dateStr != null) {
            datestamp = SVNDate.parseDateString(dateStr);
          }
          entry =
              new SVNDirEntry(
                  url, reposRoot, "", kind, 0, !props.isEmpty(), rev, datestamp, author);
          entry.setRelativePath("");
        }
      }
    } else if (entry != null) {
      if (entry.getKind() == SVNNodeKind.DIR) {
        entry.setName("");
      }
      entry.setRelativePath(entry.getKind() == SVNNodeKind.DIR ? "" : entry.getName());
    }
    if (entry == null) {
      SVNErrorMessage err =
          SVNErrorMessage.create(
              SVNErrorCode.FS_NOT_FOUND, "URL ''{0}'' non-existent in that revision", url);
      SVNErrorManager.error(err, SVNLogType.WC);
    }
    final Map locksMap = new SVNHashMap();
    if (fetchLocks) {
      SVNLock[] locks = new SVNLock[0];
      try {
        locks = repos.getLocks("");
      } catch (SVNException e) {
        if (!(e.getErrorMessage() != null
            && e.getErrorMessage().getErrorCode() == SVNErrorCode.RA_NOT_IMPLEMENTED)) {
          throw e;
        }
      }
      if (locks != null && locks.length > 0) {
        SVNURL root = repos.getRepositoryRoot(true);
        for (int i = 0; i < locks.length; i++) {
          String repositoryPath = locks[i].getPath();
          locksMap.put(root.appendPath(repositoryPath, false), locks[i]);
        }
      }
    }
    ISVNDirEntryHandler nestedHandler =
        new ISVNDirEntryHandler() {

          public void handleDirEntry(SVNDirEntry dirEntry) throws SVNException {
            dirEntry.setLock((SVNLock) locksMap.get(dirEntry.getURL()));
            handler.handleDirEntry(dirEntry);
          }
        };
    entry.setExternalParentUrl(externalParentUrl);
    entry.setExternalTarget(externalTarget);
    nestedHandler.handleDirEntry(entry);
    if (entry.getKind() == SVNNodeKind.DIR
        && (depth == SVNDepth.FILES
            || depth == SVNDepth.IMMEDIATES
            || depth == SVNDepth.INFINITY)) {
      list(
          repos,
          "",
          rev,
          depth,
          entryFields,
          externals,
          externalParentUrl,
          externalTarget,
          nestedHandler);
    }

    if (includeExternals && externals != null && externals.size() > 0) {
      listExternals(repos, externals, depth, entryFields, fetchLocks, handler);
    }
  }
  public SVNDirEntry getDir(
      String path, long revision, boolean includeComment, final Collection entries)
      throws SVNException {
    Long rev = getRevisionObject(revision);
    // convert path to path relative to repos root.
    SVNDirEntry parentEntry = null;
    try {
      openConnection();
      final SVNURL url = getLocation().setPath(getFullPath(path), false);
      ISVNDirEntryHandler handler =
          new ISVNDirEntryHandler() {
            public void handleDirEntry(SVNDirEntry dirEntry) throws SVNException {
              dirEntry =
                  new SVNDirEntry(
                      url.appendPath(dirEntry.getName(), false),
                      dirEntry.getName(),
                      dirEntry.getKind(),
                      dirEntry.getSize(),
                      dirEntry.hasProperties(),
                      dirEntry.getRevision(),
                      dirEntry.getDate(),
                      dirEntry.getAuthor());
              entries.add(dirEntry);
            }
          };
      path = getRepositoryPath(path);
      // get parent
      Object[] buffer = new Object[] {"stat", path, getRevisionObject(revision)};
      write("(w(s(n)))", buffer);
      authenticate();
      read("[((?F))]", buffer, true);
      parentEntry = (SVNDirEntry) buffer[0];
      parentEntry =
          new SVNDirEntry(
              url,
              "",
              parentEntry.getKind(),
              parentEntry.getSize(),
              parentEntry.hasProperties(),
              parentEntry.getRevision(),
              parentEntry.getDate(),
              parentEntry.getAuthor());

      // get entries.
      buffer = new Object[] {"get-dir", path, rev, Boolean.FALSE, Boolean.TRUE};
      write("(w(s(n)ww))", buffer);
      authenticate();
      buffer = read("[(N(*P)", buffer, true);
      revision = buffer[0] != null ? SVNReader.getLong(buffer, 0) : revision;
      if (handler != null) {
        buffer[0] = handler;
        read("(*D)))", buffer, true);
      } else {
        read("()))", null, true);
      }
      // get comments.
      if (includeComment) {
        Map messages = new HashMap();
        for (Iterator ents = entries.iterator(); ents.hasNext(); ) {
          SVNDirEntry entry = (SVNDirEntry) ents.next();
          Long key = getRevisionObject(entry.getRevision());
          if (messages.containsKey(key)) {
            entry.setCommitMessage((String) messages.get(key));
            continue;
          }
          buffer = new Object[] {"rev-prop", key, SVNRevisionProperty.LOG};
          write("(w(ns))", buffer);
          authenticate();
          buffer = read("[((?S))]", buffer, true);
          messages.put(key, buffer[0]);
          entry.setCommitMessage((String) buffer[0]);
        }
      }
    } catch (SVNException e) {
      closeSession();
      throw e;
    } finally {
      closeConnection();
    }
    return parentEntry;
  }
Esempio n. 18
0
  private static void list(
      SVNRepository repository,
      String path,
      long rev,
      SVNDepth depth,
      int entryFields,
      Map<SVNURL, SVNPropertyValue> externals,
      SVNURL externalParentUrl,
      String externalTarget,
      ISVNDirEntryHandler handler)
      throws SVNException {
    if (depth == SVNDepth.EMPTY) {
      return;
    }
    Collection entries = new TreeSet();
    SVNProperties properties;
    try {
      properties = externals == null ? null : new SVNProperties();
      entries = repository.getDir(path, rev, properties, entryFields, entries);
    } catch (SVNAuthenticationException e) {
      return;
    } catch (SVNException e) {
      if (e.getErrorMessage().getErrorCode() == SVNErrorCode.RA_NOT_AUTHORIZED) {
        return;
      }
      throw e;
    }

    SVNPropertyValue svnExternalsVaule =
        properties == null ? null : properties.getSVNPropertyValue(SVNProperty.EXTERNALS);
    if (svnExternalsVaule != null) {
      SVNURL location = repository.getLocation();
      externals.put(location.appendPath(path, false), svnExternalsVaule);
    }

    for (Iterator iterator = entries.iterator(); iterator.hasNext(); ) {
      SVNDirEntry entry = (SVNDirEntry) iterator.next();
      String childPath = SVNPathUtil.append(path, entry.getName());
      entry.setRelativePath(childPath);
      if (entry.getKind() == SVNNodeKind.FILE
          || depth == SVNDepth.IMMEDIATES
          || depth == SVNDepth.INFINITY) {
        entry.setExternalParentUrl(externalParentUrl);
        entry.setExternalTarget(externalTarget);
        handler.handleDirEntry(entry);
      }
      if (entry.getKind() == SVNNodeKind.DIR
          && entry.getDate() != null
          && depth == SVNDepth.INFINITY) {
        list(
            repository,
            childPath,
            rev,
            depth,
            entryFields,
            externals,
            externalParentUrl,
            externalTarget,
            handler);
      }
    }
  }