Attachment #158854 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.36	4	OpenIDE-Module-Specification-Version: 2.37
5	OpenIDE-Module: org.netbeans.modules.maven.indexer/2	5	OpenIDE-Module: org.netbeans.modules.maven.indexer/2
6		6

Lines 186-191 Link Here

(-)maven.indexer/nbproject/project.xml (+1 lines)
186	<package>org.apache.lucene.util.cache</package>	186	<package>org.apache.lucene.util.cache</package>
187	<package>org.netbeans.modules.maven.indexer.api</package>	187	<package>org.netbeans.modules.maven.indexer.api</package>
188	<package>org.netbeans.modules.maven.indexer.api.ui</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.ui</package>
190	<package>org.netbeans.modules.maven.indexer.spi.impl</package>	191	<package>org.netbeans.modules.maven.indexer.spi.impl</package>
191	</friend-packages>	192	</friend-packages>




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);
    }


    }

    @Override
    public 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);
            }
        };
        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<String> filterArtifactIdForGroupId(final String groupId, final String prefix, List<RepositoryInfo> repos) {
        ResultImpl<String> result = new ResultImpl<>(new Redo<String>() {
            @Override
            public void run(ResultImpl<String> result) {
                filterArtifactIdForGroupId( groupId, prefix, result, result.getSkipped(), false);
            }
        });
        return filterArtifactIdForGroupId( groupId, prefix, result, repos, true);
    }
    private ResultImplementation<String> filterArtifactIdForGroupId(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<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 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
 */
public class ResultImpl<T> implements ResultImplementation {
    private final List<RepositoryInfo> skipped = new ArrayList<RepositoryInfo>();
    private List<T> results = new ArrayList<T>();
    private final Redo<T> redoAction;

    int totalResults = 0;
    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.fireChangeIndex();
    }
    }
    
    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 (-168 / +195 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		196
232	@Override
233	public void addTotalResults(Result<?> result, int moreResults) {
234	result.addTotalResultCount(moreResults);
235	}	197	}
236		198
237	@Override
238	public void addReturnedResults(Result<?> result, int moreResults) {
239	result.addReturnedResultCount(moreResults);
240	}
241	}
242
243
244	/**	199	/**
245	* One usage result.	200	* One usage result.
246	*/	201	*/
Lines 268-278 Link Here
268	}	223	}
269	}	224	}
270		225
		226	private static interface QueryCall<T> {
		227	ResultImplementation<T> call(RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos);
		228	}
271		229
272	private static @NonNull BaseQueries findBaseQueries() {	230	private static <T> Result<T> getQueryResult(List<RepositoryInfo> repos, QueryCall<T> c) {
273	return Lookup.getDefault().lookup(BaseQueries.class);	231	List<ResultImplementation<T>> results = new LinkedList<>();
		232	if (repos == null) {
		233	repos = RepositoryPreferences.getInstance().getRepositoryInfos();
274	}	234	}
		235	Map<RepositoryIndexQueryProvider, List<RepositoryInfo>> qp2Repo = getQueryProvider2Repo(repos);
		236	for(Map.Entry<RepositoryIndexQueryProvider, List<RepositoryInfo>> e : qp2Repo.entrySet()) {
		237	results.add(c.call(e.getKey(), e.getValue()));
		238	}
		239	return new Result<>(new CompositeResult<>(results));
		240	}
275		241
		242	private static Map<RepositoryIndexQueryProvider, List<RepositoryInfo>> getQueryProvider2Repo(List<RepositoryInfo> repos) {
		243	Collection<? extends RepositoryIndexQueryProvider> idxs = Lookup.getDefault().lookupAll(RepositoryIndexQueryProvider.class);
		244	Map<RepositoryIndexQueryProvider, List<RepositoryInfo>> qp2Repo = new HashMap<>();
		245	for (RepositoryInfo repo : repos) {
		246	for (RepositoryIndexQueryProvider idx : idxs) {
		247	if(idx.handlesRepository(repo)) {
		248	List<RepositoryInfo> mappedRepos = qp2Repo.get(idx);
		249	if(mappedRepos == null) {
		250	mappedRepos = new LinkedList<>();
		251	qp2Repo.put(idx, mappedRepos);
		252	}
		253	mappedRepos.add(repo);
		254	break;
		255	}
		256	}
		257	}
		258	return qp2Repo;
		259	}
		260
