This project has retired. For details please refer to its Attic page.
DefaultArchivaAdministration xref
View Javadoc
1   package org.apache.archiva.admin.repository.admin;
2   /*
3    * Licensed to the Apache Software Foundation (ASF) under one
4    * or more contributor license agreements.  See the NOTICE file
5    * distributed with this work for additional information
6    * regarding copyright ownership.  The ASF licenses this file
7    * to you under the Apache License, Version 2.0 (the
8    * "License"); you may not use this file except in compliance
9    * with the License.  You may obtain a copy of the License at
10   *
11   *   http://www.apache.org/licenses/LICENSE-2.0
12   *
13   * Unless required by applicable law or agreed to in writing,
14   * software distributed under the License is distributed on an
15   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16   * KIND, either express or implied.  See the License for the
17   * specific language governing permissions and limitations
18   * under the License.
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   * @author Olivier Lamy
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          // setup wagon on start with initial values
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             // back to default values
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 }