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

   1 package org.apache.archiva.rest.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 org.apache.archiva.admin.model.AuditInformation;
  23 import org.apache.archiva.admin.model.RepositoryAdminException;
  24 import org.apache.archiva.admin.model.admin.ArchivaAdministration;
  25 import org.apache.archiva.admin.model.beans.ProxyConnector;
  26 import org.apache.archiva.admin.model.proxyconnector.ProxyConnectorAdmin;
  27 import org.apache.archiva.common.utils.VersionUtil;
  28 import org.apache.archiva.indexer.search.SearchResultHit;
  29 import org.apache.archiva.maven2.model.Artifact;
  30 import org.apache.archiva.metadata.model.ArtifactMetadata;
  31 import org.apache.archiva.metadata.model.facets.AuditEvent;
  32 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  33 import org.apache.archiva.components.taskqueue.TaskQueueException;
  34 import org.apache.archiva.redback.configuration.UserConfiguration;
  35 import org.apache.archiva.redback.configuration.UserConfigurationKeys;
  36 import org.apache.archiva.redback.rest.services.RedbackAuthenticationThreadLocal;
  37 import org.apache.archiva.redback.rest.services.RedbackRequestInformation;
  38 import org.apache.archiva.redback.users.User;
  39 import org.apache.archiva.repository.ManagedRepository;
  40 import org.apache.archiva.repository.ManagedRepositoryContent;
  41 import org.apache.archiva.repository.RepositoryException;
  42 import org.apache.archiva.repository.RepositoryRegistry;
  43 import org.apache.archiva.metadata.audit.AuditListener;
  44 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  45 import org.apache.archiva.rest.services.utils.ArtifactBuilder;
  46 import org.apache.archiva.scheduler.repository.model.RepositoryArchivaTaskScheduler;
  47 import org.apache.archiva.scheduler.repository.model.RepositoryTask;
  48 import org.apache.archiva.security.AccessDeniedException;
  49 import org.apache.archiva.security.ArchivaSecurityException;
  50 import org.apache.archiva.security.PrincipalNotFoundException;
  51 import org.apache.archiva.security.UserRepositories;
  52 import org.apache.commons.lang3.StringUtils;
  53 import org.modelmapper.ModelMapper;
  54 import org.modelmapper.PropertyMap;
  55 import org.modelmapper.convention.MatchingStrategies;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58 import org.springframework.context.ApplicationContext;
  59
  60 import javax.inject.Inject;
  61 import javax.inject.Named;
  62 import javax.servlet.http.HttpServletRequest;
  63 import javax.servlet.http.HttpServletResponse;
  64 import javax.ws.rs.core.Context;
  65 import javax.ws.rs.core.Response;
  66 import java.util.ArrayList;
  67 import java.util.Collection;
  68 import java.util.Collections;
  69 import java.util.HashMap;
  70 import java.util.List;
  71 import java.util.Map;
  72
  73 /**
  74  * abstract class with common utilities methods
  75  *
  76  * @author Olivier Lamy
  77  * @since 1.4-M1
  78  */
  79 public abstract class AbstractRestService
  80 {
  81
  82     protected final Logger log = LoggerFactory.getLogger( getClass() );
  83
  84     @Inject
  85     private List<AuditListener> auditListeners = new ArrayList<>();
  86
  87     @Inject
  88     protected UserRepositories userRepositories;
  89
  90
  91     /**
  92      * FIXME: this could be multiple implementations and needs to be configured.
  93      */
  94     @Inject
  95     @Named(value = "repositorySessionFactory")
  96     protected RepositorySessionFactory repositorySessionFactory;
  97
  98     @Inject
  99     protected ArchivaAdministration archivaAdministration;
 100
 101     @Inject
 102     protected ProxyConnectorAdmin proxyConnectorAdmin;
 103
 104     @Inject
 105     protected RepositoryRegistry repositoryRegistry;
 106
 107     @Inject
 108     @Named(value = "archivaTaskScheduler#repository")
 109     protected RepositoryArchivaTaskScheduler repositoryTaskScheduler;
 110
 111
 112     @Inject
 113     @Named(value = "userConfiguration#default")
 114     protected UserConfiguration config;
 115
 116     @Context
 117     protected HttpServletRequest httpServletRequest;
 118
 119     @Context
 120     protected HttpServletResponse httpServletResponse;
 121
 122     protected AuditInformation getAuditInformation()
 123     {
 124         RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
 125         User user = redbackRequestInformation == null ? null : redbackRequestInformation.getUser();
 126         String remoteAddr = redbackRequestInformation == null ? null : redbackRequestInformation.getRemoteAddr();
 127         return new AuditInformation( user, remoteAddr );
 128     }
 129
 130     public List<AuditListener> getAuditListeners()
 131     {
 132         return auditListeners;
 133     }
 134
 135     public void setAuditListeners( List<AuditListener> auditListeners )
 136     {
 137         this.auditListeners = auditListeners;
 138     }
 139
 140     protected List<String> getObservableRepos()
 141     {
 142         try
 143         {
 144             List<String> ids = userRepositories.getObservableRepositoryIds( getPrincipal() );
 145             return ids == null ? Collections.<String>emptyList() : ids;
 146         }
 147         catch ( PrincipalNotFoundException e )
 148         {
 149             log.warn( e.getMessage(), e );
 150         }
 151         catch ( AccessDeniedException e )
 152         {
 153             log.warn( e.getMessage(), e );
 154         }
 155         catch ( ArchivaSecurityException e )
 156         {
 157             log.warn( e.getMessage(), e );
 158         }
 159         return Collections.emptyList();
 160     }
 161
 162     protected String getPrincipal()
 163     {
 164         RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
 165
 166         return redbackRequestInformation == null
 167             ? config.getString( UserConfigurationKeys.DEFAULT_GUEST )
 168             : ( redbackRequestInformation.getUser() == null
 169                 ? config.getString( UserConfigurationKeys.DEFAULT_GUEST )
 170                 : redbackRequestInformation.getUser().getUsername() );
 171     }
 172
 173     protected String getBaseUrl()
 174         throws RepositoryAdminException
 175     {
 176         String applicationUrl = archivaAdministration.getUiConfiguration().getApplicationUrl();
 177         if ( StringUtils.isNotBlank( applicationUrl ) )
 178         {
 179             return applicationUrl;
 180         }
 181         return httpServletRequest.getScheme() + "://" + httpServletRequest.getServerName() + (
 182             httpServletRequest.getServerPort() == 80 ? "" : ":" + httpServletRequest.getServerPort() )
 183             + httpServletRequest.getContextPath();
 184     }
 185
 186     protected <T> Map<String, T> getBeansOfType( ApplicationContext applicationContext, Class<T> clazz )
 187     {
 188         //TODO do some caching here !!!
 189         // olamy : with plexus we get only roleHint
 190         // as per convention we named spring bean role#hint remove role# if exists
 191         Map<String, T> springBeans = applicationContext.getBeansOfType( clazz );
 192
 193         Map<String, T> beans = new HashMap<>( springBeans.size() );
 194
 195         for ( Map.Entry<String, T> entry : springBeans.entrySet() )
 196         {
 197             String key = StringUtils.contains( entry.getKey(), '#' )
 198                 ? StringUtils.substringAfterLast( entry.getKey(), "#" )
 199                 : entry.getKey();
 200             beans.put( key, entry.getValue() );
 201         }
 202         return beans;
 203     }
 204
 205     protected void triggerAuditEvent( String repositoryId, String filePath, String action )
 206     {
 207         AuditEvent auditEvent = new AuditEvent( repositoryId, getPrincipal(), filePath, action );
 208         AuditInformation auditInformation = getAuditInformation();
 209         auditEvent.setUserId( auditInformation.getUser() == null ? "" : auditInformation.getUser().getUsername() );
 210         auditEvent.setRemoteIP( auditInformation.getRemoteAddr() );
 211         for ( AuditListener auditListener : getAuditListeners() )
 212         {
 213             auditListener.auditEvent( auditEvent );
 214         }
 215     }
 216
 217     /**
 218      * @param artifact
 219      * @return
 220      */
 221     protected String getArtifactUrl( Artifact artifact )
 222         throws ArchivaRestServiceException
 223     {
 224         return getArtifactUrl( artifact, null );
 225     }
 226
 227
 228     protected String getArtifactUrl( Artifact artifact, String repositoryId )
 229         throws ArchivaRestServiceException
 230     {
 231         try
 232         {
 233
 234             if ( httpServletRequest == null )
 235             {
 236                 return null;
 237             }
 238
 239             StringBuilder sb = new StringBuilder( getBaseUrl() );
 240
 241             sb.append( "/repository" );
 242
 243             // when artifact come from a remote repository when have here the remote repo id
 244             // we must replace it with a valid managed one available for the user.
 245             if ( StringUtils.isEmpty( repositoryId ) )
 246             {
 247                 List<String> userRepos = userRepositories.getObservableRepositoryIds( getPrincipal() );
 248                 // is it a good one? if yes nothing to
 249                 // if not search the repo who is proxy for this remote
 250                 if ( !userRepos.contains( artifact.getContext() ) )
 251                 {
 252                     for ( Map.Entry<String, List<ProxyConnector>> entry : proxyConnectorAdmin.getProxyConnectorAsMap().entrySet() )
 253                     {
 254                         for ( ProxyConnector proxyConnector : entry.getValue() )
 255                         {
 256                             if ( StringUtils.equals( "remote-" + proxyConnector.getTargetRepoId(),
 257                                                      artifact.getContext() ) //
 258                                 && userRepos.contains( entry.getKey() ) )
 259                             {
 260                                 sb.append( '/' ).append( entry.getKey() );
 261                             }
 262                         }
 263                     }
 264
 265                 }
 266                 else
 267                 {
 268                     sb.append( '/' ).append( artifact.getContext() );
 269                 }
 270
 271
 272             }
 273             else
 274             {
 275                 sb.append( '/' ).append( repositoryId );
 276             }
 277
 278             sb.append( '/' ).append( StringUtils.replaceChars( artifact.getGroupId(), '.', '/' ) );
 279             sb.append( '/' ).append( artifact.getArtifactId() );
 280             if ( VersionUtil.isSnapshot( artifact.getVersion() ) )
 281             {
 282                 sb.append( '/' ).append( VersionUtil.getBaseVersion( artifact.getVersion() ) );
 283             }
 284             else
 285             {
 286                 sb.append( '/' ).append( artifact.getVersion() );
 287             }
 288             sb.append( '/' ).append( artifact.getArtifactId() );
 289             sb.append( '-' ).append( artifact.getVersion() );
 290             if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
 291             {
 292                 sb.append( '-' ).append( artifact.getClassifier() );
 293             }
 294             // maven-plugin packaging is a jar
 295             if ( StringUtils.equals( "maven-plugin", artifact.getPackaging() ) )
 296             {
 297                 sb.append( "jar" );
 298             }
 299             else
 300             {
 301                 sb.append( '.' ).append( artifact.getFileExtension() );
 302             }
 303
 304             return sb.toString();
 305         }
 306         catch ( Exception e )
 307         {
 308             throw new ArchivaRestServiceException( e.getMessage(),
 309                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
 310         }
 311     }
 312
 313     protected List<Artifact> buildArtifacts( Collection<ArtifactMetadata> artifactMetadatas, String repositoryId )
 314         throws ArchivaRestServiceException
 315     {
 316         try
 317         {
 318             if ( artifactMetadatas != null && !artifactMetadatas.isEmpty() )
 319             {
 320                 List<Artifact> artifacts = new ArrayList<>( artifactMetadatas.size() );
 321                 for ( ArtifactMetadata artifact : artifactMetadatas )
 322                 {
 323
 324                     String repoId = repositoryId != null ? repositoryId : artifact.getRepositoryId();
 325                     if ( repoId == null ) {
 326                         throw new IllegalStateException( "Repository Id is null" );
 327                     }
 328                     ManagedRepository repo = repositoryRegistry.getManagedRepository( repoId );
 329                     if (repo==null) {
 330                         throw new RepositoryException( "Repository not found "+repoId );
 331                     }
 332                     ManagedRepositoryContent content = repo.getContent( );
 333                     ArtifactBuilder builder =
 334                         new ArtifactBuilder().forArtifactMetadata( artifact ).withManagedRepositoryContent(
 335                             content );
 336                     Artifact art = builder.build();
 337                     art.setUrl( getArtifactUrl( art, repositoryId ) );
 338                     artifacts.add( art );
 339                 }
 340                 return artifacts;
 341             }
 342             return Collections.emptyList();
 343         }
 344         catch ( RepositoryException e )
 345         {
 346             log.error( e.getMessage(), e );
 347             throw new ArchivaRestServiceException( e.getMessage(),
 348                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
 349         }
 350     }
 351
 352     protected Boolean doScanRepository( String repositoryId, boolean fullScan )
 353     {
 354         if ( repositoryTaskScheduler.isProcessingRepositoryTask( repositoryId ) )
 355         {
 356             log.info( "scanning of repository with id {} already scheduled", repositoryId );
 357             return Boolean.FALSE;
 358         }
 359         RepositoryTask task = new RepositoryTask();
 360         task.setRepositoryId( repositoryId );
 361         task.setScanAll( fullScan );
 362         try
 363         {
 364             repositoryTaskScheduler.queueTask( task );
 365         }
 366         catch ( TaskQueueException e )
 367         {
 368             log.error( "failed to schedule scanning of repo with id {}", repositoryId, e );
 369             return false;
 370         }
 371         return true;
 372     }
 373
 374     private static class ModelMapperHolder
 375     {
 376         private static ModelMapper MODEL_MAPPER = new ModelMapper();
 377
 378         static
 379         {
 380             MODEL_MAPPER.addMappings( new SearchResultHitMap() );
 381             MODEL_MAPPER.getConfiguration().setMatchingStrategy( MatchingStrategies.STRICT );
 382         }
 383     }
 384
 385
 386     private static class SearchResultHitMap
 387         extends PropertyMap<SearchResultHit, Artifact>
 388     {
 389         @Override
 390         protected void configure()
 391         {
 392             skip().setId( null );
 393         }
 394     }
 395
 396     ;
 397
 398     protected ModelMapper getModelMapper()
 399     {
 400         return ModelMapperHolder.MODEL_MAPPER;
 401     }
 402 }