276	/**	261	/**
277	*	262	*
278	* @param repos	263	* @param repos
Lines 280-286 Link Here
280	* @since 2.9	265	* @since 2.9
281	*/	266	*/
282	public static Result<String> getGroupsResult(@NullAllowed List<RepositoryInfo> repos) {	267	public static Result<String> getGroupsResult(@NullAllowed List<RepositoryInfo> repos) {
283	return findBaseQueries().getGroups(repos);	268	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		269	BaseQueries baseQueries = queryProvider.getBaseQueries();
		270	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		271	return baseQueries.getGroups(providerRepos);
		272	});
284	}	273	}
285		274
286	/**	275	/**
Lines 291-300 Link Here
291	* @since 2.9	280	* @since 2.9
292	*/	281	*/
293	public static Result<String> filterGroupIdsResult(String prefix, @NullAllowed List<RepositoryInfo> repos) {	282	public static Result<String> filterGroupIdsResult(String prefix, @NullAllowed List<RepositoryInfo> repos) {
294	return findBaseQueries().filterGroupIds(prefix, repos);	283	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		284	BaseQueries baseQueries = queryProvider.getBaseQueries();
		285	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		286	return baseQueries.filterGroupIds(prefix, providerRepos);
		287	});
295	}	288	}
296		289
297
298	/**	290	/**
299	*	291	*
300	* @param groupId	292	* @param groupId
Lines 305-311 Link Here
305	* @since 2.9	297	* @since 2.9
306	*/	298	*/
307	public static Result<NBVersionInfo> getRecordsResult(String groupId, String artifactId, String version, @NullAllowed List<RepositoryInfo> repos) {	299	public static Result<NBVersionInfo> getRecordsResult(String groupId, String artifactId, String version, @NullAllowed List<RepositoryInfo> repos) {
308	return findBaseQueries().getRecords(groupId, artifactId, version, repos);	300	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		301	BaseQueries baseQueries = queryProvider.getBaseQueries();
		302	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		303	return baseQueries.getRecords(groupId, artifactId, version, providerRepos);
		304	});
309	}	305	}
310		306
311	/**	307	/**
Lines 316-325 Link Here
316	* @since 2.28	312	* @since 2.28
317	*/	313	*/
318	public static Result<String> getGAVsForPackaging(String packaging, @NullAllowed List<RepositoryInfo> repos) {	314	public static Result<String> getGAVsForPackaging(String packaging, @NullAllowed List<RepositoryInfo> repos) {
319	return findBaseQueries().getGAVsForPackaging(packaging, repos);	315	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		316	BaseQueries baseQueries = queryProvider.getBaseQueries();
		317	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		318	return baseQueries.getGAVsForPackaging(packaging, providerRepos);
		319	});
320	}	320	}
321		321
322
323	/**	322	/**
324	*	323	*
325	* @param groupId	324	* @param groupId
Lines 328-337 Link Here
328	* @since 2.9	327	* @since 2.9
329	*/	328	*/
330	public static Result<String> getArtifactsResult(String groupId, @NullAllowed List<RepositoryInfo> repos) {	329	public static Result<String> getArtifactsResult(String groupId, @NullAllowed List<RepositoryInfo> repos) {
331	return findBaseQueries().getArtifacts(groupId, 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.getArtifacts(groupId, providerRepos);
		334	});
332	}	335	}
333		336
334
335	/**	337	/**
336	*	338	*
337	* @param groupId	339	* @param groupId
Lines 341-354 Link Here
341	* @since 2.9	343	* @since 2.9
342	*/	344	*/
343	public static Result<NBVersionInfo> getVersionsResult(String groupId, String artifactId, @NullAllowed List<RepositoryInfo> repos) {	345	public static Result<NBVersionInfo> getVersionsResult(String groupId, String artifactId, @NullAllowed List<RepositoryInfo> repos) {
344	return findBaseQueries().getVersions(groupId, artifactId, repos);	346	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		347	BaseQueries baseQueries = queryProvider.getBaseQueries();
		348	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		349	return baseQueries.getVersions(groupId, artifactId, providerRepos);
		350	});
