Attachment #159443 for bug #257567

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

Lines 1-6 Link Here

(-)maven.indexer/manifest.mf (-1 / +1 lines)
1	Manifest-Version: 1.0	1	Manifest-Version: 1.0
2	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/maven/indexer/Bundle.properties	2	OpenIDE-Module-Localizing-Bundle: org/netbeans/modules/maven/indexer/Bundle.properties
3	AutoUpdate-Show-In-Client: false	3	AutoUpdate-Show-In-Client: false
4	OpenIDE-Module-Specification-Version: 2.37	4	OpenIDE-Module-Specification-Version: 2.38
5	OpenIDE-Module: org.netbeans.modules.maven.indexer/2	5	OpenIDE-Module: org.netbeans.modules.maven.indexer/2
6		6




import org.codehaus.plexus.util.FileUtils;
import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NullAllowed;
import org.netbeans.api.annotations.common.SuppressWarnings;
import org.netbeans.modules.maven.embedder.EmbedderFactory;
import org.netbeans.modules.maven.embedder.MavenEmbedder;
import org.netbeans.modules.maven.indexer.api.NBArtifactInfo;

import org.netbeans.modules.maven.indexer.api.QueryField;
import org.netbeans.modules.maven.indexer.api.RepositoryInfo;
import org.netbeans.modules.maven.indexer.api.RepositoryPreferences;
import org.netbeans.modules.maven.indexer.api.RepositoryQueries.Result;
import org.netbeans.modules.maven.indexer.spi.ArchetypeQueries;
import org.netbeans.modules.maven.indexer.spi.BaseQueries;
import org.netbeans.modules.maven.indexer.spi.ChecksumQueries;

import org.netbeans.modules.maven.indexer.spi.ContextLoadedQuery;
import org.netbeans.modules.maven.indexer.spi.DependencyInfoQueries;
import org.netbeans.modules.maven.indexer.spi.GenericFindQuery;
import org.netbeans.modules.maven.indexer.spi.impl.RepositoryIndexerImplementation;
import org.netbeans.modules.maven.indexer.spi.ResultImplementation;
import org.netbeans.modules.maven.indexer.spi.impl.Redo;
import org.netbeans.modules.maven.indexer.spi.impl.IndexingNotificationProvider;
import org.openide.modules.Places;
import org.openide.util.BaseUtilities;

import org.openide.util.lookup.ServiceProvider;
import org.openide.util.lookup.ServiceProviders;
import org.openide.util.NbBundle.Messages;
import org.netbeans.modules.maven.indexer.spi.RepositoryIndexQueryProvider;

