archiva/archiva-modules/plugins/audit/src/main/java/org/apache/archiva/audit/DefaultAuditManager.java

package org.apache.archiva.audit;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import org.apache.archiva.metadata.model.facets.AuditEvent;
import org.apache.archiva.metadata.repository.MetadataRepository;
import org.apache.archiva.metadata.repository.MetadataRepositoryException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.TimeZone;

/**
 *
 */
@Service("auditManager#default")
public class DefaultAuditManager
    implements AuditManager
{
    private static final int NUM_RECENT_EVENTS = 10;

    private static final Logger log = LoggerFactory.getLogger( DefaultAuditManager.class );

    private static final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone( "UTC" );

    @Override
    public List<AuditEvent> getMostRecentAuditEvents( MetadataRepository metadataRepository,
                                                      List<String> repositoryIds )
        throws MetadataRepositoryException
    {
        // TODO: consider a more efficient implementation that directly gets the last ten from the content repository
        List<AuditRecord> records = new ArrayList<>();
        for ( String repositoryId : repositoryIds )
        {
            List<String> names = metadataRepository.getMetadataFacets( repositoryId, AuditEvent.FACET_ID );
            for ( String name : names )
            {
                records.add( new AuditRecord( repositoryId, name ) );
            }
        }
        Collections.sort( records );
        records = records.subList( 0, records.size() < NUM_RECENT_EVENTS ? records.size() : NUM_RECENT_EVENTS );

        List<AuditEvent> events = new ArrayList<>( records.size() );
        for ( AuditRecord record : records )
        {
            AuditEvent auditEvent = (AuditEvent) metadataRepository.getMetadataFacet( record.repositoryId,
                                                                                      AuditEvent.FACET_ID,
                                                                                      record.name );
            events.add( auditEvent );
        }
        return events;
    }

    @Override
    public void addAuditEvent( MetadataRepository repository, AuditEvent event )
        throws MetadataRepositoryException
    {
        // ignore those with no repository - they will still be logged to the textual audit log
        if ( event.getRepositoryId() != null )
        {
            repository.addMetadataFacet( event.getRepositoryId(), event );
        }
    }

    @Override
    public void deleteAuditEvents( MetadataRepository metadataRepository, String repositoryId )
        throws MetadataRepositoryException
    {
        metadataRepository.removeMetadataFacets( repositoryId, AuditEvent.FACET_ID );
    }

    @Override
    public List<AuditEvent> getAuditEventsInRange( MetadataRepository metadataRepository,
                                                   Collection<String> repositoryIds, Date startTime, Date endTime )
        throws MetadataRepositoryException
    {
        return getAuditEventsInRange( metadataRepository, repositoryIds, null, startTime, endTime );
    }

    @Override
    public List<AuditEvent> getAuditEventsInRange( MetadataRepository metadataRepository,
                                                   Collection<String> repositoryIds, String resource, Date startTime,
                                                   Date endTime )
        throws MetadataRepositoryException
    {
        List<AuditEvent> results = new ArrayList<>();
        for ( String repositoryId : repositoryIds )
        {
            List<String> list = metadataRepository.getMetadataFacets( repositoryId, AuditEvent.FACET_ID );
            for ( String name : list )
            {
                try
                {
                    Date date = createNameFormat().parse( name );
                    if ( ( startTime == null || !date.before( startTime ) ) && ( endTime == null || !date.after(
                        endTime ) ) )
                    {
                        AuditEvent event = (AuditEvent) metadataRepository.getMetadataFacet( repositoryId,
                                                                                             AuditEvent.FACET_ID,
                                                                                             name );

                        if ( resource == null || event.getResource().startsWith( resource ) )
                        {
                            results.add( event );
                        }
                    }
                }
                catch ( ParseException e )
                {
                    log.error( "Invalid audit event found in the metadata repository: " + e.getMessage() );
                    // continue and ignore this one
                }
            }
        }
        Collections.sort( results, new Comparator<AuditEvent>()
        {
            @Override
            public int compare( AuditEvent o1, AuditEvent o2 )
            {
                return o2.getTimestamp().compareTo( o1.getTimestamp() );
            }
        } );
        return results;
    }

    private static SimpleDateFormat createNameFormat()
    {
        SimpleDateFormat fmt = new SimpleDateFormat( AuditEvent.TIMESTAMP_FORMAT );
        fmt.setTimeZone( UTC_TIME_ZONE );
        return fmt;
    }

    private static final class AuditRecord
        implements Comparable<AuditRecord>
    {
        private String repositoryId;

        private String name;

        public AuditRecord( String repositoryId, String name )
        {
            this.repositoryId = repositoryId;
            this.name = name;
        }

        @Override
        public int compareTo( AuditRecord other )
        {
            // reverse ordering
            return other.name.compareTo( name );
        }
    }
}