345	}	351	}
346		352
347
348	private static @NonNull DependencyInfoQueries findDIQ() {
349	return Lookup.getDefault().lookup(DependencyInfoQueries.class);
350	}
351
352	/**	353	/**
353	*	354	*
354	* @param groupId	355	* @param groupId
Lines 359-368 Link Here
359	* @since 2.9	360	* @since 2.9
360	*/	361	*/
361	public static Result<NBGroupInfo> findDependencyUsageResult(String groupId, String artifactId, String version, @NullAllowed List<RepositoryInfo> repos) {	362	public static Result<NBGroupInfo> findDependencyUsageResult(String groupId, String artifactId, String version, @NullAllowed List<RepositoryInfo> repos) {
362	return findDIQ().findDependencyUsageGroups(groupId, artifactId, version, repos);	363	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		364	DependencyInfoQueries dependencyInfoQueries = queryProvider.getDependencyInfoQueries();
		365	return dependencyInfoQueries != null ?
		366	dependencyInfoQueries.findDependencyUsageGroups(groupId, artifactId, version, providerRepos) :
		367	new NullResultImpl<NBGroupInfo>();
		368	});
363	}	369	}
364		370
365
366	/**	371	/**
367	*	372	*
368	* @param file	373	* @param file
Lines 377-402 Link Here
377	} catch (IOException ex) {	382	} catch (IOException ex) {
378	Logger.getLogger(RepositoryQueries.class.getName()).log(Level.INFO, "Could not determine SHA-1 of " + file, ex);	383	Logger.getLogger(RepositoryQueries.class.getName()).log(Level.INFO, "Could not determine SHA-1 of " + file, ex);
379	}	384	}
380	return NexusRepositoryIndexerImpl.Accessor.ACCESSOR.createVersionResult(new Redo<NBVersionInfo>() {	385	return new Result<>(new NullResultImpl<NBVersionInfo>());
381	@Override
382	public void run(Result<NBVersionInfo> result) {
383	//noop
384	}	386	}
385	});
386		387
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) {	388	private static Result<NBVersionInfo> findBySHA1(String sha1, @NullAllowed List<RepositoryInfo> repos) {
394	return findChecksumQueries().findBySHA1(sha1, repos);	389	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		390	ChecksumQueries checksumQueries = queryProvider.getChecksumQueries();
		391	return checksumQueries != null ?
		392	checksumQueries.findBySHA1(sha1, providerRepos) :
		393	new NullResultImpl<NBVersionInfo>();
		394	});
395	}	395	}
396		396
397	private static @NonNull ClassesQuery findClassesQueries() {
398	return Lookup.getDefault().lookup(ClassesQuery.class);
399	}
400	/**	397	/**
401	*	398	*
402	* @param className	399	* @param className
Lines 411-417 Link Here
411	* @since 2.9	408	* @since 2.9
412	*/	409	*/
413	public static Result<NBVersionInfo> findVersionsByClassResult(final String className, @NullAllowed List<RepositoryInfo> repos) {	410	public static Result<NBVersionInfo> findVersionsByClassResult(final String className, @NullAllowed List<RepositoryInfo> repos) {
414	return findClassesQueries().findVersionsByClass(className, repos);	411	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		412	ClassesQuery classesQuery = queryProvider.getClassesQuery();
		413	return classesQuery != null ?
		414	classesQuery.findVersionsByClass(className, providerRepos) :
		415	new NullResultImpl<NBVersionInfo>();
		416	});
415	}	417	}
416		418
417	/**	419	/**
Lines 440-446 Link Here
440	RepositoryInfo repositoryInfo = it1.next();	442	RepositoryInfo repositoryInfo = it1.next();
441	List<RepositoryInfo> repositoryInfoL = new ArrayList<RepositoryInfo>(1);	443	List<RepositoryInfo> repositoryInfoL = new ArrayList<RepositoryInfo>(1);
442	repositoryInfoL.add(repositoryInfo);	444	repositoryInfoL.add(repositoryInfo);
443	query.addResults(findClassesQueries().findVersionsByClass(query.getClassName(), repositoryInfoL).getResults(), !it1.hasNext());	445	Result<NBVersionInfo> queryResult = getQueryResult(repositoryInfoL, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		446	ClassesQuery classesQuery = queryProvider.getClassesQuery();
		447	return classesQuery != null ?
		448	classesQuery.findVersionsByClass(query.getClassName(), providerRepos) :
		449	new NullResultImpl<NBVersionInfo>();
		450	});
		451	query.addResults(queryResult.getResults(), !it1.hasNext());
444	// still someone waiting for results?	452	// still someone waiting for results?
445	if (query.countObservers() == 0)	453	if (query.countObservers() == 0)
446	return;	454	return;
Lines 449-458 Link Here
449	query.addResults(null, true);	457	query.addResults(null, true);
450	}	458	}
451		459
452	private static @NonNull ClassUsageQuery findClassUsageQuery() {
453	return Lookup.getDefault().lookup(ClassUsageQuery.class);
454	}
455
456	/**	460	/**
457	* Finds all usages of a given class.	461	* Finds all usages of a given class.
458	* The implementation may not provide results within the same artifact, or on classes in the JRE.	462	* 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	466	* @since 2.9
463	*/	467	*/
464	public static Result<ClassUsage> findClassUsagesResult(String className, @NullAllowed List<RepositoryInfo> repos) {	468	public static Result<ClassUsage> findClassUsagesResult(String className, @NullAllowed List<RepositoryInfo> repos) {
465	return findClassUsageQuery().findClassUsages(className, repos);	469	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		470	ClassUsageQuery classUsageQuery = queryProvider.getClassUsageQuery();
		471	return classUsageQuery != null ?
		472	classUsageQuery.findClassUsages(className, repos) :
		473	new NullResultImpl<ClassUsage>();
		474	});