@ServiceProviders({
    @ServiceProvider(service=RepositoryIndexerImplementation.class),
    @ServiceProvider(service=RepositoryIndexQueryProvider.class, position = Integer.MAX_VALUE)
    @ServiceProvider(service=ChecksumQueries.class),
    @ServiceProvider(service=ArchetypeQueries.class),
    @ServiceProvider(service=DependencyInfoQueries.class),
    @ServiceProvider(service=ClassesQuery.class),
    @ServiceProvider(service=ClassUsageQuery.class),
    @ServiceProvider(service=GenericFindQuery.class),
    @ServiceProvider(service=ContextLoadedQuery.class)
})
public class NexusRepositoryIndexerImpl implements RepositoryIndexerImplementation, RepositoryIndexQueryProvider,
        BaseQueries, ChecksumQueries, ArchetypeQueries, DependencyInfoQueries,
        ClassesQuery, ClassUsageQuery, GenericFindQuery, ContextLoadedQuery {

    
    public static abstract class Accessor {
  
        @SuppressWarnings("MS_SHOULD_BE_FINAL")
        public static Accessor ACCESSOR;
        
        protected Accessor() {
            ACCESSOR = this;
        }
        
        public abstract void addSkipped(Result<?> result, Collection<RepositoryInfo> infos);
        
        public abstract List<RepositoryInfo> getSkipped(Result<?> result);
        
        public abstract void setStringResults(Result<String> result, Collection<String> newResults);
        
        public abstract void setVersionResults(Result<NBVersionInfo> result, Collection<NBVersionInfo> newResults);
        
        public abstract void addSkipped(Result<?> result, RepositoryInfo info);
        
        public abstract Result<String> createStringResult(Redo<String> redo);
        
        public abstract Result<NBVersionInfo> createVersionResult(Redo<NBVersionInfo> redo);
        
        public abstract Result<NBGroupInfo> createGroupResult(Redo<NBGroupInfo> redo);
        
        public abstract void setGroupResults(Result<NBGroupInfo> result, Collection<NBGroupInfo> newResults);
        
        public abstract Result<RepositoryQueries.ClassUsage> createClassResult(Redo<RepositoryQueries.ClassUsage> redo);
        
        public abstract void setClassResults(Result<RepositoryQueries.ClassUsage> result, Collection<RepositoryQueries.ClassUsage> newResults);
        
        public abstract void addTotalResults(Result<?> result, int moreResults);
        
        public abstract void addReturnedResults(Result<?> result, int moreResults);
    }
    
    private static final Logger LOGGER = Logger.getLogger(NexusRepositoryIndexerImpl.class.getName());
       
    static {

    private static final Set<Mutex> indexingMutexes = new HashSet<Mutex>();
    private static final RequestProcessor RP = new RequestProcessor("indexing", 1);

    @Override
    public boolean handlesRepository(RepositoryInfo repo) {
        // should always come as last when looked up
        // handles all remote repos
        return true; 
    }
    
    @Override
    public BaseQueries getBaseQueries() {
        return this;
    }

    @Override
    public ChecksumQueries getChecksumQueries() {
        return this;
    }

    @Override
    public ArchetypeQueries getArchetypeQueries() {
        return this;
    }

    @Override
    public DependencyInfoQueries getDependencyInfoQueries() {
        return this;
    }

    @Override
    public ClassesQuery getClassesQuery() {
        return this;
    }

    @Override
    public ClassUsageQuery getClassUsageQuery() {
        return this;
    }

    @Override
    public GenericFindQuery getGenericFindQuery() {
        return this;
    }

    @Override
    public ContextLoadedQuery getContextLoadedQuery() {
        return this;
    }
    
    private Mutex getRepoMutex(RepositoryInfo repo) {
        return getRepoMutex(repo.getId());
    }

    }

    @Override
    public ResultImplementation<String> getGroups(List<RepositoryInfo> repos) {
        return filterGroupIds("", repos);
    }


    }
    }

    private ResultImplementation<String> filterGroupIds(final String prefix, final List<RepositoryInfo> repos) {
        Redo<String> redo = new Redo<String>() {
    @Override
            public void run(ResultImpl<String> result) {
                filterGroupIds(prefix, result, result.getSkipped(), false);
            @Override
            public void run(Result<String> result) {
                filterGroupIds(prefix, result, Accessor.ACCESSOR.getSkipped(result), false);
            }
        };
        ResultImpl<String> result = new ResultImpl<String>(redo);
        return filterGroupIds(prefix, result, repos, true);
    }
    
    private ResultImplementation<String> filterGroupIds(final String prefix, final ResultImpl<String> result, 
                                                            final List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final Set<String> groups = new TreeSet<String>(result.getResults());
        final List<RepositoryInfo> slowCheck = new ArrayList<RepositoryInfo>();

//            }
//        }, skipAction, skipUnIndexed);
        
        result.setResults(groups);
        return result;
    }

    @Override
    public ResultImplementation<String> getGAVsForPackaging(final String packaging, List<RepositoryInfo> repos) {
        ResultImpl<String> result = new ResultImpl<>(new Redo<String>() {
            @Override
            public void run(ResultImpl<String> result) {
                getGAVsForPackaging(packaging, result, result.getSkipped(), false);
            }
        });
        return getGAVsForPackaging(packaging,result, repos, true);
    }
    
    private ResultImplementation<String> getGAVsForPackaging(final String packaging, final ResultImpl<String> result, 
                                             List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final List<String> infos = new ArrayList<String>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);

                            }
                        }
                    } finally {
                        result.addReturnedResultCount(response.getTotalProcessedArtifactInfoCount());
                        result.addTotalResultCount(response.getTotalHitsCount());
                        response.close();
                    }
                }
            }
        }, skipAction, skipUnIndexed);
        result.setResults(infos);
        return result;        
    }
    

    @Override
    public ResultImplementation<NBVersionInfo> getRecords(final String groupId, final String artifactId, final String version, List<RepositoryInfo> repos) {
        ResultImpl<NBVersionInfo> result = new ResultImpl<>(new Redo<NBVersionInfo>() {
            @Override
            public void run(ResultImpl<NBVersionInfo> result) {
                getRecords(groupId, artifactId, version, result, result.getSkipped(), false);
            }
        });
        return getRecords(groupId, artifactId, version, result, repos, true);
    }
    
    private ResultImplementation<NBVersionInfo> getRecords(final String groupId, final String artifactId, final String version, final ResultImpl<NBVersionInfo> result, 
                                             List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final List<NBVersionInfo> infos = new ArrayList<NBVersionInfo>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);

                            infos.add(convertToNBVersionInfo(ai));
                        }
                    } finally {
                        result.addReturnedResultCount(response.getTotalProcessedArtifactInfoCount());
                        result.addTotalResultCount(response.getTotalHitsCount());
                        response.close();
                    }
                }
            }
        }, skipAction, skipUnIndexed);
        doSortIssue226100(infos);
        result.setResults(infos);
        return result;
    }

    @Override
    public ResultImplementation<String> getArtifacts(final String groupId, final List<RepositoryInfo> repos) {
        ResultImpl<String> result = new ResultImpl<>(new Redo<String>() {
            @Override
            public void run(ResultImpl<String> result) {
                getArtifacts(groupId, result, result.getSkipped(), false);
            }
        });
        return getArtifacts(groupId, result, repos, true);
    }
    
    private  ResultImplementation<String> getArtifacts(final String groupId, final ResultImpl<String> result, final List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final Set<String> artifacts = new TreeSet<String>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);
        iterate(repos, new RepoAction() {

                }
            }
        }, skipAction, skipUnIndexed);
        result.setResults(artifacts);
        return result;
    }

    @Override
    public ResultImplementation<NBVersionInfo> getVersions(final String groupId, final String artifactId, List<RepositoryInfo> repos) {
        ResultImpl<NBVersionInfo> result = new ResultImpl<>(new Redo<NBVersionInfo>() {
            @Override
            public void run(ResultImpl<NBVersionInfo> result) {
                getVersions(groupId, artifactId, result, result.getSkipped(), false);
            }
        });
        return getVersions(groupId, artifactId, result, repos, true);
    }
    private ResultImplementation<NBVersionInfo> getVersions(final String groupId, final String artifactId, final ResultImpl<NBVersionInfo> result, List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final List<NBVersionInfo> infos = new ArrayList<NBVersionInfo>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);
        iterate(repos, new RepoAction() {

                            infos.add(convertToNBVersionInfo(ai));
                        }
                    } finally {
                        result.addReturnedResultCount(response.getTotalProcessedArtifactInfoCount());
                        result.addTotalResultCount(response.getTotalHitsCount());
                        response.close();
                    }
                }
            }
        }, skipAction, skipUnIndexed);
        doSortIssue226100(infos);
        result.setResults(infos);
        return result;
    }

    @Override
    public ResultImplementation<NBVersionInfo> findVersionsByClass(final String className, List<RepositoryInfo> repos) {
        ResultImpl<NBVersionInfo> result = new ResultImpl(new Redo<NBVersionInfo>() {
            @Override
            public void run(ResultImpl<NBVersionInfo> result) {
                findVersionsByClass(className, result, result.getSkipped(), false);
            }
        });
        return findVersionsByClass(className, result, repos, true);
    }
    
    private ResultImplementation<NBVersionInfo> findVersionsByClass(final String className, final ResultImpl<NBVersionInfo> result, List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final List<NBVersionInfo> infos = new ArrayList<NBVersionInfo>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);
        iterate(repos, new RepoAction() {

                        infos.addAll(postProcessClasses(response.getResults(), clsname));
                    } finally {
                        //?? really count in this case?
                        result.addReturnedResultCount(response.getTotalProcessedArtifactInfoCount());
                        result.addTotalResultCount(response.getTotalHitsCount());
                        response.close();
                    }
                }
            }
        }, skipAction, skipUnIndexed);
        doSortIssue226100(infos);
        result.setResults(infos);
        return result;
    }

    @Override 
    public ResultImplementation<RepositoryQueries.ClassUsage> findClassUsages(final String className, @NullAllowed List<RepositoryInfo> repos) {
        ResultImpl<RepositoryQueries.ClassUsage> result = new ResultImpl<>(new Redo<RepositoryQueries.ClassUsage>() {
            @Override
            public void run(ResultImpl<RepositoryQueries.ClassUsage> result) {
                findClassUsages(className, result, result.getSkipped(), false);
            }
        });
        return findClassUsages(className, result, repos, true);
        
    }
    
    private ResultImplementation<RepositoryQueries.ClassUsage> findClassUsages(final String className, ResultImpl<RepositoryQueries.ClassUsage> result, @NullAllowed List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        List<RepositoryInfo> localRepos = new ArrayList<RepositoryInfo>();
        if (repos == null) {
            repos = RepositoryPreferences.getInstance().getRepositoryInfos();

                return r1.getArtifact().compareTo(r2.getArtifact());
            }
        });
        result.setResults(results);
        return result;
    }
    
    @Override
    public ResultImplementation<NBVersionInfo> findDependencyUsage(final String groupId, final String artifactId, final String version, @NullAllowed List<RepositoryInfo> repos) {
        ResultImpl<NBVersionInfo> result = new ResultImpl<>(new Redo<NBVersionInfo>() {
            @Override
            public void run(ResultImpl<NBVersionInfo> result) {
                findDependencyUsage(groupId, artifactId, version, result, result.getSkipped(), false);
            }
        });
        return findDependencyUsage(groupId, artifactId, version, result, repos, true);
    }
    private ResultImplementation<NBVersionInfo> findDependencyUsage(String groupId, String artifactId, String version, final ResultImpl<NBVersionInfo> result, @NullAllowed List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final Query q = ArtifactDependencyIndexCreator.query(groupId, artifactId, version);
        final List<NBVersionInfo> infos = new ArrayList<NBVersionInfo>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);

                            infos.add(convertToNBVersionInfo(ai));
                        }
                    } finally {
                        result.addReturnedResultCount(response.getTotalProcessedArtifactInfoCount());
                        result.addTotalResultCount(response.getTotalHitsCount());
                        response.close();
                    }
                }
            }
        }, skipAction, skipUnIndexed);
        result.setResults(infos);
        return result;
    }
    
    @Override
    public ResultImplementation<NBGroupInfo> findDependencyUsageGroups(final String groupId, final String artifactId, final String version, List<RepositoryInfo> repos) {
        ResultImpl<NBGroupInfo> result = new ResultImpl<>(new Redo<NBGroupInfo>() {
            @Override
            public void run(ResultImpl<NBGroupInfo> result) {
                findDependencyUsageGroups(groupId, artifactId, version, result, result.getSkipped(), false);
            }
        });
        return findDependencyUsageGroups(groupId, artifactId, version, result, repos, true);
    }

    private ResultImplementation<NBGroupInfo> findDependencyUsageGroups(String groupId, String artifactId, String version, ResultImpl<NBGroupInfo> result, List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        //tempmaps
        Map<String, NBGroupInfo> groupMap = new HashMap<String, NBGroupInfo>();
        Map<String, NBArtifactInfo> artifactMap = new HashMap<String, NBArtifactInfo>();
        List<NBGroupInfo> groupInfos = new ArrayList<NBGroupInfo>(result.getResults());
        ResultImpl<NBVersionInfo> res = new ResultImpl(new Redo<NBVersionInfo>() {

            @Override
            public void run(ResultImpl<NBVersionInfo> result) {
                //noop will not be called
            }
        });

        convertToNBGroupInfo(res.getResults(),
                groupMap, artifactMap, groupInfos);
        if (res.isPartial()) {
            result.addSkipped(res.getSkipped());
        }
        result.setResults(groupInfos);
        return result;
        
    }

    

    @Override
    public ResultImplementation<NBVersionInfo> findBySHA1(final String sha1, List<RepositoryInfo> repos) {
        ResultImpl<NBVersionInfo> result = new ResultImpl<>(new Redo<NBVersionInfo>() {
            @Override
            public void run(ResultImpl<NBVersionInfo> result) {
                findBySHA1(sha1, result, result.getSkipped(), false);
            }
        });
        return findBySHA1(sha1, result, repos, true);
    }
    
    private ResultImplementation<NBVersionInfo> findBySHA1(final String sha1, final ResultImpl<NBVersionInfo> result, List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final List<NBVersionInfo> infos = new ArrayList<NBVersionInfo>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);
        iterate(repos, new RepoAction() {

                            infos.add(convertToNBVersionInfo(ai));
                        }
                    } finally {
                        result.addReturnedResultCount(response.getTotalProcessedArtifactInfoCount());
                        result.addTotalResultCount(response.getTotalHitsCount());
                        response.close();
                    }
                }
            }
        }, skipAction, skipUnIndexed);
        doSortIssue226100(infos);
        result.setResults(infos);
        return result;
    }

    @Override
    public ResultImplementation<NBVersionInfo> findArchetypes(List<RepositoryInfo> repos) {
        ResultImpl<NBVersionInfo> result = new ResultImpl<>(new Redo<NBVersionInfo>() {
            @Override
            public void run(ResultImpl<NBVersionInfo> result) {
                findArchetypes( result, result.getSkipped(), false);
            }
        });
        return findArchetypes( result, repos, true);
    }
    
    private ResultImplementation<NBVersionInfo> findArchetypes(final ResultImpl<NBVersionInfo> result, List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final List<NBVersionInfo> infos = new ArrayList<NBVersionInfo>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);
        iterate(repos, new RepoAction() {

                            infos.add(convertToNBVersionInfo(ai));
                        }
                    } finally {
                        result.addReturnedResultCount(response.getTotalProcessedArtifactInfoCount());
                        result.addTotalResultCount(response.getTotalHitsCount());
                        response.close();
                    }
                }
            }
        }, skipAction, skipUnIndexed);
        doSortIssue226100(infos);
        result.setResults(infos);
        return result;
    }

    @Override
    public ResultImplementation<String> filterPluginArtifactIds(final String groupId, final String prefix, List<RepositoryInfo> repos) {
        ResultImpl<String> result = new ResultImpl<>(new Redo<String>() {
            @Override
            public void run(ResultImpl<String> result) {
                filterPluginArtifactIds(groupId, prefix, result, result.getSkipped(), false);
            }
        });
        return filterPluginArtifactIds(groupId, prefix, result, repos, true);
    }
    
    private ResultImplementation<String> filterPluginArtifactIds(final String groupId, final String prefix, ResultImpl<String> result, List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final Set<String> artifacts = new TreeSet<String>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);
        iterate(repos, new RepoAction() {

                }
            }
        }, skipAction, skipUnIndexed);
        result.setResults(artifacts);
        return result;
    }

    @Override
    public ResultImplementation<String> filterPluginGroupIds(final String prefix, List<RepositoryInfo> repos) {
        ResultImpl<String> result = new ResultImpl<>(new Redo<String>() {
            @Override
            public void run(ResultImpl<String> result) {
                filterPluginGroupIds( prefix, result, result.getSkipped(), false);
            }
        });
        return filterPluginGroupIds( prefix, result, repos, true);
    }
    
    private ResultImplementation<String> filterPluginGroupIds(final String prefix, ResultImpl<String> result, List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final Set<String> artifacts = new TreeSet<String>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);
        iterate(repos, new RepoAction() {

                }
            }
        }, skipAction, skipUnIndexed);
        result.setResults(artifacts);
        return result;
    }

    @Override
    public ResultImplementation<NBVersionInfo> find(final List<QueryField> fields, List<RepositoryInfo> repos) {
        ResultImpl<NBVersionInfo> result = new ResultImpl<>(new Redo<NBVersionInfo>() {
            @Override
            public void run(ResultImpl<NBVersionInfo> result) {
                find( fields, result, result.getSkipped(), false);
            }
        });
        return filterArtifactIdForGroupId( groupId, prefix, result, repos, true);
    }
    private RepositoryQueries.Result<String> filterArtifactIdForGroupId(final String groupId, final String prefix, Result<String> result, List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final Set<String> artifacts = new TreeSet<String>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);
        iterate(repos, new RepoAction() {
            @Override public void run(RepositoryInfo repo, IndexingContext context) throws IOException {
                BooleanQuery bq = new BooleanQuery();
                String id = groupId + ArtifactInfo.FS + prefix;
                bq.add(new BooleanClause(setBooleanRewrite(new PrefixQuery(new Term(ArtifactInfo.UINFO, id))), BooleanClause.Occur.MUST));
                //mkleint: this is not capped, because only a string is collected (and collapsed), the rest gets CGed fast
                IteratorSearchResponse response = repeatedPagedSearch(bq, Collections.singletonList(context), NO_CAP_RESULT_COUNT);
                if (response != null) {
                    try {
                        for (ArtifactInfo artifactInfo : response.getResults()) {
                            artifacts.add(artifactInfo.artifactId);
                        }
                    } finally {
                        response.close();
                    }
                }
            }
        }, skipAction, skipUnIndexed);       
        Accessor.ACCESSOR.setStringResults(result, artifacts);
        return result;
    }

    @Override
    public RepositoryQueries.Result<NBVersionInfo> find(final List<QueryField> fields, List<RepositoryInfo> repos) {
        RepositoryQueries.Result<NBVersionInfo> result = Accessor.ACCESSOR.createVersionResult(new Redo<NBVersionInfo>() {
            @Override
            public void run(Result<NBVersionInfo> result) {
                find( fields, result, Accessor.ACCESSOR.getSkipped(result), false);
            }
        });
        return find(fields,  result, repos, true);
    }
    private ResultImplementation<NBVersionInfo> find(final List<QueryField> fields, final ResultImpl<NBVersionInfo> result, List<RepositoryInfo> repos, final boolean skipUnIndexed) {
        final List<NBVersionInfo> infos = new ArrayList<NBVersionInfo>(result.getResults());
        final SkippedAction skipAction = new SkippedAction(result);
        iterate(repos, new RepoAction() {

                            infos.add(convertToNBVersionInfo(ai));
                        }
                    } finally {
                        result.addReturnedResultCount(resp.getTotalProcessedArtifactInfoCount());
                        result.addTotalResultCount(resp.getTotalHitsCount());
                        resp.close();
                    }
                }
            }
        }, skipAction, skipUnIndexed);
        doSortIssue226100(infos);
        result.setResults(infos);
        return result;
    }
    


    private static class SkippedAction implements RepoAction {

        private final ResultImpl<?> result;

        private SkippedAction(ResultImpl<?> result) {
            this.result = result;
        }
        
        @Override
        public void run(RepositoryInfo repo, IndexingContext context) throws IOException {
            //indexing context is always null here..
            result.addSkipped(repo);
        }
        
    }

Lines 44-50 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/OnStop.java (-1 / +1 lines)
44		44
45	import java.util.logging.Level;	45	import java.util.logging.Level;
46	import java.util.logging.Logger;	46	import java.util.logging.Logger;
47	import org.netbeans.modules.maven.indexer.spi.RepositoryIndexerImplementation;	47	import org.netbeans.modules.maven.indexer.spi.impl.RepositoryIndexerImplementation;
48	import org.openide.util.Lookup;	48	import org.openide.util.Lookup;
49		49
50	@org.openide.modules.OnStop	50	@org.openide.modules.OnStop




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.maven.indexer;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.netbeans.modules.maven.indexer.api.RepositoryInfo;
import org.netbeans.modules.maven.indexer.spi.ResultImplementation;
import org.netbeans.modules.maven.indexer.spi.impl.Redo;
import org.netbeans.modules.project.spi.intern.ProjectIDEServices;

/**
 *
 * @author Tomas Stupka
 */
public class ResultImpl<T> implements ResultImplementation {
    private final List<RepositoryInfo> skipped = new ArrayList<>();
    private final List<T> results = new ArrayList<>();
    private final Redo<T> redoAction;

    private int totalResults = 0;
    private int returnedResults = 0;

