// {{{ maybeReloadDirectory() method
public void maybeReloadDirectory(String path) {
String browserDir = browser.getDirectory();
String symlinkBrowserDir;
if (MiscUtilities.isURL(browserDir)) {
symlinkBrowserDir = browserDir;
} else {
symlinkBrowserDir = MiscUtilities.resolveSymlinks(browserDir);
}
if (MiscUtilities.pathsEqual(path, symlinkBrowserDir)) {
saveExpansionState();
loadDirectory(null, browserDir, false);
}
// because this method is called for *every* VFS update,
// we don't want to scan the tree all the time. So we
// use the following algorithm to determine if the path
// might be part of the tree:
// - if the path starts with the browser's current directory,
// we do the tree scan
// - if the browser's directory is 'favorites:' -- we have to
// do the tree scan, as every path can appear under the
// favorites list
// - if the browser's directory is 'roots:' and path is on
// the local filesystem, do a tree scan
if (!browserDir.startsWith(FavoritesVFS.PROTOCOL)
&& !browserDir.startsWith(FileRootsVFS.PROTOCOL)
&& !path.startsWith(symlinkBrowserDir)) return;
if (browserDir.startsWith(FileRootsVFS.PROTOCOL)
&& MiscUtilities.isURL(path)
&& !"file".equals(MiscUtilities.getProtocolOfURL(path))) return;
table.maybeReloadDirectory(path);
} // }}}
// {{{ recursive listFiles() method
private void listFiles(
Object session,
Collection<String> stack,
List<String> files,
String directory,
VFSFileFilter filter,
boolean recursive,
Component comp,
boolean skipBinary,
boolean skipHidden)
throws IOException {
String resolvedPath = directory;
if (recursive && !MiscUtilities.isURL(directory)) {
resolvedPath = MiscUtilities.resolveSymlinks(directory);
/*
* If looking at a symlink, do not traverse the
* resolved path more than once.
*/
if (!directory.equals(resolvedPath)) {
if (stack.contains(resolvedPath)) {
Log.log(Log.ERROR, this, "Recursion in listFiles(): " + directory);
return;
}
stack.add(resolvedPath);
}
}
Thread ct = Thread.currentThread();
WorkThread wt = null;
if (ct instanceof WorkThread) {
wt = (WorkThread) ct;
}
VFSFile[] _files = _listFiles(session, directory, comp);
if (_files == null || _files.length == 0) return;
for (int i = 0; i < _files.length; i++) {
if (wt != null && wt.isAborted()) break;
VFSFile file = _files[i];
if (skipHidden && (file.isHidden() || MiscUtilities.isBackup(file.getName()))) continue;
if (!filter.accept(file)) continue;
if (file.getType() == VFSFile.DIRECTORY || file.getType() == VFSFile.FILESYSTEM) {
if (recursive) {
String canonPath = _canonPath(session, file.getPath(), comp);
listFiles(
session, stack, files, canonPath, filter, recursive, comp, skipBinary, skipHidden);
}
} else // It's a regular file
{
if (skipBinary) {
try {
if (file.isBinary(session)) {
Log.log(Log.NOTICE, this, file.getPath() + ": skipped as a binary file");
continue;
}
} catch (IOException e) {
Log.log(Log.ERROR, this, e);
// may be not binary...
}
}
files.add(file.getPath());
}
}
} // }}}
// {{{ run() method
public void run() {
/* if the VFS supports renaming files, we first
* save to #<filename>#save#, then rename that
* to <filename>, so that if the save fails,
* data will not be lost.
*
* as of 4.1pre7 we now call vfs.getTwoStageSaveName()
* instead of constructing the path directly
* since some VFS's might not allow # in filenames.
*/
boolean vfsRenameCap = (vfs.getCapabilities() & VFS.RENAME_CAP) != 0;
boolean wantTwoStage = wantTwoStageSave(buffer);
boolean twoStageSave = vfsRenameCap && wantTwoStage;
try {
String[] args = {vfs.getFileName(path)};
setStatus(jEdit.getProperty("vfs.status.save", args));
// the entire save operation can be aborted...
setAbortable(true);
path = vfs._canonPath(session, path, view);
if (!MiscUtilities.isURL(path)) path = MiscUtilities.resolveSymlinks(path);
String savePath;
if (twoStageSave) {
savePath = vfs.getTwoStageSaveName(path);
if (savePath == null) {
throw new IOException("Can't get a temporary path for two-stage save: " + path);
}
} else {
makeBackup();
savePath = path;
}
OutputStream out = vfs._createOutputStream(session, savePath, view);
if (out == null) {
buffer.setBooleanProperty(ERROR_OCCURRED, true);
return;
}
try {
// this must be after the stream is created or
// we deadlock with SSHTools.
buffer.readLock();
try {
// Can't use buffer.getName() here because
// it is not changed until the save is
// complete
if (path.endsWith(".gz")) buffer.setBooleanProperty(Buffer.GZIPPED, true);
else if (buffer.getName().endsWith(".gz")) {
// The path do not ends with gz.
// The buffer name was .gz.
// So it means it's blabla.txt.gz -> blabla.txt, I remove
// the gz property
buffer.setBooleanProperty(Buffer.GZIPPED, false);
}
if (buffer.getBooleanProperty(Buffer.GZIPPED)) out = new GZIPOutputStream(out);
write(buffer, out);
} finally {
buffer.readUnlock();
}
} finally {
IOUtilities.closeQuietly(out);
}
if (twoStageSave) {
makeBackup();
if (!vfs._rename(session, savePath, path, view))
throw new IOException("Rename failed: " + savePath);
}
if (!twoStageSave) VFSManager.sendVFSUpdate(vfs, path, true);
} catch (FileNotFoundException e) {
Log.log(Log.ERROR, this, "Unable to save buffer " + e);
String[] pp = {e.getMessage()};
VFSManager.error(view, path, "ioerror.write-error", pp);
buffer.setBooleanProperty(ERROR_OCCURRED, true);
} catch (UnsupportedCharsetException e) {
Log.log(Log.ERROR, this, e, e);
String[] pp = {e.getCharsetName()};
VFSManager.error(view, path, "ioerror.unsupported-encoding-error", pp);
buffer.setBooleanProperty(ERROR_OCCURRED, true);
} catch (Exception e) {
Log.log(Log.ERROR, this, e);
String[] pp = {e.toString()};
VFSManager.error(view, path, "ioerror.write-error", pp);
buffer.setBooleanProperty(ERROR_OCCURRED, true);
} catch (WorkThread.Abort a) {
buffer.setBooleanProperty(ERROR_OCCURRED, true);
} finally {
try {
vfs._saveComplete(session, buffer, path, view);
if (twoStageSave) {
vfs._finishTwoStageSave(session, buffer, path, view);
}
// clean up left-over markers file
if (!jEdit.getBooleanProperty("persistentMarkers"))
vfs._delete(session, Buffer.getMarkersPath(vfs, path), view);
vfs._endVFSSession(session, view);
} catch (Exception e) {
Log.log(Log.ERROR, this, e);
String[] pp = {e.toString()};
VFSManager.error(view, path, "ioerror.write-error", pp);
buffer.setBooleanProperty(ERROR_OCCURRED, true);
} catch (WorkThread.Abort a) {
buffer.setBooleanProperty(ERROR_OCCURRED, true);
}
}
} // }}}
// {{{ equals() method
public boolean equals(Object compareObj) {
if (!(compareObj instanceof HyperSearchFileNode)) return false;
HyperSearchFileNode otherResult = (HyperSearchFileNode) compareObj;
return path.equals(MiscUtilities.resolveSymlinks(otherResult.path));
} // }}}