466	}	475	}
467		476
468
469	private static @NonNull ArchetypeQueries findArchetypeQueries() {
470	return Lookup.getDefault().lookup(ArchetypeQueries.class);
471	}
472
473	/**	477	/**
474	*	478	*
475	* @param repos	479	* @param repos
Lines 477-487 Link Here
477	* @since 2.9	481	* @since 2.9
478	*/	482	*/
479	public static Result<NBVersionInfo> findArchetypesResult(@NullAllowed List<RepositoryInfo> repos) {	483	public static Result<NBVersionInfo> findArchetypesResult(@NullAllowed List<RepositoryInfo> repos) {
480	return findArchetypeQueries().findArchetypes(repos);	484	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		485	ArchetypeQueries archetypeQueries = queryProvider.getArchetypeQueries();
		486	return archetypeQueries != null ?
		487	archetypeQueries.findArchetypes(repos) :
		488	new NullResultImpl<NBVersionInfo>();
		489	});
481	}	490	}
482		491
483
484
485	/**	492	/**
486	*	493	*
487	* @param groupId	494	* @param groupId
Lines 491-500 Link Here
491	* @since 2.9	498	* @since 2.9
492	*/	499	*/
493	public static Result<String> filterPluginArtifactIdsResult(String groupId, String prefix, @NullAllowed List<RepositoryInfo> repos) {	500	public static Result<String> filterPluginArtifactIdsResult(String groupId, String prefix, @NullAllowed List<RepositoryInfo> repos) {
494	return findBaseQueries().filterPluginArtifactIds(groupId, prefix, repos);	501	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		502	BaseQueries baseQueries = queryProvider.getBaseQueries();
		503	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		504	return baseQueries.filterPluginArtifactIds(groupId, prefix, providerRepos);
		505	});
495	}	506	}
496		507
497
498	/**	508	/**
499	*	509	*
500	* @param prefix	510	* @param prefix
Lines 503-516 Link Here
503	* @since 2.9	513	* @since 2.9
504	*/	514	*/
505	public static Result<String> filterPluginGroupIdsResult(String prefix, @NullAllowed List<RepositoryInfo> repos) {	515	public static Result<String> filterPluginGroupIdsResult(String prefix, @NullAllowed List<RepositoryInfo> repos) {
506	return findBaseQueries().filterPluginGroupIds(prefix, repos);	516	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		517	BaseQueries baseQueries = queryProvider.getBaseQueries();
		518	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		519	return baseQueries.filterPluginGroupIds(prefix, providerRepos);
		520	});
507	}	521	}
508		522
509
510	private static @NonNull GenericFindQuery findFindQuery() {
511	return Lookup.getDefault().lookup(GenericFindQuery.class);
512	}
513
514	/**	523	/**
515	* @throws BooleanQuery.TooManyClauses This runtime exception can be thrown if given query is too	524	* @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	525	* general and such search can't be executed as it would probably end with
Lines 525-531 Link Here
525	* @since 2.9	534	* @since 2.9
526	*/	535	*/
527	public static Result<NBVersionInfo> findResult(List<QueryField> fields, @NullAllowed List<RepositoryInfo> repos) {	536	public static Result<NBVersionInfo> findResult(List<QueryField> fields, @NullAllowed List<RepositoryInfo> repos) {
528	return findFindQuery().find(fields, repos);	537	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		538	GenericFindQuery genericFindQuery = queryProvider.getGenericFindQuery();
		539	return genericFindQuery != null ?
		540	genericFindQuery.find(fields, providerRepos) :
		541	new NullResultImpl<NBVersionInfo>();
		542	});
