org.tmatesoft.svn.core.SVNURL Java Examples

private String createDiffDescription(long revision, String cleanedFilePath) throws SVNException {
	String returnable = null;
	final SvnOperationFactory svnOperationFactory = new SvnOperationFactory();
	try {
		final ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
		final SvnDiffGenerator diffGenerator = new SvnDiffGenerator();
		final SvnDiff diff = svnOperationFactory.createDiff();
		SVNURL currentRepoFilePath = SVNURL.parseURIEncoded(repo.getLocation().toString() + "/" + cleanedFilePath);
		List<SVNFileRevision> revisions = new ArrayList<SVNFileRevision>();
		repo.getFileRevisions(cleanedFilePath, revisions, 0, entry.getRevision());
		diff.setSources(SvnTarget.fromURL(currentRepoFilePath, SVNRevision.create(getLastCommitWhenChanged(revision, revisions))),
				SvnTarget.fromURL(currentRepoFilePath, SVNRevision.create(revision)));
		diff.setUseGitDiffFormat(true);
		diff.setDiffGenerator(diffGenerator);
		diff.setOutput(byteArrayOutputStream);
		diff.setDepth(SVNDepth.EMPTY);
		diff.run();
		returnable = new String(byteArrayOutputStream.toByteArray());
	} finally {
		svnOperationFactory.dispose();
	}
	return returnable;
}
 

@Override
public void close() throws Exception {
  final SVNRepository repo = openSvnRepository(url);
  long revision = repo.getLatestRevision();
  try {
    final SVNLock[] locks = repo.getLocks(suffix);
    if (locks.length > 0) {
      final SVNURL root = repo.getRepositoryRoot(true);
      final Map<String, String> locksMap = new HashMap<>();
      for (SVNLock lock : locks) {
        final String relativePath = SVNURLUtil.getRelativeURL(url, root.appendPath(lock.getPath(), false), false);
        locksMap.put(relativePath, lock.getID());
      }
      repo.unlock(locksMap, true, null);
    }
    final ISVNEditor editor = repo.getCommitEditor("Remove subdir for test", null, false, null);
    editor.openRoot(-1);
    editor.deleteEntry(suffix, revision);
    editor.closeEdit();
  } finally {
    repo.closeSession();
  }
}
 

public void checkoutBroken(File workingDirectory, VcsRepository repository, String revision)
    throws WorkingCopyCheckoutException {
  try {
    SvnUtil.setupLibrary();
    final SvnOperationFactory svnOperationFactory = new SvnOperationFactory();
    try {
        final SvnCheckout checkout = svnOperationFactory.createCheckout();
        checkout.setSingleTarget(SvnTarget.fromFile(workingDirectory));
        checkout.setSource(SvnTarget.fromURL(SVNURL.parseURIEncoded(repository.getUrl()), SVNRevision.create(Long.parseLong(revision))));
        checkout.run();
    } finally {
        svnOperationFactory.dispose();
    }
  } catch (NumberFormatException | SVNException e) {
    throw new WorkingCopyCheckoutException(repository, revision, e);
  }
}
 

/**
 * This method downloads an entire github repository or only a sub-directory within a repository.<br>
 * It can also download and extract an archive version of a github repository.
 * It relies on svn export command.<br>
 *
 * @param githubURL
 * @return
 */
private String downloadPackageFromGithub(String githubURL) throws SVNException {
    // Convert the githubRL to an svn format
    String svnURL = transformGithubURLToSvnURL(githubURL);

    // Save files in a system temporary directory
    String tDir = System.getProperty("java.io.tmpdir");
    String packagePath = tDir + "pkg_tmp" + System.nanoTime();
    File outputDir = new File(packagePath);

    // Perform an "svn export" command to download an entire repository or a subdirectory
    final SvnOperationFactory svnOperationFactory = new SvnOperationFactory();
    try {
        final SvnExport export = svnOperationFactory.createExport();
        export.setSource(SvnTarget.fromURL(SVNURL.parseURIEncoded(svnURL)));
        export.setSingleTarget(SvnTarget.fromFile(outputDir));
        //overwrite an existing file
        export.setForce(true);
        export.run();
    } finally {
        //close connection pool associted with this object
        svnOperationFactory.dispose();
    }
    return packagePath;
}
 

