Attachment #109328 for bug #199986

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 199986
Collapse All | Expand All




        
        <change>
            <api name="versioning_spi"/>
            <summary>isExcluded() added to VersioningSupport</summary>
            <version major="1" minor="25"/>
            <date day="8" month="7" year="2011"/>
            <author login="ovrabec"/>
            <compatibility addition="yes"/>
            <description>
                Method <code>isExcluded</code> states that a given folder is excluded from version control completely. 
                All version control systems should respect the return value and consider such folders to be unversioned.
            </description>
            <class package="org.netbeans.modules.versioning.spi" name="VersioningSupport"/>
            <issue number="199986"/>
        </change>
        <change>
            <api name="versioning_spi"/>
            <summary>New @VersioningSystem.Registration annotation</summary>
            <version major="1" minor="24"/>
            <date day="23" month="5" year="2011"/>

Lines 44-50 Link Here

(-)a/versioning/nbproject/project.properties (-1 / +1 lines)
44	javac.source=1.6	44	javac.source=1.6
45		45
46	javadoc.name=Versioning	46	javadoc.name=Versioning
47	spec.version.base=1.24	47	spec.version.base=1.25
48	is.autoload=true	48	is.autoload=true
49		49
50	javadoc.arch=${basedir}/arch.xml	50	javadoc.arch=${basedir}/arch.xml

Lines 86-91 Link Here

(-)a/versioning/src/org/netbeans/modules/versioning/Utils.java (+44 lines)
86	private static FileSystem filesystem;	86	private static FileSystem filesystem;
87		87
88	/**	88	/**
		89	* Keeps excluded/unversioned folders
		90	*/
		91	private static File [] unversionedFolders;
		92
		93	/**
89	* Constructs a VCSContext out of a Lookup, basically taking all Nodes inside.	94	* Constructs a VCSContext out of a Lookup, basically taking all Nodes inside.
90	* Nodes are converted to Files based on their nature.	95	* Nodes are converted to Files based on their nature.
91	* For example Project Nodes are queried for their SourceRoots and those roots become the root files of this context.	96	* For example Project Nodes are queried for their SourceRoots and those roots become the root files of this context.
Lines 321-326 Link Here
321	return priority;	326	return priority;
322	}	327	}
323		328
		329	public static File[] getUnversionedFolders () {
		330	if (unversionedFolders == null) {
		331	File[] files;
		332	try {
		333	String uf = VersioningSupport.getPreferences().get("unversionedFolders", ""); //NOI18N
		334	String ufProp = System.getProperty("versioning.unversionedFolders", ""); //NOI18N
		335	StringBuilder sb = new StringBuilder(uf);
		336	String nbUserdir = System.getProperty("netbeans.user", ""); //NOI18N
		337	if (!nbUserdir.isEmpty() && !"true".equals(System.getProperty("versioning.netbeans.user.versioned", "false"))) { //NOI18N
		338	if (sb.length() > 0) {
		339	sb.append(';');
		340	}
		341	sb.append(nbUserdir);
		342	}
		343	if (!ufProp.isEmpty()) {
		344	if (sb.length() > 0) {
		345	sb.append(';');
		346	}
		347	sb.append(ufProp);
		348	}
		349	if (sb.length() == 0) {
		350	files = new File[0];
		351	} else {
		352	String [] paths = sb.toString().split("\\;"); //NOI18N
		353	files = new File[paths.length];
		354	int idx = 0;
		355	for (String path : paths) {
		356	files[idx++] = new File(path);
		357	}
		358	}
		359	} catch (Exception e) {
		360	files = new File[0];
		361	Logger.getLogger(Utils.class.getName()).log(Level.INFO, e.getMessage(), e);
		362	}
		363	unversionedFolders = files;
		364	}
		365	return unversionedFolders;
		366	}
		367
324	static FileSystem getRootFilesystem() {	368	static FileSystem getRootFilesystem() {
325	if(filesystem == null) {	369	if(filesystem == null) {
326	try {	370	try {




                owner = folderOwners.get(folder);
            }
        }

        if (owner == null && VersioningSupport.isExcluded(folder)) {
            // the owner is not known yet and the folder is excluded/unversioned
            LOG.log(Level.FINE, " caching NULL_OWNER of excluded {0}", new Object[] { file }); //NOI18N
            if (isFile) {
                synchronized(fileOwners) {
                    fileOwners.put(folder, NULL_OWNER);
                }
            }
            synchronized(folderOwners) {
                folderOwners.put(folder, NULL_OWNER);
            }
            return null;
        } else if (owner != null) {
            synchronized(fileOwners) {
                LOG.log(Level.FINE, " caching owner {0} of {1}", new Object[] { owner != null ? owner.getClass().getName() : null, file }) ;
                fileOwners.put(file, owner != null ? owner : NULL_OWNER);            





import java.io.File;
import java.util.prefs.Preferences;
import org.netbeans.modules.versioning.Utils;

/**
 * Collection of utility methods for Versioning systems implementors. 

    public static void versionedRootsChanged() {
        VersioningManager.getInstance().versionedRootsChanged();
    }

    /**
     * Tests whether the given folder is excluded (unversioned) from version control.
     * <ul>
     * <li>Folders set in <code>versioning.unversionedFolders</code> system property are excluded. 
     * Misconfigured automount daemons may try to look for versioning metadata causing hangs and full load.</li>
     * <li>Netbeans userdir is excluded by default. To include the userdir set <code>versioning.netbeans.user.versioned</code> system property to <code>true</code></li>
     * </ul>
     * <p>Versioning systems <strong>must NOT</strong> scan a folder if this method returns true and should consider it as unversioned.</p>
     *
     * @param folder a folder to query
     * @link http://www.netbeans.org/bugzilla/show_bug.cgi?id=105161
     * @link http://www.netbeans.org/bugzilla/show_bug.cgi?id=195284
     * @since 1.25
     * @return true if the given folder is excluded from version control, false otherwise
     */
    public static boolean isExcluded (File folder) {
        // forbid scanning for UNC paths \\ or \\computerName
        if (folder.getPath().startsWith("\\\\")) { //NOI18N
            return folder.getParent() == null || folder.getParent().equals("\\\\"); //NOI18N
        }
        for (File unversionedFolder : Utils.getUnversionedFolders()) {
            if (Utils.isAncestorOrEqual(unversionedFolder, folder)) {
                return true;
            }
        }
        return false;
    }
}





