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