    /**
     * used internally by the repository indexing/searching engine(s)
     */
    public ResultImpl(Redo<T> redo) {
        redoAction = redo;
    }

    /**
     * returns true is one or more indexes were skipped, eg because the indexing was taking place.
     * @return 
     */
    @Override
    public synchronized boolean isPartial() {
        return !skipped.isEmpty();
    }

    /**
     * used internally by the repository indexing/searching engine(s) to mark the result as partially skipped
     */
    synchronized void addSkipped(RepositoryInfo info) {
        skipped.add(info);
    }

    /**
     * waits for currently unaccessible indexes to finish, not to be called in AWT thread.
     */
    @Override
    public void waitForSkipped() {
        assert !ProjectIDEServices.isEventDispatchThread();
        redoAction.run(this);
        synchronized (this) {
            skipped.clear();
        }
    }

    synchronized void setResults(Collection<T> newResults) {
        results.clear();
        results.addAll(newResults);
    }

    @Override
    public synchronized List<T> getResults() {
        return Collections.unmodifiableList(results);
    }


    /**
     * used internally by the repository indexing/searching engine(s) to mark the result as partially skipped
     */
    synchronized void addSkipped(Collection<RepositoryInfo> infos) {
        skipped.addAll(infos);
    }

    /**
     * used internally by the repository indexing/searching engine(s) to mark the result as partially skipped
     */
    synchronized List<RepositoryInfo> getSkipped() {
        return Collections.unmodifiableList(skipped);
    }
    
    /**
     * total number of hits
     * @return
     * @since 2.20
     */
    @Override
    public int getTotalResultCount() {
        return totalResults;
    }

    void addTotalResultCount(int moreTotalResults) {
        totalResults += moreTotalResults;
    }
    /**
     * in some cases not entirely accurate number of processed and returned hits, typically should be less or equals to totalResultCount
     * @return 
     * @since 2.20
     */
    @Override
    public int getReturnedResultCount() {
        return returnedResults;
    }

    void addReturnedResultCount(int moreReturnedResults) {
        returnedResults = moreReturnedResults + returnedResults;
    }
    
}





import java.util.Collection;
import org.apache.maven.artifact.Artifact;
import org.netbeans.modules.maven.indexer.NexusRepositoryIndexerImpl;
import org.netbeans.modules.maven.indexer.spi.impl.RepositoryIndexerImplementation;
import org.openide.util.Lookup;
import org.netbeans.modules.maven.indexer.spi.RepositoryIndexQueryProvider;

/**
 *


    public static void indexRepo(RepositoryInfo repo) {
        assert repo != null;
        RepositoryIndexerImplementation impl = findImplementation(repo);
        if(impl != null) {
            // fires 
            impl.indexRepo(repo);
        } else {
            repo.fireIndexChange();
    }
    }
    
    public static void updateIndexWithArtifacts(RepositoryInfo repo, Collection<Artifact> artifacts) {
        assert repo != null;
        if (artifacts == null || artifacts.isEmpty()) {
            return;
        }
        RepositoryIndexerImplementation impl = findImplementation(repo);
        if(impl != null) {
            impl.updateIndexWithArtifacts(repo, artifacts);
    }
    }

    public static void deleteArtifactFromIndex(RepositoryInfo repo, Artifact artifact) {
        assert repo != null;
        if (artifact == null) {
            return;
        }
        RepositoryIndexerImplementation impl = findImplementation(repo);
        if(impl != null) {
            impl.deleteArtifactFromIndex(repo, artifact);
    }
    }
    
    static RepositoryIndexerImplementation findImplementation(RepositoryInfo repo) {
        Lookup l = Lookup.getDefault();
        Collection<? extends RepositoryIndexQueryProvider> queryProviders = l.lookupAll(RepositoryIndexQueryProvider.class);
        for (RepositoryIndexQueryProvider queryProvider : queryProviders) {
            if(!(queryProvider instanceof NexusRepositoryIndexerImpl) && queryProvider.handlesRepository(repo)) {
                // skip if 
                return null;
    }
        }
        return l.lookup(RepositoryIndexerImplementation.class);
    }
    
}

Lines 46-63 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/api/RepositoryQueries.java (-184 / +188 lines)
46	import java.io.IOException;	46	import java.io.IOException;
47	import java.util.ArrayList;	47	import java.util.ArrayList;
48	import java.util.Collection;	48	import java.util.Collection;
49	import java.util.Collections;	49	import java.util.HashMap;
50	import java.util.Iterator;	50	import java.util.Iterator;
		51	import java.util.LinkedList;
51	import java.util.List;	52	import java.util.List;
		53	import java.util.Map;
		54	import java.util.Map.Entry;
52	import java.util.Set;	55	import java.util.Set;
53	import java.util.logging.Level;	56	import java.util.logging.Level;
54	import java.util.logging.Logger;	57	import java.util.logging.Logger;
		58	import org.apache.lucene.search.BooleanQuery;
55	import org.netbeans.api.annotations.common.NonNull;	59	import org.netbeans.api.annotations.common.NonNull;
56	import org.netbeans.api.annotations.common.NullAllowed;	60	import org.netbeans.api.annotations.common.NullAllowed;
57	import org.netbeans.modules.maven.indexer.NexusRepositoryIndexerImpl;	61	import org.netbeans.modules.maven.indexer.ResultImpl;
58	import org.netbeans.modules.maven.indexer.spi.*;	62	import org.netbeans.modules.maven.indexer.spi.ArchetypeQueries;
		63	import org.netbeans.modules.maven.indexer.spi.BaseQueries;
		64	import org.netbeans.modules.maven.indexer.spi.ChecksumQueries;
		65	import org.netbeans.modules.maven.indexer.spi.ClassUsageQuery;
		66	import org.netbeans.modules.maven.indexer.spi.ClassesQuery;
		67	import org.netbeans.modules.maven.indexer.spi.ContextLoadedQuery;
		68	import org.netbeans.modules.maven.indexer.spi.DependencyInfoQueries;
		69	import org.netbeans.modules.maven.indexer.spi.GenericFindQuery;
		70	import org.netbeans.modules.maven.indexer.spi.NullResultImpl;
		71	import org.netbeans.modules.maven.indexer.spi.ResultImplementation;
59	import org.netbeans.modules.project.spi.intern.ProjectIDEServices;	72	import org.netbeans.modules.project.spi.intern.ProjectIDEServices;
60	import org.openide.util.Lookup;	73	import org.openide.util.Lookup;
		74	import org.netbeans.modules.maven.indexer.spi.RepositoryIndexQueryProvider;
61		75
62	/**	76	/**
63	* Searches Maven repositories in various ways.	77	* Searches Maven repositories in various ways.
Lines 71-246 Link Here
71		85
72	/**	86	/**
73	* query result set	87	* query result set
		88	* @param <T>
74	* @since 2.9	89	* @since 2.9
75	*/	90	*/
76	public final static class Result<T> {	91	public final static class Result<T> {
77	private final List<RepositoryInfo> skipped = new ArrayList<RepositoryInfo>();	92	private final ResultImplementation<T> impl;
78	private List<T> results = new ArrayList<T>();
79	private final Redo<T> redoAction;
80	int totalResults = 0;
81	int returnedResults = 0;
82		93
83	/**	94	/**
84	* used internally by the repository indexing/searching engine(s)	95	* Creates a Result instance.
		96	* @param impl
85	*/	97	*/
86	Result(Redo<T> redo) {	98	public Result(ResultImplementation<T> impl) {
87	redoAction = redo;	99	this.impl = impl;
88	}	100	}
89		101
90	/**	102	/**
91	* returns true is one or more indexes were skipped, eg because the indexing was taking place.	103	* Returns true is one or more indexes were skipped, e.g. because the indexing was taking place.
92	* @return	104	* @return
93	*/	105	*/
94	public synchronized boolean isPartial() {	106	public synchronized boolean isPartial() {
95	return !skipped.isEmpty();	107	return impl.isPartial();
96	}	108	}
97		109
98	/**	110	/**
99	* used internally by the repository indexing/searching engine(s) to mark the result as partially skipped	111	* Waits for currently unaccessible indexes to finish, not to be called in AWT thread.
100	*/	112	*/
101	synchronized void addSkipped(RepositoryInfo info) {
102	skipped.add(info);
103	}
104
105	/**
106	* waits for currently unaccessible indexes to finish, not to be called in AWT thread.
107	*/
108	public void waitForSkipped() {	113	public void waitForSkipped() {
109	assert !ProjectIDEServices.isEventDispatchThread();	114	assert !ProjectIDEServices.isEventDispatchThread();
110	redoAction.run(this);	115	impl.waitForSkipped();
111	synchronized (this) {
112	skipped.clear();
113	}	116	}
114	}
115		117
116	synchronized void setResults(Collection<T> newResults) {
117	results.clear();
118	results.addAll(newResults);
119	}
120
121	public synchronized List<T> getResults() {
122	return Collections.unmodifiableList(results);
123	}
124
125
126	/**	118	/**
127	* used internally by the repository indexing/searching engine(s) to mark the result as partially skipped	119	* Returns a list of results
		120	* @return
128	*/	121	*/
129	synchronized void addSkipped(Collection<RepositoryInfo> infos) {	122	public synchronized List<T> getResults() {
130	skipped.addAll(infos);	123	return impl.getResults();
131	}	124	}
132		125
133	/**	126	/**
134	* used internally by the repository indexing/searching engine(s) to mark the result as partially skipped	127	* Total number of hits
135	*/
136	synchronized List<RepositoryInfo> getSkipped() {
137	return Collections.unmodifiableList(skipped);
138	}
139	/**
140	* total number of hits
141	* @return	128	* @return
142	* @since 2.20	129	* @since 2.20
143	*/	130	*/
144	public int getTotalResultCount() {	131	public int getTotalResultCount() {
145	return totalResults;	132	return impl.getTotalResultCount();
146	}	133	}
147		134
148	void addTotalResultCount(int moreTotalResults) {
149	totalResults = totalResults + moreTotalResults;
150	}
151	/**	135	/**
152	* in some cases not entirely accurate number of processed and returned hits, typically should be less or equals to totalResultCount	136	* in some cases not entirely accurate number of processed and returned hits, typically should be less or equals to totalResultCount
153	* @return	137	* @return
154	* @since 2.20	138	* @since 2.20
155	*/	139	*/
156	public int getReturnedResultCount() {	140	public int getReturnedResultCount() {
157	return returnedResults;	141	return impl.getReturnedResultCount();
158	}	142	}
159
160	void addReturnedResultCount(int moreReturnedResults) {
161	returnedResults = returnedResults + moreReturnedResults;
162	}	143	}
163		144
		145	private final static class CompositeResult<T> implements ResultImplementation {
164		146
		147	private final List<ResultImplementation<T>> results;
165		148
		149	public CompositeResult(List<ResultImplementation<T>> results) {
		150	this.results = results;
166	}	151	}
167		152
168
169	static {
170	new AccessorImpl();
171	}
172
173
174
175	static class AccessorImpl extends NexusRepositoryIndexerImpl.Accessor {
176
177	@Override	153	@Override
178	public void addSkipped(Result<?> result, Collection<RepositoryInfo> infos) {	154	public boolean isPartial() {
179	result.addSkipped(infos);	155	for (ResultImplementation<T> result : results) {
		156	if(result.isPartial()) {
		157	return true;
180	}	158	}
181
182	@Override
183	public List<RepositoryInfo> getSkipped(Result<?> result) {
184	return result.getSkipped();
185	}	159	}
186		160	return false;
187	@Override
188	public void addSkipped(Result<?> result, RepositoryInfo info) {
189	result.addSkipped(info);
190	}	161	}
191		162
192	@Override	163	@Override
193	public Result<String> createStringResult(Redo<String> redo) {	164	public void waitForSkipped() {
194	return new Result<String>(redo);	165	for (ResultImplementation<T> result : results) {
		166	result.waitForSkipped();
195	}	167	}
196
197	@Override
198	public Result<NBVersionInfo> createVersionResult(Redo<NBVersionInfo> redo) {
199	return new Result<NBVersionInfo>(redo);
200	}	168	}
201		169
202	@Override	170	@Override
203	public void setStringResults(Result<String> result, Collection<String> newResults) {	171	public List<T> getResults() {
204	result.setResults(newResults);	172	List<T> ret = new LinkedList<>();
		173	for (ResultImplementation<T> result : results) {
		174	ret.addAll(result.getResults());
205	}	175	}
206		176	return ret;
207	@Override
208	public void setVersionResults(Result<NBVersionInfo> result, Collection<NBVersionInfo> newResults) {
209	result.setResults(newResults);
210	}	177	}
211		178
212	@Override	179	@Override
213	public Result<NBGroupInfo> createGroupResult(Redo<NBGroupInfo> redo) {	180	public int getTotalResultCount() {
214	return new Result<NBGroupInfo>(redo);	181	int ret = 0;
		182	for (ResultImplementation<T> result : results) {
		183	ret += result.getTotalResultCount();
215	}	184	}
216		185	return ret;
217	@Override
218	public void setGroupResults(Result<NBGroupInfo> result, Collection<NBGroupInfo> newResults) {
219	result.setResults(newResults);
220	}	186	}
221		187
222	@Override	188	@Override
223	public Result<ClassUsage> createClassResult(Redo<ClassUsage> redo) {	189	public int getReturnedResultCount() {
224	return new Result<ClassUsage>(redo);	190	int ret = 0;
		191	for (ResultImplementation<T> result : results) {
		192	ret += result.getReturnedResultCount();
225	}	193	}
226		194	return ret;
227	@Override
228	public void setClassResults(Result<ClassUsage> result, Collection<ClassUsage> newResults) {
229	result.setResults(newResults);
230	}	195	}
231
232	@Override
233	public void addTotalResults(Result<?> result, int moreResults) {
234	result.addTotalResultCount(moreResults);
235	}	196	}
236		197
237	@Override
238	public void addReturnedResults(Result<?> result, int moreResults) {
239	result.addReturnedResultCount(moreResults);
240	}
241	}
242
243
244	/**	198	/**
245	* One usage result.	199	* One usage result.
246	*/	200	*/
Lines 268-300 Link Here
268	}	222	}
269	}	223	}
270		224
		225	private static interface QueryCall<T> {
		226	ResultImplementation<T> call(RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos);
		227	}