529	}	543	}
530		544
531	/**	545	/**
Lines 553-559 Link Here
553	RepositoryInfo repositoryInfo = it1.next();	567	RepositoryInfo repositoryInfo = it1.next();
554	List<RepositoryInfo> repositoryInfoL = new ArrayList<RepositoryInfo>(1);	568	List<RepositoryInfo> repositoryInfoL = new ArrayList<RepositoryInfo>(1);
555	repositoryInfoL.add(repositoryInfo);	569	repositoryInfoL.add(repositoryInfo);
556	query.addResults(findFindQuery().find(query.getQueryFields(), repositoryInfoL).getResults(), !it1.hasNext());	570	Result<NBVersionInfo> qeuryResult = getQueryResult(repositoryInfoL, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		571	GenericFindQuery genericFindQuery = queryProvider.getGenericFindQuery();
		572	return genericFindQuery != null ?
		573	genericFindQuery.find(query.getQueryFields(), providerRepos) :
		574	new NullResultImpl<NBVersionInfo>();
		575	});
		576	query.addResults(qeuryResult.getResults(), !it1.hasNext());
557	// still someone waiting for results?	577	// still someone waiting for results?
558	if (query.countObservers() == 0)	578	if (query.countObservers() == 0)
559	return;	579	return;
Lines 564-578 Link Here
564		584
565	public static @NonNull List<RepositoryInfo> getLoadedContexts() {	585	public static @NonNull List<RepositoryInfo> getLoadedContexts() {
566	List<RepositoryInfo> toRet = new ArrayList<RepositoryInfo>();	586	List<RepositoryInfo> toRet = new ArrayList<RepositoryInfo>();
567	ContextLoadedQuery clq = Lookup.getDefault().lookup(ContextLoadedQuery.class);	587	List<RepositoryInfo> repos = RepositoryPreferences.getInstance().getRepositoryInfos();
		588	Map<RepositoryIndexQueryProvider, List<RepositoryInfo>> i2r = getQueryProvider2Repo(repos);
		589	for(Entry<RepositoryIndexQueryProvider, List<RepositoryInfo>> e : i2r.entrySet()) {
		590	ContextLoadedQuery clq = e.getKey().getContextLoadedQuery();
568	assert clq != null;	591	assert clq != null;
569	toRet.addAll(clq.getLoaded(RepositoryPreferences.getInstance().getRepositoryInfos()));	592	toRet.addAll(clq.getLoaded(repos));
		593	}
570	return toRet;	594	return toRet;
571	}	595	}
572		596
573
574	public static Result<String> filterArtifactIdForGroupIdResult(String groupId, String prefix, @NullAllowed List<RepositoryInfo> repos) {	597	public static Result<String> filterArtifactIdForGroupIdResult(String groupId, String prefix, @NullAllowed List<RepositoryInfo> repos) {
575	return findBaseQueries().filterArtifactIdForGroupId(groupId, prefix, repos);	598	return getQueryResult(repos, (RepositoryIndexQueryProvider queryProvider, List<RepositoryInfo> providerRepos) -> {
		599	BaseQueries baseQueries = queryProvider.getBaseQueries();
		600	assert baseQueries != null: "RepositoryIndexQueryProvider.getBaseQueries not allowed to return null";
		601	return baseQueries.filterArtifactIdForGroupId(groupId, prefix, providerRepos);
		602	});
576	}	603	}
577		604
578	}	605	}

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	}




 */
public interface BaseQueries {

    ResultImplementation<String> getGroups(List<RepositoryInfo> repos);

    ResultImplementation<String> filterGroupIds(String prefix, List<RepositoryInfo> repos);

    ResultImplementation<NBVersionInfo> getRecords(String groupId, String artifactId, String version, List<RepositoryInfo> repos);

    ResultImplementation<String> getArtifacts(String groupId, List<RepositoryInfo> repos);

    ResultImplementation<NBVersionInfo> getVersions(String groupId, String artifactId, List<RepositoryInfo> repos);

