Attachment #96857 for bug #181684

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 181684
Collapse All | Expand All




        <apidef name="masterfs">MasterFileSystem API</apidef>
    </apidefs>
    <changes>
        <change id="recursive-control">
            <api name="masterfs"/>
            <summary><code>ProvidedExtensions.refreshRecursively</code> was added.</summary>
            <version major="2" minor="23"/>
            <date day="14" month="4" year="2010"/>
            <author login="jtulach"/>
            <compatibility addition="yes" binary="compatible" source="compatible" semantic="compatible" deprecation="no" deletion="no" modification="no"/>
            <description>
                <p>
                    <code>ProvidedExtensions.refreshRecursively</code> allows
                    various version control providers to get better control
                    on behavior of recursive listener.
                </p>
            </description>
            <class package="org.netbeans.modules.masterfs.providers" name="ProvidedExtensions"/>
            <issue number="181684"/>
        </change>
        <change id="added-canWrite-friend-contract-for-versioning-systems">
            <api name="masterfs"/>
            <summary><code>ProvidedExtensions.canWrite</code> was added.</summary>

Lines 1-7 Link Here

(-)a/masterfs/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module: org.netbeans.modules.masterfs/2	2	OpenIDE-Module: org.netbeans.modules.masterfs/2
3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/masterfs/resources/Bundle.properties	3	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/masterfs/resources/Bundle.properties
4	OpenIDE-Module-Specification-Version: 2.22	4	OpenIDE-Module-Specification-Version: 2.23
5	AutoUpdate-Show-In-Client: false	5	AutoUpdate-Show-In-Client: false
6	AutoUpdate-Essential-Module: true	6	AutoUpdate-Essential-Module: true
7		7





import java.io.File;
import java.util.Collection;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.CopyOnWriteArraySet;

final class FileObjectKeeper implements FileChangeListener {
    private static final Logger LOG = Logger.getLogger(FileObjectKeeper.class.getName());