private void updateRepoForUpdate(String uri)
		throws SVNException, FileNotFoundException, IOException {
	SvnOperationFactory svnFactory = new SvnOperationFactory();
	final SvnCheckout checkout = svnFactory.createCheckout();
	checkout.setSource(SvnTarget.fromURL(SVNURL.parseURIEncoded(uri)));
	checkout.setSingleTarget(SvnTarget.fromFile(this.workingDir));
	checkout.run();

	// update bar.properties
	File barProps = new File(this.workingDir, "trunk/bar.properties");
	StreamUtils.copy("foo: foo", Charset.defaultCharset(),
			new FileOutputStream(barProps));
	// commit to repo
	SvnCommit svnCommit = svnFactory.createCommit();
	svnCommit.setCommitMessage("update bar.properties");
	svnCommit.setSingleTarget(SvnTarget.fromFile(barProps));
	svnCommit.run();
}
 

@NotNull
private String getRepositoryPath(@NotNull SVNURL url) throws SVNException {
  final String root = repositoryInfo.getBaseUrl().getPath();
  final String path = url.getPath();
  if (!path.startsWith(root)) {
    throw new SVNException(SVNErrorMessage.create(SVNErrorCode.BAD_URL, "Invalid relative path: " + path + " (base: " + root + ")"));
  }
  if (root.length() == path.length()) {
    return "";
  }
  final boolean hasSlash = root.endsWith("/");
  if ((!hasSlash) && (path.charAt(root.length()) != '/')) {
    throw new SVNException(SVNErrorMessage.create(SVNErrorCode.BAD_URL, "Invalid relative path: " + path + " (base: " + root + ")"));
  }
  return StringHelper.normalize(path.substring(root.length()));
}
 

SvnDirectoryRefresher(final AtomicBoolean shutdown,
                      final File directory,
                      final SVNURL svnUrl,
                      final SvnPersisterCore svnPersisterCore) {
    this.shutdown = shutdown;
    this.directory = directory;
    this.svnUrl = svnUrl;
    this.svnPersisterCore = svnPersisterCore;
}
 

public void handleProperty(SVNURL url, SVNPropertyData data) throws SVNException {
    if (getPropgetUtils().isBinary(data)) {
        String path = getPropgetUtils().getProcessor().getInfoProcessor().urlToRelativePath(url.toString());
        //System.out.println(path);
        binaryFiles.add(path.replace(File.separatorChar, '/'));
    }
}
 

@NotNull
private SVNRepository openSvnRepository(@NotNull SVNURL url) throws SVNException {
  final SVNRepository repo = SVNRepositoryFactory.create(url);
  if (authManager != null) {
    repo.setAuthenticationManager(authManager);
  }
  return repo;
}
 

public SvnTesterExternal(@NotNull SVNURL url, @Nullable ISVNAuthenticationManager authManager) throws SVNException {
  this.url = url;
  this.authManager = authManager;
  this.suffix = UUID.randomUUID().toString();
  final SVNRepository repo = openSvnRepository(url);
  try {
    final ISVNEditor editor = repo.getCommitEditor("Create subdir for test", null, false, null);
    editor.openRoot(-1);
    editor.addDir(suffix, null, -1);
    editor.closeDir();
    editor.closeEdit();
  } finally {
    repo.closeSession();
  }
}
 

