This project has retired. For details please refer to its Attic page.
Source code 
001package org.apache.archiva.admin.repository.admin;
002/*
003 * Licensed to the Apache Software Foundation (ASF) under one
004 * or more contributor license agreements.  See the NOTICE file
005 * distributed with this work for additional information
006 * regarding copyright ownership.  The ASF licenses this file
007 * to you under the Apache License, Version 2.0 (the
008 * "License"); you may not use this file except in compliance
009 * with the License.  You may obtain a copy of the License at
010 *
011 *   http://www.apache.org/licenses/LICENSE-2.0
012 *
013 * Unless required by applicable law or agreed to in writing,
014 * software distributed under the License is distributed on an
015 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
016 * KIND, either express or implied.  See the License for the
017 * specific language governing permissions and limitations
018 * under the License.
019 */
020
021import org.apache.archiva.admin.model.AuditInformation;
022import org.apache.archiva.admin.model.RepositoryAdminException;
023import org.apache.archiva.admin.model.admin.ArchivaAdministration;
024import org.apache.archiva.admin.model.beans.*;
025import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
026import org.apache.archiva.configuration.Configuration;
027import org.apache.archiva.configuration.UserInterfaceOptions;
028import org.apache.archiva.configuration.WebappConfiguration;
029import org.apache.archiva.metadata.model.facets.AuditEvent;
030import org.apache.commons.text.StringEscapeUtils;
031import org.apache.commons.lang3.StringUtils;
032import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
033import org.apache.maven.wagon.providers.http.HttpWagon;
034import org.springframework.stereotype.Service;
035import org.springframework.util.ResourceUtils;
036
037import javax.annotation.PostConstruct;
038import javax.annotation.PreDestroy;
039import java.net.URI;
040import java.net.URISyntaxException;
041import java.util.ArrayList;
042import java.util.Collections;
043import java.util.List;
044
045/**
046 * @author Olivier Lamy
047 */
048@Service( "archivaAdministration#default" )
049public class DefaultArchivaAdministration
050    extends AbstractRepositoryAdmin
051    implements ArchivaAdministration
052{
053
054    private PoolingHttpClientConnectionManager poolingClientConnectionManager;
055
056    @PostConstruct
057    public void initialize()
058        throws RepositoryAdminException
059    {
060        // setup wagon on start with initial values
061        NetworkConfiguration networkConfiguration = getNetworkConfiguration();
062        setupWagon( networkConfiguration );
063    }
064
065    @PreDestroy
066    public void shutdown()
067    {
068        if ( this.poolingClientConnectionManager != null )
069        {
070            this.poolingClientConnectionManager.shutdown();
071        }
072    }
073
074
075    @Override
076    public List<LegacyArtifactPath> getLegacyArtifactPaths()
077        throws RepositoryAdminException
078    {
079        List<LegacyArtifactPath> legacyArtifactPaths = new ArrayList<>(
080            getArchivaConfiguration().getConfiguration().getLegacyArtifactPaths().size() );
081        for ( org.apache.archiva.configuration.LegacyArtifactPath legacyArtifactPath : getArchivaConfiguration().getConfiguration().getLegacyArtifactPaths() )
082        {
083            legacyArtifactPaths.add(
084                getModelMapper().map( legacyArtifactPath, LegacyArtifactPath.class ) );
085        }
086        return legacyArtifactPaths;
087    }
088
089    @Override
090    public void addLegacyArtifactPath( LegacyArtifactPath legacyArtifactPath, AuditInformation auditInformation )
091        throws RepositoryAdminException
092    {
093        Configuration configuration = getArchivaConfiguration().getConfiguration();
094
095        configuration.addLegacyArtifactPath( getModelMapper().map( legacyArtifactPath,
096                                                                   org.apache.archiva.configuration.LegacyArtifactPath.class ) );
097
098        saveConfiguration( configuration );
099        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}