271		228
272	private static @NonNull BaseQueries findBaseQueries() {	229	private static <T> Result<T> getQueryResult(List<RepositoryInfo> repos, QueryCall<T> c) {
273	return Lookup.getDefault().lookup(BaseQueries.class);	230	List<ResultImplementation<T>> results = new LinkedList<>();
		231	if (repos == null) {
		232	repos = RepositoryPreferences.getInstance().getRepositoryInfos();
274	}	233	}
		234	Map<RepositoryIndexQueryProvider, List<RepositoryInfo>> qp2Repo = getQueryProvider2Repo(repos);
		235	for(Map.Entry<RepositoryIndexQueryProvider, List<RepositoryInfo>> e : qp2Repo.entrySet()) {
		236	results.add(c.call(e.getKey(), e.getValue()));
		237	}
		238	return new Result<>(new CompositeResult<>(results));
		239	}
275		240
276	/**	241	private static Map<RepositoryIndexQueryProvider, List<RepositoryInfo>> getQueryProvider2Repo(List<RepositoryInfo> repos) {
277	*	242	Collection<? extends RepositoryIndexQueryProvider> idxs = Lookup.getDefault().lookupAll(RepositoryIndexQueryProvider.class);
278	* @param repos	243	Map<RepositoryIndexQueryProvider, List<RepositoryInfo>> qp2Repo = new HashMap<>();
279	* @return	244	for (RepositoryInfo repo : repos) {
280	* @since 2.9	245	for (RepositoryIndexQueryProvider idx : idxs) {
281	*/	246	if(idx.handlesRepository(repo)) {
282	public static Result<String> getGroupsResult(@NullAllowed List<RepositoryInfo> repos) {	247	List<RepositoryInfo> mappedRepos = qp2Repo.get(idx);
283	return findBaseQueries().getGroups(repos);	248	if(mappedRepos == null) {
		249	mappedRepos = new LinkedList<>();
		250	qp2Repo.put(idx, mappedRepos);
284	}	251	}
		252	mappedRepos.add(repo);
		253	break;
		254	}
		255	}
		256	}
		257	return qp2Repo;
		258	}
285		259
286	/**	260	/**
287	*	261	*
288	* @param prefix
289	* @param repos	262	* @param repos
290	* @return	263	* @return
291	* @since 2.9	264	* @since 2.9
292	*/	265	*/
293	public static Result<String> filterGroupIdsResult(String prefix, @NullAllowed List<RepositoryInfo> repos) {	266	public static Result<String> getGroupsResult(@NullAllowed List<RepositoryInfo> repos) {
294	return findBaseQueries().filterGroupIds(prefix, repos);	267	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		268	BaseQueries baseQueries = queryProvider.getBaseQueries();
		269	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		270	return baseQueries.getGroups(providerRepos);
		271	});
295	}	272	}
296		273
297
298	/**	274	/**
299	*	275	*
300	* @param groupId	276	* @param groupId
Lines 305-311 Link Here
305	* @since 2.9	281	* @since 2.9
306	*/	282	*/
307	public static Result<NBVersionInfo> getRecordsResult(String groupId, String artifactId, String version, @NullAllowed List<RepositoryInfo> repos) {	283	public static Result<NBVersionInfo> getRecordsResult(String groupId, String artifactId, String version, @NullAllowed List<RepositoryInfo> repos) {
308	return findBaseQueries().getRecords(groupId, artifactId, version, repos);	284	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		285	BaseQueries baseQueries = queryProvider.getBaseQueries();
		286	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		287	return baseQueries.getRecords(groupId, artifactId, version, providerRepos);
		288	});
309	}	289	}
310		290
311	/**	291	/**
Lines 316-325 Link Here
316	* @since 2.28	296	* @since 2.28
317	*/	297	*/
318	public static Result<String> getGAVsForPackaging(String packaging, @NullAllowed List<RepositoryInfo> repos) {	298	public static Result<String> getGAVsForPackaging(String packaging, @NullAllowed List<RepositoryInfo> repos) {
319	return findBaseQueries().getGAVsForPackaging(packaging, repos);	299	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		300	BaseQueries baseQueries = queryProvider.getBaseQueries();
		301	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		302	return baseQueries.getGAVsForPackaging(packaging, providerRepos);
		303	});
320	}	304	}
321		305
322
323	/**	306	/**
324	*	307	*
325	* @param groupId	308	* @param groupId
Lines 328-337 Link Here
328	* @since 2.9	311	* @since 2.9
329	*/	312	*/
330	public static Result<String> getArtifactsResult(String groupId, @NullAllowed List<RepositoryInfo> repos) {	313	public static Result<String> getArtifactsResult(String groupId, @NullAllowed List<RepositoryInfo> repos) {
331	return findBaseQueries().getArtifacts(groupId, repos);	314	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		315	BaseQueries baseQueries = queryProvider.getBaseQueries();
		316	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		317	return baseQueries.getArtifacts(groupId, providerRepos);
		318	});
332	}	319	}
333		320
334
335	/**	321	/**
336	*	322	*
337	* @param groupId	323	* @param groupId
Lines 341-354 Link Here
341	* @since 2.9	327	* @since 2.9
342	*/	328	*/
343	public static Result<NBVersionInfo> getVersionsResult(String groupId, String artifactId, @NullAllowed List<RepositoryInfo> repos) {	329	public static Result<NBVersionInfo> getVersionsResult(String groupId, String artifactId, @NullAllowed List<RepositoryInfo> repos) {
344	return findBaseQueries().getVersions(groupId, artifactId, repos);	330	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		331	BaseQueries baseQueries = queryProvider.getBaseQueries();
		332	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		333	return baseQueries.getVersions(groupId, artifactId, providerRepos);
		334	});
345	}	335	}
346		336
347
348	private static @NonNull DependencyInfoQueries findDIQ() {
349	return Lookup.getDefault().lookup(DependencyInfoQueries.class);
350	}
351
352	/**	337	/**
353	*	338	*
354	* @param groupId	339	* @param groupId
Lines 359-368 Link Here
359	* @since 2.9	344	* @since 2.9
360	*/	345	*/
361	public static Result<NBGroupInfo> findDependencyUsageResult(String groupId, String artifactId, String version, @NullAllowed List<RepositoryInfo> repos) {	346	public static Result<NBGroupInfo> findDependencyUsageResult(String groupId, String artifactId, String version, @NullAllowed List<RepositoryInfo> repos) {
362	return findDIQ().findDependencyUsageGroups(groupId, artifactId, version, repos);	347	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		348	DependencyInfoQueries dependencyInfoQueries = queryProvider.getDependencyInfoQueries();
		349	return dependencyInfoQueries != null ?
		350	dependencyInfoQueries.findDependencyUsageGroups(groupId, artifactId, version, providerRepos) :
		351	new NullResultImpl<>();
		352	});
363	}	353	}
364		354
365
366	/**	355	/**
367	*	356	*
368	* @param file	357	* @param file
Lines 377-402 Link Here
377	} catch (IOException ex) {	366	} catch (IOException ex) {
378	Logger.getLogger(RepositoryQueries.class.getName()).log(Level.INFO, "Could not determine SHA-1 of " + file, ex);	367	Logger.getLogger(RepositoryQueries.class.getName()).log(Level.INFO, "Could not determine SHA-1 of " + file, ex);
379	}	368	}
380	return NexusRepositoryIndexerImpl.Accessor.ACCESSOR.createVersionResult(new Redo<NBVersionInfo>() {	369	return new Result<>(new NullResultImpl<>());
381	@Override
382	public void run(Result<NBVersionInfo> result) {
383	//noop
384	}	370	}
385	});
386		371
387	}
388
389	private static ChecksumQueries findChecksumQueries() {
390	return Lookup.getDefault().lookup(ChecksumQueries.class);
391	}
392
393	private static Result<NBVersionInfo> findBySHA1(String sha1, @NullAllowed List<RepositoryInfo> repos) {	372	private static Result<NBVersionInfo> findBySHA1(String sha1, @NullAllowed List<RepositoryInfo> repos) {
394	return findChecksumQueries().findBySHA1(sha1, repos);	373	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		374	ChecksumQueries checksumQueries = queryProvider.getChecksumQueries();
		375	return checksumQueries != null ?
		376	checksumQueries.findBySHA1(sha1, providerRepos) :
		377	new NullResultImpl<>();
		378	});
395	}	379	}
396		380
397	private static @NonNull ClassesQuery findClassesQueries() {
398	return Lookup.getDefault().lookup(ClassesQuery.class);
399	}
400	/**	381	/**
401	*	382	*
402	* @param className	383	* @param className
Lines 411-417 Link Here
411	* @since 2.9	392	* @since 2.9
412	*/	393	*/
413	public static Result<NBVersionInfo> findVersionsByClassResult(final String className, @NullAllowed List<RepositoryInfo> repos) {	394	public static Result<NBVersionInfo> findVersionsByClassResult(final String className, @NullAllowed List<RepositoryInfo> repos) {
414	return findClassesQueries().findVersionsByClass(className, repos);	395	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		396	ClassesQuery classesQuery = queryProvider.getClassesQuery();
		397	return classesQuery != null ?
		398	classesQuery.findVersionsByClass(className, providerRepos) :
		399	new NullResultImpl<>();
		400	});
