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

   1 package org.apache.archiva.rest.services;
   2 /*
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  *   http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing,
  14  * software distributed under the License is distributed on an
  15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  16  * KIND, either express or implied.  See the License for the
  17  * specific language governing permissions and limitations
  18  * under the License.
  19  */
  20
  21 import net.sf.beanlib.provider.replicator.BeanReplicator;
  22 import org.apache.archiva.indexer.search.RepositorySearch;
  23 import org.apache.archiva.indexer.search.RepositorySearchException;
  24 import org.apache.archiva.indexer.search.SearchFields;
  25 import org.apache.archiva.indexer.search.SearchResultHit;
  26 import org.apache.archiva.indexer.search.SearchResultLimits;
  27 import org.apache.archiva.indexer.search.SearchResults;
  28 import org.apache.archiva.rest.api.model.Artifact;
  29 import org.apache.archiva.rest.api.model.Dependency;
  30 import org.apache.archiva.rest.api.model.GroupIdList;
  31 import org.apache.archiva.rest.api.model.SearchRequest;
  32 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  33 import org.apache.archiva.rest.api.services.SearchService;
  34 import org.apache.archiva.rest.services.interceptors.HttpContext;
  35 import org.apache.archiva.rest.services.interceptors.HttpContextThreadLocal;
  36 import org.apache.archiva.security.AccessDeniedException;
  37 import org.apache.archiva.security.ArchivaSecurityException;
  38 import org.apache.archiva.security.PrincipalNotFoundException;
  39 import org.apache.archiva.security.UserRepositories;
  40 import org.apache.commons.collections.ListUtils;
  41 import org.apache.commons.lang.StringUtils;
  42 import org.codehaus.plexus.redback.users.UserManager;
  43 import org.codehaus.redback.rest.services.RedbackAuthenticationThreadLocal;
  44 import org.codehaus.redback.rest.services.RedbackRequestInformation;
  45 import org.slf4j.Logger;
  46 import org.slf4j.LoggerFactory;
  47 import org.springframework.stereotype.Service;
  48
  49 import javax.inject.Inject;
  50 import javax.servlet.http.HttpServletRequest;
  51 import javax.ws.rs.core.Context;
  52 import java.util.ArrayList;
  53 import java.util.Collections;
  54 import java.util.List;
  55
  56 /**
  57  * @author Olivier Lamy
  58  */
  59 @Service( "searchService#rest" )
  60 public class DefaultSearchService
  61     implements SearchService
  62 {
  63
  64     private Logger log = LoggerFactory.getLogger( getClass() );
  65
  66     @Inject
  67     private RepositorySearch repositorySearch;
  68
  69     @Inject
  70     private UserRepositories userRepositories;
  71
  72     @Context
  73     private HttpServletRequest httpServletRequest;
  74
  75     public List<Artifact> quickSearch( String queryString )
  76         throws ArchivaRestServiceException
  77     {
  78         if ( StringUtils.isBlank( queryString ) )
  79         {
  80             return Collections.emptyList();
  81         }
  82
  83         SearchResultLimits limits = new SearchResultLimits( 0 );
  84         List<String> observableRepoIds = getObservableRepos();
  85         try
  86         {
  87             SearchResults searchResults =
  88                 repositorySearch.search( getPrincipal(), getObservableRepos(), queryString, limits,
  89                                          Collections.<String>emptyList() );
  90             return getArtifacts( searchResults );
  91
  92         }
  93         catch ( RepositorySearchException e )
  94         {
  95             log.error( e.getMessage(), e );
  96             throw new ArchivaRestServiceException( e.getMessage() );
  97         }
  98     }
  99
 100     public List<Artifact> getArtifactVersions( String groupId, String artifactId, String packaging )
 101         throws ArchivaRestServiceException
 102     {
 103         if ( StringUtils.isBlank( groupId ) || StringUtils.isBlank( artifactId ) )
 104         {
 105             return Collections.emptyList();
 106         }
 107         SearchFields searchField = new SearchFields();
 108         searchField.setGroupId( groupId );
 109         searchField.setArtifactId( artifactId );
 110         searchField.setPackaging( StringUtils.isBlank( packaging ) ? "jar" : packaging );
 111         searchField.setRepositories( getObservableRepos() );
 112
 113         try
 114         {
 115             SearchResults searchResults = repositorySearch.search( getPrincipal(), searchField, null );
 116             return getArtifacts( searchResults );
 117         }
 118         catch ( RepositorySearchException e )
 119         {
 120             log.error( e.getMessage(), e );
 121             throw new ArchivaRestServiceException( e.getMessage() );
 122         }
 123     }
 124
 125     public List<Artifact> searchArtifacts( SearchRequest searchRequest )
 126         throws ArchivaRestServiceException
 127     {
 128         if ( searchRequest == null )
 129         {
 130             return Collections.emptyList();
 131         }
 132         SearchFields searchField = new BeanReplicator().replicateBean( searchRequest, SearchFields.class );
 133         SearchResultLimits limits = new SearchResultLimits( 0 );
 134
 135         // if no repos set we use ones available for the user
 136         if ( searchField.getRepositories() == null || searchField.getRepositories().isEmpty() )
 137         {
 138             searchField.setRepositories( getObservableRepos() );
 139         }
 140
 141         try
 142         {
 143             SearchResults searchResults = repositorySearch.search( getPrincipal(), searchField, limits );
 144             return getArtifacts( searchResults );
 145         }
 146         catch ( RepositorySearchException e )
 147         {
 148             log.error( e.getMessage(), e );
 149             throw new ArchivaRestServiceException( e.getMessage() );
 150         }
 151     }
 152
 153     public GroupIdList getAllGroupIds( List<String> selectedRepos )
 154         throws ArchivaRestServiceException
 155     {
 156         List<String> observableRepos = getObservableRepos();
 157         List<String> repos = ListUtils.intersection( observableRepos, selectedRepos );
 158         if ( repos == null || repos.isEmpty() )
 159         {
 160             return new GroupIdList( Collections.<String>emptyList() );
 161         }
 162         try
 163         {
 164             return new GroupIdList( new ArrayList<String>( repositorySearch.getAllGroupIds( getPrincipal(), repos ) ) );
 165         }
 166         catch ( RepositorySearchException e )
 167         {
 168             log.error( e.getMessage(), e );
 169             throw new ArchivaRestServiceException( e.getMessage() );
 170         }
 171
 172     }
 173
 174     public List<Dependency> getDependencies( String groupId, String artifactId, String version )
 175         throws ArchivaRestServiceException
 176     {
 177         return null;  //To change body of implemented methods use File | Settings | File Templates.
 178     }
 179
 180     public List<Artifact> getArtifactByChecksum( String checksum )
 181         throws ArchivaRestServiceException
 182     {
 183         return null;  //To change body of implemented methods use File | Settings | File Templates.
 184     }
 185
 186
 187     protected List<String> getObservableRepos()
 188     {
 189         try
 190         {
 191             List<String> ids = userRepositories.getObservableRepositoryIds( getPrincipal() );
 192             return ids == null ? Collections.<String>emptyList() : ids;
 193         }
 194         catch ( PrincipalNotFoundException e )
 195         {
 196             log.warn( e.getMessage(), e );
 197         }
 198         catch ( AccessDeniedException e )
 199         {
 200             log.warn( e.getMessage(), e );
 201         }
 202         catch ( ArchivaSecurityException e )
 203         {
 204             log.warn( e.getMessage(), e );
 205         }
 206         return Collections.emptyList();
 207     }
 208
 209     protected String getPrincipal()
 210     {
 211         RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
 212
 213         return redbackRequestInformation == null
 214             ? UserManager.GUEST_USERNAME
 215             : ( redbackRequestInformation.getUser() == null
 216                 ? UserManager.GUEST_USERNAME
 217                 : redbackRequestInformation.getUser().getUsername() );
 218     }
 219
 220     protected List<Artifact> getArtifacts( SearchResults searchResults )
 221     {
 222
 223         if ( searchResults == null || searchResults.isEmpty() )
 224         {
 225             return Collections.emptyList();
 226         }
 227         List<Artifact> artifacts = new ArrayList<Artifact>( searchResults.getReturnedHitsCount() );
 228         for ( SearchResultHit hit : searchResults.getHits() )
 229         {
 230             // duplicate Artifact one per available version
 231             if ( hit.getVersions().size() > 0 )
 232             {
 233                 for ( String version : hit.getVersions() )
 234                 {
 235
 236                     Artifact versionned = new BeanReplicator().replicateBean( hit, Artifact.class );
 237
 238                     if ( StringUtils.isNotBlank( version ) )
 239                     {
 240                         versionned.setVersion( version );
 241                         versionned.setUrl( getArtifactUrl( versionned ) );
 242
 243                         artifacts.add( versionned );
 244
 245                     }
 246                 }
 247             }
 248         }
 249         return artifacts;
 250     }
 251
 252     /**
 253      * TODO add a configuration mechanism to have configured the base archiva url
 254      * @param artifact
 255      * @return
 256      */
 257     private String getArtifactUrl( Artifact artifact )
 258     {
 259
 260         if ( httpServletRequest == null )
 261         {
 262             return null;
 263         }
 264         if ( StringUtils.isEmpty( artifact.getUrl() ) )
 265         {
 266             return null;
 267         }
 268         StringBuilder sb = new StringBuilder( getBaseUrl( httpServletRequest ) );
 269
 270         sb.append( "/repository" );
 271         if ( !StringUtils.startsWith( artifact.getUrl(), "/" ) )
 272         {
 273             sb.append( '/' );
 274         }
 275         sb.append( artifact.getUrl() );
 276         return sb.toString();
 277     }
 278
 279     protected String getBaseUrl( HttpServletRequest req )
 280     {
 281         return req.getScheme() + "://" + req.getServerName() + ( req.getServerPort() == 80
 282             ? ""
 283             : ":" + req.getServerPort() ) + req.getContextPath();
 284     }
 285 }