/*******************************************************************************
* Copyright (c) 2008, 2017 xored software, Inc. and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* xored software, Inc. - initial API and Implementation (Andrei Sobolev)
*******************************************************************************/
package org.eclipse.dltk.core.internal.rse;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileInfo;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.RuntimePerformanceMonitor;
import org.eclipse.dltk.core.RuntimePerformanceMonitor.PerformanceNode;
import org.eclipse.dltk.core.environment.EnvironmentPathUtils;
import org.eclipse.dltk.core.environment.FileHandles;
import org.eclipse.dltk.core.environment.IEnvironment;
import org.eclipse.dltk.core.environment.IFileHandle;
import org.eclipse.dltk.core.environment.IFileStoreProvider;
import org.eclipse.dltk.core.internal.rse.perfomance.RSEPerfomanceStatistics;
import org.eclipse.dltk.core.internal.rse.ssh.RSESshManager;
import org.eclipse.dltk.ssh.core.ISshConnection;
import org.eclipse.dltk.ssh.core.ISshFileHandle;
import org.eclipse.rse.core.model.IHost;
public class RSEFileHandle implements IFileHandle, IFileStoreProvider {
private static final int SYMLINK_CONNECTION_TIMEOUT = 30 * 1000;
private static final int CACHE_LIMIT = 1000;
private static final long CACHE_ENTRY_LIFETIME = 10 * 1000;
private static class CacheEntry {
final IFileInfo fileInfo;
final long timestamp;
public CacheEntry(IFileInfo fileInfo, long timestamp) {
this.fileInfo = fileInfo;
this.timestamp = timestamp;
}
}
private static final Map<IFileStore, CacheEntry> cache = new HashMap<>();
private final IFileStore file;
private final IEnvironment environment;
private ISshFileHandle sshFile;
/**
* @param infos
* @since 2.0
*/
public RSEFileHandle(IEnvironment env, IFileStore file) {
this.environment = env;
this.file = file;
}
private void fetchSshFile() {
if (sshFile != null) {
return;
}
if (environment instanceof RSEEnvironment) {
RSEEnvironment rseEnv = (RSEEnvironment) environment;
IHost host = rseEnv.getHost();
ISshConnection connection = RSESshManager.getConnection(host);
if (connection != null) { // This is ssh connection, and it's alive.
try {
sshFile = connection.getHandle(new Path(getPathString()));
} catch (Exception e) {
DLTKRSEPlugin.log("Failed to locate direct ssh connection", //$NON-NLS-1$
e);
}
}
}
}
/**
* @since 2.0
*/
public RSEFileHandle(IEnvironment env, IFileStore file,
ISshFileHandle sshFile) {
this.environment = env;
this.file = file;
this.sshFile = sshFile;
}
public RSEFileHandle(IEnvironment env, URI locationURI) {
this(env, RSEEnvironment.getStoreFor(locationURI));
}
@Override
public boolean exists() {
if (!environment.connect()) {
return false;
}
fetchSshFile();
if (sshFile != null) {
return sshFile.exists();
}
try {
return fetchInfo(false).exists();
} catch (RuntimeException e) {
return false;
}
}
private IFileInfo fetchInfo(boolean force) {
final boolean isRemote = !environment.isLocal();
long now = 0;
if (isRemote && !force) {
CacheEntry entry;
synchronized (cache) {
entry = cache.get(getCacheKey());
}
if (entry != null) {
now = System.currentTimeMillis();
if (now - entry.timestamp < CACHE_ENTRY_LIFETIME) {
return entry.fileInfo;
}
}
}
final IFileInfo info = file.fetchInfo();
if (isRemote) {
if (now == 0) {
now = System.currentTimeMillis();
}
synchronized (cache) {
checkCacheLimit();
cache.put(getCacheKey(), new CacheEntry(info, now));
}
}
return info;
}
private static void checkCacheLimit() {
if (cache.size() > CACHE_LIMIT) {
cache.clear();
}
}
/**
* @return
*/
private final IFileStore getCacheKey() {
return file;
}
@Override
public String toOSString() {
return this.environment.convertPathToString(getPath());
}
@Override
public String getCanonicalPath() {
return this.environment.getCanonicalPath(getPath());
}
@Override
public IFileHandle getChild(final String childname) {
if (!environment.connect()) {
URI childURI;
try {
childURI = new URI(toURI().toString() + "/" + childname); //$NON-NLS-1$
return new RSEFileHandle(environment, childURI);
} catch (URISyntaxException e) {
DLTKRSEPlugin.log(e);
}
}
fetchSshFile();
IFileStore childStore = file.getChild(childname);
if (sshFile != null) {
return new RSEFileHandle(environment, childStore, sshFile
.getChild(childname));
}
return new RSEFileHandle(environment, childStore);
}
@Override
public IFileHandle[] getChildren() {
if (!environment.connect()) {
return null;
}
fetchSshFile();
if (sshFile != null) {
try {
final ISshFileHandle[] children = sshFile
.getChildren(new NullProgressMonitor());
final IFileHandle rseChildren[] = new IFileHandle[children.length];
for (int i = 0; i < children.length; i++) {
final ISshFileHandle child = children[i];
final IFileStore childStore = file
.getChild(child.getName());
rseChildren[i] = new RSEFileHandle(environment, childStore,
child);
}
return rseChildren;
} catch (CoreException e) {
DLTKRSEPlugin.log(e);
}
}
try {
final IFileInfo[] infos = file.childInfos(EFS.NONE,
new NullProgressMonitor());
if (infos.length != 0) {
synchronized (cache) {
checkCacheLimit();
}
}
final IFileHandle[] children = new IFileHandle[infos.length];
final long now = System.currentTimeMillis();
for (int i = 0; i < infos.length; i++) {
final IFileInfo childInfo = infos[i];
children[i] = new RSEFileHandle(environment, file
.getChild(childInfo.getName()));
final IFileStore childCacheKey = ((RSEFileHandle) children[i])
.getCacheKey();
synchronized (cache) {
cache.put(childCacheKey, new CacheEntry(childInfo, now));
}
}
return children;
} catch (CoreException e) {
if (DLTKCore.DEBUG)
e.printStackTrace();
return null;
}
}
@Override
public IEnvironment getEnvironment() {
return environment;
}
@Override
public URI toURI() {
return file.toURI();
}
@Override
public String getName() {
return file.getName();
}
@Override
public IFileHandle getParent() {
IFileStore parent = file.getParent();
if (parent == null)
return null;
return new RSEFileHandle(environment, parent);
}
@Override
public IPath getPath() {
return new Path(getPathString());
}
private String getPathString() {
return file.toURI().getPath();
}
@Override
public boolean isDirectory() {
if (!environment.connect()) {
return false;
}
fetchSshFile();
if (sshFile != null) {
return sshFile.isDirectory();
}
return fetchInfo(false).isDirectory();
}
@Override
public boolean isFile() {
if (!environment.connect()) {
return false;
}
fetchSshFile();
if (sshFile != null) {
return sshFile.exists() && !sshFile.isDirectory();
}
final IFileInfo info = fetchInfo(false);
return info.exists() && !info.isDirectory();
}
@Override
public boolean isSymlink() {
if (!environment.connect()) {
return false;
}
fetchSshFileWait();
if (sshFile != null) {
return sshFile.isSymlink();
}
return fetchInfo(false).getAttribute(EFS.ATTRIBUTE_SYMLINK);
}
private void fetchSshFileWait() {
final long startTime = System.currentTimeMillis();
while (sshFile == null
&& (System.currentTimeMillis() - startTime < SYMLINK_CONNECTION_TIMEOUT)) {
fetchSshFile();
try {
Thread.sleep(50);
} catch (InterruptedException e) {
if (DLTKCore.DEBUG) {
e.printStackTrace();
}
}
}
}
private InputStream internalOpenInputStream(IProgressMonitor monitor)
throws IOException {
if (!environment.connect()) {
return null;
}
fetchSshFile();
if (sshFile != null) {
try {
return sshFile.getInputStream(monitor);
} catch (CoreException e) {
throw new IOException(e.getLocalizedMessage());
}
}
try {
return file.openInputStream(EFS.NONE, monitor);
} catch (CoreException e) {
if (DLTKCore.DEBUG)
e.printStackTrace();
throw new IOException(e.getLocalizedMessage());
}
}
@Override
public InputStream openInputStream(IProgressMonitor monitor)
throws IOException {
if (!environment.connect()) {
return null;
}
if (RSEPerfomanceStatistics.PERFOMANCE_TRACING) {
return new CountStream(this.internalOpenInputStream(monitor));
}
return this.internalOpenInputStream(monitor);
}
@Override
public OutputStream openOutputStream(IProgressMonitor monitor)
throws IOException {
if (!environment.connect()) {
return null;
}
synchronized (cache) {
cache.clear();
}
fetchSshFile();
if (sshFile != null) {
try {
return sshFile.getOutputStream(monitor);
} catch (CoreException e) {
throw new IOException(e.getLocalizedMessage());
}
}
try {
return new BufferedOutputStream(file.openOutputStream(EFS.NONE,
monitor)) {
@Override
public void close() throws IOException {
super.close();
clearLastModifiedCache();
}
};
} catch (CoreException e) {
if (DLTKCore.DEBUG)
e.printStackTrace();
throw new IOException(e.getLocalizedMessage());
}
}
@Override
public boolean equals(Object obj) {
if (obj instanceof RSEFileHandle) {
RSEFileHandle anotherFile = (RSEFileHandle) obj;
return this.file.equals(anotherFile.file);
}
return false;
}
@Override
public int hashCode() {
return file.hashCode();
}
@Override
public String toString() {
return toOSString();
}
@Override
public long lastModified() {
if (!environment.connect()) {
return 0;
}
fetchSshFile();
PerformanceNode p = RuntimePerformanceMonitor.begin();
long lm = 0;
if (sshFile != null) {
lm = sshFile.lastModificationTime();
} else {
lm = fetchInfo(false).getLastModified();
}
p.done("#", "Return file timestamp", 0); //$NON-NLS-1$//$NON-NLS-2$
return lm;
}
@Override
public long length() {
if (!environment.connect()) {
return 0;
}
fetchSshFile();
if (sshFile != null) {
return sshFile.getSize();
}
return fetchInfo(false).getLength();
}
@Override
public IPath getFullPath() {
return EnvironmentPathUtils.getFullPath(environment, getPath());
}
@Override
public String getEnvironmentId() {
return environment.getId();
}
private static final class CountStream extends BufferedInputStream {
private InputStream stream;
public CountStream(InputStream stream) {
super(stream);
}
@Override
public int read() throws IOException {
int read = stream.read();
if (read != -1) {
RSEPerfomanceStatistics
.inc(RSEPerfomanceStatistics.TOTAL_BYTES_RECEIVED);
}
return read;
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
int read = this.stream.read(b, off, len);
if (read != -1) {
RSEPerfomanceStatistics.inc(
RSEPerfomanceStatistics.TOTAL_BYTES_RECEIVED, read);
}
return read;
}
@Override
public int read(byte[] b) throws IOException {
int read = this.stream.read(b);
if (read != -1) {
RSEPerfomanceStatistics.inc(
RSEPerfomanceStatistics.TOTAL_BYTES_RECEIVED, read);
}
return read;
}
}
/**
* @since 2.0
*/
@Override
public IFileStore getFileStore() {
return this.file;
}
/**
* Removes saved timestamp for this element.
*
* @since 2.0
*/
public void clearLastModifiedCache() {
synchronized (cache) {
cache.remove(getCacheKey());
}
}
/**
* @since 2.0
*/
public String resolvePath() {
final String currentPath = getPathString();
if (environment.connect() && isSymlink()) {
// Try to resolve canonical path using direct ssh connection
if (sshFile != null) {
final String link = sshFile.readLink();
if (link != null) {
if (link.startsWith("/")) { //$NON-NLS-1$
if (!link.equals(currentPath)) {
return environment.getFile(new Path(link))
.getCanonicalPath();
}
} else {
final IPath fullLink = getPath().removeLastSegments(1)
.append(link);
if (!currentPath.equals(fullLink.toString())) {
return environment.getFile(fullLink)
.getCanonicalPath();
}
}
}
} else {
final IFileInfo info = file.fetchInfo();
if (info != null && info.getAttribute(EFS.ATTRIBUTE_SYMLINK)) {
final String linkTarget = info
.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET);
if (linkTarget != null && !currentPath.equals(linkTarget)) {
final Path link = new Path(linkTarget);
final IFileStore resolved;
if (link.isAbsolute()) {
resolved = file.getFileSystem().getStore(link);
} else {
resolved = file.getFileStore(link);
}
return resolved.toURI().getPath();
}
}
}
}
return currentPath;
}
@Override
public void move(IFileHandle destination) throws CoreException {
fetchSshFile();
if (sshFile != null) {
sshFile.move(FileHandles.asPath(destination, environment));
} else {
file
.move(FileHandles.asFileStore(destination), EFS.OVERWRITE,
null);
}
}
}