Attachment #95591 for bug #180061

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




 */
package org.netbeans.modules.parsing.impl.indexing.errors;

import java.beans.PropertyChangeEvent;
import org.netbeans.api.java.classpath.ClassPath;
import java.awt.Image;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.IOException;
import java.net.URL;

import org.netbeans.api.fileinfo.NonRecursiveFolder;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ui.OpenProjects;
import org.netbeans.modules.masterfs.providers.AnnotationProvider;
import org.netbeans.modules.masterfs.providers.InterceptionListener;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileStateInvalidException;
import org.openide.filesystems.FileStatusEvent;
import org.openide.filesystems.FileUtil;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.Mutex.ExceptionAction;
import org.openide.util.RequestProcessor;

import static org.openide.util.ImageUtilities.assignToolTipToImage;

        return null;
    }
    
    static final int IN_ERROR_REC = 1;
    static final int IN_ERROR_NONREC = 2;
    static final int INVALID = 4;
    static final int FILE_IN_ERROR_NONREC_HACK = 8;
    
    private Map<FileObject, Integer> knownFiles2Error = new WeakHashMap<FileObject, Integer>();
    

    
    private long cumulativeTime;
    private Collection<FileObject> toProcess = null;

    private final RequestProcessor.Task WORKER = new RequestProcessor("ErrorAnnotator worker", 1).create(new Runnable() {
        public void run() {
            long startTime = System.currentTimeMillis();

            Logger.getLogger(ErrorAnnotator.class.getName()).log(Level.FINE, "time spent in error annotations computation: {0}, cumulative time: {1}", new Object[] {(endTime - startTime), (cumulativeTime += (endTime - startTime))});
        }
    });

    private static void fillInErrorCache(FileObject root, Map<FileObject, Integer> errors) {
        TaskCache.getDefault().fillIn(root, errors);
    }

    private static final RequestProcessor PRELOAD_WORKER = new RequestProcessor("ErrorAnnotator preload worker", 1, true, false);
    private final Set<FileObject> preloaded = new HashSet<FileObject>();

    private void preloadAll() {
        long start = System.currentTimeMillis();
        try {
            TaskCache.getDefault().refreshTransaction(new ExceptionAction<Void>() {
                @Override
                public Void run() throws Exception {
                    synchronized(ErrorAnnotator.this) {
                        Project[] open = OpenProjects.getDefault().getOpenProjects();
                        Set<FileObject> removed = new HashSet<FileObject>(preloaded);

                        for (Project prj : open) {
                            if (Thread.interrupted()) {
                                return null;
                            }
                            for (FileObject root : Utilities.findIndexedRootsUnderDirectory(prj, prj.getProjectDirectory())) {
                                if (Thread.interrupted()) {
                                    return null;
                                }
                                fillInErrorCache(root, knownFiles2Error);
                                if (Thread.interrupted()) {
                                    return null;
                                }
                                removed.remove(root);
                                preloaded.add(root);
                            }
                        }

                        preloaded.removeAll(removed);

                        return null;
                    }
                }
            });
        } catch (IOException ex) {
            Exceptions.printStackTrace(ex);
        } finally {
            long end = System.currentTimeMillis();

            System.err.println("preloading took: " + (end - start));
        }
    }

    private final RequestProcessor.Task preloadTask = PRELOAD_WORKER.create(new Runnable() {
        @Override
        public void run() {
            preloadAll();
        }
    });

    private static final class ProjectOpenedListenerImpl implements PropertyChangeListener {

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            ErrorAnnotator a = getAnnotator();

            a.preloadTask.cancel();
            a.preloadTask.schedule(0);
        }
        
    }

    public static void setProjectListener() {
        OpenProjects.getDefault().addPropertyChangeListener(new ProjectOpenedListenerImpl());
    }
}