415	}	401	}
416		402
417	/**	403	/**
Lines 438-446 Link Here
438	//TODO first process the loaded ones, index and wait for finish of indexing of the unloaded ones..	424	//TODO first process the loaded ones, index and wait for finish of indexing of the unloaded ones..
439	for (Iterator<RepositoryInfo> it1 = query.getRepositories().iterator(); it1.hasNext();) {	425	for (Iterator<RepositoryInfo> it1 = query.getRepositories().iterator(); it1.hasNext();) {
440	RepositoryInfo repositoryInfo = it1.next();	426	RepositoryInfo repositoryInfo = it1.next();
441	List<RepositoryInfo> repositoryInfoL = new ArrayList<RepositoryInfo>(1);	427	List<RepositoryInfo> repositoryInfoL = new ArrayList<>(1);
442	repositoryInfoL.add(repositoryInfo);	428	repositoryInfoL.add(repositoryInfo);
443	query.addResults(findClassesQueries().findVersionsByClass(query.getClassName(), repositoryInfoL).getResults(), !it1.hasNext());	429	Result<NBVersionInfo> queryResult = getQueryResult(repositoryInfoL, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		430	ClassesQuery classesQuery = queryProvider.getClassesQuery();
		431	return classesQuery != null ?
		432	classesQuery.findVersionsByClass(query.getClassName(), providerRepos) :
		433	new NullResultImpl<>();
		434	});
		435	query.addResults(queryResult.getResults(), !it1.hasNext());
444	// still someone waiting for results?	436	// still someone waiting for results?
445	if (query.countObservers() == 0)	437	if (query.countObservers() == 0)
446	return;	438	return;
Lines 449-458 Link Here
449	query.addResults(null, true);	441	query.addResults(null, true);
450	}	442	}
451		443
452	private static @NonNull ClassUsageQuery findClassUsageQuery() {
453	return Lookup.getDefault().lookup(ClassUsageQuery.class);
454	}
455
456	/**	444	/**
457	* Finds all usages of a given class.	445	* Finds all usages of a given class.
458	* The implementation may not provide results within the same artifact, or on classes in the JRE.	446	* The implementation may not provide results within the same artifact, or on classes in the JRE.
Lines 462-475 Link Here
462	* @since 2.9	450	* @since 2.9
463	*/	451	*/
464	public static Result<ClassUsage> findClassUsagesResult(String className, @NullAllowed List<RepositoryInfo> repos) {	452	public static Result<ClassUsage> findClassUsagesResult(String className, @NullAllowed List<RepositoryInfo> repos) {
465	return findClassUsageQuery().findClassUsages(className, repos);	453	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		454	ClassUsageQuery classUsageQuery = queryProvider.getClassUsageQuery();
		455	return classUsageQuery != null ?
		456	classUsageQuery.findClassUsages(className, repos) :
		457	new NullResultImpl<>();
		458	});
466	}	459	}
467		460
468
469	private static @NonNull ArchetypeQueries findArchetypeQueries() {
470	return Lookup.getDefault().lookup(ArchetypeQueries.class);
471	}
472
473	/**	461	/**
474	*	462	*
475	* @param repos	463	* @param repos
Lines 477-487 Link Here
477	* @since 2.9	465	* @since 2.9
478	*/	466	*/
479	public static Result<NBVersionInfo> findArchetypesResult(@NullAllowed List<RepositoryInfo> repos) {	467	public static Result<NBVersionInfo> findArchetypesResult(@NullAllowed List<RepositoryInfo> repos) {
480	return findArchetypeQueries().findArchetypes(repos);	468	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		469	ArchetypeQueries archetypeQueries = queryProvider.getArchetypeQueries();
		470	return archetypeQueries != null ?
		471	archetypeQueries.findArchetypes(repos) :
		472	new NullResultImpl<>();
		473	});
481	}	474	}
482		475
483
484
485	/**	476	/**
486	*	477	*
487	* @param groupId	478	* @param groupId
Lines 491-500 Link Here
491	* @since 2.9	482	* @since 2.9
492	*/	483	*/
493	public static Result<String> filterPluginArtifactIdsResult(String groupId, String prefix, @NullAllowed List<RepositoryInfo> repos) {	484	public static Result<String> filterPluginArtifactIdsResult(String groupId, String prefix, @NullAllowed List<RepositoryInfo> repos) {
494	return findBaseQueries().filterPluginArtifactIds(groupId, prefix, repos);	485	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		486	BaseQueries baseQueries = queryProvider.getBaseQueries();
		487	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		488	return baseQueries.filterPluginArtifactIds(groupId, prefix, providerRepos);
		489	});
495	}	490	}
496		491
497
498	/**	492	/**
499	*	493	*
500	* @param prefix	494	* @param prefix
Lines 503-516 Link Here
503	* @since 2.9	497	* @since 2.9
504	*/	498	*/
505	public static Result<String> filterPluginGroupIdsResult(String prefix, @NullAllowed List<RepositoryInfo> repos) {	499	public static Result<String> filterPluginGroupIdsResult(String prefix, @NullAllowed List<RepositoryInfo> repos) {
506	return findBaseQueries().filterPluginGroupIds(prefix, repos);	500	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		501	BaseQueries baseQueries = queryProvider.getBaseQueries();
		502	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		503	return baseQueries.filterPluginGroupIds(prefix, providerRepos);
		504	});
507	}	505	}
508		506
509
510	private static @NonNull GenericFindQuery findFindQuery() {
511	return Lookup.getDefault().lookup(GenericFindQuery.class);
512	}
513
514	/**	507	/**
515	* @throws BooleanQuery.TooManyClauses This runtime exception can be thrown if given query is too	508	* @throws BooleanQuery.TooManyClauses This runtime exception can be thrown if given query is too
516	* general and such search can't be executed as it would probably end with	509	* general and such search can't be executed as it would probably end with
Lines 525-531 Link Here
525	* @since 2.9	518	* @since 2.9
526	*/	519	*/
527	public static Result<NBVersionInfo> findResult(List<QueryField> fields, @NullAllowed List<RepositoryInfo> repos) {	520	public static Result<NBVersionInfo> findResult(List<QueryField> fields, @NullAllowed List<RepositoryInfo> repos) {
528	return findFindQuery().find(fields, repos);	521	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		522	GenericFindQuery genericFindQuery = queryProvider.getGenericFindQuery();
		523	return genericFindQuery != null ?
		524	genericFindQuery.find(fields, providerRepos) :
		525	new NullResultImpl<>();
		526	});
529	}	527	}
530		528
531	/**	529	/**
Lines 551-559 Link Here
551	public static void find(QueryRequest query) {	549	public static void find(QueryRequest query) {
552	for (Iterator<RepositoryInfo> it1 = query.getRepositories().iterator(); it1.hasNext();) {	550	for (Iterator<RepositoryInfo> it1 = query.getRepositories().iterator(); it1.hasNext();) {
553	RepositoryInfo repositoryInfo = it1.next();	551	RepositoryInfo repositoryInfo = it1.next();
554	List<RepositoryInfo> repositoryInfoL = new ArrayList<RepositoryInfo>(1);	552	List<RepositoryInfo> repositoryInfoL = new ArrayList<>(1);
555	repositoryInfoL.add(repositoryInfo);	553	repositoryInfoL.add(repositoryInfo);
556	query.addResults(findFindQuery().find(query.getQueryFields(), repositoryInfoL).getResults(), !it1.hasNext());	554	Result<NBVersionInfo> qeuryResult =
		555	getQueryResult(repositoryInfoL, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		556	GenericFindQuery genericFindQuery = queryProvider.getGenericFindQuery();
		557	return genericFindQuery != null ?
		558	genericFindQuery.find(query.getQueryFields(), providerRepos) :
		559	new NullResultImpl<>();
		560	});
		561	query.addResults(qeuryResult.getResults(), !it1.hasNext());
557	// still someone waiting for results?	562	// still someone waiting for results?
558	if (query.countObservers() == 0)	563	if (query.countObservers() == 0)
559	return;	564	return;
Lines 563-578 Link Here
563	}	568	}
564		569
565	public static @NonNull List<RepositoryInfo> getLoadedContexts() {	570	public static @NonNull List<RepositoryInfo> getLoadedContexts() {
566	List<RepositoryInfo> toRet = new ArrayList<RepositoryInfo>();	571	List<RepositoryInfo> toRet = new ArrayList<>();
567	ContextLoadedQuery clq = Lookup.getDefault().lookup(ContextLoadedQuery.class);	572	List<RepositoryInfo> repos = RepositoryPreferences.getInstance().getRepositoryInfos();
		573	Map<RepositoryIndexQueryProvider, List<RepositoryInfo>> i2r = getQueryProvider2Repo(repos);
		574	for(Entry<RepositoryIndexQueryProvider, List<RepositoryInfo>> e : i2r.entrySet()) {
		575	ContextLoadedQuery clq = e.getKey().getContextLoadedQuery();
568	assert clq != null;	576	assert clq != null;
569	toRet.addAll(clq.getLoaded(RepositoryPreferences.getInstance().getRepositoryInfos()));	577	toRet.addAll(clq.getLoaded(repos));
		578	}
570	return toRet;	579	return toRet;
571	}	580	}
572		581
573
574	public static Result<String> filterArtifactIdForGroupIdResult(String groupId, String prefix, @NullAllowed List<RepositoryInfo> repos) {
575	return findBaseQueries().filterArtifactIdForGroupId(groupId, prefix, repos);
576	}	582	}
577
578	}

Lines 53-58 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/spi/ArchetypeQueries.java (-1 / +1 lines)
53	*/	53	*/
54	public interface ArchetypeQueries {	54	public interface ArchetypeQueries {
55		55
56	RepositoryQueries.Result<NBVersionInfo> findArchetypes(List<RepositoryInfo> repos);	56	ResultImplementation<NBVersionInfo> findArchetypes(List<RepositoryInfo> repos);
57		57
58	}	58	}

Lines 44-73 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/spi/BaseQueries.java (-12 / +64 lines)
44	import java.util.List;	44	import java.util.List;
45	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;	45	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;
46	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;	46	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;
47	import org.netbeans.modules.maven.indexer.api.RepositoryQueries;
48		47
49	/**	48	/**
50	* The basic set of queries. To be implemented by all index managers.	49	* The basic set of queries. To be implemented by all index managers.
		50	*
		51	* <p><b>Note</b> that all calls might be made from the IDE-s user interface and
		52	* even if the return time isn't crucial for the UI responsivity, it still should be
		53	* "reasonably" fast.</p>
		54	*
51	* @author Milos Kleint	55	* @author Milos Kleint
52	*/	56	*/
53	public interface BaseQueries {	57	public interface BaseQueries {
54		58
55	RepositoryQueries.Result<String> getGroups(List<RepositoryInfo> repos);	59	/**
		60	* Returns all group id-s available.
		61	*
		62	* @param repos repositories to search in
		63	* @return groupId-s
		64	*/
		65	ResultImplementation<String> getGroups(List<RepositoryInfo> repos);
56		66
57	RepositoryQueries.Result<String> filterGroupIds(String prefix, List<RepositoryInfo> repos);	67	/**
		68	* Returns versions given by GAV.
		69	*
		70	* @param groupId
		71	* @param artifactId
		72	* @param version
		73	* @param repos repositories to search in
		74	* @return NBVersionInfo-s
		75	*/
		76	ResultImplementation<NBVersionInfo> getRecords(String groupId, String artifactId, String version, List<RepositoryInfo> repos);
58		77
59	RepositoryQueries.Result<NBVersionInfo> getRecords(String groupId, String artifactId, String version, List<RepositoryInfo> repos);	78	/**
		79	* Returns versions given by a groupId, artifactId.
		80	*
		81	* @param groupId
		82	* @param artifactId
		83	* @param repos repositories to search in
		84	* @return NBVersionInfo-s
		85	*/
		86	ResultImplementation<NBVersionInfo> getVersions(String groupId, String artifactId, List<RepositoryInfo> repos);
60		87
61	RepositoryQueries.Result<String> getArtifacts(String groupId, List<RepositoryInfo> repos);	88	/**
		89	* Returns all artifactId-s given by a groupId.
		90	*
		91	* @param groupId
		92	* @param repos repositories to search in
		93	* @return artifactId-s
		94	*/
		95	ResultImplementation<String> getArtifacts(String groupId, List<RepositoryInfo> repos);
62		96
63	RepositoryQueries.Result<NBVersionInfo> getVersions(String groupId, String artifactId, List<RepositoryInfo> repos);	97	/**
		98	* Returns all artifactId-s given by a groupId and artifactId prefix.
		99	*
		100	* @param groupId
		101	* @param artifactIdPrefix
		102	* @param repos repositories to search in
		103	* @return artifactId-s
		104	*/
		105	ResultImplementation<String> filterPluginArtifactIds(String groupId, String artifactIdPrefix, List<RepositoryInfo> repos);
64		106
65	RepositoryQueries.Result<String> filterPluginArtifactIds(String groupId, String prefix, List<RepositoryInfo> repos);	107	/**
		108	* Returns all groupId-s given by a groupId prefix.
		109	*
		110	* @param prefix
		111	* @param repos repositories to search in
		112	* @return groupId-s
		113	*/
		114	ResultImplementation<String> filterPluginGroupIds(String prefix, List<RepositoryInfo> repos);
66		115
67	RepositoryQueries.Result<String> filterPluginGroupIds(String prefix, List<RepositoryInfo> repos);	116	/**
		117	* Return all GAV-s given by a packaging.
		118	*
		119	* @param packaging
		120	* @param repos repositories to search in
		121	* @return GAV-s
		122	*/
		123	ResultImplementation<String> getGAVsForPackaging(String packaging, List<RepositoryInfo> repos);
68		124
69	RepositoryQueries.Result<String> filterArtifactIdForGroupId(String groupId, String prefix, List<RepositoryInfo> repos);
70
71	RepositoryQueries.Result<String> getGAVsForPackaging(String packaging, List<RepositoryInfo> repos);
72
73	}	125	}

