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.managed.ManagedRepositoryAdmin;
  26 import org.apache.archiva.audit.AuditEvent;
  27 import org.apache.archiva.audit.AuditListener;
  28 import org.apache.archiva.common.utils.VersionUtil;
  29 import org.apache.archiva.maven2.model.Artifact;
  30 import org.apache.archiva.metadata.model.ArtifactMetadata;
  31 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  32 import org.apache.archiva.redback.components.taskqueue.TaskQueueException;
  33 import org.apache.archiva.redback.rest.services.RedbackAuthenticationThreadLocal;
  34 import org.apache.archiva.redback.rest.services.RedbackRequestInformation;
  35 import org.apache.archiva.redback.users.User;
  36 import org.apache.archiva.redback.users.UserManager;
  37 import org.apache.archiva.repository.RepositoryContentFactory;
  38 import org.apache.archiva.repository.RepositoryException;
  39 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  40 import org.apache.archiva.rest.services.utils.ArtifactBuilder;
  41 import org.apache.archiva.scheduler.repository.DefaultRepositoryArchivaTaskScheduler;
  42 import org.apache.archiva.scheduler.repository.model.RepositoryTask;
  43 import org.apache.archiva.security.AccessDeniedException;
  44 import org.apache.archiva.security.ArchivaSecurityException;
  45 import org.apache.archiva.security.PrincipalNotFoundException;
  46 import org.apache.archiva.security.UserRepositories;
  47 import org.apache.commons.lang.StringUtils;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50 import org.springframework.context.ApplicationContext;
  51
  52 import javax.inject.Inject;
  53 import javax.inject.Named;
  54 import javax.servlet.http.HttpServletRequest;
  55 import javax.ws.rs.core.Context;
  56 import javax.ws.rs.core.Response;
  57 import java.util.ArrayList;
  58 import java.util.Collections;
  59 import java.util.HashMap;
  60 import java.util.List;
  61 import java.util.Map;
  62
  63 /**
  64  * abstract class with common utilities methods
  65  *
  66  * @author Olivier Lamy
  67  * @since 1.4-M1
  68  */
  69 public abstract class AbstractRestService
  70 {
  71
  72     protected Logger log = LoggerFactory.getLogger( getClass() );
  73
  74     @Inject
  75     private List<AuditListener> auditListeners = new ArrayList<AuditListener>();
  76
  77     @Inject
  78     protected UserRepositories userRepositories;
  79
  80
  81     @Inject
  82     @Named(value = "repositorySessionFactory")
  83     protected RepositorySessionFactory repositorySessionFactory;
  84
  85     @Inject
  86     protected ArchivaAdministration archivaAdministration;
  87
  88     @Inject
  89     protected ManagedRepositoryAdmin managedRepositoryAdmin;
  90
  91     @Inject
  92     protected RepositoryContentFactory repositoryContentFactory;
  93
  94     @Inject
  95     @Named(value = "archivaTaskScheduler#repository")
  96     protected DefaultRepositoryArchivaTaskScheduler repositoryTaskScheduler;
  97
  98     @Context
  99     protected HttpServletRequest httpServletRequest;
 100
 101     protected AuditInformation getAuditInformation()
 102     {
 103         RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
 104         User user = redbackRequestInformation == null ? null : redbackRequestInformation.getUser();
 105         String remoteAddr = redbackRequestInformation == null ? null : redbackRequestInformation.getRemoteAddr();
 106         return new AuditInformation( user, remoteAddr );
 107     }
 108
 109     public List<AuditListener> getAuditListeners()
 110     {
 111         return auditListeners;
 112     }
 113
 114     public void setAuditListeners( List<AuditListener> auditListeners )
 115     {
 116         this.auditListeners = auditListeners;
 117     }
 118
 119     protected List<String> getObservableRepos()
 120     {
 121         try
 122         {
 123             List<String> ids = userRepositories.getObservableRepositoryIds( getPrincipal() );
 124             return ids == null ? Collections.<String>emptyList() : ids;
 125         }
 126         catch ( PrincipalNotFoundException e )
 127         {
 128             log.warn( e.getMessage(), e );
 129         }
 130         catch ( AccessDeniedException e )
 131         {
 132             log.warn( e.getMessage(), e );
 133         }
 134         catch ( ArchivaSecurityException e )
 135         {
 136             log.warn( e.getMessage(), e );
 137         }
 138         return Collections.emptyList();
 139     }
 140
 141     protected String getPrincipal()
 142     {
 143         RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
 144
 145         return redbackRequestInformation == null
 146             ? UserManager.GUEST_USERNAME
 147             : ( redbackRequestInformation.getUser() == null
 148                 ? UserManager.GUEST_USERNAME
 149                 : redbackRequestInformation.getUser().getUsername() );
 150     }
 151
 152     protected String getBaseUrl()
 153         throws RepositoryAdminException
 154     {
 155         String applicationUrl = archivaAdministration.getUiConfiguration().getApplicationUrl();
 156         if ( StringUtils.isNotBlank( applicationUrl ) )
 157         {
 158             return applicationUrl;
 159         }
 160         return httpServletRequest.getScheme() + "://" + httpServletRequest.getServerName() + (
 161             httpServletRequest.getServerPort() == 80 ? "" : ":" + httpServletRequest.getServerPort() )
 162             + httpServletRequest.getContextPath();
 163     }
 164
 165     protected <T> Map<String, T> getBeansOfType( ApplicationContext applicationContext, Class<T> clazz )
 166     {
 167         //TODO do some caching here !!!
 168         // olamy : with plexus we get only roleHint
 169         // as per convention we named spring bean role#hint remove role# if exists
 170         Map<String, T> springBeans = applicationContext.getBeansOfType( clazz );
 171
 172         Map<String, T> beans = new HashMap<String, T>( springBeans.size() );
 173
 174         for ( Map.Entry<String, T> entry : springBeans.entrySet() )
 175         {
 176             String key = StringUtils.contains( entry.getKey(), '#' )
 177                 ? StringUtils.substringAfterLast( entry.getKey(), "#" )
 178                 : entry.getKey();
 179             beans.put( key, entry.getValue() );
 180         }
 181         return beans;
 182     }
 183
 184     protected void triggerAuditEvent( String repositoryId, String filePath, String action )
 185     {
 186         AuditEvent auditEvent = new AuditEvent( repositoryId, getPrincipal(), filePath, action );
 187         AuditInformation auditInformation = getAuditInformation();
 188         auditEvent.setUserId( auditInformation.getUser() == null ? "" : auditInformation.getUser().getUsername() );
 189         auditEvent.setRemoteIP( auditInformation.getRemoteAddr() );
 190         for ( AuditListener auditListener : getAuditListeners() )
 191         {
 192             auditListener.auditEvent( auditEvent );
 193         }
 194     }
 195
 196     /**
 197      * @param artifact
 198      * @return
 199      */
 200     protected String getArtifactUrl( Artifact artifact )
 201         throws ArchivaRestServiceException
 202     {
 203         try
 204         {
 205
 206             if ( httpServletRequest == null )
 207             {
 208                 return null;
 209             }
 210
 211             StringBuilder sb = new StringBuilder( getBaseUrl() );
 212
 213             sb.append( "/repository" );
 214
 215             // FIXME when artifact come from a remote repository when have here the remote repo id
 216             // we must replace it with a valid managed one available for the user.
 217
 218             sb.append( '/' ).append( artifact.getContext() );
 219
 220             sb.append( '/' ).append( StringUtils.replaceChars( artifact.getGroupId(), '.', '/' ) );
 221             sb.append( '/' ).append( artifact.getArtifactId() );
 222             if ( VersionUtil.isSnapshot( artifact.getVersion() ) )
 223             {
 224                 sb.append( '/' ).append( VersionUtil.getBaseVersion( artifact.getVersion() ) );
 225             }
 226             else
 227             {
 228                 sb.append( '/' ).append( artifact.getVersion() );
 229             }
 230             sb.append( '/' ).append( artifact.getArtifactId() );
 231             sb.append( '-' ).append( artifact.getVersion() );
 232             if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
 233             {
 234                 sb.append( '-' ).append( artifact.getClassifier() );
 235             }
 236             // maven-plugin packaging is a jar
 237             if ( StringUtils.equals( "maven-plugin", artifact.getPackaging() ) )
 238             {
 239                 sb.append( "jar" );
 240             }
 241             else
 242             {
 243                 sb.append( '.' ).append( artifact.getFileExtension() );
 244             }
 245
 246             return sb.toString();
 247         }
 248         catch ( RepositoryAdminException e )
 249         {
 250             throw new ArchivaRestServiceException( e.getMessage(),
 251                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
 252         }
 253     }
 254
 255     protected List<Artifact> buildArtifacts( List<ArtifactMetadata> artifactMetadatas, String repositoryId )
 256         throws ArchivaRestServiceException
 257     {
 258         try
 259         {
 260             if ( artifactMetadatas != null && !artifactMetadatas.isEmpty() )
 261             {
 262                 List<Artifact> artifacts = new ArrayList<Artifact>( artifactMetadatas.size() );
 263                 for ( ArtifactMetadata artifact : artifactMetadatas )
 264                 {
 265
 266                     ArtifactBuilder builder =
 267                         new ArtifactBuilder().forArtifactMetadata( artifact ).withManagedRepositoryContent(
 268                             repositoryContentFactory.getManagedRepositoryContent( repositoryId ) );
 269                     Artifact art = builder.build();
 270                     art.setUrl( getArtifactUrl( art ) );
 271                     artifacts.add( art );
 272                 }
 273                 return artifacts;
 274             }
 275             return Collections.emptyList();
 276         }
 277         catch ( RepositoryException e )
 278         {
 279             log.error( e.getMessage(), e );
 280             throw new ArchivaRestServiceException( e.getMessage(),
 281                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
 282         }
 283     }
 284
 285     protected Boolean doScanRepository( String repositoryId, boolean fullScan )
 286     {
 287         if ( repositoryTaskScheduler.isProcessingRepositoryTask( repositoryId ) )
 288         {
 289             log.info( "scanning of repository with id {} already scheduled", repositoryId );
 290             return Boolean.FALSE;
 291         }
 292         RepositoryTask task = new RepositoryTask();
 293         task.setRepositoryId( repositoryId );
 294         task.setScanAll( fullScan );
 295         try
 296         {
 297             repositoryTaskScheduler.queueTask( task );
 298         }
 299         catch ( TaskQueueException e )
 300         {
 301             log.error( "failed to schedule scanning of repo with id {}", repositoryId, e );
 302             return false;
 303         }
 304         return true;
 305     }
 306 }