Attachment #115691 for bug #208378

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

Lines 181-190 Link Here

(-)a/csl.api/test/unit/src/org/netbeans/modules/csl/api/test/CslTestBase.java (-4 / +3 lines)
181	import org.netbeans.modules.parsing.api.Snapshot;	181	import org.netbeans.modules.parsing.api.Snapshot;
182	import org.netbeans.modules.parsing.api.Source;	182	import org.netbeans.modules.parsing.api.Source;
183	import org.netbeans.modules.parsing.api.UserTask;	183	import org.netbeans.modules.parsing.api.UserTask;
184	import org.netbeans.modules.parsing.impl.indexing.CacheFolder;	184	import org.netbeans.modules.parsing.impl.indexing.*;
185	import org.netbeans.modules.parsing.impl.indexing.FileObjectIndexable;
186	import org.netbeans.modules.parsing.impl.indexing.RepositoryUpdater;
187	import org.netbeans.modules.parsing.impl.indexing.SPIAccessor;
188	import org.netbeans.modules.parsing.impl.indexing.lucene.LayeredDocumentIndex;	185	import org.netbeans.modules.parsing.impl.indexing.lucene.LayeredDocumentIndex;
189	import org.netbeans.modules.parsing.impl.indexing.lucene.LuceneIndexFactory;	186	import org.netbeans.modules.parsing.impl.indexing.lucene.LuceneIndexFactory;
190	import org.netbeans.modules.parsing.impl.indexing.lucene.TestIndexFactoryImpl;	187	import org.netbeans.modules.parsing.impl.indexing.lucene.TestIndexFactoryImpl;
Lines 1562-1567 Link Here
1562	false,	1559	false,
1563	false,	1560	false,
1564	false,	1561	false,
		1562	SuspendSupport.NOP,
		1563	null,
1565	null	1564	null
1566	);	1565	);
1567		1566