Lines 51-55 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/spi/ChecksumQueries.java (-1 / +1 lines)
51	* @author Milos Kleint	51	* @author Milos Kleint
52	*/	52	*/
53	public interface ChecksumQueries {	53	public interface ChecksumQueries {
54	RepositoryQueries.Result<NBVersionInfo> findBySHA1(String sha1, List<RepositoryInfo> repos);	54	ResultImplementation<NBVersionInfo> findBySHA1(String sha1, List<RepositoryInfo> repos);
55	}	55	}

Lines 59-64 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/spi/ClassUsageQuery.java (-1 / +1 lines)
59	* @param repos repositories of this type to search in	59	* @param repos repositories of this type to search in
60	* @return result object with a list of usages	60	* @return result object with a list of usages
61	*/	61	*/
62	RepositoryQueries.Result<RepositoryQueries.ClassUsage> findClassUsages(String className, List<RepositoryInfo> repos);	62	ResultImplementation<RepositoryQueries.ClassUsage> findClassUsages(String className, List<RepositoryInfo> repos);
63		63
64	}	64	}

Lines 43-51 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/spi/ClassesQuery.java (-2 / +2 lines)
43	package org.netbeans.modules.maven.indexer.spi;	43	package org.netbeans.modules.maven.indexer.spi;
44		44
45	import java.util.List;	45	import java.util.List;
		46	import org.apache.lucene.search.BooleanQuery;
46	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;	47	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;
47	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;	48	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;
48	import org.netbeans.modules.maven.indexer.api.RepositoryQueries;
49		49
50	/**	50	/**
51	* Query to find artifacts information from class names.	51	* Query to find artifacts information from class names.
Lines 61-65 Link Here
61	* accordingly, for example by telling user that entered text for	61	* accordingly, for example by telling user that entered text for
62	* search is too general.	62	* search is too general.
63	*/	63	*/
64	public RepositoryQueries.Result<NBVersionInfo> findVersionsByClass(final String className, List<RepositoryInfo> repos);	64	public ResultImplementation<NBVersionInfo> findVersionsByClass(final String className, List<RepositoryInfo> repos);
65	}	65	}

Lines 45-51 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/spi/DependencyInfoQueries.java (-3 / +2 lines)
45	import org.netbeans.modules.maven.indexer.api.NBGroupInfo;	45	import org.netbeans.modules.maven.indexer.api.NBGroupInfo;
46	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;	46	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;
47	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;	47	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;
48	import org.netbeans.modules.maven.indexer.api.RepositoryQueries;
49		48
50	/**	49	/**
51	* Query to find dependency information of artifacts.Non mandatory for repository managers.	50	* Query to find dependency information of artifacts.Non mandatory for repository managers.
Lines 53-60 Link Here
53	*/	52	*/
54	public interface DependencyInfoQueries {	53	public interface DependencyInfoQueries {
55		54
56	RepositoryQueries.Result<NBVersionInfo> findDependencyUsage(String groupId, String artifactId, String version, List<RepositoryInfo> repoIds);	55	ResultImplementation<NBVersionInfo> findDependencyUsage(String groupId, String artifactId, String version, List<RepositoryInfo> repoIds);
57		56
58	RepositoryQueries.Result<NBGroupInfo> findDependencyUsageGroups(String groupId, String artifactId, String version, List<RepositoryInfo> repoIds);	57	ResultImplementation<NBGroupInfo> findDependencyUsageGroups(String groupId, String artifactId, String version, List<RepositoryInfo> repoIds);
59		58
60	}	59	}




package org.netbeans.modules.maven.indexer.spi;

import java.util.List;
import org.apache.lucene.search.BooleanQuery;
import org.netbeans.modules.maven.indexer.api.NBVersionInfo;
import org.netbeans.modules.maven.indexer.api.QueryField;
import org.netbeans.modules.maven.indexer.api.RepositoryInfo;
import org.netbeans.modules.maven.indexer.api.RepositoryQueries;

/**
 * non mandatory query to for generic searching within the repository.

     * accordingly, for example by telling user that entered text for
     * search is too general.
     */
    public ResultImplementation<NBVersionInfo> find(List<QueryField> fields, List<RepositoryInfo> repos);
    
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.maven.indexer.spi;

import java.util.Collections;
import java.util.List;

/**
 * Convenience class.
 * 
 * @author Tomas Stupka
 * @param <T>
 */
public final class NullResultImpl<T> implements ResultImplementation<T> {        

    @Override
    public boolean isPartial() {
        return false;
    }

    @Override
    public void waitForSkipped() {

    }
    
    @Override
    public List<T> getResults() {            
        return Collections.EMPTY_LIST;
    }

    @Override
    public int getTotalResultCount() {
        return 0;
    }
    
    @Override
    public int getReturnedResultCount() {
        return 0;
    }        
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.maven.indexer.spi;

import org.netbeans.modules.maven.indexer.api.RepositoryQueries;

/**
 * used internally by the repository indexing/searching engine(s)
 * @author mkleint
 */
public interface Redo<T> {
    void run(RepositoryQueries.Result<T> result);
}    





/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.maven.indexer.spi;

import org.netbeans.api.annotations.common.CheckForNull;
import org.netbeans.api.annotations.common.NonNull;
import org.netbeans.api.annotations.common.NullAllowed;
import org.netbeans.modules.maven.indexer.api.RepositoryInfo;

/**
 * Provides repository queries.<br> 
 * Register via <code>@ServiceProvider(service=RepositoryIndexQueryProvider.class)</code>
 * 
 * @author Tomas Stupka
 * @since 2.38
 */
public interface RepositoryIndexQueryProvider {
    
    /** 
     * Determines if queries for the given repository are handled by this provider or not.
     * 
     * @param repo the repository
     * @return <code>true</code> if the given repository is handled by this provider, otherwise <code>false</code>
     * @since 2.38
     */
    boolean handlesRepository(RepositoryInfo repo);
    
    /**
     * Returns a {@link ArchetypeQueries} implementation.
     * 
     * @return ArchetypeQueries or <code>null</code> if not provided
     * @since 2.38
     */
    @CheckForNull ArchetypeQueries getArchetypeQueries();
    
    /**
     * Returns a {@link BaseQueries} implementation.
     * 
     * @return BaseQueries
     * @since 2.38
     */
    @NonNull BaseQueries getBaseQueries();
    
    /**
     * Returns a {@link ChecksumQueries} implementation.
     * 
     * @return ChecksumQueries or <code>null</code> if not provided
     * @since 2.38
     */
    @CheckForNull ChecksumQueries getChecksumQueries();
    
    /**
     * Returns a {@link ClassUsageQuery} implementation.
     * 
     * @return ClassUsageQuery or <code>null</code> if not provided
     * @since 2.38
     */
    @CheckForNull ClassUsageQuery getClassUsageQuery();
    
    /**
     * Returns a {@link ClassesQuery} implementation.
     * 
     * @return ClassesQuery or <code>null</code> if not provided
     * @since 2.38
     */
    @CheckForNull ClassesQuery getClassesQuery();
    
    /**
     * Returns a {@link ContextLoadedQuery} implementation.
     * 
     * @return ContextLoadedQuery or <code>null</code> if not provided
     * @since 2.38
     */
    @CheckForNull ContextLoadedQuery getContextLoadedQuery();
    
    /**
     * Returns a {@link DependencyInfoQueries} implementation.
     * 
     * @return DependencyInfoQueries or <code>null</code> if not provided
     * @since 2.38
     */
    @CheckForNull DependencyInfoQueries getDependencyInfoQueries();
    
    /**
     * Returns a {@link GenericFindQuery} implementation.
     * 
     * @return GenericFindQuery or <code>null</code> if not provided
     * @since 2.38
     */
    @CheckForNull GenericFindQuery getGenericFindQuery();
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */
package org.netbeans.modules.maven.indexer.spi;

import java.util.Collection;
import org.apache.maven.artifact.Artifact;
import org.netbeans.modules.maven.indexer.api.RepositoryInfo;

/**
 * Implementation of repository indexer (repository manager). Apart from basic
 * indexing features also serves as provider of various index queries.
 * There is one implementation based on apache indexer
 * 
 * @author Milos Kleint
 */
public interface RepositoryIndexerImplementation {
    
    /**
     * Index local repository or retrieve remote prepopulated index for local use.
     * @param repo
     */
    void indexRepo(RepositoryInfo repo);
    
    void updateIndexWithArtifacts(RepositoryInfo repo, Collection<Artifact> artifacts);

    void deleteArtifactFromIndex(RepositoryInfo repo, Artifact artifact);

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.maven.indexer.spi;

import java.util.List;

/**
 * Implement to provide a maven index query result.
 * 
 * @author Tomas Stupka
 * @param <T>
 * @since 2.38
 * @see org.netbeans.modules.maven.indexer.api.RepositoryQueries.Result
 */
public interface ResultImplementation<T> {
    /**
     * Returns true is one or more indexes were skipped, e.g. because the indexing was taking place.
     * 
     * @return <code>true</code> if the result is partial, otherwise <code>false</code>
     * @since 2.38
     */
    public boolean isPartial();
    
    /**
     * Waits for currently unaccessible indexes to finish, not to be called in AWT thread.
     * 
     * @since 2.38
     */
    public void waitForSkipped();
    
    /**
     * Returns the results.
     * 
     * @return a list of results
     * @since 2.38
     */
    public List<T> getResults();
    
    /**
     * Total number of hits.
     * 
     * @return the total number of hits
     * @since 2.38
     */
    public int getTotalResultCount();
    
    /**
     * In some cases not entirely accurate number of processed and returned hits, 
     * typically should be less or equal to {@link #getReturnedResultCount()}.
     * 
     * @return the returned result count
     * @since 2.38
     */
    public int getReturnedResultCount();
}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2012 Sun Microsystems, Inc.
 */
package org.netbeans.modules.maven.indexer.spi.impl;

import org.netbeans.modules.maven.indexer.ResultImpl;

/**
 * used internally by the repository indexing/searching engine(s)
 * @author mkleint
 */
public interface Redo<T> {
    void run(ResultImpl<T> result);
}    





package org.netbeans.modules.maven.indexer.spi.impl;

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2008 Sun Microsystems, Inc.
 */


import java.util.Collection;
import org.apache.maven.artifact.Artifact;
import org.netbeans.modules.maven.indexer.api.RepositoryInfo;

/**
 * 
 * Used internally.
 * 
 * Implementation of repository indexer (repository manager). Apart from basic
 * indexing features also serves as provider of various index queries.
 * There is one implementation based on apache indexer
 * 
 * @author Milos Kleint
 */
public interface RepositoryIndexerImplementation {
    
    /**
     * Index local repository or retrieve remote prepopulated index for local use.
     * @param repo
     */
    void indexRepo(RepositoryInfo repo);
    
    void updateIndexWithArtifacts(RepositoryInfo repo, Collection<Artifact> artifacts);

