001 package 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
021 import net.sf.beanlib.provider.replicator.BeanReplicator;
022 import org.apache.archiva.admin.model.AuditInformation;
023 import org.apache.archiva.admin.model.RepositoryAdminException;
024 import org.apache.archiva.admin.model.admin.ArchivaAdministration;
025 import org.apache.archiva.admin.model.beans.FileType;
026 import org.apache.archiva.admin.model.beans.LegacyArtifactPath;
027 import org.apache.archiva.admin.model.beans.NetworkConfiguration;
028 import org.apache.archiva.admin.model.beans.OrganisationInformation;
029 import org.apache.archiva.admin.model.beans.UiConfiguration;
030 import org.apache.archiva.admin.repository.AbstractRepositoryAdmin;
031 import org.apache.archiva.audit.AuditEvent;
032 import org.apache.archiva.configuration.Configuration;
033 import org.apache.archiva.configuration.UserInterfaceOptions;
034 import org.apache.archiva.configuration.WebappConfiguration;
035 import org.apache.commons.lang.StringUtils;
036 import org.apache.http.impl.conn.PoolingClientConnectionManager;
037 import org.apache.maven.wagon.providers.http.HttpWagon;
038 import org.springframework.stereotype.Service;
039
040 import javax.annotation.PostConstruct;
041 import javax.annotation.PreDestroy;
042 import java.util.ArrayList;
043 import java.util.Collections;
044 import java.util.List;
045
046 /**
047 * @author Olivier Lamy
048 */
049 @Service( "archivaAdministration#default" )
050 public class DefaultArchivaAdministration
051 extends AbstractRepositoryAdmin
052 implements ArchivaAdministration
053 {
054
055 private PoolingClientConnectionManager poolingClientConnectionManager;
056
057 @PostConstruct
058 public void initialize()
059 throws RepositoryAdminException
060 {
061 // setup wagon on start with initial values
062 NetworkConfiguration networkConfiguration = getNetworkConfiguration();
063 setupWagon( networkConfiguration );
064 }
065
066 @PreDestroy
067 public void shutdown()
068 {
069 if ( this.poolingClientConnectionManager != null )
070 {
071 this.poolingClientConnectionManager.shutdown();
072 }
073 }
074
075
076 public List<LegacyArtifactPath> getLegacyArtifactPaths()
077 throws RepositoryAdminException
078 {
079 List<LegacyArtifactPath> legacyArtifactPaths = new ArrayList<LegacyArtifactPath>(
080 getArchivaConfiguration().getConfiguration().getLegacyArtifactPaths().size() );
081 for ( org.apache.archiva.configuration.LegacyArtifactPath legacyArtifactPath : getArchivaConfiguration().getConfiguration().getLegacyArtifactPaths() )
082 {
083 legacyArtifactPaths.add(
084 new BeanReplicator().replicateBean( legacyArtifactPath, LegacyArtifactPath.class ) );
085 }
086 return legacyArtifactPaths;
087 }
088
089 public void addLegacyArtifactPath( LegacyArtifactPath legacyArtifactPath, AuditInformation auditInformation )
090 throws RepositoryAdminException
091 {
092 Configuration configuration = getArchivaConfiguration().getConfiguration();
093
094 configuration.addLegacyArtifactPath( new BeanReplicator().replicateBean( legacyArtifactPath,
095 org.apache.archiva.configuration.LegacyArtifactPath.class ) );
096
097 saveConfiguration( configuration );
098 triggerAuditEvent( "", "", AuditEvent.ADD_LEGACY_PATH, auditInformation );
099 }
100
101 public void deleteLegacyArtifactPath( String path, AuditInformation auditInformation )
102 throws RepositoryAdminException
103 {
104 Configuration configuration = getArchivaConfiguration().getConfiguration();
105 org.apache.archiva.configuration.LegacyArtifactPath legacyArtifactPath =
106 new org.apache.archiva.configuration.LegacyArtifactPath();
107
108 legacyArtifactPath.setPath( path );
109 configuration.removeLegacyArtifactPath( legacyArtifactPath );
110
111 saveConfiguration( configuration );
112 triggerAuditEvent( "", "", AuditEvent.REMOVE_LEGACY_PATH, auditInformation );
113 }
114
115
116 public void addFileTypePattern( String fileTypeId, String pattern, AuditInformation auditInformation )
117 throws RepositoryAdminException
118 {
119 Configuration configuration = getArchivaConfiguration().getConfiguration();
120
121 org.apache.archiva.configuration.FileType fileType = getFileTypeById( fileTypeId, configuration );
122 if ( fileType == null )
123 {
124 return;
125 }
126
127 if ( fileType.getPatterns().contains( pattern ) )
128 {
129 throw new RepositoryAdminException(
130 "File type [" + fileTypeId + "] already contains pattern [" + pattern + "]" );
131 }
132 fileType.addPattern( pattern );
133
134 saveConfiguration( configuration );
135 triggerAuditEvent( "", "", AuditEvent.ADD_PATTERN, auditInformation );
136 }
137
138 public void removeFileTypePattern( String fileTypeId, String pattern, AuditInformation auditInformation )
139 throws RepositoryAdminException
140 {
141 Configuration configuration = getArchivaConfiguration().getConfiguration();
142
143 org.apache.archiva.configuration.FileType fileType = getFileTypeById( fileTypeId, configuration );
144 if ( fileType == null )
145 {
146 return;
147 }
148 fileType.removePattern( pattern );
149
150 saveConfiguration( configuration );
151 triggerAuditEvent( "", "", AuditEvent.REMOVE_PATTERN, auditInformation );
152 }
153
154 public FileType getFileType( String fileTypeId )
155 throws RepositoryAdminException
156 {
157 org.apache.archiva.configuration.FileType fileType =
158 getFileTypeById( fileTypeId, getArchivaConfiguration().getConfiguration() );
159 if ( fileType == null )
160 {
161 return null;
162 }
163 return new BeanReplicator().replicateBean( fileType, FileType.class );
164 }
165
166 public void addFileType( FileType fileType, AuditInformation auditInformation )
167 throws RepositoryAdminException
168 {
169 Configuration configuration = getArchivaConfiguration().getConfiguration();
170 if ( getFileTypeById( fileType.getId(), configuration ) != null )
171 {
172 throw new RepositoryAdminException(
173 "impossible to FileType with id " + fileType.getId() + " already exists" );
174 }
175
176 configuration.getRepositoryScanning().addFileType(
177 new BeanReplicator().replicateBean( fileType, org.apache.archiva.configuration.FileType.class ) );
178 saveConfiguration( configuration );
179 }
180
181 public void removeFileType( String fileTypeId, AuditInformation auditInformation )
182 throws RepositoryAdminException
183 {
184 Configuration configuration = getArchivaConfiguration().getConfiguration();
185 org.apache.archiva.configuration.FileType fileType = new org.apache.archiva.configuration.FileType();
186 fileType.setId( fileTypeId );
187 configuration.getRepositoryScanning().removeFileType( fileType );
188 saveConfiguration( configuration );
189 }
190
191 public void addKnownContentConsumer( String knownContentConsumer, AuditInformation auditInformation )
192 throws RepositoryAdminException
193 {
194 Configuration configuration = getArchivaConfiguration().getConfiguration();
195 if ( configuration.getRepositoryScanning().getKnownContentConsumers().contains( knownContentConsumer ) )
196 {
197 log.warn( "skip adding knownContentConsumer {} as already here", knownContentConsumer );
198 return;
199 }
200 configuration.getRepositoryScanning().addKnownContentConsumer( knownContentConsumer );
201 saveConfiguration( configuration );
202 triggerAuditEvent( "", "", AuditEvent.ENABLE_REPO_CONSUMER, auditInformation );
203 }
204
205 public void removeKnownContentConsumer( String knownContentConsumer, AuditInformation auditInformation )
206 throws RepositoryAdminException
207 {
208 Configuration configuration = getArchivaConfiguration().getConfiguration();
209 configuration.getRepositoryScanning().removeKnownContentConsumer( knownContentConsumer );
210 saveConfiguration( configuration );
211 triggerAuditEvent( "", "", AuditEvent.DISABLE_REPO_CONSUMER, auditInformation );
212 }
213
214 public void addInvalidContentConsumer( String invalidContentConsumer, AuditInformation auditInformation )
215 throws RepositoryAdminException
216 {
217 Configuration configuration = getArchivaConfiguration().getConfiguration();
218 if ( configuration.getRepositoryScanning().getInvalidContentConsumers().contains( invalidContentConsumer ) )
219 {
220 log.warn( "skip adding invalidContentConsumer {} as already here", invalidContentConsumer );
221 return;
222 }
223 configuration.getRepositoryScanning().addInvalidContentConsumer( invalidContentConsumer );
224 saveConfiguration( configuration );
225 triggerAuditEvent( "", "", AuditEvent.ENABLE_REPO_CONSUMER, auditInformation );
226 }
227
228 public void removeInvalidContentConsumer( String invalidContentConsumer, AuditInformation auditInformation )
229 throws RepositoryAdminException
230 {
231 Configuration configuration = getArchivaConfiguration().getConfiguration();
232 configuration.getRepositoryScanning().removeInvalidContentConsumer( invalidContentConsumer );
233 saveConfiguration( configuration );
234 triggerAuditEvent( "", "", AuditEvent.DISABLE_REPO_CONSUMER, auditInformation );
235 }
236
237 public void setKnownContentConsumers( List<String> knownContentConsumers, AuditInformation auditInformation )
238 throws RepositoryAdminException
239 {
240 if ( knownContentConsumers == null )
241 {
242 return;
243 }
244 for ( String knowContentConsumer : knownContentConsumers )
245 {
246 addKnownContentConsumer( knowContentConsumer, auditInformation );
247 }
248 }
249
250 public void setInvalidContentConsumers( List<String> invalidContentConsumers, AuditInformation auditInformation )
251 throws RepositoryAdminException
252 {
253 if ( invalidContentConsumers == null )
254 {
255 return;
256 }
257 for ( String invalidContentConsumer : invalidContentConsumers )
258 {
259 addKnownContentConsumer( invalidContentConsumer, auditInformation );
260 }
261 }
262
263 public List<FileType> getFileTypes()
264 throws RepositoryAdminException
265 {
266 List<org.apache.archiva.configuration.FileType> configFileTypes =
267 getArchivaConfiguration().getConfiguration().getRepositoryScanning().getFileTypes();
268 if ( configFileTypes == null || configFileTypes.isEmpty() )
269 {
270 return Collections.emptyList();
271 }
272 List<FileType> fileTypes = new ArrayList<FileType>( configFileTypes.size() );
273 for ( org.apache.archiva.configuration.FileType fileType : configFileTypes )
274 {
275 fileTypes.add( new BeanReplicator().replicateBean( fileType, FileType.class ) );
276 }
277 return fileTypes;
278 }
279
280 public List<String> getKnownContentConsumers()
281 throws RepositoryAdminException
282 {
283 return new ArrayList<String>(
284 getArchivaConfiguration().getConfiguration().getRepositoryScanning().getKnownContentConsumers() );
285 }
286
287 public List<String> getInvalidContentConsumers()
288 throws RepositoryAdminException
289 {
290 return new ArrayList<String>(
291 getArchivaConfiguration().getConfiguration().getRepositoryScanning().getInvalidContentConsumers() );
292 }
293
294 public OrganisationInformation getOrganisationInformation()
295 throws RepositoryAdminException
296 {
297 org.apache.archiva.configuration.OrganisationInformation organisationInformation =
298 getArchivaConfiguration().getConfiguration().getOrganisationInfo();
299 if ( organisationInformation == null )
300 {
301 return null;
302 }
303 return new BeanReplicator().replicateBean( organisationInformation, OrganisationInformation.class );
304 }
305
306 public void setOrganisationInformation( OrganisationInformation organisationInformation )
307 throws RepositoryAdminException
308 {
309 Configuration configuration = getArchivaConfiguration().getConfiguration();
310 if ( organisationInformation != null )
311 {
312 org.apache.archiva.configuration.OrganisationInformation organisationInformationModel =
313 new BeanReplicator().replicateBean( organisationInformation,
314 org.apache.archiva.configuration.OrganisationInformation.class );
315 configuration.setOrganisationInfo( organisationInformationModel );
316 }
317 else
318 {
319 configuration.setOrganisationInfo( null );
320 }
321 saveConfiguration( configuration );
322 }
323
324 public UiConfiguration getUiConfiguration()
325 throws RepositoryAdminException
326 {
327 WebappConfiguration webappConfiguration = getArchivaConfiguration().getConfiguration().getWebapp();
328 if ( webappConfiguration == null )
329 {
330 return null;
331 }
332 UserInterfaceOptions userInterfaceOptions = webappConfiguration.getUi();
333 if ( userInterfaceOptions == null )
334 {
335 return null;
336 }
337 return new BeanReplicator().replicateBean( userInterfaceOptions, UiConfiguration.class );
338 }
339
340 public void updateUiConfiguration( UiConfiguration uiConfiguration )
341 throws RepositoryAdminException
342 {
343 Configuration configuration = getArchivaConfiguration().getConfiguration();
344 if ( uiConfiguration != null )
345 {
346
347 UserInterfaceOptions userInterfaceOptions =
348 new BeanReplicator().replicateBean( uiConfiguration, UserInterfaceOptions.class );
349 configuration.getWebapp().setUi( userInterfaceOptions );
350 }
351 else
352 {
353 configuration.getWebapp().setUi( null );
354 }
355 saveConfiguration( configuration );
356
357 }
358
359 public NetworkConfiguration getNetworkConfiguration()
360 throws RepositoryAdminException
361 {
362 org.apache.archiva.configuration.NetworkConfiguration networkConfiguration =
363 getArchivaConfiguration().getConfiguration().getNetworkConfiguration();
364
365 if ( networkConfiguration == null )
366 {
367 return null;
368 }
369 return new BeanReplicator().replicateBean( networkConfiguration, NetworkConfiguration.class );
370 }
371
372 public void setNetworkConfiguration( NetworkConfiguration networkConfiguration )
373 throws RepositoryAdminException
374 {
375 Configuration configuration = getArchivaConfiguration().getConfiguration();
376 if ( networkConfiguration == null )
377 {
378 configuration.setNetworkConfiguration( null );
379 }
380 else
381 {
382 configuration.setNetworkConfiguration( new BeanReplicator().replicateBean( networkConfiguration,
383 org.apache.archiva.configuration.NetworkConfiguration.class ) );
384 }
385 setupWagon( networkConfiguration );
386 saveConfiguration( configuration );
387 }
388
389 protected void setupWagon( NetworkConfiguration networkConfiguration )
390 {
391 if ( networkConfiguration == null )
392 {
393 // back to default values
394 HttpWagon.setUseClientManagerPooled( true );
395 poolingClientConnectionManager = new PoolingClientConnectionManager();
396 poolingClientConnectionManager.setDefaultMaxPerRoute( 30 );
397 poolingClientConnectionManager.setMaxTotal( 30 );
398 HttpWagon.setConnectionManagerPooled( poolingClientConnectionManager );
399
400 }
401 else
402 {
403 HttpWagon.setUseClientManagerPooled( networkConfiguration.isUsePooling() );
404 poolingClientConnectionManager = new PoolingClientConnectionManager();
405 poolingClientConnectionManager.setDefaultMaxPerRoute( networkConfiguration.getMaxTotalPerHost() );
406 poolingClientConnectionManager.setMaxTotal( networkConfiguration.getMaxTotal() );
407 HttpWagon.setConnectionManagerPooled( poolingClientConnectionManager );
408 }
409 }
410
411 //-------------------------
412 //
413 //-------------------------
414
415 private org.apache.archiva.configuration.FileType getFileTypeById( String id, Configuration configuration )
416 {
417 for ( org.apache.archiva.configuration.FileType fileType : configuration.getRepositoryScanning().getFileTypes() )
418 {
419 if ( StringUtils.equals( id, fileType.getId() ) )
420 {
421 return fileType;
422 }
423 }
424 return null;
425 }
426
427 }