This project has retired. For details please refer to its Attic page.
AbstractRestService xref
View Javadoc
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/facets/AuditEvent.html#AuditEvent">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         RepositoryTaskpository/model/RepositoryTask.html#RepositoryTask">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 }