public static void main(String[] args) {
/*
* Initialize the library. It must be done before calling any
* method of the library.
*/
setupLibrary();
/*
* Run commit example and process error if any.
*/
try {
commitExample();
} catch (SVNException e) {
SVNErrorMessage err = e.getErrorMessage();
/*
* Display all tree of error messages.
* Utility method SVNErrorMessage.getFullMessage() may be used instead of the loop.
*/
while (err != null) {
System.err.println(err.getErrorCode().getCode() + " : " + err.getMessage());
err = err.getChildErrorMessage();
}
System.exit(1);
}
System.exit(0);
}
public static SVNAdminArea open(File path, Level logLevel) throws SVNException {
SVNErrorMessage error = null;
int wcFormatVersion = -1;
Collection enabledFactories = getSelector().getEnabledFactories(path, ourFactories, false);
File adminDir = new Resource(path, SVNFileUtil.getAdminDirectoryName());
File entriesFile = new Resource(adminDir, "entries");
if (adminDir.isDirectory() && entriesFile.isFile()) {
for (Iterator factories = enabledFactories.iterator(); factories.hasNext(); ) {
SVNAdminAreaFactory factory = (SVNAdminAreaFactory) factories.next();
try {
wcFormatVersion = factory.getVersion(path);
if (wcFormatVersion > factory.getSupportedVersion()) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.WC_UNSUPPORTED_FORMAT,
"The path ''{0}'' appears to be part of a Subversion 1.7 or greater\n"
+ "working copy. Please upgrade your Subversion client to use this\n"
+ "working copy.",
path);
SVNErrorManager.error(err, SVNLogType.WC);
} else if (wcFormatVersion < factory.getSupportedVersion()) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.WC_UNSUPPORTED_FORMAT,
"Working copy format of {0} is too old ({1}); please check out your working copy again",
new Object[] {path, new Integer(wcFormatVersion)});
SVNErrorManager.error(err, SVNLogType.WC);
}
} catch (SVNException e) {
if (error != null) {
error.setChildErrorMessage(e.getErrorMessage());
} else {
error = e.getErrorMessage();
}
continue;
}
SVNAdminArea adminArea = factory.doOpen(path, wcFormatVersion);
if (adminArea != null) {
adminArea.setWorkingCopyFormatVersion(wcFormatVersion);
return adminArea;
}
}
}
if (error == null) {
if (path != null) {
checkWCNG(path.getAbsoluteFile(), path);
}
error =
SVNErrorMessage.create(
SVNErrorCode.WC_NOT_DIRECTORY, "''{0}'' is not a working copy", path);
}
if (error.getErrorCode() == SVNErrorCode.WC_UNSUPPORTED_FORMAT) {
error.setChildErrorMessage(null);
}
SVNErrorManager.error(error, logLevel, SVNLogType.WC);
return null;
}
public static int checkWC(File path, boolean useSelector, Level logLevel) throws SVNException {
Collection enabledFactories = ourFactories;
if (useSelector) {
enabledFactories = getSelector().getEnabledFactories(path, enabledFactories, false);
}
SVNErrorMessage error = null;
int version = -1;
for (Iterator factories = enabledFactories.iterator(); factories.hasNext(); ) {
SVNAdminAreaFactory factory = (SVNAdminAreaFactory) factories.next();
try {
version = factory.doCheckWC(path, logLevel);
if (version == 0) {
return version;
}
if (version > factory.getSupportedVersion()) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.WC_UNSUPPORTED_FORMAT,
"The path ''{0}'' appears to be part of a Subversion 1.7 or greater\n"
+ "working copy. Please upgrade your Subversion client to use this\n"
+ "working copy.",
path);
SVNErrorManager.error(err, SVNLogType.WC);
} else if (version < factory.getSupportedVersion()) {
SVNErrorMessage err =
SVNErrorMessage.create(
SVNErrorCode.WC_UNSUPPORTED_FORMAT,
"Working copy format of {0} is too old ({1}); please check out your working copy again",
new Object[] {path, new Integer(version)});
SVNErrorManager.error(err, SVNLogType.WC);
}
} catch (SVNException e) {
if (error != null) {
error.setChildErrorMessage(e.getErrorMessage());
} else {
error = e.getErrorMessage();
}
continue;
}
return version;
}
if (error == null) {
if (path != null) {
checkWCNG(path.getAbsoluteFile(), path);
}
error =
SVNErrorMessage.create(
SVNErrorCode.WC_NOT_DIRECTORY, "''{0}'' is not a working copy", path);
}
if (error.getErrorCode() == SVNErrorCode.WC_UNSUPPORTED_FORMAT) {
error.setChildErrorMessage(null);
}
SVNErrorManager.error(error, logLevel, SVNLogType.WC);
return 0;
}
public DAVLock refreshLock(DAVResource resource, String lockToken, Date newTime)
throws DAVException {
// TODO: add here authz check
FSFS fsfs = resource.getFSFS();
String path = resource.getResourceURI().getPath();
FSLock svnLock = null;
try {
svnLock = (FSLock) fsfs.getLockHelper(path, false);
} catch (SVNException e) {
throw DAVException.convertError(
e.getErrorMessage(),
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Token doesn't point to a lock.",
null);
}
if (svnLock == null || !svnLock.getID().equals(lockToken)) {
throw new DAVException(
"Lock refresh request doesn't match existing lock.",
HttpServletResponse.SC_UNAUTHORIZED,
DAVErrorCode.LOCK_SAVE_LOCK);
}
try {
svnLock =
(FSLock)
fsfs.lockPath(
svnLock.getPath(),
svnLock.getID(),
resource.getUserName(),
svnLock.getComment(),
newTime,
SVNRepository.INVALID_REVISION,
true,
svnLock.isDAVComment());
} catch (SVNException e) {
SVNErrorMessage err = e.getErrorMessage();
if (err.getErrorCode() == SVNErrorCode.FS_NO_USER) {
throw new DAVException(
"Anonymous lock refreshing is not allowed.",
HttpServletResponse.SC_UNAUTHORIZED,
DAVErrorCode.LOCK_SAVE_LOCK);
}
throw DAVException.convertError(
err,
HttpServletResponse.SC_INTERNAL_SERVER_ERROR,
"Failed to refresh existing lock.",
null);
}
return convertSVNLockToDAVLock(svnLock, false, resource.exists());
}
public static void sendError(
@NotNull SvnServerWriter writer, @NotNull SVNErrorMessage errorMessage) throws IOException {
writer
.listBegin()
.word("failure")
.listBegin()
.listBegin()
.number(errorMessage.getErrorCode().getCode())
.string(errorMessage.getMessage())
.string("")
.number(0)
.listEnd()
.listEnd()
.listEnd();
}
private void unlock12(Map pathToTokens, boolean force, ISVNLockHandler handler)
throws SVNException {
for (Iterator paths = pathToTokens.keySet().iterator(); paths.hasNext(); ) {
String path = (String) paths.next();
String id = (String) pathToTokens.get(path);
path = getRepositoryPath(path);
if (id == null) {
Object[] buffer = new Object[] {"get-lock", path};
write("(w(s))", buffer);
authenticate();
read("[((?L))]", buffer, true);
SVNLock lock = (SVNLock) buffer[0];
if (lock == null) {
lock = new SVNLock(path, "", null, null, null, null);
SVNErrorMessage err =
SVNErrorMessage.create(SVNErrorCode.RA_NOT_LOCKED, "No lock on path ''{0}''", path);
handler.handleUnlock(path, lock, err);
continue;
}
id = lock.getID();
}
Object[] buffer = new Object[] {"unlock", path, id, Boolean.valueOf(force)};
write("(w(s(s)w))", buffer);
authenticate();
SVNErrorMessage error = null;
try {
read("[()]", buffer, true);
} catch (SVNException e) {
if (e.getErrorMessage() != null
&& e.getErrorMessage().getErrorCode() == SVNErrorCode.RA_NOT_LOCKED) {
error = e.getErrorMessage();
error = SVNErrorMessage.create(error.getErrorCode(), error.getMessageTemplate(), path);
} else {
throw e;
}
}
if (handler != null) {
SVNLock lock = new SVNLock(path, id, null, null, null, null);
handler.handleUnlock(path, lock, error);
}
}
}
private void export(String url, String destinationDirectory) throws MojoExecutionException {
SubversionUtils svn = new SubversionUtils(trunk + tag + url, destinationDirectory);
try {
svn.export();
} catch (SVNException e) {
SVNErrorMessage err = e.getErrorMessage();
/*
* Display all tree of error messages.
* Utility method SVNErrorMessage.getFullMessage() may be used instead of the loop.
*/
while (err != null) {
getLog().error(err.getErrorCode().getCode() + " : " + err.getMessage());
err = err.getChildErrorMessage();
}
throw new MojoExecutionException(e.getMessage());
}
}
public HTTPStatus request(
String method,
String path,
HTTPHeader header,
InputStream body,
int ok1,
int ok2,
OutputStream dst,
DefaultHandler handler,
SVNErrorMessage context)
throws SVNException {
if ("".equals(path) || path == null) {
path = "/";
}
// 1. prompt for ssl client cert if needed, if cancelled - throw cancellation exception.
HTTPSSLKeyManager keyManager =
myKeyManager == null && myRepository.getAuthenticationManager() != null
? createKeyManager()
: myKeyManager;
TrustManager trustManager =
myTrustManager == null && myRepository.getAuthenticationManager() != null
? myRepository.getAuthenticationManager().getTrustManager(myRepository.getLocation())
: myTrustManager;
String sslRealm =
"<" + myHost.getProtocol() + "://" + myHost.getHost() + ":" + myHost.getPort() + ">";
SVNAuthentication httpAuth = myLastValidAuth;
boolean isAuthForced =
myRepository.getAuthenticationManager() != null
? myRepository.getAuthenticationManager().isAuthenticationForced()
: false;
if (httpAuth == null && isAuthForced) {
httpAuth =
myRepository
.getAuthenticationManager()
.getFirstAuthentication(ISVNAuthenticationManager.PASSWORD, sslRealm, null);
myChallengeCredentials =
new HTTPBasicAuthentication((SVNPasswordAuthentication) httpAuth, myCharset);
}
String realm = null;
// 2. create request instance.
HTTPRequest request = new HTTPRequest(myCharset);
request.setConnection(this);
request.setKeepAlive(true);
request.setRequestBody(body);
request.setResponseHandler(handler);
request.setResponseStream(dst);
SVNErrorMessage err = null;
boolean ntlmAuthIsRequired = false;
boolean ntlmProxyAuthIsRequired = false;
boolean negoAuthIsRequired = false;
int authAttempts = 0;
while (true) {
HTTPStatus status = null;
if (System.currentTimeMillis() >= myNextRequestTimeout) {
SVNDebugLog.getDefaultLog().logFine(SVNLogType.NETWORK, "Keep-Alive timeout detected");
close();
}
int retryCount = 1;
try {
err = null;
String httpAuthResponse = null;
String proxyAuthResponse = null;
while (retryCount >= 0) {
connect(keyManager, trustManager);
request.reset();
request.setProxied(myIsProxied);
request.setSecured(myIsSecured);
if (myProxyAuthentication != null
&& (ntlmProxyAuthIsRequired
|| !"NTLM".equals(myProxyAuthentication.getAuthenticationScheme()))) {
if (proxyAuthResponse == null) {
request.initCredentials(myProxyAuthentication, method, path);
proxyAuthResponse = myProxyAuthentication.authenticate();
}
request.setProxyAuthentication(proxyAuthResponse);
}
if (myChallengeCredentials != null
&& (ntlmAuthIsRequired
|| negoAuthIsRequired
|| ((!"NTLM".equals(myChallengeCredentials.getAuthenticationScheme()))
&& !"Negotiate".equals(myChallengeCredentials.getAuthenticationScheme()))
&& httpAuth != null)) {
if (httpAuthResponse == null) {
request.initCredentials(myChallengeCredentials, method, path);
httpAuthResponse = myChallengeCredentials.authenticate();
}
request.setAuthentication(httpAuthResponse);
}
try {
request.dispatch(method, path, header, ok1, ok2, context);
break;
} catch (EOFException pe) {
// retry, EOF always means closed connection.
if (retryCount > 0) {
close();
continue;
}
throw (IOException) new IOException(pe.getMessage()).initCause(pe);
} finally {
retryCount--;
}
}
myNextRequestTimeout = request.getNextRequestTimeout();
status = request.getStatus();
} catch (SSLHandshakeException ssl) {
myRepository.getDebugLog().logFine(SVNLogType.NETWORK, ssl);
close();
if (ssl.getCause() instanceof SVNSSLUtil.CertificateNotTrustedException) {
SVNErrorManager.cancel(ssl.getCause().getMessage(), SVNLogType.NETWORK);
}
SVNErrorMessage sslErr =
SVNErrorMessage.create(
SVNErrorCode.RA_NOT_AUTHORIZED,
"SSL handshake failed: ''{0}''",
new Object[] {ssl.getMessage()},
SVNErrorMessage.TYPE_ERROR,
ssl);
if (keyManager != null) {
keyManager.acknowledgeAndClearAuthentication(sslErr);
}
err = SVNErrorMessage.create(SVNErrorCode.RA_DAV_REQUEST_FAILED, ssl);
// continue; http://svnkit.com/tracker/view.php?id=301 - Kohsuke
} catch (IOException e) {
myRepository.getDebugLog().logFine(SVNLogType.NETWORK, e);
if (e instanceof SocketTimeoutException) {
err =
SVNErrorMessage.create(
SVNErrorCode.RA_DAV_REQUEST_FAILED,
"timed out waiting for server",
null,
SVNErrorMessage.TYPE_ERROR,
e);
} else if (e instanceof UnknownHostException) {
err =
SVNErrorMessage.create(
SVNErrorCode.RA_DAV_REQUEST_FAILED,
"unknown host",
null,
SVNErrorMessage.TYPE_ERROR,
e);
} else if (e instanceof ConnectException) {
err =
SVNErrorMessage.create(
SVNErrorCode.RA_DAV_REQUEST_FAILED,
"connection refused by the server",
null,
SVNErrorMessage.TYPE_ERROR,
e);
} else if (e instanceof SVNCancellableOutputStream.IOCancelException) {
SVNErrorManager.cancel(e.getMessage(), SVNLogType.NETWORK);
} else if (e instanceof SSLException) {
err = SVNErrorMessage.create(SVNErrorCode.RA_DAV_REQUEST_FAILED, e);
} else {
err = SVNErrorMessage.create(SVNErrorCode.RA_DAV_REQUEST_FAILED, e);
}
} catch (SVNException e) {
myRepository.getDebugLog().logFine(SVNLogType.NETWORK, e);
// force connection close on SVNException
// (could be thrown by user's auth manager methods).
close();
throw e;
} finally {
finishResponse(request);
}
if (err != null) {
close();
break;
}
if (keyManager != null) {
myKeyManager = keyManager;
myTrustManager = trustManager;
keyManager.acknowledgeAndClearAuthentication(null);
}
if (status.getCode() == HttpURLConnection.HTTP_FORBIDDEN) {
myLastValidAuth = null;
close();
err = request.getErrorMessage();
} else if (myIsProxied && status.getCode() == HttpURLConnection.HTTP_PROXY_AUTH) {
Collection proxyAuthHeaders =
request.getResponseHeader().getHeaderValues(HTTPHeader.PROXY_AUTHENTICATE_HEADER);
try {
myProxyAuthentication =
HTTPAuthentication.parseAuthParameters(
proxyAuthHeaders, myProxyAuthentication, myCharset);
} catch (SVNException svne) {
myRepository.getDebugLog().logFine(SVNLogType.NETWORK, svne);
err = svne.getErrorMessage();
break;
}
if (myProxyAuthentication instanceof HTTPNTLMAuthentication) {
ntlmProxyAuthIsRequired = true;
HTTPNTLMAuthentication ntlmProxyAuth = (HTTPNTLMAuthentication) myProxyAuthentication;
if (ntlmProxyAuth.isInType3State()) {
continue;
}
}
err =
SVNErrorMessage.create(
SVNErrorCode.RA_NOT_AUTHORIZED, "HTTP proxy authorization failed");
SVNURL location = myRepository.getLocation();
ISVNAuthenticationManager authManager = myRepository.getAuthenticationManager();
ISVNProxyManager proxyManager =
authManager != null ? authManager.getProxyManager(location) : null;
if (proxyManager != null) {
proxyManager.acknowledgeProxyContext(false, err);
}
close();
break;
} else if (status.getCode() == HttpURLConnection.HTTP_UNAUTHORIZED) {
authAttempts++; // how many times did we try?
Collection authHeaderValues =
request.getResponseHeader().getHeaderValues(HTTPHeader.AUTHENTICATE_HEADER);
if (authHeaderValues == null || authHeaderValues.size() == 0) {
err = request.getErrorMessage();
status.setError(
SVNErrorMessage.create(
SVNErrorCode.RA_DAV_REQUEST_FAILED,
err.getMessageTemplate(),
err.getRelatedObjects()));
if ("LOCK".equalsIgnoreCase(method)) {
status
.getError()
.setChildErrorMessage(
SVNErrorMessage.create(
SVNErrorCode.UNSUPPORTED_FEATURE,
"Probably you are trying to lock file in repository that only allows anonymous access"));
}
SVNErrorManager.error(status.getError(), SVNLogType.NETWORK);
return status;
}
// we should work around a situation when a server
// does not support Basic authentication while we're
// forcing it, credentials should not be immediately
// thrown away
boolean skip = false;
isAuthForced =
myRepository.getAuthenticationManager() != null
? myRepository.getAuthenticationManager().isAuthenticationForced()
: false;
if (isAuthForced) {
if (httpAuth != null
&& myChallengeCredentials != null
&& !HTTPAuthentication.isSchemeSupportedByServer(
myChallengeCredentials.getAuthenticationScheme(), authHeaderValues)) {
skip = true;
}
}
try {
myChallengeCredentials =
HTTPAuthentication.parseAuthParameters(
authHeaderValues, myChallengeCredentials, myCharset);
} catch (SVNException svne) {
err = svne.getErrorMessage();
break;
}
myChallengeCredentials.setChallengeParameter("methodname", method);
myChallengeCredentials.setChallengeParameter("uri", path);
if (skip) {
close();
continue;
}
HTTPNTLMAuthentication ntlmAuth = null;
HTTPNegotiateAuthentication negoAuth = null;
if (myChallengeCredentials instanceof HTTPNTLMAuthentication) {
ntlmAuthIsRequired = true;
ntlmAuth = (HTTPNTLMAuthentication) myChallengeCredentials;
if (ntlmAuth.isInType3State()) {
continue;
}
} else if (myChallengeCredentials instanceof HTTPDigestAuthentication) {
// continue (retry once) if previous request was acceppted?
if (myLastValidAuth != null) {
myLastValidAuth = null;
continue;
}
} else if (myChallengeCredentials instanceof HTTPNegotiateAuthentication) {
negoAuthIsRequired = true;
negoAuth = (HTTPNegotiateAuthentication) myChallengeCredentials;
if (negoAuth.isStarted()) {
continue;
}
}
myLastValidAuth = null;
if (ntlmAuth != null && ntlmAuth.isNative() && authAttempts == 1) {
/*
* if this is the first time we get HTTP_UNAUTHORIZED, NTLM is the target auth scheme
* and JNA is available, we should try a native auth mechanism first without calling
* auth providers.
*/
continue;
}
if (negoAuth != null) {
continue;
}
ISVNAuthenticationManager authManager = myRepository.getAuthenticationManager();
if (authManager == null) {
err = request.getErrorMessage();
break;
}
realm = myChallengeCredentials.getChallengeParameter("realm");
realm = realm == null ? "" : " " + realm;
realm =
"<"
+ myHost.getProtocol()
+ "://"
+ myHost.getHost()
+ ":"
+ myHost.getPort()
+ ">"
+ realm;
if (httpAuth == null) {
httpAuth =
authManager.getFirstAuthentication(
ISVNAuthenticationManager.PASSWORD, realm, myRepository.getLocation());
} else {
authManager.acknowledgeAuthentication(
false,
ISVNAuthenticationManager.PASSWORD,
realm,
request.getErrorMessage(),
httpAuth);
httpAuth =
authManager.getNextAuthentication(
ISVNAuthenticationManager.PASSWORD, realm, myRepository.getLocation());
}
if (httpAuth == null) {
err = SVNErrorMessage.create(SVNErrorCode.CANCELLED, "HTTP authorization cancelled");
break;
}
if (httpAuth != null) {
myChallengeCredentials.setCredentials((SVNPasswordAuthentication) httpAuth);
}
continue;
} else if (status.getCode() == HttpURLConnection.HTTP_MOVED_PERM
|| status.getCode() == HttpURLConnection.HTTP_MOVED_TEMP) {
close();
String newLocation =
request.getResponseHeader().getFirstHeaderValue(HTTPHeader.LOCATION_HEADER);
if (newLocation == null) {
err = request.getErrorMessage();
break;
}
int hostIndex = newLocation.indexOf("://");
if (hostIndex > 0) {
hostIndex += 3;
hostIndex = newLocation.indexOf("/", hostIndex);
}
if (hostIndex > 0 && hostIndex < newLocation.length()) {
String newPath = newLocation.substring(hostIndex);
if (newPath.endsWith("/")
&& !newPath.endsWith("//")
&& !path.endsWith("/")
&& newPath.substring(0, newPath.length() - 1).equals(path)) {
path += "//";
continue;
}
}
err = request.getErrorMessage();
} else if (request.getErrorMessage() != null) {
err = request.getErrorMessage();
} else {
ntlmProxyAuthIsRequired = false;
ntlmAuthIsRequired = false;
negoAuthIsRequired = false;
}
if (err != null) {
break;
}
if (myIsProxied) {
SVNURL location = myRepository.getLocation();
ISVNAuthenticationManager authManager = myRepository.getAuthenticationManager();
ISVNProxyManager proxyManager =
authManager != null ? authManager.getProxyManager(location) : null;
if (proxyManager != null) {
proxyManager.acknowledgeProxyContext(true, null);
}
}
if (httpAuth != null && realm != null && myRepository.getAuthenticationManager() != null) {
myRepository
.getAuthenticationManager()
.acknowledgeAuthentication(
true, ISVNAuthenticationManager.PASSWORD, realm, null, httpAuth);
}
if (trustManager != null && myRepository.getAuthenticationManager() != null) {
myRepository.getAuthenticationManager().acknowledgeTrustManager(trustManager);
}
if (httpAuth != null) {
myLastValidAuth = httpAuth;
}
status.setHeader(request.getResponseHeader());
return status;
}
// force close on error that was not processed before.
// these are errors that has no relation to http status (processing error or cancellation).
close();
if (err != null
&& err.getErrorCode().getCategory() != SVNErrorCode.RA_DAV_CATEGORY
&& err.getErrorCode() != SVNErrorCode.UNSUPPORTED_FEATURE) {
SVNErrorManager.error(err, SVNLogType.NETWORK);
}
// err2 is another default context...
// myRepository.getDebugLog().info(err.getMessage());
myRepository.getDebugLog().logFine(SVNLogType.NETWORK, new Exception(err.getMessage()));
SVNErrorMessage err2 =
SVNErrorMessage.create(
SVNErrorCode.RA_DAV_REQUEST_FAILED,
"{0} request failed on ''{1}''",
new Object[] {method, path},
err.getType(),
err.getCause());
SVNErrorManager.error(err, err2, SVNLogType.NETWORK);
return null;
}