    ResultImplementation<String> filterPluginArtifactIds(String groupId, String prefix, List<RepositoryInfo> repos);

    ResultImplementation<String> filterPluginGroupIds(String prefix, List<RepositoryInfo> repos);

    ResultImplementation<String> filterArtifactIdForGroupId(String groupId, String prefix, List<RepositoryInfo> repos);

    ResultImplementation<String> getGAVsForPackaging(String packaging, List<RepositoryInfo> repos);

}

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.37
 */
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.37
     */
    boolean handlesRepository(RepositoryInfo repo);
    
    /**
     * Returns a {@link ArchetypeQueries} implementation.
     * 
     * @return ArchetypeQueries or <code>null</code> if not provided
     * @since 2.37
     */
    @CheckForNull 
    ArchetypeQueries getArchetypeQueries();
    
    /**
     * Returns a {@link BaseQueries} implementation.
     * 
     * @return BaseQueries
     * @since 2.37
     */
    @NonNull BaseQueries getBaseQueries();
    
    /**
     * Returns a {@link ChecksumQueries} implementation.
     * 
     * @return ChecksumQueries or <code>null</code> if not provided
     * @since 2.37
     */
    @CheckForNull ChecksumQueries getChecksumQueries();
    
    /**
     * Returns a {@link ClassUsageQuery} implementation.
     * 
     * @return ClassUsageQuery or <code>null</code> if not provided
     * @since 2.37
     */
    @CheckForNull ClassUsageQuery getClassUsageQuery();
    
    /**
     * Returns a {@link ClassesQuery} implementation.
     * 
     * @return ClassesQuery or <code>null</code> if not provided
     * @since 2.37
     */
    @CheckForNull ClassesQuery getClassesQuery();
    
    /**
     * Returns a {@link ContextLoadedQuery} implementation.
     * 
     * @return ContextLoadedQuery or <code>null</code> if not provided
     * @since 2.37
     */
    @CheckForNull ContextLoadedQuery getContextLoadedQuery();
    
    /**
     * Returns a {@link DependencyInfoQueries} implementation.
     * 
     * @return DependencyInfoQueries or <code>null</code> if not provided
     * @since 2.37
     */
    @CheckForNull DependencyInfoQueries getDependencyInfoQueries();
    
    /**
     * Returns a {@link GenericFindQuery} implementation.
     * 
     * @return GenericFindQuery or <code>null</code> if not provided
     * @since 2.37
     */
    @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.37
 * @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 
     */
    public boolean isPartial();
    
    /**
     * Waits for currently unaccessible indexes to finish, not to be called in AWT thread.
     */
    public void waitForSkipped();
    
    /**
     * Returns the results.
     * @return 
     */
    public List<T> getResults();
    
    /**
     * Total number of hits.
     * @return     
     */
    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 
     */
    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 (+15 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;
		51	import org.netbeans.modules.maven.indexer.api.AbstractTestQueryProvider.TestIndexer1;
49	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;	52	import org.netbeans.modules.maven.indexer.api.NBVersionInfo;
50	import org.netbeans.modules.maven.indexer.api.QueryField;	53	import org.netbeans.modules.maven.indexer.api.QueryField;
		54	import org.netbeans.modules.maven.indexer.api.RepositoryQueries;
51	import org.openide.util.test.TestFileUtils;	55	import org.openide.util.test.TestFileUtils;
52		56
53	public class NexusRepositoryIndexerImplTest extends NexusTestBase {	57	public class NexusRepositoryIndexerImplTest extends NexusTestBase {
Lines 62-67 Link Here
62	assertEquals("[test]", nrii.filterGroupIds("", Collections.singletonList(info)).getResults().toString());	66	assertEquals("[test]", nrii.filterGroupIds("", Collections.singletonList(info)).getResults().toString());
63	}	67	}
64		68
		69	public void testFilterGroupIdsViaRepositoryQueries() throws Exception {
		70	// jusr add some alternative QueryProvider not handlig our request
		71	MockServices.setServices(TestIndexer1.class);
		72
		73	install(File.createTempFile("whatever", ".txt", getWorkDir()), "test", "spin", "1.1", "txt");
		74	nrii.indexRepo(info);
		75	// RepositoryQueries should handle the query via our NexusRepositoryIndexerImpl
		76	RepositoryQueries.Result<String> res = RepositoryQueries.filterGroupIdsResult("", Collections.singletonList(info));
		77	assertEquals("[test]", res.getResults().toString());
		78	}
		79
65	public void testFind() throws Exception {	80	public void testFind() throws Exception {
66	installPOM("test", "plugin", "0", "maven-plugin");	81	installPOM("test", "plugin", "0", "maven-plugin");
67	install(TestFileUtils.writeZipFile(new File(getWorkDir(), "plugin.jar"), "META-INF/maven/plugin.xml:<plugin><goalPrefix>stuff</goalPrefix></plugin>"), "test", "plugin", "0", "maven-plugin");	82	install(TestFileUtils.writeZipFile(new File(getWorkDir(), "plugin.jar"), "META-INF/maven/plugin.xml:<plugin><goalPrefix>stuff</goalPrefix></plugin>"), "test", "plugin", "0", "maven-plugin");

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

Line 0 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/ResultImpl.java (+151 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
		56	*/
		57	public class ResultImpl<T> implements ResultImplementation {
		58	private final List<RepositoryInfo> skipped = new ArrayList<RepositoryInfo>();
		59	private List<T> results = new ArrayList<T>();
		60	private final Redo<T> redoAction;
		61
		62	int totalResults = 0;
		63	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	* total number of hits
126	* @return
127	* @since 2.20
128	*/
129	@Override
130	public int getTotalResultCount() {
131	return totalResults;
132	}
133
134	void addTotalResultCount(int moreTotalResults) {
135	totalResults += moreTotalResults;
136	}
137	/**
138	* in some cases not entirely accurate number of processed and returned hits, typically should be less or equals to totalResultCount
139	* @return
140	* @since 2.20
141	*/
142	@Override
143	public int getReturnedResultCount() {
144	return returnedResults;
145	}
146
147	void addReturnedResultCount(int moreReturnedResults) {
148	returnedResults = moreReturnedResults + returnedResults;
149	}
150
151	}

Lines 52-73 Link Here

(-)maven.indexer/src/org/netbeans/modules/maven/indexer/spi/BaseQueries.java (-9 / +9 lines)
52	*/	52	*/
53	public interface BaseQueries {	53	public interface BaseQueries {
54		54
55	RepositoryQueries.Result<String> getGroups(List<RepositoryInfo> repos);	55	ResultImplementation<String> getGroups(List<RepositoryInfo> repos);
56		56
57	RepositoryQueries.Result<String> filterGroupIds(String prefix, List<RepositoryInfo> repos);	57	ResultImplementation<String> filterGroupIds(String prefix, List<RepositoryInfo> repos);
58		58
59	RepositoryQueries.Result<NBVersionInfo> getRecords(String groupId, String artifactId, String version, List<RepositoryInfo> repos);	59	ResultImplementation<NBVersionInfo> getRecords(String groupId, String artifactId, String version, List<RepositoryInfo> repos);
60		60
61	RepositoryQueries.Result<String> getArtifacts(String groupId, List<RepositoryInfo> repos);	61	ResultImplementation<String> getArtifacts(String groupId, List<RepositoryInfo> repos);
62		62
63	RepositoryQueries.Result<NBVersionInfo> getVersions(String groupId, String artifactId, List<RepositoryInfo> repos);	63	ResultImplementation<NBVersionInfo> getVersions(String groupId, String artifactId, List<RepositoryInfo> repos);
64		64
65	RepositoryQueries.Result<String> filterPluginArtifactIds(String groupId, String prefix, List<RepositoryInfo> repos);	65	ResultImplementation<String> filterPluginArtifactIds(String groupId, String prefix, List<RepositoryInfo> repos);
66		66
67	RepositoryQueries.Result<String> filterPluginGroupIds(String prefix, List<RepositoryInfo> repos);	67	ResultImplementation<String> filterPluginGroupIds(String prefix, List<RepositoryInfo> repos);
68		68
69	RepositoryQueries.Result<String> filterArtifactIdForGroupId(String groupId, String prefix, List<RepositoryInfo> repos);	69	ResultImplementation<String> filterArtifactIdForGroupId(String groupId, String prefix, List<RepositoryInfo> repos);
70		70
71	RepositoryQueries.Result<String> getGAVsForPackaging(String packaging, List<RepositoryInfo> repos);	71	ResultImplementation<String> getGAVsForPackaging(String packaging, List<RepositoryInfo> repos);
72		72
73	}	73	}

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	}