import org.netbeans.modules.java.source.parsing.FileObjects;
import org.netbeans.modules.java.source.usages.ClassIndexImpl.UsageType;
import org.netbeans.modules.parsing.impl.indexing.SPIAccessor;
import org.netbeans.modules.parsing.impl.indexing.SuspendSupport;
import org.netbeans.modules.parsing.lucene.support.LowMemoryWatcher;
import org.netbeans.modules.parsing.spi.indexing.Context;
import org.openide.filesystems.FileObject;

     */
    @Deprecated
    public final Result start (final @NonNull URL url, final AtomicBoolean canceled, final AtomicBoolean shutdown) throws IOException, IllegalArgumentException  {
        return start (
                url,
                SPIAccessor.getInstance().createContext(
                    FileUtil.createMemoryFileSystem().getRoot(),
                    url,
                    JavaIndex.NAME,
                    JavaIndex.VERSION,
                    null,
                    false,
                    false,
                    false,
                    SuspendSupport.NOP,
                    null,
                    null));
    }

    public Result resume () throws IOException {




<!-- ACTUAL CHANGES BEGIN HERE: -->

  <changes>
  <change id="SuspendStatus">
      <api name="ParsingAPI"/>
      <summary>Added <code>SuspendStatus</code> service which can be used by indexers to find out if
      indexing is suspended.</summary>
      <version major="1" minor="52"/>
      <date day="17" month="2" year="2012"/>
      <author login="tzezula"/>
      <compatibility source="compatible" binary="compatible" semantic="compatible" deletion="no" addition="yes" modification="no"/>
      <description>
          <p>
               The indexing is suspended by the infrastructure when high priority request like index query or execution
               of <code>UserTask</code>, <code>ParserResultTask</code> is in progress. The <code>SuspendStatus</code>
               allows indexers to find out that indexing is suspended or to park while it's suspended.
          </p>
      </description>
      <class package="org.netbeans.modules.parsing.spi.indexing" name="SuspendedStatus"/>
      <class package="org.netbeans.modules.parsing.spi.indexing" name="Context"/>
      <issue number="208378"/>
  </change>
  <change id="IndexingAwareParserResultTask">
      <api name="ParsingAPI"/>
      <summary>Added <code>IndexingAwareParserResultTask</code> which is a specialization of <code>ParserResultTask</code>

Lines 3-6 Link Here

(-)a/parsing.api/nbproject/project.properties (-1 / +1 lines)
3	javac.source=1.6	3	javac.source=1.6
4	javadoc.apichanges=${basedir}/apichanges.xml	4	javadoc.apichanges=${basedir}/apichanges.xml
5	javadoc.arch=${basedir}/arch.xml	5	javadoc.arch=${basedir}/arch.xml
6	spec.version.base=1.51.0	6	spec.version.base=1.52.0

Lines 42-47 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/impl/indexing/Crawler.java (+1 lines)
42		42
43	package org.netbeans.modules.parsing.impl.indexing;	43	package org.netbeans.modules.parsing.impl.indexing;
44		44
		45	import org.netbeans.modules.parsing.spi.indexing.SuspendStatus;
45	import java.io.IOException;	46	import java.io.IOException;
46	import java.net.URL;	47	import java.net.URL;
47	import java.util.ArrayList;	48	import java.util.ArrayList;

Lines 42-47 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/impl/indexing/FileObjectCrawler.java (+1 lines)
42		42
43	package org.netbeans.modules.parsing.impl.indexing;	43	package org.netbeans.modules.parsing.impl.indexing;
44		44
		45	import org.netbeans.modules.parsing.spi.indexing.SuspendStatus;
45	import java.io.File;	46	import java.io.File;
46	import java.io.IOException;	47	import java.io.IOException;
47	import java.util.Collection;	48	import java.util.Collection;




import org.netbeans.modules.parsing.lucene.support.IndexManager;
import org.netbeans.modules.parsing.spi.ParseException;
import org.netbeans.modules.parsing.spi.Parser;
import org.netbeans.modules.parsing.spi.indexing.*;
import org.netbeans.modules.parsing.spi.indexing.BinaryIndexerFactory;
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.EmbeddingIndexer;
import org.netbeans.modules.parsing.spi.indexing.EmbeddingIndexerFactory;
import org.netbeans.modules.parsing.spi.indexing.Indexable;
import org.netbeans.modules.parsing.spi.indexing.SourceIndexerFactory;
import org.openide.filesystems.FileChangeAdapter;
import org.openide.filesystems.FileChangeListener;
import org.openide.filesystems.FileEvent;

                        scannedRoots2Peers,
                        sourcesForBinaryRoots,
                        false,
                        suspendSupport.getSuspendStatus(),
                        LogContext.create(LogContext.EventType.PATH, null));
                }
            }

                    forceRefresh,
                    sourcesForBinaryRoots.contains(rootUrl),
                    steady,
                    suspendSupport.getSuspendStatus(),
                    logCtx);
            }
        } else {

                checkEditor,
                forceRefresh,
                sourcesForBinaryRoots.contains(rootUrl),
                suspendSupport.getSuspendStatus(),
                logCtx);
        }
        return flw;

        if (cifInfos == null) {
            throw new InvalidParameterException("No CustomIndexerFactory with name: '" + indexerName + "'"); //NOI18N
        } else {
            Work w = new RefreshCifIndices(cifInfos, scannedRoots2Dependencies, sourcesForBinaryRoots, suspendSupport.getSuspendStatus(), logCtx);
            scheduleWork(w, false);
        }
    }

                logStatistics,
                filesOrFileObjects == null ? Collections.<Object>emptySet() : Arrays.asList(filesOrFileObjects),
                fsRefreshInterceptor,
                suspendSupport.getSuspendStatus(),
                logCtx),
            wait);
    }

                        scannedRoots2Peers,
                        sourcesForBinaryRoots,
                        !existingPathsChanged,
                        suspendSupport.getSuspendStatus(),
                        logContext),
                    false);
        }

                    false,
                    false,
                    sourcesForBinaryRoots.contains(rootUrl),
                    suspendSupport.getSuspendStatus(),
                    logContext),
                false);
        }

                                    scannedRoots2Peers,
                                    sourcesForBinaryRoots,
                                    false,
                                    suspendSupport.getSuspendStatus(),
                                    LogContext.create(LogContext.EventType.FILE, null));
                            } else {
                                //Already seen files work is enough

                                        true,
                                        sourcForBinaryRoot,
                                        true,
                                        suspendSupport.getSuspendStatus(),
                                        LogContext.create(LogContext.EventType.FILE, null));
                                } else {
                                    //If no children nothing needs to be done - save some CPU time

                                true,
                                sourcForBinaryRoot,
                                true,
                                suspendSupport.getSuspendStatus(),
                                LogContext.create(LogContext.EventType.FILE, null));
                        }
                        if (wrk != null) {

                if (root != null && isVisible(fo, root.second)) {
                    final Work wrk = new BinaryWork(
                        root.first,
                        suspendSupport.getSuspendStatus(),
                        LogContext.create(LogContext.EventType.FILE, null));
                    eventQueue.record(FileEventLog.FileOp.CREATE, root.first, null, fe, wrk);
                    processed = true;

                            true,
                            sourceForBinaryRoot,
                            true,
                            suspendSupport.getSuspendStatus(),
                            LogContext.create(LogContext.EventType.FILE, null));
                        eventQueue.record(FileEventLog.FileOp.CREATE, root.first, FileUtil.getRelativePath(root.second, fo), fe, wrk);
                        processed = true;

                if (root != null && isVisible(fo,root.second)) {
                    final Work wrk = new BinaryWork(
                        root.first,
                        suspendSupport.getSuspendStatus(),
                        LogContext.create(LogContext.EventType.FILE, null));
                    eventQueue.record(FileEventLog.FileOp.CREATE, root.first, null, fe, wrk);
                    processed = true;

                        final Work wrk = new DeleteWork(
                            root.first,
                            Collections.singleton(relativePath),
                            suspendSupport.getSuspendStatus(),
                            LogContext.create(LogContext.EventType.FILE, null));
                        eventQueue.record(FileEventLog.FileOp.DELETE, root.first, relativePath, fe, wrk);
                        processed = true;

                if (root != null && isVisible(fo, root.second)) {
                    final Work wrk = new BinaryWork(
                        root.first,
                        suspendSupport.getSuspendStatus(),
                        LogContext.create(LogContext.EventType.FILE, null));
                    eventQueue.record(FileEventLog.FileOp.DELETE, root.first, null, fe, wrk);
                    processed = true;

                        final Work work = new DeleteWork(
                            root.first,
                            Collections.singleton(oldFilePath),
                            suspendSupport.getSuspendStatus(),
                            LogContext.create(LogContext.EventType.FILE, null));
                        eventQueue.record(FileEventLog.FileOp.DELETE, root.first, oldFilePath, fe, work);
                    } else {

                            final Work work = new DeleteWork(
                                root.first,
                                oldFilePaths,
                                suspendSupport.getSuspendStatus(),
                                LogContext.create(LogContext.EventType.FILE, null));
                            eventQueue.record(FileEventLog.FileOp.DELETE, root.first, path, fe, work);
                        }

                                true,
                                sourceForBinaryRoot,
                                true,
                                suspendSupport.getSuspendStatus(),
                                LogContext.create(LogContext.EventType.FILE, null));
                            eventQueue.record(FileEventLog.FileOp.CREATE, root.first, FileUtil.getRelativePath(rootFo, newFile), fe,flw);
                        }

                                    null,
                                    fe,
                                    new BinaryWork(oldBinaryRoot,
                                        suspendSupport.getSuspendStatus(),
                                        LogContext.create(LogContext.EventType.FILE, null)));    //NOI18N
                        } catch (MalformedURLException mue) {
                            LOGGER.log(Level.WARNING, null, mue);

                            null,
                            fe,
                            new BinaryWork(root.first,
                                suspendSupport.getSuspendStatus(),
                                LogContext.create(LogContext.EventType.FILE, null)));
                    processed = true;
                }

                        changedIndexers,
                        scannedRoots2Dependencies,
                        sourcesForBinaryRoots,
                        suspendSupport.getSuspendStatus(),
                        LogContext.create(LogContext.EventType.INDEXER,null)),
                        false);
            }

                        changedIndexers,
                        scannedRoots2Dependencies,
                        sourcesForBinaryRoots,
                        suspendSupport.getSuspendStatus(),
                        LogContext.create(LogContext.EventType.INDEXER, null)),
                        false);
            }

                                    true,
                                    sourcesForBinaryRoots.contains(root.first),
                                    true,
                                    suspendSupport.getSuspendStatus(),
                                    LogContext.create(LogContext.EventType.FILE, null));
                            jobs.put(root.first, job);
                        } else {

                    for(IndexerCache.IndexerInfo<CustomIndexerFactory> info : cifInfos) {
                        try {
                            CustomIndexerFactory factory = info.getIndexerFactory();
                            Context ctx = SPIAccessor.getInstance().createContext(
                                    CacheFolder.getDataFolder(root.first),
                                    root.first,
                                    factory.getIndexerName(),
                                    factory.getIndexVersion(),
                                    null,
                                    false,
                                    true,
                                    false,
                                    SuspendSupport.NOP,
                                    null,
                                    null);
                            factory.filesDirty(dirty, ctx);
                        } catch (IOException ex) {
                            LOGGER.log(Level.WARNING, null, ex);

                    for(IndexerCache.IndexerInfo<EmbeddingIndexerFactory> info : eifInfos) {
                        try {
                            EmbeddingIndexerFactory factory = info.getIndexerFactory();
                            Context ctx = SPIAccessor.getInstance().createContext(
                                    CacheFolder.getDataFolder(root.first),
                                    root.first,
                                    factory.getIndexerName(),
                                    factory.getIndexVersion(),
                                    null,
                                    false,
                                    true,
                                    false,
                                    SuspendSupport.NOP,
                                    null,
                                    null);
                            factory.filesDirty(dirty, ctx);
                        } catch (IOException ex) {
                            LOGGER.log(Level.WARNING, null, ex);

                scannedRoots2Peers,
                sourcesForBinaryRoots,
                true,
                suspendSupport.getSuspendStatus(),
                work == null ?
                    LogContext.create(LogContext.EventType.PATH, null)
                    : work.getLogContext()), false);

                final Pair<String,Integer> key = Pair.of(factory.getIndexerName(),factory.getIndexVersion());
                Pair<SourceIndexerFactory,Context> value = ctxToFinish.get(key);
                if (value == null) {
                    final Context ctx = SPIAccessor.getInstance().createContext(
                            cacheRoot,
                            root,
                            factory.getIndexerName(),
                            factory.getIndexVersion(),
                            null,
                            followUpJob,
                            checkEditor,
                            sourceForBinaryRoot,
                            getSuspendStatus(),
                            getShuttdownRequest(),
                            null);
                    value = Pair.<SourceIndexerFactory,Context>of(factory,ctx);
                    ctxToFinish.put(key,value);
                }

                    final Pair<String,Integer> key = Pair.of(eif.getIndexerName(), eif.getIndexVersion());
                    Pair<SourceIndexerFactory,Context> value = ctxToFinish.get(key);
                    if (value == null) {
                        final Context context = SPIAccessor.getInstance().createContext(
                                cacheRoot,
                                root,
                                eif.getIndexerName(),
                                eif.getIndexVersion(),
                                null,
                                followUpJob,
                                checkEditor,
                                sourceForBinaryRoot,
                                getSuspendStatus(),
                                getShuttdownRequest(),
                                null);
                        value = Pair.<SourceIndexerFactory,Context>of(eif,context);
                        ctxToFinish.put(key, value);
                    }

                        final Pair<String,Integer> key = Pair.of(factory.getIndexerName(),factory.getIndexVersion());
                        Pair<SourceIndexerFactory,Context> value = contexts.get(key);
                        if (value == null) {
                            final Context ctx = SPIAccessor.getInstance().createContext(
                                    cacheRoot,
                                    root,
                                    factory.getIndexerName(),
                                    factory.getIndexVersion(),
                                    null,
                                    followUpJob,
                                    checkEditor,
                                    sourceForBinaryRoot,
                                    getSuspendStatus(),
                                    getShuttdownRequest(),
                                    null);
                            value = Pair.<SourceIndexerFactory,Context>of(factory,ctx);
                            contexts.put(key,value);
                        }

                                    final Pair<String,Integer> key = Pair.of(factory.getIndexerName(),factory.getIndexVersion());
                                    Pair<SourceIndexerFactory,Context> value = contexts.get(key);
                                    if (value == null) {
                                        final Context ctx = SPIAccessor.getInstance().createContext(
                                                cacheRoot,
                                                root,
                                                factory.getIndexerName(),
                                                factory.getIndexVersion(),
                                                null,
                                                followUpJob,
                                                checkEditor,
                                                sourceForBinaryRoot,
                                                getSuspendStatus(),
                                                getShuttdownRequest(),
                                                null);
                                        value = Pair.<SourceIndexerFactory,Context>of(factory,ctx);
                                        contexts.put(key,value);
                                    }

            final FileObject cacheRoot = CacheFolder.getDataFolder(root);
            for(BinaryIndexerFactory bif : indexers.bifs) {
                final Context ctx = SPIAccessor.getInstance().createContext(
                    cacheRoot,
                    root,
                    bif.getIndexerName(),
                    bif.getIndexVersion(),
                    null,
                    false,
                    false,
                    false,
                    getSuspendStatus(),
                    getShuttdownRequest(),
                    null);
                contexts.put(bif, ctx);
            }
        }

                                            final Pair<String,Integer> key = Pair.of(indexerName,indexerVersion);
                                            Pair<SourceIndexerFactory,Context> value = transactionContexts.get(key);
                                            if (value == null) {
                                                final Context context = SPIAccessor.getInstance().createContext(
                                                        cache,
                                                        rootURL,
                                                        indexerName,
                                                        indexerVersion,
                                                        null,
                                                        followUpJob,
                                                        checkEditor,
                                                        sourceForBinaryRoot,
                                                        getSuspendStatus(),
                                                        getShuttdownRequest(),
                                                        null);
                                                value = Pair.<SourceIndexerFactory,Context>of(indexerFactory,context);
                                                transactionContexts.put(key,value);
                                            }




            boolean followUpJob,
            boolean checkForEditorModifications,
            boolean sourceForBinaryRoot,
            @NonNull final SuspendStatus suspendedStatus,
            @NullAllowed final CancelRequest cancelRequest,
            @NullAllowed final LogContext logContext) throws IOException;
    
    @NonNull
    public abstract SuspendStatus createSuspendStatus(@NonNull SuspendSupport.SuspendStatusImpl impl);
            String indexerName, int indexerVersion, IndexFactoryImpl factory,
            boolean followUpJob, boolean checkForEditorModifications,
            boolean sourceForBinaryRoot, CancelRequest cancelRequest) throws IOException {
        return createContext(
            indexFolder,
            rootURL,
            indexerName,
            indexerVersion,
            factory,
            followUpJob,
            checkForEditorModifications,
            sourceForBinaryRoot,
            cancelRequest,
            null);
    }

    public abstract void context_attachIndexingSupport(Context context, IndexingSupport support);


