Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * ====================================================================
   * Copyright (c) 2004-2006 TMate Software Ltd.  All rights reserved.
   *
   * This software is licensed as described in the file COPYING, which
   * you should have received as part of this distribution.  The terms
   * are also available at http://svnkit.com/license.html
   * If newer versions of this license are posted there, you may use a
   * newer version instead, at your option.
  * ====================================================================
  */
 
 package org.tmatesoft.svn.core.internal.io.dav;
 
 import java.util.Date;
 import java.util.Map;
 

Author(s):
TMate Software Ltd.
Version:
1.1.0
 
 public class DAVConnection {
     
     private IHTTPConnection myHttpConnection;
     private String myActivityCollectionURL;
     private Map myLocks;
     private boolean myKeepLocks;
     private SVNRepository myRepository;
     
     public DAVConnection(IHTTPConnectionFactory connectionFactorySVNRepository repository) {
          = repository;
          = connectionFactory;
     }
     
     public SVNURL getLocation() {
         return .getLocation();
     }
     
     public void updateLocation() {
          = null;
     }
 
     public void open(DAVRepository repositorythrows SVNException {
         if ( == null) {
         	 = .createHTTPConnection(repository);
         }
     }
 
     public void fetchRepositoryRoot(DAVRepository repositorythrows SVNException {
         if (!repository.hasRepositoryRoot()) {
             String rootPath = repository.getLocation().getURIEncodedPath();
             DAVBaselineInfo info = DAVUtil.getBaselineInfo(thisrepositoryrootPath, -1, falsefalsenull);
             // remove relative part from the path
             rootPath = rootPath.substring(0, rootPath.length() - info.baselinePath.length());
             SVNURL location = repository.getLocation();
             SVNURL url = location.setPath(rootPathtrue);
             repository.setRepositoryRoot(url);
         }
     }
 
     public void fetchRepositoryUUID(DAVRepository repositorythrows SVNException {
         if (!repository.hasRepositoryUUID()) {
             DAVUtil.findStartingProperties(thisrepositoryrepository.getLocation().getURIEncodedPath());
             if (!repository.hasRepositoryUUID()) {
                 SVNErrorMessage err = SVNErrorMessage.create(."Please upgrade to server 0.19 or later");
                 SVNErrorManager.error(err);
             }
         }
     }    
     
     public HTTPStatus doPropfind(String pathHTTPHeader headerStringBuffer bodyDefaultHandler handlerthrows SVNException {
         return .request("PROPFIND"pathheaderbody, -1, 0, nullhandler);
     }
     
    public SVNLock doGetLock(String pathDAVRepository reposthrows SVNException {
        DAVBaselineInfo info = DAVUtil.getBaselineInfo(thisrepospath, -1, falsetruenull);
        StringBuffer body = DAVGetLockHandler.generateGetLockRequest(null);
        DAVGetLockHandler handler = new DAVGetLockHandler();
        SVNErrorMessage context = SVNErrorMessage.create(."Failed to fetch lock information");
        HTTPStatus rc = .request("PROPFIND"pathnullbody, 200, 207, nullhandlercontext);
        
        String id = handler.getID();
        if (id == null) {
            return null;
        }
        String comment = handler.getComment();
        Date createdDate = created != null ? SVNTimeUtil.parseDate(created) : null;
        path = SVNEncodingUtil.uriDecode(info.baselinePath);
        if (!path.startsWith("/")) {
            path = "/" + path;
        }
        return new SVNLock(pathidownercommentcreatedDatenull);
    }
    public SVNLock[] doGetLocks(String paththrows SVNException {
        DAVGetLocksHandler handler = new DAVGetLocksHandler();
        HTTPStatus status = null;
        try {
            status = doReport(path, DAVGetLocksHandler.generateGetLocksRequest(null), handler);
        } catch (SVNException e) {
            if (e.getErrorMessage() != null && e.getErrorMessage().getErrorCode() == .) {
                SVNErrorMessage err = SVNErrorMessage.create(."Server does not support locking features");
                SVNErrorManager.error(erre.getErrorMessage());
            } else if (e.getErrorMessage() != null && e.getErrorMessage().getErrorCode() == .) {
                return new SVNLock[0];
            }
            throw e;
        }
        if (status.getCode() == 501) {
            SVNErrorMessage err = SVNErrorMessage.create(."Server does not support locking features");
            SVNErrorManager.error(errstatus.getError());
        } else if (status.getCode() == .) {
            return new SVNLock[0];
        } else if (status.getError() != null && status.getError().getErrorCode() == .) { 
            SVNErrorMessage err = SVNErrorMessage.create(."Server does not support locking features");
            SVNErrorManager.error(errstatus.getError());
        } else if (status.getError() != null) {
            SVNErrorManager.error(status.getError());
        }
        return handler.getLocks();
    }
    public SVNLock doLock(String pathDAVRepository reposString commentboolean forcelong revisionthrows SVNException {
        DAVBaselineInfo info = DAVUtil.getBaselineInfo(thisrepospath, -1, falsetruenull);
        StringBuffer body = DAVGetLockHandler.generateSetLockRequest(nullcomment);
        HTTPHeader header = null;
        if (revision >= 0) {
            header = new HTTPHeader();
            header.setHeaderValue(., Long.toString(revision));
        }
        if (force) {
            if (header == null) {
                header = new HTTPHeader();
            }
            header.setHeaderValue(."lock-steal");
        }
        DAVGetLockHandler handler = new DAVGetLockHandler();
        SVNErrorMessage context = SVNErrorMessage.create(."Lock request failed");
        HTTPStatus status = .request("LOCK"pathheaderbody, -1, 0, nullhandlercontext);
        if (status.getError() != null) {
            SVNErrorManager.error(status.getError());
        }
        if (status != null) {
            String userName = .getLastValidCredentials() != null ? .getLastValidCredentials().getUserName() : null
            String created = status.getHeader().getFirstHeaderValue(.);
            if (userName == null || created == null) {
                SVNErrorMessage err = SVNErrorMessage.create(."Incomplete lock data returned");
                SVNErrorManager.error(err);
            }
            Date createdDate = created != null ? SVNTimeUtil.parseDate(created) : null;            
            return new SVNLock(info.baselinePathhandler.getID(), userNamecommentcreatedDatenull);
        }
        return null;
    }
    public void doUnlock(String pathDAVRepository reposString idboolean forcethrows SVNException {
        if (id == null) {
            SVNLock lock = doGetLock(pathrepos);
            if (lock != null) {
                id = lock.getID();
            } 
            if (id == null) {
                SVNErrorMessage err = SVNErrorMessage.create(."''{0}'' is not locked in the repository"path);
                SVNErrorManager.error(err);
            }
        }
        HTTPHeader header = new HTTPHeader();
        header.setHeaderValue(."<" + id + ">");
        if (force) {
            header.setHeaderValue(."lock-break");
        }
        SVNErrorMessage context = SVNErrorMessage.create(."Unlock request failed");
        .request("UNLOCK"pathheader, (StringBuffernull, 204, 0, nullnullcontext);
    }
	public void doGet(String pathOutputStream osthrows SVNException {
        SVNErrorMessage context = SVNErrorMessage.create(."GET request failed for ''{0}''"path);
		.request("GET"pathnull, (StringBuffernull, 200, 226, osnullcontext);
    }
    public HTTPStatus doReport(String pathStringBuffer requestBodyDefaultHandler handlerthrows SVNException {
        return doReport(pathrequestBodyhandlerfalse);
    }
    public HTTPStatus doReport(String pathStringBuffer requestBodyDefaultHandler handlerboolean spoolthrows SVNException {
        .setSpoolResponse(spool);
        try {
            HTTPHeader header = new HTTPHeader();
            header.addHeaderValue("Accept-Encoding""svndiff1;q=0.9,svndiff;q=0.8");
            return .request("REPORT"pathheaderrequestBody, -1, 0, nullhandler);
        } finally {
            .setSpoolResponse(false);
        }
	}
    public void doProppatch(String repositoryPathString pathStringBuffer requestBodyDefaultHandler handlerSVNErrorMessage contextthrows SVNException {
        HTTPHeader header = null;
        if ( != null && repositoryPath != null && .containsKey(repositoryPath)) {
            header = new HTTPHeader();
            header.setHeaderValue(."(<" + .get(repositoryPath) + ">)");
        }
        try {
            .request("PROPPATCH"pathheaderrequestBody, 200, 207, nullhandlercontext);
        } catch (SVNException e) {
            if (context == null && e.getErrorMessage().getErrorCode() == .) {
                SVNErrorMessage err = SVNErrorMessage.create(."At least one property change failed; repository is unchanged");
                SVNErrorManager.error(err);
            }
            // handler error.
            throw e;
        }
    }
    
    public String doMakeActivity() throws SVNException {
        String locationPath = SVNEncodingUtil.uriEncode(getLocation().getPath());
        String url = getActivityCollectionURL(locationPathfalse) + generateUUID();
        HTTPStatus status = .request("MKACTIVITY"urlnull, (StringBuffernull, 201, 404, nullnull);
        if (status.getCode() == 404) {
            url = getActivityCollectionURL(locationPathtrue) + generateUUID();
            status = .request("MKACTIVITY"urlnull, (StringBuffernull, 201, 0, nullnull);
        }
        return url;
    }
    
    public HTTPStatus doDelete(String paththrows SVNException {
        return .request("DELETE"pathnull, (StringBuffernull, 404, 204, nullnull);
    }
    public HTTPStatus doDelete(String repositoryPathString pathlong revisionthrows SVNException {
        HTTPHeader header = new HTTPHeader();
        if (revision >= 0) {
            header.setHeaderValue(., Long.toString(revision));
        }
        header.setHeaderValue(."infinity");
        StringBuffer request = null;
        if ( != null && DAVMergeHandler.hasChildPaths(repositoryPath)) {
            if (.containsKey(repositoryPath)) {
                header.setHeaderValue(."<" + repositoryPath + "> (<" + .get(repositoryPath) + ">)");
            }
            if () {
                header.setHeaderValue(."keep-locks");
            }
            request = new StringBuffer();
            request.append("<?xml version=\"1.0\" encoding=\"utf-8\"?> ");
            String locationPath = getLocation().getPath();
            locationPath = SVNEncodingUtil.uriEncode(locationPath);
            request = DAVMergeHandler.generateLockDataRequest(requestlocationPathrepositoryPath);
        }
        return .request("DELETE"pathheaderrequest, 204, 404, nullnull);
    }
    
    public HTTPStatus doMakeCollection(String paththrows SVNException {
        return .request("MKCOL"pathnull, (StringBuffernull, 201, 0, nullnull);
    }
    
    public HTTPStatus doPutDiff(String repositoryPathString pathInputStream datalong sizeString baseChecksumString textChecksumthrows SVNException {        
        HTTPHeader headers = new HTTPHeader();
        headers.setHeaderValue(."application/vnd.svn-svndiff");
        headers.setHeaderValue(.size + "");
        if ( != null && .containsKey(repositoryPath)) {
            headers.setHeaderValue(."<" + repositoryPath + "> (<" + .get(repositoryPath) + ">)");
        }
        if (baseChecksum != null) {
            headers.setHeaderValue(.baseChecksum);
        }
        if (textChecksum != null) {
            headers.setHeaderValue(.textChecksum);
        }
        return .request("PUT"pathheadersdata, 201, 204, nullnull);
    }
    
    public HTTPStatus doMerge(String activityURLboolean responseDefaultHandler handlerthrows SVNException {
        String locationPath = SVNEncodingUtil.uriEncode(getLocation().getPath());
        StringBuffer request = DAVMergeHandler.generateMergeRequest(nulllocationPathactivityURL);
        HTTPHeader header = null;
        if (!response || ( != null && !)) {
            header = new HTTPHeader();
            String value = "";
            if (!response) {
                value += "no-merge-response";
            }
            if ( != null && !) {
                value += " release-locks";
            }
            header.setHeaderValue(.value);
        }
        return .request("MERGE"getLocation().getURIEncodedPath(), headerrequest, -1, 0, nullhandler);
    }
    
    public HTTPStatus doCheckout(String activityPathString repositoryPathString pathboolean allow404throws SVNException {
        StringBuffer request = new StringBuffer();
        request.append("<?xml version=\"1.0\" encoding=\"utf-8\"?>");
        request.append("<D:checkout xmlns:D=\"DAV:\">");
        request.append("<D:activity-set>");
        request.append("<D:href>");
        request.append(activityPath);
        request.append("</D:href>");
        request.append("</D:activity-set></D:checkout>");
        HTTPHeader header = null;
        if ( != null && repositoryPath != null && .containsKey(repositoryPath)) {
            header = new HTTPHeader();
            header.setHeaderValue(."(<" + .get(repositoryPath) + ">)");
        }
        HTTPStatus status = .request("CHECKOUT"pathheaderrequest, 201, allow404 ? 404 : 0, nullnull);
        // update location to be a path!
        if (status.getHeader().hasHeader(.)) {
            SVNURL location = SVNURL.parseURIEncoded(status.getHeader().getFirstHeaderValue(.));
            status.getHeader().setHeaderValue(.location.getURIEncodedPath());
        }
        return status;
    }
    public void doCopy(String srcString dstint depththrows SVNException {
        HTTPHeader header = new HTTPHeader();
        header.setHeaderValue(.dst);
        header.setHeaderValue(.depth > 0 ? "infinity" : "0");
        SVNErrorMessage context = SVNErrorMessage.create(."COPY of {0}"src);
        HTTPStatus status = .request("COPY"srcheader, (StringBuffernull, -1, 0, nullnullcontext);
        if (status.getCode() >= 300 && status.getError() != null) {
            SVNErrorMessage err = status.getError();
            SVNErrorManager.error(err);
        }        
    }
    public void close()  {
        if ( != null) {
            .close();
             = null;
             = null;
             = false;
        }
    }
    
    private String getActivityCollectionURL(String pathboolean forcethrows SVNException {
        if (!force &&  != null) {
            return ;
        }
        DAVOptionsHandler handler = new DAVOptionsHandler();
        .request("OPTIONS"pathnull., -1, 0, nullhandler);
        if ( == null) {
            SVNErrorMessage err = SVNErrorMessage.create(.
                    "The OPTIONS request did not include the requested activity-collection-set; this often means that the URL is not WebDAV-enabled");
            SVNErrorManager.error(err);
        }
        return ;
    }
    
    private static String generateUUID() {
        try {
            return SVNUUIDGenerator.formatUUID(SVNUUIDGenerator.generateUUID());
        } catch (SVNException svne) {
            long time = System.currentTimeMillis();
            String uuid = Long.toHexString(time);
            int zeroes = 16 - uuid.length();
            for(int i = 0; i < zeroesi++) {
                uuid = "0" + uuid;
            }
            return uuid;
        }
    }
    public void setLocks(Map locksboolean keepLocks) {
         = locks;
         = keepLocks;
    }
    public void clearAuthenticationCache() {
        if ( != null) {
        }
    }
New to GrepCode? Check out our FAQ X