import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Set;
import java.util.logging.Level;

            }
        }
    }

    public boolean fillIn(FileObject root, Map<FileObject, Integer> errorsCache) {
        try {
            ClassPath cp = ClassPath.getClassPath(root, ClassPath.SOURCE);

            if (cp == null) {
                return false;
            }

            File cacheRoot = getCacheRoot(root.getURL(), true);

            if (cacheRoot == null) {
                //index does not exist:
                return false;
            }

            fillInRecursivelly(root, cacheRoot, errorsCache);
            return true;
        } catch (IOException e) {
            Logger.getLogger("global").log(Level.WARNING, null, e);
            return false;
        }
    }
    
    private int fillInRecursivelly(FileObject fileOrFolder, File cache, Map<FileObject, Integer> errorsCache) {
        if (true) fillInNoErrorBadge(fileOrFolder, errorsCache);
        if (fileOrFolder.isFolder()) {
            if (!cache.exists()) {
                fillInNoErrorBadge(fileOrFolder, errorsCache);
                return 0;
            }

            int v = 0;

            for (FileObject c : fileOrFolder.getChildren()) {
                int res = fillInRecursivelly(c, new File(cache, c.getNameExt()), errorsCache);

                v |= (res & ErrorAnnotator.IN_ERROR_REC) | (((res & ErrorAnnotator.FILE_IN_ERROR_NONREC_HACK) != 0) ? ErrorAnnotator.IN_ERROR_NONREC : 0);
            }

            errorsCache.put(fileOrFolder, v);

            return v;
        } else {
            File c = new File(cache.getParentFile(), fileOrFolder.getName() + "." + ERR_EXT);

            return c.exists() ? ErrorAnnotator.IN_ERROR_NONREC | ErrorAnnotator.IN_ERROR_REC | ErrorAnnotator.FILE_IN_ERROR_NONREC_HACK : 0;
        }
    }

    private void fillInNoErrorBadge(FileObject fileOrFolder, Map<FileObject, Integer> errorsCache) {
        if (fileOrFolder.isFolder()) {
            for (FileObject c : fileOrFolder.getChildren()) {
                fillInNoErrorBadge(c, errorsCache);
            }
        }

        errorsCache.put(fileOrFolder, 0);
    }
    
    private boolean folderContainsErrors(File folder, boolean recursively) throws IOException {
        File[] errors = folder.listFiles(new FilenameFilter() {

Return to bug 180061

Lines 40-47 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/impl/indexing/errors/ErrorAnnotator.java (-4 / +82 lines)
40	*/	40	*/
41	package org.netbeans.modules.parsing.impl.indexing.errors;	41	package org.netbeans.modules.parsing.impl.indexing.errors;
42		42
		43	import java.beans.PropertyChangeEvent;
43	import org.netbeans.api.java.classpath.ClassPath;	44	import org.netbeans.api.java.classpath.ClassPath;
44	import java.awt.Image;	45	import java.awt.Image;
		46	import java.beans.PropertyChangeListener;
45	import java.io.File;	47	import java.io.File;
46	import java.io.IOException;	48	import java.io.IOException;
47	import java.net.URL;	49	import java.net.URL;
Lines 59-71 Link Here
59	import org.netbeans.api.fileinfo.NonRecursiveFolder;	61	import org.netbeans.api.fileinfo.NonRecursiveFolder;
60	import org.netbeans.api.project.FileOwnerQuery;	62	import org.netbeans.api.project.FileOwnerQuery;
61	import org.netbeans.api.project.Project;	63	import org.netbeans.api.project.Project;
		64	import org.netbeans.api.project.ui.OpenProjects;
62	import org.netbeans.modules.masterfs.providers.AnnotationProvider;	65	import org.netbeans.modules.masterfs.providers.AnnotationProvider;
63	import org.netbeans.modules.masterfs.providers.InterceptionListener;	66	import org.netbeans.modules.masterfs.providers.InterceptionListener;
64	import org.openide.filesystems.FileObject;	67	import org.openide.filesystems.FileObject;
65	import org.openide.filesystems.FileStateInvalidException;	68	import org.openide.filesystems.FileStateInvalidException;
66	import org.openide.filesystems.FileStatusEvent;	69	import org.openide.filesystems.FileStatusEvent;
67	import org.openide.filesystems.FileUtil;	70	import org.openide.filesystems.FileUtil;
		71	import org.openide.util.Exceptions;
68	import org.openide.util.Lookup;	72	import org.openide.util.Lookup;
		73	import org.openide.util.Mutex.ExceptionAction;
69	import org.openide.util.RequestProcessor;	74	import org.openide.util.RequestProcessor;
70		75
71	import static org.openide.util.ImageUtilities.assignToolTipToImage;	76	import static org.openide.util.ImageUtilities.assignToolTipToImage;
Lines 237-245 Link Here
237	return null;	242	return null;
238	}	243	}
239		244
240	private static final int IN_ERROR_REC = 1;	245	static final int IN_ERROR_REC = 1;
241	private static final int IN_ERROR_NONREC = 2;	246	static final int IN_ERROR_NONREC = 2;
242	private static final int INVALID = 4;	247	static final int INVALID = 4;
		248	static final int FILE_IN_ERROR_NONREC_HACK = 8;
243		249
244	private Map<FileObject, Integer> knownFiles2Error = new WeakHashMap<FileObject, Integer>();	250	private Map<FileObject, Integer> knownFiles2Error = new WeakHashMap<FileObject, Integer>();
245		251
Lines 276-282 Link Here
276		282
277	private long cumulativeTime;	283	private long cumulativeTime;
278	private Collection<FileObject> toProcess = null;	284	private Collection<FileObject> toProcess = null;
279		285
280	private final RequestProcessor.Task WORKER = new RequestProcessor("ErrorAnnotator worker", 1).create(new Runnable() {	286	private final RequestProcessor.Task WORKER = new RequestProcessor("ErrorAnnotator worker", 1).create(new Runnable() {
281	public void run() {	287	public void run() {
282	long startTime = System.currentTimeMillis();	288	long startTime = System.currentTimeMillis();
Lines 345-348 Link Here
345	Logger.getLogger(ErrorAnnotator.class.getName()).log(Level.FINE, "time spent in error annotations computation: {0}, cumulative time: {1}", new Object[] {(endTime - startTime), (cumulativeTime += (endTime - startTime))});	351	Logger.getLogger(ErrorAnnotator.class.getName()).log(Level.FINE, "time spent in error annotations computation: {0}, cumulative time: {1}", new Object[] {(endTime - startTime), (cumulativeTime += (endTime - startTime))});
346	}	352	}
347	});	353	});
		354
		355	private static void fillInErrorCache(FileObject root, Map<FileObject, Integer> errors) {
		356	TaskCache.getDefault().fillIn(root, errors);
		357	}
		358
		359	private static final RequestProcessor PRELOAD_WORKER = new RequestProcessor("ErrorAnnotator preload worker", 1, true, false);
		360	private final Set<FileObject> preloaded = new HashSet<FileObject>();
		361
		362	private void preloadAll() {
		363	long start = System.currentTimeMillis();
		364	try {
		365	TaskCache.getDefault().refreshTransaction(new ExceptionAction<Void>() {
		366	@Override
		367	public Void run() throws Exception {
		368	synchronized(ErrorAnnotator.this) {
		369	Project[] open = OpenProjects.getDefault().getOpenProjects();
		370	Set<FileObject> removed = new HashSet<FileObject>(preloaded);
		371
		372	for (Project prj : open) {
		373	if (Thread.interrupted()) {
		374	return null;
		375	}
		376	for (FileObject root : Utilities.findIndexedRootsUnderDirectory(prj, prj.getProjectDirectory())) {
		377	if (Thread.interrupted()) {
		378	return null;
		379	}
		380	fillInErrorCache(root, knownFiles2Error);
		381	if (Thread.interrupted()) {
		382	return null;
		383	}
		384	removed.remove(root);
		385	preloaded.add(root);
		386	}
		387	}
		388
		389	preloaded.removeAll(removed);
		390
		391	return null;
		392	}
		393	}
		394	});
		395	} catch (IOException ex) {
		396	Exceptions.printStackTrace(ex);
		397	} finally {
		398	long end = System.currentTimeMillis();
		399
		400	System.err.println("preloading took: " + (end - start));
		401	}
		402	}
		403
		404	private final RequestProcessor.Task preloadTask = PRELOAD_WORKER.create(new Runnable() {
		405	@Override
		406	public void run() {
		407	preloadAll();
		408	}
		409	});
		410
		411	private static final class ProjectOpenedListenerImpl implements PropertyChangeListener {
		412
		413	@Override
		414	public void propertyChange(PropertyChangeEvent evt) {
		415	ErrorAnnotator a = getAnnotator();
		416
		417	a.preloadTask.cancel();
418	a.preloadTask.schedule(0);
419	}
420
421	}
422
423	public static void setProjectListener() {
424	OpenProjects.getDefault().addPropertyChangeListener(new ProjectOpenedListenerImpl());
425	}
348	}	426	}