Lines 41-46 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/impl/indexing/SuspendSupport.java (-34 / +55 lines)
41	*/	41	*/
42	package org.netbeans.modules.parsing.impl.indexing;	42	package org.netbeans.modules.parsing.impl.indexing;
43		43
		44	import org.netbeans.modules.parsing.spi.indexing.SuspendStatus;
44	import java.util.Arrays;	45	import java.util.Arrays;
45	import java.util.logging.Level;	46	import java.util.logging.Level;
46	import java.util.logging.Logger;	47	import java.util.logging.Logger;
Lines 53-59 Link Here
53	*	54	*
54	* @author Tomas Zezula	55	* @author Tomas Zezula
55	*/	56	*/
56	final class SuspendSupport implements SuspendStatus {	57	public final class SuspendSupport {
57		58
58	private static final Logger LOG = Logger.getLogger(SuspendSupport.class.getName());	59	private static final Logger LOG = Logger.getLogger(SuspendSupport.class.getName());
59	private static final boolean NO_SUSPEND = Boolean.getBoolean("SuspendSupport.disabled"); //NOI18N	60	private static final boolean NO_SUSPEND = Boolean.getBoolean("SuspendSupport.disabled"); //NOI18N
Lines 61-75 Link Here
61	private final RequestProcessor worker;	62	private final RequestProcessor worker;
62	private final Object lock = new Object();	63	private final Object lock = new Object();
63	private final ThreadLocal<Boolean> ignoreSuspend = new ThreadLocal<Boolean>();	64	private final ThreadLocal<Boolean> ignoreSuspend = new ThreadLocal<Boolean>();
		65	private final SuspendStatus suspendStatus = SPIAccessor.getInstance().createSuspendStatus(new DefaultImpl());
64	//@GuardedBy("lock")	66	//@GuardedBy("lock")
65	private int suspedDepth;	67	private int suspedDepth;
		68
		69	public static final SuspendStatus NOP = SPIAccessor.getInstance().createSuspendStatus(new NopImpl());
66		70
		71
		72	@NonNull
		73	public SuspendStatus getSuspendStatus() {
		74	return suspendStatus;
		75	}
		76
		77	public static interface SuspendStatusImpl {
		78	public boolean isSuspended();
		79	public void parkWhileSuspended() throws InterruptedException;
		80	}
		81
		82
		83
		84	//-- Package private --
		85
67	SuspendSupport(@NonNull final RequestProcessor rp) {	86	SuspendSupport(@NonNull final RequestProcessor rp) {
68	Parameters.notNull("rp", rp); //NOI18N	87	Parameters.notNull("rp", rp); //NOI18N
69	this.worker = rp;	88	this.worker = rp;
70	}	89	}
71		90
72	public void suspend() {	91	void suspend() {
73	if (NO_SUSPEND) {	92	if (NO_SUSPEND) {
74	return;	93	return;
75	}	94	}
Lines 87-93 Link Here
87	}	106	}
88	}	107	}
89		108
90	public void resume() {	109	void resume() {
91	if (NO_SUSPEND) {	110	if (NO_SUSPEND) {
92	return;	111	return;
93	}	112	}
Lines 104-110 Link Here
104	}	123	}
105	}	124	}
106		125
107	public void runWithNoSuspend(final Runnable work) {	126	void runWithNoSuspend(final Runnable work) {
108	ignoreSuspend.set(Boolean.TRUE);	127	ignoreSuspend.set(Boolean.TRUE);
109	try {	128	try {
110	work.run();	129	work.run();
Lines 112-147 Link Here
112	ignoreSuspend.remove();	131	ignoreSuspend.remove();
113	}	132	}
114	}	133	}
115
116	@Override
117	public boolean isSuspended() {
118	if (ignoreSuspend.get() == Boolean.TRUE) {
119	return false;
120	}
121	synchronized(lock) {
122	return suspedDepth > 0;
123	}
124	}
125
126	@Override
127	public void parkWhileSuspended() throws InterruptedException {
128	if (ignoreSuspend.get() == Boolean.TRUE) {
129	return;
130	}
131	synchronized(lock) {
132	boolean parked = false;
133	while (suspedDepth > 0) {
134	LOG.fine("PARK"); //NOI18N
135	lock.wait();
136	parked = true;
137	}
138	if (LOG.isLoggable(Level.FINE) && parked) {
139	LOG.fine("UNPARK"); //NOI18N
140	}
141	}
142	}
143		134
144	static final SuspendStatus NOP = new SuspendStatus () {	135	private static final class NopImpl implements SuspendStatusImpl {
145	@Override	136	@Override
146	public boolean isSuspended() {	137	public boolean isSuspended() {
147	return false;	138	return false;
Lines 149-154 Link Here
149	@Override	140	@Override
150	public void parkWhileSuspended() throws InterruptedException {	141	public void parkWhileSuspended() throws InterruptedException {
151	}	142	}
152	};	143	}
		144
		145	private final class DefaultImpl implements SuspendStatusImpl {
		146	@Override
		147	public boolean isSuspended() {
		148	if (ignoreSuspend.get() == Boolean.TRUE) {
		149	return false;
		150	}
		151	synchronized(lock) {
		152	return suspedDepth > 0;
		153	}
		154	}
		155
		156	@Override
		157	public void parkWhileSuspended() throws InterruptedException {
		158	if (ignoreSuspend.get() == Boolean.TRUE) {
		159	return;
		160	}
		161	synchronized(lock) {
		162	boolean parked = false;
		163	while (suspedDepth > 0) {
		164	LOG.fine("PARK"); //NOI18N
		165	lock.wait();
		166	parked = true;
		167	}
		168	if (LOG.isLoggable(Level.FINE) && parked) {
		169	LOG.fine("UNPARK"); //NOI18N
		170	}
		171	}
		172	}
		173	}
153		174
154	}	175	}




    private final boolean checkForEditorModifications;
    private final boolean sourceForBinaryRoot;
    private final CancelRequest cancelRequest;
    private final SuspendStatus suspendedStatus;
    private final LogContext logContext;
    private final Map<String,Object> props;
    private FileObject indexFolder;

             final IndexFactoryImpl factory, boolean followUpJob,
             final boolean checkForEditorModifications,
             final boolean sourceForBinaryRoot,
             @NonNull final SuspendStatus suspendedStatus,
             @NullAllowed final CancelRequest cancelRequest,
             @NullAllowed final LogContext logContext
    ) throws IOException {
        assert indexBaseFolder != null;

        this.checkForEditorModifications = checkForEditorModifications;
        this.sourceForBinaryRoot = sourceForBinaryRoot;
        this.cancelRequest = cancelRequest;
        this.suspendedStatus = suspendedStatus;
        this.logContext = logContext;
        this.props = new HashMap<String, Object>();
    }

    public boolean isCancelled() {
        return cancelRequest == null ? false : cancelRequest.isRaised();
    }
    
    /**
     * Returns {@link SuspendStatus} providing information
     * about indexing suspension.
     * @return the {@link SuspendStatus}
     * @since 1.52
     */
    @NonNull
    public SuspendStatus getSuspendStatus() {
        return suspendedStatus;
    }

    // -----------------------------------------------------------------------
    // Package private implementation