NativeDaemon(@NotNull String svnserve, @NotNull String svnadmin) throws IOException, InterruptedException, SVNException {
  int port = detectPort();
  url = SVNURL.create("svn", null, HOST, port, null, true);
  repo = TestHelper.createTempDir("git-as-svn-repo");
  log.info("Starting native svn daemon at: {}, url: {}", repo, url);
  Runtime.getRuntime().exec(new String[]{
      svnadmin,
      "create",
      repo.toString()
  }).waitFor();
  Path config = createConfigs(repo);
  daemon = Runtime.getRuntime().exec(new String[]{
      svnserve,
      "--daemon",
      "--root", repo.toString(),
      "--config-file", config.toString(),
      "--listen-host", HOST,
      "--listen-port", Integer.toString(port)
  });
  long serverStartupTimeout = System.currentTimeMillis() + SERVER_STARTUP_TIMEOUT;
  while (true) {
    try {
      SVNRepositoryFactory.create(url).getRevisionPropertyValue(0, "example");
    } catch (SVNAuthenticationException ignored) {
      break;
    } catch (SVNException e) {
      if ((e.getErrorMessage().getErrorCode() == SVNErrorCode.RA_SVN_IO_ERROR) && (System.currentTimeMillis() < serverStartupTimeout)) {
        Thread.sleep(SERVER_STARTUP_DELAY);
        continue;
      }
      throw e;
    }
    break;
  }
}
 

@Test
public void repoRootRelocate() throws Exception {
  try (SvnTestServer server = SvnTestServer.createEmpty()) {
    final SVNURL url = server.getUrl(false);
    try {
      SvnTestServer.openSvnRepository(url, SvnTestServer.USER_NAME, SvnTestServer.PASSWORD).getLatestRevision();
    } catch (SVNException e) {
      Assert.assertEquals(e.getErrorMessage().getErrorCode(), SVNErrorCode.RA_SVN_REPOS_NOT_FOUND);
      final String expected = String.format("Repository branch not found. Use `svn relocate %s/master` to fix your working copy", url.toString());
      Assert.assertEquals(e.getErrorMessage().getMessageTemplate(), expected);
    }
  }
}
 

DeltaParams(
    @NotNull int[] rev,
    @NotNull String path,
    @NotNull String targetPath,
    boolean textDeltas,
    @NotNull Depth depth,
    @NotNull SendCopyFrom sendCopyFrom,
    /*
     * Broken-minded SVN feature we're unlikely to support EVER.
     * <p>
     * If {@code ignoreAncestry} is {@code false} and file was deleted and created back between source and target revisions,
     * SVN server sends two deltas for this file - deletion and addition. The only effect that this behavior produces is
     * increased number of tree conflicts on client.
     * <p>
     * Worse, in SVN it is possible to delete file and create it back in the same commit, effectively breaking its history.
     */
    @SuppressWarnings("UnusedParameters") boolean ignoreAncestry,
    boolean includeInternalProps,
    int lowRevision
) throws SVNException {
  this.rev = rev;
  this.path = path;
  this.targetPath = targetPath.isEmpty() ? null : SVNURL.parseURIEncoded(targetPath);
  this.depth = depth;
  this.sendCopyFrom = sendCopyFrom;
  this.textDeltas = textDeltas;
  this.includeInternalProps = includeInternalProps;
  this.lowRevision = lowRevision;
}
 

public SVNRepository initRepository(boolean cached) throws SVNException, MalformedURLException {
	SVNRepository repo = null;
	SVNURL svnUrl = SVNURL.parseURIEncoded(url);
	if (url.startsWith(HTTP_SCHEME + SCHEME_SEPARATOR) || url.startsWith(HTTPS_SCHEME + SCHEME_SEPARATOR)) {
		DAVRepositoryFactory.setup();
		repo = DAVRepositoryFactory.create(svnUrl);
		repo.testConnection();
		if(cached) {
			TmpDirCreator tmpDirCreator = new TmpDirCreator(url);
			File tempDir = tmpDirCreator.getLocalTempDir();
			SVNURL cachedRepoPath = SVNURL.parseURIEncoded(FILE_SCHEME + SCHEME_SEPARATOR + tempDir);
			if(!tempDir.exists()){
				messageOutputStream.println("Caching subversion repository " + svnUrl + " This can take a while...");
				tempDir.mkdirs();
				cachedRepoPath = SVNRepositoryFactory.createLocalRepository(tempDir, true, true);
				tmpDirCreator.writeIdFileToTempDir();
				SVNRepository targetRepo = SVNRepositoryFactory.create(cachedRepoPath);
				SVNRepositoryReplicator replicator = SVNRepositoryReplicator.newInstance();
				replicator.setReplicationHandler(new ProgressBarReplicationHandler(repo.getLatestRevision()));
				replicator.replicateRepository(repo, targetRepo, -1, -1);
				messageOutputStream.println("\nCaching finished succesfully...");
			}
			svnUrl = cachedRepoPath;
			FSRepositoryFactory.setup();
			repo = FSRepositoryFactory.create(svnUrl);
		}
	} else if (url.startsWith(SVN_SCHEME + SCHEME_SEPARATOR)) {
		SVNRepositoryFactoryImpl.setup();
		repo = SVNRepositoryFactoryImpl.create(svnUrl);
	} else if (url.startsWith(FILE_SCHEME + SCHEME_SEPARATOR)) {
		FSRepositoryFactory.setup();
		repo = FSRepositoryFactory.create(svnUrl);
	} else
		throw new MalformedURLException(String.format("URL %s is not an supported SVN url!", url));
	repo.testConnection();
	return repo;
}
 

