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.audit.AuditEvent;
  26 import org.apache.archiva.audit.AuditListener;
  27 import org.apache.archiva.common.utils.VersionUtil;
  28 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
  29 import org.apache.archiva.redback.rest.services.RedbackAuthenticationThreadLocal;
  30 import org.apache.archiva.redback.rest.services.RedbackRequestInformation;
  31 import org.apache.archiva.redback.users.User;
  32 import org.apache.archiva.redback.users.UserManager;
  33 import org.apache.archiva.rest.api.model.Artifact;
  34 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
  35 import org.apache.archiva.security.AccessDeniedException;
  36 import org.apache.archiva.security.ArchivaSecurityException;
  37 import org.apache.archiva.security.PrincipalNotFoundException;
  38 import org.apache.archiva.security.UserRepositories;
  39 import org.apache.commons.lang.StringUtils;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42 import org.springframework.context.ApplicationContext;
  43
  44 import javax.inject.Inject;
  45 import javax.inject.Named;
  46 import javax.servlet.http.HttpServletRequest;
  47 import javax.ws.rs.core.Context;
  48 import javax.ws.rs.core.Response;
  49 import java.util.ArrayList;
  50 import java.util.Collections;
  51 import java.util.HashMap;
  52 import java.util.List;
  53 import java.util.Map;
  54
  55 /**
  56  * abstract class with common utilities methods
  57  *
  58  * @author Olivier Lamy
  59  * @since 1.4-M1
  60  */
  61 public abstract class AbstractRestService
  62 {
  63
  64     protected Logger log = LoggerFactory.getLogger( getClass() );
  65
  66     @Inject
  67     private List<AuditListener> auditListeners = new ArrayList<AuditListener>();
  68
  69     @Inject
  70     protected UserRepositories userRepositories;
  71
  72
  73     @Inject
  74     @Named( value = "repositorySessionFactory" )
  75     protected RepositorySessionFactory repositorySessionFactory;
  76
  77     @Inject
  78     protected ArchivaAdministration archivaAdministration;
  79
  80     @Context
  81     protected HttpServletRequest httpServletRequest;
  82
  83     protected AuditInformation getAuditInformation()
  84     {
  85         RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
  86         User user = redbackRequestInformation == null ? null : redbackRequestInformation.getUser();
  87         String remoteAddr = redbackRequestInformation == null ? null : redbackRequestInformation.getRemoteAddr();
  88         return new AuditInformation( user, remoteAddr );
  89     }
  90
  91     public List<AuditListener> getAuditListeners()
  92     {
  93         return auditListeners;
  94     }
  95
  96     public void setAuditListeners( List<AuditListener> auditListeners )
  97     {
  98         this.auditListeners = auditListeners;
  99     }
 100
 101     protected List<String> getObservableRepos()
 102     {
 103         try
 104         {
 105             List<String> ids = userRepositories.getObservableRepositoryIds( getPrincipal() );
 106             return ids == null ? Collections.<String>emptyList() : ids;
 107         }
 108         catch ( PrincipalNotFoundException e )
 109         {
 110             log.warn( e.getMessage(), e );
 111         }
 112         catch ( AccessDeniedException e )
 113         {
 114             log.warn( e.getMessage(), e );
 115         }
 116         catch ( ArchivaSecurityException e )
 117         {
 118             log.warn( e.getMessage(), e );
 119         }
 120         return Collections.emptyList();
 121     }
 122
 123     protected String getPrincipal()
 124     {
 125         RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
 126
 127         return redbackRequestInformation == null
 128             ? UserManager.GUEST_USERNAME
 129             : ( redbackRequestInformation.getUser() == null
 130                 ? UserManager.GUEST_USERNAME
 131                 : redbackRequestInformation.getUser().getUsername() );
 132     }
 133
 134     protected String getBaseUrl()
 135         throws RepositoryAdminException
 136     {
 137         String applicationUrl = archivaAdministration.getUiConfiguration().getApplicationUrl();
 138         if ( StringUtils.isNotBlank( applicationUrl ) )
 139         {
 140             return applicationUrl;
 141         }
 142         return httpServletRequest.getScheme() + "://" + httpServletRequest.getServerName() + (
 143             httpServletRequest.getServerPort() == 80 ? "" : ":" + httpServletRequest.getServerPort() )
 144             + httpServletRequest.getContextPath();
 145     }
 146
 147     protected <T> Map<String, T> getBeansOfType( ApplicationContext applicationContext, Class<T> clazz )
 148     {
 149         //TODO do some caching here !!!
 150         // olamy : with plexus we get only roleHint
 151         // as per convention we named spring bean role#hint remove role# if exists
 152         Map<String, T> springBeans = applicationContext.getBeansOfType( clazz );
 153
 154         Map<String, T> beans = new HashMap<String, T>( springBeans.size() );
 155
 156         for ( Map.Entry<String, T> entry : springBeans.entrySet() )
 157         {
 158             String key = StringUtils.substringAfterLast( entry.getKey(), "#" );
 159             beans.put( key, entry.getValue() );
 160         }
 161         return beans;
 162     }
 163
 164     protected void triggerAuditEvent( String repositoryId, String filePath, String action )
 165     {
 166         AuditEvent auditEvent = new AuditEvent( repositoryId, getPrincipal(), filePath, action );
 167         AuditInformation auditInformation = getAuditInformation();
 168         auditEvent.setUserId( auditInformation.getUser() == null ? "" : auditInformation.getUser().getUsername() );
 169         auditEvent.setRemoteIP( auditInformation.getRemoteAddr() );
 170         for ( AuditListener auditListener : getAuditListeners() )
 171         {
 172             auditListener.auditEvent( auditEvent );
 173         }
 174     }
 175
 176     /**
 177      * @param artifact
 178      * @return
 179      */
 180     protected String getArtifactUrl( Artifact artifact )
 181         throws ArchivaRestServiceException
 182     {
 183         try
 184         {
 185
 186             if ( httpServletRequest == null )
 187             {
 188                 return null;
 189             }
 190
 191             StringBuilder sb = new StringBuilder( getBaseUrl() );
 192
 193             sb.append( "/repository" );
 194
 195             sb.append( '/' ).append( artifact.getContext() );
 196
 197             sb.append( '/' ).append( StringUtils.replaceChars( artifact.getGroupId(), '.', '/' ) );
 198             sb.append( '/' ).append( artifact.getArtifactId() );
 199             if ( VersionUtil.isSnapshot( artifact.getVersion() ) )
 200             {
 201                 sb.append( '/' ).append( VersionUtil.getBaseVersion( artifact.getVersion() ) );
 202             }
 203             else
 204             {
 205                 sb.append( '/' ).append( artifact.getVersion() );
 206             }
 207             sb.append( '/' ).append( artifact.getArtifactId() );
 208             sb.append( '-' ).append( artifact.getVersion() );
 209             if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
 210             {
 211                 sb.append( '-' ).append( artifact.getClassifier() );
 212             }
 213             // maven-plugin packaging is a jar
 214             if ( StringUtils.equals( "maven-plugin", artifact.getPackaging() ) )
 215             {
 216                 sb.append( "jar" );
 217             }
 218             else
 219             {
 220                 sb.append( '.' ).append( artifact.getFileExtension() );
 221             }
 222
 223             return sb.toString();
 224         }
 225         catch ( RepositoryAdminException e )
 226         {
 227             throw new ArchivaRestServiceException( e.getMessage(),
 228                                                    Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
 229         }
 230     }
 231 }