import org.netbeans.modules.parsing.impl.indexing.LogContext;
import org.netbeans.modules.parsing.impl.indexing.RepositoryUpdater;
import org.netbeans.modules.parsing.impl.indexing.SPIAccessor;
import org.netbeans.modules.parsing.impl.indexing.SuspendSupport.SuspendStatusImpl;
import org.netbeans.modules.parsing.spi.Parser.Result;
import org.netbeans.modules.parsing.spi.indexing.support.IndexingSupport;
import org.openide.filesystems.FileObject;

                boolean followUpJob,
                boolean checkForEditorModifications,
                boolean sourceForBinaryRoot,
                @NonNull SuspendStatus suspendedStatus,
                @NullAllowed CancelRequest cancelRequest,
                @NullAllowed final LogContext logContext) throws IOException {
            return new Context(
                    indexFolder,

                    followUpJob,
                    checkForEditorModifications,
                    sourceForBinaryRoot,
                    suspendedStatus,
                    cancelRequest,
                    logContext);
        }

        @NonNull
        @Override
        public SuspendStatus createSuspendStatus(@NonNull final SuspendStatusImpl impl) {
            return new SuspendStatus(impl);
        }

        @Override
        public String getIndexerName(Context ctx) {
            assert ctx != null;

Lines 39-51 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/impl/indexing/SuspendStatus.java (-5 / +44 lines)
39	*	39	*
40	* Portions Copyrighted 2011 Sun Microsystems, Inc.	40	* Portions Copyrighted 2011 Sun Microsystems, Inc.
41	*/	41	*/
42	package org.netbeans.modules.parsing.impl.indexing;	42	package org.netbeans.modules.parsing.spi.indexing;
		43
		44	import org.netbeans.api.annotations.common.NonNull;
		45	import org.netbeans.modules.parsing.api.UserTask;
		46	import org.netbeans.modules.parsing.impl.indexing.SuspendSupport;
		47	import org.netbeans.modules.parsing.spi.ParserResultTask;
		48	import org.openide.util.Parameters;
43		49
44	/**	50	/**
45	*	51	* A service for indexers to check if an indexing is suspended or
		52	* to park while indexing is suspended.
		53	* The indexing is suspended by the infrastructure when high priority request
		54	* like index query or execution of {@link UserTask}, {@link ParserResultTask}
		55	* is in progress.
		56	* The instance of the {@link SuspendStatus} can be obtained from
		57	* {@link Context#getSuspendStatus()}. The infrastructure suspends indexing
		58	* automatically. The {@link EmbeddingIndexer}s are suspended with a file granularity.
		59	* The {@link CustomIndexer}s are suspended with a source root granularity.
		60	* This service can be used for more fine granularity suspending especially for
		61	* {@link CustomIndexer}s.
46	* @author Tomas Zezula	62	* @author Tomas Zezula
		63	* @since 1.52
47	*/	64	*/
48	interface SuspendStatus {	65	public final class SuspendStatus {
49	boolean isSuspended();	66
50	void parkWhileSuspended() throws InterruptedException;	67	private final SuspendSupport.SuspendStatusImpl impl;
		68
		69	SuspendStatus(@NonNull final SuspendSupport.SuspendStatusImpl impl) {
		70	Parameters.notNull("impl", impl); //NOI18N
		71	this.impl = impl;
		72	}
		73
		74	/**
		75	* Checks if an indexing is suspended.
		76	* @return true if an indexing is suspended.
		77	*/
		78	public boolean isSuspended() {
		79	return impl.isSuspended();
		80	}
		81
		82	/**
		83	* Parks a current (caller) thread while an indexing is suspended.
		84	* Threading: The caller should not hold any locks when calling this method.
		85	* @throws InterruptedException if the caller is interrupted.
		86	*/
		87	public void parkWhileSuspended() throws InterruptedException {
		88	impl.parkWhileSuspended();
		89	}
51	}	90	}




import org.netbeans.modules.parsing.impl.indexing.lucene.LuceneIndexFactory;
import org.netbeans.modules.parsing.lucene.support.DocumentIndex;
import org.netbeans.modules.parsing.lucene.support.Queries;
import org.netbeans.modules.parsing.spi.indexing.*;
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.netbeans.modules.parsing.spi.indexing.PathRecognizer;
import org.netbeans.spi.java.classpath.ClassPathProvider;
import org.netbeans.spi.java.classpath.support.ClassPathSupport;
import org.openide.filesystems.FileObject;

    }

    public void testIndexingSupportInstances () throws Exception {
        final Context ctx1 = SPIAccessor.getInstance().createContext(
                CacheFolder.getDataFolder(
                root.toURL()),
                root.toURL(),
                "fooIndexer",
                1,
                null,
                false,
                false,
                false,
                SuspendSupport.NOP,
                null,
                null);
        assertNotNull(ctx1);
        final Context ctx2 = SPIAccessor.getInstance().createContext(
                CacheFolder.getDataFolder(root.toURL()),
                root.toURL(),
                "embIndexer",
                1,
                null,
                false,
                false,
                false,
                SuspendSupport.NOP,
                null,
                null);
        assertNotNull(ctx2);

        final IndexingSupport is1 = IndexingSupport.getInstance(ctx1);


    public void testIndexingQuerySupport () throws Exception {
        // index
        final Context ctx = SPIAccessor.getInstance().createContext(
                CacheFolder.getDataFolder(root.toURL()),
                root.toURL(),
                "fooIndexer",
                1,
                null,
                false,
                false,
                false,
                SuspendSupport.NOP,
                null,
                null);
        assertNotNull(ctx);
        final Indexable i1 = SPIAccessor.getInstance().create(new FileObjectIndexable(root, f1));
        final IndexingSupport is = IndexingSupport.getInstance(ctx);


    public void testQuerySupportCaching() throws Exception {
        // index
        final Context ctx = SPIAccessor.getInstance().createContext(
                CacheFolder.getDataFolder(root.toURL()),
                root.toURL(),
                "fooIndexer",
                1,
                null,
                false,
                false,
                false,
                SuspendSupport.NOP,
                null,
                null);
        assertNotNull(ctx);
        final Indexable i1 = SPIAccessor.getInstance().create(new FileObjectIndexable(root, f1));
        final IndexingSupport is = IndexingSupport.getInstance(ctx);

Return to bug 208378

Lines 108-113 Link Here

(-)a/java.source/src/org/netbeans/modules/java/source/usages/BinaryAnalyser.java (-2 / +15 lines)
108	import org.netbeans.modules.java.source.parsing.FileObjects;	108	import org.netbeans.modules.java.source.parsing.FileObjects;
109	import org.netbeans.modules.java.source.usages.ClassIndexImpl.UsageType;	109	import org.netbeans.modules.java.source.usages.ClassIndexImpl.UsageType;
110	import org.netbeans.modules.parsing.impl.indexing.SPIAccessor;	110	import org.netbeans.modules.parsing.impl.indexing.SPIAccessor;
		111	import org.netbeans.modules.parsing.impl.indexing.SuspendSupport;
111	import org.netbeans.modules.parsing.lucene.support.LowMemoryWatcher;	112	import org.netbeans.modules.parsing.lucene.support.LowMemoryWatcher;
112	import org.netbeans.modules.parsing.spi.indexing.Context;	113	import org.netbeans.modules.parsing.spi.indexing.Context;
113	import org.openide.filesystems.FileObject;	114	import org.openide.filesystems.FileObject;
Lines 200-207 Link Here
200	*/	201	*/
201	@Deprecated	202	@Deprecated
202	public final Result start (final @NonNull URL url, final AtomicBoolean canceled, final AtomicBoolean shutdown) throws IOException, IllegalArgumentException {	203	public final Result start (final @NonNull URL url, final AtomicBoolean canceled, final AtomicBoolean shutdown) throws IOException, IllegalArgumentException {
203	return start (url, SPIAccessor.getInstance().createContext(FileUtil.createMemoryFileSystem().getRoot(), url,	204	return start (
204	JavaIndex.NAME, JavaIndex.VERSION, null, false, false, false, null));	205	url,
		206	SPIAccessor.getInstance().createContext(
		207	FileUtil.createMemoryFileSystem().getRoot(),
		208	url,
		209	JavaIndex.NAME,
		210	JavaIndex.VERSION,
		211	null,
		212	false,
		213	false,
		214	false,
		215	SuspendSupport.NOP,
		216	null,
		217	null));
205	}	218	}
206		219
207	public Result resume () throws IOException {	220	public Result resume () throws IOException {

Lines 110-115 Link Here

(-)a/parsing.api/apichanges.xml (+19 lines)
110	<!-- ACTUAL CHANGES BEGIN HERE: -->	110	<!-- ACTUAL CHANGES BEGIN HERE: -->
111		111
112	<changes>	112	<changes>
		113	<change id="SuspendStatus">
		114	<api name="ParsingAPI"/>
		115	<summary>Added <code>SuspendStatus</code> service which can be used by indexers to find out if
		116	indexing is suspended.</summary>
		117	<version major="1" minor="52"/>
		118	<date day="17" month="2" year="2012"/>
		119	<author login="tzezula"/>
		120	<compatibility source="compatible" binary="compatible" semantic="compatible" deletion="no" addition="yes" modification="no"/>
		121	<description>
		122	<p>
		123	The indexing is suspended by the infrastructure when high priority request like index query or execution
		124	of <code>UserTask</code>, <code>ParserResultTask</code> is in progress. The <code>SuspendStatus</code>
		125	allows indexers to find out that indexing is suspended or to park while it's suspended.
		126	</p>
		127	</description>
		128	<class package="org.netbeans.modules.parsing.spi.indexing" name="SuspendedStatus"/>
		129	<class package="org.netbeans.modules.parsing.spi.indexing" name="Context"/>
		130	<issue number="208378"/>
		131	</change>
113	<change id="IndexingAwareParserResultTask">	132	<change id="IndexingAwareParserResultTask">
114	<api name="ParsingAPI"/>	133	<api name="ParsingAPI"/>
115	<summary>Added <code>IndexingAwareParserResultTask</code> which is a specialization of <code>ParserResultTask</code>	134	<summary>Added <code>IndexingAwareParserResultTask</code> which is a specialization of <code>ParserResultTask</code>

Lines 89-114 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/impl/indexing/SPIAccessor.java (-19 / +5 lines)
89	boolean followUpJob,	89	boolean followUpJob,
90	boolean checkForEditorModifications,	90	boolean checkForEditorModifications,
91	boolean sourceForBinaryRoot,	91	boolean sourceForBinaryRoot,
92	CancelRequest cancelRequest,	92	@NonNull final SuspendStatus suspendedStatus,
		93	@NullAllowed final CancelRequest cancelRequest,
93	@NullAllowed final LogContext logContext) throws IOException;	94	@NullAllowed final LogContext logContext) throws IOException;
94		95
95	public final Context createContext (	96	@NonNull
96	final FileObject indexFolder, final URL rootURL,	97	public abstract SuspendStatus createSuspendStatus(@NonNull SuspendSupport.SuspendStatusImpl impl);
97	String indexerName, int indexerVersion, IndexFactoryImpl factory,
98	boolean followUpJob, boolean checkForEditorModifications,
99	boolean sourceForBinaryRoot, CancelRequest cancelRequest) throws IOException {
100	return createContext(
101	indexFolder,
102	rootURL,
103	indexerName,
104	indexerVersion,
105	factory,
106	followUpJob,
107	checkForEditorModifications,
108	sourceForBinaryRoot,
109	cancelRequest,
110	null);
111	}
112		98
113	public abstract void context_attachIndexingSupport(Context context, IndexingSupport support);	99	public abstract void context_attachIndexingSupport(Context context, IndexingSupport support);
114		100

Lines 79-84 Link Here

(-)a/parsing.api/src/org/netbeans/modules/parsing/spi/indexing/Context.java (-1 / +15 lines)
79	private final boolean checkForEditorModifications;	79	private final boolean checkForEditorModifications;
80	private final boolean sourceForBinaryRoot;	80	private final boolean sourceForBinaryRoot;
81	private final CancelRequest cancelRequest;	81	private final CancelRequest cancelRequest;
		82	private final SuspendStatus suspendedStatus;
82	private final LogContext logContext;	83	private final LogContext logContext;
83	private final Map<String,Object> props;	84	private final Map<String,Object> props;
84	private FileObject indexFolder;	85	private FileObject indexFolder;
Lines 94-100 Link Here
94	final IndexFactoryImpl factory, boolean followUpJob,	95	final IndexFactoryImpl factory, boolean followUpJob,
95	final boolean checkForEditorModifications,	96	final boolean checkForEditorModifications,
96	final boolean sourceForBinaryRoot,	97	final boolean sourceForBinaryRoot,
97	final CancelRequest cancelRequest,	98	@NonNull final SuspendStatus suspendedStatus,
		99	@NullAllowed final CancelRequest cancelRequest,
98	@NullAllowed final LogContext logContext	100	@NullAllowed final LogContext logContext
99	) throws IOException {	101	) throws IOException {
100	assert indexBaseFolder != null;	102	assert indexBaseFolder != null;
Lines 109-114 Link Here
109	this.checkForEditorModifications = checkForEditorModifications;	111	this.checkForEditorModifications = checkForEditorModifications;
110	this.sourceForBinaryRoot = sourceForBinaryRoot;	112	this.sourceForBinaryRoot = sourceForBinaryRoot;
111	this.cancelRequest = cancelRequest;	113	this.cancelRequest = cancelRequest;
		114	this.suspendedStatus = suspendedStatus;
112	this.logContext = logContext;	115	this.logContext = logContext;
113	this.props = new HashMap<String, Object>();	116	this.props = new HashMap<String, Object>();
114	}	117	}
Lines 256-261 Link Here
256	public boolean isCancelled() {	259	public boolean isCancelled() {
257	return cancelRequest == null ? false : cancelRequest.isRaised();	260	return cancelRequest == null ? false : cancelRequest.isRaised();
258	}	261	}
		262
		263	/**
		264	* Returns {@link SuspendStatus} providing information
		265	* about indexing suspension.
		266	* @return the {@link SuspendStatus}
		267	* @since 1.52
		268	*/
		269	@NonNull
		270	public SuspendStatus getSuspendStatus() {
		271	return suspendedStatus;
		272	}
259		273
260	// -----------------------------------------------------------------------	274	// -----------------------------------------------------------------------
261	// Package private implementation	275	// Package private implementation

Lines 59-69 Link Here

(-)a/parsing.api/test/unit/src/org/netbeans/modules/parsing/spi/indexing/support/IndexingSupportTest.java (-9 / +50 lines)
59	import org.netbeans.modules.parsing.impl.indexing.lucene.LuceneIndexFactory;	59	import org.netbeans.modules.parsing.impl.indexing.lucene.LuceneIndexFactory;
60	import org.netbeans.modules.parsing.lucene.support.DocumentIndex;	60	import org.netbeans.modules.parsing.lucene.support.DocumentIndex;
61	import org.netbeans.modules.parsing.lucene.support.Queries;	61	import org.netbeans.modules.parsing.lucene.support.Queries;
62	import org.netbeans.modules.parsing.spi.indexing.Context;	62	import org.netbeans.modules.parsing.spi.indexing.*;
63	import org.netbeans.modules.parsing.spi.indexing.CustomIndexer;
64	import org.netbeans.modules.parsing.spi.indexing.CustomIndexerFactory;
65	import org.netbeans.modules.parsing.spi.indexing.Indexable;
66	import org.netbeans.modules.parsing.spi.indexing.PathRecognizer;
67	import org.netbeans.spi.java.classpath.ClassPathProvider;	63	import org.netbeans.spi.java.classpath.ClassPathProvider;
68	import org.netbeans.spi.java.classpath.support.ClassPathSupport;	64	import org.netbeans.spi.java.classpath.support.ClassPathSupport;
69	import org.openide.filesystems.FileObject;	65	import org.openide.filesystems.FileObject;
Lines 107-115 Link Here
107	}	103	}
108		104
109	public void testIndexingSupportInstances () throws Exception {	105	public void testIndexingSupportInstances () throws Exception {
110	final Context ctx1 = SPIAccessor.getInstance().createContext(CacheFolder.getDataFolder(root.getURL()), root.getURL(), "fooIndexer", 1, null, false, false, false, null);	106	final Context ctx1 = SPIAccessor.getInstance().createContext(
		107	CacheFolder.getDataFolder(
		108	root.toURL()),
		109	root.toURL(),
		110	"fooIndexer",
		111	1,
		112	null,
		113	false,
		114	false,
		115	false,
		116	SuspendSupport.NOP,
		117	null,
		118	null);
111	assertNotNull(ctx1);	119	assertNotNull(ctx1);
112	final Context ctx2 = SPIAccessor.getInstance().createContext(CacheFolder.getDataFolder(root.getURL()), root.getURL(), "embIndexer", 1, null, false, false, false, null);	120	final Context ctx2 = SPIAccessor.getInstance().createContext(
		121	CacheFolder.getDataFolder(root.toURL()),
		122	root.toURL(),
		123	"embIndexer",
		124	1,
		125	null,
		126	false,
		127	false,
		128	false,
		129	SuspendSupport.NOP,
		130	null,
		131	null);
113	assertNotNull(ctx2);	132	assertNotNull(ctx2);
114		133
115	final IndexingSupport is1 = IndexingSupport.getInstance(ctx1);	134	final IndexingSupport is1 = IndexingSupport.getInstance(ctx1);
Lines 123-129 Link Here
123		142
124	public void testIndexingQuerySupport () throws Exception {	143	public void testIndexingQuerySupport () throws Exception {
125	// index	144	// index
126	final Context ctx = SPIAccessor.getInstance().createContext(CacheFolder.getDataFolder(root.getURL()), root.getURL(), "fooIndexer", 1, null, false, false, false, null);	145	final Context ctx = SPIAccessor.getInstance().createContext(
		146	CacheFolder.getDataFolder(root.toURL()),
		147	root.toURL(),
		148	"fooIndexer",
		149	1,
		150	null,
		151	false,
		152	false,
		153	false,
		154	SuspendSupport.NOP,
		155	null,
		156	null);
127	assertNotNull(ctx);	157	assertNotNull(ctx);
128	final Indexable i1 = SPIAccessor.getInstance().create(new FileObjectIndexable(root, f1));	158	final Indexable i1 = SPIAccessor.getInstance().create(new FileObjectIndexable(root, f1));
129	final IndexingSupport is = IndexingSupport.getInstance(ctx);	159	final IndexingSupport is = IndexingSupport.getInstance(ctx);
Lines 195-201 Link Here
195		225
196	public void testQuerySupportCaching() throws Exception {	226	public void testQuerySupportCaching() throws Exception {
197	// index	227	// index
198	final Context ctx = SPIAccessor.getInstance().createContext(CacheFolder.getDataFolder(root.getURL()), root.getURL(), "fooIndexer", 1, null, false, false, false, null);	228	final Context ctx = SPIAccessor.getInstance().createContext(
		229	CacheFolder.getDataFolder(root.toURL()),
		230	root.toURL(),
		231	"fooIndexer",
		232	1,
		233	null,
		234	false,
		235	false,
		236	false,
		237	SuspendSupport.NOP,
		238	null,
		239	null);
199	assertNotNull(ctx);	240	assertNotNull(ctx);
200	final Indexable i1 = SPIAccessor.getInstance().create(new FileObjectIndexable(root, f1));	241	final Indexable i1 = SPIAccessor.getInstance().create(new FileObjectIndexable(root, f1));
201	final IndexingSupport is = IndexingSupport.getInstance(ctx);	242	final IndexingSupport is = IndexingSupport.getInstance(ctx);