@Nullable
static <T extends BranchProvider> RepositoryInfo findRepositoryInfo(@NotNull RepositoryMapping<T> mapping, @NotNull SVNURL url, @NotNull SvnServerWriter writer) throws SVNException, IOException {
  final String path = StringHelper.normalizeDir(url.getPath());
  final Map.Entry<String, T> repo = getMapped(mapping.getMapping(), path);
  if (repo == null) {
    BaseCmd.sendError(writer, SVNErrorMessage.create(SVNErrorCode.RA_SVN_REPOS_NOT_FOUND, "Repository not found: " + url));
    return null;
  }

  final String branchPath = repo.getKey().isEmpty() ? path : path.substring(repo.getKey().length() - 1);
  final NavigableMap<String, GitBranch> branches = repo.getValue().getBranches();

  if (branchPath.length() <= 1) {
    final String branchName = repo.getValue().getBranches().size() == 1
        ? repo.getValue().getBranches().values().iterator().next().getShortBranchName()
        : "<branchname>";
    final String msg = String.format("Repository branch not found. Use `svn relocate %s/%s` to fix your working copy", url, branchName);
    BaseCmd.sendError(writer, SVNErrorMessage.create(SVNErrorCode.RA_SVN_REPOS_NOT_FOUND, msg));
    return null;
  }

  final Map.Entry<String, GitBranch> branch = getMapped(branches, branchPath);

  if (branch == null) {
    BaseCmd.sendError(writer, SVNErrorMessage.create(SVNErrorCode.RA_SVN_REPOS_NOT_FOUND, "Repository branch not found: " + url));
    return null;
  }

  return new RepositoryInfo(
      SVNURL.create(
          url.getProtocol(),
          url.getUserInfo(),
          url.getHost(),
          url.getPort() == SVNURL.getDefaultPortNumber(url.getProtocol()) ? -1 : url.getPort(),
          repo.getKey() + branch.getKey().substring(1),
          true
      ),
      branch.getValue()
  );
}
 

public File checkoutFile(String _rev, String _rel_path) {
	final SvnOperationFactory svnOperationFactory = new SvnOperationFactory();
	File f = null;
	SVNURL url = null;
	try {
		// Create subdir for given rev
		final String rel_dir = _rel_path.substring(0, _rel_path.lastIndexOf('/'));
		final Path rev_dir = Paths.get(this.workDir.toString(), _rev, rel_dir);
		Path p = Files.createDirectories(rev_dir);

		// Create SVNURL for specific file
		url = SVNURL.parseURIEncoded(this.rootRepo.getRepositoryRoot(false) + "/" + rel_dir);

		// Perform checkout
		SVNRevision revision = SVNRevision.create(Long.valueOf(_rev));

		SVNUpdateClient clnt = new SVNUpdateClient((ISVNAuthenticationManager)this.authManager, null);
		clnt.doCheckout(url, p.toFile(), revision, revision, SVNDepth.FILES, false); //IMMEDIATES, FILES, INFINITY

		//
		//			final SvnCheckout checkout = svnOperationFactory.createCheckout();
		//			checkout.setSingleTarget(SvnTarget.fromFile(p.toFile()));
		//			checkout.setSource(SvnTarget.fromURL(url));
		//			checkout.setDepth(SVNDepth.IMMEDIATES); //INFINITY
		//			checkout.setRevision(revision);
		//
		//			// Checkout and get file
		//			checkout.run();
		f = Paths.get(this.workDir.toString(), _rev, _rel_path).toFile();
	} catch (Exception e) {
		SvnClient.log.error("Error while checking out URL '" + url + "', revision "+ _rev + ": " + e.getMessage());
	} finally {
		svnOperationFactory.dispose();
	}
	return f;
}
 