    void deleteArtifactFromIndex(RepositoryInfo repo, Artifact artifact);

}

Lines 46-53 Link Here

(-)maven.indexer/test/unit/src/org/netbeans/modules/maven/indexer/NexusRepositoryIndexerImplTest.java (-2 / +10 lines)
46	import java.util.Collections;	46	import java.util.Collections;
47	import java.util.List;	47	import java.util.List;
48	import org.apache.maven.index.ArtifactInfo;	48	import org.apache.maven.index.ArtifactInfo;
		49	import org.netbeans.junit.MockServices;
		50	import org.netbeans.modules.maven.indexer.api.AbstractTestQueryProvider.TestIndexer1;
49	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;	51	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;
50	import org.netbeans.modules.maven.indexer.api.QueryField;	52	import org.netbeans.modules.maven.indexer.api.QueryField;
		53	import org.netbeans.modules.maven.indexer.api.RepositoryQueries;
51	import org.openide.util.test.TestFileUtils;	54	import org.openide.util.test.TestFileUtils;
52		55
53	public class NexusRepositoryIndexerImplTest extends NexusTestBase {	56	public class NexusRepositoryIndexerImplTest extends NexusTestBase {
Lines 56-65 Link Here
56	super(n);	59	super(n);
57	}	60	}
58		61
59	public void testFilterGroupIds() throws Exception {	62	public void testFilterPluginGroupIdsRepositoryQueries() throws Exception {
		63	// add an alternative QueryProvider _not_ handlig our request
		64	MockServices.setServices(TestIndexer1.class);
		65
60	install(File.createTempFile("whatever", ".txt", getWorkDir()), "test", "spin", "1.1", "txt");	66	install(File.createTempFile("whatever", ".txt", getWorkDir()), "test", "spin", "1.1", "txt");
61	nrii.indexRepo(info);	67	nrii.indexRepo(info);
62	assertEquals("[test]", nrii.filterGroupIds("", Collections.singletonList(info)).getResults().toString());	68	// RepositoryQueries should handle the query via our NexusRepositoryIndexerImpl
		69	RepositoryQueries.Result<String> res = RepositoryQueries.getArtifactsResult("test", Collections.singletonList(info));
		70	assertEquals("[spin]", res.getResults().toString());
63	}	71	}
64		72
65	public void testFind() throws Exception {	73	public void testFind() throws Exception {

Lines 49-54 Link Here

(-)maven.indexer/test/unit/src/org/netbeans/modules/maven/indexer/NexusTestBase.java (-1 / +2 lines)
49	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;	49	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;
50	import org.netbeans.modules.maven.indexer.api.RepositoryPreferences;	50	import org.netbeans.modules.maven.indexer.api.RepositoryPreferences;
51	import org.openide.modules.api.PlacesTestUtils;	51	import org.openide.modules.api.PlacesTestUtils;
		52	import org.openide.util.Lookup;
52	import org.openide.util.Utilities;	53	import org.openide.util.Utilities;
53	import org.openide.util.test.TestFileUtils;	54	import org.openide.util.test.TestFileUtils;
54		55
Lines 75-81 Link Here
75	artifactInstaller = embedder.lookupComponent(ArtifactInstaller.class);	76	artifactInstaller = embedder.lookupComponent(ArtifactInstaller.class);
76	info = new RepositoryInfo("test", "Test", repo.getAbsolutePath(), null);	77	info = new RepositoryInfo("test", "Test", repo.getAbsolutePath(), null);
77	RepositoryPreferences.getInstance().addOrModifyRepositoryInfo(info);	78	RepositoryPreferences.getInstance().addOrModifyRepositoryInfo(info);
78	nrii = new NexusRepositoryIndexerImpl();	79	nrii = Lookup.getDefault().lookup(NexusRepositoryIndexerImpl.class);
79	}	80	}
80		81
81	@Override protected Level logLevel() {	82	@Override protected Level logLevel() {




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2016 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2016 Sun Microsystems, Inc.
 */
package org.netbeans.modules.maven.indexer.api;

import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.apache.maven.artifact.Artifact;
import org.netbeans.modules.maven.indexer.spi.ArchetypeQueries;
import org.netbeans.modules.maven.indexer.spi.BaseQueries;
import org.netbeans.modules.maven.indexer.spi.ChecksumQueries;
import org.netbeans.modules.maven.indexer.spi.ClassUsageQuery;
import org.netbeans.modules.maven.indexer.spi.ClassesQuery;
import org.netbeans.modules.maven.indexer.spi.ContextLoadedQuery;
import org.netbeans.modules.maven.indexer.spi.DependencyInfoQueries;
import org.netbeans.modules.maven.indexer.spi.GenericFindQuery;
import org.netbeans.modules.maven.indexer.spi.ResultImplementation;
import org.openide.util.Exceptions;
import org.netbeans.modules.maven.indexer.spi.RepositoryIndexQueryProvider;

/**
 *
 * @author tomas
 */
public abstract class AbstractTestQueryProvider implements RepositoryIndexQueryProvider {

    private static final String TESTREPO = "testrepo";
    
    public static class TestIndexer1 extends AbstractTestQueryProvider {
        public static final String ID = TESTREPO + ".1";
        public static RepositoryInfo REPO;
        static {
            try {REPO = new RepositoryInfo(ID, ID, null, "http://test1"); } catch (URISyntaxException ex) { Exceptions.printStackTrace(ex); }
        }
        public TestIndexer1() {
            this.repos = new RepositoryInfo[] {REPO};
        }
        protected String getID() {
            return ID;
        }
    }
    public static class TestIndexer2 extends AbstractTestQueryProvider {
        public static final String ID = TESTREPO + ".2";
        public static RepositoryInfo REPO;
        static {
            try {REPO = new RepositoryInfo(ID, ID, null, "http://test1"); } catch (URISyntaxException ex) { Exceptions.printStackTrace(ex); }
        }
        public TestIndexer2() {
            this.repos = new RepositoryInfo[] {REPO};
        }
        
        protected String getID() {
            return ID;
        }
    }
    
    protected RepositoryInfo[] repos;
    public AbstractTestQueryProvider() {
    }

    @Override
    public boolean handlesRepository(RepositoryInfo repo) {
        for (RepositoryInfo r : repos) {
            if(repo.getId().equals(r.getId())) {
                return true;
            }
        }    
        return false;
    }

    abstract protected String getID();

    @Override
    public ArchetypeQueries getArchetypeQueries() {
        return new ArchetypeQueries() {
            @Override
            public ResultImplementation<NBVersionInfo> findArchetypes(List<RepositoryInfo> repos) {
                return new ResultImplementation<NBVersionInfo>() {
                    @Override
                    public boolean isPartial() {
                        return false;
                    }

                    @Override
                    public void waitForSkipped() { }

                    @Override
                    public List<NBVersionInfo> getResults() {
                        return Arrays.asList(new NBVersionInfo(getID(), getID(), getID(), "1.0", "jar", "jar", "test", "test", null));
                    }

                    @Override
                    public int getTotalResultCount() {
                        return 1;
                    }

                    @Override
                    public int getReturnedResultCount() {
                        return 1;
                    }
                };
            }
        };
    }
    
    @Override
    public BaseQueries getBaseQueries() {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }

    @Override
    public ChecksumQueries getChecksumQueries() {
        return null;
    }

    @Override
    public ClassUsageQuery getClassUsageQuery() {
        return null;
    }

    @Override
    public ClassesQuery getClassesQuery() {
        return null;
    }

    @Override
    public ContextLoadedQuery getContextLoadedQuery() {
        return null;
    }

    @Override
    public DependencyInfoQueries getDependencyInfoQueries() {
        return null;
    }

    @Override
    public GenericFindQuery getGenericFindQuery() {
        return null;
    }

}




/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2010 Oracle and/or its affiliates. All rights reserved.
 *
 * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
 * Other names may be trademarks of their respective owners.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common
 * Development and Distribution License("CDDL") (collectively, the
 * "License"). You may not use this file except in compliance with the
 * License. You can obtain a copy of the License at
 * http://www.netbeans.org/cddl-gplv2.html
 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
 * specific language governing permissions and limitations under the
 * License.  When distributing the software, include this License Header
 * Notice in each file and include the License file at
 * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the GPL Version 2 section of the License file that
 * accompanied this code. If applicable, add the following below the
 * License Header, with the fields enclosed by brackets [] replaced by
 * your own identifying information:
 * "Portions Copyrighted [year] [name of copyright owner]"
 *
 * If you wish your version of this file to be governed by only the CDDL
 * or only the GPL Version 2, indicate your decision by adding
 * "[Contributor] elects to include this software in this distribution
 * under the [CDDL or GPL Version 2] license." If you do not indicate a
 * single choice of license, a recipient has the option to distribute
 * your version of this file under either the CDDL, the GPL Version 2 or
 * to extend the choice of license to its licensees as provided above.
 * However, if you add GPL Version 2 code and therefore, elected the GPL
 * Version 2 license, then the option applies only if the new code is
 * made subject to such option by the copyright holder.
 *
 * Contributor(s):
 *
 * Portions Copyrighted 2010 Sun Microsystems, Inc.
 */

package org.netbeans.modules.maven.indexer.api;

import java.io.File;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import org.netbeans.junit.MockServices;
import org.netbeans.junit.NbTestCase;
import org.netbeans.modules.maven.indexer.api.AbstractTestQueryProvider.TestIndexer1;
import org.netbeans.modules.maven.indexer.api.AbstractTestQueryProvider.TestIndexer2;
import org.netbeans.modules.maven.indexer.spi.ArchetypeQueries;
import org.openide.util.Exceptions;

public class RepositoryQueriesTest extends NbTestCase {

    public RepositoryQueriesTest(String name) {
        super(name);
    }
    
    @Override 
    protected void setUp() throws Exception {
        super.setUp();
    }
    
    public void testAlternativeQueryProvider() throws URISyntaxException {
        
    }
    
    public void testAlternativeResult() throws URISyntaxException {
        MockServices.setServices(TestIndexer1.class);
        
        RepositoryQueries.Result<NBVersionInfo> result = RepositoryQueries.findArchetypesResult(Arrays.asList(TestIndexer1.REPO));
        assertEquals(TestIndexer1.ID, result.getResults().get(0).getArtifactId());
        assertEquals(1, result.getTotalResultCount());
        assertEquals(1, result.getReturnedResultCount());
    }
    
    public void testTwoReposTwoQueryProviders() throws URISyntaxException {
        MockServices.setServices(TestIndexer1.class, TestIndexer2.class);

        RepositoryQueries.Result<NBVersionInfo> result = RepositoryQueries.findArchetypesResult(Arrays.asList(TestIndexer1.REPO, TestIndexer2.REPO));
        assertEquals(2, result.getTotalResultCount());
        assertEquals(2, result.getReturnedResultCount());
        assertArtefactIds(result.getResults(), new String[] {TestIndexer1.ID, TestIndexer2.ID});
    }
    
    public void testTwoReposOneAccepted() throws URISyntaxException {
        MockServices.setServices(TestIndexer1.class);
        
        RepositoryQueries.Result<NBVersionInfo> result = RepositoryQueries.findArchetypesResult(Arrays.asList(TestIndexer1.REPO, TestIndexer2.REPO));
        assertEquals(1, result.getTotalResultCount());
        assertEquals(1, result.getReturnedResultCount());
        assertArtefactIds(result.getResults(), new String[] {TestIndexer1.ID});
    }
    
    public void testNullResult() throws URISyntaxException {
        MockServices.setServices(NullQueryProvider.class);
        List<RepositoryInfo> repos = Arrays.asList(NullQueryProvider.REPO);
        assertEquals(0, RepositoryQueries.findArchetypesResult(repos).getTotalResultCount());
        assertEquals(0, RepositoryQueries.findBySHA1Result(new File(""), Arrays.asList(NullQueryProvider.REPO)).getTotalResultCount());
        assertEquals(0, RepositoryQueries.findClassUsagesResult("", repos).getTotalResultCount());
        assertEquals(0, RepositoryQueries.findDependencyUsageResult("","","", repos).getTotalResultCount());
        assertEquals(0, RepositoryQueries.findResult(Collections.EMPTY_LIST, repos).getTotalResultCount());
        assertEquals(0, RepositoryQueries.findVersionsByClassResult("", repos).getTotalResultCount());
        assertEquals(0, RepositoryQueries.getLoadedContexts().size());
    }

    private void assertArtefactIds(List<NBVersionInfo> infos, String[] ids) {
        assertEquals(ids.length, infos.size());
        List<String> returnedIds = new ArrayList<>(infos.size());
        infos.stream().forEach((info) -> returnedIds.add(info.getArtifactId()));
        for (String id : ids) {
            assertTrue(returnedIds.contains(id));
        }
    }

    public static class NullQueryProvider extends AbstractTestQueryProvider {
        static final String ID = "nullrepo";
        static RepositoryInfo REPO;
        static {
            try {
                REPO = new RepositoryInfo(ID, ID, null, "http://test1");
            } catch (URISyntaxException ex) {
                Exceptions.printStackTrace(ex);
            }
        }

        public NullQueryProvider() {
            this.repos = new RepositoryInfo[] {REPO};
        }
        protected String getID() {
            return ID;
        }
        @Override
        public ArchetypeQueries getArchetypeQueries() {
            return null;
        }        
    }

}

Return to bug 257567

Lines 168-173 Link Here

(-)maven.indexer/nbproject/project.xml (-2 / +2 lines)
168	<friend>org.netbeans.modules.maven.refactoring</friend>	168	<friend>org.netbeans.modules.maven.refactoring</friend>
169	<friend>org.netbeans.modules.maven.repository</friend>	169	<friend>org.netbeans.modules.maven.repository</friend>
170	<friend>org.netbeans.modules.maven.search</friend>	170	<friend>org.netbeans.modules.maven.search</friend>
		171	<friend>ro.emilianbold.modules.maven.search.remote</friend>
171	<package>org.apache.lucene</package>	172	<package>org.apache.lucene</package>
172	<package>org.apache.lucene.analysis</package>	173	<package>org.apache.lucene.analysis</package>
173	<package>org.apache.lucene.analysis.standard</package>	174	<package>org.apache.lucene.analysis.standard</package>
Lines 185-192 Link Here
185	<package>org.apache.lucene.util</package>	186	<package>org.apache.lucene.util</package>
186	<package>org.apache.lucene.util.cache</package>	187	<package>org.apache.lucene.util.cache</package>
187	<package>org.netbeans.modules.maven.indexer.api</package>	188	<package>org.netbeans.modules.maven.indexer.api</package>
188	<package>org.netbeans.modules.maven.indexer.api.ui</package>	189	<package>org.netbeans.modules.maven.indexer.spi</package>
189	<package>org.netbeans.modules.maven.indexer.spi.ui</package>
190	<package>org.netbeans.modules.maven.indexer.spi.impl</package>	190	<package>org.netbeans.modules.maven.indexer.spi.impl</package>
191	</friend-packages>	191	</friend-packages>
192	<class-path-extension>	192	<class-path-extension>

Line 0 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/ResultImpl.java (+152 lines)
		1	/*
		2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
		3	*
		4	* Copyright 2016 Oracle and/or its affiliates. All rights reserved.
		5	*
		6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
		7	* Other names may be trademarks of their respective owners.
		8	*
		9	* The contents of this file are subject to the terms of either the GNU
		10	* General Public License Version 2 only ("GPL") or the Common
		11	* Development and Distribution License("CDDL") (collectively, the
		12	* "License"). You may not use this file except in compliance with the
		13	* License. You can obtain a copy of the License at
		14	* http://www.netbeans.org/cddl-gplv2.html
		15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
		16	* specific language governing permissions and limitations under the
		17	* License. When distributing the software, include this License Header
		18	* Notice in each file and include the License file at
		19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
		20	* particular file as subject to the "Classpath" exception as provided
		21	* by Oracle in the GPL Version 2 section of the License file that
		22	* accompanied this code. If applicable, add the following below the
		23	* License Header, with the fields enclosed by brackets [] replaced by
		24	* your own identifying information:
		25	* "Portions Copyrighted [year] [name of copyright owner]"
		26	*
		27	* If you wish your version of this file to be governed by only the CDDL
		28	* or only the GPL Version 2, indicate your decision by adding
		29	* "[Contributor] elects to include this software in this distribution
		30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
		31	* single choice of license, a recipient has the option to distribute
		32	* your version of this file under either the CDDL, the GPL Version 2 or
		33	* to extend the choice of license to its licensees as provided above.
		34	* However, if you add GPL Version 2 code and therefore, elected the GPL
		35	* Version 2 license, then the option applies only if the new code is
		36	* made subject to such option by the copyright holder.
		37	*
		38	* Contributor(s):
		39	*
		40	* Portions Copyrighted 2016 Sun Microsystems, Inc.
		41	*/
		42	package org.netbeans.modules.maven.indexer;
		43
		44	import java.util.ArrayList;
		45	import java.util.Collection;
		46	import java.util.Collections;
		47	import java.util.List;
		48	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;
		49	import org.netbeans.modules.maven.indexer.spi.ResultImplementation;
		50	import org.netbeans.modules.maven.indexer.spi.impl.Redo;
		51	import org.netbeans.modules.project.spi.intern.ProjectIDEServices;
		52
		53	/**
		54	*
		55	* @author Tomas Stupka
		56	*/
		57	public class ResultImpl<T> implements ResultImplementation {
		58	private final List<RepositoryInfo> skipped = new ArrayList<>();
		59	private final List<T> results = new ArrayList<>();
		60	private final Redo<T> redoAction;
		61
		62	private int totalResults = 0;
		63	private int returnedResults = 0;
		64
65	/**
66	* used internally by the repository indexing/searching engine(s)
67	*/
68	public ResultImpl(Redo<T> redo) {
69	redoAction = redo;
70	}
71
72	/**
73	* returns true is one or more indexes were skipped, eg because the indexing was taking place.
74	* @return
75	*/
76	@Override
77	public synchronized boolean isPartial() {
78	return !skipped.isEmpty();
79	}
80
81	/**
82	* used internally by the repository indexing/searching engine(s) to mark the result as partially skipped
83	*/
84	synchronized void addSkipped(RepositoryInfo info) {
85	skipped.add(info);
86	}
87
88	/**
89	* waits for currently unaccessible indexes to finish, not to be called in AWT thread.
90	*/
91	@Override
92	public void waitForSkipped() {
93	assert !ProjectIDEServices.isEventDispatchThread();
94	redoAction.run(this);
95	synchronized (this) {
96	skipped.clear();
97	}
98	}
99
100	synchronized void setResults(Collection<T> newResults) {
101	results.clear();
102	results.addAll(newResults);
103	}
104
105	@Override
106	public synchronized List<T> getResults() {
107	return Collections.unmodifiableList(results);
108	}
109
110
111	/**
112	* used internally by the repository indexing/searching engine(s) to mark the result as partially skipped
113	*/
114	synchronized void addSkipped(Collection<RepositoryInfo> infos) {
115	skipped.addAll(infos);
116	}
117
118	/**
119	* used internally by the repository indexing/searching engine(s) to mark the result as partially skipped
120	*/
121	synchronized List<RepositoryInfo> getSkipped() {
122	return Collections.unmodifiableList(skipped);
123	}
124
125	/**
126	* total number of hits
127	* @return
128	* @since 2.20
129	*/
130	@Override
131	public int getTotalResultCount() {
132	return totalResults;
133	}
134
135	void addTotalResultCount(int moreTotalResults) {
136	totalResults += moreTotalResults;
137	}
138	/**
139	* in some cases not entirely accurate number of processed and returned hits, typically should be less or equals to totalResultCount
140	* @return
141	* @since 2.20
142	*/
143	@Override
144	public int getReturnedResultCount() {
145	return returnedResults;
146	}
147
148	void addReturnedResultCount(int moreReturnedResults) {
149	returnedResults = moreReturnedResults + returnedResults;
150	}
151
152	}

Lines 1-53 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/spi/Redo.java (-53 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 2012 Oracle and/or its affiliates. All rights reserved.
5	*
6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
7	* Other names may be trademarks of their respective owners.
8	*
9	* The contents of this file are subject to the terms of either the GNU
10	* General Public License Version 2 only ("GPL") or the Common
11	* Development and Distribution License("CDDL") (collectively, the
12	* "License"). You may not use this file except in compliance with the
13	* License. You can obtain a copy of the License at
14	* http://www.netbeans.org/cddl-gplv2.html
15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
16	* specific language governing permissions and limitations under the
17	* License. When distributing the software, include this License Header
18	* Notice in each file and include the License file at
19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
20	* particular file as subject to the "Classpath" exception as provided
21	* by Oracle in the GPL Version 2 section of the License file that
22	* accompanied this code. If applicable, add the following below the
23	* License Header, with the fields enclosed by brackets [] replaced by
24	* your own identifying information:
25	* "Portions Copyrighted [year] [name of copyright owner]"
26	*
27	* If you wish your version of this file to be governed by only the CDDL
28	* or only the GPL Version 2, indicate your decision by adding
29	* "[Contributor] elects to include this software in this distribution
30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
31	* single choice of license, a recipient has the option to distribute
32	* your version of this file under either the CDDL, the GPL Version 2 or
33	* to extend the choice of license to its licensees as provided above.
34	* However, if you add GPL Version 2 code and therefore, elected the GPL
35	* Version 2 license, then the option applies only if the new code is
36	* made subject to such option by the copyright holder.
37	*
38	* Contributor(s):
39	*
40	* Portions Copyrighted 2012 Sun Microsystems, Inc.
41	*/
42	package org.netbeans.modules.maven.indexer.spi;
43
44	import org.netbeans.modules.maven.indexer.api.RepositoryQueries;
45
46	/**
47	* used internally by the repository indexing/searching engine(s)
48	* @author mkleint
49	*/
50	public interface Redo<T> {
51	void run(RepositoryQueries.Result<T> result);
52	}
53

Lines 1-67 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/spi/RepositoryIndexerImplementation.java (-67 lines)
1	/*
2	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
3	*
4	* Copyright 2010 Oracle and/or its affiliates. All rights reserved.
5	*
6	* Oracle and Java are registered trademarks of Oracle and/or its affiliates.
7	* Other names may be trademarks of their respective owners.
8	*
9	* The contents of this file are subject to the terms of either the GNU
10	* General Public License Version 2 only ("GPL") or the Common
11	* Development and Distribution License("CDDL") (collectively, the
12	* "License"). You may not use this file except in compliance with the
13	* License. You can obtain a copy of the License at
14	* http://www.netbeans.org/cddl-gplv2.html
15	* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
16	* specific language governing permissions and limitations under the
17	* License. When distributing the software, include this License Header
18	* Notice in each file and include the License file at
19	* nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
20	* particular file as subject to the "Classpath" exception as provided
21	* by Oracle in the GPL Version 2 section of the License file that
22	* accompanied this code. If applicable, add the following below the
23	* License Header, with the fields enclosed by brackets [] replaced by
24	* your own identifying information:
25	* "Portions Copyrighted [year] [name of copyright owner]"
26	*
27	* If you wish your version of this file to be governed by only the CDDL
28	* or only the GPL Version 2, indicate your decision by adding
29	* "[Contributor] elects to include this software in this distribution
30	* under the [CDDL or GPL Version 2] license." If you do not indicate a
31	* single choice of license, a recipient has the option to distribute
32	* your version of this file under either the CDDL, the GPL Version 2 or
33	* to extend the choice of license to its licensees as provided above.
34	* However, if you add GPL Version 2 code and therefore, elected the GPL
35	* Version 2 license, then the option applies only if the new code is
36	* made subject to such option by the copyright holder.
37	*
38	* Contributor(s):
39	*
40	* Portions Copyrighted 2008 Sun Microsystems, Inc.
41	*/
42	package org.netbeans.modules.maven.indexer.spi;
43
44	import java.util.Collection;
45	import org.apache.maven.artifact.Artifact;
46	import org.netbeans.modules.maven.indexer.api.RepositoryInfo;
47
48	/**
49	* Implementation of repository indexer (repository manager). Apart from basic
50	* indexing features also serves as provider of various index queries.
51	* There is one implementation based on apache indexer
52	*
53	* @author Milos Kleint
54	*/
55	public interface RepositoryIndexerImplementation {
56
57	/**
58	* Index local repository or retrieve remote prepopulated index for local use.
59	* @param repo
60	*/
61	void indexRepo(RepositoryInfo repo);
62
63	void updateIndexWithArtifacts(RepositoryInfo repo, Collection<Artifact> artifacts);
64
65	void deleteArtifactFromIndex(RepositoryInfo repo, Artifact artifact);
66
67	}