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.util.List;
 
 public class WebdavRoot implements Root<WebdavNode> {
     private final WebdavFilesystem filesystem;
     public final HttpHost host;
     private final HttpParams params;
     private String authorization;
 
     public WebdavRoot(WebdavFilesystem filesystemString protocolString hostint port) {
         this. = filesystem;
         this. = new HttpHost(hostportprotocol);
         this. = null;
         this. = new BasicHttpParams();
 
         HttpProtocolParams.setVersion(.);
         HttpProtocolParams.setContentCharset(.);
     }
 
     public void setUserInfo(String userinfo) {
         int idx;
 
         idx = userinfo.indexOf(':');
         if (idx == -1) {
             setCredentials(userinfo"");
         } else {
             setCredentials(userinfo.substring(0, idx), userinfo.substring(idx + 1));
         }
     }
 
     public void setCredentials(String usernameString password) {
     	 = "Basic " + new Base64(true).run(username + ":" + password);
     }
 
     public int getConnectionTimeout() {
         return HttpConnectionParams.getConnectionTimeout();
     }
 
     public void setConnectionTimeout(int millis) {
         HttpConnectionParams.setSoTimeout(millis);
     }
 
     public int getSoTimeout() {
         return HttpConnectionParams.getSoTimeout();
     }
 
     public void setSoTimeout(int millis) {
         HttpConnectionParams.setSoTimeout(millis);
     }
 
     @Override
     public boolean equals(Object obj) {
         WebdavRoot root;
 
         if (obj instanceof WebdavRoot) {
             root = (WebdavRootobj;
             return  == root.filesystem /* TODO params etc */;
         }
         return false;
     }
    @Override
    public int hashCode() {
        return .hashCode();
    }
    public WebdavFilesystem getFilesystem() {
        return ;
    }
    public String getId() {
        int port;
        port = .getPort();
        // TODO: credentials?
        return "//" + .getHostName() + (port == 80 ? "" : ":" + port) + "/";
    }
    public WebdavNode node(String pathString encodedQuery) {
        return new WebdavNode(thispathencodedQueryfalse);
    }
    private final List<WebdavConnectionpool = new ArrayList<WebdavConnection>();
    private int allocated = 0;
    public synchronized WebdavConnection allocate() throws IOException {
        int size;
        ++;
        size = .size();
        if (size > 0) {
            return .remove(size - 1);
        } else {
        	Socket socket;
            if ("https".equals(.getSchemeName())) {
                socket = SSLSocketFactory.getDefault().createSocket(.getHostName(), .getPort());
            } else {
                socket = new Socket(.getHostName(), .getPort());
            }
            return WebdavConnection.open(socket);
        }
    }
    public synchronized void free(HttpResponse responseWebdavConnection connectionthrows IOException {
        HttpEntity entity;
        if ( == 0) {
            throw new IllegalStateException();
        }
        --;
        if (response != null) {
            entity = response.getEntity();
            if (entity != null) {
                entity.consumeContent();
            }
        }
        if (wantsClose(response)) {
            connection.close();
        }
        if (connection.isOpen() && .size() < 10) {
            .add(connection);
        }
    }
    public synchronized int getAllocated() {
        return ;
    }
    private static boolean wantsClose(HttpResponse response) {
        if (response == null) {
            // no response yet
            return true;
        }
        for (Header header : response.getHeaders(.)) {
            if ("close".equalsIgnoreCase(header.getValue())) {
                return true;
            }
        }
        return false;
    }
    //--
    public void send(WebdavConnection connHttpRequest requestthrows IOException {
        // TODO: side effect
        request.addHeader(..getHostName());
        if ( != null) {
            request.addHeader("Authorization");
        }
        // TODO: request.addHeader("Keep-Alive", "300");
        try {
            conn.sendRequestHeader(request);
            if (request instanceof HttpEntityEnclosingRequest) {
                conn.sendRequestEntity((HttpEntityEnclosingRequestrequest);
            }
            conn.flush();
        } catch (IOException e) {
            free(nullconn);
            throw e;
        } catch (HttpException e) {
            free(nullconn);
            // TODO
          	throw new IOException(e);
        } catch (RuntimeException e) {
            free(nullconn);
            throw e;
        }
    }
    public HttpResponse receive(WebdavConnection connboolean headthrows IOException {
        HttpResponse response;
        int statuscode;
        response = null;
        try {
            do {
                response = conn.receiveResponseHeader();
                if (canResponseHaveBody(responsehead)) {
                    conn.receiveResponseEntity(response);
                }
                statuscode = response.getStatusLine().getStatusCode();
            } while (response == null || statuscode < .);
            return response;
        } catch (IOException e) {
            free(responseconn);
            throw e;
        } catch (HttpException e) {
            free(responseconn);
            // TODO
          	throw new IOException(e);
        } catch (RuntimeException e) {
            free(responseconn);
            throw e;
        }
    }
    private boolean canResponseHaveBody(HttpResponse responseboolean head) {
        int status;
        status = response.getStatusLine().getStatusCode();
        if (status == . && head) {
            return false;
        }
        return status >= .
            && status != .
            && status != .
            && status != .;
    }
New to GrepCode? Check out our FAQ X