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

   1 package org.apache.maven.repository.discovery;
   2
   3 /*
   4  * Copyright 2005-2006 The Apache Software Foundation.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 import org.apache.maven.artifact.Artifact;
  20 import org.apache.maven.artifact.DefaultArtifact;
  21 import org.apache.maven.artifact.handler.ArtifactHandler;
  22 import org.apache.maven.artifact.handler.DefaultArtifactHandler;
  23 import org.apache.maven.artifact.repository.metadata.ArtifactRepositoryMetadata;
  24 import org.apache.maven.artifact.repository.metadata.GroupRepositoryMetadata;
  25 import org.apache.maven.artifact.repository.metadata.Metadata;
  26 import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
  27 import org.apache.maven.artifact.repository.metadata.SnapshotArtifactRepositoryMetadata;
  28 import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader;
  29 import org.apache.maven.artifact.versioning.VersionRange;
  30 import org.codehaus.plexus.util.DirectoryScanner;
  31 import org.codehaus.plexus.util.FileUtils;
  32 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;
  33
  34 import java.io.File;
  35 import java.io.FileNotFoundException;
  36 import java.io.IOException;
  37 import java.io.InputStream;
  38 import java.io.InputStreamReader;
  39 import java.io.Reader;
  40 import java.net.URL;
  41 import java.util.ArrayList;
  42 import java.util.Arrays;
  43 import java.util.Collections;
  44 import java.util.Iterator;
  45 import java.util.List;
  46 import java.util.StringTokenizer;
  47
  48 /**
  49  * This class gets all the paths that contain the metadata files.
  50  */
  51 public class DefaultMetadataDiscoverer
  52     implements MetadataDiscoverer
  53 {
  54
  55     /**
  56      * Standard patterns to exclude from discovery as they are not artifacts.
  57      */
  58     private static final String[] STANDARD_DISCOVERY_EXCLUDES = {"bin/**", "reports/**", ".maven/**", "**/*.md5",
  59         "**/*.MD5", "**/*.sha1", "**/*.SHA1", "**/*snapshot-version", "*/website/**", "*/licenses/**", "*/licences/**",
  60         "**/.htaccess", "**/*.html", "**/*.asc", "**/*.txt", "**/README*", "**/CHANGELOG*", "**/KEYS*"};
  61
  62     /**
  63      * Standard patterns to include in discovery of metadata files.
  64      */
  65     private static final String[] STANDARD_DISCOVERY_INCLUDES = {"**/*-metadata.xml", "**/*/*-metadata.xml",
  66         "**/*/*/*-metadata.xml", "**/*-metadata-*.xml", "**/*/*-metadata-*.xml", "**/*/*/*-metadata-*.xml"};
  67
  68     private static final String[] EMPTY_STRING_ARRAY = new String[0];
  69
  70     private List excludedPaths = new ArrayList();
  71
  72     private List kickedOutPaths = new ArrayList();
  73
  74     /**
  75      * Search the repository for metadata files.
  76      *
  77      * @param repositoryBase
  78      * @param blacklistedPatterns
  79      */
  80     public List discoverMetadata( File repositoryBase, String blacklistedPatterns )
  81     {
  82         List metadataFiles = new ArrayList();
  83         String[] metadataPaths = scanForMetadataPaths( repositoryBase, blacklistedPatterns );
  84
  85         for ( int i = 0; i < metadataPaths.length; i++ )
  86         {
  87             RepositoryMetadata metadata = buildMetadata( repositoryBase
  88                 .getPath(), metadataPaths[i] );
  89
  90             if ( metadata != null )
  91             {
  92                 metadataFiles.add( metadata );
  93             }
  94             else
  95             {
  96                 kickedOutPaths.add( metadataPaths[i] );
  97             }
  98         }
  99
 100         return metadataFiles;
 101     }
 102
 103     /**
 104      * Create RepositoryMetadata object.
 105      *
 106      * @param repo         The path to the repository.
 107      * @param metadataPath The path to the metadata file.
 108      * @return
 109      */
 110     private RepositoryMetadata buildMetadata( String repo, String metadataPath )
 111     {
 112
 113         RepositoryMetadata metadata = null;
 114
 115         try
 116         {
 117             URL url = new File( repo + "/" + metadataPath ).toURL();
 118             InputStream is = url.openStream();
 119             Reader reader = new InputStreamReader( is );
 120             MetadataXpp3Reader metadataReader = new MetadataXpp3Reader();
 121
 122             Metadata m = metadataReader.read( reader );
 123             String metaGroupId = m.getGroupId();
 124             String metaArtifactId = m.getArtifactId();
 125             String metaVersion = m.getVersion();
 126
 127             // check if the groupId, artifactId and version is in the
 128             // metadataPath
 129             // parse the path, in reverse order
 130             List pathParts = new ArrayList();
 131             StringTokenizer st = new StringTokenizer( metadataPath, "/\\" );
 132             while ( st.hasMoreTokens() )
 133             {
 134                 pathParts.add( st.nextToken() );
 135             }
 136
 137             Collections.reverse( pathParts );
 138             // remove the metadata file
 139             pathParts.remove( 0 );
 140             Iterator it = pathParts.iterator();
 141             String tmpDir = (String) it.next();
 142
 143             ArtifactHandler handler = new DefaultArtifactHandler( "jar" );
 144             VersionRange version = VersionRange.createFromVersion( metaVersion );
 145             Artifact artifact =
 146                 new DefaultArtifact( metaGroupId, metaArtifactId, version, "compile", "jar", "", handler );
 147
 148             // snapshotMetadata
 149             if ( tmpDir.equals( metaVersion ) )
 150             {
 151                 metadata = new SnapshotArtifactRepositoryMetadata( artifact );
 152             }
 153             else if ( tmpDir.equals( metaArtifactId ) )
 154             {
 155                 // artifactMetadata
 156                 metadata = new ArtifactRepositoryMetadata( artifact );
 157             }
 158             else
 159             {
 160
 161                 String groupDir = "";
 162                 int ctr = 0;
 163                 for ( it = pathParts.iterator(); it.hasNext(); )
 164                 {
 165                     if ( ctr == 0 )
 166                     {
 167                         groupDir = (String) it.next();
 168                     }
 169                     else
 170                     {
 171                         groupDir = (String) it.next() + "." + groupDir;
 172                     }
 173                     ctr++;
 174                 }
 175
 176                 // groupMetadata
 177                 if ( metaGroupId.equals( groupDir ) )
 178                 {
 179                     metadata = new GroupRepositoryMetadata( metaGroupId );
 180                 }
 181             }
 182
 183         }
 184         catch ( FileNotFoundException fe )
 185         {
 186             return null;
 187         }
 188         catch ( XmlPullParserException xe )
 189         {
 190             return null;
 191         }
 192         catch ( IOException ie )
 193         {
 194             return null;
 195         }
 196
 197         return metadata;
 198     }
 199
 200     /**
 201      * Scan or search for metadata files.
 202      *
 203      * @param repositoryBase      The repository directory.
 204      * @param blacklistedPatterns The patterns to be exluded from the search.
 205      * @return
 206      */
 207     private String[] scanForMetadataPaths( File repositoryBase, String blacklistedPatterns )
 208     {
 209
 210         List allExcludes = new ArrayList();
 211         allExcludes.addAll( FileUtils.getDefaultExcludesAsList() );
 212         allExcludes.addAll( Arrays.asList( STANDARD_DISCOVERY_EXCLUDES ) );
 213
 214         if ( blacklistedPatterns != null && blacklistedPatterns.length() > 0 )
 215         {
 216             allExcludes.addAll( Arrays.asList( blacklistedPatterns.split( "," ) ) );
 217         }
 218
 219         DirectoryScanner scanner = new DirectoryScanner();
 220         scanner.setBasedir( repositoryBase );
 221         scanner.setIncludes( STANDARD_DISCOVERY_INCLUDES );
 222         scanner.setExcludes( (String[]) allExcludes.toArray( EMPTY_STRING_ARRAY ) );
 223         scanner.scan();
 224
 225         excludedPaths.addAll( Arrays.asList( scanner.getExcludedFiles() ) );
 226
 227         return scanner.getIncludedFiles();
 228
 229     }
 230
 231     public Iterator getExcludedPathsIterator()
 232     {
 233         return excludedPaths.iterator();
 234     }
 235
 236     public Iterator getKickedOutPathsIterator()
 237     {
 238         return kickedOutPaths.iterator();
 239     }
 240
 241 }