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

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