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

   1 package org.apache.maven.archiva.reporting.database;
   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.archiva.reporting.model.ArtifactResults;
  20 import org.apache.maven.archiva.reporting.model.MetadataResults;
  21 import org.apache.maven.archiva.reporting.model.Reporting;
  22 import org.apache.maven.archiva.reporting.model.Result;
  23 import org.apache.maven.archiva.reporting.group.ReportGroup;
  24 import org.apache.maven.artifact.Artifact;
  25 import org.apache.maven.artifact.repository.ArtifactRepository;
  26 import org.apache.maven.artifact.repository.metadata.RepositoryMetadata;
  27
  28 import java.util.Date;
  29 import java.util.HashMap;
  30 import java.util.Iterator;
  31 import java.util.LinkedHashSet;
  32 import java.util.Map;
  33 import java.util.Set;
  34
  35 /**
  36  * @todo i18n, including message formatting and parameterisation
  37  */
  38 public class ReportingDatabase
  39 {
  40     private final Reporting reporting;
  41
  42     private Map artifactMap;
  43
  44     private Map metadataMap;
  45
  46     private int numFailures;
  47
  48     private int numWarnings;
  49
  50     private ArtifactRepository repository;
  51
  52     private boolean inProgress;
  53
  54     private long startTime;
  55
  56     private final ReportGroup reportGroup;
  57
  58     private Set metadataWithProblems;
  59
  60     private Map filteredDatabases = new HashMap();
  61
  62     private int numNotices;
  63
  64     public ReportingDatabase( ReportGroup reportGroup )
  65     {
  66         this( reportGroup, new Reporting() );
  67     }
  68
  69     public ReportingDatabase( ReportGroup reportGroup, Reporting reporting )
  70     {
  71         this( reportGroup, reporting, null );
  72     }
  73
  74     public ReportingDatabase( ReportGroup reportGroup, ArtifactRepository repository )
  75     {
  76         this( reportGroup, new Reporting(), repository );
  77     }
  78
  79     public ReportingDatabase( ReportGroup reportGroup, Reporting reporting, ArtifactRepository repository )
  80     {
  81         this.reportGroup = reportGroup;
  82
  83         this.reporting = reporting;
  84
  85         this.repository = repository;
  86
  87         initArtifactMap();
  88
  89         initMetadataMap();
  90     }
  91
  92     public void addFailure( Artifact artifact, String processor, String problem, String reason )
  93     {
  94         ArtifactResults results = getArtifactResults( artifact );
  95         Result result = createResult( processor, problem, reason );
  96         if ( !results.getFailures().contains( result ) )
  97         {
  98             results.addFailure( result );
  99             numFailures++;
 100         }
 101         updateTimings();
 102
 103         if ( filteredDatabases.containsKey( problem ) )
 104         {
 105             ReportingDatabase reportingDatabase = (ReportingDatabase) filteredDatabases.get( problem );
 106
 107             reportingDatabase.addFailure( artifact, processor, problem, reason );
 108         }
 109     }
 110
 111     public void addNotice( Artifact artifact, String processor, String problem, String reason )
 112     {
 113         ArtifactResults results = getArtifactResults( artifact );
 114         Result result = createResult( processor, problem, reason );
 115         if ( !results.getNotices().contains( result ) )
 116         {
 117             results.addNotice( result );
 118             numNotices++;
 119         }
 120         updateTimings();
 121
 122         if ( filteredDatabases.containsKey( problem ) )
 123         {
 124             ReportingDatabase reportingDatabase = (ReportingDatabase) filteredDatabases.get( problem );
 125
 126             reportingDatabase.addNotice( artifact, processor, problem, reason );
 127         }
 128     }
 129
 130     public void addWarning( Artifact artifact, String processor, String problem, String reason )
 131     {
 132         ArtifactResults results = getArtifactResults( artifact );
 133         Result result = createResult( processor, problem, reason );
 134         if ( !results.getWarnings().contains( result ) )
 135         {
 136             results.addWarning( result );
 137             numWarnings++;
 138         }
 139         updateTimings();
 140
 141         if ( filteredDatabases.containsKey( problem ) )
 142         {
 143             ReportingDatabase reportingDatabase = (ReportingDatabase) filteredDatabases.get( problem );
 144
 145             reportingDatabase.addWarning( artifact, processor, problem, reason );
 146         }
 147     }
 148
 149     ArtifactResults getArtifactResults( Artifact artifact )
 150     {
 151         return getArtifactResults( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(),
 152                                    artifact.getType(), artifact.getClassifier() );
 153     }
 154
 155     private ArtifactResults getArtifactResults( String groupId, String artifactId, String version, String type,
 156                                                 String classifier )
 157     {
 158         Map artifactMap = this.artifactMap;
 159
 160         String key = getArtifactKey( groupId, artifactId, version, type, classifier );
 161         ArtifactResults results = (ArtifactResults) artifactMap.get( key );
 162         if ( results == null )
 163         {
 164             results = new ArtifactResults();
 165             results.setArtifactId( artifactId );
 166             results.setClassifier( classifier );
 167             results.setGroupId( groupId );
 168             results.setType( type );
 169             results.setVersion( version );
 170
 171             artifactMap.put( key, results );
 172             reporting.getArtifacts().add( results );
 173         }
 174
 175         return results;
 176     }
 177
 178     private void initArtifactMap()
 179     {
 180         Map map = new HashMap();
 181         for ( Iterator i = reporting.getArtifacts().iterator(); i.hasNext(); )
 182         {
 183             ArtifactResults result = (ArtifactResults) i.next();
 184
 185             String key = getArtifactKey( result.getGroupId(), result.getArtifactId(), result.getVersion(),
 186                                          result.getType(), result.getClassifier() );
 187             map.put( key, result );
 188
 189             numFailures += result.getFailures().size();
 190             numWarnings += result.getWarnings().size();
 191             numNotices += result.getNotices().size();
 192         }
 193         artifactMap = map;
 194     }
 195
 196     private static String getArtifactKey( String groupId, String artifactId, String version, String type,
 197                                           String classifier )
 198     {
 199         return groupId + ":" + artifactId + ":" + version + ":" + type + ":" + classifier;
 200     }
 201
 202     private static Result createResult( String processor, String problem, String reason )
 203     {
 204         Result result = new Result();
 205         result.setProcessor( processor );
 206         result.setProblem( problem );
 207         result.setReason( reason );
 208         return result;
 209     }
 210
 211     public void addFailure( RepositoryMetadata metadata, String processor, String problem, String reason )
 212     {
 213         MetadataResults results = getMetadataResults( metadata, System.currentTimeMillis() );
 214         if ( !metadataWithProblems.contains( results ) )
 215         {
 216             metadataWithProblems.add( results );
 217         }
 218         Result result = createResult( processor, problem, reason );
 219         if ( !results.getFailures().contains( result ) )
 220         {
 221             results.addFailure( result );
 222             numFailures++;
 223         }
 224         updateTimings();
 225
 226         if ( filteredDatabases.containsKey( problem ) )
 227         {
 228             ReportingDatabase reportingDatabase = (ReportingDatabase) filteredDatabases.get( problem );
 229
 230             reportingDatabase.addFailure( metadata, processor, problem, reason );
 231         }
 232     }
 233
 234     public void addWarning( RepositoryMetadata metadata, String processor, String problem, String reason )
 235     {
 236         MetadataResults results = getMetadataResults( metadata, System.currentTimeMillis() );
 237         if ( !metadataWithProblems.contains( results ) )
 238         {
 239             metadataWithProblems.add( results );
 240         }
 241         Result result = createResult( processor, problem, reason );
 242         if ( !results.getWarnings().contains( result ) )
 243         {
 244             results.addWarning( result );
 245             numWarnings++;
 246         }
 247         updateTimings();
 248
 249         if ( filteredDatabases.containsKey( problem ) )
 250         {
 251             ReportingDatabase reportingDatabase = (ReportingDatabase) filteredDatabases.get( problem );
 252
 253             reportingDatabase.addWarning( metadata, processor, problem, reason );
 254         }
 255     }
 256
 257     public void addNotice( RepositoryMetadata metadata, String processor, String problem, String reason )
 258     {
 259         MetadataResults results = getMetadataResults( metadata, System.currentTimeMillis() );
 260         if ( !metadataWithProblems.contains( results ) )
 261         {
 262             metadataWithProblems.add( results );
 263         }
 264         Result result = createResult( processor, problem, reason );
 265         if ( !results.getNotices().contains( result ) )
 266         {
 267             results.addNotice( result );
 268             numNotices++;
 269         }
 270         updateTimings();
 271
 272         if ( filteredDatabases.containsKey( problem ) )
 273         {
 274             ReportingDatabase reportingDatabase = (ReportingDatabase) filteredDatabases.get( problem );
 275
 276             reportingDatabase.addNotice( metadata, processor, problem, reason );
 277         }
 278     }
 279
 280     public Set getMetadataWithProblems()
 281     {
 282         return metadataWithProblems;
 283     }
 284
 285     private void initMetadataMap()
 286     {
 287         Map map = new HashMap();
 288         Set problems = new LinkedHashSet();
 289
 290         for ( Iterator i = reporting.getMetadata().iterator(); i.hasNext(); )
 291         {
 292             MetadataResults result = (MetadataResults) i.next();
 293
 294             String key = getMetadataKey( result.getGroupId(), result.getArtifactId(), result.getVersion() );
 295
 296             map.put( key, result );
 297
 298             numFailures += result.getFailures().size();
 299             numWarnings += result.getWarnings().size();
 300             numNotices += result.getNotices().size();
 301
 302             if ( !result.getFailures().isEmpty() || !result.getWarnings().isEmpty() || !result.getNotices().isEmpty() )
 303             {
 304                 problems.add( result );
 305             }
 306         }
 307         metadataMap = map;
 308         metadataWithProblems = problems;
 309     }
 310
 311     private static String getMetadataKey( String groupId, String artifactId, String version )
 312     {
 313         return groupId + ":" + artifactId + ":" + version;
 314     }
 315
 316     public int getNumFailures()
 317     {
 318         return numFailures;
 319     }
 320
 321     public int getNumWarnings()
 322     {
 323         return numWarnings;
 324     }
 325
 326     public Reporting getReporting()
 327     {
 328         return reporting;
 329     }
 330
 331     public Iterator getArtifactIterator()
 332     {
 333         return reporting.getArtifacts().iterator();
 334     }
 335
 336     public Iterator getMetadataIterator()
 337     {
 338         return reporting.getMetadata().iterator();
 339     }
 340
 341     public boolean isMetadataUpToDate( RepositoryMetadata metadata, long timestamp )
 342     {
 343         String key = getMetadataKey( metadata.getGroupId(), metadata.getArtifactId(), metadata.getBaseVersion() );
 344         Map map = metadataMap;
 345         MetadataResults results = (MetadataResults) map.get( key );
 346         return results != null && results.getLastModified() >= timestamp;
 347     }
 348
 349     /**
 350      * Make sure the metadata record exists, but remove any previous reports in preparation for adding new ones.
 351      *
 352      * @param metadata     the metadata
 353      * @param lastModified the modification time of the file being tracked
 354      */
 355     public void cleanMetadata( RepositoryMetadata metadata, long lastModified )
 356     {
 357         MetadataResults results = getMetadataResults( metadata, lastModified );
 358
 359         results.setLastModified( lastModified );
 360
 361         numFailures -= results.getFailures().size();
 362         results.getFailures().clear();
 363
 364         numWarnings -= results.getWarnings().size();
 365         results.getWarnings().clear();
 366
 367         numNotices -= results.getWarnings().size();
 368         results.getNotices().clear();
 369
 370         metadataWithProblems.remove( results );
 371     }
 372
 373     MetadataResults getMetadataResults( RepositoryMetadata metadata, long lastModified )
 374     {
 375         return getMetadataResults( metadata.getGroupId(), metadata.getArtifactId(), metadata.getBaseVersion(),
 376                                    lastModified );
 377     }
 378
 379     private MetadataResults getMetadataResults( String groupId, String artifactId, String baseVersion,
 380                                                 long lastModified )
 381     {
 382         String key = getMetadataKey( groupId, artifactId, baseVersion );
 383         Map metadataMap = this.metadataMap;
 384         MetadataResults results = (MetadataResults) metadataMap.get( key );
 385         if ( results == null )
 386         {
 387             results = new MetadataResults();
 388             results.setArtifactId( artifactId );
 389             results.setGroupId( groupId );
 390             results.setVersion( baseVersion );
 391             results.setLastModified( lastModified );
 392
 393             metadataMap.put( key, results );
 394             reporting.getMetadata().add( results );
 395         }
 396         return results;
 397     }
 398
 399     public void removeArtifact( Artifact artifact )
 400     {
 401         Map map = artifactMap;
 402
 403         String key = getArtifactKey( artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(),
 404                                      artifact.getType(), artifact.getClassifier() );
 405         ArtifactResults results = (ArtifactResults) map.get( key );
 406         if ( results != null )
 407         {
 408             for ( Iterator i = reporting.getArtifacts().iterator(); i.hasNext(); )
 409             {
 410                 if ( results.equals( i.next() ) )
 411                 {
 412                     i.remove();
 413                 }
 414             }
 415
 416             numFailures -= results.getFailures().size();
 417             numWarnings -= results.getWarnings().size();
 418             numNotices -= results.getNotices().size();
 419
 420             map.remove( key );
 421         }
 422     }
 423
 424     public ArtifactRepository getRepository()
 425     {
 426         return repository;
 427     }
 428
 429     public boolean isInProgress()
 430     {
 431         return inProgress;
 432     }
 433
 434     public void setInProgress( boolean inProgress )
 435     {
 436         this.inProgress = inProgress;
 437
 438         if ( inProgress )
 439         {
 440             startTime = System.currentTimeMillis();
 441         }
 442     }
 443
 444     public void clear()
 445     {
 446         // clear the values rather than destroy the instance so that the "inProgress" indicator is in tact.
 447         numWarnings = 0;
 448         numNotices = 0;
 449         numFailures = 0;
 450
 451         artifactMap.clear();
 452         metadataMap.clear();
 453         metadataWithProblems.clear();
 454         filteredDatabases.clear();
 455
 456         reporting.getArtifacts().clear();
 457         reporting.getMetadata().clear();
 458
 459         updateTimings();
 460     }
 461
 462     public void setStartTime( long startTime )
 463     {
 464         this.startTime = startTime;
 465     }
 466
 467     public long getStartTime()
 468     {
 469         return startTime;
 470     }
 471
 472     public void updateTimings()
 473     {
 474         long startTime = getStartTime();
 475         Date endTime = new Date();
 476         if ( startTime > 0 )
 477         {
 478             getReporting().setExecutionTime( endTime.getTime() - startTime );
 479         }
 480         getReporting().setLastModified( endTime.getTime() );
 481     }
 482
 483     public ReportGroup getReportGroup()
 484     {
 485         return reportGroup;
 486     }
 487
 488     public ReportingDatabase getFilteredDatabase( String filter )
 489     {
 490         ReportingDatabase reportingDatabase = (ReportingDatabase) filteredDatabases.get( filter );
 491
 492         if ( reportingDatabase == null )
 493         {
 494             reportingDatabase = new ReportingDatabase( reportGroup, repository );
 495
 496             Reporting reporting = reportingDatabase.getReporting();
 497             reporting.setExecutionTime( this.reporting.getExecutionTime() );
 498             reporting.setLastModified( this.reporting.getLastModified() );
 499
 500             for ( Iterator i = this.reporting.getArtifacts().iterator(); i.hasNext(); )
 501             {
 502                 ArtifactResults results = (ArtifactResults) i.next();
 503                 ArtifactResults targetResults = null;
 504                 for ( Iterator j = results.getFailures().iterator(); j.hasNext(); )
 505                 {
 506                     Result result = (Result) j.next();
 507
 508                     if ( filter.equals( result.getProcessor() ) )
 509                     {
 510                         if ( targetResults == null )
 511                         {
 512                             // lazily create so it is not added unless it has to be
 513                             targetResults = createArtifactResults( reportingDatabase, results );
 514                         }
 515
 516                         targetResults.addFailure( result );
 517                         reportingDatabase.numFailures++;
 518                     }
 519                 }
 520                 for ( Iterator j = results.getWarnings().iterator(); j.hasNext(); )
 521                 {
 522                     Result result = (Result) j.next();
 523
 524                     if ( filter.equals( result.getProcessor() ) )
 525                     {
 526                         if ( targetResults == null )
 527                         {
 528                             // lazily create so it is not added unless it has to be
 529                             targetResults = createArtifactResults( reportingDatabase, results );
 530                         }
 531
 532                         targetResults.addWarning( result );
 533                         reportingDatabase.numWarnings++;
 534                     }
 535                 }
 536                 for ( Iterator j = results.getNotices().iterator(); j.hasNext(); )
 537                 {
 538                     Result result = (Result) j.next();
 539
 540                     if ( filter.equals( result.getProcessor() ) )
 541                     {
 542                         if ( targetResults == null )
 543                         {
 544                             // lazily create so it is not added unless it has to be
 545                             targetResults = createArtifactResults( reportingDatabase, results );
 546                         }
 547
 548                         targetResults.addNotice( result );
 549                         reportingDatabase.numNotices++;
 550                     }
 551                 }
 552             }
 553             for ( Iterator i = this.reporting.getMetadata().iterator(); i.hasNext(); )
 554             {
 555                 MetadataResults results = (MetadataResults) i.next();
 556                 MetadataResults targetResults = null;
 557                 for ( Iterator j = results.getFailures().iterator(); j.hasNext(); )
 558                 {
 559                     Result result = (Result) j.next();
 560
 561                     if ( filter.equals( result.getProcessor() ) )
 562                     {
 563                         if ( targetResults == null )
 564                         {
 565                             // lazily create so it is not added unless it has to be
 566                             targetResults = createMetadataResults( reportingDatabase, results );
 567                         }
 568
 569                         targetResults.addFailure( result );
 570                         reportingDatabase.numFailures++;
 571                     }
 572                 }
 573                 for ( Iterator j = results.getWarnings().iterator(); j.hasNext(); )
 574                 {
 575                     Result result = (Result) j.next();
 576
 577                     if ( filter.equals( result.getProcessor() ) )
 578                     {
 579                         if ( targetResults == null )
 580                         {
 581                             // lazily create so it is not added unless it has to be
 582                             targetResults = createMetadataResults( reportingDatabase, results );
 583                         }
 584
 585                         targetResults.addWarning( result );
 586                         reportingDatabase.numWarnings++;
 587                     }
 588                 }
 589                 for ( Iterator j = results.getNotices().iterator(); j.hasNext(); )
 590                 {
 591                     Result result = (Result) j.next();
 592
 593                     if ( filter.equals( result.getProcessor() ) )
 594                     {
 595                         if ( targetResults == null )
 596                         {
 597                             // lazily create so it is not added unless it has to be
 598                             targetResults = createMetadataResults( reportingDatabase, results );
 599                         }
 600
 601                         targetResults.addNotice( result );
 602                         reportingDatabase.numNotices++;
 603                     }
 604                 }
 605             }
 606
 607             filteredDatabases.put( filter, reportingDatabase );
 608         }
 609
 610         return reportingDatabase;
 611     }
 612
 613     private static MetadataResults createMetadataResults( ReportingDatabase reportingDatabase, MetadataResults results )
 614     {
 615         MetadataResults targetResults = reportingDatabase.getMetadataResults( results.getGroupId(),
 616                                                                               results.getArtifactId(),
 617                                                                               results.getVersion(),
 618                                                                               results.getLastModified() );
 619         reportingDatabase.metadataWithProblems.add( targetResults );
 620         return targetResults;
 621     }
 622
 623     private static ArtifactResults createArtifactResults( ReportingDatabase reportingDatabase, ArtifactResults results )
 624     {
 625         return reportingDatabase.getArtifactResults( results.getGroupId(), results.getArtifactId(),
 626                                                      results.getVersion(), results.getType(), results.getClassifier() );
 627     }
 628
 629     public int getNumNotices()
 630     {
 631         return numNotices;
 632     }
 633 }