public static SVNRepository createRepository(String url) throws SVNException{
	return  SVNRepositoryFactory.create(SVNURL.parseURIEncoded(url));	
}
 

@Override
public SVNURL getSvnUrl() {
    return svnUrl;
}
 

@Override
public TestVersionResult determineVersions(final String fetchRevision) throws StoreException.ReadException {
    checkShutdownState();

    return doReadWithClientAndRepository(new SvnOperation<TestVersionResult>() {
        @Override
        public TestVersionResult execute(final SVNRepository repo, final SVNClientManager clientManager) throws Exception {
            final String testDefPath = testDefinitionsDirectory;
            /*
            final SVNDirEntry info = repo.info(testDefPath, 2);
            if (info == null) {
                LOGGER.warn("No test matrix found in " + testDefPath + " under " + svnPath);
                return null;
            }
            */
            final Long revision = fetchRevision.length() > 0 ? parseRevisionOrDie(fetchRevision) : Long.valueOf(-1);
            final SVNRevision svnRevision = revision.longValue() > 0 ? SVNRevision.create(revision.longValue()) : SVNRevision.HEAD;
            final SVNLogClient logClient = clientManager.getLogClient();
            final FilterableSVNDirEntryHandler handler = new FilterableSVNDirEntryHandler();
            final SVNURL url = SvnPersisterCoreImpl.this.svnUrl.appendPath(testDefPath, false);
            logClient.doList(url,
                             svnRevision,
                             svnRevision,
                             /* fetchlocks */false,
                             SVNDepth.IMMEDIATES,
                             SVNDirEntry.DIRENT_KIND | SVNDirEntry.DIRENT_CREATED_REVISION,
                             handler);


            final SVNDirEntry logEntry = handler.getParent();

            final List<TestVersionResult.Test> tests = Lists.newArrayListWithExpectedSize(handler.getChildren().size());
            for (final SVNDirEntry testDefFile : handler.getChildren()) {
                if (testDefFile.getKind() != SVNNodeKind.DIR) {
                    LOGGER.warn(String.format("svn kind (%s) is not SVNNodeKind.DIR, skipping %s", testDefFile.getKind(), testDefFile.getURL()));
                    continue;
                }
                final String testName = testDefFile.getName();
                final long testRevision;

                /*
                    When a svn directory gets copied using svn cp source-dir destination-dir, the revision
                    returned by svn list --verbose directory is different from that of svn log directory/sub-dir
                    The revision returned by svn list is the revision of the on the source-dir instead of the destination-dir
                    The code below checks to see if the directory at the provided revision exists, if it does it will use this revision.
                    If the directory does does not exist, try and identify the correct revision using svn log.
                 */
                final SVNLogEntry log = getMostRecentLogEntry(clientManager, testDefPath + "/" + testDefFile.getRelativePath(), svnRevision);
                if (log != null && log.getRevision() != testDefFile.getRevision()) {
                    // The difference in the log.revision and the list.revision can occur during an ( svn cp )
                    if (LOGGER.isDebugEnabled()) {
                        LOGGER.debug("svn log r" + log.getRevision() + " is different than svn list r" + testDefFile.getRevision() + " for " + testDefFile.getURL());
                    }
                    testRevision = log.getRevision();
                } else {
                    testRevision = testDefFile.getRevision();
                }

                tests.add(new TestVersionResult.Test(testName, String.valueOf(testRevision)));
            }

            final String matrixRevision = String.valueOf(logEntry.getRevision());
            return new TestVersionResult(
                tests,
                logEntry.getDate(),
                logEntry.getAuthor(),
                matrixRevision,
                logEntry.getCommitMessage()
            );
        }

        @Override
        public StoreException handleException(final Exception e) throws StoreException {
            throw new StoreException.ReadException("Unable to read from SVN", e);
        }
    });
}
 

