rse/plugins/org.eclipse.dltk.ssh.core/src/org/eclipse/dltk/ssh/internal/core/SshFileHandle.java

package org.eclipse.dltk.ssh.internal.core;

import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.dltk.ssh.core.ISshFileHandle;

import com.jcraft.jsch.SftpATTRS;
import com.jcraft.jsch.ChannelSftp.LsEntry;

public class SshFileHandle implements ISshFileHandle,
		IOutputStreamCloseListener {
	private static final int CACHE_LIMIT = 1000;

	private static class CacheEntry {
		final SftpATTRS attrs;
		final long lastAccess;

		public CacheEntry(SftpATTRS attrs, long lastAccess) {
			this.attrs = attrs;
			this.lastAccess = lastAccess;
		}

	}

	private static final Map<SshFileHandle, CacheEntry> attrCache = new HashMap<SshFileHandle, CacheEntry>();

	private SshConnection connection = null;
	private IPath path;
	// private IPath linkTarget;
	private SftpATTRS attrs;
	private Map<String, SshFileHandle> children = new HashMap<String, SshFileHandle>();
	private boolean childrenFetched = false;

	public SshFileHandle(SshConnection connection, IPath path, SftpATTRS attrs) {
		this.connection = connection;
		this.path = path;
		this.attrs = attrs;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.dltk.ssh.internal.core.ISshFileHandle#createFolder(java.lang
	 * .String, org.eclipse.core.runtime.IProgressMonitor)
	 */
	public ISshFileHandle createFolder(String newEntryName,
			IProgressMonitor monitor) throws CoreException {
		ISshFileHandle child = getChild(newEntryName);
		if (child != null) {
			child.mkdir();
			fetchAttrs();
		}
		return child;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.dltk.ssh.internal.core.ISshFileHandle#mkdir()
	 */
	public void mkdir() {
		connection.mkdir(path);
		cleanAttrs();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.dltk.ssh.internal.core.ISshFileHandle#delete()
	 */
	public void delete() throws CoreException {
		fetchAttrs();
		if (attrs != null) {
			connection.delete(path, attrs.isDir());
			cleanAttrs();
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.dltk.ssh.internal.core.ISshFileHandle#exists()
	 */
	public boolean exists() {
		fetchAttrs();
		return attrs != null;
	}

	private void fetchAttrs() {
		fetchAttrs(false);
	}

	private void cleanAttrs() {
		attrs = null;
		synchronized (attrCache) {
			attrCache.remove(this);
		}
	}

	private void fetchAttrs(boolean clean) {
		if (attrs == null || clean) {
			attrs = fetchCacheAttrs(clean);
		}
		if (attrs != null && attrs.isLink()) {
			attrs = fetchCacheAttrs(true);
			// this.linkTarget = connection.getResolvedPath(path);
		}
	}

	private SftpATTRS fetchCacheAttrs(boolean clean) {
		long c = 0;
		synchronized (attrCache) {
			if (attrCache.size() > CACHE_LIMIT) {
				attrCache.clear();
			} else if (!clean) {
				final CacheEntry entry = attrCache.get(this);
				if (entry != null) {
					c = System.currentTimeMillis();
					if ((c - entry.lastAccess) < 1000 * 10) {
						return entry.attrs;
					}
				}
			}
		}
		SftpATTRS attrs = connection.getAttrs(path);
		if (c == 0) {
			c = System.currentTimeMillis();
		}
		synchronized (attrCache) {
			attrCache.put(this, new CacheEntry(attrs, c));
		}
		return attrs;
	}

	public synchronized ISshFileHandle getChild(String newEntryName) {
		if (children.containsKey(newEntryName)) {
			return children.get(newEntryName);
		}
		ISshFileHandle child = new SshFileHandle(connection, path
				.append(newEntryName), null);
		return child;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.dltk.ssh.internal.core.ISshFileHandle#getChildren(org.eclipse
	 * .core.runtime.IProgressMonitor)
	 */
	public synchronized ISshFileHandle[] getChildren(IProgressMonitor monitor)
			throws CoreException {
		if (!childrenFetched) {
			// Fetch all child handles
			fetchChildren();
		}
		return children.values().toArray(new SshFileHandle[children.size()]);
	}

	private void fetchChildren() {
		Vector<LsEntry> list = connection.list(path);
		if (list != null) {
			children.clear();
			long c = System.currentTimeMillis();
			for (LsEntry entry : list) {
				String filename = entry.getFilename();
				if (filename.equals(".") || filename.equals("..")) { //$NON-NLS-1$ //$NON-NLS-2$
					continue;
				}
				final SftpATTRS childAttrs = entry.getAttrs();
				final IPath childPath;
				if (filename.indexOf(IPath.DEVICE_SEPARATOR) == -1) {
					childPath = path.append(filename);
				} else {
					// this way DEVICE_SEPARATOR is kept in path segment
					childPath = path.append(new Path(null, filename));
				}
				SshFileHandle childHandle = new SshFileHandle(connection,
						childPath, childAttrs);
				synchronized (attrCache) {
					attrCache.put(childHandle, new CacheEntry(childAttrs, c));
				}
				children.put(filename, childHandle);
			}
			childrenFetched = true;
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.dltk.ssh.internal.core.ISshFileHandle#getInputStream(org.
	 * eclipse.core.runtime.IProgressMonitor)
	 */
	public InputStream getInputStream(IProgressMonitor monitor)
			throws CoreException {
		// fetchAttrs();
		// if (attrs != null) {
		// IPath current = this.path;
		// if (attrs.isLink() && linkTarget != null) {
		// current = linkTarget;
		// }
		final InputStream stream = connection.get(this.path);
		// TODO throw/wrap original exception?
		return stream;
		// }
		// return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.dltk.ssh.internal.core.ISshFileHandle#getName()
	 */
	public String getName() {
		return path.lastSegment();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.dltk.ssh.core.ISshFileHandle#getPath()
	 */
	public IPath getPath() {
		return path;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return path.toString();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.dltk.ssh.internal.core.ISshFileHandle#getOutputStream(org
	 * .eclipse.core.runtime.IProgressMonitor)
	 */
	public OutputStream getOutputStream(IProgressMonitor monitor)
			throws CoreException {
		final OutputStream stream = connection.put(this.path, this);
		return stream;
	}

	public void streamClosed() {
		cleanAttrs();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.dltk.ssh.internal.core.ISshFileHandle#isDirectory()
	 */
	public boolean isDirectory() {
		fetchAttrs();
		if (attrs != null) {
			return attrs.isDir();
		} else {
			// IStatus status = new Status(IStatus.ERROR, "blah",
			// "Failed to retrive file information:" + path);
			// throw new CoreException(status);
			return false;
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.dltk.ssh.internal.core.ISshFileHandle#lastModificationTime()
	 */
	public long lastModificationTime() {
		fetchAttrs();
		if (attrs != null) {
			return attrs.getMTime() * 1000L;
		} else {
			// IStatus status = new Status(IStatus.ERROR, "blah",
			// "Failed to retrive file information:" + path);
			// throw new CoreException(status);
			return 0;
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see
	 * org.eclipse.dltk.ssh.internal.core.ISshFileHandle#setLastModified(long,
	 * org.eclipse.core.runtime.IProgressMonitor)
	 */
	public void setLastModified(long timestamp, IProgressMonitor monitor)
			throws CoreException {
		connection.setLastModified(path, timestamp);
		cleanAttrs();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.dltk.ssh.internal.core.ISshFileHandle#getSize()
	 */
	public long getSize() {
		fetchAttrs();
		if (attrs != null) {
			return attrs.getSize();
		}
		return 0;
	}

	public boolean isSymlink() {
		final SftpATTRS attrs = connection.getLAttrs(path);
		return attrs != null && attrs.isLink();
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result
				+ ((connection == null) ? 0 : connection.hashCode());
		result = prime * result + ((path == null) ? 0 : path.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		SshFileHandle other = (SshFileHandle) obj;
		if (connection == null) {
			if (other.connection != null)
				return false;
		} else if (!connection.equals(other.connection))
			return false;
		if (path == null) {
			if (other.path != null)
				return false;
		} else if (!path.equals(other.path))
			return false;
		return true;
	}

	public String readLink() {
		return connection.readLink(path);
	}

	public void move(IPath destination) throws CoreException {
		connection.move(path, destination);
	}
}