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

   1 package org.apache.maven.archiva.reporting.metadata;
   2
   3 import org.apache.commons.lang.StringUtils;
   4 import org.codehaus.plexus.util.FileUtils;
   5
   6 import java.io.File;
   7 import java.io.IOException;
   8 import java.util.ArrayList;
   9 import java.util.Arrays;
  10 import java.util.Collections;
  11 import java.util.HashMap;
  12 import java.util.Iterator;
  13 import java.util.List;
  14 import java.util.Map;
  15
  16 /**
  17  * MetadataValidateConsumer
  18  *
  19  * @author <a href="mailto:joakime@apache.org">Joakim Erdfelt</a>
  20  * @version $Id$
  21  *
  22  * TODO: whoops, how do we consumer metadata?
  23  */
  24 public class MetadataValidateConsumer
  25 {
  26
  27 //    /**
  28 //     * Process the metadata encountered in the repository and report all errors found, if any.
  29 //     *
  30 //     * @param metadata   the metadata to be processed.
  31 //     * @param repository the repository where the metadata was encountered
  32 //     * @param reporter   the ReportingDatabase to receive processing results
  33 //     */
  34 //    public void processMetadata( RepositoryMetadata metadata, ArtifactRepository repository )
  35 //    {
  36 //        if ( metadata.storedInGroupDirectory() )
  37 //        {
  38 //            try
  39 //            {
  40 //                checkPluginMetadata( metadata, repository );
  41 //            }
  42 //            catch ( IOException e )
  43 //            {
  44 //                addWarning( metadata, null, "Error getting plugin artifact directories versions: " + e );
  45 //            }
  46 //        }
  47 //        else
  48 //        {
  49 //            Versioning versioning = metadata.getMetadata().getVersioning();
  50 //            boolean found = false;
  51 //            if ( versioning != null )
  52 //            {
  53 //                String lastUpdated = versioning.getLastUpdated();
  54 //                if ( lastUpdated != null && lastUpdated.length() != 0 )
  55 //                {
  56 //                    found = true;
  57 //                }
  58 //            }
  59 //            if ( !found )
  60 //            {
  61 //                addFailure( metadata, "missing-last-updated", "Missing lastUpdated element inside the metadata." );
  62 //            }
  63 //
  64 //            if ( metadata.storedInArtifactVersionDirectory() )
  65 //            {
  66 //                checkSnapshotMetadata( metadata, repository );
  67 //            }
  68 //            else
  69 //            {
  70 //                checkMetadataVersions( metadata, repository );
  71 //
  72 //                try
  73 //                {
  74 //                    checkRepositoryVersions( metadata, repository );
  75 //                }
  76 //                catch ( IOException e )
  77 //                {
  78 //                    String reason = "Error getting plugin artifact directories versions: " + e;
  79 //                    addWarning( metadata, null, reason );
  80 //                }
  81 //            }
  82 //        }
  83 //    }
  84 //
  85 //    private void addWarning( RepositoryMetadata metadata, String problem, String reason )
  86 //    {
  87 //        // TODO: reason could be an i18n key derived from the processor and the problem ID and the
  88 //        database.addWarning( metadata, ROLE_HINT, problem, reason );
  89 //    }
  90 //
  91 //    /**
  92 //     * Method for processing a GroupRepositoryMetadata
  93 //     *
  94 //     * @param metadata   the metadata to be processed.
  95 //     * @param repository the repository where the metadata was encountered
  96 //     * @param reporter   the ReportingDatabase to receive processing results
  97 //     */
  98 //    private void checkPluginMetadata( RepositoryMetadata metadata, ArtifactRepository repository )
  99 //        throws IOException
 100 //    {
 101 //        File metadataDir = new File( repository.getBasedir(), repository.pathOfRemoteRepositoryMetadata( metadata ) )
 102 //            .getParentFile();
 103 //        List pluginDirs = getArtifactIdFiles( metadataDir );
 104 //
 105 //        Map prefixes = new HashMap();
 106 //        for ( Iterator plugins = metadata.getMetadata().getPlugins().iterator(); plugins.hasNext(); )
 107 //        {
 108 //            Plugin plugin = (Plugin) plugins.next();
 109 //
 110 //            String artifactId = plugin.getArtifactId();
 111 //            if ( artifactId == null || artifactId.length() == 0 )
 112 //            {
 113 //                addFailure( metadata, "missing-artifact-id:" + plugin.getPrefix(),
 114 //                            "Missing or empty artifactId in group metadata for plugin " + plugin.getPrefix() );
 115 //            }
 116 //
 117 //            String prefix = plugin.getPrefix();
 118 //            if ( prefix == null || prefix.length() == 0 )
 119 //            {
 120 //                addFailure( metadata, "missing-plugin-prefix:" + artifactId,
 121 //                            "Missing or empty plugin prefix for artifactId " + artifactId + "." );
 122 //            }
 123 //            else
 124 //            {
 125 //                if ( prefixes.containsKey( prefix ) )
 126 //                {
 127 //                    addFailure( metadata, "duplicate-plugin-prefix:" + prefix, "Duplicate plugin prefix found: "
 128 //                        + prefix + "." );
 129 //                }
 130 //                else
 131 //                {
 132 //                    prefixes.put( prefix, plugin );
 133 //                }
 134 //            }
 135 //
 136 //            if ( artifactId != null && artifactId.length() > 0 )
 137 //            {
 138 //                File pluginDir = new File( metadataDir, artifactId );
 139 //                if ( !pluginDirs.contains( pluginDir ) )
 140 //                {
 141 //                    addFailure( metadata, "missing-plugin-from-repository:" + artifactId, "Metadata plugin "
 142 //                        + artifactId + " not found in the repository" );
 143 //                }
 144 //                else
 145 //                {
 146 //                    pluginDirs.remove( pluginDir );
 147 //                }
 148 //            }
 149 //        }
 150 //
 151 //        if ( pluginDirs.size() > 0 )
 152 //        {
 153 //            for ( Iterator plugins = pluginDirs.iterator(); plugins.hasNext(); )
 154 //            {
 155 //                File plugin = (File) plugins.next();
 156 //                addFailure( metadata, "missing-plugin-from-metadata:" + plugin.getName(), "Plugin " + plugin.getName()
 157 //                    + " is present in the repository but " + "missing in the metadata." );
 158 //            }
 159 //        }
 160 //    }
 161 //
 162 //    /**
 163 //     * Method for processing a SnapshotArtifactRepository
 164 //     *
 165 //     * @param metadata   the metadata to be processed.
 166 //     * @param repository the repository where the metadata was encountered
 167 //     * @param reporter   the ReportingDatabase to receive processing results
 168 //     */
 169 //    private void checkSnapshotMetadata( RepositoryMetadata metadata, ArtifactRepository repository )
 170 //    {
 171 //        RepositoryQueryLayer repositoryQueryLayer = repositoryQueryLayerFactory.createRepositoryQueryLayer( repository );
 172 //
 173 //        Versioning versioning = metadata.getMetadata().getVersioning();
 174 //        if ( versioning != null )
 175 //        {
 176 //            Snapshot snapshot = versioning.getSnapshot();
 177 //
 178 //            String version = StringUtils.replace( metadata.getBaseVersion(), Artifact.SNAPSHOT_VERSION, snapshot
 179 //                .getTimestamp()
 180 //                + "-" + snapshot.getBuildNumber() );
 181 //            Artifact artifact = artifactFactory.createProjectArtifact( metadata.getGroupId(), metadata.getArtifactId(),
 182 //                                                                       version );
 183 //            artifact.isSnapshot(); // trigger baseVersion correction
 184 //
 185 //            if ( !repositoryQueryLayer.containsArtifact( artifact ) )
 186 //            {
 187 //                addFailure( metadata, "missing-snapshot-artifact-from-repository:" + version, "Snapshot artifact "
 188 //                    + version + " does not exist." );
 189 //            }
 190 //        }
 191 //    }
 192 //
 193 //    /**
 194 //     * Method for validating the versions declared inside an ArtifactRepositoryMetadata
 195 //     *
 196 //     * @param metadata   the metadata to be processed.
 197 //     * @param repository the repository where the metadata was encountered
 198 //     * @param reporter   the ReportingDatabase to receive processing results
 199 //     */
 200 //    private void checkMetadataVersions( RepositoryMetadata metadata, ArtifactRepository repository )
 201 //    {
 202 //        RepositoryQueryLayer repositoryQueryLayer = repositoryQueryLayerFactory.createRepositoryQueryLayer( repository );
 203 //
 204 //        Versioning versioning = metadata.getMetadata().getVersioning();
 205 //        if ( versioning != null )
 206 //        {
 207 //            for ( Iterator versions = versioning.getVersions().iterator(); versions.hasNext(); )
 208 //            {
 209 //                String version = (String) versions.next();
 210 //
 211 //                Artifact artifact = artifactFactory.createProjectArtifact( metadata.getGroupId(), metadata
 212 //                    .getArtifactId(), version );
 213 //
 214 //                if ( !repositoryQueryLayer.containsArtifact( artifact ) )
 215 //                {
 216 //                    addFailure( metadata, "missing-artifact-from-repository:" + version, "Artifact version " + version
 217 //                        + " is present in metadata but " + "missing in the repository." );
 218 //                }
 219 //            }
 220 //        }
 221 //    }
 222 //
 223 //    /**
 224 //     * Searches the artifact repository directory for all versions and verifies that all of them are listed in the
 225 //     * ArtifactRepositoryMetadata
 226 //     *
 227 //     * @param metadata   the metadata to be processed.
 228 //     * @param repository the repository where the metadata was encountered
 229 //     * @param reporter   the ReportingDatabase to receive processing results
 230 //     * @throws java.io.IOException if there is a problem reading from the file system
 231 //     */
 232 //    private void checkRepositoryVersions( RepositoryMetadata metadata, ArtifactRepository repository )
 233 //        throws IOException
 234 //    {
 235 //        Versioning versioning = metadata.getMetadata().getVersioning();
 236 //        List metadataVersions = versioning != null ? versioning.getVersions() : Collections.EMPTY_LIST;
 237 //        File versionsDir = new File( repository.getBasedir(), repository.pathOfRemoteRepositoryMetadata( metadata ) )
 238 //            .getParentFile();
 239 //
 240 //        // TODO: I don't know how this condition can happen, but it was seen on the main repository.
 241 //        // Avoid hard failure
 242 //        if ( versionsDir.exists() )
 243 //        {
 244 //            List versions = FileUtils.getFileNames( versionsDir, "*/*.pom", null, false );
 245 //            for ( Iterator i = versions.iterator(); i.hasNext(); )
 246 //            {
 247 //                File path = new File( (String) i.next() );
 248 //                String version = path.getParentFile().getName();
 249 //                if ( !metadataVersions.contains( version ) )
 250 //                {
 251 //                    addFailure( metadata, "missing-artifact-from-metadata:" + version, "Artifact version " + version
 252 //                        + " found in the repository but " + "missing in the metadata." );
 253 //                }
 254 //            }
 255 //        }
 256 //        else
 257 //        {
 258 //            addFailure( metadata, null, "Metadata's directory did not exist: " + versionsDir );
 259 //        }
 260 //    }
 261 //
 262 //    /**
 263 //     * Used to gather artifactIds from a groupId directory.
 264 //     *
 265 //     * @param groupIdDir the directory of the group
 266 //     * @return the list of artifact ID File objects for each directory
 267 //     * @throws IOException if there was a failure to read the directories
 268 //     */
 269 //    private List getArtifactIdFiles( File groupIdDir )
 270 //        throws IOException
 271 //    {
 272 //        List artifactIdFiles = new ArrayList();
 273 //
 274 //        File[] files = groupIdDir.listFiles();
 275 //        if ( files != null )
 276 //        {
 277 //            for ( Iterator i = Arrays.asList( files ).iterator(); i.hasNext(); )
 278 //            {
 279 //                File artifactDir = (File) i.next();
 280 //
 281 //                if ( artifactDir.isDirectory() )
 282 //                {
 283 //                    List versions = FileUtils.getFileNames( artifactDir, "*/*.pom", null, false );
 284 //                    if ( versions.size() > 0 )
 285 //                    {
 286 //                        artifactIdFiles.add( artifactDir );
 287 //                    }
 288 //                }
 289 //            }
 290 //        }
 291 //
 292 //        return artifactIdFiles;
 293 //    }
 294 //
 295 //    private void addFailure( RepositoryMetadata metadata, String problem, String reason )
 296 //    {
 297 //        // TODO: reason could be an i18n key derived from the processor and the problem ID and the
 298 //        database.addFailure( metadata, ROLE_HINT, problem, reason );
 299 //    }
 300
 301 }