@Override
@Export(name = "svn-url")
public SVNURL getSvnUrl() {
    return core.getSvnUrl();
}
 

static void doInWorkingDirectory(
    final Logger logger,
    final File userDir,
    final String username,
    final String password,
    final SVNURL svnUrl,
    final FileBasedProctorStore.ProctorUpdater updater,
    final String comment) throws IOException, SVNException, Exception {
    final BasicAuthenticationManager authManager = new BasicAuthenticationManager(username, password);
    final SVNClientManager userClientManager = SVNClientManager.newInstance(null, authManager);
    final SVNWCClient wcClient = userClientManager.getWCClient();

    try {
        // Clean up the UserDir
        SvnProctorUtils.cleanUpWorkingDir(logger, userDir, svnUrl, userClientManager);

        /*
            if (previousVersion != 0) {
                final Collection<?> changesSinceGivenVersion = repo.log(new String[] { "" }, null, previousVersion, -1, false, false);
                if (! changesSinceGivenVersion.isEmpty()) {
                    //  TODO: the baseline version is out of date, so need to go back to the user
                }
            }
            updateClient.doCheckout(checkoutUrl, workingDir, null, SVNRevision.HEAD, SVNDepth.INFINITY, false);
        */

        final FileBasedProctorStore.RcsClient rcsClient = new SvnPersisterCoreImpl.SvnRcsClient(wcClient);
        final boolean thingsChanged = updater.doInWorkingDirectory(rcsClient, userDir);

        if (thingsChanged) {
            final SVNCommitClient commitClient = userClientManager.getCommitClient();
            final SVNCommitPacket commit = commitClient.doCollectCommitItems(new File[]{userDir}, false, false, SVNDepth.INFINITY, new String[0]);
            long elapsed = -System.currentTimeMillis();
            final SVNCommitInfo info = commitClient.doCommit(commit, /* keepLocks */ false, comment);
            elapsed += System.currentTimeMillis();
            if (logger.isDebugEnabled()) {
                final StringBuilder changes = new StringBuilder("Committed " + commit.getCommitItems().length + " changes: ");
                for (final SVNCommitItem item : commit.getCommitItems()) {
                    changes.append(item.getKind() + " - " + item.getPath() + ", ");
                }
                changes.append(String.format(" in %d ms new revision: r%d", elapsed, info.getNewRevision()));
                logger.debug(changes.toString());
            }
        }
    } finally {
        userClientManager.dispose();
    }
}
 

@NotNull
public static SVNRepository openSvnRepository(@NotNull SVNURL url, @NotNull String username, @NotNull String password) throws SVNException {
  final SVNRepository repo = SVNRepositoryFactory.create(url);
  repo.setAuthenticationManager(BasicAuthenticationManager.newInstance(username, password.toCharArray()));
  return repo;
}
 

@NotNull
public SVNURL getUrl(boolean withPrefix) throws SVNException {
  return SVNURL.create("svn", null, BIND_HOST, server.getPort(), withPrefix ? prefix : "", true);
}
 

@Override
@NotNull
public SVNURL getUrl() throws SVNException {
  return getUrl(true);
}
 

@NotNull
@Override
public SVNURL getUrl() {
  return url;
}
 

public void setParent(@NotNull SVNURL url) throws SVNException {
  this.parent = getRepositoryPath(url);
}
 

@NotNull
@Override
public SVNURL getUrl() throws SVNException {
  return url.appendPath(suffix, false);
}
 

public RepositoryInfo(@NotNull SVNURL baseUrl, @NotNull GitBranch branch) {
  this.baseUrl = baseUrl;
  this.branch = branch;
}
 

@NotNull
public SVNURL getBaseUrl() {
  return baseUrl;
}
 

@Nullable
SVNURL getTargetPath() {
  return targetPath;
}