    private Set<FolderObj> kept;
    private Collection<FileChangeListener> listeners;
    private final FolderObj root;
    private long timeStamp;

        }
    }

    public List<File> init(long previous, FileObjectFactory factory, boolean expected) {
        File file = root.getFileName().getFile();
        LinkedList<File> arr = new LinkedList<File>();
        long ts = root.getProvidedExtensions().refreshRecursively(file, previous, arr);
        for (File f : arr) {
            if (f.isDirectory()) {
                continue;
            }
            long lm = f.lastModified();
            LOG.log(Level.FINE, "  check {0} for {1}", new Object[] { lm, f });
            if (lm > ts) {
                ts = lm;
            }
            if (lm > previous && factory != null) {
                final BaseFileObj prevFO = factory.getCachedOnly(f);
                if (prevFO == null) {
                    BaseFileObj who = factory.getValidFileObject(f, Caller.Others);
                    if (who != null) {
                        LOG.log(Level.FINE, "External change detected {0}", who);  //NOI18N
                        who.fireFileChangedEvent(expected);
                            who.fireFileChangedEvent(expected);
                        } else {
                            LOG.log(Level.FINE, "Cannot get valid FileObject. File probably removed: {0}", f);  //NOI18N
                        }
                    } else {
                        LOG.log(Level.FINE, "Cannot get valid FileObject. File probably removed: {0}", f);  //NOI18N
                        prevFO.refresh(expected, true);
                    }
                } else {
                    LOG.log(Level.FINE, "Do classical refresh for {0}", prevFO);  //NOI18N
                    prevFO.refresh(expected, true);
                }
            }
        }
        timeStamp = ts;
        LOG.log(Level.FINE, "Testing {0}, time {1}", new Object[] { file, timeStamp });
        return arr;
    }

    private void listenTo(FolderObj fo, boolean add, Collection<? super File> children) {
        if (add) {
            fo.addFileChangeListener(this);
            if (fo instanceof FolderObj) {
                FolderObj folder = (FolderObj)fo;
                folder.getKeeper(children);
                folder.getChildren();
                kept.add(folder);
            }
            LOG.log(Level.FINER, "Listening to {0}", fo);

    private void listenToAll(Callable<?> stop) {
        assert Thread.holdsLock(this);
        assert kept == null;
        kept = new HashSet<FolderObj>();
        LinkedList<File> it = new LinkedList<File>();
        listenTo(root, true, it);
        FileObjectFactory factory = null;
        for (;;) {
            File f = it.poll();
            if (f == null) {
                break;
            }
            if (factory == null) {
                factory = FileObjectFactory.getInstance(f);
            }
            FileObject fo = factory.getValidFileObject(f, Caller.Others);
            if (fo instanceof FolderObj) {
                FolderObj obj = (FolderObj) fo;
                Object shallStop = null;

                    LOG.log(Level.INFO, "addRecursiveListener to {0} interrupted", root); // NOI18N
                    return;
                }
                listenTo(obj, true, it);
            }
        }
    }

    private void listenNoMore() {
        assert Thread.holdsLock(this);

        listenTo(root, false, null);
        Set<FolderObj> k = kept;
        if (k != null) {
            for (FolderObj fo : k) {
                listenTo(fo, false, null);
            }
            kept = null;
        }

    @Override
    public void fileFolderCreated(FileEvent fe) {
        Collection<FileChangeListener> arr = listeners;
        final FileObject folder = fe.getFile();
        if (folder instanceof FolderObj) {
            FolderObj obj = (FolderObj)folder;
            synchronized (this) {
                LinkedList<File> it = new LinkedList<File>();
                listenTo(obj, true, it);
                FileObjectFactory factory = null;
                for (;;) {
                    File f = it.poll();
                    if (f == null) {
                        break;
                    }
                    if (factory == null) {
                        factory = FileObjectFactory.getInstance(f);
                    }
                    FileObject fo = factory.getValidFileObject(f, Caller.Others);
                    if (fo instanceof FolderObj) {
                        listenTo((FolderObj)fo, true, it);
                    }
                }
            }

        }

        if (f instanceof FolderObj) {
            FolderObj obj = (FolderObj)f;
            synchronized (this) {
                if (kept != null) {
                    kept.remove(obj);
                }
                listenTo(obj, false, null);
            }
        }
        if (arr == null) {




import java.io.OutputStream;
import java.io.SyncFailedException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;

import org.openide.filesystems.FileChangeListener;
import org.openide.filesystems.FileLock;
import org.openide.filesystems.FileObject;
import org.openide.util.Exceptions;
import org.openide.util.Mutex;

/**

        return folderChildren;
    }

    synchronized FileObjectKeeper getKeeper(Collection<? super File> arr) {
        if (keeper == null) {
            keeper = new FileObjectKeeper(this);
            List<File> ch = keeper.init(-1, null, false);
            if (arr != null) {
                arr.addAll(ch);
            }
        } else if (arr != null) {
            List<File> ch = keeper.init(keeper.childrenLastModified(), null, false);
            arr.addAll(ch);
        }
        return keeper;
    }

    @Override
    public final void addRecursiveListener(FileChangeListener fcl) {
        getKeeper(null).addRecursiveListener(fcl);
    }

    @Override
    public final void removeRecursiveListener(FileChangeListener fcl) {
        getKeeper(null).removeRecursiveListener(fcl);
    }



Lines 43-48 Link Here

(-)a/masterfs/src/org/netbeans/modules/masterfs/providers/ProvidedExtensions.java (+24 lines)
43		43
44	import java.io.File;	44	import java.io.File;
45	import java.io.IOException;	45	import java.io.IOException;
		46	import java.util.Arrays;
		47	import java.util.List;
46	import org.openide.filesystems.FileObject;	48	import org.openide.filesystems.FileObject;
47		49
48	/**	50	/**
Lines 187-190 Link Here
187	public Object getAttribute(File file, String attrName) {	189	public Object getAttribute(File file, String attrName) {
188	return null;	190	return null;
189	}	191	}
		192
		193	/** Allows versioning system to exclude some children from recursive
		194	* listening check. Also notifies the versioning whenever a refresh
		195	* is required and allows the versiniong to provide special timestamp
		196	* for a directory.
		197	*
		198	* @param dir the directory to check timestamp for
		199	* @param lastTimeStamp the previously known timestamp or -1
		200	* @param children add children that shall be interated into this array
		201	* @return the timestamp that shall represent this directory, it will
		202	* be compared with timestamps of all children and the newest
		203	* one will be kept and next time passed as lastTimeStamp. Return
		204	* 0 if the directory does not have any special timestamp
		205	* @since 2.23
		206	*/
		207	public long refreshRecursively(File dir, long lastTimeStamp, List<? super File> children) {
		208	final File[] arr = dir.listFiles();
		209	if (arr != null) {
		210	children.addAll(Arrays.asList(arr));
		211	}
		212	return 0;
		213	}
190	}	214	}

Return to bug 181684

Lines 48-53 Link Here

(-)a/masterfs/src/org/netbeans/modules/masterfs/filebasedfs/fileobjects/FolderObj.java (-5 / +11 lines)
48	import java.io.OutputStream;	48	import java.io.OutputStream;
49	import java.io.SyncFailedException;	49	import java.io.SyncFailedException;
50	import java.util.ArrayList;	50	import java.util.ArrayList;
		51	import java.util.Collection;
51	import java.util.HashSet;	52	import java.util.HashSet;
52	import java.util.LinkedList;	53	import java.util.LinkedList;
53	import java.util.List;	54	import java.util.List;
Lines 70-76 Link Here
70	import org.openide.filesystems.FileChangeListener;	71	import org.openide.filesystems.FileChangeListener;
71	import org.openide.filesystems.FileLock;	72	import org.openide.filesystems.FileLock;
72	import org.openide.filesystems.FileObject;	73	import org.openide.filesystems.FileObject;
73	import org.openide.util.Exceptions;
74	import org.openide.util.Mutex;	74	import org.openide.util.Mutex;
75		75
76	/**	76	/**
Lines 520-541 Link Here
520	return folderChildren;	520	return folderChildren;
521	}	521	}
522		522
523	synchronized FileObjectKeeper getKeeper() {	523	synchronized FileObjectKeeper getKeeper(Collection<? super File> arr) {
524	if (keeper == null) {	524	if (keeper == null) {
525	keeper = new FileObjectKeeper(this);	525	keeper = new FileObjectKeeper(this);
526	keeper.init(-1, null, false);	526	List<File> ch = keeper.init(-1, null, false);
		527	if (arr != null) {
		528	arr.addAll(ch);
		529	}
		530	} else if (arr != null) {
		531	List<File> ch = keeper.init(keeper.childrenLastModified(), null, false);
		532	arr.addAll(ch);
527	}	533	}
528	return keeper;	534	return keeper;
529	}	535	}
530		536
531	@Override	537	@Override
532	public final void addRecursiveListener(FileChangeListener fcl) {	538	public final void addRecursiveListener(FileChangeListener fcl) {
533	getKeeper().addRecursiveListener(fcl);	539	getKeeper(null).addRecursiveListener(fcl);
534	}	540	}
535		541
536	@Override	542	@Override
537	public final void removeRecursiveListener(FileChangeListener fcl) {	543	public final void removeRecursiveListener(FileChangeListener fcl) {
538	getKeeper().removeRecursiveListener(fcl);	544	getKeeper(null).removeRecursiveListener(fcl);
539	}	545	}
540		546
541		547

Lines 46-51 Link Here

(-)a/masterfs/apichanges.xml (+17 lines)
46	<apidef name="masterfs">MasterFileSystem API</apidef>	46	<apidef name="masterfs">MasterFileSystem API</apidef>
47	</apidefs>	47	</apidefs>
48	<changes>	48	<changes>
		49	<change id="recursive-control">
		50	<api name="masterfs"/>
		51	<summary><code>ProvidedExtensions.refreshRecursively</code> was added.</summary>
		52	<version major="2" minor="23"/>
		53	<date day="14" month="4" year="2010"/>
		54	<author login="jtulach"/>
		55	<compatibility addition="yes" binary="compatible" source="compatible" semantic="compatible" deprecation="no" deletion="no" modification="no"/>
		56	<description>
		57	<p>
		58	<code>ProvidedExtensions.refreshRecursively</code> allows
		59	various version control providers to get better control
		60	on behavior of recursive listener.
		61	</p>
		62	</description>
		63	<class package="org.netbeans.modules.masterfs.providers" name="ProvidedExtensions"/>
		64	<issue number="181684"/>
		65	</change>
49	<change id="added-canWrite-friend-contract-for-versioning-systems">	66	<change id="added-canWrite-friend-contract-for-versioning-systems">
50	<api name="masterfs"/>	67	<api name="masterfs"/>
51	<summary><code>ProvidedExtensions.canWrite</code> was added.</summary>	68	<summary><code>ProvidedExtensions.canWrite</code> was added.</summary>