source.dussan.org Git - archiva.git/blob

   1 package org.apache.maven.archiva.repository.project.filters;
   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.commons.collections.CollectionUtils;
  23 import org.apache.commons.lang.StringUtils;
  24 import org.apache.maven.archiva.model.ArchivaModelCloner;
  25 import org.apache.maven.archiva.model.ArchivaProjectModel;
  26 import org.apache.maven.archiva.model.ArtifactReference;
  27 import org.apache.maven.archiva.model.CiManagement;
  28 import org.apache.maven.archiva.model.Dependency;
  29 import org.apache.maven.archiva.model.Exclusion;
  30 import org.apache.maven.archiva.model.Individual;
  31 import org.apache.maven.archiva.model.IssueManagement;
  32 import org.apache.maven.archiva.model.License;
  33 import org.apache.maven.archiva.model.MailingList;
  34 import org.apache.maven.archiva.model.Organization;
  35 import org.apache.maven.archiva.model.ProjectRepository;
  36 import org.apache.maven.archiva.model.Scm;
  37 import org.apache.maven.archiva.model.VersionedReference;
  38 import org.apache.maven.archiva.repository.project.ProjectModelException;
  39 import org.apache.maven.archiva.repository.project.ProjectModelFilter;
  40 import org.codehaus.plexus.evaluator.DefaultExpressionEvaluator;
  41 import org.codehaus.plexus.evaluator.EvaluatorException;
  42 import org.codehaus.plexus.evaluator.ExpressionEvaluator;
  43 import org.codehaus.plexus.evaluator.ExpressionSource;
  44 import org.codehaus.plexus.evaluator.sources.PropertiesExpressionSource;
  45 import org.codehaus.plexus.evaluator.sources.SystemPropertyExpressionSource;
  46
  47 import java.util.ArrayList;
  48 import java.util.HashSet;
  49 import java.util.List;
  50 import java.util.Properties;
  51 import java.util.Set;
  52
  53 /**
  54  * ProjectModelExpressionFilter
  55  *
  56  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  57  * @version $Id$
  58  * @plexus.component role="org.apache.maven.archiva.repository.project.ProjectModelFilter"
  59  *                   role-hint="expression"
  60  *                   instantiation-strategy="per-lookup"
  61  */
  62 public class ProjectModelExpressionFilter
  63     implements ProjectModelFilter
  64 {
  65     private ExpressionEvaluator evaluator = new DefaultExpressionEvaluator();
  66
  67     /**
  68      * Find and Evaluate the Expressions present in the model.
  69      *
  70      * @param model the model to correct.
  71      */
  72     public ArchivaProjectModel filter( final ArchivaProjectModel model )
  73         throws ProjectModelException
  74     {
  75         Properties props = new Properties();
  76
  77         if ( model.getProperties() != null )
  78         {
  79             props.putAll( model.getProperties() );
  80         }
  81
  82         ArchivaProjectModel ret = ArchivaModelCloner.clone( model );
  83
  84         // TODO: should probably clone evaluator to prevent threading issues.
  85         synchronized ( evaluator )
  86         {
  87             // TODO: create .resetSources() method in ExpressionEvaluator project on plexus side.
  88             // Remove previous expression sources.
  89             List<ExpressionSource> oldSources = new ArrayList<ExpressionSource>();
  90             oldSources.addAll( evaluator.getExpressionSourceList() );
  91             for ( ExpressionSource exprSrc : oldSources )
  92             {
  93                 evaluator.removeExpressionSource( exprSrc );
  94             }
  95
  96             // Setup new sources (based on current model)
  97             PropertiesExpressionSource propsSource = new PropertiesExpressionSource();
  98             propsSource.setProperties( props );
  99             evaluator.addExpressionSource( propsSource );
 100
 101             // Add system properties to the mix.
 102             evaluator.addExpressionSource( new SystemPropertyExpressionSource() );
 103
 104             try
 105             {
 106                 // Setup some common properties.
 107                 String groupId = StringUtils.defaultString( evaluator.expand( model.getGroupId() ) );
 108                 String artifactId = StringUtils.defaultString( evaluator.expand( model.getArtifactId() ) );
 109                 String version = StringUtils.defaultString( evaluator.expand( model.getVersion() ) );
 110                 String name = StringUtils.defaultString( evaluator.expand( model.getName() ) );
 111
 112                 /* Archiva doesn't need to handle a full expression language with object tree walking
 113                  * as the requirements within Archiva are much smaller, a quick replacement of the
 114                  * important fields (groupId, artifactId, version, name) are handled specifically.
 115                  */
 116                 props.setProperty( "pom.groupId",  groupId );
 117                 props.setProperty( "pom.artifactId", artifactId );
 118                 props.setProperty( "pom.version", version );
 119                 props.setProperty( "pom.name", name );
 120                 props.setProperty( "project.groupId",  groupId );
 121                 props.setProperty( "project.artifactId", artifactId );
 122                 props.setProperty( "project.version", version );
 123                 props.setProperty( "project.name", name );
 124
 125                 // Evaluate everything.
 126                 ret.setVersion( evaluator.expand( ret.getVersion() ) );
 127                 ret.setGroupId( evaluator.expand( ret.getGroupId() ) );
 128                 ret.setName( evaluator.expand( ret.getName() ) );
 129                 ret.setDescription( evaluator.expand( ret.getDescription() ) );
 130                 ret.setPackaging( evaluator.expand( ret.getPackaging() ) );
 131                 ret.setUrl( evaluator.expand( ret.getUrl() ) );
 132
 133                 evaluateParentProject( evaluator, ret.getParentProject() );
 134
 135                 evaluateBuildExtensions( evaluator, ret.getBuildExtensions() );
 136                 evaluateCiManagement( evaluator, ret.getCiManagement() );
 137                 evaluateDependencyList( evaluator, ret.getDependencies() );
 138                 evaluateDependencyList( evaluator, ret.getDependencyManagement() );
 139                 evaluateIndividuals( evaluator, ret.getIndividuals() );
 140                 evaluateIssueManagement( evaluator, ret.getIssueManagement() );
 141                 evaluateLicenses( evaluator, ret.getLicenses() );
 142                 evaluateMailingLists( evaluator, ret.getMailingLists() );
 143                 evaluateOrganization( evaluator, ret.getOrganization() );
 144                 evaluatePlugins( evaluator, ret.getPlugins() );
 145                 evaluateRelocation( evaluator, ret.getRelocation() );
 146                 evaluateReports( evaluator, ret.getReports() );
 147                 evaluateRepositories( evaluator, ret.getRepositories() );
 148                 evaluateScm( evaluator, ret.getScm() );
 149             }
 150             catch ( EvaluatorException e )
 151             {
 152                 throw new ProjectModelException( "Unable to evaluate expression in model: " + e.getMessage(), e );
 153             }
 154         }
 155
 156         return ret;
 157     }
 158
 159     private void evaluateArtifactReferenceList( ExpressionEvaluator eval, List<ArtifactReference> refs )
 160         throws EvaluatorException
 161     {
 162         if ( CollectionUtils.isEmpty( refs ) )
 163         {
 164             return;
 165         }
 166
 167         for ( ArtifactReference ref : refs )
 168         {
 169             ref.setGroupId( eval.expand( ref.getGroupId() ) );
 170             ref.setArtifactId( eval.expand( ref.getArtifactId() ) );
 171             ref.setVersion( eval.expand( ref.getVersion() ) );
 172             ref.setClassifier( eval.expand( ref.getClassifier() ) );
 173             ref.setType( eval.expand( ref.getType() ) );
 174         }
 175     }
 176
 177     private void evaluateBuildExtensions( ExpressionEvaluator eval, List<ArtifactReference> buildExtensions )
 178         throws EvaluatorException
 179     {
 180         if ( CollectionUtils.isEmpty( buildExtensions ) )
 181         {
 182             return;
 183         }
 184
 185         for ( ArtifactReference ref : buildExtensions )
 186         {
 187             ref.setGroupId( eval.expand( ref.getGroupId() ) );
 188             ref.setArtifactId( eval.expand( ref.getArtifactId() ) );
 189             ref.setVersion( eval.expand( ref.getVersion() ) );
 190             ref.setClassifier( eval.expand( ref.getClassifier() ) );
 191             ref.setType( eval.expand( ref.getType() ) );
 192         }
 193     }
 194
 195     private void evaluateCiManagement( ExpressionEvaluator eval, CiManagement ciManagement )
 196         throws EvaluatorException
 197     {
 198         if ( ciManagement == null )
 199         {
 200             return;
 201         }
 202
 203         ciManagement.setSystem( eval.expand( ciManagement.getSystem() ) );
 204         ciManagement.setUrl( eval.expand( ciManagement.getUrl() ) );
 205     }
 206
 207     private void evaluateDependencyList( ExpressionEvaluator eval, List<Dependency> dependencies )
 208         throws EvaluatorException
 209     {
 210         if ( CollectionUtils.isEmpty( dependencies ) )
 211         {
 212             return;
 213         }
 214
 215         for ( Dependency dependency : dependencies )
 216         {
 217             dependency.setGroupId( eval.expand( dependency.getGroupId() ) );
 218             dependency.setArtifactId( eval.expand( dependency.getArtifactId() ) );
 219             dependency.setVersion( eval.expand( dependency.getVersion() ) );
 220             dependency.setScope( eval.expand( dependency.getScope() ) );
 221             dependency.setType( eval.expand( dependency.getType() ) );
 222             dependency.setUrl( eval.expand( dependency.getUrl() ) );
 223
 224             evaluateExclusions( eval, dependency.getExclusions() );
 225         }
 226     }
 227
 228     private void evaluateExclusions( ExpressionEvaluator eval, List<Exclusion> exclusions )
 229         throws EvaluatorException
 230     {
 231         if ( CollectionUtils.isEmpty( exclusions ) )
 232         {
 233             return;
 234         }
 235
 236         for ( Exclusion exclusion : exclusions )
 237         {
 238             exclusion.setGroupId( eval.expand( exclusion.getGroupId() ) );
 239             exclusion.setArtifactId( eval.expand( exclusion.getArtifactId() ) );
 240         }
 241     }
 242
 243     private void evaluateIndividuals( ExpressionEvaluator eval, List<Individual> individuals )
 244         throws EvaluatorException
 245     {
 246         if ( CollectionUtils.isEmpty( individuals ) )
 247         {
 248             return;
 249         }
 250
 251         for ( Individual individual : individuals )
 252         {
 253             individual.setPrincipal( eval.expand( individual.getPrincipal() ) );
 254             individual.setName( eval.expand( individual.getName() ) );
 255             individual.setEmail( eval.expand( individual.getEmail() ) );
 256             individual.setTimezone( eval.expand( individual.getTimezone() ) );
 257             individual.setOrganization( eval.expand( individual.getOrganization() ) );
 258             individual.setOrganizationUrl( eval.expand( individual.getOrganizationUrl() ) );
 259             individual.setUrl( eval.expand( individual.getUrl() ) );
 260
 261             evaluateProperties( eval, individual.getProperties() );
 262             evaluateStringList( eval, individual.getRoles() );
 263         }
 264     }
 265
 266     private void evaluateIssueManagement( ExpressionEvaluator eval, IssueManagement issueManagement )
 267         throws EvaluatorException
 268     {
 269         if ( issueManagement == null )
 270         {
 271             return;
 272         }
 273
 274         issueManagement.setSystem( eval.expand( issueManagement.getSystem() ) );
 275         issueManagement.setUrl( eval.expand( issueManagement.getUrl() ) );
 276     }
 277
 278     private void evaluateLicenses( ExpressionEvaluator eval, List<License> licenses )
 279         throws EvaluatorException
 280     {
 281         if ( CollectionUtils.isEmpty( licenses ) )
 282         {
 283             return;
 284         }
 285
 286         for ( License license : licenses )
 287         {
 288             license.setName( eval.expand( license.getName() ) );
 289             license.setUrl( eval.expand( license.getUrl() ) );
 290             license.setComments( eval.expand( license.getComments() ) );
 291         }
 292     }
 293
 294     private void evaluateMailingLists( ExpressionEvaluator eval, List<MailingList> mailingLists )
 295         throws EvaluatorException
 296     {
 297         if ( CollectionUtils.isEmpty( mailingLists ) )
 298         {
 299             return;
 300         }
 301
 302         for ( MailingList mlist : mailingLists )
 303         {
 304             mlist.setName( eval.expand( mlist.getName() ) );
 305             mlist.setSubscribeAddress( eval.expand( mlist.getSubscribeAddress() ) );
 306             mlist.setUnsubscribeAddress( eval.expand( mlist.getUnsubscribeAddress() ) );
 307             mlist.setPostAddress( eval.expand( mlist.getPostAddress() ) );
 308             mlist.setMainArchiveUrl( eval.expand( mlist.getMainArchiveUrl() ) );
 309
 310             evaluateStringList( eval, mlist.getOtherArchives() );
 311         }
 312     }
 313
 314     private void evaluateOrganization( ExpressionEvaluator eval, Organization organization )
 315         throws EvaluatorException
 316     {
 317         if ( organization == null )
 318         {
 319             return;
 320         }
 321
 322         organization.setName( eval.expand( organization.getName() ) );
 323         organization.setUrl( eval.expand( organization.getUrl() ) );
 324         organization.setFavicon( eval.expand( organization.getFavicon() ) );
 325     }
 326
 327     private void evaluateParentProject( ExpressionEvaluator eval, VersionedReference parentProject )
 328         throws EvaluatorException
 329     {
 330         if ( parentProject == null )
 331         {
 332             return;
 333         }
 334
 335         parentProject.setGroupId( eval.expand( parentProject.getGroupId() ) );
 336         parentProject.setArtifactId( eval.expand( parentProject.getArtifactId() ) );
 337         parentProject.setVersion( eval.expand( parentProject.getVersion() ) );
 338     }
 339
 340     private void evaluatePlugins( ExpressionEvaluator eval, List<ArtifactReference> plugins )
 341         throws EvaluatorException
 342     {
 343         evaluateArtifactReferenceList( eval, plugins );
 344     }
 345
 346     private void evaluateProperties( ExpressionEvaluator eval, Properties props )
 347         throws EvaluatorException
 348     {
 349         if ( props == null )
 350         {
 351             return;
 352         }
 353
 354         // Only evaluate the values, not the keys.
 355
 356         // Collect the key names. (Done ahead of time to prevent iteration / concurrent modification exceptions)
 357         Set<String> keys = new HashSet<String>();
 358         for ( Object obj : props.keySet() )
 359         {
 360             keys.add( (String) obj );
 361         }
 362
 363         // Evaluate all of the values.
 364         for ( String key : keys )
 365         {
 366             String value = props.getProperty( key );
 367             props.setProperty( key, eval.expand( value ) );
 368         }
 369     }
 370
 371     private void evaluateRelocation( ExpressionEvaluator eval, VersionedReference relocation )
 372         throws EvaluatorException
 373     {
 374         if ( relocation == null )
 375         {
 376             return;
 377         }
 378
 379         relocation.setGroupId( eval.expand( relocation.getGroupId() ) );
 380         relocation.setArtifactId( eval.expand( relocation.getArtifactId() ) );
 381         relocation.setVersion( eval.expand( relocation.getVersion() ) );
 382     }
 383
 384     private void evaluateReports( ExpressionEvaluator eval, List<ArtifactReference> reports )
 385         throws EvaluatorException
 386     {
 387         evaluateArtifactReferenceList( eval, reports );
 388     }
 389
 390     private void evaluateRepositories( ExpressionEvaluator eval, List<ProjectRepository> repositories )
 391         throws EvaluatorException
 392     {
 393         if ( CollectionUtils.isEmpty( repositories ) )
 394         {
 395             return;
 396         }
 397
 398         for ( ProjectRepository repository : repositories )
 399         {
 400             repository.setId( eval.expand( repository.getId() ) );
 401             repository.setLayout( eval.expand( repository.getLayout() ) );
 402             repository.setName( eval.expand( repository.getName() ) );
 403             repository.setUrl( eval.expand( repository.getUrl() ) );
 404         }
 405     }
 406
 407     private void evaluateScm( ExpressionEvaluator eval, Scm scm )
 408         throws EvaluatorException
 409     {
 410         if ( scm == null )
 411         {
 412             return;
 413         }
 414
 415         scm.setConnection( eval.expand( scm.getConnection() ) );
 416         scm.setDeveloperConnection( eval.expand( scm.getDeveloperConnection() ) );
 417         scm.setUrl( eval.expand( scm.getUrl() ) );
 418     }
 419
 420     private void evaluateStringList( ExpressionEvaluator eval, List<String> strings )
 421         throws EvaluatorException
 422     {
 423         if ( CollectionUtils.isEmpty( strings ) )
 424         {
 425             return;
 426         }
 427
 428         // Create new list to hold post-evaluated strings.
 429         List<String> evaluated = new ArrayList<String>();
 430
 431         // Evaluate them all
 432         for ( String str : strings )
 433         {
 434             evaluated.add( eval.expand( str ) );
 435         }
 436
 437         // Populate the original list with the post-evaluated list.
 438         strings.clear();
 439         strings.addAll( evaluated );
 440     }
 441 }