diff options
9 files changed, 905 insertions, 981 deletions
diff --git a/archiva-modules/metadata/metadata-model/src/main/java/org/apache/archiva/metadata/model/ArtifactMetadata.java b/archiva-modules/metadata/metadata-model/src/main/java/org/apache/archiva/metadata/model/ArtifactMetadata.java index c129d1ed8..8bb12d3dd 100644 --- a/archiva-modules/metadata/metadata-model/src/main/java/org/apache/archiva/metadata/model/ArtifactMetadata.java +++ b/archiva-modules/metadata/metadata-model/src/main/java/org/apache/archiva/metadata/model/ArtifactMetadata.java @@ -19,6 +19,8 @@ package org.apache.archiva.metadata.model; * under the License. */ +import sun.reflect.generics.repository.MethodRepository; + import javax.xml.bind.annotation.XmlRootElement; import java.time.Instant; import java.time.LocalDateTime; @@ -39,6 +41,8 @@ import java.util.Date; public class ArtifactMetadata extends FacetedMetadata { + + /** * The artifact ID uniquely identifies an artifact within a given namespace, project and project version. For * example, <tt>archiva-1.4-20100201.345612-2.jar</tt> @@ -145,12 +149,12 @@ public class ArtifactMetadata public void setFileLastModified( long fileLastModified ) { - this.fileLastModified = ZonedDateTime.ofInstant(Instant.ofEpochMilli(fileLastModified), ZoneId.of("GMT")); + this.fileLastModified = ZonedDateTime.ofInstant(Instant.ofEpochMilli(fileLastModified), ModelInfo.STORAGE_TZ); } public void setWhenGathered( ZonedDateTime whenGathered ) { - this.whenGathered = whenGathered; + this.whenGathered = whenGathered.withZoneSameInstant(ModelInfo.STORAGE_TZ); } public void setMd5( String md5 ) diff --git a/archiva-modules/metadata/metadata-model/src/main/java/org/apache/archiva/metadata/model/ModelInfo.java b/archiva-modules/metadata/metadata-model/src/main/java/org/apache/archiva/metadata/model/ModelInfo.java new file mode 100644 index 000000000..de1a1c0df --- /dev/null +++ b/archiva-modules/metadata/metadata-model/src/main/java/org/apache/archiva/metadata/model/ModelInfo.java @@ -0,0 +1,30 @@ +package org.apache.archiva.metadata.model; + +/* + * 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 java.time.ZoneId; + +public interface ModelInfo { + + /** + * The timezone used for storing the time / date information + */ + ZoneId STORAGE_TZ = ZoneId.of("UTC"); +} diff --git a/archiva-modules/metadata/metadata-repository-api/src/main/java/org/apache/archiva/metadata/repository/AbstractMetadataRepository.java b/archiva-modules/metadata/metadata-repository-api/src/main/java/org/apache/archiva/metadata/repository/AbstractMetadataRepository.java index 7d7258645..c4e27103c 100644 --- a/archiva-modules/metadata/metadata-repository-api/src/main/java/org/apache/archiva/metadata/repository/AbstractMetadataRepository.java +++ b/archiva-modules/metadata/metadata-repository-api/src/main/java/org/apache/archiva/metadata/repository/AbstractMetadataRepository.java @@ -26,11 +26,10 @@ import org.apache.archiva.metadata.model.MetadataFacetFactory; import org.apache.archiva.metadata.model.ProjectMetadata; import org.apache.archiva.metadata.model.ProjectVersionMetadata; import org.apache.archiva.metadata.model.ProjectVersionReference; +import org.apache.commons.collections4.ComparatorUtils; import java.time.ZonedDateTime; -import java.util.Collection; -import java.util.List; -import java.util.Set; +import java.util.*; import java.util.stream.Stream; public abstract class AbstractMetadataRepository @@ -119,7 +118,7 @@ public abstract class AbstractMetadataRepository } @Override - public Collection<ArtifactMetadata> getArtifactsByChecksum( RepositorySession session, String repositoryId, String checksum ) + public List<ArtifactMetadata> getArtifactsByChecksum(RepositorySession session, String repositoryId, String checksum ) throws MetadataRepositoryException { throw new UnsupportedOperationException(); @@ -255,6 +254,45 @@ public abstract class AbstractMetadataRepository throw new UnsupportedOperationException(); } + protected static Comparator<ArtifactMetadata> getArtifactMetadataComparator(final QueryParameter queryParameter, String defaultAttr) { + List<Comparator<ArtifactMetadata>> compList = new ArrayList<>(); + List<String> sortFields = new ArrayList<>(); + if (queryParameter.getSortFields().size() == 0) { + sortFields.add(defaultAttr); + } else { + sortFields = queryParameter.getSortFields(); + } + for (String attribute : sortFields) { + switch (attribute) { + case "id": + compList.add(Comparator.comparing(ArtifactMetadata::getId)); + break; + case "whenGathered": + compList.add(Comparator.comparing(ArtifactMetadata::getWhenGathered)); + break; + case "fileLastModified": + compList.add(Comparator.comparing(ArtifactMetadata::getFileLastModified)); + case "version": + compList.add(Comparator.comparing(ArtifactMetadata::getVersion)); + break; + case "projectVersion": + compList.add(Comparator.comparing(ArtifactMetadata::getProjectVersion)); + break; + case "project": + compList.add(Comparator.comparing(ArtifactMetadata::getProject)); + break; + default: + // + } + } + Comparator<ArtifactMetadata> comp = ComparatorUtils.chainedComparator(compList); + if (queryParameter.isAscending()) { + return comp; + } else { + return comp.reversed(); + } + } + @Override public Collection<ArtifactMetadata> getArtifacts( RepositorySession session, String repoId, String namespace, String projectId, String projectVersion ) diff --git a/archiva-modules/metadata/metadata-repository-api/src/main/java/org/apache/archiva/metadata/repository/MetadataRepository.java b/archiva-modules/metadata/metadata-repository-api/src/main/java/org/apache/archiva/metadata/repository/MetadataRepository.java index b0849cd14..e679704c8 100644 --- a/archiva-modules/metadata/metadata-repository-api/src/main/java/org/apache/archiva/metadata/repository/MetadataRepository.java +++ b/archiva-modules/metadata/metadata-repository-api/src/main/java/org/apache/archiva/metadata/repository/MetadataRepository.java @@ -26,6 +26,7 @@ import org.apache.archiva.metadata.model.ProjectMetadata; import org.apache.archiva.metadata.model.ProjectVersionMetadata; import org.apache.archiva.metadata.model.ProjectVersionReference; +import java.time.ZoneId; import java.time.ZonedDateTime; import java.util.Collection; import java.util.List; @@ -87,9 +88,16 @@ import java.util.stream.Stream; * * Facets can be stored on repository, project, version and artifact level. * + * For retrieving artifacts there are methods that return lists and streaming based methods. Some implementations (e.g. JCR) use + * lazy loading for the retrieved objects. So the streaming methods may be faster and use less memory than the list based methods. + * But for some backends there is no difference. + * */ public interface MetadataRepository { + + + /** * Update metadata for a particular project in the metadata repository, or create it, if it does not already exist. * @@ -155,15 +163,46 @@ public interface MetadataRepository List<String> getMetadataFacets( RepositorySession session, String repositoryId, String facetId ) throws MetadataRepositoryException; + + /** + * + * The same as + * @see #getMetadataFacetStream(RepositorySession, String, Class, QueryParameter queryParameter) + * but uses default query parameters. + * + * There is no limitation of the number of result objects returned, but implementations may have a hard upper bound for + * the number of results. + * + * @param session + * @param repositoryId + * @param facetClazz + * @param <T> + * @return + * @throws MetadataRepositoryException + * @since 3.0 + */ <T extends MetadataFacet> Stream<T> getMetadataFacetStream( RepositorySession session, String repositoryId, Class<T> facetClazz) throws MetadataRepositoryException; + /** + * Returns a stream of MetadataFacet elements that match the given facet class. + * Implementations should order the resulting stream by facet name. + * + * + * @param session The repository session + * @param repositoryId The repository id + * @param facetClazz The class of the facet + * @param <T> The facet type + * @return + * @throws MetadataRepositoryException + * @since 3.0 + */ <T extends MetadataFacet> Stream<T> getMetadataFacetStream(RepositorySession session, String repositoryId, Class<T> facetClazz, QueryParameter queryParameter) throws MetadataRepositoryException; /** - * Returns true, if there is facet data stored for the given id on the repository. The facet data itself - * may be empty. It's just checking if there is data stored for the given facet id. + * Returns true, if there is facet data stored for the given facet id on the repository on repository level. The facet data itself + * may be empty. It's just checking if there is an object stored for the given facet id. * * @param session The repository session * @param repositoryId The repository id @@ -200,13 +239,14 @@ public interface MetadataRepository * @param name The name of the facet (name or path) * @param <T> The type of the facet object * @return The facet instance, if it exists. - * @throws MetadataRepositoryException + * @throws MetadataRepositoryException if the data cannot be retrieved from the backend + * @since 3.0 */ <T extends MetadataFacet> T getMetadataFacet(RepositorySession session, String repositoryId, Class<T> clazz, String name) throws MetadataRepositoryException; /** - * Adss a facet to the repository level. + * Adds a facet to the repository level. * * @param session The repository session * @param repositoryId The id of the repository @@ -238,41 +278,79 @@ public interface MetadataRepository void removeMetadataFacet( RepositorySession session, String repositoryId, String facetId, String name ) throws MetadataRepositoryException; + /** - * if startTime or endTime are <code>null</code> they are not used for search - * + * Is the same as {@link #getArtifactsByDateRange(RepositorySession, String, ZonedDateTime, ZonedDateTime, QueryParameter)}, but + * uses default query parameters. * - * @param session - * @param repositoryId - * @param startTime can be <code>null</code> - * @param endTime can be <code>null</code> - * @return - * @throws MetadataRepositoryException */ List<ArtifactMetadata> getArtifactsByDateRange(RepositorySession session, String repositoryId, ZonedDateTime startTime, ZonedDateTime endTime ) throws MetadataRepositoryException; + /** + * + * Searches for artifacts where the 'whenGathered' attribute value is between the given start and end time. + * If start or end time or both are <code>null</code>, the time range for the search is unbounded for this parameter. + * + * + * @param session The repository session + * @param repositoryId The repository id + * @param startTime The start time/date as zoned date, can be <code>null</code> + * @param endTime The end time/date as zoned date, can be <code>null</code> + * @param queryParameter Additional parameters for the query that affect ordering and returned results + * @return The list of metadata objects for the found instances. + * @throws MetadataRepositoryException if the query fails. + * @since 3.0 + */ List<ArtifactMetadata> getArtifactsByDateRange(RepositorySession session, String repositoryId, ZonedDateTime startTime, ZonedDateTime endTime, QueryParameter queryParameter ) throws MetadataRepositoryException; /** - * Returns all the artifacts - * @param session - * @param repositoryId - * @param startTime - * @param endTime - * @return + * Returns all the artifacts who's 'whenGathered' attribute value is inside the given time range (inclusive) as stream of objects. + * + * Implementations should return a stream of sorted objects. The objects should be sorted by the 'whenGathered' date in ascending order. + * + * @param session The repository session + * @param repositoryId The repository id + * @param startTime The start time, can be <code>null</code> + * @param endTime The end time, can be <code>null</code> + * @return A stream of artifact metadata objects. * @throws MetadataRepositoryException + * @since 3.0 */ Stream<ArtifactMetadata> getArtifactsByDateRangeStream( RepositorySession session, String repositoryId, ZonedDateTime startTime, ZonedDateTime endTime ) throws MetadataRepositoryException; + /** + * Returns all the artifacts who's 'whenGathered' attribute value is inside the given time range (inclusive) as stream of objects. + * + * If no sort attributes are given by the queryParameter, the result is sorted by the 'whenGathered' date. + * + * @param session The repository session + * @param repositoryId The repository id + * @param startTime The start time, can be <code>null</code> + * @param endTime The end time, can be <code>null</code> + * @param queryParameter Additional parameters for the query that affect ordering and number of returned results. + * @return A stream of artifact metadata objects. + * @throws MetadataRepositoryException + * @since 3.0 + */ Stream<ArtifactMetadata> getArtifactsByDateRangeStream(RepositorySession session, String repositoryId, ZonedDateTime startTime, ZonedDateTime endTime, QueryParameter queryParameter) throws MetadataRepositoryException; - Collection<ArtifactMetadata> getArtifactsByChecksum( RepositorySession session, String repositoryId, String checksum ) + + /** + * Returns the artifacts that match the given checksum. All checksum types are searched. + * + * @param session The repository session + * @param repositoryId The repository id + * @param checksum The checksum as string of numbers + * @return The list of artifacts that match the given checksum. + * @throws MetadataRepositoryException + */ + List<ArtifactMetadata> getArtifactsByChecksum(RepositorySession session, String repositoryId, String checksum ) throws MetadataRepositoryException; /** diff --git a/archiva-modules/metadata/metadata-repository-api/src/test/java/org/apache/archiva/metadata/repository/AbstractMetadataRepositoryTest.java b/archiva-modules/metadata/metadata-repository-api/src/test/java/org/apache/archiva/metadata/repository/AbstractMetadataRepositoryTest.java index d34f8ab0c..a747b7f28 100644 --- a/archiva-modules/metadata/metadata-repository-api/src/test/java/org/apache/archiva/metadata/repository/AbstractMetadataRepositoryTest.java +++ b/archiva-modules/metadata/metadata-repository-api/src/test/java/org/apache/archiva/metadata/repository/AbstractMetadataRepositoryTest.java @@ -903,7 +903,7 @@ public abstract class AbstractMetadataRepositoryTest { for (int i = 0; i<500; i++) { - getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_FACET_ID, TEST_VALUE, TEST_NAME+"/"+i ) ); + getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_FACET_ID, TEST_VALUE, TEST_NAME+"/"+String.format("%03d",i) ) ); } } @@ -916,15 +916,79 @@ public abstract class AbstractMetadataRepositoryTest assertEquals( 100, result.size( ) ); assertNotNull( result.get( 0 ) ); for (int i=0; i<10; i++) { - log.info( "Result {}", result.get( i ).getName( ) ); + assertEquals(TEST_NAME + "/" + String.format("%03d",i), result.get(i).getName()); } - assertEquals( TEST_NAME+"/"+0, result.get( 0 ).getName( ) ); - }, 2, 500 ); + }, 3, 500 ); } } @Test + public void testGetMetadataFacetsStreamWithOffset( ) + throws Exception + { + try ( RepositorySession session = getSessionFactory( ).createSession( ) ) + { + for (int i = 0; i<100; i++) + { + getRepository( ).addMetadataFacet( session, TEST_REPO_ID, new TestMetadataFacet( TEST_FACET_ID, TEST_VALUE, TEST_NAME+"/"+String.format("%03d", i) ) ); + } + } + + try ( RepositorySession session = getSessionFactory( ).createSession( ) ) + { + tryAssert( ( ) -> { + Stream<TestMetadataFacet> str = getRepository( ).getMetadataFacetStream( session, TEST_REPO_ID, TestMetadataFacet.class, new QueryParameter(5, 10)); + assertNotNull( str ); + List<TestMetadataFacet> result = str.collect( Collectors.toList( ) ); + assertEquals( 10, result.size( ) ); + assertNotNull( result.get( 0 ) ); + for (int i=0; i<10; i++) { + assertEquals(TEST_NAME + "/" + String.format("%03d",i+5), result.get(i).getName()); + } + }, 3, 500 ); + + } + } + + @Test + public void testGetArtifactsByDateRangeStreamLowerAndUpperBound( ) + throws Exception + { + try ( RepositorySession session = getSessionFactory( ).createSession( ) ) + { + final ArtifactMetadata artifact1 = createArtifact( ); + artifact1.setWhenGathered(ZonedDateTime.now().minusDays(1)); + getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact1 ); + final ArtifactMetadata artifact2 = createArtifact( ); + artifact2.setId(artifact2.getId()+"-2"); + artifact2.setVersion(TEST_PROJECT_VERSION+"-2"); + artifact2.setWhenGathered(ZonedDateTime.now()); + getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact2 ); + final ArtifactMetadata artifact3 = createArtifact(); + artifact3.setId(artifact3.getId()+"-3"); + artifact3.setVersion(TEST_PROJECT_VERSION+"-3"); + artifact3.setWhenGathered(ZonedDateTime.now().plusDays(1)); + getRepository( ).updateArtifact( session, TEST_REPO_ID, TEST_NAMESPACE, TEST_PROJECT, TEST_PROJECT_VERSION, artifact3 ); + session.save( ); + + ZonedDateTime lower = artifact2.getWhenGathered().minusSeconds(10); + ZonedDateTime upper = artifact2.getWhenGathered().plusSeconds(10); + + tryAssert( ( ) -> { + Stream<ArtifactMetadata> stream = getRepository().getArtifactsByDateRangeStream(session, TEST_REPO_ID, lower, upper, new QueryParameter()); + assertNotNull(stream); + + List<ArtifactMetadata> artifacts = stream.collect(Collectors.toList()); + assertEquals(1, artifacts.size()); + + + assertEquals( Collections.singletonList( artifact2 ), artifacts ); + } ); + } + } + + @Test public void testGetMetadataFacetsWhenEmpty( ) throws Exception { diff --git a/archiva-modules/plugins/metadata-store-cassandra/src/main/java/org/apache/archiva/metadata/repository/cassandra/CassandraMetadataRepository.java b/archiva-modules/plugins/metadata-store-cassandra/src/main/java/org/apache/archiva/metadata/repository/cassandra/CassandraMetadataRepository.java index 21df69da8..97a57533d 100644 --- a/archiva-modules/plugins/metadata-store-cassandra/src/main/java/org/apache/archiva/metadata/repository/cassandra/CassandraMetadataRepository.java +++ b/archiva-modules/plugins/metadata-store-cassandra/src/main/java/org/apache/archiva/metadata/repository/cassandra/CassandraMetadataRepository.java @@ -73,18 +73,7 @@ import org.slf4j.LoggerFactory; import java.time.Instant; import java.time.ZoneId; import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedList; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.Spliterator; -import java.util.UUID; +import java.util.*; import java.util.function.BiFunction; import java.util.function.Consumer; import java.util.stream.Stream; @@ -1795,7 +1784,7 @@ public class CassandraMetadataRepository @Override public List<ArtifactMetadata> getArtifactsByDateRange( RepositorySession session, final String repositoryId, final ZonedDateTime startTime, - final ZonedDateTime endTime ) + final ZonedDateTime endTime, QueryParameter queryParameter ) throws MetadataRepositoryException { @@ -1805,6 +1794,7 @@ public class CassandraMetadataRepository .setColumnFamily( cassandraArchivaManager.getArtifactMetadataFamilyName() ) // .setColumnNames( ArtifactMetadataModel.COLUMNS ); // + if ( startTime != null ) { query = query.addGteExpression( WHEN_GATHERED.toString(), startTime.toInstant().toEpochMilli() ); @@ -1831,10 +1821,25 @@ public class CassandraMetadataRepository return artifactMetadatas; } + /** + * For documentation see {@link MetadataRepository#getArtifactsByDateRangeStream(RepositorySession, String, ZonedDateTime, ZonedDateTime, QueryParameter)} + * + * This implementation orders the stream. It does not order the query in the backend. + * + * @param session The repository session + * @param repositoryId The repository id + * @param startTime The start time, can be <code>null</code> + * @param endTime The end time, can be <code>null</code> + * @param queryParameter Additional parameters for the query that affect ordering and number of returned results. + * @return + * @throws MetadataRepositoryException + * @see MetadataRepository#getArtifactsByDateRangeStream + */ @Override public Stream<ArtifactMetadata> getArtifactsByDateRangeStream(RepositorySession session, String repositoryId, ZonedDateTime startTime, ZonedDateTime endTime, QueryParameter queryParameter) throws MetadataRepositoryException { - return null; + Comparator<ArtifactMetadata> comp = getArtifactMetadataComparator(queryParameter, "whenGathered"); + return getArtifactsByDateRange(session, repositoryId, startTime, endTime, queryParameter).stream().sorted(comp).skip(queryParameter.getOffset()).limit(queryParameter.getLimit()); } @@ -1881,7 +1886,7 @@ public class CassandraMetadataRepository } @Override - public Collection<ArtifactMetadata> getArtifactsByChecksum( RepositorySession session, final String repositoryId, final String checksum ) + public List<ArtifactMetadata> getArtifactsByChecksum(RepositorySession session, final String repositoryId, final String checksum ) throws MetadataRepositoryException { @@ -1923,7 +1928,7 @@ public class CassandraMetadataRepository } - return artifactMetadataMap.values(); + return new ArrayList(artifactMetadataMap.values()); } /** diff --git a/archiva-modules/plugins/metadata-store-file/src/main/java/org/apache/archiva/metadata/repository/file/FileMetadataRepository.java b/archiva-modules/plugins/metadata-store-file/src/main/java/org/apache/archiva/metadata/repository/file/FileMetadataRepository.java index eee6c0259..272f53664 100644 --- a/archiva-modules/plugins/metadata-store-file/src/main/java/org/apache/archiva/metadata/repository/file/FileMetadataRepository.java +++ b/archiva-modules/plugins/metadata-store-file/src/main/java/org/apache/archiva/metadata/repository/file/FileMetadataRepository.java @@ -22,25 +22,8 @@ package org.apache.archiva.metadata.repository.file; import org.apache.archiva.configuration.ArchivaConfiguration; import org.apache.archiva.configuration.ManagedRepositoryConfiguration; import org.apache.archiva.metadata.QueryParameter; -import org.apache.archiva.metadata.model.ArtifactMetadata; -import org.apache.archiva.metadata.model.CiManagement; -import org.apache.archiva.metadata.model.Dependency; -import org.apache.archiva.metadata.model.IssueManagement; -import org.apache.archiva.metadata.model.License; -import org.apache.archiva.metadata.model.MailingList; -import org.apache.archiva.metadata.model.MetadataFacet; -import org.apache.archiva.metadata.model.MetadataFacetFactory; -import org.apache.archiva.metadata.model.Organization; -import org.apache.archiva.metadata.model.ProjectMetadata; -import org.apache.archiva.metadata.model.ProjectVersionMetadata; -import org.apache.archiva.metadata.model.ProjectVersionReference; -import org.apache.archiva.metadata.model.Scm; -import org.apache.archiva.metadata.repository.AbstractMetadataRepository; -import org.apache.archiva.metadata.repository.MetadataRepository; -import org.apache.archiva.metadata.repository.MetadataRepositoryException; -import org.apache.archiva.metadata.repository.MetadataResolutionException; -import org.apache.archiva.metadata.repository.MetadataService; -import org.apache.archiva.metadata.repository.RepositorySession; +import org.apache.archiva.metadata.model.*; +import org.apache.archiva.metadata.repository.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -48,37 +31,20 @@ import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; -import java.nio.file.FileVisitOption; -import java.nio.file.Files; -import java.nio.file.NoSuchFileException; -import java.nio.file.Path; -import java.nio.file.Paths; +import java.nio.file.*; import java.time.Instant; import java.time.ZoneId; import java.time.ZonedDateTime; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collection; -import java.util.Collections; -import java.util.Comparator; -import java.util.HashMap; -import java.util.HashSet; -import java.util.LinkedHashSet; -import java.util.List; -import java.util.Map; -import java.util.Properties; -import java.util.Set; -import java.util.StringTokenizer; +import java.util.*; import java.util.stream.Collectors; import java.util.stream.Stream; public class FileMetadataRepository - extends AbstractMetadataRepository implements MetadataRepository -{ + extends AbstractMetadataRepository implements MetadataRepository { private final ArchivaConfiguration configuration; - private Logger log = LoggerFactory.getLogger( FileMetadataRepository.class ); + private Logger log = LoggerFactory.getLogger(FileMetadataRepository.class); private static final String PROJECT_METADATA_KEY = "project-metadata"; @@ -88,297 +54,250 @@ public class FileMetadataRepository private static final String METADATA_KEY = "metadata"; - private Map<String, Path> baseDirectory = new HashMap<>( ); + private Map<String, Path> baseDirectory = new HashMap<>(); - public FileMetadataRepository( MetadataService metadataService, - ArchivaConfiguration configuration ) - { - super( metadataService ); + public FileMetadataRepository(MetadataService metadataService, + ArchivaConfiguration configuration) { + super(metadataService); this.configuration = configuration; } - private Path getBaseDirectory(String repoId ) - throws IOException - { - if (!baseDirectory.containsKey( repoId )) - { + private Path getBaseDirectory(String repoId) + throws IOException { + if (!baseDirectory.containsKey(repoId)) { Path baseDir; ManagedRepositoryConfiguration managedRepositoryConfiguration = - configuration.getConfiguration( ).getManagedRepositoriesAsMap( ).get( repoId ); - if ( managedRepositoryConfiguration == null ) - { - baseDir = Files.createTempDirectory( repoId ); - } else - { - baseDir = Paths.get( managedRepositoryConfiguration.getLocation( ) ); + configuration.getConfiguration().getManagedRepositoriesAsMap().get(repoId); + if (managedRepositoryConfiguration == null) { + baseDir = Files.createTempDirectory(repoId); + } else { + baseDir = Paths.get(managedRepositoryConfiguration.getLocation()); } - baseDirectory.put(repoId, baseDir.resolve( ".archiva" )); + baseDirectory.put(repoId, baseDir.resolve(".archiva")); } return baseDirectory.get(repoId); } - private Path getDirectory( String repoId ) - throws IOException - { - return getBaseDirectory( repoId ).resolve( "content" ); + private Path getDirectory(String repoId) + throws IOException { + return getBaseDirectory(repoId).resolve("content"); } @Override - public void updateProject( RepositorySession session, String repoId, ProjectMetadata project ) - { - updateProject( session, repoId, project.getNamespace(), project.getId() ); + public void updateProject(RepositorySession session, String repoId, ProjectMetadata project) { + updateProject(session, repoId, project.getNamespace(), project.getId()); } - private void updateProject( RepositorySession session, String repoId, String namespace, String id ) - { + private void updateProject(RepositorySession session, String repoId, String namespace, String id) { // TODO: this is a more braindead implementation than we would normally expect, for prototyping purposes - updateNamespace( session, repoId, namespace ); + updateNamespace(session, repoId, namespace); - try - { - Path namespaceDirectory = getDirectory( repoId ).resolve( namespace ); + try { + Path namespaceDirectory = getDirectory(repoId).resolve(namespace); Properties properties = new Properties(); - properties.setProperty( "namespace", namespace ); - properties.setProperty( "id", id ); - writeProperties( properties, namespaceDirectory.resolve( id ), PROJECT_METADATA_KEY ); - } - catch ( IOException e ) - { - log.error( "Could not update project {}, {}, {}: {}", repoId, namespace, id, e.getMessage(), e ); + properties.setProperty("namespace", namespace); + properties.setProperty("id", id); + writeProperties(properties, namespaceDirectory.resolve(id), PROJECT_METADATA_KEY); + } catch (IOException e) { + log.error("Could not update project {}, {}, {}: {}", repoId, namespace, id, e.getMessage(), e); } } @Override - public void updateProjectVersion( RepositorySession session, String repoId, String namespace, String projectId, - ProjectVersionMetadata versionMetadata ) - { + public void updateProjectVersion(RepositorySession session, String repoId, String namespace, String projectId, + ProjectVersionMetadata versionMetadata) { - try - { - updateProject( session, repoId, namespace, projectId ); + try { + updateProject(session, repoId, namespace, projectId); Path directory = - getDirectory( repoId ).resolve( namespace + "/" + projectId + "/" + versionMetadata.getId() ); + getDirectory(repoId).resolve(namespace + "/" + projectId + "/" + versionMetadata.getId()); - Properties properties = readOrCreateProperties( directory, PROJECT_VERSION_METADATA_KEY ); + Properties properties = readOrCreateProperties(directory, PROJECT_VERSION_METADATA_KEY); // remove properties that are not references or artifacts - for ( Object key : new ArrayList<>( properties.keySet() ) ) - { + for (Object key : new ArrayList<>(properties.keySet())) { String name = (String) key; - if ( !name.contains( ":" ) && !name.equals( "facetIds" ) ) - { - properties.remove( name ); + if (!name.contains(":") && !name.equals("facetIds")) { + properties.remove(name); } // clear the facet contents so old properties are no longer written - clearMetadataFacetProperties( versionMetadata.getFacetList(), properties, "" ); + clearMetadataFacetProperties(versionMetadata.getFacetList(), properties, ""); } - properties.setProperty( "id", versionMetadata.getId() ); - setProperty( properties, "name", versionMetadata.getName() ); - setProperty( properties, "description", versionMetadata.getDescription() ); - setProperty( properties, "url", versionMetadata.getUrl() ); - setProperty( properties, "incomplete", String.valueOf( versionMetadata.isIncomplete() ) ); - if ( versionMetadata.getScm() != null ) - { - setProperty( properties, "scm.connection", versionMetadata.getScm().getConnection() ); - setProperty( properties, "scm.developerConnection", versionMetadata.getScm().getDeveloperConnection() ); - setProperty( properties, "scm.url", versionMetadata.getScm().getUrl() ); + properties.setProperty("id", versionMetadata.getId()); + setProperty(properties, "name", versionMetadata.getName()); + setProperty(properties, "description", versionMetadata.getDescription()); + setProperty(properties, "url", versionMetadata.getUrl()); + setProperty(properties, "incomplete", String.valueOf(versionMetadata.isIncomplete())); + if (versionMetadata.getScm() != null) { + setProperty(properties, "scm.connection", versionMetadata.getScm().getConnection()); + setProperty(properties, "scm.developerConnection", versionMetadata.getScm().getDeveloperConnection()); + setProperty(properties, "scm.url", versionMetadata.getScm().getUrl()); } - if ( versionMetadata.getCiManagement() != null ) - { - setProperty( properties, "ci.system", versionMetadata.getCiManagement().getSystem() ); - setProperty( properties, "ci.url", versionMetadata.getCiManagement().getUrl() ); + if (versionMetadata.getCiManagement() != null) { + setProperty(properties, "ci.system", versionMetadata.getCiManagement().getSystem()); + setProperty(properties, "ci.url", versionMetadata.getCiManagement().getUrl()); } - if ( versionMetadata.getIssueManagement() != null ) - { - setProperty( properties, "issue.system", versionMetadata.getIssueManagement().getSystem() ); - setProperty( properties, "issue.url", versionMetadata.getIssueManagement().getUrl() ); + if (versionMetadata.getIssueManagement() != null) { + setProperty(properties, "issue.system", versionMetadata.getIssueManagement().getSystem()); + setProperty(properties, "issue.url", versionMetadata.getIssueManagement().getUrl()); } - if ( versionMetadata.getOrganization() != null ) - { - setProperty( properties, "org.name", versionMetadata.getOrganization().getName() ); - setProperty( properties, "org.url", versionMetadata.getOrganization().getUrl() ); + if (versionMetadata.getOrganization() != null) { + setProperty(properties, "org.name", versionMetadata.getOrganization().getName()); + setProperty(properties, "org.url", versionMetadata.getOrganization().getUrl()); } int i = 0; - for ( License license : versionMetadata.getLicenses() ) - { - setProperty( properties, "license." + i + ".name", license.getName() ); - setProperty( properties, "license." + i + ".url", license.getUrl() ); + for (License license : versionMetadata.getLicenses()) { + setProperty(properties, "license." + i + ".name", license.getName()); + setProperty(properties, "license." + i + ".url", license.getUrl()); i++; } i = 0; - for ( MailingList mailingList : versionMetadata.getMailingLists() ) - { - setProperty( properties, "mailingList." + i + ".archive", mailingList.getMainArchiveUrl() ); - setProperty( properties, "mailingList." + i + ".name", mailingList.getName() ); - setProperty( properties, "mailingList." + i + ".post", mailingList.getPostAddress() ); - setProperty( properties, "mailingList." + i + ".unsubscribe", mailingList.getUnsubscribeAddress() ); - setProperty( properties, "mailingList." + i + ".subscribe", mailingList.getSubscribeAddress() ); - setProperty( properties, "mailingList." + i + ".otherArchives", - join( mailingList.getOtherArchives() ) ); + for (MailingList mailingList : versionMetadata.getMailingLists()) { + setProperty(properties, "mailingList." + i + ".archive", mailingList.getMainArchiveUrl()); + setProperty(properties, "mailingList." + i + ".name", mailingList.getName()); + setProperty(properties, "mailingList." + i + ".post", mailingList.getPostAddress()); + setProperty(properties, "mailingList." + i + ".unsubscribe", mailingList.getUnsubscribeAddress()); + setProperty(properties, "mailingList." + i + ".subscribe", mailingList.getSubscribeAddress()); + setProperty(properties, "mailingList." + i + ".otherArchives", + join(mailingList.getOtherArchives())); i++; } i = 0; ProjectVersionReference reference = new ProjectVersionReference(); - reference.setNamespace( namespace ); - reference.setProjectId( projectId ); - reference.setProjectVersion( versionMetadata.getId() ); - reference.setReferenceType( ProjectVersionReference.ReferenceType.DEPENDENCY ); - for ( Dependency dependency : versionMetadata.getDependencies() ) - { - setProperty( properties, "dependency." + i + ".classifier", dependency.getClassifier() ); - setProperty( properties, "dependency." + i + ".scope", dependency.getScope() ); - setProperty( properties, "dependency." + i + ".systemPath", dependency.getSystemPath() ); - setProperty( properties, "dependency." + i + ".artifactId", dependency.getArtifactId() ); - setProperty( properties, "dependency." + i + ".groupId", dependency.getGroupId() ); - setProperty( properties, "dependency." + i + ".version", dependency.getVersion() ); - setProperty( properties, "dependency." + i + ".type", dependency.getType() ); - setProperty( properties, "dependency." + i + ".optional", String.valueOf( dependency.isOptional() ) ); - - updateProjectReference( repoId, dependency.getGroupId(), dependency.getArtifactId(), - dependency.getVersion(), reference ); + reference.setNamespace(namespace); + reference.setProjectId(projectId); + reference.setProjectVersion(versionMetadata.getId()); + reference.setReferenceType(ProjectVersionReference.ReferenceType.DEPENDENCY); + for (Dependency dependency : versionMetadata.getDependencies()) { + setProperty(properties, "dependency." + i + ".classifier", dependency.getClassifier()); + setProperty(properties, "dependency." + i + ".scope", dependency.getScope()); + setProperty(properties, "dependency." + i + ".systemPath", dependency.getSystemPath()); + setProperty(properties, "dependency." + i + ".artifactId", dependency.getArtifactId()); + setProperty(properties, "dependency." + i + ".groupId", dependency.getGroupId()); + setProperty(properties, "dependency." + i + ".version", dependency.getVersion()); + setProperty(properties, "dependency." + i + ".type", dependency.getType()); + setProperty(properties, "dependency." + i + ".optional", String.valueOf(dependency.isOptional())); + + updateProjectReference(repoId, dependency.getGroupId(), dependency.getArtifactId(), + dependency.getVersion(), reference); i++; } - Set<String> facetIds = new LinkedHashSet<>( versionMetadata.getFacetIds( ) ); - facetIds.addAll( Arrays.asList( properties.getProperty( "facetIds", "" ).split( "," ) ) ); - properties.setProperty( "facetIds", join( facetIds ) ); + Set<String> facetIds = new LinkedHashSet<>(versionMetadata.getFacetIds()); + facetIds.addAll(Arrays.asList(properties.getProperty("facetIds", "").split(","))); + properties.setProperty("facetIds", join(facetIds)); - updateProjectVersionFacets( versionMetadata, properties ); + updateProjectVersionFacets(versionMetadata, properties); - writeProperties( properties, directory, PROJECT_VERSION_METADATA_KEY ); - } - catch ( IOException e ) - { - log.error( "Could not update project version {}, {}, {}: {}", repoId, namespace, versionMetadata.getId(), e.getMessage(), e ); + writeProperties(properties, directory, PROJECT_VERSION_METADATA_KEY); + } catch (IOException e) { + log.error("Could not update project version {}, {}, {}: {}", repoId, namespace, versionMetadata.getId(), e.getMessage(), e); } } - private void updateProjectVersionFacets( ProjectVersionMetadata versionMetadata, Properties properties ) - { - for ( MetadataFacet facet : versionMetadata.getFacetList() ) - { - for ( Map.Entry<String, String> entry : facet.toProperties().entrySet() ) - { - properties.setProperty( facet.getFacetId() + ":" + entry.getKey(), entry.getValue() ); + private void updateProjectVersionFacets(ProjectVersionMetadata versionMetadata, Properties properties) { + for (MetadataFacet facet : versionMetadata.getFacetList()) { + for (Map.Entry<String, String> entry : facet.toProperties().entrySet()) { + properties.setProperty(facet.getFacetId() + ":" + entry.getKey(), entry.getValue()); } } } - private static void clearMetadataFacetProperties( Collection<MetadataFacet> facetList, Properties properties, - String prefix ) - { + private static void clearMetadataFacetProperties(Collection<MetadataFacet> facetList, Properties properties, + String prefix) { List<Object> propsToRemove = new ArrayList<>(); - for ( MetadataFacet facet : facetList ) - { - for ( Object key : new ArrayList<>( properties.keySet() ) ) - { + for (MetadataFacet facet : facetList) { + for (Object key : new ArrayList<>(properties.keySet())) { String keyString = (String) key; - if ( keyString.startsWith( prefix + facet.getFacetId() + ":" ) ) - { - propsToRemove.add( key ); + if (keyString.startsWith(prefix + facet.getFacetId() + ":")) { + propsToRemove.add(key); } } } - for ( Object key : propsToRemove ) - { - properties.remove( key ); + for (Object key : propsToRemove) { + properties.remove(key); } } - private void updateProjectReference( String repoId, String namespace, String projectId, String projectVersion, - ProjectVersionReference reference ) - { - try - { - Path directory = getDirectory( repoId ).resolve( namespace + "/" + projectId + "/" + projectVersion ); - - Properties properties = readOrCreateProperties( directory, PROJECT_VERSION_METADATA_KEY ); - int i = Integer.parseInt( properties.getProperty( "ref:lastReferenceNum", "-1" ) ) + 1; - setProperty( properties, "ref:lastReferenceNum", Integer.toString( i ) ); - setProperty( properties, "ref:reference." + i + ".namespace", reference.getNamespace() ); - setProperty( properties, "ref:reference." + i + ".projectId", reference.getProjectId() ); - setProperty( properties, "ref:reference." + i + ".projectVersion", reference.getProjectVersion() ); - setProperty( properties, "ref:reference." + i + ".referenceType", reference.getReferenceType().toString() ); - - writeProperties( properties, directory, PROJECT_VERSION_METADATA_KEY ); - } - catch ( IOException e ) - { - log.error( "Could not update project reference {}, {}, {}, {}: {}", repoId, namespace, projectId, projectVersion, e.getMessage(), e ); + private void updateProjectReference(String repoId, String namespace, String projectId, String projectVersion, + ProjectVersionReference reference) { + try { + Path directory = getDirectory(repoId).resolve(namespace + "/" + projectId + "/" + projectVersion); + + Properties properties = readOrCreateProperties(directory, PROJECT_VERSION_METADATA_KEY); + int i = Integer.parseInt(properties.getProperty("ref:lastReferenceNum", "-1")) + 1; + setProperty(properties, "ref:lastReferenceNum", Integer.toString(i)); + setProperty(properties, "ref:reference." + i + ".namespace", reference.getNamespace()); + setProperty(properties, "ref:reference." + i + ".projectId", reference.getProjectId()); + setProperty(properties, "ref:reference." + i + ".projectVersion", reference.getProjectVersion()); + setProperty(properties, "ref:reference." + i + ".referenceType", reference.getReferenceType().toString()); + + writeProperties(properties, directory, PROJECT_VERSION_METADATA_KEY); + } catch (IOException e) { + log.error("Could not update project reference {}, {}, {}, {}: {}", repoId, namespace, projectId, projectVersion, e.getMessage(), e); } } @Override - public void updateNamespace( RepositorySession session, String repoId, String namespace ) - { - try - { - Path namespaceDirectory = getDirectory( repoId ).resolve( namespace ); + public void updateNamespace(RepositorySession session, String repoId, String namespace) { + try { + Path namespaceDirectory = getDirectory(repoId).resolve(namespace); Properties properties = new Properties(); - properties.setProperty( "namespace", namespace ); - writeProperties( properties, namespaceDirectory, NAMESPACE_METADATA_KEY ); + properties.setProperty("namespace", namespace); + writeProperties(properties, namespaceDirectory, NAMESPACE_METADATA_KEY); - } - catch ( IOException e ) - { - log.error( "Could not update namespace of {}, {}: {}", repoId, namespace, e.getMessage(), e ); + } catch (IOException e) { + log.error("Could not update namespace of {}, {}: {}", repoId, namespace, e.getMessage(), e); } } @Override - public List<String> getMetadataFacets( RepositorySession session, String repoId, String facetId ) - throws MetadataRepositoryException - { - try - { - Path directory = getMetadataDirectory( repoId, facetId ); + public List<String> getMetadataFacets(RepositorySession session, String repoId, String facetId) + throws MetadataRepositoryException { + try { + Path directory = getMetadataDirectory(repoId, facetId); if (!(Files.exists(directory) && Files.isDirectory(directory))) { return Collections.emptyList(); } List<String> facets; final String searchFile = METADATA_KEY + ".properties"; - try(Stream<Path> fs = Files.walk(directory, FileVisitOption.FOLLOW_LINKS) ) { + try (Stream<Path> fs = Files.walk(directory, FileVisitOption.FOLLOW_LINKS)) { facets = fs.filter(Files::isDirectory).filter(path -> Files.exists(path.resolve(searchFile))) .map(path -> directory.relativize(path).toString()).collect(Collectors.toList()); } return facets; - } - catch ( IOException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public <T extends MetadataFacet> Stream<T> getMetadataFacetStream(RepositorySession session, String repositoryId, Class<T> facetClazz, QueryParameter queryParameter) throws MetadataRepositoryException - { - final MetadataFacetFactory<T> metadataFacetFactory = getFacetFactory( facetClazz ); - if (metadataFacetFactory==null) { + public <T extends MetadataFacet> Stream<T> getMetadataFacetStream(RepositorySession session, String repositoryId, Class<T> facetClazz, QueryParameter queryParameter) throws MetadataRepositoryException { + final MetadataFacetFactory<T> metadataFacetFactory = getFacetFactory(facetClazz); + if (metadataFacetFactory == null) { return null; } - final String facetId = metadataFacetFactory.getFacetId( ); + final String facetId = metadataFacetFactory.getFacetId(); final String searchFile = METADATA_KEY + ".properties"; - try - { - Path directory = getMetadataDirectory( repositoryId, facetId ); - return Files.walk( directory, FileVisitOption.FOLLOW_LINKS ).filter( Files::isDirectory ) - .filter( path -> Files.exists( path.resolve( searchFile ) ) ) - .map(path -> directory.relativize(path).toString()) - .sorted() - .skip( queryParameter.getOffset()) - .limit(queryParameter.getLimit()) - .map(name -> getMetadataFacet( session, repositoryId, facetClazz, name )); + try { + Path directory = getMetadataDirectory(repositoryId, facetId); + return Files.walk(directory, FileVisitOption.FOLLOW_LINKS).filter(Files::isDirectory) + .filter(path -> Files.exists(path.resolve(searchFile))) + .map(path -> directory.relativize(path).toString()) + .sorted() + .skip(queryParameter.getOffset()) + .limit(queryParameter.getLimit()) + .map(name -> getMetadataFacet(session, repositoryId, facetClazz, name)); } catch (IOException e) { - throw new MetadataRepositoryException( e.getMessage( ), e ); + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public boolean hasMetadataFacet( RepositorySession session, String repositoryId, String facetId ) - throws MetadataRepositoryException - { + public boolean hasMetadataFacet(RepositorySession session, String repositoryId, String facetId) + throws MetadataRepositoryException { try { Path directory = getMetadataDirectory(repositoryId, facetId); @@ -398,428 +317,350 @@ public class FileMetadataRepository @Override - public <T extends MetadataFacet> T getMetadataFacet( RepositorySession session, String repositoryId, Class<T> facetClazz, String name ) - { - final MetadataFacetFactory<T> metadataFacetFactory = getFacetFactory( facetClazz ); - if (metadataFacetFactory==null) { + public <T extends MetadataFacet> T getMetadataFacet(RepositorySession session, String repositoryId, Class<T> facetClazz, String name) { + final MetadataFacetFactory<T> metadataFacetFactory = getFacetFactory(facetClazz); + if (metadataFacetFactory == null) { return null; } - final String facetId = metadataFacetFactory.getFacetId( ); + final String facetId = metadataFacetFactory.getFacetId(); Properties properties; - try - { + try { properties = - readProperties( getMetadataDirectory( repositoryId, facetId ).resolve( name ), METADATA_KEY ); - } - catch ( NoSuchFileException | FileNotFoundException e ) - { + readProperties(getMetadataDirectory(repositoryId, facetId).resolve(name), METADATA_KEY); + } catch (NoSuchFileException | FileNotFoundException e) { return null; - } - catch ( IOException e ) - { - log.error( "Could not read properties from {}, {}: {}", repositoryId, facetId, e.getMessage(), e ); + } catch (IOException e) { + log.error("Could not read properties from {}, {}: {}", repositoryId, facetId, e.getMessage(), e); return null; } T metadataFacet = null; - if ( metadataFacetFactory != null ) - { - metadataFacet = metadataFacetFactory.createMetadataFacet( repositoryId, name ); + if (metadataFacetFactory != null) { + metadataFacet = metadataFacetFactory.createMetadataFacet(repositoryId, name); Map<String, String> map = new HashMap<>(); - for ( Object key : new ArrayList<>( properties.keySet() ) ) - { + for (Object key : new ArrayList<>(properties.keySet())) { String property = (String) key; - map.put( property, properties.getProperty( property ) ); + map.put(property, properties.getProperty(property)); } - metadataFacet.fromProperties( map ); + metadataFacet.fromProperties(map); } return metadataFacet; } - @Override - public void addMetadataFacet( RepositorySession session, String repositoryId, MetadataFacet metadataFacet ) - { + public void addMetadataFacet(RepositorySession session, String repositoryId, MetadataFacet metadataFacet) { Properties properties = new Properties(); - properties.putAll( metadataFacet.toProperties() ); + properties.putAll(metadataFacet.toProperties()); - try - { + try { Path directory = - getMetadataDirectory( repositoryId, metadataFacet.getFacetId() ).resolve( metadataFacet.getName() ); - writeProperties( properties, directory, METADATA_KEY ); - } - catch ( IOException e ) - { + getMetadataDirectory(repositoryId, metadataFacet.getFacetId()).resolve(metadataFacet.getName()); + writeProperties(properties, directory, METADATA_KEY); + } catch (IOException e) { // TODO! - log.error( e.getMessage(), e ); + log.error(e.getMessage(), e); } } @Override - public void removeMetadataFacets( RepositorySession session, String repositoryId, String facetId ) - throws MetadataRepositoryException - { - try - { - Path dir = getMetadataDirectory( repositoryId, facetId ); - org.apache.archiva.common.utils.FileUtils.deleteDirectory( dir ); - } - catch ( IOException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + public void removeMetadataFacets(RepositorySession session, String repositoryId, String facetId) + throws MetadataRepositoryException { + try { + Path dir = getMetadataDirectory(repositoryId, facetId); + org.apache.archiva.common.utils.FileUtils.deleteDirectory(dir); + } catch (IOException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public void removeMetadataFacet( RepositorySession session, String repoId, String facetId, String name ) - throws MetadataRepositoryException - { - try - { - Path dir = getMetadataDirectory( repoId, facetId ).resolve( name ); - org.apache.archiva.common.utils.FileUtils.deleteDirectory( dir ); - } - catch ( IOException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + public void removeMetadataFacet(RepositorySession session, String repoId, String facetId, String name) + throws MetadataRepositoryException { + try { + Path dir = getMetadataDirectory(repoId, facetId).resolve(name); + org.apache.archiva.common.utils.FileUtils.deleteDirectory(dir); + } catch (IOException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public List<ArtifactMetadata> getArtifactsByDateRange(RepositorySession session, String repoId, ZonedDateTime startTime, ZonedDateTime endTime ) - throws MetadataRepositoryException - { - try - { - // TODO: this is quite slow - if we are to persist with this repository implementation we should build an index - // of this information (eg. in Lucene, as before) - + public List<ArtifactMetadata> getArtifactsByDateRange(RepositorySession session, String repoId, ZonedDateTime startTime, ZonedDateTime endTime) + throws MetadataRepositoryException { + try { List<ArtifactMetadata> artifacts = new ArrayList<>(); - for ( String ns : getRootNamespaces(session , repoId ) ) - { - getArtifactsByDateRange( session, artifacts, repoId, ns, startTime, endTime ); + for (String ns : getRootNamespaces(session, repoId)) { + getArtifactsByDateRange(session, artifacts, repoId, ns, startTime, endTime); } - artifacts.sort(new ArtifactComparator() ); + artifacts.sort(new ArtifactComparator()); return artifacts; - } - catch ( MetadataResolutionException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + } catch (MetadataResolutionException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } - @Override - public Stream<ArtifactMetadata> getArtifactsByDateRangeStream( RepositorySession session, String repositoryId, ZonedDateTime startTime, ZonedDateTime endTime ) throws MetadataRepositoryException - { - return null; - } + /** + * Result is sorted by date, + * + * @param session The repository session + * @param repositoryId The repository id + * @param startTime The start time, can be <code>null</code> + * @param endTime The end time, can be <code>null</code> + * @param queryParameter Additional parameters for the query that affect ordering and number of returned results. + * @return + * @throws MetadataRepositoryException + */ @Override - public Stream<ArtifactMetadata> getArtifactsByDateRangeStream(RepositorySession session, String repositoryId, ZonedDateTime startTime, ZonedDateTime endTime, QueryParameter queryParameter) throws MetadataRepositoryException - { - return null; + public Stream<ArtifactMetadata> getArtifactsByDateRangeStream(RepositorySession session, String repositoryId, ZonedDateTime startTime, ZonedDateTime endTime, QueryParameter queryParameter) throws MetadataRepositoryException { + try { + List<ArtifactMetadata> artifacts = new ArrayList<>(); + for (String ns : getRootNamespaces(session, repositoryId)) { + getArtifactsByDateRange(session, artifacts, repositoryId, ns, startTime, endTime); + } + Comparator<ArtifactMetadata> comp = getArtifactMetadataComparator(queryParameter, "whenGathered"); + return artifacts.stream().sorted(comp).skip(queryParameter.getOffset()).limit(queryParameter.getLimit()); + + } catch (MetadataResolutionException e) { + throw new MetadataRepositoryException(e.getMessage(), e); + } } - private void getArtifactsByDateRange( RepositorySession session, List<ArtifactMetadata> artifacts, String repoId, String ns, ZonedDateTime startTime, - ZonedDateTime endTime ) - throws MetadataRepositoryException - { - try - { - for ( String namespace : getNamespaces( session, repoId, ns ) ) - { - getArtifactsByDateRange( session, artifacts, repoId, ns + "." + namespace, startTime, endTime ); + + private void getArtifactsByDateRange(RepositorySession session, List<ArtifactMetadata> artifacts, String repoId, String ns, ZonedDateTime startTime, + ZonedDateTime endTime) + throws MetadataRepositoryException { + try { + for (String namespace : getNamespaces(session, repoId, ns)) { + getArtifactsByDateRange(session, artifacts, repoId, ns + "." + namespace, startTime, endTime); } - for ( String project : getProjects( session, repoId, ns ) ) - { - for ( String version : getProjectVersions( session, repoId, ns, project ) ) - { - for ( ArtifactMetadata artifact : getArtifacts( session, repoId, ns, project, version ) ) - { - if ( startTime == null || startTime.isBefore( ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())) ) ) - { - if ( endTime == null || endTime.isAfter( ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())) ) ) - { - artifacts.add( artifact ); + for (String project : getProjects(session, repoId, ns)) { + for (String version : getProjectVersions(session, repoId, ns, project)) { + for (ArtifactMetadata artifact : getArtifacts(session, repoId, ns, project, version)) { + if (startTime == null || startTime.isBefore(ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())))) { + if (endTime == null || endTime.isAfter(ZonedDateTime.from(artifact.getWhenGathered().toInstant().atZone(ZoneId.systemDefault())))) { + artifacts.add(artifact); } } } } } - } - catch ( MetadataResolutionException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + } catch (MetadataResolutionException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public Collection<ArtifactMetadata> getArtifacts( RepositorySession session, String repoId, String namespace, String projectId, - String projectVersion ) - throws MetadataResolutionException - { - try - { + public Collection<ArtifactMetadata> getArtifacts(RepositorySession session, String repoId, String namespace, String projectId, + String projectVersion) + throws MetadataResolutionException { + try { Map<String, ArtifactMetadata> artifacts = new HashMap<>(); - Path directory = getDirectory( repoId ).resolve( namespace + "/" + projectId + "/" + projectVersion ); + Path directory = getDirectory(repoId).resolve(namespace + "/" + projectId + "/" + projectVersion); - Properties properties = readOrCreateProperties( directory, PROJECT_VERSION_METADATA_KEY ); + Properties properties = readOrCreateProperties(directory, PROJECT_VERSION_METADATA_KEY); - for ( Map.Entry entry : properties.entrySet() ) - { + for (Map.Entry entry : properties.entrySet()) { String name = (String) entry.getKey(); - StringTokenizer tok = new StringTokenizer( name, ":" ); - if ( tok.hasMoreTokens() && "artifact".equals( tok.nextToken() ) ) - { + StringTokenizer tok = new StringTokenizer(name, ":"); + if (tok.hasMoreTokens() && "artifact".equals(tok.nextToken())) { String field = tok.nextToken(); String id = tok.nextToken(); - ArtifactMetadata artifact = artifacts.get( id ); - if ( artifact == null ) - { + ArtifactMetadata artifact = artifacts.get(id); + if (artifact == null) { artifact = new ArtifactMetadata(); - artifact.setRepositoryId( repoId ); - artifact.setNamespace( namespace ); - artifact.setProject( projectId ); - artifact.setProjectVersion( projectVersion ); - artifact.setVersion( projectVersion ); - artifact.setId( id ); - artifacts.put( id, artifact ); + artifact.setRepositoryId(repoId); + artifact.setNamespace(namespace); + artifact.setProject(projectId); + artifact.setProjectVersion(projectVersion); + artifact.setVersion(projectVersion); + artifact.setId(id); + artifacts.put(id, artifact); } String value = (String) entry.getValue(); - if ( "updated".equals( field ) ) - { - artifact.setFileLastModified( Long.parseLong( value ) ); - } - else if ( "size".equals( field ) ) - { - artifact.setSize( Long.valueOf( value ) ); - } - else if ( "whenGathered".equals( field ) ) - { - artifact.setWhenGathered( ZonedDateTime.ofInstant(Instant.ofEpochMilli(Long.parseLong( value )), ZoneId.of("GMT") ) ); - } - else if ( "version".equals( field ) ) - { - artifact.setVersion( value ); - } - else if ( "md5".equals( field ) ) - { - artifact.setMd5( value ); - } - else if ( "sha1".equals( field ) ) - { - artifact.setSha1( value ); - } - else if ( "facetIds".equals( field ) ) - { - if ( value.length() > 0 ) - { + if ("updated".equals(field)) { + artifact.setFileLastModified(Long.parseLong(value)); + } else if ("size".equals(field)) { + artifact.setSize(Long.valueOf(value)); + } else if ("whenGathered".equals(field)) { + artifact.setWhenGathered(ZonedDateTime.ofInstant(Instant.ofEpochMilli(Long.parseLong(value)), ZoneId.of("GMT"))); + } else if ("version".equals(field)) { + artifact.setVersion(value); + } else if ("md5".equals(field)) { + artifact.setMd5(value); + } else if ("sha1".equals(field)) { + artifact.setSha1(value); + } else if ("facetIds".equals(field)) { + if (value.length() > 0) { String propertyPrefix = "artifact:facet:" + id + ":"; - for ( String facetId : value.split( "," ) ) - { - MetadataFacetFactory factory = getFacetFactory( facetId ); - if ( factory == null ) - { - log.error( "Attempted to load unknown artifact metadata facet: {}", facetId ); - } - else - { + for (String facetId : value.split(",")) { + MetadataFacetFactory factory = getFacetFactory(facetId); + if (factory == null) { + log.error("Attempted to load unknown artifact metadata facet: {}", facetId); + } else { MetadataFacet facet = factory.createMetadataFacet(); String prefix = propertyPrefix + facet.getFacetId(); Map<String, String> map = new HashMap<>(); - for ( Object key : new ArrayList<>( properties.keySet() ) ) - { + for (Object key : new ArrayList<>(properties.keySet())) { String property = (String) key; - if ( property.startsWith( prefix ) ) - { - map.put( property.substring( prefix.length() + 1 ), - properties.getProperty( property ) ); + if (property.startsWith(prefix)) { + map.put(property.substring(prefix.length() + 1), + properties.getProperty(property)); } } - facet.fromProperties( map ); - artifact.addFacet( facet ); + facet.fromProperties(map); + artifact.addFacet(facet); } } } - updateArtifactFacets( artifact, properties ); + updateArtifactFacets(artifact, properties); } } } return artifacts.values(); - } - catch ( IOException e ) - { - throw new MetadataResolutionException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataResolutionException(e.getMessage(), e); } } @Override - public void close() - { + public void close() { // nothing additional to close } @Override - public boolean canObtainAccess( Class<?> aClass ) - { + public boolean canObtainAccess(Class<?> aClass) { return false; } @Override - public <T> T obtainAccess( RepositorySession session, Class<T> aClass ) - { + public <T> T obtainAccess(RepositorySession session, Class<T> aClass) { throw new IllegalArgumentException( - "Access using " + aClass + " is not supported on the file metadata storage" ); + "Access using " + aClass + " is not supported on the file metadata storage"); } - private void updateArtifactFacets( ArtifactMetadata artifact, Properties properties ) - { + private void updateArtifactFacets(ArtifactMetadata artifact, Properties properties) { String propertyPrefix = "artifact:facet:" + artifact.getId() + ":"; - for ( MetadataFacet facet : artifact.getFacetList() ) - { - for ( Map.Entry<String, String> e : facet.toProperties().entrySet() ) - { + for (MetadataFacet facet : artifact.getFacetList()) { + for (Map.Entry<String, String> e : facet.toProperties().entrySet()) { String key = propertyPrefix + facet.getFacetId() + ":" + e.getKey(); - properties.setProperty( key, e.getValue() ); + properties.setProperty(key, e.getValue()); } } } @Override - public List<ArtifactMetadata> getArtifactsByChecksum( RepositorySession session, String repositoryId, String checksum ) - throws MetadataRepositoryException - { - try - { + public List<ArtifactMetadata> getArtifactsByChecksum(RepositorySession session, String repositoryId, String checksum) + throws MetadataRepositoryException { + try { // TODO: this is quite slow - if we are to persist with this repository implementation we should build an index // of this information (eg. in Lucene, as before) // alternatively, we could build a referential tree in the content repository, however it would need some levels // of depth to avoid being too broad to be useful (eg. /repository/checksums/a/ab/abcdef1234567) List<ArtifactMetadata> artifacts = new ArrayList<>(); - for ( String ns : getRootNamespaces( session, repositoryId ) ) - { - getArtifactsByChecksum( session, artifacts, repositoryId, ns, checksum ); + for (String ns : getRootNamespaces(session, repositoryId)) { + getArtifactsByChecksum(session, artifacts, repositoryId, ns, checksum); } return artifacts; - } - catch ( MetadataResolutionException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + } catch (MetadataResolutionException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public void removeNamespace( RepositorySession session, String repositoryId, String project ) - throws MetadataRepositoryException - { - try - { - Path namespaceDirectory = getDirectory( repositoryId ).resolve( project ); - org.apache.archiva.common.utils.FileUtils.deleteDirectory( namespaceDirectory ); + public void removeNamespace(RepositorySession session, String repositoryId, String project) + throws MetadataRepositoryException { + try { + Path namespaceDirectory = getDirectory(repositoryId).resolve(project); + org.apache.archiva.common.utils.FileUtils.deleteDirectory(namespaceDirectory); //Properties properties = new Properties(); //properties.setProperty( "namespace", namespace ); //writeProperties( properties, namespaceDirectory, NAMESPACE_METADATA_KEY ); - } - catch ( IOException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public void removeArtifact( RepositorySession session, ArtifactMetadata artifactMetadata, String baseVersion ) - throws MetadataRepositoryException - { + public void removeArtifact(RepositorySession session, ArtifactMetadata artifactMetadata, String baseVersion) + throws MetadataRepositoryException { - try - { - Path directory = getDirectory( artifactMetadata.getRepositoryId() ).resolve( - artifactMetadata.getNamespace() + "/" + artifactMetadata.getProject() + "/" - + baseVersion ); + try { + Path directory = getDirectory(artifactMetadata.getRepositoryId()).resolve( + artifactMetadata.getNamespace() + "/" + artifactMetadata.getProject() + "/" + + baseVersion); - Properties properties = readOrCreateProperties( directory, PROJECT_VERSION_METADATA_KEY ); + Properties properties = readOrCreateProperties(directory, PROJECT_VERSION_METADATA_KEY); String id = artifactMetadata.getId(); - properties.remove( "artifact:updated:" + id ); - properties.remove( "artifact:whenGathered:" + id ); - properties.remove( "artifact:size:" + id ); - properties.remove( "artifact:md5:" + id ); - properties.remove( "artifact:sha1:" + id ); - properties.remove( "artifact:version:" + id ); - properties.remove( "artifact:facetIds:" + id ); + properties.remove("artifact:updated:" + id); + properties.remove("artifact:whenGathered:" + id); + properties.remove("artifact:size:" + id); + properties.remove("artifact:md5:" + id); + properties.remove("artifact:sha1:" + id); + properties.remove("artifact:version:" + id); + properties.remove("artifact:facetIds:" + id); String prefix = "artifact:facet:" + id + ":"; - for ( Object key : new ArrayList<>( properties.keySet() ) ) - { + for (Object key : new ArrayList<>(properties.keySet())) { String property = (String) key; - if ( property.startsWith( prefix ) ) - { - properties.remove( property ); + if (property.startsWith(prefix)) { + properties.remove(property); } } - writeProperties( properties, directory, PROJECT_VERSION_METADATA_KEY ); - } - catch ( IOException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + writeProperties(properties, directory, PROJECT_VERSION_METADATA_KEY); + } catch (IOException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public void removeArtifact( RepositorySession session, String repoId, String namespace, String project, String version, String id ) - throws MetadataRepositoryException - { - try - { - Path directory = getDirectory( repoId ).resolve( namespace + "/" + project + "/" + version ); - - Properties properties = readOrCreateProperties( directory, PROJECT_VERSION_METADATA_KEY ); - - properties.remove( "artifact:updated:" + id ); - properties.remove( "artifact:whenGathered:" + id ); - properties.remove( "artifact:size:" + id ); - properties.remove( "artifact:md5:" + id ); - properties.remove( "artifact:sha1:" + id ); - properties.remove( "artifact:version:" + id ); - properties.remove( "artifact:facetIds:" + id ); + public void removeArtifact(RepositorySession session, String repoId, String namespace, String project, String version, String id) + throws MetadataRepositoryException { + try { + Path directory = getDirectory(repoId).resolve(namespace + "/" + project + "/" + version); + + Properties properties = readOrCreateProperties(directory, PROJECT_VERSION_METADATA_KEY); + + properties.remove("artifact:updated:" + id); + properties.remove("artifact:whenGathered:" + id); + properties.remove("artifact:size:" + id); + properties.remove("artifact:md5:" + id); + properties.remove("artifact:sha1:" + id); + properties.remove("artifact:version:" + id); + properties.remove("artifact:facetIds:" + id); String prefix = "artifact:facet:" + id + ":"; - for ( Object key : new ArrayList<>( properties.keySet() ) ) - { + for (Object key : new ArrayList<>(properties.keySet())) { String property = (String) key; - if ( property.startsWith( prefix ) ) - { - properties.remove( property ); + if (property.startsWith(prefix)) { + properties.remove(property); } } - org.apache.archiva.common.utils.FileUtils.deleteDirectory( directory ); + org.apache.archiva.common.utils.FileUtils.deleteDirectory(directory); //writeProperties( properties, directory, PROJECT_VERSION_METADATA_KEY ); - } - catch ( IOException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } /** * FIXME implements this !!!! * - * * @param session * @param repositoryId * @param namespace @@ -829,294 +670,241 @@ public class FileMetadataRepository * @throws MetadataRepositoryException */ @Override - public void removeArtifact( RepositorySession session, String repositoryId, String namespace, String project, String projectVersion, - MetadataFacet metadataFacet ) - throws MetadataRepositoryException - { - throw new UnsupportedOperationException( "not implemented" ); + public void removeArtifact(RepositorySession session, String repositoryId, String namespace, String project, String projectVersion, + MetadataFacet metadataFacet) + throws MetadataRepositoryException { + throw new UnsupportedOperationException("not implemented"); } @Override - public void removeRepository( RepositorySession session, String repoId ) - throws MetadataRepositoryException - { - try - { - Path dir = getDirectory( repoId ); - org.apache.archiva.common.utils.FileUtils.deleteDirectory( dir ); - } - catch ( IOException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + public void removeRepository(RepositorySession session, String repoId) + throws MetadataRepositoryException { + try { + Path dir = getDirectory(repoId); + org.apache.archiva.common.utils.FileUtils.deleteDirectory(dir); + } catch (IOException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } - private void getArtifactsByChecksum( RepositorySession session, List<ArtifactMetadata> artifacts, String repositoryId, String ns, - String checksum ) - throws MetadataRepositoryException - { - try - { - for ( String namespace : getNamespaces( session, repositoryId, ns ) ) - { - getArtifactsByChecksum( session, artifacts, repositoryId, ns + "." + namespace, checksum ); + private void getArtifactsByChecksum(RepositorySession session, List<ArtifactMetadata> artifacts, String repositoryId, String ns, + String checksum) + throws MetadataRepositoryException { + try { + for (String namespace : getNamespaces(session, repositoryId, ns)) { + getArtifactsByChecksum(session, artifacts, repositoryId, ns + "." + namespace, checksum); } - for ( String project : getProjects( session, repositoryId, ns ) ) - { - for ( String version : getProjectVersions( session, repositoryId, ns, project ) ) - { - for ( ArtifactMetadata artifact : getArtifacts( session, repositoryId, ns, project, version ) ) - { - if ( checksum.equals( artifact.getMd5() ) || checksum.equals( artifact.getSha1() ) ) - { - artifacts.add( artifact ); + for (String project : getProjects(session, repositoryId, ns)) { + for (String version : getProjectVersions(session, repositoryId, ns, project)) { + for (ArtifactMetadata artifact : getArtifacts(session, repositoryId, ns, project, version)) { + if (checksum.equals(artifact.getMd5()) || checksum.equals(artifact.getSha1())) { + artifacts.add(artifact); } } } } - } - catch ( MetadataResolutionException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + } catch (MetadataResolutionException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public List<ArtifactMetadata> getArtifactsByProjectVersionMetadata( RepositorySession session, String key, String value, String repositoryId ) - throws MetadataRepositoryException - { - throw new UnsupportedOperationException( "not yet implemented in File backend" ); + public List<ArtifactMetadata> getArtifactsByProjectVersionMetadata(RepositorySession session, String key, String value, String repositoryId) + throws MetadataRepositoryException { + throw new UnsupportedOperationException("not yet implemented in File backend"); } @Override - public List<ArtifactMetadata> getArtifactsByMetadata( RepositorySession session, String key, String value, String repositoryId ) - throws MetadataRepositoryException - { - throw new UnsupportedOperationException( "not yet implemented in File backend" ); + public List<ArtifactMetadata> getArtifactsByMetadata(RepositorySession session, String key, String value, String repositoryId) + throws MetadataRepositoryException { + throw new UnsupportedOperationException("not yet implemented in File backend"); } @Override - public List<ArtifactMetadata> getArtifactsByProperty( RepositorySession session, String key, String value, String repositoryId ) - throws MetadataRepositoryException - { - throw new UnsupportedOperationException( "getArtifactsByProperty not yet implemented in File backend" ); + public List<ArtifactMetadata> getArtifactsByProperty(RepositorySession session, String key, String value, String repositoryId) + throws MetadataRepositoryException { + throw new UnsupportedOperationException("getArtifactsByProperty not yet implemented in File backend"); } - private Path getMetadataDirectory( String repoId, String facetId ) - throws IOException - { - return getBaseDirectory( repoId ).resolve( "facets/" + facetId ); + private Path getMetadataDirectory(String repoId, String facetId) + throws IOException { + return getBaseDirectory(repoId).resolve("facets/" + facetId); } - private String join( Collection<String> ids ) - { - if ( ids != null && !ids.isEmpty() ) - { + private String join(Collection<String> ids) { + if (ids != null && !ids.isEmpty()) { StringBuilder s = new StringBuilder(); - for ( String id : ids ) - { - s.append( id ); - s.append( "," ); + for (String id : ids) { + s.append(id); + s.append(","); } - return s.substring( 0, s.length() - 1 ); + return s.substring(0, s.length() - 1); } return ""; } - private void setProperty( Properties properties, String name, String value ) - { - if ( value != null ) - { - properties.setProperty( name, value ); + private void setProperty(Properties properties, String name, String value) { + if (value != null) { + properties.setProperty(name, value); } } @Override - public void updateArtifact( RepositorySession session, String repoId, String namespace, String projectId, String projectVersion, - ArtifactMetadata artifact ) - { - try - { + public void updateArtifact(RepositorySession session, String repoId, String namespace, String projectId, String projectVersion, + ArtifactMetadata artifact) { + try { ProjectVersionMetadata metadata = new ProjectVersionMetadata(); - metadata.setId( projectVersion ); - updateProjectVersion( session, repoId, namespace, projectId, metadata ); + metadata.setId(projectVersion); + updateProjectVersion(session, repoId, namespace, projectId, metadata); - Path directory = getDirectory( repoId ).resolve( namespace + "/" + projectId + "/" + projectVersion ); + Path directory = getDirectory(repoId).resolve(namespace + "/" + projectId + "/" + projectVersion); - Properties properties = readOrCreateProperties( directory, PROJECT_VERSION_METADATA_KEY ); + Properties properties = readOrCreateProperties(directory, PROJECT_VERSION_METADATA_KEY); - clearMetadataFacetProperties( artifact.getFacetList(), properties, - "artifact:facet:" + artifact.getId() + ":" ); + clearMetadataFacetProperties(artifact.getFacetList(), properties, + "artifact:facet:" + artifact.getId() + ":"); String id = artifact.getId(); - properties.setProperty( "artifact:updated:" + id, - Long.toString( artifact.getFileLastModified().toInstant().toEpochMilli()) ); - properties.setProperty( "artifact:whenGathered:" + id, - Long.toString( artifact.getWhenGathered().toInstant().toEpochMilli()) ); - properties.setProperty( "artifact:size:" + id, Long.toString( artifact.getSize() ) ); - if ( artifact.getMd5() != null ) - { - properties.setProperty( "artifact:md5:" + id, artifact.getMd5() ); + properties.setProperty("artifact:updated:" + id, + Long.toString(artifact.getFileLastModified().toInstant().toEpochMilli())); + properties.setProperty("artifact:whenGathered:" + id, + Long.toString(artifact.getWhenGathered().toInstant().toEpochMilli())); + properties.setProperty("artifact:size:" + id, Long.toString(artifact.getSize())); + if (artifact.getMd5() != null) { + properties.setProperty("artifact:md5:" + id, artifact.getMd5()); } - if ( artifact.getSha1() != null ) - { - properties.setProperty( "artifact:sha1:" + id, artifact.getSha1() ); + if (artifact.getSha1() != null) { + properties.setProperty("artifact:sha1:" + id, artifact.getSha1()); } - properties.setProperty( "artifact:version:" + id, artifact.getVersion() ); + properties.setProperty("artifact:version:" + id, artifact.getVersion()); - Set<String> facetIds = new LinkedHashSet<>( artifact.getFacetIds( ) ); + Set<String> facetIds = new LinkedHashSet<>(artifact.getFacetIds()); String property = "artifact:facetIds:" + id; - facetIds.addAll( Arrays.asList( properties.getProperty( property, "" ).split( "," ) ) ); - properties.setProperty( property, join( facetIds ) ); + facetIds.addAll(Arrays.asList(properties.getProperty(property, "").split(","))); + properties.setProperty(property, join(facetIds)); - updateArtifactFacets( artifact, properties ); + updateArtifactFacets(artifact, properties); - writeProperties( properties, directory, PROJECT_VERSION_METADATA_KEY ); - } - catch ( IOException e ) - { + writeProperties(properties, directory, PROJECT_VERSION_METADATA_KEY); + } catch (IOException e) { // TODO - log.error( e.getMessage(), e ); + log.error(e.getMessage(), e); } } - private Properties readOrCreateProperties( Path directory, String propertiesKey ) - { - try - { - return readProperties( directory, propertiesKey ); - } - catch ( FileNotFoundException | NoSuchFileException e ) - { + private Properties readOrCreateProperties(Path directory, String propertiesKey) { + try { + return readProperties(directory, propertiesKey); + } catch (FileNotFoundException | NoSuchFileException e) { // ignore and return new properties - } - catch ( IOException e ) - { + } catch (IOException e) { // TODO - log.error( e.getMessage(), e ); + log.error(e.getMessage(), e); } return new Properties(); } - private Properties readProperties( Path directory, String propertiesKey ) - throws IOException - { + private Properties readProperties(Path directory, String propertiesKey) + throws IOException { Properties properties = new Properties(); - try (InputStream in = Files.newInputStream( directory.resolve( propertiesKey + ".properties" ))) - { + try (InputStream in = Files.newInputStream(directory.resolve(propertiesKey + ".properties"))) { - properties.load( in ); + properties.load(in); } return properties; } @Override - public ProjectMetadata getProject( RepositorySession session, String repoId, String namespace, String projectId ) - throws MetadataResolutionException - { - try - { - Path directory = getDirectory( repoId ).resolve( namespace + "/" + projectId ); + public ProjectMetadata getProject(RepositorySession session, String repoId, String namespace, String projectId) + throws MetadataResolutionException { + try { + Path directory = getDirectory(repoId).resolve(namespace + "/" + projectId); - Properties properties = readOrCreateProperties( directory, PROJECT_METADATA_KEY ); + Properties properties = readOrCreateProperties(directory, PROJECT_METADATA_KEY); ProjectMetadata project = null; - String id = properties.getProperty( "id" ); - if ( id != null ) - { + String id = properties.getProperty("id"); + if (id != null) { project = new ProjectMetadata(); - project.setNamespace( properties.getProperty( "namespace" ) ); - project.setId( id ); + project.setNamespace(properties.getProperty("namespace")); + project.setId(id); } return project; - } - catch ( IOException e ) - { - throw new MetadataResolutionException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataResolutionException(e.getMessage(), e); } } @Override - public ProjectVersionMetadata getProjectVersion( RepositorySession session, String repoId, String namespace, String projectId, - String projectVersion ) - throws MetadataResolutionException - { - try - { - Path directory = getDirectory( repoId ).resolve( namespace + "/" + projectId + "/" + projectVersion ); - - Properties properties = readOrCreateProperties( directory, PROJECT_VERSION_METADATA_KEY ); - String id = properties.getProperty( "id" ); + public ProjectVersionMetadata getProjectVersion(RepositorySession session, String repoId, String namespace, String projectId, + String projectVersion) + throws MetadataResolutionException { + try { + Path directory = getDirectory(repoId).resolve(namespace + "/" + projectId + "/" + projectVersion); + + Properties properties = readOrCreateProperties(directory, PROJECT_VERSION_METADATA_KEY); + String id = properties.getProperty("id"); ProjectVersionMetadata versionMetadata = null; - if ( id != null ) - { + if (id != null) { versionMetadata = new ProjectVersionMetadata(); - versionMetadata.setId( id ); - versionMetadata.setName( properties.getProperty( "name" ) ); - versionMetadata.setDescription( properties.getProperty( "description" ) ); - versionMetadata.setUrl( properties.getProperty( "url" ) ); - versionMetadata.setIncomplete( Boolean.valueOf( properties.getProperty( "incomplete", "false" ) ) ); - - String scmConnection = properties.getProperty( "scm.connection" ); - String scmDeveloperConnection = properties.getProperty( "scm.developerConnection" ); - String scmUrl = properties.getProperty( "scm.url" ); - if ( scmConnection != null || scmDeveloperConnection != null || scmUrl != null ) - { + versionMetadata.setId(id); + versionMetadata.setName(properties.getProperty("name")); + versionMetadata.setDescription(properties.getProperty("description")); + versionMetadata.setUrl(properties.getProperty("url")); + versionMetadata.setIncomplete(Boolean.valueOf(properties.getProperty("incomplete", "false"))); + + String scmConnection = properties.getProperty("scm.connection"); + String scmDeveloperConnection = properties.getProperty("scm.developerConnection"); + String scmUrl = properties.getProperty("scm.url"); + if (scmConnection != null || scmDeveloperConnection != null || scmUrl != null) { Scm scm = new Scm(); - scm.setConnection( scmConnection ); - scm.setDeveloperConnection( scmDeveloperConnection ); - scm.setUrl( scmUrl ); - versionMetadata.setScm( scm ); + scm.setConnection(scmConnection); + scm.setDeveloperConnection(scmDeveloperConnection); + scm.setUrl(scmUrl); + versionMetadata.setScm(scm); } - String ciSystem = properties.getProperty( "ci.system" ); - String ciUrl = properties.getProperty( "ci.url" ); - if ( ciSystem != null || ciUrl != null ) - { + String ciSystem = properties.getProperty("ci.system"); + String ciUrl = properties.getProperty("ci.url"); + if (ciSystem != null || ciUrl != null) { CiManagement ci = new CiManagement(); - ci.setSystem( ciSystem ); - ci.setUrl( ciUrl ); - versionMetadata.setCiManagement( ci ); + ci.setSystem(ciSystem); + ci.setUrl(ciUrl); + versionMetadata.setCiManagement(ci); } - String issueSystem = properties.getProperty( "issue.system" ); - String issueUrl = properties.getProperty( "issue.url" ); - if ( issueSystem != null || issueUrl != null ) - { + String issueSystem = properties.getProperty("issue.system"); + String issueUrl = properties.getProperty("issue.url"); + if (issueSystem != null || issueUrl != null) { IssueManagement issueManagement = new IssueManagement(); - issueManagement.setSystem( issueSystem ); - issueManagement.setUrl( issueUrl ); - versionMetadata.setIssueManagement( issueManagement ); + issueManagement.setSystem(issueSystem); + issueManagement.setUrl(issueUrl); + versionMetadata.setIssueManagement(issueManagement); } - String orgName = properties.getProperty( "org.name" ); - String orgUrl = properties.getProperty( "org.url" ); - if ( orgName != null || orgUrl != null ) - { + String orgName = properties.getProperty("org.name"); + String orgUrl = properties.getProperty("org.url"); + if (orgName != null || orgUrl != null) { Organization org = new Organization(); - org.setName( orgName ); - org.setUrl( orgUrl ); - versionMetadata.setOrganization( org ); + org.setName(orgName); + org.setUrl(orgUrl); + versionMetadata.setOrganization(org); } boolean done = false; int i = 0; - while ( !done ) - { - String licenseName = properties.getProperty( "license." + i + ".name" ); - String licenseUrl = properties.getProperty( "license." + i + ".url" ); - if ( licenseName != null || licenseUrl != null ) - { + while (!done) { + String licenseName = properties.getProperty("license." + i + ".name"); + String licenseUrl = properties.getProperty("license." + i + ".url"); + if (licenseName != null || licenseUrl != null) { License license = new License(); - license.setName( licenseName ); - license.setUrl( licenseUrl ); - versionMetadata.addLicense( license ); - } - else - { + license.setName(licenseName); + license.setUrl(licenseUrl); + versionMetadata.addLicense(license); + } else { done = true; } i++; @@ -1124,31 +912,24 @@ public class FileMetadataRepository done = false; i = 0; - while ( !done ) - { - String mailingListName = properties.getProperty( "mailingList." + i + ".name" ); - if ( mailingListName != null ) - { + while (!done) { + String mailingListName = properties.getProperty("mailingList." + i + ".name"); + if (mailingListName != null) { MailingList mailingList = new MailingList(); - mailingList.setName( mailingListName ); - mailingList.setMainArchiveUrl( properties.getProperty( "mailingList." + i + ".archive" ) ); - String p = properties.getProperty( "mailingList." + i + ".otherArchives" ); - if ( p != null && p.length() > 0 ) - { - mailingList.setOtherArchives( Arrays.asList( p.split( "," ) ) ); + mailingList.setName(mailingListName); + mailingList.setMainArchiveUrl(properties.getProperty("mailingList." + i + ".archive")); + String p = properties.getProperty("mailingList." + i + ".otherArchives"); + if (p != null && p.length() > 0) { + mailingList.setOtherArchives(Arrays.asList(p.split(","))); + } else { + mailingList.setOtherArchives(Collections.emptyList()); } - else - { - mailingList.setOtherArchives( Collections.emptyList() ); - } - mailingList.setPostAddress( properties.getProperty( "mailingList." + i + ".post" ) ); - mailingList.setSubscribeAddress( properties.getProperty( "mailingList." + i + ".subscribe" ) ); + mailingList.setPostAddress(properties.getProperty("mailingList." + i + ".post")); + mailingList.setSubscribeAddress(properties.getProperty("mailingList." + i + ".subscribe")); mailingList.setUnsubscribeAddress( - properties.getProperty( "mailingList." + i + ".unsubscribe" ) ); - versionMetadata.addMailingList( mailingList ); - } - else - { + properties.getProperty("mailingList." + i + ".unsubscribe")); + versionMetadata.addMailingList(mailingList); + } else { done = true; } i++; @@ -1156,150 +937,123 @@ public class FileMetadataRepository done = false; i = 0; - while ( !done ) - { - String dependencyArtifactId = properties.getProperty( "dependency." + i + ".artifactId" ); - if ( dependencyArtifactId != null ) - { + while (!done) { + String dependencyArtifactId = properties.getProperty("dependency." + i + ".artifactId"); + if (dependencyArtifactId != null) { Dependency dependency = new Dependency(); - dependency.setArtifactId( dependencyArtifactId ); - dependency.setGroupId( properties.getProperty( "dependency." + i + ".groupId" ) ); - dependency.setClassifier( properties.getProperty( "dependency." + i + ".classifier" ) ); + dependency.setArtifactId(dependencyArtifactId); + dependency.setGroupId(properties.getProperty("dependency." + i + ".groupId")); + dependency.setClassifier(properties.getProperty("dependency." + i + ".classifier")); dependency.setOptional( - Boolean.valueOf( properties.getProperty( "dependency." + i + ".optional" ) ) ); - dependency.setScope( properties.getProperty( "dependency." + i + ".scope" ) ); - dependency.setSystemPath( properties.getProperty( "dependency." + i + ".systemPath" ) ); - dependency.setType( properties.getProperty( "dependency." + i + ".type" ) ); - dependency.setVersion( properties.getProperty( "dependency." + i + ".version" ) ); + Boolean.valueOf(properties.getProperty("dependency." + i + ".optional"))); + dependency.setScope(properties.getProperty("dependency." + i + ".scope")); + dependency.setSystemPath(properties.getProperty("dependency." + i + ".systemPath")); + dependency.setType(properties.getProperty("dependency." + i + ".type")); + dependency.setVersion(properties.getProperty("dependency." + i + ".version")); dependency.setOptional( - Boolean.valueOf( properties.getProperty( "dependency." + i + ".optional" ) ) ); - versionMetadata.addDependency( dependency ); - } - else - { + Boolean.valueOf(properties.getProperty("dependency." + i + ".optional"))); + versionMetadata.addDependency(dependency); + } else { done = true; } i++; } - String facetIds = properties.getProperty( "facetIds", "" ); - if ( facetIds.length() > 0 ) - { - for ( String facetId : facetIds.split( "," ) ) - { - MetadataFacetFactory factory = getFacetFactory( facetId ); - if ( factory == null ) - { - log.error( "Attempted to load unknown project version metadata facet: {}", facetId ); - } - else - { + String facetIds = properties.getProperty("facetIds", ""); + if (facetIds.length() > 0) { + for (String facetId : facetIds.split(",")) { + MetadataFacetFactory factory = getFacetFactory(facetId); + if (factory == null) { + log.error("Attempted to load unknown project version metadata facet: {}", facetId); + } else { MetadataFacet facet = factory.createMetadataFacet(); Map<String, String> map = new HashMap<>(); - for ( Object key : new ArrayList<>( properties.keySet() ) ) - { + for (Object key : new ArrayList<>(properties.keySet())) { String property = (String) key; - if ( property.startsWith( facet.getFacetId() ) ) - { - map.put( property.substring( facet.getFacetId().length() + 1 ), - properties.getProperty( property ) ); + if (property.startsWith(facet.getFacetId())) { + map.put(property.substring(facet.getFacetId().length() + 1), + properties.getProperty(property)); } } - facet.fromProperties( map ); - versionMetadata.addFacet( facet ); + facet.fromProperties(map); + versionMetadata.addFacet(facet); } } } - updateProjectVersionFacets( versionMetadata, properties ); + updateProjectVersionFacets(versionMetadata, properties); } return versionMetadata; - } - catch ( IOException e ) - { - throw new MetadataResolutionException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataResolutionException(e.getMessage(), e); } } @Override - public Collection<String> getArtifactVersions( RepositorySession session, String repoId, String namespace, String projectId, - String projectVersion ) - throws MetadataResolutionException - { - try - { - Path directory = getDirectory( repoId ).resolve( namespace + "/" + projectId + "/" + projectVersion ); - - Properties properties = readOrCreateProperties( directory, PROJECT_VERSION_METADATA_KEY ); - - Set<String> versions = new HashSet<>( ); - for ( Map.Entry entry : properties.entrySet() ) - { + public Collection<String> getArtifactVersions(RepositorySession session, String repoId, String namespace, String projectId, + String projectVersion) + throws MetadataResolutionException { + try { + Path directory = getDirectory(repoId).resolve(namespace + "/" + projectId + "/" + projectVersion); + + Properties properties = readOrCreateProperties(directory, PROJECT_VERSION_METADATA_KEY); + + Set<String> versions = new HashSet<>(); + for (Map.Entry entry : properties.entrySet()) { String name = (String) entry.getKey(); - if ( name.startsWith( "artifact:version:" ) ) - { - versions.add( (String) entry.getValue() ); + if (name.startsWith("artifact:version:")) { + versions.add((String) entry.getValue()); } } return versions; - } - catch ( IOException e ) - { - throw new MetadataResolutionException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataResolutionException(e.getMessage(), e); } } @Override - public Collection<ProjectVersionReference> getProjectReferences( RepositorySession session, String repoId, String namespace, String projectId, - String projectVersion ) - throws MetadataResolutionException - { - try - { - Path directory = getDirectory( repoId ).resolve( namespace + "/" + projectId + "/" + projectVersion ); + public Collection<ProjectVersionReference> getProjectReferences(RepositorySession session, String repoId, String namespace, String projectId, + String projectVersion) + throws MetadataResolutionException { + try { + Path directory = getDirectory(repoId).resolve(namespace + "/" + projectId + "/" + projectVersion); - Properties properties = readOrCreateProperties( directory, PROJECT_VERSION_METADATA_KEY ); - int numberOfRefs = Integer.parseInt( properties.getProperty( "ref:lastReferenceNum", "-1" ) ) + 1; + Properties properties = readOrCreateProperties(directory, PROJECT_VERSION_METADATA_KEY); + int numberOfRefs = Integer.parseInt(properties.getProperty("ref:lastReferenceNum", "-1")) + 1; List<ProjectVersionReference> references = new ArrayList<>(); - for ( int i = 0; i < numberOfRefs; i++ ) - { + for (int i = 0; i < numberOfRefs; i++) { ProjectVersionReference reference = new ProjectVersionReference(); - reference.setProjectId( properties.getProperty( "ref:reference." + i + ".projectId" ) ); - reference.setNamespace( properties.getProperty( "ref:reference." + i + ".namespace" ) ); - reference.setProjectVersion( properties.getProperty( "ref:reference." + i + ".projectVersion" ) ); - reference.setReferenceType( ProjectVersionReference.ReferenceType.valueOf( - properties.getProperty( "ref:reference." + i + ".referenceType" ) ) ); - references.add( reference ); + reference.setProjectId(properties.getProperty("ref:reference." + i + ".projectId")); + reference.setNamespace(properties.getProperty("ref:reference." + i + ".namespace")); + reference.setProjectVersion(properties.getProperty("ref:reference." + i + ".projectVersion")); + reference.setReferenceType(ProjectVersionReference.ReferenceType.valueOf( + properties.getProperty("ref:reference." + i + ".referenceType"))); + references.add(reference); } return references; - } - catch ( IOException e ) - { - throw new MetadataResolutionException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataResolutionException(e.getMessage(), e); } } @Override - public Collection<String> getRootNamespaces( RepositorySession session, String repoId ) - throws MetadataResolutionException - { - return getNamespaces( session, repoId, null ); + public Collection<String> getRootNamespaces(RepositorySession session, String repoId) + throws MetadataResolutionException { + return getNamespaces(session, repoId, null); } @Override - public Collection<String> getNamespaces( RepositorySession session, String repoId, String baseNamespace ) - throws MetadataResolutionException - { - try - { + public Collection<String> getNamespaces(RepositorySession session, String repoId, String baseNamespace) + throws MetadataResolutionException { + try { List<String> allNamespaces; - Path directory = getDirectory( repoId ); + Path directory = getDirectory(repoId); if (!(Files.exists(directory) && Files.isDirectory(directory))) { return Collections.emptyList(); } final String searchFile = NAMESPACE_METADATA_KEY + ".properties"; - try(Stream<Path> fs = Files.list(directory)) { + try (Stream<Path> fs = Files.list(directory)) { allNamespaces = fs.filter(Files::isDirectory).filter(path -> Files.exists(path.resolve(searchFile)) ).map(path -> path.getFileName().toString()).collect(Collectors.toList()); @@ -1307,188 +1061,147 @@ public class FileMetadataRepository Set<String> namespaces = new LinkedHashSet<>(); int fromIndex = baseNamespace != null ? baseNamespace.length() + 1 : 0; - for ( String namespace : allNamespaces ) - { - if ( baseNamespace == null || namespace.startsWith( baseNamespace + "." ) ) - { - int i = namespace.indexOf( '.', fromIndex ); - if ( i >= 0 ) - { - namespaces.add( namespace.substring( fromIndex, i ) ); - } - else - { - namespaces.add( namespace.substring( fromIndex ) ); + for (String namespace : allNamespaces) { + if (baseNamespace == null || namespace.startsWith(baseNamespace + ".")) { + int i = namespace.indexOf('.', fromIndex); + if (i >= 0) { + namespaces.add(namespace.substring(fromIndex, i)); + } else { + namespaces.add(namespace.substring(fromIndex)); } } } - return new ArrayList<>( namespaces ); - } - catch ( IOException e ) - { - throw new MetadataResolutionException( e.getMessage(), e ); + return new ArrayList<>(namespaces); + } catch (IOException e) { + throw new MetadataResolutionException(e.getMessage(), e); } } @Override - public Collection<String> getProjects( RepositorySession session, String repoId, String namespace ) - throws MetadataResolutionException - { - try - { + public Collection<String> getProjects(RepositorySession session, String repoId, String namespace) + throws MetadataResolutionException { + try { List<String> projects; - Path directory = getDirectory( repoId ).resolve( namespace ); + Path directory = getDirectory(repoId).resolve(namespace); if (!(Files.exists(directory) && Files.isDirectory(directory))) { return Collections.emptyList(); } final String searchFile = PROJECT_METADATA_KEY + ".properties"; - try(Stream<Path> fs = Files.list(directory)) { + try (Stream<Path> fs = Files.list(directory)) { projects = fs.filter(Files::isDirectory).filter(path -> Files.exists(path.resolve(searchFile)) ).map(path -> path.getFileName().toString()).collect(Collectors.toList()); } return projects; - } - catch ( IOException e ) - { - throw new MetadataResolutionException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataResolutionException(e.getMessage(), e); } } @Override - public Collection<String> getProjectVersions( RepositorySession session, String repoId, String namespace, String projectId ) - throws MetadataResolutionException - { - try - { + public Collection<String> getProjectVersions(RepositorySession session, String repoId, String namespace, String projectId) + throws MetadataResolutionException { + try { List<String> projectVersions; - Path directory = getDirectory( repoId ).resolve( namespace + "/" + projectId ); + Path directory = getDirectory(repoId).resolve(namespace + "/" + projectId); if (!(Files.exists(directory) && Files.isDirectory(directory))) { return Collections.emptyList(); } final String searchFile = PROJECT_VERSION_METADATA_KEY + ".properties"; - try(Stream<Path> fs = Files.list(directory)) { + try (Stream<Path> fs = Files.list(directory)) { projectVersions = fs.filter(Files::isDirectory).filter(path -> Files.exists(path.resolve(searchFile)) ).map(path -> path.getFileName().toString()).collect(Collectors.toList()); } return projectVersions; - } - catch ( IOException e ) - { - throw new MetadataResolutionException( e.getMessage(), e ); + } catch (IOException e) { + throw new MetadataResolutionException(e.getMessage(), e); } } @Override - public void removeProject( RepositorySession session, String repositoryId, String namespace, String projectId ) - throws MetadataRepositoryException - { - try - { - Path directory = getDirectory( repositoryId ).resolve( namespace + "/" + projectId ); - org.apache.archiva.common.utils.FileUtils.deleteDirectory( directory ); - } - catch ( IOException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + public void removeProject(RepositorySession session, String repositoryId, String namespace, String projectId) + throws MetadataRepositoryException { + try { + Path directory = getDirectory(repositoryId).resolve(namespace + "/" + projectId); + org.apache.archiva.common.utils.FileUtils.deleteDirectory(directory); + } catch (IOException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } @Override - public void removeProjectVersion( RepositorySession session, String repoId, String namespace, String projectId, String projectVersion ) - throws MetadataRepositoryException - { - try - { - Path directory = getDirectory( repoId ).resolve( namespace + "/" + projectId + "/" + projectVersion ); - org.apache.archiva.common.utils.FileUtils.deleteDirectory( directory ); - } - catch ( IOException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + public void removeProjectVersion(RepositorySession session, String repoId, String namespace, String projectId, String projectVersion) + throws MetadataRepositoryException { + try { + Path directory = getDirectory(repoId).resolve(namespace + "/" + projectId + "/" + projectVersion); + org.apache.archiva.common.utils.FileUtils.deleteDirectory(directory); + } catch (IOException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } - private void writeProperties( Properties properties, Path directory, String propertiesKey ) - throws IOException - { + private void writeProperties(Properties properties, Path directory, String propertiesKey) + throws IOException { Files.createDirectories(directory); - try (OutputStream os = Files.newOutputStream( directory.resolve( propertiesKey + ".properties" ))) - { - properties.store( os, null ); + try (OutputStream os = Files.newOutputStream(directory.resolve(propertiesKey + ".properties"))) { + properties.store(os, null); } } private static class ArtifactComparator - implements Comparator<ArtifactMetadata> - { + implements Comparator<ArtifactMetadata> { @Override - public int compare( ArtifactMetadata artifact1, ArtifactMetadata artifact2 ) - { - if ( artifact1.getWhenGathered() == artifact2.getWhenGathered() ) - { + public int compare(ArtifactMetadata artifact1, ArtifactMetadata artifact2) { + if (artifact1.getWhenGathered() == artifact2.getWhenGathered()) { return 0; } - if ( artifact1.getWhenGathered() == null ) - { + if (artifact1.getWhenGathered() == null) { return 1; } - if ( artifact2.getWhenGathered() == null ) - { + if (artifact2.getWhenGathered() == null) { return -1; } - return artifact1.getWhenGathered().compareTo( artifact2.getWhenGathered() ); + return artifact1.getWhenGathered().compareTo(artifact2.getWhenGathered()); } } @Override - public List<ArtifactMetadata> getArtifacts( RepositorySession session, String repoId ) - throws MetadataRepositoryException - { - try - { + public List<ArtifactMetadata> getArtifacts(RepositorySession session, String repoId) + throws MetadataRepositoryException { + try { List<ArtifactMetadata> artifacts = new ArrayList<>(); - for ( String ns : getRootNamespaces( session, repoId ) ) - { - getArtifacts( session, artifacts, repoId, ns ); + for (String ns : getRootNamespaces(session, repoId)) { + getArtifacts(session, artifacts, repoId, ns); } return artifacts; - } - catch ( MetadataResolutionException e ) - { - throw new MetadataRepositoryException( e.getMessage(), e ); + } catch (MetadataResolutionException e) { + throw new MetadataRepositoryException(e.getMessage(), e); } } - private void getArtifacts( RepositorySession session, List<ArtifactMetadata> artifacts, String repoId, String ns ) - throws MetadataResolutionException - { - for ( String namespace : getNamespaces( session, repoId, ns ) ) - { - getArtifacts( session, artifacts, repoId, ns + "." + namespace ); + private void getArtifacts(RepositorySession session, List<ArtifactMetadata> artifacts, String repoId, String ns) + throws MetadataResolutionException { + for (String namespace : getNamespaces(session, repoId, ns)) { + getArtifacts(session, artifacts, repoId, ns + "." + namespace); } - for ( String project : getProjects( session, repoId, ns ) ) - { - for ( String version : getProjectVersions( session, repoId, ns, project ) ) - { - artifacts.addAll( getArtifacts( session, repoId, ns, project, version ) ); + for (String project : getProjects(session, repoId, ns)) { + for (String version : getProjectVersions(session, repoId, ns, project)) { + artifacts.addAll(getArtifacts(session, repoId, ns, project, version)); } } } @Override - public List<ArtifactMetadata> searchArtifacts( RepositorySession session, String repositoryId, String text, boolean exact ) - { - throw new UnsupportedOperationException( "searchArtifacts not yet implemented in File backend" ); + public List<ArtifactMetadata> searchArtifacts(RepositorySession session, String repositoryId, String text, boolean exact) { + throw new UnsupportedOperationException("searchArtifacts not yet implemented in File backend"); } @Override - public List<ArtifactMetadata> searchArtifacts( RepositorySession session, String repositoryId, String key, String text, boolean exact ) - { - throw new UnsupportedOperationException( "searchArtifacts not yet implemented in File backend" ); + public List<ArtifactMetadata> searchArtifacts(RepositorySession session, String repositoryId, String key, String text, boolean exact) { + throw new UnsupportedOperationException("searchArtifacts not yet implemented in File backend"); } } diff --git a/archiva-modules/plugins/metadata-store-jcr/src/main/java/org/apache/archiva/metadata/repository/jcr/JcrConstants.java b/archiva-modules/plugins/metadata-store-jcr/src/main/java/org/apache/archiva/metadata/repository/jcr/JcrConstants.java index e4faa4e1f..46caef96f 100644 --- a/archiva-modules/plugins/metadata-store-jcr/src/main/java/org/apache/archiva/metadata/repository/jcr/JcrConstants.java +++ b/archiva-modules/plugins/metadata-store-jcr/src/main/java/org/apache/archiva/metadata/repository/jcr/JcrConstants.java @@ -19,6 +19,8 @@ package org.apache.archiva.metadata.repository.jcr; * under the License. */ +import java.time.ZoneId; + /** * Node types and properties defined in the schema. * @@ -26,6 +28,9 @@ package org.apache.archiva.metadata.repository.jcr; */ public interface JcrConstants { + + + String BASE_NODE_TYPE = "archiva:base"; String NAMESPACE_NODE_TYPE = "archiva:namespace"; String PROJECT_NODE_TYPE = "archiva:project"; diff --git a/archiva-modules/plugins/metadata-store-jcr/src/main/java/org/apache/archiva/metadata/repository/jcr/JcrMetadataRepository.java b/archiva-modules/plugins/metadata-store-jcr/src/main/java/org/apache/archiva/metadata/repository/jcr/JcrMetadataRepository.java index fd3fd49cf..101b633d8 100644 --- a/archiva-modules/plugins/metadata-store-jcr/src/main/java/org/apache/archiva/metadata/repository/jcr/JcrMetadataRepository.java +++ b/archiva-modules/plugins/metadata-store-jcr/src/main/java/org/apache/archiva/metadata/repository/jcr/JcrMetadataRepository.java @@ -21,20 +21,7 @@ package org.apache.archiva.metadata.repository.jcr; import com.google.common.collect.ImmutableMap; import org.apache.archiva.metadata.QueryParameter; -import org.apache.archiva.metadata.model.ArtifactMetadata; -import org.apache.archiva.metadata.model.CiManagement; -import org.apache.archiva.metadata.model.Dependency; -import org.apache.archiva.metadata.model.FacetedMetadata; -import org.apache.archiva.metadata.model.IssueManagement; -import org.apache.archiva.metadata.model.License; -import org.apache.archiva.metadata.model.MailingList; -import org.apache.archiva.metadata.model.MetadataFacet; -import org.apache.archiva.metadata.model.MetadataFacetFactory; -import org.apache.archiva.metadata.model.Organization; -import org.apache.archiva.metadata.model.ProjectMetadata; -import org.apache.archiva.metadata.model.ProjectVersionMetadata; -import org.apache.archiva.metadata.model.ProjectVersionReference; -import org.apache.archiva.metadata.model.Scm; +import org.apache.archiva.metadata.model.*; import org.apache.archiva.metadata.model.maven2.MavenArtifactFacet; import org.apache.archiva.metadata.repository.AbstractMetadataRepository; import org.apache.archiva.metadata.repository.MetadataRepository; @@ -792,10 +779,10 @@ public class JcrMetadataRepository query.setLimit(queryParameter.getLimit()); ValueFactory valueFactory = jcrSession.getValueFactory(); if (startTime != null) { - query.bindValue("start", valueFactory.createValue(createCalendar(startTime))); + query.bindValue("start", valueFactory.createValue(createCalendar(startTime.withZoneSameInstant(ModelInfo.STORAGE_TZ)))); } if (endTime != null) { - query.bindValue("end", valueFactory.createValue(createCalendar(endTime))); + query.bindValue("end", valueFactory.createValue(createCalendar(endTime.withZoneSameInstant(ModelInfo.STORAGE_TZ)))); } return query.execute(); } catch (RepositoryException e) { @@ -843,7 +830,7 @@ public class JcrMetadataRepository @Override - public List<ArtifactMetadata> getArtifactsByChecksum( RepositorySession session, String repositoryId, String checksum ) + public List<ArtifactMetadata> getArtifactsByChecksum(RepositorySession session, String repositoryId, String checksum ) throws MetadataRepositoryException { final Session jcrSession = getSession( session ); |