Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 1&1 Internet AG, http://www.1and1.org
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU Lesser General Public License as published by
   * the Free Software Foundation; either version 2 of the License,
   * or (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  * See the GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package net.sf.beezle.sushi.fs.webdav;
 
 
 import java.net.URI;
 import java.util.List;
 
 public class WebdavNode extends Node {
 	private final WebdavRoot root;

Never starts with a slash. Without type - never with tailing /. With special characters - will be encoded in http requests
 
     private final String path;

    
Null or never starts with ?
 
     private final String encodedQuery;
 
     private boolean tryDir;
 
     private final Object tryLock;

    

Parameters:
encodedQuery null or query without initial "?"
 
     public WebdavNode(WebdavRoot rootString pathString encodedQueryboolean tryDir) {
         if (path.startsWith("/")) {
             throw new IllegalArgumentException(path);
         }
         if (encodedQuery != null && encodedQuery.startsWith("?")) {
             throw new IllegalArgumentException(path);
         }
         this. = root;
         this. = path;
         this. = encodedQuery;
         this. = tryDir;
         this. = new Object();
     }
 
     public URI getURI() {
         return getURI(.getFilesystem().getScheme());
     }
 
     public URI getInternalURI() {
         return getURI(.getFilesystem().getInternalScheme());
     }
 
     private URI getURI(String scheme) {
        HttpHost host;
        host = .;
        try {
            return new URI(schemenullhost.getHostName(), host.getPort(), "/" + getQuery(), null);
        } catch (URISyntaxException e) {
            throw new IllegalStateException(e);
        }
    }
    public boolean equals(Object object) {
        if (object instanceof WebdavNode) {
            if (Util.eq(, ((WebdavNodeobject).)) {
                return super.equals(object);
            }
        }
        return false;
    }
    
    @Override
    public WebdavRoot getRoot() {
        return ;
    }
    @Override
    public WebdavNode getParent() {
        return (WebdavNodedoGetParent();
    }
    @Override
    public WebdavNode join(String ... paths) {
        return (WebdavNodedoJoin(paths);
    }
    @Override
    public WebdavNode join(List<Stringpaths) {
        return (WebdavNodedoJoin(paths);
    }
    @Override
    public long length() throws LengthException {
        boolean oldTryDir;
        Property property;
        synchronized () {
            oldTryDir = ;
            try {
                 = false;
                property = getProperty(.);
            } catch (IOException e) {
                 = oldTryDir;
                throw new LengthException(thise);
            }
            return Long.parseLong((Stringproperty.getValue());
        }
    }
    private static final SimpleDateFormat FMT;
    static {
        Calendar calendar;
        calendar = Calendar.getInstance();
        calendar.set(2000, ., 1, 0, 0);
         = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss zzz".);
        .setTimeZone(TimeZone.getTimeZone("GMT"));
        .set2DigitYearStart(calendar.getTime());
    }
    @Override
    public long getLastModified() throws GetLastModifiedException {
        Property property;
        try {
            synchronized () {
                try {
                    property = getProperty(.);
                } catch (MovedException e) {
                     = !;
                    property = getProperty(.);
                }
            }
        } catch (IOException e) {
            throw new GetLastModifiedException(thise);
        }
        try {
            synchronized () {
                return .parse((Stringproperty.getValue()).getTime();
            }
        } catch (ParseException e) {
            throw new GetLastModifiedException(thise);
        }
    }
    @Override
    public void setLastModified(long millisthrows SetLastModifiedException {
        // no allowed by webdav standard
        throw new SetLastModifiedException(this);
    }
    @Override
    public int getMode() {
        throw unsupported("getMode()");
    }
    @Override
    public void setMode(int mode) {
        throw unsupported("setMode()");
    }
    @Override
    public int getUid() {
        throw unsupported("getUid()");
    }
    @Override
    public void setUid(int uid) {
        throw unsupported("setUid()");
    }
    @Override
    public int getGid() {
        throw unsupported("getGid()");
    }
    @Override
    public void setGid(int gid) {
        throw unsupported("setGid()");
    }
    @Override
    public String getPath() {
        return ;
    }
    public String getQuery() {
        if ( != null) {
            try {
                return new URI("foo://bar/path?" + ).getQuery();
            } catch (URISyntaxException e) {
                throw new IllegalStateException();
            }
        } else {
            return null;
        }
    }
    @Override
    public Node delete() throws DeleteException {
        try {
            synchronized () {
                try {
                    new Delete(this).invoke();
                } catch (MovedException e) {
                     = !;
                    new Delete(this).invoke();
                }
            }
        } catch (IOException e) {
            throw new DeleteException(thise);
        }
        return this;
    }
    @Override
    public Node move(Node destthrows MoveException {
        if (dest instanceof WebdavNode) {
            return move((WebdavNodedest);
        } else {
            throw new MoveException(thisdest"cannot move webdav node to none-webdav node");
        }
    }
    public WebdavNode move(WebdavNode destthrows MoveException {
        try {
            synchronized () {
                try {
                    dest.tryDir = ;
                    new Move(thisdest).invoke();
                } catch (MovedException e) {
                     = !;
                    dest.tryDir = ;
                    new Move(thisdest).invoke();
                }
            }
catch (IOException e) {
			throw new MoveException(thisdeste.getMessage(), e);
		}
        return dest;
    }
    @Override
    public WebdavNode mkdir() throws MkdirException {
        try {
            synchronized () {
                 = true;
                new MkCol(this).invoke();
            }
        } catch (IOException e) {
            throw new MkdirException(thise);
        }
        return this;
    }
    @Override
    public void mklink(String target) {
        throw unsupported("mklink()");
    }
    @Override
    public String readLink() {
        throw unsupported("readLink()");
    }
    @Override
    public boolean exists() throws ExistsException {
        synchronized () {
            try {
                new Head(this).invoke();
                return true;
            } catch (StatusException e) {
                switch (e.getStatusLine().getStatusCode()) {
                    case .:
                         = !;
                        return true;
                    case .:
                        return false;
                    default:
                        throw new ExistsException(thise);
                }
            } catch (IOException e) {
                throw new ExistsException(thise);
            }
        }
    }
    @Override
    public boolean isFile() throws ExistsException {
        return tryDir(false);
    }
    @Override
    public boolean isDirectory() throws ExistsException {
        return tryDir(true);
    }
    @Override
    public boolean isLink() {
    	return false;
    }
    @Override
    public InputStream createInputStream() throws IOException {
        synchronized () {
             = false;
            return new Get(this).invoke();
        }
    }
    @Override
    public OutputStream createOutputStream(boolean appendthrows IOException {
        byte[] add;
        final Put method;
        final WebdavConnection connection;
        OutputStream result;
        if (append) {
            try {
                add = readBytes();
            } catch (FileNotFoundException e) {
                add = null;
            }
        } else {
            add = null;
        }
        synchronized () {
             = false;
            method = new Put(this);
            connection = method.request();
            result = new ChunkedOutputStream(connection.getOutputBuffer()) {
                private boolean closed = false;
                @Override
                public void close() throws IOException {
                    if () {
                        return;
                    }
                     = true;
                    super.close();
                    method.response(connection);
                }
            };
            if (add != null) {
                result.write(add);
            }
        }
        return result;
    }
    @Override
    public List<Nodelist() throws ListException {
        PropFind method;
        List<Noderesult;
        URI href;
        synchronized () {
            try {
                 = true;
                method = new PropFind(this., 1);
                result = new ArrayList<Node>();
                for (MultiStatus response : method.invoke()) {
                    try {
                        href = new URI(response.href);
                    } catch (URISyntaxException e) {
                        throw new ListException(thise);
                    }
                    if (samePath(href)) {
                        // ignore "."
                    } else {
                        result.add(createChild(href));
                    }
                }
                return result;
            } catch (StatusException e) {
                if (e.getStatusLine().getStatusCode() == 400) {
                    return null// this is a file
                }
                throw new ListException(thise);
            } catch (MovedException e) {
                 = false;
                return null// this is a file
            } catch (IOException e) {
                throw new ListException(thise);
            }
        }
    }
    private boolean samePath(URI uri) {
        String cmp;
        int idx;
        int cl;
        int pl;
        cmp = uri.getPath();
        idx = cmp.indexOf();
        if (idx == 1 && cmp.charAt(0) == '/') {
            cl = cmp.length();
            pl = .length();
            if (cl == 1 + .length() || cl == 1 + pl + 1 && cmp.charAt(cl - 1) == '/') {
                return true;
            }
        }
        return false;
    }
	private WebdavNode createChild(URI href) {
		String childPath;
		boolean dir;
		WebdavNode result;
        childPath = href.getPath();
		dir = childPath.endsWith("/");
		if (dir) {
		    childPath = childPath.substring(0, childPath.length() - 1);
		}
        childPath = Strings.removeLeft(childPath"/");
        if (!childPath.startsWith()) {
            throw new IllegalStateException();
        }
		result = new WebdavNode(childPathnulldir);
		return result;
	}
    public String getAttribute(String namethrows WebdavException {
    	Property result;
    	Name n;
    	n = new Name(name.);
        try {
            synchronized () {
            	try {
        		    result = getPropertyOpt(n);
        	    } catch (MovedException e) {
                     = !;
            		result = getPropertyOpt(n);
            	}
            }
        	return result == null ? null : (Stringresult.getValue();
catch (IOException e) {
			throw new WebdavException(thise);
		}
    }
    public void setAttribute(String nameString valuethrows WebdavException {
        try {
        	setProperty(new Name(name.), value);
catch (IOException e) {
			throw new WebdavException(thise);
		}
    }
    private void setProperty(Name nameString valuethrows IOException {
    	Property prop;
        prop = new Property(namevalue);
        synchronized () {
            try {
                new PropPatch(thisprop).invoke();
            } catch (MovedException e) {
                 = !;
                new PropPatch(thisprop).invoke();
            }
        }
    }

    

Returns:
never null
    private Property getProperty(Name namethrows IOException {
    	Property result;
        result = getPropertyOpt(name);
        if (result == null) {
            throw new IllegalStateException();
        }
        return result;
    }
    private Property getPropertyOpt(Name namethrows IOException {
        PropFind method;
        List<MultiStatusresponse;
        method = new PropFind(thisname, 0);
        response = method.invoke();
        return MultiStatus.lookupOne(responsename).;
    }
    private boolean tryDir(boolean tryTryDirthrows ExistsException {
        boolean reset;
        boolean result;
        synchronized () {
            reset = ;
             = tryTryDir;
            try {
                if (getRoot().getFilesystem().isDav()) {
                    result = doTryDirDav();
                } else {
                    result = doTryDirHttp();
                }
            } catch (MovedException e) {
                 = reset;
                return false;
            } catch (FileNotFoundException e) {
                 = reset;
                return false;
            } catch (IOException e) {
                 = reset;
                throw new ExistsException(thise);
            }
            if (!result) {
                 = reset;
            }
        }
        return result;
    }
    private boolean doTryDirDav() throws IOException {
        Property property;
        org.w3c.dom.Node node;
        property = getProperty(.);
        node = (org.w3c.dom.Nodeproperty.getValue();
        if (node == null) {
            return  == false;
        }
        return  == "collection".equals(node.getLocalName());
    }
    private boolean doTryDirHttp() throws IOException {
        try {
            new Head(this).invoke();
            return true;
        } catch (StatusException e2) {
            switch (e2.getStatusLine().getStatusCode()) {
                case .:
                    return false;
                case .:
                    return false;
                default:
                    throw e2;
            }
        }
    }
    //--

    
see http://tools.ietf.org/html/rfc2616#section-5.1.2
    public String getAbsPath() {
        StringBuilder builder;
        synchronized () {
            builder = new StringBuilder(.length() + 10);
            builder.append('/');
            if (!.isEmpty()) {
                try {
                    builder.append(new URI(nullnullnull).getRawPath());
                } catch (URISyntaxException e) {
                    throw new IllegalStateException();
                }
                if () {
                    builder.append('/');
                }
            }
            if ( != null) {
                builder.append('?');
                builder.append();
            }
        }
        return builder.toString();
    }
New to GrepCode? Check out our FAQ X