This project has retired. For details please refer to its
Attic page.
DefaultArchivaAdministration xref
1 package org.apache.archiva.admin.repository.admin;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 import org.apache.archiva.admin.model.AuditInformation;
22 import org.apache.archiva.admin.model.RepositoryAdminException;
23 import org.apache.archiva.admin.model.admin.ArchivaAdministration;
24 import org.apache.archiva.admin.model.beans.*;
25 import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
26 import org.apache.archiva.configuration.Configuration;
27 import org.apache.archiva.configuration.UserInterfaceOptions;
28 import org.apache.archiva.configuration.WebappConfiguration;
29 import org.apache.archiva.metadata.model.facets.AuditEvent;
30 import org.apache.commons.text.StringEscapeUtils;
31 import org.apache.commons.lang3.StringUtils;
32 import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
33 import org.apache.maven.wagon.providers.http.HttpWagon;
34 import org.springframework.stereotype.Service;
35 import org.springframework.util.ResourceUtils;
36
37 import javax.annotation.PostConstruct;
38 import javax.annotation.PreDestroy;
39 import java.net.URI;
40 import java.net.URISyntaxException;
41 import java.util.ArrayList;
42 import java.util.Collections;
43 import java.util.List;
44
45
46
47
48 @Service( "archivaAdministration#default" )
49 public class DefaultArchivaAdministration
50 extends AbstractRepositoryAdmin
51 implements ArchivaAdministration
52 {
53
54 private PoolingHttpClientConnectionManager poolingClientConnectionManager;
55
56 @PostConstruct
57 public void initialize()
58 throws RepositoryAdminException
59 {
60
61 NetworkConfiguration networkConfiguration = getNetworkConfiguration();
62 setupWagon( networkConfiguration );
63 }
64
65 @PreDestroy
66 public void shutdown()
67 {
68 if ( this.poolingClientConnectionManager != null )
69 {
70 this.poolingClientConnectionManager.shutdown();
71 }
72 }
73
74
75 @Override
76 public List<LegacyArtifactPath> getLegacyArtifactPaths()
77 throws RepositoryAdminException
78 {
79 List<LegacyArtifactPath> legacyArtifactPaths = new ArrayList<>(
80 getArchivaConfiguration().getConfiguration().getLegacyArtifactPaths().size() );
81 for ( org.apache.archiva.configuration.LegacyArtifactPath legacyArtifactPath : getArchivaConfiguration().getConfiguration().getLegacyArtifactPaths() )
82 {
83 legacyArtifactPaths.add(
84 getModelMapper().map( legacyArtifactPath, LegacyArtifactPath.class ) );
85 }
86 return legacyArtifactPaths;
87 }
88
89 @Override
90 public void addLegacyArtifactPath( LegacyArtifactPath legacyArtifactPath, AuditInformation auditInformation )
91 throws RepositoryAdminException
92 {
93 Configuration configuration = getArchivaConfiguration().getConfiguration();
94
95 configuration.addLegacyArtifactPath( getModelMapper().map( legacyArtifactPath,
96 org.apache.archiva.configuration.LegacyArtifactPath.class ) );
97
98 saveConfiguration( configuration );
99 triggerAuditEvent( "", "", AuditEvent.ADD_LEGACY_PATH, auditInformation );
100 }
101
102 @Override
103 public void deleteLegacyArtifactPath( String path, AuditInformation auditInformation )
104 throws RepositoryAdminException
105 {
106 Configuration configuration = getArchivaConfiguration().getConfiguration();
107 org.apache.archiva.configuration.LegacyArtifactPath legacyArtifactPath =
108 new org.apache.archiva.configuration.LegacyArtifactPath();
109
110 legacyArtifactPath.setPath( path );
111 configuration.removeLegacyArtifactPath( legacyArtifactPath );
112
113 saveConfiguration( configuration );
114 triggerAuditEvent( "", "", AuditEvent.REMOVE_LEGACY_PATH, auditInformation );
115 }
116
117
118 @Override
119 public void addFileTypePattern( String fileTypeId, String pattern, AuditInformation auditInformation )
120 throws RepositoryAdminException
121 {
122 Configuration configuration = getArchivaConfiguration().getConfiguration();
123
124 org.apache.archiva.configuration.FileType fileType = getFileTypeById( fileTypeId, configuration );
125 if ( fileType == null )
126 {
127 return;
128 }
129
130 if ( fileType.getPatterns().contains( pattern ) )
131 {
132 throw new RepositoryAdminException(
133 "File type [" + fileTypeId + "] already contains pattern [" + pattern + "]" );
134 }
135 fileType.addPattern( pattern );
136
137 saveConfiguration( configuration );
138 triggerAuditEvent( "", "", AuditEvent.ADD_PATTERN, auditInformation );
139 }
140
141 @Override
142 public void removeFileTypePattern( String fileTypeId, String pattern, AuditInformation auditInformation )
143 throws RepositoryAdminException
144 {
145 Configuration configuration = getArchivaConfiguration().getConfiguration();
146
147 org.apache.archiva.configuration.FileType fileType = getFileTypeById( fileTypeId, configuration );
148 if ( fileType == null )
149 {
150 return;
151 }
152 fileType.removePattern( pattern );
153
154 saveConfiguration( configuration );
155 triggerAuditEvent( "", "", AuditEvent.REMOVE_PATTERN, auditInformation );
156 }
157
158 @Override
159 public FileType getFileType( String fileTypeId )
160 throws RepositoryAdminException
161 {
162 org.apache.archiva.configuration.FileType fileType =
163 getFileTypeById( fileTypeId, getArchivaConfiguration().getConfiguration() );
164 if ( fileType == null )
165 {
166 return null;
167 }
168 return getModelMapper().map( fileType, FileType.class );
169 }
170
171 @Override
172 public void addFileType( FileType fileType, AuditInformation auditInformation )
173 throws RepositoryAdminException
174 {
175 Configuration configuration = getArchivaConfiguration().getConfiguration();
176 if ( getFileTypeById( fileType.getId(), configuration ) != null )
177 {
178 throw new RepositoryAdminException(
179 "impossible to FileType with id " + fileType.getId() + " already exists" );
180 }
181
182 configuration.getRepositoryScanning().addFileType(
183 getModelMapper().map( fileType, org.apache.archiva.configuration.FileType.class ) );
184 saveConfiguration( configuration );
185 }
186
187 @Override
188 public void removeFileType( String fileTypeId, AuditInformation auditInformation )
189 throws RepositoryAdminException
190 {
191 Configuration configuration = getArchivaConfiguration().getConfiguration();
192 org.apache.archiva.configuration.FileType fileType = new org.apache.archiva.configuration.FileType();
193 fileType.setId( fileTypeId );
194 configuration.getRepositoryScanning().removeFileType( fileType );
195 saveConfiguration( configuration );
196 }
197
198 @Override
199 public void addKnownContentConsumer( String knownContentConsumer, AuditInformation auditInformation )
200 throws RepositoryAdminException
201 {
202 Configuration configuration = getArchivaConfiguration().getConfiguration();
203 if ( configuration.getRepositoryScanning().getKnownContentConsumers().contains( knownContentConsumer ) )
204 {
205 log.warn( "skip adding knownContentConsumer {} as already here", knownContentConsumer );
206 return;
207 }
208 configuration.getRepositoryScanning().addKnownContentConsumer( knownContentConsumer );
209 saveConfiguration( configuration );
210 triggerAuditEvent( "", "", AuditEvent.ENABLE_REPO_CONSUMER, auditInformation );
211 }
212
213 @Override
214 public void removeKnownContentConsumer( String knownContentConsumer, AuditInformation auditInformation )
215 throws RepositoryAdminException
216 {
217 Configuration configuration = getArchivaConfiguration().getConfiguration();
218 configuration.getRepositoryScanning().removeKnownContentConsumer( knownContentConsumer );
219 saveConfiguration( configuration );
220 triggerAuditEvent( "", "", AuditEvent.DISABLE_REPO_CONSUMER, auditInformation );
221 }
222
223 @Override
224 public void addInvalidContentConsumer( String invalidContentConsumer, AuditInformation auditInformation )
225 throws RepositoryAdminException
226 {
227 Configuration configuration = getArchivaConfiguration().getConfiguration();
228 if ( configuration.getRepositoryScanning().getInvalidContentConsumers().contains( invalidContentConsumer ) )
229 {
230 log.warn( "skip adding invalidContentConsumer {} as already here", invalidContentConsumer );
231 return;
232 }
233 configuration.getRepositoryScanning().addInvalidContentConsumer( invalidContentConsumer );
234 saveConfiguration( configuration );
235 triggerAuditEvent( "", "", AuditEvent.ENABLE_REPO_CONSUMER, auditInformation );
236 }
237
238 @Override
239 public void removeInvalidContentConsumer( String invalidContentConsumer, AuditInformation auditInformation )
240 throws RepositoryAdminException
241 {
242 Configuration configuration = getArchivaConfiguration().getConfiguration();
243 configuration.getRepositoryScanning().removeInvalidContentConsumer( invalidContentConsumer );
244 saveConfiguration( configuration );
245 triggerAuditEvent( "", "", AuditEvent.DISABLE_REPO_CONSUMER, auditInformation );
246 }
247
248 @Override
249 public void setKnownContentConsumers( List<String> knownContentConsumers, AuditInformation auditInformation )
250 throws RepositoryAdminException
251 {
252 if ( knownContentConsumers == null )
253 {
254 return;
255 }
256 for ( String knowContentConsumer : knownContentConsumers )
257 {
258 addKnownContentConsumer( knowContentConsumer, auditInformation );
259 }
260 }
261
262 @Override
263 public void setInvalidContentConsumers( List<String> invalidContentConsumers, AuditInformation auditInformation )
264 throws RepositoryAdminException
265 {
266 if ( invalidContentConsumers == null )
267 {
268 return;
269 }
270 for ( String invalidContentConsumer : invalidContentConsumers )
271 {
272 addKnownContentConsumer( invalidContentConsumer, auditInformation );
273 }
274 }
275
276 @Override
277 public List<FileType> getFileTypes()
278 throws RepositoryAdminException
279 {
280 List<org.apache.archiva.configuration.FileType> configFileTypes =
281 getArchivaConfiguration().getConfiguration().getRepositoryScanning().getFileTypes();
282 if ( configFileTypes == null || configFileTypes.isEmpty() )
283 {
284 return Collections.emptyList();
285 }
286 List<FileType> fileTypes = new ArrayList<>( configFileTypes.size() );
287 for ( org.apache.archiva.configuration.FileType fileType : configFileTypes )
288 {
289 fileTypes.add( getModelMapper().map( fileType, FileType.class ) );
290 }
291 return fileTypes;
292 }
293
294 @Override
295 public List<String> getKnownContentConsumers()
296 throws RepositoryAdminException
297 {
298 return new ArrayList<>(
299 getArchivaConfiguration().getConfiguration().getRepositoryScanning().getKnownContentConsumers() );
300 }
301
302 @Override
303 public List<String> getInvalidContentConsumers()
304 throws RepositoryAdminException
305 {
306 return new ArrayList<>(
307 getArchivaConfiguration().getConfiguration().getRepositoryScanning().getInvalidContentConsumers() );
308 }
309
310 @Override
311 public OrganisationInformation getOrganisationInformation()
312 throws RepositoryAdminException
313 {
314 org.apache.archiva.configuration.OrganisationInformation organisationInformation =
315 getArchivaConfiguration().getConfiguration().getOrganisationInfo();
316 if ( organisationInformation == null )
317 {
318 return null;
319 }
320 return getModelMapper().map( organisationInformation, OrganisationInformation.class );
321 }
322
323 private String fixUrl(String url, String propertyName) throws RepositoryAdminException {
324 if ( StringUtils.isNotEmpty( url ) )
325 {
326 if ( !ResourceUtils.isUrl( url ) )
327 {
328 throw new RepositoryAdminException( "Bad URL in " + propertyName + ": " + url );
329 }
330 try {
331 URI urlToCheck = new URI(url);
332 return urlToCheck.toString();
333 } catch (URISyntaxException e) {
334 throw new RepositoryAdminException( "Bad URL in " + propertyName + ": " + url );
335 }
336 }
337 return url;
338
339 }
340
341 private String convertName(String name) {
342 return StringEscapeUtils.escapeHtml4( StringUtils.trimToEmpty( name ) );
343 }
344
345 @Override
346 public void setOrganisationInformation( OrganisationInformation organisationInformation )
347 throws RepositoryAdminException
348 {
349
350 organisationInformation.setUrl(fixUrl(organisationInformation.getUrl(), "url"));
351 organisationInformation.setLogoLocation(fixUrl( organisationInformation.getLogoLocation(), "logoLocation" ));
352 Configuration configuration = getArchivaConfiguration( ).getConfiguration( );
353 if ( organisationInformation != null )
354 {
355 organisationInformation.setName( convertName( organisationInformation.getName() ));
356 org.apache.archiva.configuration.OrganisationInformation organisationInformationModel =
357 getModelMapper( ).map( organisationInformation,
358 org.apache.archiva.configuration.OrganisationInformation.class );
359 configuration.setOrganisationInfo( organisationInformationModel );
360 }
361 else
362 {
363 configuration.setOrganisationInfo( null );
364 }
365 saveConfiguration( configuration );
366 }
367
368 @Override
369 public UiConfiguration getUiConfiguration()
370 throws RepositoryAdminException
371 {
372 WebappConfiguration webappConfiguration = getArchivaConfiguration().getConfiguration().getWebapp();
373 if ( webappConfiguration == null )
374 {
375 return null;
376 }
377 UserInterfaceOptions userInterfaceOptions = webappConfiguration.getUi();
378 if ( userInterfaceOptions == null )
379 {
380 return null;
381 }
382 return getModelMapper().map( userInterfaceOptions, UiConfiguration.class );
383 }
384
385 @Override
386 public void updateUiConfiguration( UiConfiguration uiConfiguration )
387 throws RepositoryAdminException
388 {
389 Configuration configuration = getArchivaConfiguration().getConfiguration();
390 if ( uiConfiguration != null )
391 {
392
393 UserInterfaceOptions userInterfaceOptions =
394 getModelMapper().map( uiConfiguration, UserInterfaceOptions.class );
395 configuration.getWebapp().setUi( userInterfaceOptions );
396 }
397 else
398 {
399 configuration.getWebapp().setUi( null );
400 }
401 saveConfiguration( configuration );
402
403 }
404
405 @Override
406 public NetworkConfiguration getNetworkConfiguration()
407 throws RepositoryAdminException
408 {
409 org.apache.archiva.configuration.NetworkConfiguration networkConfiguration =
410 getArchivaConfiguration().getConfiguration().getNetworkConfiguration();
411
412 if ( networkConfiguration == null )
413 {
414 return null;
415 }
416 return getModelMapper().map( networkConfiguration, NetworkConfiguration.class );
417 }
418
419 @Override
420 public void setNetworkConfiguration( NetworkConfiguration networkConfiguration )
421 throws RepositoryAdminException
422 {
423 Configuration configuration = getArchivaConfiguration().getConfiguration();
424 if ( networkConfiguration == null )
425 {
426 configuration.setNetworkConfiguration( null );
427 }
428 else
429 {
430 configuration.setNetworkConfiguration( getModelMapper().map( networkConfiguration,
431 org.apache.archiva.configuration.NetworkConfiguration.class ) );
432 }
433 setupWagon( networkConfiguration );
434 saveConfiguration( configuration );
435 }
436
437 protected void setupWagon( NetworkConfiguration networkConfiguration )
438 {
439 if ( networkConfiguration == null )
440 {
441
442 HttpWagon.setPersistentPool( true );
443 poolingClientConnectionManager = new PoolingHttpClientConnectionManager();
444 poolingClientConnectionManager.setDefaultMaxPerRoute( 30 );
445 poolingClientConnectionManager.setMaxTotal( 30 );
446 HttpWagon.setPoolingHttpClientConnectionManager( poolingClientConnectionManager );
447
448 }
449 else
450 {
451 HttpWagon.setPersistentPool( networkConfiguration.isUsePooling() );
452 poolingClientConnectionManager = new PoolingHttpClientConnectionManager();
453 poolingClientConnectionManager.setDefaultMaxPerRoute( networkConfiguration.getMaxTotalPerHost() );
454 poolingClientConnectionManager.setMaxTotal( networkConfiguration.getMaxTotal() );
455 HttpWagon.setPoolingHttpClientConnectionManager( poolingClientConnectionManager );
456 }
457 }
458
459
460
461
462
463 private org.apache.archiva.configuration.FileType getFileTypeById( String id, Configuration configuration )
464 {
465 for ( org.apache.archiva.configuration.FileType fileType : configuration.getRepositoryScanning().getFileTypes() )
466 {
467 if ( StringUtils.equals( id, fileType.getId() ) )
468 {
469 return fileType;
470 }
471 }
472 return null;
473 }
474
475 }