import java.io.IOException;
import java.io.File;
import java.lang.reflect.Field;
import java.security.Permission;
import java.util.LinkedList;
import java.util.List;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.versioning.spi.VersioningSupport;
import org.netbeans.modules.versioning.spi.VersioningSystem;
import org.netbeans.modules.versioning.spi.testvcs.TestVCS;


        testFileOwnerCache(true /* unversioned */ , true /* folder */);
        testFileOwnerCache(false/* unversioned */ , true /* folder */);
    }

    public void testExcludedFolders () throws Exception {
        Field f = Utils.class.getDeclaredField("unversionedFolders");
        f.setAccessible(true);
        f.set(Utils.class, (File[]) null);

        File a = new File(getWorkDir(), "a");
        File b = new File(getWorkDir(), "b");
        System.setProperty("versioning.unversionedFolders", a.getAbsolutePath() + ";" + b.getAbsolutePath() + ";");
        File c = new File(getWorkDir(), "c");
        VersioningSupport.getPreferences().put("unversionedFolders", c.getAbsolutePath()); //NOI18N
        File userdir = new File(getWorkDir(), "userdir");
        System.setProperty("netbeans.user", userdir.getAbsolutePath());
        assertTrue(VersioningSupport.isExcluded(a));
        assertTrue(VersioningSupport.isExcluded(b));
        assertTrue(VersioningSupport.isExcluded(c));
        assertTrue(VersioningSupport.isExcluded(userdir));
        assertTrue(VersioningSupport.isExcluded(new File(userdir, "ffff")));
        assertFalse(VersioningSupport.isExcluded(userdir.getParentFile()));

        assertEquals(4, ((File[]) f.get(Utils.class)).length);

        // what if someone still wants to have userdir versioned?
        System.setProperty("versioning.netbeans.user.versioned", "true");
        
        f.set(Utils.class, (File[]) null);
        
        assertTrue(VersioningSupport.isExcluded(a));
        assertTrue(VersioningSupport.isExcluded(b));
        assertTrue(VersioningSupport.isExcluded(c));
        assertFalse(VersioningSupport.isExcluded(userdir));
        assertFalse(VersioningSupport.isExcluded(new File(userdir, "ffff")));
        assertFalse(VersioningSupport.isExcluded(userdir.getParentFile()));

        assertEquals(3, ((File[]) f.get(Utils.class)).length);
    }

    private void testFileOwnerCache(boolean isVersioned, boolean isFolder) throws IOException {
        File folder = isVersioned ? getVersionedFolder() : getUnversionedFolder();
        File child = new File(folder, "file");

Return to bug 199986

Lines 111-116 Link Here

(-)a/versioning/apichanges.xml (+14 lines)
111		111
112	<change>	112	<change>
113	<api name="versioning_spi"/>	113	<api name="versioning_spi"/>
		114	<summary>isExcluded() added to VersioningSupport</summary>
		115	<version major="1" minor="25"/>
		116	<date day="8" month="7" year="2011"/>
		117	<author login="ovrabec"/>
		118	<compatibility addition="yes"/>
		119	<description>
		120	Method <code>isExcluded</code> states that a given folder is excluded from version control completely.
		121	All version control systems should respect the return value and consider such folders to be unversioned.
		122	</description>
		123	<class package="org.netbeans.modules.versioning.spi" name="VersioningSupport"/>
		124	<issue number="199986"/>
		125	</change>
		126	<change>
		127	<api name="versioning_spi"/>
114	<summary>New @VersioningSystem.Registration annotation</summary>	128	<summary>New @VersioningSystem.Registration annotation</summary>
115	<version major="1" minor="24"/>	129	<version major="1" minor="24"/>
116	<date day="23" month="5" year="2011"/>	130	<date day="23" month="5" year="2011"/>

Lines 388-395 Link Here

(-)a/versioning/src/org/netbeans/modules/versioning/VersioningManager.java (-2 / +14 lines)
388	owner = folderOwners.get(folder);	388	owner = folderOwners.get(folder);
389	}	389	}
390	}	390	}
391		391
392	if (owner != null) {	392	if (owner == null && VersioningSupport.isExcluded(folder)) {
		393	// the owner is not known yet and the folder is excluded/unversioned
		394	LOG.log(Level.FINE, " caching NULL_OWNER of excluded {0}", new Object[] { file }); //NOI18N
		395	if (isFile) {
		396	synchronized(fileOwners) {
		397	fileOwners.put(folder, NULL_OWNER);
		398	}
		399	}
		400	synchronized(folderOwners) {
		401	folderOwners.put(folder, NULL_OWNER);
		402	}
		403	return null;
		404	} else if (owner != null) {
393	synchronized(fileOwners) {	405	synchronized(fileOwners) {
394	LOG.log(Level.FINE, " caching owner {0} of {1}", new Object[] { owner != null ? owner.getClass().getName() : null, file }) ;	406	LOG.log(Level.FINE, " caching owner {0} of {1}", new Object[] { owner != null ? owner.getClass().getName() : null, file }) ;
395	fileOwners.put(file, owner != null ? owner : NULL_OWNER);	407	fileOwners.put(file, owner != null ? owner : NULL_OWNER);

Lines 49-54 Link Here

(-)a/versioning/src/org/netbeans/modules/versioning/spi/VersioningSupport.java (+29 lines)
49		49
50	import java.io.File;	50	import java.io.File;
51	import java.util.prefs.Preferences;	51	import java.util.prefs.Preferences;
		52	import org.netbeans.modules.versioning.Utils;
52		53
53	/**	54	/**
54	* Collection of utility methods for Versioning systems implementors.	55	* Collection of utility methods for Versioning systems implementors.
Lines 117-120 Link Here
117	public static void versionedRootsChanged() {	118	public static void versionedRootsChanged() {
118	VersioningManager.getInstance().versionedRootsChanged();	119	VersioningManager.getInstance().versionedRootsChanged();
119	}	120	}
		121
		122	/**
		123	* Tests whether the given folder is excluded (unversioned) from version control.
		124	* <ul>
		125	* <li>Folders set in <code>versioning.unversionedFolders</code> system property are excluded.
		126	* Misconfigured automount daemons may try to look for versioning metadata causing hangs and full load.</li>
		127	* <li>Netbeans userdir is excluded by default. To include the userdir set <code>versioning.netbeans.user.versioned</code> system property to <code>true</code></li>
		128	* </ul>
		129	* <p>Versioning systems <strong>must NOT</strong> scan a folder if this method returns true and should consider it as unversioned.</p>
		130	*
		131	* @param folder a folder to query
		132	* @link http://www.netbeans.org/bugzilla/show_bug.cgi?id=105161
		133	* @link http://www.netbeans.org/bugzilla/show_bug.cgi?id=195284
		134	* @since 1.25
		135	* @return true if the given folder is excluded from version control, false otherwise
		136	*/
		137	public static boolean isExcluded (File folder) {
		138	// forbid scanning for UNC paths \\ or \\computerName
		139	if (folder.getPath().startsWith("\\\\")) { //NOI18N
		140	return folder.getParent() == null \|\| folder.getParent().equals("\\\\"); //NOI18N
		141	}
		142	for (File unversionedFolder : Utils.getUnversionedFolders()) {
		143	if (Utils.isAncestorOrEqual(unversionedFolder, folder)) {
		144	return true;
		145	}
		146	}
		147	return false;
		148	}
120	}	149	}

Lines 45-54 Link Here

(-)a/versioning/test/unit/src/org/netbeans/modules/versioning/GetOwnerTest.java (+38 lines)
45		45
46	import java.io.IOException;	46	import java.io.IOException;
47	import java.io.File;	47	import java.io.File;
		48	import java.lang.reflect.Field;
48	import java.security.Permission;	49	import java.security.Permission;
49	import java.util.LinkedList;	50	import java.util.LinkedList;
50	import java.util.List;	51	import java.util.List;
51	import org.netbeans.junit.NbTestCase;	52	import org.netbeans.junit.NbTestCase;
		53	import org.netbeans.modules.versioning.spi.VersioningSupport;
52	import org.netbeans.modules.versioning.spi.VersioningSystem;	54	import org.netbeans.modules.versioning.spi.VersioningSystem;
53	import org.netbeans.modules.versioning.spi.testvcs.TestVCS;	55	import org.netbeans.modules.versioning.spi.testvcs.TestVCS;
54		56
Lines 178-184 Link Here
178	testFileOwnerCache(true /* unversioned / , true / folder */);	180	testFileOwnerCache(true /* unversioned / , true / folder */);
179	testFileOwnerCache(false/* unversioned / , true / folder */);	181	testFileOwnerCache(false/* unversioned / , true / folder */);
180	}	182	}
		183
		184	public void testExcludedFolders () throws Exception {
		185	Field f = Utils.class.getDeclaredField("unversionedFolders");
		186	f.setAccessible(true);
		187	f.set(Utils.class, (File[]) null);
		188
		189	File a = new File(getWorkDir(), "a");
		190	File b = new File(getWorkDir(), "b");
		191	System.setProperty("versioning.unversionedFolders", a.getAbsolutePath() + ";" + b.getAbsolutePath() + ";");
		192	File c = new File(getWorkDir(), "c");
		193	VersioningSupport.getPreferences().put("unversionedFolders", c.getAbsolutePath()); //NOI18N
		194	File userdir = new File(getWorkDir(), "userdir");
		195	System.setProperty("netbeans.user", userdir.getAbsolutePath());
		196	assertTrue(VersioningSupport.isExcluded(a));
		197	assertTrue(VersioningSupport.isExcluded(b));
		198	assertTrue(VersioningSupport.isExcluded(c));
		199	assertTrue(VersioningSupport.isExcluded(userdir));
		200	assertTrue(VersioningSupport.isExcluded(new File(userdir, "ffff")));
		201	assertFalse(VersioningSupport.isExcluded(userdir.getParentFile()));
		202
		203	assertEquals(4, ((File[]) f.get(Utils.class)).length);
		204
		205	// what if someone still wants to have userdir versioned?
		206	System.setProperty("versioning.netbeans.user.versioned", "true");
181		207
		208	f.set(Utils.class, (File[]) null);
		209
		210	assertTrue(VersioningSupport.isExcluded(a));
		211	assertTrue(VersioningSupport.isExcluded(b));
		212	assertTrue(VersioningSupport.isExcluded(c));
		213	assertFalse(VersioningSupport.isExcluded(userdir));
		214	assertFalse(VersioningSupport.isExcluded(new File(userdir, "ffff")));
		215	assertFalse(VersioningSupport.isExcluded(userdir.getParentFile()));
		216
		217	assertEquals(3, ((File[]) f.get(Utils.class)).length);
		218	}
		219
182	private void testFileOwnerCache(boolean isVersioned, boolean isFolder) throws IOException {	220	private void testFileOwnerCache(boolean isVersioned, boolean isFolder) throws IOException {
183	File folder = isVersioned ? getVersionedFolder() : getUnversionedFolder();	221	File folder = isVersioned ? getVersionedFolder() : getUnversionedFolder();
184	File child = new File(folder, "file");	222	File child = new File(folder, "file");