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.ssh;
 
 
 import java.net.URI;
 import java.util.List;
 
 public class SshNode extends Node {
     private final SshRoot root;
     private final String slashPath;
 
     public SshNode(SshRoot rootString path) {
         if (root == null) {
             throw new IllegalArgumentException();
         }
         this. = root;
         this. = "/" + path;
     }
 
     @Override
     public URI getURI() {
         try {
             return new URI(.getFilesystem().getScheme(), .getUser(), .getHost(), -1, nullnull);
         } catch (URISyntaxException e) {
             throw new IllegalStateException();
         }
     }
 
     @Override
     public SshRoot getRoot() {
         return ;
     }
 
     @Override
     public SshNode getParent() {
         return (SshNodedoGetParent();
     }
 
     @Override
     public SshNode join(String ... paths) {
         return (SshNodedoJoin(paths);
     }
 
     @Override
     public SshNode join(List<Stringpaths) {
         return (SshNodedoJoin(paths);
     }
 
     private static String escape(String str) {
         StringBuilder builder;
         int len;
         char c;
 
         builder = new StringBuilder();
         len = str.length();
         for (int i = 0; i < leni++) {
             c = str.charAt(i);
            switch (c) {
                case '*':
                case '?':
                case '\\':
                    builder.append('\\');
                    builder.append(c);
                    break;
                default:
                    builder.append(c);
                    // do nothing
            }
        }
        return builder.toString();
    }
    private static String unescape(String str) {
        StringBuilder builder;
        int len;
        char c;
        builder = new StringBuilder();
        len = str.length();
        for (int i = 0; i < leni++) {
            c = str.charAt(i);
            switch (c) {
                case '\\':
                    builder.append(str.charAt(++i));
                    break;
                default:
                    builder.append(c);
                    // do nothing
            }
        }
        return builder.toString();
    }
    @Override
    public long length() throws LengthException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                SftpATTRS attrs = sftp.stat(escape());
                if (attrs.isDir()) {
                    throw new LengthException(thisnew IOException("file expected"));
                }
                return attrs.getSize();
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new LengthException(thise);
        } catch (JSchException e) {
            throw new LengthException(thise);
        }
    }
    @Override
    public String getPath() {
        return .substring(1);
    }
    //--
    @Override
    public List<SshNodelist() throws ListException {
        List<SshNodenodes;
        ChannelSftp.LsEntry entry;
        String name;
        boolean dir;
        ChannelSftp sftp;
        try {
            nodes = new ArrayList<SshNode>();
            dir = false;
            sftp = alloc();
            try {
                for (Object obj : sftp.ls(escape())) {
                    try {
                        entry = (ChannelSftp.LsEntryobj;
                        name = entry.getFilename();
                        if (".".equals(name) || "..".equals(name)) {
                            dir = true;
                        } else {
                            nodes.add(join(name));
                        }
                    } catch (IllegalArgumentException e) {
                        throw new IllegalArgumentException("illegal name: " + obje);
                    }
                }
                if (!dir && nodes.size() == 1) {
                    return null;
                } else {
                    return nodes;
                }
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            if (e.id == 2) {
                throw new ListException(thisnew FileNotFoundException(getPath()));
            }
            throw new ListException(thise);
        } catch (JSchException e) {
            throw new ListException(thise);
        }
    }
    //--
    @Override
    public SshNode delete() throws DeleteException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
        } catch (JSchException e) {
            throw new DeleteException(thise);
        }
        try {
            doDelete(sftp);
        } finally {
            try {
                free(sftp);
            } catch (JSchException e) {
                throw new DeleteException(thise);
            }
        }
        return this;
    }
    private void doDelete(ChannelSftp sftpthrows DeleteException {
        SftpATTRS stat;
        try {
            // stat follows symlinks - lstat does *not*. Delete must *not* follow symlinks
            stat = sftp.lstat(escape());
            if (stat.isDir()) {
                for (SshNode child : list()) {
                    child.doDelete(sftp);
                }
                sftp.rmdir(escape());
            } else {
                sftp.rm(escape());
            }
        } catch (SftpException e) {
            if (e.id == . || e.id == .) {
                throw new DeleteException(thisnew FileNotFoundException());
            }
            throw new DeleteException(thise);
        } catch (ListException e) {
            throw new DeleteException(thise);
        }
    }
    @Override
    public Node move(Node destNodethrows MoveException {
        SshNode dest;
        ChannelSftp sftp;
        if (!(destNode instanceof SshNode)) {
            throw new MoveException(thisdestNode"target has is different node type");
        }
        dest = (SshNodedestNode;
        try {
            sftp = alloc();
            try {
                sftp.rename(escape(), escape(dest.slashPath));
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new MoveException(thisdest"ssh failure"e);
        } catch (JSchException e) {
            throw new MoveException(thisdest"ssh failure"e);
        }
        return dest;
    }
    @Override
    public Node mkdir() throws MkdirException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                sftp.mkdir(escape());
            } finally {
                free(sftp);
            }
            return this;
        } catch (SftpException e) {
            throw new MkdirException(thise);
        } catch (JSchException e) {
            throw new MkdirException(thise);
        }
    }
    private boolean noSuchFile(Exception ethrows ExistsException {
        if (e instanceof SftpException) {
            if (((SftpExceptione). == 2) {
                return false;
            }
        }
        throw new ExistsException(thise);
    }
    @Override
    public boolean exists() throws ExistsException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                // do not follow links!
                sftp.lstat(escape());
            } finally {
                free(sftp);
            }
            return true;
        } catch (SftpException e) {
            return noSuchFile(e);
        } catch (JSchException e) {
            return noSuchFile(e);
        }
    }
    @Override
    public boolean isFile() throws ExistsException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                // follow links!
                return !sftp.stat(escape()).isDir();
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            return noSuchFile(e);
        } catch (JSchException e) {
            return noSuchFile(e);
        }
    }
    @Override
    public boolean isDirectory() throws ExistsException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                // follow links!
                return sftp.stat(escape()).isDir();
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            return noSuchFile(e);
        } catch (JSchException e) {
            return noSuchFile(e);
        }
    }
    @Override
    public boolean isLink() throws ExistsException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                // CAUTION: use lstat to *not* follow symlinks
                return sftp.lstat(escape()).isLink();
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            return noSuchFile(e);
        } catch (JSchException e) {
            return noSuchFile(e);
        }
    }
    @Override
    public void mklink(String targetthrows LinkException {
        ChannelSftp sftp;
        try {
            checkNotExists();
            getParent().checkDirectory();
            sftp = alloc();
            try {
                sftp.symlink(targetescape());
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new LinkException(thise);
        } catch (JSchException e) {
            throw new LinkException(thise);
        } catch (IOException e) {
            throw new LinkException(thise);
        }
    }
    @Override
    public String readLink() throws ReadLinkException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                return sftp.readlink(escape());
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new ReadLinkException(thise);
        } catch (JSchException e) {
            throw new ReadLinkException(thise);
        }
    }
    @Override
    public long getLastModified() throws GetLastModifiedException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                return 1000L * sftp.stat(escape()).getMTime();
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new GetLastModifiedException(thise);
        } catch (JSchException e) {
            throw new GetLastModifiedException(thise);
        }
    }
    @Override
    public void setLastModified(long millisthrows SetLastModifiedException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                sftp.setMtime(escape(), (int) (millis / 1000));
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new SetLastModifiedException(thise);
        } catch (JSchException e) {
            throw new SetLastModifiedException(thise);
        }
    }
    @Override
    public int getMode() throws IOException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                return sftp.stat(escape()).getPermissions() & 0777;
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new IOException(e);
        } catch (JSchException e) {
            throw new IOException(e);
        }
    }
    @Override
    public void setMode(int modethrows IOException {
        SftpATTRS stat;
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                stat = sftp.stat(escape());
                stat.setPERMISSIONS(mode);
                sftp.setStat(escape(), stat);
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new IOException(e);
        } catch (JSchException e) {
            throw new IOException(e);
        }
    }
    @Override
    public int getUid() throws IOException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                return sftp.stat(escape()).getUId();
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new IOException(e);
        } catch (JSchException e) {
            throw new IOException(e);
        }
    }
    @Override
    public void setUid(int uidthrows IOException {
        String str;
        SftpATTRS stat;
        ChannelSftp sftp;
        try {
            if (isDirectory()) { // TODO
                str = getRoot().exec("chown", Integer.toString(uid), escape());
                if (str.length() > 0) {
                    throw new IOException("chown failed:" + str);
                }
            } else {
                sftp = alloc();
                try {
                    stat = sftp.stat(escape());
                    stat.setUIDGID(uidstat.getGId());
                    sftp.setStat(escape(), stat);
                } finally {
                    free(sftp);
                }
            }
        } catch (JSchException e) {
            throw new IOException(e);
        } catch (SftpException e) {
            throw new IOException(e);
        }
    }
    @Override
    public int getGid() throws IOException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                return sftp.stat(escape()).getGId();
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            throw new IOException(e);
        } catch (JSchException e) {
            throw new IOException(e);
        }
    }
    @Override
    public void setGid(int gidthrows IOException {
        String str;
        SftpATTRS stat;
        ChannelSftp sftp;
        try {
            if (isDirectory()) { // TODO
                str = getRoot().exec("chgrp", Integer.toString(gid), );
                if (str.length() > 0) {
                    throw new IOException("chgrp failed:" + str);
                }
            } else {
                sftp = alloc();
                try {
                    stat = sftp.stat(escape());
                    stat.setUIDGID(stat.getUId(), gid);
                    sftp.setStat(escape(), stat);
                } finally {
                    free(sftp);
                }
            }
        } catch (JSchException e) {
            throw new IOException(e);
        } catch (SftpException e) {
            throw new IOException(e);
        }
    }
    @Override
    public byte[] readBytes() throws IOException {
        ByteArrayOutputStream out;
        out = new ByteArrayOutputStream();
        get(out);
        return out.toByteArray();
    }
    @Override
    public InputStream createInputStream() throws IOException {
        final FileNode tmp;
        OutputStream out;
        tmp = getWorld().getTemp().createTempFile();
        out = tmp.createOutputStream();
        get(out);
        out.close();
        return new FilterInputStream(tmp.createInputStream()) {
            @Override
            public void close() throws IOException {
                super.close();
                // opt because it may be closed twice:
                tmp.deleteOpt();
            }
        };
    }
    @Override
    public OutputStream createOutputStream(final boolean appendthrows IOException {
        return new CheckedByteArrayOutputStream() {
            @Override
            public void close() throws IOException {
                super.close();
                try {
                    put(toByteArray(), append);
                } catch (JSchException e) {
                    throw new IOException(e);
                } catch (SftpException e) {
                    throw new IOException(e);
                }
            }
        };
    }

    
This is the core funktion to get a file.

Throws:
java.io.FileNotFoundException if this is not a file
    public void get(OutputStream outthrows IOException {
        ChannelSftp sftp;
        try {
            sftp = alloc();
            try {
                sftp.get(escape(), out);
            } finally {
                free(sftp);
            }
        } catch (SftpException e) {
            if (e.id == 2 || e.id == 4) {
                throw new FileNotFoundException(getPath());
            }
            throw new IOException(e);
        } catch (JSchException e) {
            throw new IOException(e);
        }
    }
    public void put(final byte[] datathrows JSchExceptionSftpException {
        put(datafalse);
    }
    public void put(final byte[] databoolean appendthrows JSchExceptionSftpException {
        ChannelSftp sftp;
        sftp = alloc();
        try {
            sftp.put(new ByteArrayInputStream(data), escape(), append ? . : .);
        } finally {
            free(sftp);
        }
    }
    //-- convenience
    private ChannelSftp alloc() throws JSchException {
        return .allocateChannelSftp();
    }
    private void free(ChannelSftp channelthrows JSchException {
        .freeChannelSftp(channel);
    }
New to GrepCode? Check out our FAQ X