This project has retired. For details please refer to its Attic page.
DefaultArchivaConfiguration xref
View Javadoc
1   package org.apache.archiva.configuration;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import org.apache.archiva.configuration.functors.ProxyConnectorConfigurationOrderComparator;
23  import org.apache.archiva.configuration.io.registry.ConfigurationRegistryReader;
24  import org.apache.archiva.configuration.io.registry.ConfigurationRegistryWriter;
25  import org.apache.archiva.policies.AbstractUpdatePolicy;
26  import org.apache.archiva.policies.CachedFailuresPolicy;
27  import org.apache.archiva.policies.ChecksumPolicy;
28  import org.apache.archiva.policies.DownloadErrorPolicy;
29  import org.apache.archiva.policies.Policy;
30  import org.apache.archiva.policies.PostDownloadPolicy;
31  import org.apache.archiva.policies.PreDownloadPolicy;
32  import org.apache.archiva.redback.components.evaluator.DefaultExpressionEvaluator;
33  import org.apache.archiva.redback.components.evaluator.EvaluatorException;
34  import org.apache.archiva.redback.components.evaluator.ExpressionEvaluator;
35  import org.apache.archiva.redback.components.evaluator.sources.SystemPropertyExpressionSource;
36  import org.apache.archiva.redback.components.registry.Registry;
37  import org.apache.archiva.redback.components.registry.RegistryException;
38  import org.apache.archiva.redback.components.registry.RegistryListener;
39  import org.apache.archiva.redback.components.registry.commons.CommonsConfigurationRegistry;
40  import org.apache.archiva.redback.components.springutils.ComponentContainer;
41  import org.apache.commons.collections.CollectionUtils;
42  import org.apache.commons.collections.ListUtils;
43  import org.apache.commons.collections.MapUtils;
44  import org.apache.commons.configuration.BaseConfiguration;
45  import org.apache.commons.io.FileUtils;
46  import org.apache.commons.lang.StringUtils;
47  import org.slf4j.Logger;
48  import org.slf4j.LoggerFactory;
49  import org.springframework.stereotype.Service;
50  
51  import javax.annotation.PostConstruct;
52  import javax.inject.Inject;
53  import javax.inject.Named;
54  import java.io.File;
55  import java.io.IOException;
56  import java.util.ArrayList;
57  import java.util.Arrays;
58  import java.util.Collection;
59  import java.util.Collections;
60  import java.util.HashMap;
61  import java.util.HashSet;
62  import java.util.Iterator;
63  import java.util.List;
64  import java.util.Map;
65  import java.util.Map.Entry;
66  import java.util.Set;
67  
68  /**
69   * <p>
70   * Implementation of configuration holder that retrieves it from the registry.
71   * </p>
72   * <p>
73   * The registry layers and merges the 2 configuration files: user, and application server.
74   * </p>
75   * <p>
76   * Instead of relying on the model defaults, if the registry is empty a default configuration file is loaded and
77   * applied from a resource. The defaults are not loaded into the registry as the lists (eg repositories) could no longer
78   * be removed if that was the case.
79   * </p>
80   * <p>
81   * When saving the configuration, it is saved to the location it was read from. If it was read from the defaults, it
82   * will be saved to the user location.
83   * However, if the configuration contains information from both sources, an exception is raised as this is currently
84   * unsupported. The reason for this is that it is not possible to identify where to re-save elements, and can result
85   * in list configurations (eg repositories) becoming inconsistent.
86   * </p>
87   * <p>
88   * If the configuration is outdated, it will be upgraded when it is loaded. This is done by checking the version flag
89   * before reading it from the registry.
90   * </p>
91   */
92  @Service("archivaConfiguration#default")
93  public class DefaultArchivaConfiguration
94      implements ArchivaConfiguration, RegistryListener
95  {
96      private Logger log = LoggerFactory.getLogger( DefaultArchivaConfiguration.class );
97  
98      /**
99       * Plexus registry to read the configuration from.
100      */
101     @Inject
102     @Named(value = "commons-configuration")
103     private Registry registry;
104 
105     @Inject
106     private ComponentContainer componentContainer;
107 
108     /**
109      * The configuration that has been converted.
110      */
111     private Configuration configuration;
112 
113     /**
114      * see #initialize
115      *
116      * @todo these don't strictly belong in here
117      */
118     private Map<String, PreDownloadPolicy> prePolicies;
119 
120     /**
121      * see #initialize
122      *
123      * @todo these don't strictly belong in here
124      */
125     private Map<String, PostDownloadPolicy> postPolicies;
126 
127     /**
128      * see #initialize
129      *
130      * @todo these don't strictly belong in here
131      */
132     private Map<String, DownloadErrorPolicy> downloadErrorPolicies;
133 
134 
135     /**
136      * see #initialize
137      * default-value="${user.home}/.m2/archiva.xml"
138      */
139     private String userConfigFilename = "${user.home}/.m2/archiva.xml";
140 
141     /**
142      * see #initialize
143      * default-value="${appserver.base}/conf/archiva.xml"
144      */
145     private String altConfigFilename = "${appserver.base}/conf/archiva.xml";
146 
147     /**
148      * Configuration Listeners we've registered.
149      */
150     private Set<ConfigurationListener> listeners = new HashSet<>();
151 
152     /**
153      * Registry Listeners we've registered.
154      */
155     private Set<RegistryListener> registryListeners = new HashSet<>();
156 
157     /**
158      * Boolean to help determine if the configuration exists as a result of pulling in
159      * the default-archiva.xml
160      */
161     private boolean isConfigurationDefaulted = false;
162 
163     private static final String KEY = "org.apache.archiva";
164 
165     // Section used for default only configuration
166     private static final String KEY_DEFAULT_ONLY = "org.apache.archiva_default";
167 
168     @Override
169     public Configuration getConfiguration()
170     {
171         return loadConfiguration();
172     }
173 
174     private synchronized Configuration loadConfiguration()
175     {
176         if ( configuration == null )
177         {
178             configuration = load();
179             configuration = unescapeExpressions( configuration );
180             if ( isConfigurationDefaulted )
181             {
182                 configuration = checkRepositoryLocations( configuration );
183             }
184         }
185 
186         return configuration;
187     }
188 
189     private boolean hasConfigVersionChanged(Configuration current, Registry defaultOnlyConfiguration) {
190         return current==null || current.getVersion()==null ||
191                 !current.getVersion().trim().equals(defaultOnlyConfiguration.getString("version","").trim());
192     }
193 
194     @SuppressWarnings("unchecked")
195     private Configuration load()
196     {
197         // TODO: should this be the same as section? make sure unnamed sections still work (eg, sys properties)
198         Registry subset = registry.getSubset( KEY );
199         if ( subset.getString( "version" ) == null )
200         {
201             // a little autodetection of v1, even if version is omitted (this was previously allowed)
202             if ( subset.getSubset( "repositoryScanning" ).isEmpty() )
203             {
204                 // only for empty, or v < 1
205                 subset = readDefaultConfiguration();
206             }
207         }
208 
209         Configuration config = new ConfigurationRegistryReader().read( subset );
210 
211 
212         config.getRepositoryGroups();
213         config.getRepositoryGroupsAsMap();
214         if ( !config.getRepositories().isEmpty() )
215         {
216             for ( V1RepositoryConfiguration r : config.getRepositories() )
217             {
218                 r.setScanned( r.isIndexed() );
219 
220                 if ( StringUtils.startsWith( r.getUrl(), "file://" ) )
221                 {
222                     r.setLocation( r.getUrl().substring( 7 ) );
223                     config.addManagedRepository( r );
224                 }
225                 else if ( StringUtils.startsWith( r.getUrl(), "file:" ) )
226                 {
227                     r.setLocation( r.getUrl().substring( 5 ) );
228                     config.addManagedRepository( r );
229                 }
230                 else if ( StringUtils.isEmpty( r.getUrl() ) )
231                 {
232                     // in case of empty url we can consider it as a managed one
233                     // check if location is null
234                     //file://${appserver.base}/repositories/${id}
235                     if ( StringUtils.isEmpty( r.getLocation() ) )
236                     {
237                         r.setLocation( "file://${appserver.base}/repositories/" + r.getId() );
238                     }
239                     config.addManagedRepository( r );
240                 }
241                 else
242                 {
243                     RemoteRepositoryConfiguration repo = new RemoteRepositoryConfiguration();
244                     repo.setId( r.getId() );
245                     repo.setLayout( r.getLayout() );
246                     repo.setName( r.getName() );
247                     repo.setUrl( r.getUrl() );
248                     config.addRemoteRepository( repo );
249                 }
250             }
251 
252             // Prevent duplicate repositories from showing up.
253             config.getRepositories().clear();
254 
255             registry.removeSubset( KEY + ".repositories" );
256         }
257 
258         if ( !CollectionUtils.isEmpty( config.getRemoteRepositories() ) )
259         {
260             List<RemoteRepositoryConfiguration> remoteRepos = config.getRemoteRepositories();
261             for ( RemoteRepositoryConfiguration repo : remoteRepos )
262             {
263                 // [MRM-582] Remote Repositories with empty <username> and <password> fields shouldn't be created in configuration.
264                 if ( StringUtils.isBlank( repo.getUsername() ) )
265                 {
266                     repo.setUsername( null );
267                 }
268 
269                 if ( StringUtils.isBlank( repo.getPassword() ) )
270                 {
271                     repo.setPassword( null );
272                 }
273             }
274         }
275 
276         if ( !config.getProxyConnectors().isEmpty() )
277         {
278             // Fix Proxy Connector Settings.
279 
280             // Create a copy of the list to read from (to prevent concurrent modification exceptions)
281             List<ProxyConnectorConfiguration> proxyConnectorList = new ArrayList<>( config.getProxyConnectors() );
282             // Remove the old connector list.
283             config.getProxyConnectors().clear();
284 
285             for ( ProxyConnectorConfiguration connector : proxyConnectorList )
286             {
287                 // Fix policies
288                 boolean connectorValid = true;
289 
290                 Map<String, String> policies = new HashMap<>();
291                 // Make copy of policies
292                 policies.putAll( connector.getPolicies() );
293                 // Clear out policies
294                 connector.getPolicies().clear();
295 
296                 // Work thru policies. cleaning them up.
297                 for ( Entry<String, String> entry : policies.entrySet() )
298                 {
299                     String policyId = entry.getKey();
300                     String setting = entry.getValue();
301 
302                     // Upgrade old policy settings.
303                     if ( "releases".equals( policyId ) || "snapshots".equals( policyId ) )
304                     {
305                         if ( "ignored".equals( setting ) )
306                         {
307                             setting = AbstractUpdatePolicy.ALWAYS;
308                         }
309                         else if ( "disabled".equals( setting ) )
310                         {
311                             setting = AbstractUpdatePolicy.NEVER;
312                         }
313                     }
314                     else if ( "cache-failures".equals( policyId ) )
315                     {
316                         if ( "ignored".equals( setting ) )
317                         {
318                             setting = CachedFailuresPolicy.NO;
319                         }
320                         else if ( "cached".equals( setting ) )
321                         {
322                             setting = CachedFailuresPolicy.YES;
323                         }
324                     }
325                     else if ( "checksum".equals( policyId ) )
326                     {
327                         if ( "ignored".equals( setting ) )
328                         {
329                             setting = ChecksumPolicy.IGNORE;
330                         }
331                     }
332 
333                     // Validate existance of policy key.
334                     if ( policyExists( policyId ) )
335                     {
336                         Policy policy = findPolicy( policyId );
337                         // Does option exist?
338                         if ( !policy.getOptions().contains( setting ) )
339                         {
340                             setting = policy.getDefaultOption();
341                         }
342                         connector.addPolicy( policyId, setting );
343                     }
344                     else
345                     {
346                         // Policy key doesn't exist. Don't add it to golden version.
347                         log.warn( "Policy [{}] does not exist.", policyId );
348                     }
349                 }
350 
351                 if ( connectorValid )
352                 {
353                     config.addProxyConnector( connector );
354                 }
355             }
356 
357             // Normalize the order fields in the proxy connectors.
358             Map<String, java.util.List<ProxyConnectorConfiguration>> proxyConnectorMap =
359                 config.getProxyConnectorAsMap();
360 
361             for ( List<ProxyConnectorConfiguration> connectors : proxyConnectorMap.values() )
362             {
363                 // Sort connectors by order field.
364                 Collections.sort( connectors, ProxyConnectorConfigurationOrderComparator.getInstance() );
365 
366                 // Normalize the order field values.
367                 int order = 1;
368                 for ( ProxyConnectorConfiguration connector : connectors )
369                 {
370                     connector.setOrder( order++ );
371                 }
372             }
373         }
374 
375 
376 
377         return config;
378     }
379 
380     /*
381      * Updates the checkpath list for repositories.
382      *
383      * We are replacing existing ones and adding new ones. This allows to update the list with new releases.
384      *
385      * We are also updating existing remote repositories, if they exist already.
386      *
387      * This update method should only be called, if the config version changes to avoid overwriting
388      * user repository settings all the time.
389      */
390     private void updateCheckPathDefaults(Configuration config, Registry defaultConfiguration) {
391         List<RepositoryCheckPath> existingCheckPathList = config.getArchivaDefaultConfiguration().getDefaultCheckPaths();
392         HashMap<String, RepositoryCheckPath> existingCheckPaths = new HashMap<>();
393         HashMap<String, RepositoryCheckPath> newCheckPaths = new HashMap<>();
394         for (RepositoryCheckPath path : config.getArchivaDefaultConfiguration().getDefaultCheckPaths()) {
395             existingCheckPaths.put(path.getUrl(), path);
396         }
397         List defaultCheckPathsSubsets = defaultConfiguration.getSubsetList("archivaDefaultConfiguration.defaultCheckPaths.defaultCheckPath" );
398         for ( Iterator i = defaultCheckPathsSubsets.iterator(); i.hasNext(); )
399         {
400             RepositoryCheckPath v = readRepositoryCheckPath( (Registry) i.next() );
401             if (existingCheckPaths.containsKey(v.getUrl())) {
402                 existingCheckPathList.remove(existingCheckPaths.get(v.getUrl()));
403             }
404             existingCheckPathList.add(v);
405             newCheckPaths.put(v.getUrl(), v);
406         }
407         // Remote repositories update
408         for (RemoteRepositoryConfiguration remoteRepositoryConfiguration : config.getRemoteRepositories()) {
409             String url = remoteRepositoryConfiguration.getUrl().toLowerCase();
410             if (newCheckPaths.containsKey(url)) {
411                 String currentPath = remoteRepositoryConfiguration.getCheckPath();
412                 String newPath = newCheckPaths.get(url).getPath();
413                 log.info("Updating connection check path for repository {}, from '{}' to '{}'.", remoteRepositoryConfiguration.getId(),
414                         currentPath, newPath);
415                 remoteRepositoryConfiguration.setCheckPath(newPath);
416             }
417         }
418     }
419 
420     private RepositoryCheckPath readRepositoryCheckPath( Registry registry )
421     {
422         RepositoryCheckPath value = new RepositoryCheckPath();
423 
424         String url = registry.getString( "url", value.getUrl() );
425 
426         value.setUrl( url );
427         String path = registry.getString( "path", value.getPath() );
428         value.setPath( path );
429         return value;
430     }
431 
432     private Policy findPolicy( String policyId )
433     {
434         if ( MapUtils.isEmpty( prePolicies ) )
435         {
436             log.error( "No PreDownloadPolicies found!" );
437             return null;
438         }
439 
440         if ( MapUtils.isEmpty( postPolicies ) )
441         {
442             log.error( "No PostDownloadPolicies found!" );
443             return null;
444         }
445 
446         Policy policy;
447 
448         policy = prePolicies.get( policyId );
449         if ( policy != null )
450         {
451             return policy;
452         }
453 
454         policy = postPolicies.get( policyId );
455         if ( policy != null )
456         {
457             return policy;
458         }
459 
460         policy = downloadErrorPolicies.get( policyId );
461         if ( policy != null )
462         {
463             return policy;
464         }
465 
466         return null;
467     }
468 
469     private boolean policyExists( String policyId )
470     {
471         if ( MapUtils.isEmpty( prePolicies ) )
472         {
473             log.error( "No PreDownloadPolicies found!" );
474             return false;
475         }
476 
477         if ( MapUtils.isEmpty( postPolicies ) )
478         {
479             log.error( "No PostDownloadPolicies found!" );
480             return false;
481         }
482 
483         return ( prePolicies.containsKey( policyId ) || postPolicies.containsKey( policyId )
484             || downloadErrorPolicies.containsKey( policyId ) );
485     }
486 
487     private Registry readDefaultConfiguration()
488     {
489         // if it contains some old configuration, remove it (Archiva 0.9)
490         registry.removeSubset( KEY );
491 
492         try
493         {
494             registry.addConfigurationFromResource( "org/apache/archiva/configuration/default-archiva.xml", KEY );
495             this.isConfigurationDefaulted = true;
496         }
497         catch ( RegistryException e )
498         {
499             throw new ConfigurationRuntimeException(
500                 "Fatal error: Unable to find the built-in default configuration and load it into the registry", e );
501         }
502         return registry.getSubset( KEY );
503     }
504 
505     /*
506      * Reads the default only configuration into a special prefix. This allows to check for changes
507      * of the default configuration.
508      */
509     private Registry readDefaultOnlyConfiguration()
510     {
511         registry.removeSubset(KEY_DEFAULT_ONLY);
512         try
513         {
514             registry.addConfigurationFromResource( "org/apache/archiva/configuration/default-archiva.xml", KEY_DEFAULT_ONLY);
515         }
516         catch ( RegistryException e )
517         {
518             throw new ConfigurationRuntimeException(
519                     "Fatal error: Unable to find the built-in default configuration and load it into the registry", e );
520         }
521         return registry.getSubset(KEY_DEFAULT_ONLY);
522     }
523 
524     @SuppressWarnings("unchecked")
525     @Override
526     public synchronized void save( Configuration configuration )
527         throws IndeterminateConfigurationException, RegistryException
528     {
529         Registry section = registry.getSection( KEY + ".user" );
530         Registry baseSection = registry.getSection( KEY + ".base" );
531         if ( section == null )
532         {
533             section = baseSection;
534             if ( section == null )
535             {
536                 section = createDefaultConfigurationFile();
537             }
538         }
539         else if ( baseSection != null )
540         {
541             Collection<String> keys = baseSection.getKeys();
542             boolean foundList = false;
543             for ( Iterator<String> i = keys.iterator(); i.hasNext() && !foundList; )
544             {
545                 String key = i.next();
546 
547                 // a little aggressive with the repositoryScanning and databaseScanning - should be no need to split
548                 // that configuration
549                 if ( key.startsWith( "repositories" ) //
550                     || key.startsWith( "proxyConnectors" ) //
551                     || key.startsWith( "networkProxies" ) //
552                     || key.startsWith( "repositoryScanning" ) //
553                     || key.startsWith( "remoteRepositories" ) //
554                     || key.startsWith( "managedRepositories" ) //
555                     || key.startsWith( "repositoryGroups" ) ) //
556                 {
557                     foundList = true;
558                 }
559             }
560 
561             if ( foundList )
562             {
563                 this.configuration = null;
564 
565                 throw new IndeterminateConfigurationException(
566                     "Configuration can not be saved when it is loaded from two sources" );
567             }
568         }
569 
570         // escape all cron expressions to handle ','
571         escapeCronExpressions( configuration );
572 
573         // [MRM-661] Due to a bug in the modello registry writer, we need to take these out by hand. They'll be put back by the writer.
574         if ( section != null )
575         {
576             if ( configuration.getManagedRepositories().isEmpty() )
577             {
578                 section.removeSubset( "managedRepositories" );
579             }
580             if ( configuration.getRemoteRepositories().isEmpty() )
581             {
582                 section.removeSubset( "remoteRepositories" );
583 
584             }
585             if ( configuration.getProxyConnectors().isEmpty() )
586             {
587                 section.removeSubset( "proxyConnectors" );
588             }
589             if ( configuration.getNetworkProxies().isEmpty() )
590             {
591                 section.removeSubset( "networkProxies" );
592             }
593             if ( configuration.getLegacyArtifactPaths().isEmpty() )
594             {
595                 section.removeSubset( "legacyArtifactPaths" );
596             }
597             if ( configuration.getRepositoryGroups().isEmpty() )
598             {
599                 section.removeSubset( "repositoryGroups" );
600             }
601             if ( configuration.getRepositoryScanning() != null )
602             {
603                 if ( configuration.getRepositoryScanning().getKnownContentConsumers().isEmpty() )
604                 {
605                     section.removeSubset( "repositoryScanning.knownContentConsumers" );
606                 }
607                 if ( configuration.getRepositoryScanning().getInvalidContentConsumers().isEmpty() )
608                 {
609                     section.removeSubset( "repositoryScanning.invalidContentConsumers" );
610                 }
611             }
612             if (configuration.getArchivaRuntimeConfiguration()!=null) {
613                 section.removeSubset("archivaRuntimeConfiguration.defaultCheckPaths");
614             }
615 
616             new ConfigurationRegistryWriter().write( configuration, section );
617             section.save();
618         }
619 
620 
621 
622         this.configuration = unescapeExpressions( configuration );
623 
624         triggerEvent( ConfigurationEvent.SAVED );
625     }
626 
627     private void escapeCronExpressions( Configuration configuration )
628     {
629         for ( ManagedRepositoryConfiguration c : configuration.getManagedRepositories() )
630         {
631             c.setRefreshCronExpression( escapeCronExpression( c.getRefreshCronExpression() ) );
632         }
633     }
634 
635     private Registry createDefaultConfigurationFile()
636         throws RegistryException
637     {
638         // TODO: may not be needed under commons-configuration 1.4 - check
639 
640         String contents = "<configuration />";
641 
642         String fileLocation = userConfigFilename;
643 
644         if ( !writeFile( "user configuration", userConfigFilename, contents ) )
645         {
646             fileLocation = altConfigFilename;
647             if ( !writeFile( "alternative configuration", altConfigFilename, contents ) )
648             {
649                 throw new RegistryException(
650                     "Unable to create configuration file in either user [" + userConfigFilename + "] or alternative ["
651                         + altConfigFilename
652                         + "] locations on disk, usually happens when not allowed to write to those locations." );
653             }
654         }
655 
656         // olamy hackish I know :-)
657         contents = "<configuration><xml fileName=\"" + fileLocation
658             + "\" config-forceCreate=\"true\" config-name=\"org.apache.archiva.user\"/>" + "</configuration>";
659 
660         ( (CommonsConfigurationRegistry) registry ).setProperties( contents );
661 
662         registry.initialize();
663 
664         for ( RegistryListener regListener : registryListeners )
665         {
666             addRegistryChangeListener( regListener );
667         }
668 
669         triggerEvent( ConfigurationEvent.SAVED );
670 
671         Registry section = registry.getSection( KEY + ".user" );
672         return section == null ? new CommonsConfigurationRegistry( new BaseConfiguration() ) : section;
673     }
674 
675     /**
676      * Attempts to write the contents to a file, if an IOException occurs, return false.
677      * <p/>
678      * The file will be created if the directory to the file exists, otherwise this will return false.
679      *
680      * @param filetype the filetype (freeform text) to use in logging messages when failure to write.
681      * @param path     the path to write to.
682      * @param contents the contents to write.
683      * @return true if write successful.
684      */
685     private boolean writeFile( String filetype, String path, String contents )
686     {
687         File file = new File( path );
688 
689         try
690         {
691             // Check parent directory (if it is declared)
692             if ( file.getParentFile() != null )
693             {
694                 // Check that directory exists
695                 if ( !file.getParentFile().isDirectory() )
696                 {
697                     // Directory to file must exist for file to be created
698                     return false;
699                 }
700             }
701 
702             FileUtils.writeStringToFile( file, contents, "UTF-8" );
703             return true;
704         }
705         catch ( IOException e )
706         {
707             log.error( "Unable to create " + filetype + " file: " + e.getMessage(), e );
708             return false;
709         }
710     }
711 
712     private void triggerEvent( int type )
713     {
714         ConfigurationEvent evt = new ConfigurationEvent( type );
715         for ( ConfigurationListener listener : listeners )
716         {
717             listener.configurationEvent( evt );
718         }
719     }
720 
721     @Override
722     public void addListener( ConfigurationListener listener )
723     {
724         if ( listener == null )
725         {
726             return;
727         }
728 
729         listeners.add( listener );
730     }
731 
732     @Override
733     public void removeListener( ConfigurationListener listener )
734     {
735         if ( listener == null )
736         {
737             return;
738         }
739 
740         listeners.remove( listener );
741     }
742 
743 
744     @Override
745     public void addChangeListener( RegistryListener listener )
746     {
747         addRegistryChangeListener( listener );
748 
749         // keep track for later
750         registryListeners.add( listener );
751     }
752 
753     private void addRegistryChangeListener( RegistryListener listener )
754     {
755         Registry section = registry.getSection( KEY + ".user" );
756         if ( section != null )
757         {
758             section.addChangeListener( listener );
759         }
760         section = registry.getSection( KEY + ".base" );
761         if ( section != null )
762         {
763             section.addChangeListener( listener );
764         }
765     }
766 
767     @Override
768     public void removeChangeListener( RegistryListener listener )
769     {
770         boolean removed = registryListeners.remove( listener );
771         log.debug( "RegistryListener: '{}' removed {}", listener, removed );
772 
773         Registry section = registry.getSection( KEY + ".user" );
774         if ( section != null )
775         {
776             section.removeChangeListener( listener );
777         }
778         section = registry.getSection( KEY + ".base" );
779         if ( section != null )
780         {
781             section.removeChangeListener( listener );
782         }
783 
784     }
785 
786     @PostConstruct
787     public void initialize()
788     {
789 
790         this.postPolicies = componentContainer.buildMapWithRole( PostDownloadPolicy.class );
791         this.prePolicies = componentContainer.buildMapWithRole( PreDownloadPolicy.class );
792         this.downloadErrorPolicies = componentContainer.buildMapWithRole( DownloadErrorPolicy.class );
793         // Resolve expressions in the userConfigFilename and altConfigFilename
794         try
795         {
796             ExpressionEvaluator expressionEvaluator = new DefaultExpressionEvaluator();
797             expressionEvaluator.addExpressionSource( new SystemPropertyExpressionSource() );
798             String userConfigFileNameSysProps = System.getProperty( "archiva.user.configFileName" );
799             if ( StringUtils.isNotBlank( userConfigFileNameSysProps ) )
800             {
801                 userConfigFilename = userConfigFileNameSysProps;
802             }
803             else
804             {
805                 userConfigFilename = expressionEvaluator.expand( userConfigFilename );
806             }
807             altConfigFilename = expressionEvaluator.expand( altConfigFilename );
808             loadConfiguration();
809             handleUpgradeConfiguration();
810         }
811         catch ( IndeterminateConfigurationException | RegistryException e )
812         {
813             throw new RuntimeException( "failed during upgrade from previous version" + e.getMessage(), e );
814         }
815         catch ( EvaluatorException e )
816         {
817             throw new RuntimeException(
818                 "Unable to evaluate expressions found in " + "userConfigFilename or altConfigFilename.", e );
819         }
820         registry.addChangeListener( this );
821     }
822 
823     /**
824      * Handle upgrade to newer version
825      */
826     private void handleUpgradeConfiguration()
827         throws RegistryException, IndeterminateConfigurationException
828     {
829 
830         List<String> dbConsumers = Arrays.asList( "update-db-artifact", "update-db-repository-metadata" );
831 
832         // remove database consumers if here
833         List<String> intersec =
834             ListUtils.intersection( dbConsumers, configuration.getRepositoryScanning().getKnownContentConsumers() );
835 
836         if ( !intersec.isEmpty() )
837         {
838 
839             List<String> knowContentConsumers =
840                 new ArrayList<>( configuration.getRepositoryScanning().getKnownContentConsumers().size() );
841             for ( String knowContentConsumer : configuration.getRepositoryScanning().getKnownContentConsumers() )
842             {
843                 if ( !dbConsumers.contains( knowContentConsumer ) )
844                 {
845                     knowContentConsumers.add( knowContentConsumer );
846                 }
847             }
848 
849             configuration.getRepositoryScanning().setKnownContentConsumers( knowContentConsumers );
850         }
851 
852         // ensure create-archiva-metadata is here
853         if ( !configuration.getRepositoryScanning().getKnownContentConsumers().contains( "create-archiva-metadata" ) )
854         {
855             List<String> knowContentConsumers =
856                 new ArrayList<>( configuration.getRepositoryScanning().getKnownContentConsumers() );
857             knowContentConsumers.add( "create-archiva-metadata" );
858             configuration.getRepositoryScanning().setKnownContentConsumers( knowContentConsumers );
859         }
860 
861         // ensure duplicate-artifacts is here
862         if ( !configuration.getRepositoryScanning().getKnownContentConsumers().contains( "duplicate-artifacts" ) )
863         {
864             List<String> knowContentConsumers =
865                 new ArrayList<>( configuration.getRepositoryScanning().getKnownContentConsumers() );
866             knowContentConsumers.add( "duplicate-artifacts" );
867             configuration.getRepositoryScanning().setKnownContentConsumers( knowContentConsumers );
868         }
869 
870         Registry defaultOnlyConfiguration = readDefaultOnlyConfiguration();
871         // Currently we check only for configuration version change, not certain version numbers.
872         if (hasConfigVersionChanged(configuration, defaultOnlyConfiguration)) {
873             updateCheckPathDefaults(configuration, defaultOnlyConfiguration);
874             String newVersion = defaultOnlyConfiguration.getString("version");
875             if (newVersion==null) {
876                 throw new IndeterminateConfigurationException("The default configuration has no version information!");
877             }
878             configuration.setVersion(newVersion);
879             try {
880                 save(configuration);
881             } catch (IndeterminateConfigurationException e) {
882                 log.error("Error occured during configuration update to new version: {}", e.getMessage());
883             } catch (RegistryException e) {
884                 log.error("Error occured during configuration update to new version: {}", e.getMessage());
885             }
886         }
887     }
888 
889     @Override
890     public void reload()
891     {
892         this.configuration = null;
893         try
894         {
895             this.registry.initialize();
896         }
897         catch ( RegistryException e )
898         {
899             throw new ConfigurationRuntimeException( e.getMessage(), e );
900         }
901         this.initialize();
902     }
903 
904     @Override
905     public void beforeConfigurationChange( Registry registry, String propertyName, Object propertyValue )
906     {
907         // nothing to do here
908     }
909 
910     @Override
911     public synchronized void afterConfigurationChange( Registry registry, String propertyName, Object propertyValue )
912     {
913         configuration = null;
914     }
915 
916     private String removeExpressions( String directory )
917     {
918         String value = StringUtils.replace( directory, "${appserver.base}",
919                                             registry.getString( "appserver.base", "${appserver.base}" ) );
920         value = StringUtils.replace( value, "${appserver.home}",
921                                      registry.getString( "appserver.home", "${appserver.home}" ) );
922         return value;
923     }
924 
925     private String unescapeCronExpression( String cronExpression )
926     {
927         return StringUtils.replace( cronExpression, "\\,", "," );
928     }
929 
930     private String escapeCronExpression( String cronExpression )
931     {
932         return StringUtils.replace( cronExpression, ",", "\\," );
933     }
934 
935     private Configuration unescapeExpressions( Configuration config )
936     {
937         // TODO: for commons-configuration 1.3 only
938         for ( ManagedRepositoryConfiguration c : config.getManagedRepositories() )
939         {
940             c.setLocation( removeExpressions( c.getLocation() ) );
941             c.setRefreshCronExpression( unescapeCronExpression( c.getRefreshCronExpression() ) );
942         }
943 
944         return config;
945     }
946 
947     private Configuration checkRepositoryLocations( Configuration config )
948     {
949         // additional check for [MRM-789], ensure that the location of the default repositories 
950         // are not installed in the server installation        
951         for ( ManagedRepositoryConfiguration repo : (List<ManagedRepositoryConfiguration>) config.getManagedRepositories() )
952         {
953             String repoPath = repo.getLocation();
954             File repoLocation = new File( repoPath );
955 
956             if ( repoLocation.exists() && repoLocation.isDirectory() && !repoPath.endsWith(
957                 "data/repositories/" + repo.getId() ) )
958             {
959                 repo.setLocation( repoPath + "/data/repositories/" + repo.getId() );
960             }
961         }
962 
963         return config;
964     }
965 
966     public String getUserConfigFilename()
967     {
968         return userConfigFilename;
969     }
970 
971     public String getAltConfigFilename()
972     {
973         return altConfigFilename;
974     }
975 
976     @Override
977     public boolean isDefaulted()
978     {
979         return this.isConfigurationDefaulted;
980     }
981 
982     public Registry getRegistry()
983     {
984         return registry;
985     }
986 
987     public void setRegistry( Registry registry )
988     {
989         this.registry = registry;
990     }
991 
992 
993     public void setUserConfigFilename( String userConfigFilename )
994     {
995         this.userConfigFilename = userConfigFilename;
996     }
997 
998     public void setAltConfigFilename( String altConfigFilename )
999     {
1000         this.altConfigFilename = altConfigFilename;
1001     }
1002 }