Attachment #106883 for bug #180262

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




package org.netbeans.modules.java.source.indexing;

import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Collections;

import java.util.List;
import java.util.Set;
import org.netbeans.modules.java.source.usages.BuildArtifactMapperImpl;
import org.netbeans.modules.parsing.impl.indexing.CacheFolder;
import org.netbeans.modules.parsing.impl.indexing.IndexerCache;
import org.netbeans.modules.parsing.impl.indexing.IndexerCache.IndexerInfo;
import org.netbeans.modules.parsing.spi.indexing.Context;
import org.netbeans.modules.parsing.spi.indexing.CustomIndexer;
import org.netbeans.modules.parsing.spi.indexing.CustomIndexerFactory;
import org.netbeans.modules.parsing.spi.indexing.Indexable;
import org.openide.filesystems.FileObject;
import org.openide.util.Exceptions;

/**

            return ;
        }

        Set<String> javaMimeTypes = gatherJavaMimeTypes(context.getRootURI());
        List<File> updated = new LinkedList<File>();

        for (Indexable i : files) {

        }
    }

    public static Set<String> gatherJavaMimeTypes(final URL sourceRoot) {
        Set<String> mimeTypes = new HashSet<String>();

        try {
            final FileObject cacheFolder = CacheFolder.getDataFolder(sourceRoot, true);
            if (cacheFolder != null) {
                for (IndexerInfo<CustomIndexerFactory> i : IndexerCache.getCifCache().getIndexersByName(cacheFolder.getURL(), JavaIndex.NAME)) {
                    mimeTypes.addAll(i.getMimeTypes());
                }
            }
        } catch (IOException ioe) {
            Exceptions.printStackTrace(ioe);
        }

        return mimeTypes;
    }


Lines 280-286 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/usages/BuildArtifactMapperImpl.java (-1 / +1 lines)
280	copyRecursively(index, targetFolder);	280	copyRecursively(index, targetFolder);
281		281
282	if (copyResources) {	282	if (copyResources) {
283	Set<String> javaMimeTypes = COSSynchronizingIndexer.gatherJavaMimeTypes();	283	Set<String> javaMimeTypes = COSSynchronizingIndexer.gatherJavaMimeTypes(sourceRoot);
284	String[] javaMimeTypesArr = javaMimeTypes.toArray(new String[0]);	284	String[] javaMimeTypesArr = javaMimeTypes.toArray(new String[0]);
285		285
286	copyRecursively(sr, targetFolder, javaMimeTypes, javaMimeTypesArr);	286	copyRecursively(sr, targetFolder, javaMimeTypes, javaMimeTypesArr);

Lines 45-54 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/impl/indexing/IndexerCache.java (-57 / +85 lines)
45	import java.beans.PropertyChangeEvent;	45	import java.beans.PropertyChangeEvent;
46	import java.beans.PropertyChangeListener;	46	import java.beans.PropertyChangeListener;
47	import java.beans.PropertyChangeSupport;	47	import java.beans.PropertyChangeSupport;
		48	import java.io.BufferedInputStream;
		49	import java.io.BufferedOutputStream;
		50	import java.io.File;
		51	import java.io.FileInputStream;
		52	import java.io.FileOutputStream;
48	import java.io.IOException;	53	import java.io.IOException;
49	import java.io.InputStream;	54	import java.io.InputStream;
50	import java.io.OutputStream;	55	import java.io.OutputStream;
51	import java.lang.reflect.Method;	56	import java.lang.reflect.Method;
		57	import java.net.URISyntaxException;
		58	import java.net.URL;
52	import java.text.DateFormat;	59	import java.text.DateFormat;
53	import java.util.ArrayList;	60	import java.util.ArrayList;
54	import java.util.Arrays;	61	import java.util.Arrays;
Lines 66-77 Link Here
66	import java.util.Set;	73	import java.util.Set;
67	import java.util.logging.Level;	74	import java.util.logging.Level;
68	import java.util.logging.Logger;	75	import java.util.logging.Logger;
		76	import org.netbeans.api.annotations.common.NonNull;
69	import org.netbeans.api.editor.mimelookup.MimeLookup;	77	import org.netbeans.api.editor.mimelookup.MimeLookup;
70	import org.netbeans.modules.editor.settings.storage.api.EditorSettings;	78	import org.netbeans.modules.editor.settings.storage.api.EditorSettings;
71	import org.netbeans.modules.parsing.spi.indexing.CustomIndexerFactory;	79	import org.netbeans.modules.parsing.spi.indexing.CustomIndexerFactory;
72	import org.netbeans.modules.parsing.spi.indexing.EmbeddingIndexerFactory;	80	import org.netbeans.modules.parsing.spi.indexing.EmbeddingIndexerFactory;
73	import org.openide.filesystems.FileObject;
74	import org.openide.filesystems.FileUtil;
75	import org.openide.filesystems.MIMEResolver;	81	import org.openide.filesystems.MIMEResolver;
76	import org.openide.util.Lookup;	82	import org.openide.util.Lookup;
77	import org.openide.util.LookupEvent;	83	import org.openide.util.LookupEvent;
Lines 119-152 Link Here
119	return instanceEIF;	125	return instanceEIF;
120	}	126	}
121		127
122	public Collection<? extends IndexerInfo<T>> getIndexers(Set<IndexerInfo<T>> changedIndexers) {	128	public Collection<? extends IndexerInfo<T>> getIndexers(final URL cacheRoot, final Set<IndexerInfo<T>> changedIndexers) {
123	final Object [] data = getData(changedIndexers);	129	final State<T> data = getData(cacheRoot, changedIndexers);
124	@SuppressWarnings("unchecked")	130	return data.orderedInfos;
125	List<IndexerInfo<T>> infos = (List<IndexerInfo<T>>) data[2];
126	return infos;
127	}	131	}
128		132
129	public Map<String, Set<IndexerInfo<T>>> getIndexersMap(Set<IndexerInfo<T>> changedIndexers) {	133	public Map<String, Set<IndexerInfo<T>>> getIndexersMap(final URL cacheRoot, final Set<IndexerInfo<T>> changedIndexers) {
130	final Object [] data = getData(changedIndexers);	134	final State<T> data = getData(cacheRoot, changedIndexers);
131	@SuppressWarnings("unchecked")	135	return data.infosByMimeType;
132	Map<String, Set<IndexerInfo<T>>> infosMap = (Map<String, Set<IndexerInfo<T>>>) data[1];
133	return infosMap;
134	}	136	}
135		137
136	public Collection<? extends IndexerInfo<T>> getIndexersFor(String mimeType) {	138	public Collection<? extends IndexerInfo<T>> getIndexersFor(final URL cacheRoot, final String mimeType) {
137	final Object [] data = getData(null);	139	final State<T> data = getData(cacheRoot, null);
138	@SuppressWarnings("unchecked")	140	final Set<IndexerInfo<T>> infos = data.infosByMimeType.get(mimeType);
139	Map<String, Set<IndexerInfo<T>>> infosMap = (Map<String, Set<IndexerInfo<T>>>) data[1];
140	Set<IndexerInfo<T>> infos = infosMap.get(mimeType);
141	return infos == null ? Collections.<IndexerInfo<T>>emptySet() : infos;	141	return infos == null ? Collections.<IndexerInfo<T>>emptySet() : infos;
142	}	142	}
143		143
144	public Collection<? extends IndexerInfo<T>> getIndexersByName(String indexerName) {	144	public Collection<? extends IndexerInfo<T>> getIndexersByName(final URL cacheRoot, final String indexerName) {
145	final Object [] data = getData(null);	145	final State<T> data = getData(cacheRoot, null);
146	@SuppressWarnings("unchecked")	146	return data.infosByName.get(indexerName);
147	Map<String, Set<IndexerInfo<T>>> infosMap = (Map<String, Set<IndexerInfo<T>>>) data[0];
148	Set<IndexerInfo<T>> info = infosMap.get(indexerName);
149	return info;
150	}	147	}
151		148
152		149
Lines 290-300 Link Here
290	private final String infoFileName;	287	private final String infoFileName;
291	private final Tracker tracker = new Tracker();	288	private final Tracker tracker = new Tracker();
292	private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);	289	private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);
293		290	//@GuardedBy("this")
294	private boolean firstGetData = true;	291	private final Map<URL,State<T>> stateMap = new HashMap<URL, State<T>>();
295	private Map<String, Set<IndexerInfo<T>>> infosByName = null;
296	private Map<String, Set<IndexerInfo<T>>> infosByMimeType = null;
297	private List<IndexerInfo<T>> orderedInfos = null;
298		292
299	private IndexerCache(Class<T> type) {	293	private IndexerCache(Class<T> type) {
300	this.type = type;	294	this.type = type;
Lines 340-354 Link Here
340	}	334	}
341	}	335	}
342		336
343	private Object[] getData(Set<IndexerInfo<T>> changedIndexers) {	337	private State getData(final URL cacheRoot, Set<IndexerInfo<T>> changedIndexers) {
344	boolean fire = false;	338	boolean fire = false;
345		339
346	synchronized (this) {	340	synchronized (this) {
347	if (infosByName == null) {	341	State<T> state = stateMap.get(cacheRoot);
348	Map<String, IndexerInfo<T>> lastKnownInfos = readLastKnownIndexers();	342	if (state == null) {
		343	state = new State();
		344	stateMap.put(cacheRoot, state);
		345	}
		346	if (state.infosByName == null) {
		347	Map<String, IndexerInfo<T>> lastKnownInfos = readLastKnownIndexers(cacheRoot);
349	Set<String> mimeTypesToCheck = null;	348	Set<String> mimeTypesToCheck = null;
350	if (firstGetData) {	349	if (state.firstGetData) {
351	firstGetData = false;	350	state.firstGetData = false;
352	if (changedIndexers != null) {	351	if (changedIndexers != null) {
353	mimeTypesToCheck = new HashSet<String>();	352	mimeTypesToCheck = new HashSet<String>();
354	for(IndexerInfo<T> ii : lastKnownInfos.values()) {	353	for(IndexerInfo<T> ii : lastKnownInfos.values()) {
Lines 404-417 Link Here
404	// the comparator instance must not be cached, because it uses data	403	// the comparator instance must not be cached, because it uses data
405	// from the default lookup	404	// from the default lookup
406	Collections.sort(_orderedInfos, new C());	405	Collections.sort(_orderedInfos, new C());
407	infosByName = Collections.unmodifiableMap(_infosByName);	406	state.infosByName = Collections.unmodifiableMap(_infosByName);
408	infosByMimeType = Collections.unmodifiableMap(_infosByMimeType);	407	state.infosByMimeType = Collections.unmodifiableMap(_infosByMimeType);
409	orderedInfos = Collections.unmodifiableList(_orderedInfos);	408	state.orderedInfos = Collections.unmodifiableList(_orderedInfos);
410		409
411	writeLastKnownIndexers(infosByName);	410	writeLastKnownIndexers(cacheRoot, state.infosByName);
412		411
413	Map<String, Set<IndexerInfo<T>>> addedOrChangedInfosMap = new HashMap<String, Set<IndexerInfo<T>>>();	412	Map<String, Set<IndexerInfo<T>>> addedOrChangedInfosMap = new HashMap<String, Set<IndexerInfo<T>>>();
414	diff(lastKnownInfos, infosByName, addedOrChangedInfosMap);	413	diff(lastKnownInfos, state.infosByName, addedOrChangedInfosMap);
415		414
416	for(Set<IndexerInfo<T>> addedOrChangedInfos : addedOrChangedInfosMap.values()) {	415	for(Set<IndexerInfo<T>> addedOrChangedInfos : addedOrChangedInfosMap.values()) {
417	if (changedIndexers == null) {	416	if (changedIndexers == null) {
Lines 423-429 Link Here
423		422
424	if (LOG.isLoggable(Level.FINE)) {	423	if (LOG.isLoggable(Level.FINE)) {
425	LOG.log(Level.FINE, "Ordered indexers of {0}: ", type.getName()); //NOI18N	424	LOG.log(Level.FINE, "Ordered indexers of {0}: ", type.getName()); //NOI18N
426	for (IndexerInfo<T> ii : orderedInfos) {	425	for (IndexerInfo<T> ii : state.orderedInfos) {
427	LOG.log(Level.FINE, " {0} {1}: {2}", new Object[] { //NOI18N	426	LOG.log(Level.FINE, " {0} {1}: {2}", new Object[] { //NOI18N
428	ii.getIndexerFactory(),	427	ii.getIndexerFactory(),
429	changedIndexers != null && changedIndexers.contains(ii) ? "(modified)" : "", //NOI18N	428	changedIndexers != null && changedIndexers.contains(ii) ? "(modified)" : "", //NOI18N
Lines 435-459 Link Here
435	RP.post(new Runnable() {	434	RP.post(new Runnable() {
436	public @Override void run() {	435	public @Override void run() {
437	resetCache();	436	resetCache();
438	getData(null);	437	getData(cacheRoot,null);
439	}	438	}
440	}, 321);	439	}, 321);
441	}	440	}
442	}	441	}
443		442
444	if (fire && changedIndexers.size() > 0) {	443	if (fire && changedIndexers.size() > 0) {
445	pcs.firePropertyChange(type.getName(), null, changedIndexers);	444	pcs.firePropertyChange(type.getName(), null, Pair.<URL,Set<IndexerInfo<T>>>of(cacheRoot,changedIndexers));
446	}	445	}
447		446
448	return new Object [] { infosByName, infosByMimeType, orderedInfos };	447	return new State(state);
449	}	448	}
450	}	449	}
451		450
452	private void resetCache() {	451	private void resetCache() {
453	synchronized (IndexerCache.this) {	452	synchronized (IndexerCache.this) {
454	IndexerCache.this.infosByName = null;	453	for (State<T> state : stateMap.values()) {
455	IndexerCache.this.infosByMimeType = null;	454	state.reset();
456	IndexerCache.this.orderedInfos = null;	455	}
457	LOG.log(Level.FINE, "{0}: resetting indexer cache", type.getName()); //NOI18N	456	LOG.log(Level.FINE, "{0}: resetting indexer cache", type.getName()); //NOI18N
458	}	457	}
459	}	458	}
Lines 493-507 Link Here
493	}	492	}
494	}	493	}
495		494
496	private Map<String, IndexerInfo<T>> readLastKnownIndexers() {	495	private Map<String, IndexerInfo<T>> readLastKnownIndexers(final URL cacheRoot) {
497	Map<String, IndexerInfo<T>> lki = new HashMap<String, IndexerInfo<T>>();	496	Map<String, IndexerInfo<T>> lki = new HashMap<String, IndexerInfo<T>>();
498		497	File infoFile = null;
499	FileObject cacheFolder = CacheFolder.getCacheFolder();	498	try {
500	FileObject infoFile = cacheFolder.getFileObject(infoFileName);	499	infoFile = new File(new File(cacheRoot.toURI()),infoFileName);
501	if (infoFile != null) {	500	} catch (URISyntaxException use) {
		501	LOG.log(Level.FINE, "URISyntaxException: " + cacheRoot.toString(), use); //NOI18N
		502	}
		503	if (infoFile != null && infoFile.canRead()) {
502	Properties props = new Properties();	504	Properties props = new Properties();
503	try {	505	try {
504	InputStream is = infoFile.getInputStream();	506	final InputStream is = new BufferedInputStream(new FileInputStream(infoFile));
505	try {	507	try {
506	props.load(is);	508	props.load(is);
507	} finally {	509	} finally {
Lines 554-560 Link Here
554	return lki;	556	return lki;
555	}	557	}
556		558
557	private void writeLastKnownIndexers(Map<String, Set<IndexerInfo<T>>> lki) {	559	private void writeLastKnownIndexers(final URL cacheRoot, Map<String, Set<IndexerInfo<T>>> lki) {
558	Properties props = new Properties();	560	Properties props = new Properties();
559	for(String indexerName : lki.keySet()) {	561	for(String indexerName : lki.keySet()) {
560	Set<IndexerInfo<T>> iinfos = lki.get(indexerName);	562	Set<IndexerInfo<T>> iinfos = lki.get(indexerName);
Lines 590-607 Link Here
590		592
591	props.put(indexerName, sb.toString());	593	props.put(indexerName, sb.toString());
592	}	594	}
593
594	FileObject cacheFolder = CacheFolder.getCacheFolder();
595	try {	595	try {
596	FileObject infoFile = FileUtil.createData(cacheFolder, infoFileName);	596	File infoFile = new File (new File(cacheRoot.toURI()), infoFileName);
597	OutputStream os = infoFile.getOutputStream();	597	final OutputStream os = new BufferedOutputStream(new FileOutputStream(infoFile));
598	try {	598	try {
599	props.store(os, "Last known indexer " + DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM).format(new Date())); //NOI18N	599	props.store(os, "Last known indexer " + DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM).format(new Date())); //NOI18N
600	} finally {	600	} finally {
601	os.close();	601	os.close();
602	}	602	}
603	} catch (IOException ioe) {	603	} catch (IOException ioe) {
604	LOG.log(Level.FINE, "Can't write " + infoFileName + " file in " + cacheFolder.getPath(), ioe); //NOI18N	604	LOG.log(Level.FINE, "Can't write " + infoFileName + " file in " + cacheRoot, ioe); //NOI18N
		605	} catch (URISyntaxException use) {
		606	LOG.log(Level.FINE, "Can't write " + infoFileName + " file in " + cacheRoot, use); //NOI18N
605	}	607	}
606	}	608	}
607		609
Lines 786-789 Link Here
786	return highest;	788	return highest;
787	}	789	}
788	} // End of C class	790	} // End of C class
		791
		792	private static class State<T> {
		793	private boolean firstGetData;
		794	private Map<String, Set<IndexerInfo<T>>> infosByName;
		795	private Map<String, Set<IndexerInfo<T>>> infosByMimeType;
		796	private List<IndexerInfo<T>> orderedInfos;
		797
		798	private State() {
		799	firstGetData = true;
		800	}
		801
		802	private State(final @NonNull State other) {
		803	this.firstGetData = other.firstGetData;
		804	this.infosByName = other.infosByName;
		805	this.infosByMimeType = other.infosByMimeType;
		806	this.orderedInfos = other.orderedInfos;
		807	}
		808
		809
		810
		811	private void reset() {
		812	infosByName = null;
		813	infosByMimeType = null;
		814	orderedInfos = null;
		815	}
		816	}
789	}	817	}




import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

import org.openide.util.Parameters;
import org.openide.util.RequestProcessor;
import org.openide.util.TopologicalSortException;
import org.openide.util.Union2;
import org.openide.util.lookup.ServiceProvider;

/**

        if (LOGGER.isLoggable(Level.FINE)) {
            LOGGER.fine("addIndexingJob: indexerName=" + indexerName); //NOI18N
        }
        
        Work w = new RefreshCifIndices(indexerName, scannedRoots2Dependencies.keySet(), sourcesForBinaryRoots);
        scheduleWork(w, false);
            throw new InvalidParameterException("No CustomIndexerFactory with name: '" + indexerName + "'"); //NOI18N
        } else {
            Work w = new RefreshCifIndices(cifInfos, scannedRoots2Dependencies, sourcesForBinaryRoots);
            scheduleWork(w, false);
        }
    }

    public void refreshAll(boolean fullRescan, boolean wait, boolean logStatistics, Object... filesOrFileObjects) {

        if (evt.getPropertyName() != null && evt.getPropertyName().equals(CustomIndexerFactory.class.getName())) {
            if (!ignoreIndexerCacheEvents) {
                @SuppressWarnings("unchecked")
                Pair<URL,Set<IndexerCache.IndexerInfo<CustomIndexerFactory>>> changedIndexers = (Pair<URL,Set<IndexerInfo<CustomIndexerFactory>>>) evt.getNewValue();
                scheduleWork(new RefreshCifIndices(changedIndexers.second, Collections.<URL>singleton(changedIndexers.first), sourcesForBinaryRoots), false);
            }
            return;
        } else if (evt.getPropertyName() != null && evt.getPropertyName().equals(EmbeddingIndexerFactory.class.getName())) {
            if (!ignoreIndexerCacheEvents) {
                @SuppressWarnings("unchecked")
                Pair<URL,Set<IndexerCache.IndexerInfo<EmbeddingIndexerFactory>>> changedIndexers = (Pair<URL,Set<IndexerInfo<EmbeddingIndexerFactory>>>) evt.getNewValue();
                scheduleWork(new RefreshEifIndices(changedIndexers.second, Collections.<URL>singleton(changedIndexers.first), sourcesForBinaryRoots), false);
            }
            return;
        }


                    Collection<? extends Indexable> dirty = Collections.singleton(SPIAccessor.getInstance().create(new FileObjectIndexable(root.second, docFile)));
                    String mimeType = DocumentUtilities.getMimeType(document);
                    try {
                        final FileObject cacheFolder = CacheFolder.getDataFolder(root.first);
                        final URL cacheFolderURL = cacheFolder.getURL();
                        Collection<? extends IndexerCache.IndexerInfo<CustomIndexerFactory>> cifInfos = IndexerCache.getCifCache().getIndexersFor(cacheFolderURL, mimeType);
                        for(IndexerCache.IndexerInfo<CustomIndexerFactory> info : cifInfos) {
                            try {
                                CustomIndexerFactory factory = info.getIndexerFactory();
                                Context ctx = SPIAccessor.getInstance().createContext(cacheFolder, root.first,
                                        factory.getIndexerName(), factory.getIndexVersion(), null, false, true, false, null);
                                factory.filesDirty(dirty, ctx);
                            } catch (IOException ex) {
                                LOGGER.log(Level.WARNING, null, ex);
                            }
                        }

                        Collection<? extends IndexerCache.IndexerInfo<EmbeddingIndexerFactory>> eifInfos = IndexerCache.getEifCache().getIndexersFor(cacheFolderURL, mimeType);
                        for(IndexerCache.IndexerInfo<EmbeddingIndexerFactory> info : eifInfos) {
                            try {
                                EmbeddingIndexerFactory factory = info.getIndexerFactory();
                                Context ctx = SPIAccessor.getInstance().createContext(cacheFolder, root.first,
                                        factory.getIndexerName(), factory.getIndexVersion(), null, false, true, false, null);
                                factory.filesDirty(dirty, ctx);
                            } catch (IOException ex) {
                                LOGGER.log(Level.WARNING, null, ex);
                            }
                        }
                    } catch (IOException ioe) {
                        LOGGER.log(Level.WARNING, null, ioe);
                    }
                }
            } else {

            try {
                FileObject cacheRoot = CacheFolder.getDataFolder(root);

                Collection<? extends IndexerCache.IndexerInfo<CustomIndexerFactory>> cifInfos = IndexerCache.getCifCache().getIndexers(cacheRoot.getURL(), null);
                for(IndexerCache.IndexerInfo<CustomIndexerFactory> cifInfo : cifInfos) {
                    CustomIndexerFactory factory = cifInfo.getIndexerFactory();
                    Context ctx = SPIAccessor.getInstance().createContext(cacheRoot, root, factory.getIndexerName(), factory.getIndexVersion(), null, followUpJob, checkEditor, false, null);

                    factory.filesDeleted(ci.getIndexablesFor(null), ctx);
                }

                Collection<? extends IndexerCache.IndexerInfo<EmbeddingIndexerFactory>> eifInfos = IndexerCache.getEifCache().getIndexers(cacheRoot.getURL(), null);
                for(IndexerCache.IndexerInfo<EmbeddingIndexerFactory> eifInfo : eifInfos) {
                    EmbeddingIndexerFactory factory = eifInfo.getIndexerFactory();
                    Context ctx = SPIAccessor.getInstance().createContext(cacheRoot, root, factory.getIndexerName(), factory.getIndexVersion(), null, followUpJob, checkEditor, false, null);

                    if (crawler.isFinished()) {
                        final Map<SourceIndexerFactory,Boolean> invalidatedMap = new IdentityHashMap<SourceIndexerFactory, Boolean>();
                        final Map<Pair<String,Integer>,Pair<SourceIndexerFactory,Context>> ctxToFinish = new HashMap<Pair<String,Integer>,Pair<SourceIndexerFactory,Context>>();
                        final SourceIndexers indexers = SourceIndexers.load(root, false);
                        invalidateSources(resources);
                        scanStarted (root, sourceForBinaryRoot, indexers, invalidatedMap, ctxToFinish);
                        delete(crawler.getDeletedResources(), root);


    private static class RefreshCifIndices extends Work {

        private final Union2<String,Collection<? extends IndexerCache.IndexerInfo<CustomIndexerFactory>>> cifUnion;
        private final Set<URL> rootsToRefresh;
        private final Set<URL> sourcesForBinaryRoots;

        public RefreshCifIndices(Collection<? extends IndexerCache.IndexerInfo<CustomIndexerFactory>> cifInfos, Set<URL> rootsToRefresh, Set<URL> sourcesForBinaryRoots) {
            super(false, false, NbBundle.getMessage(RepositoryUpdater.class, "MSG_RefreshingIndices"),true); //NOI18N
            this.cifUnion = Union2.<String,Collection<? extends IndexerCache.IndexerInfo<CustomIndexerFactory>>>createSecond(cifInfos);
            this.rootsToRefresh = rootsToRefresh;
            this.sourcesForBinaryRoots = sourcesForBinaryRoots;
        }

        public RefreshCifIndices(String indexerName, Set<URL> rootsToRefresh, Set<URL> sourcesForBinaryRoots) {
            super(false, false, NbBundle.getMessage(RepositoryUpdater.class, "MSG_RefreshingIndices"),true); //NOI18N
            this.cifUnion = Union2.<String,Collection<? extends IndexerCache.IndexerInfo<CustomIndexerFactory>>>createFirst(indexerName);
            this.rootsToRefresh = rootsToRefresh;
            this.sourcesForBinaryRoots = sourcesForBinaryRoots;
        }

        protected @Override boolean getDone() {
            switchProgressToDeterminate(rootsToRefresh.size());
            for(URL root : rootsToRefresh) {
                if (getShuttdownRequest().isRaised()) {
                    // XXX: this only happens when the IDE is shutting down
                    return true;

                            final LinkedList<Iterable<Indexable>> allIndexblesSentToIndexers = new LinkedList<Iterable<Indexable>>();
                            try {
                                ClusteredIndexables ci = new ClusteredIndexables(resources);
                                final FileObject cacheRoot = CacheFolder.getDataFolder(root);
                                Collection<? extends IndexerCache.IndexerInfo<CustomIndexerFactory>> cifInfos =
                                        cifUnion.hasSecond() ? cifUnion.second() : IndexerCache.getCifCache().getIndexersByName(cacheRoot.getURL(), cifUnion.first());
                                for(IndexerCache.IndexerInfo<CustomIndexerFactory> cifInfo : cifInfos) {
                                    List<Iterable<Indexable>> indexerIndexablesList = new LinkedList<Iterable<Indexable>>();
                                    for(String mimeType : cifInfo.getMimeTypes()) {

                                    }

                                    final CustomIndexerFactory factory = cifInfo.getIndexerFactory();
                                    
                                    final Context ctx = SPIAccessor.getInstance().createContext(cacheRoot, root, factory.getIndexerName(), factory.getIndexVersion(), null, false, false, sourceForBinaryRoot, getShuttdownRequest());
                                    SPIAccessor.getInstance().setAllFilesJob(ctx, true);
                                    transactionContexts.add(ctx);


        public @Override String toString() {
            StringBuilder sb = new StringBuilder();
            if (cifUnion.hasSecond()) {
                for(Iterator<? extends IndexerCache.IndexerInfo<CustomIndexerFactory>> it = cifUnion.second().iterator(); it.hasNext(); ) {
                    IndexerCache.IndexerInfo<CustomIndexerFactory> cifInfo = it.next();
                    sb.append(" indexer=").append(cifInfo.getIndexerName()).append('/').append(cifInfo.getIndexerVersion()); //NOI18N
                    sb.append(" ("); //NOI18N
                    printMimeTypes(cifInfo.getMimeTypes(), sb);
                    sb.append(')'); //NOI18N
                    if (it.hasNext()) {
                        sb.append(','); //NOI18N
                    }
                }
            } else {
                sb.append("indexerName=").append(cifUnion.first()); //NOI18N
            }
            return super.toString() + sb.toString();
        }

    private static class RefreshEifIndices extends Work {

        private final Collection<? extends IndexerCache.IndexerInfo<EmbeddingIndexerFactory>> eifInfos;
        private final Set<URL> toRefresh;
        private final Set<URL> sourcesForBinaryRoots;

        public RefreshEifIndices(Collection<? extends IndexerCache.IndexerInfo<EmbeddingIndexerFactory>> eifInfos, Set<URL> toRefresh, Set<URL> sourcesForBinaryRoots) {
            super(false, false, NbBundle.getMessage(RepositoryUpdater.class, "MSG_RefreshingIndices"),true); //NOI18N
            this.eifInfos = eifInfos;
            this.toRefresh = toRefresh;
            this.sourcesForBinaryRoots = sourcesForBinaryRoots;
        }

        protected @Override boolean getDone() {
            switchProgressToDeterminate(toRefresh.size());
            for(URL root : toRefresh) {
                if (getShuttdownRequest().isRaised()) {
                    // XXX: this only happens when the IDE is shutting down
                    return true;


            boolean finished = scanBinaries(depCtx);
            if (finished) {
                finished = scanSources(depCtx, false, null);
                if (finished) {
                    finished = scanRootFiles(fullRescanFiles);
                    if (finished) {

        private boolean useInitialState;

        private DependenciesContext depCtx;
        protected SourceIndexers indexers = null; // is only ever filled by InitialRootsWork

        public RootsWork(
                Map<URL, List<URL>> scannedRoots2Depencencies,

            switchProgressToDeterminate(depCtx.newBinariesToScan.size() + depCtx.newRootsToScan.size());
            boolean finished = scanBinaries(depCtx);
            if (finished) {
                finished = scanSources(depCtx, true, scannedRoots2Dependencies);
            }

            final List<URL> missingRoots = new LinkedList<URL>();

            }

            if (!sources.isEmpty()) {
                final IndexerCache<CustomIndexerFactory> cifCache = IndexerCache.getCifCache();
                final IndexerCache<EmbeddingIndexerFactory> eifCache = IndexerCache.getEifCache();
                Map<IndexerCache.IndexerInfo<? extends SourceIndexerFactory >,Collection<URL>> rootsByFactories = new HashMap<IndexerInfo<? extends SourceIndexerFactory>, Collection<URL>>();
                for (URL source : sources) {
                    try {
                        final FileObject cacheFolder = CacheFolder.getDataFolder(source, true);
                        final URL cacheFolderURL = cacheFolder.getURL();
                        final Collection<? extends IndexerCache.IndexerInfo<CustomIndexerFactory>> cinfos = cifCache.getIndexers(cacheFolderURL, null);
                        for (IndexerCache.IndexerInfo<CustomIndexerFactory> info : cinfos) {
                            Collection<URL> rootsSet = rootsByFactories.get(info);
                            if (rootsSet == null) {
                                rootsSet = new HashSet<URL>();
                                rootsByFactories.put(info, rootsSet);
                            }
                            rootsSet.add(source);
                        }
                        final Collection<? extends IndexerCache.IndexerInfo<EmbeddingIndexerFactory>> einfos = eifCache.getIndexers(cacheFolderURL, null);
                        for (IndexerCache.IndexerInfo<EmbeddingIndexerFactory> info : einfos) {
                            Collection<URL> rootsSet = rootsByFactories.get(info);
                            if (rootsSet == null) {
                                rootsSet = new HashSet<URL>();
                                rootsByFactories.put(info, rootsSet);
                            }
                            rootsSet.add(source);
                        }
                    } catch (IOException ioe) {
                        LOGGER.log(Level.WARNING, null, ioe);
                    }
                }
                for (Map.Entry<IndexerCache.IndexerInfo<? extends SourceIndexerFactory>,Collection<URL>> e : rootsByFactories.entrySet()) {
                    e.getKey().getIndexerFactory().rootsRemoved(Collections.unmodifiableCollection(e.getValue()));
                for (IndexerCache.IndexerInfo<EmbeddingIndexerFactory> embeddingIndexer : embeddingIndexers) {
                    embeddingIndexer.getIndexerFactory().rootsRemoved(roots);
                }
                RepositoryUpdater.getDefault().rootsListeners.remove(sources, true);
            }

            return false;
        }

        protected final boolean scanSources(DependenciesContext ctx, boolean detectIndexerChanges, Map<URL, List<URL>> preregisterIn) {
            assert ctx != null;
            long scannedRootsCnt = 0;
            long completeTime = 0;

            int totalDeletedFiles = 0;
            long totalRecursiveListenersTime = 0;
            boolean finished = true;
            
            if (indexers == null) {
                indexers = SourceIndexers.load(false);
            }

            for (URL source : ctx.newRootsToScan) {
                if (isCancelled()) {
                    finished = false;

                        preregistered = true;
                    }
                    try {
                        final SourceIndexers indexers = SourceIndexers.load(source, detectIndexerChanges);
                        if (scanSource (source, ctx.fullRescanSourceRoots.contains(source), ctx.sourcesForBinaryRoots.contains(source), indexers, outOfDateFiles, deletedFiles, recursiveListenersTime)) {
                            ctx.scannedRoots.add(source);
                            success = true;

        
        public @Override boolean getDone() {
            try {
                if (indexers == null) {
                    indexers = SourceIndexers.load(true);
                }

                if (waitForProjects) {
                    boolean retry = true;
                    while (retry) {


    private static final class SourceIndexers {

        public static SourceIndexers load(final URL sourceRoot, final boolean detectChanges) throws IOException {
            return new SourceIndexers(sourceRoot, detectChanges);
        }

        public final Set<IndexerCache.IndexerInfo<CustomIndexerFactory>> changedCifs;

        public final Set<IndexerCache.IndexerInfo<EmbeddingIndexerFactory>> changedEifs;
        public final Map<String, Set<IndexerCache.IndexerInfo<EmbeddingIndexerFactory>>> eifInfosMap;

        private SourceIndexers(final URL sourceRoot, final boolean detectChanges) throws IOException {
            final long start = System.currentTimeMillis();
            if (detectChanges) {
                changedCifs = new HashSet<IndexerCache.IndexerInfo<CustomIndexerFactory>>();

                changedCifs = null;
                changedEifs = null;
            }
            final URL cacheRootURL = CacheFolder.getDataFolder(sourceRoot).getURL();
            cifInfos = IndexerCache.getCifCache().getIndexers(cacheRootURL, changedCifs);
            eifInfosMap = IndexerCache.getEifCache().getIndexersMap(cacheRootURL, changedEifs);
            
            final long delta = System.currentTimeMillis() - start;
            LOGGER.log(Level.FINE, "Loading indexers took {0} ms.", delta); // NOI18N

Return to bug 180262

Lines 43-48 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/indexing/COSSynchronizingIndexer.java (-5 / +14 lines)
43	package org.netbeans.modules.java.source.indexing;	43	package org.netbeans.modules.java.source.indexing;
44		44
45	import java.io.File;	45	import java.io.File;
		46	import java.io.IOException;
46	import java.net.URISyntaxException;	47	import java.net.URISyntaxException;
47	import java.net.URL;	48	import java.net.URL;
48	import java.util.Collections;	49	import java.util.Collections;
Lines 51-62 Link Here
51	import java.util.List;	52	import java.util.List;
52	import java.util.Set;	53	import java.util.Set;
53	import org.netbeans.modules.java.source.usages.BuildArtifactMapperImpl;	54	import org.netbeans.modules.java.source.usages.BuildArtifactMapperImpl;
		55	import org.netbeans.modules.parsing.impl.indexing.CacheFolder;
54	import org.netbeans.modules.parsing.impl.indexing.IndexerCache;	56	import org.netbeans.modules.parsing.impl.indexing.IndexerCache;
55	import org.netbeans.modules.parsing.impl.indexing.IndexerCache.IndexerInfo;	57	import org.netbeans.modules.parsing.impl.indexing.IndexerCache.IndexerInfo;
56	import org.netbeans.modules.parsing.spi.indexing.Context;	58	import org.netbeans.modules.parsing.spi.indexing.Context;
57	import org.netbeans.modules.parsing.spi.indexing.CustomIndexer;	59	import org.netbeans.modules.parsing.spi.indexing.CustomIndexer;
58	import org.netbeans.modules.parsing.spi.indexing.CustomIndexerFactory;	60	import org.netbeans.modules.parsing.spi.indexing.CustomIndexerFactory;
59	import org.netbeans.modules.parsing.spi.indexing.Indexable;	61	import org.netbeans.modules.parsing.spi.indexing.Indexable;
		62	import org.openide.filesystems.FileObject;
60	import org.openide.util.Exceptions;	63	import org.openide.util.Exceptions;
61		64
62	/**	65	/**
Lines 71-77 Link Here
71	return ;	74	return ;
72	}	75	}
73		76
74	Set<String> javaMimeTypes = gatherJavaMimeTypes();	77	Set<String> javaMimeTypes = gatherJavaMimeTypes(context.getRootURI());
75	List<File> updated = new LinkedList<File>();	78	List<File> updated = new LinkedList<File>();
76		79
77	for (Indexable i : files) {	80	for (Indexable i : files) {
Lines 103-115 Link Here
103	}	106	}
104	}	107	}
105		108
106	public static Set<String> gatherJavaMimeTypes() {	109	public static Set<String> gatherJavaMimeTypes(final URL sourceRoot) {
107	Set<String> mimeTypes = new HashSet<String>();	110	Set<String> mimeTypes = new HashSet<String>();
108		111
109	for (IndexerInfo<CustomIndexerFactory> i : IndexerCache.getCifCache().getIndexersByName(JavaIndex.NAME)) {	112	try {
110	mimeTypes.addAll(i.getMimeTypes());	113	final FileObject cacheFolder = CacheFolder.getDataFolder(sourceRoot, true);
		114	if (cacheFolder != null) {
		115	for (IndexerInfo<CustomIndexerFactory> i : IndexerCache.getCifCache().getIndexersByName(cacheFolder.getURL(), JavaIndex.NAME)) {
		116	mimeTypes.addAll(i.getMimeTypes());
		117	}
		118	}
		119	} catch (IOException ioe) {
		120	Exceptions.printStackTrace(ioe);
111	}	121	}
112
113	return mimeTypes;	122	return mimeTypes;
114	}	123	}
115		124