This project has retired. For details please refer to its
Attic page.
1 package org.apache.archiva.rest.services;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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.managed.ManagedRepositoryAdmin;
27 import org.apache.archiva.admin.model.proxyconnector.ProxyConnectorAdmin;
28 import org.apache.archiva.metadata.model.facets.AuditEvent;
29 import org.apache.archiva.repository.events.AuditListener;
30 import org.apache.archiva.common.utils.VersionUtil;
31 import org.apache.archiva.indexer.search.SearchResultHit;
32 import org.apache.archiva.maven2.model.Artifact;
33 import org.apache.archiva.metadata.model.ArtifactMetadata;
34 import org.apache.archiva.metadata.repository.RepositorySessionFactory;
35 import org.apache.archiva.redback.components.taskqueue.TaskQueueException;
36 import org.apache.archiva.redback.configuration.UserConfiguration;
37 import org.apache.archiva.redback.configuration.UserConfigurationKeys;
38 import org.apache.archiva.redback.rest.services.RedbackAuthenticationThreadLocal;
39 import org.apache.archiva.redback.rest.services.RedbackRequestInformation;
40 import org.apache.archiva.redback.users.User;
41 import org.apache.archiva.repository.RepositoryContentFactory;
42 import org.apache.archiva.repository.RepositoryException;
43 import org.apache.archiva.rest.api.services.ArchivaRestServiceException;
44 import org.apache.archiva.rest.services.utils.ArtifactBuilder;
45 import org.apache.archiva.scheduler.repository.DefaultRepositoryArchivaTaskScheduler;
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.lang.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
67 import java.util.ArrayList;
68 import java.util.Collection;
69 import java.util.Collections;
70 import java.util.HashMap;
71 import java.util.List;
72 import java.util.Map;
73
74
75
76
77
78
79
80 public abstract class AbstractRestService
81 {
82
83 protected final Logger log = LoggerFactory.getLogger( getClass() );
84
85 @Inject
86 private List<AuditListener> auditListeners = new ArrayList<>();
87
88 @Inject
89 protected UserRepositories userRepositories;
90
91
92
93
94
95 @Inject
96 @Named(value = "repositorySessionFactory")
97 protected RepositorySessionFactory repositorySessionFactory;
98
99 @Inject
100 protected ArchivaAdministration archivaAdministration;
101
102 @Inject
103 protected ProxyConnectorAdmin proxyConnectorAdmin;
104
105 @Inject
106 protected ManagedRepositoryAdmin managedRepositoryAdmin;
107
108 @Inject
109 protected RepositoryContentFactory repositoryContentFactory;
110
111 @Inject
112 @Named(value = "archivaTaskScheduler#repository")
113 protected RepositoryArchivaTaskScheduler repositoryTaskScheduler;
114
115
116 @Inject
117 @Named(value = "userConfiguration#default")
118 protected UserConfiguration config;
119
120 @Context
121 protected HttpServletRequest httpServletRequest;
122
123 @Context
124 protected HttpServletResponse httpServletResponse;
125
126 protected AuditInformation getAuditInformation()
127 {
128 RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
129 User user = redbackRequestInformation == null ? null : redbackRequestInformation.getUser();
130 String remoteAddr = redbackRequestInformation == null ? null : redbackRequestInformation.getRemoteAddr();
131 return new AuditInformation( user, remoteAddr );
132 }
133
134 public List<AuditListener> getAuditListeners()
135 {
136 return auditListeners;
137 }
138
139 public void setAuditListeners( List<AuditListener> auditListeners )
140 {
141 this.auditListeners = auditListeners;
142 }
143
144 protected List<String> getObservableRepos()
145 {
146 try
147 {
148 List<String> ids = userRepositories.getObservableRepositoryIds( getPrincipal() );
149 return ids == null ? Collections.<String>emptyList() : ids;
150 }
151 catch ( PrincipalNotFoundException e )
152 {
153 log.warn( e.getMessage(), e );
154 }
155 catch ( AccessDeniedException e )
156 {
157 log.warn( e.getMessage(), e );
158 }
159 catch ( ArchivaSecurityException e )
160 {
161 log.warn( e.getMessage(), e );
162 }
163 return Collections.emptyList();
164 }
165
166 protected String getPrincipal()
167 {
168 RedbackRequestInformation redbackRequestInformation = RedbackAuthenticationThreadLocal.get();
169
170 return redbackRequestInformation == null
171 ? config.getString( UserConfigurationKeys.DEFAULT_GUEST )
172 : ( redbackRequestInformation.getUser() == null
173 ? config.getString( UserConfigurationKeys.DEFAULT_GUEST )
174 : redbackRequestInformation.getUser().getUsername() );
175 }
176
177 protected String getBaseUrl()
178 throws RepositoryAdminException
179 {
180 String applicationUrl = archivaAdministration.getUiConfiguration().getApplicationUrl();
181 if ( StringUtils.isNotBlank( applicationUrl ) )
182 {
183 return applicationUrl;
184 }
185 return httpServletRequest.getScheme() + "://" + httpServletRequest.getServerName() + (
186 httpServletRequest.getServerPort() == 80 ? "" : ":" + httpServletRequest.getServerPort() )
187 + httpServletRequest.getContextPath();
188 }
189
190 protected <T> Map<String, T> getBeansOfType( ApplicationContext applicationContext, Class<T> clazz )
191 {
192
193
194
195 Map<String, T> springBeans = applicationContext.getBeansOfType( clazz );
196
197 Map<String, T> beans = new HashMap<>( springBeans.size() );
198
199 for ( Map.Entry<String, T> entry : springBeans.entrySet() )
200 {
201 String key = StringUtils.contains( entry.getKey(), '#' )
202 ? StringUtils.substringAfterLast( entry.getKey(), "#" )
203 : entry.getKey();
204 beans.put( key, entry.getValue() );
205 }
206 return beans;
207 }
208
209 protected void triggerAuditEvent( String repositoryId, String filePath, String action )
210 {
211 AuditEvent auditEvent = new AuditEvent( repositoryId, getPrincipal(), filePath, action );
212 AuditInformation auditInformation = getAuditInformation();
213 auditEvent.setUserId( auditInformation.getUser() == null ? "" : auditInformation.getUser().getUsername() );
214 auditEvent.setRemoteIP( auditInformation.getRemoteAddr() );
215 for ( AuditListener auditListener : getAuditListeners() )
216 {
217 auditListener.auditEvent( auditEvent );
218 }
219 }
220
221
222
223
224
225 protected String getArtifactUrl( Artifact artifact )
226 throws ArchivaRestServiceException
227 {
228 return getArtifactUrl( artifact, null );
229 }
230
231
232 protected String getArtifactUrl( Artifact artifact, String repositoryId )
233 throws ArchivaRestServiceException
234 {
235 log.debug( "Getting artifact url {}", artifact );
236 log.debug( "Getting artifact context {}", artifact.getContext() );
237 try
238 {
239
240 if ( httpServletRequest == null )
241 {
242 return null;
243 }
244
245 StringBuilder sb = new StringBuilder( getBaseUrl() );
246
247 sb.append( "/repository" );
248
249
250
251
252 if ( StringUtils.isEmpty( repositoryId ) )
253 {
254 List<String> userRepos = userRepositories.getObservableRepositoryIds( getPrincipal() );
255 log.debug( "Available repositories: {}", StringUtils.join( userRepos, "," ) );
256
257
258 boolean found = false;
259 if ( !userRepos.contains( artifact.getContext() ) )
260 {
261 for ( Map.Entry<String, List<ProxyConnector>> entry : proxyConnectorAdmin.getProxyConnectorAsMap().entrySet() )
262 {
263 for ( ProxyConnector proxyConnector : entry.getValue() )
264 {
265 if ( StringUtils.equals( "remote-" + proxyConnector.getTargetRepoId(),
266 artifact.getContext() )
267 && userRepos.contains( entry.getKey() ) )
268 {
269 sb.append( '/' ).append( entry.getKey() );
270 found = true;
271 break;
272 }
273 }
274 if (found) {
275 break;
276 }
277 }
278 if (!found) {
279 sb.append( '/' ).append( artifact.getRepositoryId( ) );
280 }
281
282 }
283 else
284 {
285 sb.append( '/' ).append( artifact.getContext() );
286 }
287
288
289 }
290 else
291 {
292 sb.append( '/' ).append( repositoryId );
293 }
294
295 sb.append( '/' ).append( StringUtils.replaceChars( artifact.getGroupId(), '.', '/' ) );
296 sb.append( '/' ).append( artifact.getArtifactId() );
297 if ( VersionUtil.isSnapshot( artifact.getVersion() ) )
298 {
299 sb.append( '/' ).append( VersionUtil.getBaseVersion( artifact.getVersion() ) );
300 }
301 else
302 {
303 sb.append( '/' ).append( artifact.getVersion() );
304 }
305 sb.append( '/' ).append( artifact.getArtifactId() );
306 sb.append( '-' ).append( artifact.getVersion() );
307 if ( StringUtils.isNotBlank( artifact.getClassifier() ) )
308 {
309 sb.append( '-' ).append( artifact.getClassifier() );
310 }
311
312 if ( StringUtils.equals( "maven-plugin", artifact.getPackaging() ) )
313 {
314 sb.append( "jar" );
315 }
316 else
317 {
318 sb.append( '.' ).append( artifact.getFileExtension() );
319 }
320
321 return sb.toString();
322 }
323 catch ( Exception e )
324 {
325 throw new ArchivaRestServiceException( e.getMessage(),
326 Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
327 }
328 }
329
330 protected List<Artifact> buildArtifacts( Collection<ArtifactMetadata> artifactMetadatas, String repositoryId )
331 throws ArchivaRestServiceException
332 {
333 try
334 {
335 if ( artifactMetadatas != null && !artifactMetadatas.isEmpty() )
336 {
337 List<Artifact> artifacts = new ArrayList<>( artifactMetadatas.size() );
338 for ( ArtifactMetadata artifact : artifactMetadatas )
339 {
340
341 String repoId = repositoryId != null ? repositoryId : artifact.getRepositoryId();
342 if ( repoId == null ) {
343 throw new IllegalStateException( "Repository Id is null" );
344 }
345
346 ArtifactBuilder builder =
347 new ArtifactBuilder().forArtifactMetadata( artifact ).withManagedRepositoryContent(
348 repositoryContentFactory.getManagedRepositoryContent( repoId ) );
349 Artifact art = builder.build();
350 art.setUrl( getArtifactUrl( art, repositoryId ) );
351 artifacts.add( art );
352 }
353 return artifacts;
354 }
355 return Collections.emptyList();
356 }
357 catch ( RepositoryException e )
358 {
359 log.error( e.getMessage(), e );
360 throw new ArchivaRestServiceException( e.getMessage(),
361 Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), e );
362 }
363 }
364
365 protected Boolean doScanRepository( String repositoryId, boolean fullScan )
366 {
367 if ( repositoryTaskScheduler.isProcessingRepositoryTask( repositoryId ) )
368 {
369 log.info( "scanning of repository with id {} already scheduled", repositoryId );
370 return Boolean.FALSE;
371 }
372 RepositoryTask task = new RepositoryTask();
373 task.setRepositoryId( repositoryId );
374 task.setScanAll( fullScan );
375 try
376 {
377 repositoryTaskScheduler.queueTask( task );
378 }
379 catch ( TaskQueueException e )
380 {
381 log.error( "failed to schedule scanning of repo with id {}", repositoryId, e );
382 return false;
383 }
384 return true;
385 }
386
387 private static class ModelMapperHolder
388 {
389 private static ModelMapper MODEL_MAPPER = new ModelMapper();
390
391 static
392 {
393 MODEL_MAPPER.addMappings( new SearchResultHitMap() );
394 MODEL_MAPPER.getConfiguration().setMatchingStrategy( MatchingStrategies.STRICT );
395 }
396 }
397
398
399 private static class SearchResultHitMap
400 extends PropertyMap<SearchResultHit, Artifact>
401 {
402 @Override
403 protected void configure()
404 {
405 skip().setId( null );
406 }
407 }
408
409 ;
410
411 protected ModelMapper getModelMapper()
412 {
413 return ModelMapperHolder.MODEL_MAPPER;
414 }
415 }