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.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.substringAfterLast( entry.getKey(), "#" );
 177             beans.put( key, entry.getValue() );
 178         }
 179         return beans;
 180     }
 181
 182     protected void triggerAuditEvent( String repositoryId, String filePath, String action )
 183     {
 184         AuditEvent auditEvent = new AuditEvent( repositoryId, getPrincipal(), filePath, action );
 185         AuditInformation auditInformation = getAuditInformation();
 186         auditEvent.setUserId( auditInformation.getUser() == null ? "" : auditInformation.getUser().getUsername() );
 187         auditEvent.setRemoteIP( auditInformation.getRemoteAddr() );
 188         for ( AuditListener auditListener : getAuditListeners() )
 189         {
 190             auditListener.auditEvent( auditEvent );
 191         }
 192     }
 193
 194     /**
 195      * @param artifact
 196      * @return
 197      */
 198     protected String getArtifactUrl( Artifact artifact )
 199         throws ArchivaRestServiceException
 200     {
 201         try
 202         {
 203
 204             if ( httpServletRequest == null )
 205             {
 206                 return null;
 207             }
 208
 209             StringBuilder sb = new StringBuilder( getBaseUrl() );
 210
 211             sb.append( "/repository" );
 212
 213             // FIXME when artifact come from a remote repository when have here the remote repo id
 214             // we must replace it with a valid managed one available for the user.
 215
 216             sb.append( '/' ).append( artifact.getContext() );
 217
 218             sb.append( '/' ).append( StringUtils.replaceChars( artifact.getGroupId(), '.', '/' ) );
 219             sb.append( '/' ).append( artifact.getArtifactId() );
 220             if ( VersionUtil.isSnapshot( artifact.getVersion() ) )
 221             {
 222                 sb.append( '/' ).append( VersionUtil.getBaseVersion( artifact.getVersion() ) );
 223             }
 224             else
 225             {
 226                 sb.append( '/' ).append( artifact.getVersion() );
 227             }
 228             sb.append( '/' ).append( artifact.getArtifactId() );
 229             sb.append( '-' ).append( artifact.getVersion() );
 230             if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
 231             {
 232                 sb.append( '-' ).append( artifact.getClassifier() );
 233             }
 234             // maven-plugin packaging is a jar
 235             if ( StringUtils.equals( "maven-plugin", artifact.getPackaging() ) )
 236             {
 237                 sb.append( "jar" );
 238             }
 239             else
 240             {
 241                 sb.append( '.' ).append( artifact.getFileExtension() );
 242             }
 243
 244             return sb.toString();
 245         }
 246         catch ( RepositoryAdminException e )
 247         {
 248             throw new ArchivaRestServiceException( e.getMessage(),
 249                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
 250         }
 251     }
 252
 253     protected List<Artifact> buildArtifacts( List<ArtifactMetadata> artifactMetadatas, String repositoryId )
 254         throws ArchivaRestServiceException
 255     {
 256         try
 257         {
 258             if ( artifactMetadatas != null && !artifactMetadatas.isEmpty() )
 259             {
 260                 List<Artifact> artifacts = new ArrayList<Artifact>( artifactMetadatas.size() );
 261                 for ( ArtifactMetadata artifact : artifactMetadatas )
 262                 {
 263
 264                     ArtifactBuilder builder =
 265                         new ArtifactBuilder().forArtifactMetadata( artifact ).withManagedRepositoryContent(
 266                             repositoryContentFactory.getManagedRepositoryContent( repositoryId ) );
 267                     Artifact art = builder.build();
 268                     art.setUrl( getArtifactUrl( art ) );
 269                     artifacts.add( art );
 270                 }
 271                 return artifacts;
 272             }
 273             return Collections.emptyList();
 274         }
 275         catch ( RepositoryException e )
 276         {
 277             log.error( e.getMessage(), e );
 278             throw new ArchivaRestServiceException( e.getMessage(),
 279                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
 280         }
 281     }
 282
 283     protected Boolean doScanRepository( String repositoryId, boolean fullScan )
 284     {
 285         if ( repositoryTaskScheduler.isProcessingRepositoryTask( repositoryId ) )
 286         {
 287             log.info( "scanning of repository with id {} already scheduled", repositoryId );
 288             return Boolean.FALSE;
 289         }
 290         RepositoryTask task = new RepositoryTask();
 291         task.setRepositoryId( repositoryId );
 292         task.setScanAll( fullScan );
 293         try
 294         {
 295             repositoryTaskScheduler.queueTask( task );
 296         }
 297         catch ( TaskQueueException e )
 298         {
 299             log.error( "failed to schedule scanning of repo with id {}", repositoryId, e );
 300             return false;
 301         }
 302         return true;
 303     }
 304 }