source.dussan.org Git - archiva.git/blob

   1 package org.apache.archiva.web.xmlrpc.services;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import java.util.ArrayList;
  23 import java.util.Collection;
  24 import java.util.Date;
  25 import java.util.List;
  26
  27 import org.apache.archiva.indexer.search.RepositorySearch;
  28 import org.apache.archiva.indexer.search.SearchResultHit;
  29 import org.apache.archiva.indexer.search.SearchResultLimits;
  30 import org.apache.archiva.indexer.search.SearchResults;
  31 import org.apache.archiva.metadata.model.ProjectVersionMetadata;
  32 import org.apache.archiva.metadata.model.ProjectVersionReference;
  33 import org.apache.archiva.metadata.repository.MetadataResolver;
  34 import org.apache.archiva.metadata.repository.storage.maven2.MavenProjectFacet;
  35 import org.apache.archiva.web.xmlrpc.api.SearchService;
  36 import org.apache.archiva.web.xmlrpc.api.beans.Artifact;
  37 import org.apache.archiva.web.xmlrpc.api.beans.Dependency;
  38 import org.apache.archiva.web.xmlrpc.security.XmlRpcUserRepositories;
  39 import org.apache.maven.archiva.common.utils.VersionUtil;
  40 import org.apache.maven.archiva.database.ArchivaDAO;
  41 import org.apache.maven.archiva.database.ArtifactDAO;
  42 import org.apache.maven.archiva.database.constraints.ArtifactsByChecksumConstraint;
  43 import org.apache.maven.archiva.database.constraints.UniqueVersionConstraint;
  44 import org.apache.maven.archiva.model.ArchivaArtifact;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47
  48 /**
  49  * SearchServiceImpl
  50  *
  51  * quick/general text search which returns a list of artifacts
  52  * query for an artifact based on a checksum
  53  * query for all available versions of an artifact, sorted in version significance order
  54  * query for all available versions of an artifact since a given date
  55  * query for an artifact's direct dependencies
  56  * query for an artifact's dependency tree (as with mvn dependency:tree - no duplicates should be included)
  57  * query for all artifacts that depend on a given artifact
  58  *
  59  * @version $Id: SearchServiceImpl.java
  60  */
  61 public class SearchServiceImpl
  62     implements SearchService
  63 {
  64     private Logger log = LoggerFactory.getLogger( SearchServiceImpl.class );
  65
  66     private RepositorySearch search;
  67
  68     private XmlRpcUserRepositories xmlRpcUserRepositories;
  69
  70     private ArchivaDAO archivaDAO;
  71
  72     private MetadataResolver metadataResolver;
  73
  74     public SearchServiceImpl( XmlRpcUserRepositories xmlRpcUserRepositories, ArchivaDAO archivaDAO,
  75                               MetadataResolver metadataResolver, RepositorySearch search )
  76     {
  77         this.xmlRpcUserRepositories = xmlRpcUserRepositories;
  78         this.archivaDAO = archivaDAO;
  79         this.search = search;
  80         this.metadataResolver = metadataResolver;
  81     }
  82
  83     @SuppressWarnings("unchecked")
  84     public List<Artifact> quickSearch( String queryString )
  85         throws Exception
  86     {
  87         List<Artifact> artifacts = new ArrayList<Artifact>();
  88         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
  89         SearchResultLimits limits = new SearchResultLimits( SearchResultLimits.ALL_PAGES );
  90         SearchResults results = null;
  91
  92         results = search.search( "", observableRepos, queryString, limits, null );
  93
  94         for ( SearchResultHit resultHit : results.getHits() )
  95         {
  96             // double-check all versions as done in SearchAction
  97             final List<String> versions = (List<String>) archivaDAO.query(
  98                 new UniqueVersionConstraint( observableRepos, resultHit.getGroupId(), resultHit.getArtifactId() ) );
  99             if ( versions != null && !versions.isEmpty() )
 100             {
 101                 resultHit.setVersion( null );
 102                 resultHit.setVersions( filterTimestampedSnapshots( versions ) );
 103             }
 104
 105             List<String> resultHitVersions = resultHit.getVersions();
 106             if ( resultHitVersions != null )
 107             {
 108                 for ( String version : resultHitVersions )
 109                 {
 110                     Artifact artifact = null;
 111                     for ( String repoId : observableRepos )
 112                     {
 113                         // slight behaviour change to previous implementation: instead of allocating "jar" when not
 114                         // found in the database, we can rely on the metadata repository to create it on the fly. We
 115                         // just allocate the default packaging if the Maven facet is not found.
 116                         ProjectVersionMetadata model =
 117                             metadataResolver.getProjectVersion( repoId, resultHit.getGroupId(),
 118                                                                 resultHit.getArtifactId(), version );
 119
 120                         if ( model != null )
 121                         {
 122                             String packaging = "jar";
 123
 124                             MavenProjectFacet facet = (MavenProjectFacet) model.getFacet( MavenProjectFacet.FACET_ID );
 125                             if ( facet != null && facet.getPackaging() != null )
 126                             {
 127                                 packaging = facet.getPackaging();
 128                             }
 129                             artifact = new Artifact( repoId, resultHit.getGroupId(), resultHit.getArtifactId(), version,
 130                                                      packaging );
 131                             break;
 132                         }
 133                     }
 134
 135                     if ( artifact != null )
 136                     {
 137                         artifacts.add( artifact );
 138                     }
 139                 }
 140             }
 141         }
 142
 143         return artifacts;
 144     }
 145
 146     /**
 147      * Remove timestamped snapshots from versions
 148      */
 149     private static List<String> filterTimestampedSnapshots( List<String> versions )
 150     {
 151         final List<String> filtered = new ArrayList<String>();
 152         for ( final String version : versions )
 153         {
 154             final String baseVersion = VersionUtil.getBaseVersion( version );
 155             if ( !filtered.contains( baseVersion ) )
 156             {
 157                 filtered.add( baseVersion );
 158             }
 159         }
 160         return filtered;
 161     }
 162
 163     public List<Artifact> getArtifactByChecksum( String checksum )
 164         throws Exception
 165     {
 166         // 1. get ArtifactDAO from ArchivaDAO
 167         // 2. create ArtifactsByChecksumConstraint( "queryTerm" )
 168         // 3. query artifacts using constraint
 169         // 4. convert results to list of Artifact objects
 170
 171         List<Artifact> results = new ArrayList<Artifact>();
 172         ArtifactDAO artifactDAO = archivaDAO.getArtifactDAO();
 173
 174         ArtifactsByChecksumConstraint constraint = new ArtifactsByChecksumConstraint( checksum );
 175         List<ArchivaArtifact> artifacts = artifactDAO.queryArtifacts( constraint );
 176
 177         for ( ArchivaArtifact archivaArtifact : artifacts )
 178         {
 179             Artifact artifact =
 180                 new Artifact( archivaArtifact.getModel().getRepositoryId(), archivaArtifact.getModel().getGroupId(),
 181                               archivaArtifact.getModel().getArtifactId(), archivaArtifact.getModel().getVersion(),
 182                               archivaArtifact.getType() );
 183             //archivaArtifact.getModel().getWhenGathered() );
 184             results.add( artifact );
 185         }
 186
 187         return results;
 188     }
 189
 190     public List<Artifact> getArtifactVersions( String groupId, String artifactId )
 191         throws Exception
 192     {
 193         List<Artifact> artifacts = new ArrayList<Artifact>();
 194         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
 195
 196         for ( String repoId : observableRepos )
 197         {
 198             Collection<String> results = metadataResolver.getProjectVersions( repoId, groupId, artifactId );
 199
 200             for ( final String version : results )
 201             {
 202                 final Artifact artifact = new Artifact( repoId, groupId, artifactId, version, "pom" );
 203
 204                 artifacts.add( artifact );
 205             }
 206         }
 207
 208         return artifacts;
 209     }
 210
 211     public List<Artifact> getArtifactVersionsByDate( String groupId, String artifactId, String version, Date since )
 212         throws Exception
 213     {
 214         List<Artifact> artifacts = new ArrayList<Artifact>();
 215
 216         // 1. get observable repositories
 217         // 2. use RepositoryBrowsing method to query uniqueVersions? (but with date)
 218
 219         return artifacts;
 220     }
 221
 222     public List<Dependency> getDependencies( String groupId, String artifactId, String version )
 223         throws Exception
 224     {
 225         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
 226
 227         for ( String repoId : observableRepos )
 228         {
 229             ProjectVersionMetadata model = metadataResolver.getProjectVersion( repoId, groupId, artifactId, version );
 230             if ( model != null )
 231             {
 232                 List<Dependency> dependencies = new ArrayList<Dependency>();
 233                 List<org.apache.archiva.metadata.model.Dependency> modelDeps = model.getDependencies();
 234                 for ( org.apache.archiva.metadata.model.Dependency dep : modelDeps )
 235                 {
 236                     Dependency dependency =
 237                         new Dependency( dep.getGroupId(), dep.getArtifactId(), dep.getVersion(), dep.getClassifier(),
 238                                         dep.getType(), dep.getScope() );
 239                     dependencies.add( dependency );
 240                 }
 241                 return dependencies;
 242             }
 243         }
 244         throw new Exception( "Artifact does not exist." );
 245     }
 246
 247     public List<Artifact> getDependencyTree( String groupId, String artifactId, String version )
 248         throws Exception
 249     {
 250         List<Artifact> a = new ArrayList<Artifact>();
 251
 252         return a;
 253     }
 254
 255     public List<Artifact> getDependees( String groupId, String artifactId, String version )
 256         throws Exception
 257     {
 258         List<Artifact> artifacts = new ArrayList<Artifact>();
 259         List<String> observableRepos = xmlRpcUserRepositories.getObservableRepositories();
 260
 261         for ( String repoId : observableRepos )
 262         {
 263             Collection<ProjectVersionReference> refs =
 264                 metadataResolver.getProjectReferences( repoId, groupId, artifactId, version );
 265             for ( ProjectVersionReference ref : refs )
 266             {
 267                 artifacts.add(
 268                     new Artifact( repoId, ref.getNamespace(), ref.getProjectId(), ref.getProjectVersion(), "" ) );
 269             }
 270         }
 271
 272         return artifacts;
 273     }
 274 }