Attachment #97027 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>




import java.io.IOException;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.Logger;

        }
        return null;
    }

    @Override
    public long refreshRecursively(File dir, long lastTimeStamp, List<? super File> children) {
        for (Iterator it = annotationProviders.iterator(); it.hasNext();) {
            AnnotationProvider provider = (AnnotationProvider) it.next();
            final InterceptionListener iListener = (provider != null) ? provider.getInterceptionListener() : null;
            if (iListener instanceof ProvidedExtensions) {
                ProvidedExtensions pe = (ProvidedExtensions)iListener;
                int prev = children.size();
                long ret = pe.refreshRecursively(dir, lastTimeStamp, children);
                assert ret != -1 || prev == children.size() : "When returning -1 from refreshRecursively, you cannot modify children: " + pe;
                if (ret != -1) {
                    return ret;
                }
            }
        }
        return super.refreshRecursively(dir, lastTimeStamp, children);
    }
    
    public static void checkReentrancy() {
        if (reentrantCheck.get() != null) {            





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	}




import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.netbeans.junit.MockServices;
import org.netbeans.junit.NbTestCase;
import org.netbeans.junit.RandomlyFails;
import org.netbeans.modules.masterfs.filebasedfs.fileobjects.BaseFileObj;
import org.openide.filesystems.FileLock;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.util.test.TestFileUtils;
import org.netbeans.modules.masterfs.filebasedfs.FileUtilTest.EventType;
import org.netbeans.modules.masterfs.filebasedfs.FileUtilTest.TestFileChangeListener;
import org.netbeans.modules.masterfs.filebasedfs.fileobjects.FileObjectFactory;
import org.netbeans.modules.masterfs.filebasedfs.fileobjects.TestUtils;
import org.netbeans.modules.masterfs.providers.ProvidedExtensionsTest;

/**
 * @author Jiri Skrivanek
 */
public class FileUtilAddRecursiveListenerTest extends NbTestCase {
    static {
        MockServices.setServices(ProvidedExtensionsTest.AnnotationProviderImpl.class);
    }

    private final Logger LOG;

    public FileUtilAddRecursiveListenerTest(String name) {

    }

    @Override
    protected void setUp() throws Exception {
        clearWorkDir();
    }

    @Override
    protected Level logLevel() {
        return Level.FINER;
    }


        LOG.info("OK");
    }

    public void testProvideExtensionsRefreshRecursively() throws Exception {
        File root = new File(getWorkDir(), "root");
        final File sub = new File(root, "sub");
        final File subsub = new File(sub, "subsub");
        File subsubdir = new File(subsub, "dir");
        subsubdir.mkdirs();
        File subfile = new File(sub, "file");
        subfile.createNewFile();
        File deepfile = new File(subsubdir, "deep");
        deepfile.createNewFile();

        ProvidedExtensionsTest.ProvidedExtensionsImpl.nextRefreshCall(
            sub,
            Long.MAX_VALUE - 10,
            subfile
        );


        TestFileChangeListener fcl = new TestFileChangeListener();
        FileObject rf = FileUtil.toFileObject(root);
        rf.addRecursiveListener(fcl);

        BaseFileObj noFO = FileObjectFactory.getInstance(root).getCachedOnly(subsubdir);
        assertNull("subsub directory has been skipped", noFO);

        assertEquals("No events", 0, fcl.checkAll());
        LOG.log(Level.INFO, "Touching subfile: {0}", deepfile);
        TestFileUtils.touch(deepfile, null);
        LOG.log(Level.INFO, "Will do refresh, lastModified: {0}", deepfile.lastModified());
        FileUtil.refreshFor(root);
        LOG.info("Refresh done");
        fcl.check(EventType.ATTRIBUTE_CHANGED); // ignore if any

        fcl.printAll(LOG);
        assertEquals("No other events", 0, fcl.checkAll());
    }
}

Lines 49-54 Link Here

(-)a/masterfs/test/unit/src/org/netbeans/modules/masterfs/providers/ProvidedExtensionsTest.java (-1 / +24 lines)
49	import java.io.InputStream;	49	import java.io.InputStream;
50	import java.io.OutputStream;	50	import java.io.OutputStream;
51	import java.util.ArrayList;	51	import java.util.ArrayList;
		52	import java.util.Arrays;
52	import java.util.Collection;	53	import java.util.Collection;
53	import java.util.HashSet;	54	import java.util.HashSet;
54	import java.util.Iterator;	55	import java.util.Iterator;
Lines 450-455 Link Here
450	}	451	}
451		452
452	public static class ProvidedExtensionsImpl extends ProvidedExtensions {	453	public static class ProvidedExtensionsImpl extends ProvidedExtensions {
		454	private static File refreshCallForDir;
		455	private static long refreshCallRetValue;
		456	private static List<File> refreshCallToAdd;
453	private int implsMoveCalls;	457	private int implsMoveCalls;
454	private int moveImplCalls;	458	private int moveImplCalls;
455	private int implsRenameCalls;	459	private int implsRenameCalls;
Lines 522-528 Link Here
522	public void beforeChange(FileObject f) {	526	public void beforeChange(FileObject f) {
523	assertNotNull(FileUtil.toFile(f));	527	assertNotNull(FileUtil.toFile(f));
524	implsBeforeChangeCalls++;	528	implsBeforeChangeCalls++;
525	}	529	}
		530
		531	public static void nextRefreshCall(File forDir, long retValue, File... toAdd) {
		532	refreshCallForDir = forDir;
		533	refreshCallRetValue = retValue;
		534	refreshCallToAdd = Arrays.asList(toAdd);
		535	}
		536
		537	@Override
		538	public long refreshRecursively(File dir, long lastTimeStamp, List<? super File> children) {
		539	if (dir.equals(refreshCallForDir)) {
		540	children.addAll(refreshCallToAdd);
		541	long r = refreshCallRetValue;
		542	refreshCallForDir = null;
		543	refreshCallToAdd = null;
		544	refreshCallRetValue = -1;
		545	return r;
		546	}
		547	return -1;
		548	}
526		549
527	@Override	550	@Override
528	public ProvidedExtensions.DeleteHandler getDeleteHandler(File f) {	551	public ProvidedExtensions.DeleteHandler getDeleteHandler(File f) {

Return to bug 181684

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>