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

   1 package org.apache.archiva.metadata.repository.stats;
   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.archiva.metadata.model.MetadataFacet;
  23
  24 import java.text.SimpleDateFormat;
  25 import java.util.Date;
  26 import java.util.HashMap;
  27 import java.util.Map;
  28 import java.util.TimeZone;
  29
  30 public class RepositoryStatistics
  31     implements MetadataFacet
  32 {
  33     private Date scanEndTime;
  34
  35     private Date scanStartTime;
  36
  37     private long totalArtifactCount;
  38
  39     private long totalArtifactFileSize;
  40
  41     private long totalFileCount;
  42
  43     private long totalGroupCount;
  44
  45     private long totalProjectCount;
  46
  47     private long newFileCount;
  48
  49     public static String FACET_ID = "org.apache.archiva.metadata.repository.stats";
  50
  51     static final String SCAN_TIMESTAMP_FORMAT = "yyyy/MM/dd/HHmmss.SSS";
  52
  53     private Map<String, Long> totalCountForType = new ZeroForNullHashMap<String, Long>();
  54
  55     private static final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone( "UTC" );
  56
  57     public Date getScanEndTime()
  58     {
  59         return scanEndTime;
  60     }
  61
  62     public void setScanEndTime( Date scanEndTime )
  63     {
  64         this.scanEndTime = scanEndTime;
  65     }
  66
  67     public Date getScanStartTime()
  68     {
  69         return scanStartTime;
  70     }
  71
  72     public void setScanStartTime( Date scanStartTime )
  73     {
  74         this.scanStartTime = scanStartTime;
  75     }
  76
  77     public long getTotalArtifactCount()
  78     {
  79         return totalArtifactCount;
  80     }
  81
  82     public void setTotalArtifactCount( long totalArtifactCount )
  83     {
  84         this.totalArtifactCount = totalArtifactCount;
  85     }
  86
  87     public long getTotalArtifactFileSize()
  88     {
  89         return totalArtifactFileSize;
  90     }
  91
  92     public void setTotalArtifactFileSize( long totalArtifactFileSize )
  93     {
  94         this.totalArtifactFileSize = totalArtifactFileSize;
  95     }
  96
  97     public long getTotalFileCount()
  98     {
  99         return totalFileCount;
 100     }
 101
 102     public void setTotalFileCount( long totalFileCount )
 103     {
 104         this.totalFileCount = totalFileCount;
 105     }
 106
 107     public long getTotalGroupCount()
 108     {
 109         return totalGroupCount;
 110     }
 111
 112     public void setTotalGroupCount( long totalGroupCount )
 113     {
 114         this.totalGroupCount = totalGroupCount;
 115     }
 116
 117     public long getTotalProjectCount()
 118     {
 119         return totalProjectCount;
 120     }
 121
 122     public void setTotalProjectCount( long totalProjectCount )
 123     {
 124         this.totalProjectCount = totalProjectCount;
 125     }
 126
 127     public void setNewFileCount( long newFileCount )
 128     {
 129         this.newFileCount = newFileCount;
 130     }
 131
 132     public long getNewFileCount()
 133     {
 134         return newFileCount;
 135     }
 136
 137     public long getDuration()
 138     {
 139         return scanEndTime.getTime() - scanStartTime.getTime();
 140     }
 141
 142     public String getFacetId()
 143     {
 144         return FACET_ID;
 145     }
 146
 147     public String getName()
 148     {
 149         return createNameFormat().format( scanStartTime );
 150     }
 151
 152     private static SimpleDateFormat createNameFormat()
 153     {
 154         SimpleDateFormat fmt = new SimpleDateFormat( SCAN_TIMESTAMP_FORMAT );
 155         fmt.setTimeZone( UTC_TIME_ZONE );
 156         return fmt;
 157     }
 158
 159     public Map<String, String> toProperties()
 160     {
 161         Map<String, String> properties = new HashMap<String, String>();
 162         properties.put( "scanEndTime", String.valueOf( scanEndTime.getTime() ) );
 163         properties.put( "scanStartTime", String.valueOf( scanStartTime.getTime() ) );
 164         properties.put( "totalArtifactCount", String.valueOf( totalArtifactCount ) );
 165         properties.put( "totalArtifactFileSize", String.valueOf( totalArtifactFileSize ) );
 166         properties.put( "totalFileCount", String.valueOf( totalFileCount ) );
 167         properties.put( "totalGroupCount", String.valueOf( totalGroupCount ) );
 168         properties.put( "totalProjectCount", String.valueOf( totalProjectCount ) );
 169         properties.put( "newFileCount", String.valueOf( newFileCount ) );
 170         for ( Map.Entry<String, Long> entry : totalCountForType.entrySet() )
 171         {
 172             properties.put( "count-" + entry.getKey(), String.valueOf( entry.getValue() ) );
 173         }
 174         return properties;
 175     }
 176
 177     public void fromProperties( Map<String, String> properties )
 178     {
 179         scanEndTime = new Date( Long.parseLong( properties.get( "scanEndTime" ) ) );
 180         scanStartTime = new Date( Long.parseLong( properties.get( "scanStartTime" ) ) );
 181         totalArtifactCount = Long.parseLong( properties.get( "totalArtifactCount" ) );
 182         totalArtifactFileSize = Long.parseLong( properties.get( "totalArtifactFileSize" ) );
 183         totalFileCount = Long.parseLong( properties.get( "totalFileCount" ) );
 184         totalGroupCount = Long.parseLong( properties.get( "totalGroupCount" ) );
 185         totalProjectCount = Long.parseLong( properties.get( "totalProjectCount" ) );
 186         newFileCount = Long.parseLong( properties.get( "newFileCount" ) );
 187         totalCountForType.clear();
 188         for ( Map.Entry<String, String> entry : properties.entrySet() )
 189         {
 190             if ( entry.getKey().startsWith( "count-" ) )
 191             {
 192                 totalCountForType.put( entry.getKey().substring( 6 ), Long.valueOf( entry.getValue() ) );
 193             }
 194         }
 195     }
 196
 197     @Override
 198     public boolean equals( Object o )
 199     {
 200         if ( this == o )
 201         {
 202             return true;
 203         }
 204         if ( o == null || getClass() != o.getClass() )
 205         {
 206             return false;
 207         }
 208
 209         RepositoryStatistics that = (RepositoryStatistics) o;
 210
 211         if ( newFileCount != that.newFileCount )
 212         {
 213             return false;
 214         }
 215         if ( totalArtifactCount != that.totalArtifactCount )
 216         {
 217             return false;
 218         }
 219         if ( totalArtifactFileSize != that.totalArtifactFileSize )
 220         {
 221             return false;
 222         }
 223         if ( totalFileCount != that.totalFileCount )
 224         {
 225             return false;
 226         }
 227         if ( totalGroupCount != that.totalGroupCount )
 228         {
 229             return false;
 230         }
 231         if ( totalProjectCount != that.totalProjectCount )
 232         {
 233             return false;
 234         }
 235         if ( !scanEndTime.equals( that.scanEndTime ) )
 236         {
 237             return false;
 238         }
 239         if ( !scanStartTime.equals( that.scanStartTime ) )
 240         {
 241             return false;
 242         }
 243         if ( !totalCountForType.equals( that.totalCountForType ) )
 244         {
 245             return false;
 246         }
 247
 248         return true;
 249     }
 250
 251     @Override
 252     public int hashCode()
 253     {
 254         int result = scanEndTime.hashCode();
 255         result = 31 * result + scanStartTime.hashCode();
 256         result = 31 * result + (int) ( totalArtifactCount ^ ( totalArtifactCount >>> 32 ) );
 257         result = 31 * result + (int) ( totalArtifactFileSize ^ ( totalArtifactFileSize >>> 32 ) );
 258         result = 31 * result + (int) ( totalFileCount ^ ( totalFileCount >>> 32 ) );
 259         result = 31 * result + (int) ( totalGroupCount ^ ( totalGroupCount >>> 32 ) );
 260         result = 31 * result + (int) ( totalProjectCount ^ ( totalProjectCount >>> 32 ) );
 261         result = 31 * result + (int) ( newFileCount ^ ( newFileCount >>> 32 ) );
 262         result = 31 * result + totalCountForType.hashCode();
 263         return result;
 264     }
 265
 266     @Override
 267     public String toString()
 268     {
 269         return "RepositoryStatistics{" + "scanEndTime=" + scanEndTime + ", scanStartTime=" + scanStartTime +
 270             ", totalArtifactCount=" + totalArtifactCount + ", totalArtifactFileSize=" + totalArtifactFileSize +
 271             ", totalFileCount=" + totalFileCount + ", totalGroupCount=" + totalGroupCount + ", totalProjectCount=" +
 272             totalProjectCount + ", newFileCount=" + newFileCount + ", totalCountForType=" + totalCountForType + '}';
 273     }
 274
 275     public Map<String, Long> getTotalCountForType()
 276     {
 277         return totalCountForType;
 278     }
 279
 280     public long getTotalCountForType( String type )
 281     {
 282         return totalCountForType.get( type );
 283     }
 284
 285     public void setTotalCountForType( String type, long count )
 286     {
 287         totalCountForType.put( type, count );
 288     }
 289
 290     private static final class ZeroForNullHashMap<K, V extends Long> extends HashMap<K, V>
 291     {
 292         @Override
 293         public V get(Object key) {
 294             V value = super.get( key );
 295
 296             return value != null ? value : ( V ) Long.valueOf( 0L );
 297         }
 298     }
 299 }