Lines 58-63 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/impl/indexing/errors/TaskCache.java (+60 lines)
58	import java.util.HashSet;	58	import java.util.HashSet;
59	import java.util.LinkedList;	59	import java.util.LinkedList;
60	import java.util.List;	60	import java.util.List;
		61	import java.util.Map;
61	import java.util.Queue;	62	import java.util.Queue;
62	import java.util.Set;	63	import java.util.Set;
63	import java.util.logging.Level;	64	import java.util.logging.Level;
Lines 374-379 Link Here
374	}	375	}
375	}	376	}
376	}	377	}
		378
		379	public boolean fillIn(FileObject root, Map<FileObject, Integer> errorsCache) {
		380	try {
		381	ClassPath cp = ClassPath.getClassPath(root, ClassPath.SOURCE);
		382
		383	if (cp == null) {
		384	return false;
		385	}
		386
		387	File cacheRoot = getCacheRoot(root.getURL(), true);
		388
		389	if (cacheRoot == null) {
		390	//index does not exist:
		391	return false;
		392	}
		393
		394	fillInRecursivelly(root, cacheRoot, errorsCache);
		395	return true;
		396	} catch (IOException e) {
		397	Logger.getLogger("global").log(Level.WARNING, null, e);
		398	return false;
		399	}
		400	}
		401
		402	private int fillInRecursivelly(FileObject fileOrFolder, File cache, Map<FileObject, Integer> errorsCache) {
		403	if (true) fillInNoErrorBadge(fileOrFolder, errorsCache);
		404	if (fileOrFolder.isFolder()) {
		405	if (!cache.exists()) {
		406	fillInNoErrorBadge(fileOrFolder, errorsCache);
		407	return 0;
		408	}
		409
		410	int v = 0;
		411
		412	for (FileObject c : fileOrFolder.getChildren()) {
		413	int res = fillInRecursivelly(c, new File(cache, c.getNameExt()), errorsCache);
		414
		415	v \|= (res & ErrorAnnotator.IN_ERROR_REC) \| (((res & ErrorAnnotator.FILE_IN_ERROR_NONREC_HACK) != 0) ? ErrorAnnotator.IN_ERROR_NONREC : 0);
		416	}
		417
		418	errorsCache.put(fileOrFolder, v);
		419
		420	return v;
		421	} else {
		422	File c = new File(cache.getParentFile(), fileOrFolder.getName() + "." + ERR_EXT);
		423
		424	return c.exists() ? ErrorAnnotator.IN_ERROR_NONREC \| ErrorAnnotator.IN_ERROR_REC \| ErrorAnnotator.FILE_IN_ERROR_NONREC_HACK : 0;
		425	}
		426	}
		427
		428	private void fillInNoErrorBadge(FileObject fileOrFolder, Map<FileObject, Integer> errorsCache) {
		429	if (fileOrFolder.isFolder()) {
		430	for (FileObject c : fileOrFolder.getChildren()) {
		431	fillInNoErrorBadge(c, errorsCache);
		432	}
		433	}
		434
		435	errorsCache.put(fileOrFolder, 0);
		436	}
377		437
378	private boolean folderContainsErrors(File folder, boolean recursively) throws IOException {	438	private boolean folderContainsErrors(File folder, boolean recursively) throws IOException {
379	File[] errors = folder.listFiles(new FilenameFilter() {	439	File[] errors = folder.listFiles(new FilenameFilter() {