Index: archiva-modules/plugins/pom.xml =================================================================== --- archiva-modules/plugins/pom.xml (revision 956052) +++ archiva-modules/plugins/pom.xml (working copy) @@ -35,6 +35,7 @@ npanday-support maven1-repository + stage-repository-merge generic-metadata-support \ No newline at end of file Index: archiva-modules/plugins/stage-repository-merge/src/test/java/org/apache/archiva/stagerepository/merge/repomerge/ArtifactsMergerTest.java =================================================================== --- archiva-modules/plugins/stage-repository-merge/src/test/java/org/apache/archiva/stagerepository/merge/repomerge/ArtifactsMergerTest.java (revision 0) +++ archiva-modules/plugins/stage-repository-merge/src/test/java/org/apache/archiva/stagerepository/merge/repomerge/ArtifactsMergerTest.java (revision 0) @@ -0,0 +1,169 @@ +/* + * (C) Copyright 2009-2010 hSenid Software International (Pvt) Limited. + * All Rights Reserved. + * + * These materials are unpublished, proprietary, confidential source code of + * hSenid Software International (Pvt) Limited and constitute a TRADE SECRET + * of hSenid Software International (Pvt) Limited. + * + * hSenid Software International (Pvt) Limited retains all title to and intellectual + * property rights in these materials. + * + */ +package org.apache.archiva.stagerepository.merge.repomerge; + +import static org.junit.Assert.assertNotNull; +import org.junit.Before; +import org.junit.Test; +import static org.mockito.Mockito.stub; + +import static org.mockito.Mockito.verify; +import org.mockito.MockitoAnnotations; +import static org.mockito.Mockito.*; +import org.codehaus.plexus.spring.PlexusInSpringTestCase; +import org.apache.maven.archiva.repository.RepositoryContentFactory; +import org.apache.maven.archiva.repository.ManagedRepositoryContent; +import org.apache.maven.archiva.repository.content.ManagedDefaultRepositoryContent; +import org.apache.maven.archiva.configuration.ArchivaConfiguration; +import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration; +import org.apache.maven.archiva.configuration.Configuration; +import org.apache.maven.archiva.configuration.RepositoryScanningConfiguration; +import org.apache.maven.archiva.model.ArchivaArtifact; +import org.apache.archiva.stagerepository.merge.repodetails.SourceAritfacts; +import org.apache.archiva.metadata.model.ArtifactMetadata; +import org.apache.archiva.metadata.repository.MetadataResolver; +//import com.sun.xml.internal.ws.api.wsdl.parser.MetaDataResolver; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.io.File; + + +public class ArtifactsMergerTest extends PlexusInSpringTestCase { + + private static final String SOURCE_REPOSITORY_ID = "test-repository"; + + private static final String TARGET_REPOSITORY_ID = "target-repo"; +// private static final String TARGET_REPOSITORY_ID = "target-repo"; + + private Configuration config; + + @MockitoAnnotations.Mock + private MetadataResolver metadataResolver ; + private RepositoryContentFactory repositoryFactory; + private ArchivaConfiguration configuration; + private SourceAritfacts sourceArtifacts ; + private ArtifactsMerger merger; + @Before + public void setUp(){ + MockitoAnnotations.initMocks(this); + metadataResolver = mock(MetadataResolver.class); + repositoryFactory = mock(RepositoryContentFactory.class); + configuration = mock(ArchivaConfiguration.class); + sourceArtifacts = mock(SourceAritfacts.class); + sourceArtifacts.setRepoId(SOURCE_REPOSITORY_ID); + sourceArtifacts.setMetadataResolver(metadataResolver); + setRepositoryConfigurations(); + merger = new ArtifactsMerger(TARGET_REPOSITORY_ID , SOURCE_REPOSITORY_ID); + merger.setConfiguration(configuration); + merger.setRepositoryFactory(repositoryFactory); + merger.setMetadataResolver(metadataResolver); + setSourceArtifacts(); + } + @Test + public void setSourceArtifacts(){ + + when(sourceArtifacts.getSourceArtifactList()).thenReturn(getArtifacts()); + merger.setSourceArtifacts(sourceArtifacts); + verify(sourceArtifacts).getSourceArtifactList(); + + + } + @Test + public void testDomerge() throws Exception{ + ManagedRepositoryContent sourceRepoContent = new ManagedDefaultRepositoryContent(); + sourceRepoContent.setRepository( config.findManagedRepositoryById( SOURCE_REPOSITORY_ID ) ); + + ManagedRepositoryContent targetRepoContent = new ManagedDefaultRepositoryContent(); + sourceRepoContent.setRepository( config.findManagedRepositoryById( TARGET_REPOSITORY_ID ) ); + + + when (configuration.getConfiguration()).thenReturn(config); + when(repositoryFactory.getManagedRepositoryContent(SOURCE_REPOSITORY_ID)).thenReturn(sourceRepoContent); + when(repositoryFactory.getManagedRepositoryContent(TARGET_REPOSITORY_ID)).thenReturn(targetRepoContent); + when(sourceArtifacts.getSourceArtifactList()).thenReturn(getArtifacts()); + when(metadataResolver.getArtifacts(TARGET_REPOSITORY_ID, "archiva" ,"archiva", "1.2.1")).thenReturn(getMetaDataList()); + merger.doMerge(); + +// verify(configuration); +// verify(repositoryFactory); +// verify(repositoryFactory); +// verify(sourceArtifacts); + verify(configuration).getConfiguration(); + verify(repositoryFactory).getManagedRepositoryContent(SOURCE_REPOSITORY_ID); + verify(repositoryFactory).getManagedRepositoryContent(TARGET_REPOSITORY_ID); + verify(sourceArtifacts).getSourceArtifactList(); + verify(metadataResolver).getArtifacts(TARGET_REPOSITORY_ID, "org.apache.archiva" ,"archiva", "1.2.1"); + +// +// + + + } + + public Collection getArtifacts(){ + ArchivaArtifact a1 = new ArchivaArtifact("org.apache.archiva","archiva", "1.2.1" , "", "jar" , SOURCE_REPOSITORY_ID); + ArchivaArtifact a2 = new ArchivaArtifact("org.apache.archiva","archiva", "1.5" , "", "jar" , SOURCE_REPOSITORY_ID); + ArrayList list = new ArrayList(); + list.add(a1) ; +// list.add(a2) ; + return list; + } + + public Collection getMetaDataList(){ + ArtifactMetadata m1 = new ArtifactMetadata(); + m1.setNamespace("org.apache.archiva"); + m1.setProject("archiva"); + m1.setVersion("1.2.1"); + ArrayList list = new ArrayList(); + list.add(m1); + return list; + + } + + public void setRepositoryConfigurations(){ + + + File sourceRepoFile = new File( getBasedir(), "src/test/resources/test-repository" ); + File targetRepoFile = new File( getBasedir(), "src/test/resources/target-repo" ); +// sourceRepoFile.mkdirs(); +// targetRepoFile.mkdirs(); + + assertTrue( sourceRepoFile.exists() ); + this.config = new Configuration(); + RepositoryScanningConfiguration repoScanConfig =new RepositoryScanningConfiguration(); + List knownContentConsumers = new ArrayList(); + knownContentConsumers.add("metadata-updater12"); + repoScanConfig.setKnownContentConsumers(knownContentConsumers); + config.setRepositoryScanning( repoScanConfig); + // config.setManagedRepositories(); + ManagedRepositoryConfiguration sourceRepoConfig = new ManagedRepositoryConfiguration(); + sourceRepoConfig.setId( SOURCE_REPOSITORY_ID ); + sourceRepoConfig.setLayout( "default" ); + sourceRepoConfig.setLocation( sourceRepoFile.getPath() ); + sourceRepoConfig.setName( SOURCE_REPOSITORY_ID ); + sourceRepoConfig.setBlockRedeployments( true ); + + ManagedRepositoryConfiguration targetRepoConfig = new ManagedRepositoryConfiguration(); + targetRepoConfig.setId( TARGET_REPOSITORY_ID ); + targetRepoConfig.setLayout( "default" ); + targetRepoConfig.setLocation( targetRepoFile.getPath() ); + targetRepoConfig.setName( TARGET_REPOSITORY_ID ); + targetRepoConfig.setBlockRedeployments( true ); + + this.config.addManagedRepository( sourceRepoConfig ); + this.config.addManagedRepository( targetRepoConfig ); + } + +} Property changes on: archiva-modules/plugins/stage-repository-merge/src/test/java/org/apache/archiva/stagerepository/merge/repomerge/ArtifactsMergerTest.java ___________________________________________________________________ Added: svn:executable + * Index: archiva-modules/plugins/stage-repository-merge/src/test/java/org/apache/archiva/stagerepository/merge/repodetails/SourceArtifactsTest.java =================================================================== --- archiva-modules/plugins/stage-repository-merge/src/test/java/org/apache/archiva/stagerepository/merge/repodetails/SourceArtifactsTest.java (revision 0) +++ archiva-modules/plugins/stage-repository-merge/src/test/java/org/apache/archiva/stagerepository/merge/repodetails/SourceArtifactsTest.java (revision 0) @@ -0,0 +1,134 @@ +package org.apache.archiva.stagerepository.merge.repodetails; + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.junit.Test; + +import org.apache.archiva.metadata.repository.MetadataResolver; +import org.apache.archiva.metadata.model.ArtifactMetadata; + +import org.apache.maven.archiva.model.ArchivaArtifact; +import org.easymock.MockControl; +import org.codehaus.plexus.spring.PlexusInSpringTestCase; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + + +public class SourceArtifactsTest + extends PlexusInSpringTestCase +{ + + private Logger log = LoggerFactory.getLogger(SourceArtifactsTest.class); + + private MockControl metadataResolverControl; + + private MetadataResolver metadataResolver; + + private static final String TEST_REPO_ID = "internal"; + + private SourceAritfacts sourceArtifacts; + + + @Override + protected void setUp() + throws Exception + { + super.setUp(); + + sourceArtifacts = new SourceAritfacts(); + sourceArtifacts.setRepoId(TEST_REPO_ID); + metadataResolverControl = MockControl.createControl(MetadataResolver.class); + metadataResolver = (MetadataResolver) metadataResolverControl.getMock(); + sourceArtifacts.setMetadataResolver(metadataResolver); + } + + + @Test + public void testSourceArtifacts() + { + + metadataResolverControl.expectAndReturn(metadataResolver.getRootNamespaces(TEST_REPO_ID), getRootNameSpace()); + + metadataResolverControl.expectAndReturn(metadataResolver.getNamespaces(TEST_REPO_ID, "org"), getNameSpace()); + + metadataResolverControl.expectAndReturn(metadataResolver.getNamespaces(TEST_REPO_ID, "org" + "." + "apache"), getProject()); + + metadataResolverControl.expectAndReturn(metadataResolver.getProjectVersions(TEST_REPO_ID, "org" + "." + "apache", "archiva"), getProjectVersions()); + + metadataResolverControl.expectAndReturn(metadataResolver.getArtifacts(TEST_REPO_ID, "apache", "archiva", "1.6"), getArtiFactMetaData()); + + metadataResolverControl.expectAndReturn(metadataResolver.getArtifacts(TEST_REPO_ID, "apache", "archiva", "1.6"), getArtiFactMetaData()); + + metadataResolverControl.replay(); + + Collection list = sourceArtifacts.getSourceArtifactList(); + assertEquals(false, list.isEmpty()); + + ArrayList metadataList = (ArrayList) sourceArtifacts.getSourceArtifactsMetaData(list.iterator().next()); + assertEquals(2, metadataList.size()); + + metadataResolverControl.verify(); + + } + + private Collection getRootNameSpace() + { + List artifactList = new ArrayList(); + artifactList.add("org"); + return artifactList; + } + + private Collection getNameSpace() + { + List namespace = new ArrayList(); + namespace.add("apache"); + return namespace; + } + + private Collection getProject() { + List namespace = new ArrayList(); + namespace.add("archiva"); + return namespace; + } + + private Collection getProjectVersions() + { + List versionList = new ArrayList(); + versionList.add("1.6"); + return versionList; + } + + private Collection getArtiFactMetaData() + { + List metaDataList = new ArrayList(); + ArtifactMetadata metaDataOne = new ArtifactMetadata(); + ArtifactMetadata metaDataTwo = new ArtifactMetadata(); + metaDataList.add(metaDataOne); + metaDataList.add(metaDataTwo); + return metaDataList; + } + +} + + Property changes on: archiva-modules/plugins/stage-repository-merge/src/test/java/org/apache/archiva/stagerepository/merge/repodetails/SourceArtifactsTest.java ___________________________________________________________________ Added: svn:executable + * Index: archiva-modules/plugins/stage-repository-merge/src/main/java/org/apache/archiva/stagerepository/merge/repomerge/ArtifactsMerger.java =================================================================== --- archiva-modules/plugins/stage-repository-merge/src/main/java/org/apache/archiva/stagerepository/merge/repomerge/ArtifactsMerger.java (revision 0) +++ archiva-modules/plugins/stage-repository-merge/src/main/java/org/apache/archiva/stagerepository/merge/repomerge/ArtifactsMerger.java (revision 0) @@ -0,0 +1,383 @@ +package org.apache.archiva.stagerepository.merge.repomerge; + +import org.apache.archiva.stagerepository.merge.repodetails.SourceAritfacts; +import org.apache.archiva.metadata.repository.MetadataResolver; +import org.apache.archiva.metadata.model.ArtifactMetadata; +import org.apache.maven.archiva.model.ArchivaArtifact; +import org.apache.maven.archiva.model.ArchivaRepositoryMetadata; +import org.apache.maven.archiva.configuration.Configuration; +import org.apache.maven.archiva.configuration.ManagedRepositoryConfiguration; +import org.apache.maven.archiva.configuration.ArchivaConfiguration; +import org.apache.maven.archiva.repository.ManagedRepositoryContent; +import org.apache.maven.archiva.repository.RepositoryContentFactory; +import org.apache.maven.archiva.repository.RepositoryNotFoundException; +import org.apache.maven.archiva.repository.RepositoryException; +import org.apache.maven.archiva.repository.metadata.MetadataTools; +import org.apache.maven.archiva.repository.metadata.RepositoryMetadataException; +import org.apache.maven.archiva.repository.metadata.RepositoryMetadataReader; +import org.apache.maven.archiva.repository.metadata.RepositoryMetadataWriter; +import org.apache.maven.archiva.common.utils.VersionComparator; +import org.apache.maven.archiva.common.utils.VersionUtil; + +import java.util.*; +import java.io.File; +import java.io.IOException; +import java.io.FileOutputStream; +import java.io.FileInputStream; +import java.text.DateFormat; +import java.text.SimpleDateFormat;/* + * 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. + */ + +/** + * @plexus.component role="org.apache.archiva.stagerepository.merge.repomerge.ArtifactsMerger" + */ + +public class ArtifactsMerger +{ + + /** + * @plexus.requirement + */ + private MetadataResolver metadataResolver; + + /** + * @plexus.requirement + */ + private RepositoryContentFactory repositoryFactory; + + /** + * @plexus.requirement role-hint="default" + */ + private ArchivaConfiguration configuration; + + private SourceAritfacts sourceArtifacts; + + private String targetRepo; + + private String sourceRepo; + + private ArrayList sourceArtifactsList; + + private Configuration config; + + private ManagedRepositoryConfiguration targetRepoConfig; + + private ManagedRepositoryConfiguration sourceRepoConfig; + + private ManagedRepositoryContent targetRepository; + + private ManagedRepositoryContent sourceRepository; + + private final static String PATH_SEPERATOR = "/"; + + public void setMetadataResolver(MetadataResolver metadataResolver) + { + this.metadataResolver = metadataResolver; + } + + public void setSourceArtifacts(SourceAritfacts sourceArtifacts) + { + this.sourceArtifacts = sourceArtifacts; + setSourceArtifactsList(); + } + + public void setConfiguration(ArchivaConfiguration configuration) + { + this.configuration = configuration; + } + + public void setRepositoryFactory(RepositoryContentFactory repositoryFactory) + { + this.repositoryFactory = repositoryFactory; + } + + public ArtifactsMerger(String targetRepo, String sourceRepo) { + this.targetRepo = targetRepo; + this.sourceRepo = sourceRepo; + + } + + private void setSourceArtifactsList() + { + sourceArtifacts.setRepoId(sourceRepo); + sourceArtifactsList = (ArrayList) sourceArtifacts.getSourceArtifactList(); + } + + private boolean isArtifactAvailableIntagerRepo(ArchivaArtifact artifact) + { + + boolean isAvailable = false; + + Collection list = metadataResolver.getArtifacts(targetRepo, artifact.getGroupId(), + artifact.getArtifactId(), artifact.getVersion()); + + if (list.isEmpty()) + { + isAvailable = false; + } else + { + isAvailable = true; + } + return isAvailable; + } + + public void doMerge() throws Exception + { + try + { + config = configuration.getConfiguration(); + + targetRepoConfig = config.findManagedRepositoryById(targetRepo); + + targetRepository = repositoryFactory.getManagedRepositoryContent(targetRepo); + + sourceRepoConfig = config.findManagedRepositoryById(sourceRepo); + + sourceRepository = repositoryFactory.getManagedRepositoryContent(sourceRepo); + + //iterates through available arfifacts list + for (ArchivaArtifact sourceArtifact : sourceArtifactsList) + { + + if (isArtifactAvailableIntagerRepo(sourceArtifact)) + { + //TODO here we need to implement replacing the exixting one + } else + { + // when the artifact does not exist in the repo folder structure creation is done + createFolderStructure(sourceArtifact); + } + } + } catch (RepositoryNotFoundException re) + { + throw re; + } + catch (RepositoryException rep) + { + throw rep; + } + } + + private void createFolderStructure(ArchivaArtifact artifact) throws IOException, RepositoryMetadataException + { + + Date lastUpdatedTimestamp = Calendar.getInstance().getTime(); + + TimeZone timezone = TimeZone.getTimeZone("UTC"); + + DateFormat fmt = new SimpleDateFormat("yyyyMMdd.HHmmss"); + + fmt.setTimeZone(timezone); + + String timestamp = fmt.format(lastUpdatedTimestamp); + + String targetRepoPath = targetRepoConfig.getLocation(); + + String sourceRepoPath = sourceRepoConfig.getLocation(); + + String artifactPath = sourceRepository.toPath(artifact); + + File sourceArtifactFile = new File(sourceRepoPath, artifactPath); + + File targetArtifactFile = new File(targetRepoPath, artifactPath); + + int lastIndex = artifactPath.lastIndexOf('/'); + + + // create a file object to the artifact version directory eg :/boot/gsoc/apps/apache-archiva-1.4-SNAPSHOT/data/repositories/internal/ant/ant/1.5.1 + File targetFile = new File(targetRepoPath, artifactPath.substring(0, lastIndex)); + + if (!targetFile.exists()) + { + // create the folder structure when it does not exist + targetFile.mkdirs(); + } + + //artifact copying + copyFile(sourceArtifactFile, targetArtifactFile); + // pom file copying + String index = artifactPath.substring(lastIndex + 1); + int last = index.lastIndexOf('.'); + File sourcePomFile = new File(sourceRepoPath, artifactPath.substring(0, lastIndex) + "/" + + artifactPath.substring(lastIndex + 1).substring(0, last) + ".pom"); + File targetPomFile = new File(targetRepoPath, artifactPath.substring(0, lastIndex) + "/" + + artifactPath.substring(lastIndex + 1).substring(0, last) + ".pom"); + + if (!targetPomFile.exists()) + { + copyFile(sourcePomFile, targetPomFile); + } + + // explicitly update only if metadata-updater consumer is not enabled! + if (!config.getRepositoryScanning().getKnownContentConsumers().contains("metadata-updater")) + { + + // maven version meta data file copying + + File versionMetadataFileInSourceArtifact = new File(sourceRepoPath, artifactPath.substring(0, lastIndex) + "/" + + MetadataTools.MAVEN_METADATA); + + File versionMetadataFileInTargetArtifact = null; + + // check metadata xml is available in source repo. if there is a metadata xml we are going to merge is as well + if (versionMetadataFileInSourceArtifact.exists()) + { + versionMetadataFileInTargetArtifact = new File(targetRepoPath, artifactPath.substring(0, lastIndex) + "/" + MetadataTools.MAVEN_METADATA); + + // check metadata xml is available in target repo. if it is not available copy it from the source artifact + if (!versionMetadataFileInTargetArtifact.exists()) + { + copyFile(versionMetadataFileInSourceArtifact, versionMetadataFileInTargetArtifact); + } else + { + // if version metadata file exists then update it. + updateVersionMetadata(versionMetadataFileInTargetArtifact, artifact, lastUpdatedTimestamp, timestamp); + } + } + + // project level maven meta data xml copying + String projectDirectoryInSourceRepo = new File(versionMetadataFileInSourceArtifact.getParent()).getParent(); + File projectMetadataFileInSourceArtifact = new File(projectDirectoryInSourceRepo, MetadataTools.MAVEN_METADATA); + + // check metadata xml is available in source repo. if there is a metadata xml we are going to merge is as well + if (projectMetadataFileInSourceArtifact.exists()) + { + + String projectDirectoryInTargetRepo = new File(versionMetadataFileInTargetArtifact.getParent()).getParent(); + File projectMetadataFileInTargetArtifact = new File(projectDirectoryInTargetRepo, MetadataTools.MAVEN_METADATA); + // check metadata xml is available in target repo.if it is not available copy it from the source artifact + if (!projectMetadataFileInTargetArtifact.exists()) + { + copyFile(projectMetadataFileInSourceArtifact, projectMetadataFileInTargetArtifact); + } else + { + // // if project metadata file exists then update it. + updateProjectMetadata(projectMetadataFileInTargetArtifact, artifact, lastUpdatedTimestamp, timestamp); + } + } + } + } + + private void copyFile(File sourceFile, File targetFile) throws IOException + { + + FileOutputStream out = new FileOutputStream(targetFile); + FileInputStream input = new FileInputStream(sourceFile); + + try + { + int i; + while ((i = input.read()) != -1) + { + out.write(i); + } + out.flush(); + } + finally + { + out.close(); + input.close(); + } + } + + + /** + * Update artifact level metadata. + */ + private void updateProjectMetadata(File projectMetaDataFileIntargetRepo, ArchivaArtifact artifact, Date lastUpdatedTimestamp, + String timestamp) + throws RepositoryMetadataException + { + ArrayList availableVersions = new ArrayList(); + String latestVersion = ""; + + ArchivaRepositoryMetadata projectMetadata = getMetadata(projectMetaDataFileIntargetRepo); + + if (projectMetaDataFileIntargetRepo.exists()) + { + availableVersions = (ArrayList) projectMetadata.getAvailableVersions(); + + Collections.sort(availableVersions, VersionComparator.getInstance()); + + if (!availableVersions.contains(artifact.getVersion())) + { + availableVersions.add(artifact.getVersion()); + } + + latestVersion = availableVersions.get(availableVersions.size() - 1); + } else + { + availableVersions.add(artifact.getVersion()); + projectMetadata.setGroupId(artifact.getGroupId()); + projectMetadata.setArtifactId(artifact.getArtifactId()); + } + + if (projectMetadata.getGroupId() == null) + { + projectMetadata.setGroupId(artifact.getGroupId()); + } + + if (projectMetadata.getArtifactId() == null) + { + projectMetadata.setArtifactId(artifact.getArtifactId()); + } + + projectMetadata.setLatestVersion(latestVersion); + projectMetadata.setAvailableVersions(availableVersions); + projectMetadata.setLastUpdated(timestamp); + projectMetadata.setLastUpdatedTimestamp(lastUpdatedTimestamp); + + if (!VersionUtil.isSnapshot(artifact.getVersion())) + { + projectMetadata.setReleasedVersion(latestVersion); + } + + RepositoryMetadataWriter.write(projectMetadata, projectMetaDataFileIntargetRepo); + + } + + private void updateVersionMetadata(File versionMetaDataFileInTargetRepo, ArchivaArtifact artifact, Date lastUpdatedTimestamp, + String timestamp) + throws RepositoryMetadataException + { + ArchivaRepositoryMetadata versionMetadata = getMetadata(versionMetaDataFileInTargetRepo); + if (!versionMetaDataFileInTargetRepo.exists()) + { + versionMetadata.setGroupId(artifact.getGroupId()); + versionMetadata.setArtifactId(artifact.getArtifactId()); + versionMetadata.setVersion(artifact.getVersion()); + } + + versionMetadata.getSnapshotVersion().setTimestamp(timestamp); + versionMetadata.setLastUpdatedTimestamp(lastUpdatedTimestamp); + RepositoryMetadataWriter.write(versionMetadata, versionMetaDataFileInTargetRepo); + } + + + private ArchivaRepositoryMetadata getMetadata(File metadataFile) + throws RepositoryMetadataException + { + ArchivaRepositoryMetadata metadata = new ArchivaRepositoryMetadata(); + if (metadataFile.exists()) + { + metadata = RepositoryMetadataReader.read(metadataFile); + } + return metadata; + } +} Property changes on: archiva-modules/plugins/stage-repository-merge/src/main/java/org/apache/archiva/stagerepository/merge/repomerge/ArtifactsMerger.java ___________________________________________________________________ Added: svn:executable + * Index: archiva-modules/plugins/stage-repository-merge/src/main/java/org/apache/archiva/stagerepository/merge/repodetails/SourceAritfacts.java =================================================================== --- archiva-modules/plugins/stage-repository-merge/src/main/java/org/apache/archiva/stagerepository/merge/repodetails/SourceAritfacts.java (revision 0) +++ archiva-modules/plugins/stage-repository-merge/src/main/java/org/apache/archiva/stagerepository/merge/repodetails/SourceAritfacts.java (revision 0) @@ -0,0 +1,159 @@ +package org.apache.archiva.stagerepository.merge.repodetails; + +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +import org.apache.archiva.metadata.repository.MetadataResolver; +import org.apache.archiva.metadata.repository.storage.maven2.MavenArtifactFacet; +import org.apache.maven.archiva.model.ArchivaArtifact; +import org.apache.archiva.metadata.model.ArtifactMetadata; + +import java.util.List; +import java.util.Collection; +import java.util.ArrayList; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + + +/** + * @plexus.component role="org.apache.archiva.stagerepository.merge.repodetails.SourceAritfacts" + */ + +public class SourceAritfacts +{ + + /** + * @plexus.requirement + */ + + private MetadataResolver metadataResolver; + + private ArrayList rootNameSpacesList; + + private ArrayList gruopIdList; + + private ArrayList artifactsList; + + private ArrayList artifactsVersionsList; + + private List artifactsListWithDetails; + + private String repoId; + + private static final Logger log = LoggerFactory.getLogger(SourceAritfacts.class); + + public String getRepoId() + { + return repoId; + } + + public void setRepoId(String repoId) + { + this.repoId = repoId; + } + + // this methos returns a ArtifactMetaData List.(i guess no harm due to hardcoding the Artifact type and version) + public Collection getSourceArtifactsMetaData(ArchivaArtifact artifact) + { + + return metadataResolver.getArtifacts(artifact.getRepositoryId(), artifact.getGroupId(), artifact.getArtifactId(), + artifact.getVersion()); + } + + + public Collection getSourceArtifactList() + { + artifactsListWithDetails = new ArrayList(); + + process(); + + return artifactsListWithDetails; + } + + + public void setMetadataResolver(MetadataResolver metadataResolver) + { + this.metadataResolver = metadataResolver; + } + + private void process() { + //this will get the root name spaces eg : org, com + rootNameSpacesList = (ArrayList) metadataResolver.getRootNamespaces(repoId); + + gruopIdList = new ArrayList(); + + artifactsList = new ArrayList(); + + //following iterates through the root name spaces list and get the gruo id of relavet root name spaces. + for (String namespace : rootNameSpacesList) + { + //this will get the gruop id list of relavant name space . eg : org > archiva(gruop id) + gruopIdList = (ArrayList) metadataResolver.getNamespaces(repoId, namespace); + + // following will iterates through the particular gruop id 's + for (String gruopId : gruopIdList) + { + // parse the parameters "repoId" and "namespace + gruop id "to artifacts list. eg : params = ("internal" , "org.archiva") + artifactsList = (ArrayList) metadataResolver.getNamespaces(repoId, namespace + "." + gruopId); + + for (String artifact : artifactsList) + { + //iterates through the artifacts and get the available versions of a particular artifact + artifactsVersionsList = (ArrayList) metadataResolver.getProjectVersions(repoId, namespace + "." + gruopId, artifact); + + for (String version : artifactsVersionsList) + { + //assign gathered attributes Artifact object and add it in to the list + artifactsListWithDetails.addAll(getArtifactMetadata(repoId, gruopId, artifact, version)); + + } + } + } + } + + } + + private Collection getArtifactMetadata(String repoId, String gruopId, String artifactId, String version) + { + MavenArtifactFacet facet = null; + + List artifactList = new ArrayList(); + + ArrayList artifactMetaDataList = (ArrayList) metadataResolver.getArtifacts(repoId, gruopId, artifactId, version); + + + for (ArtifactMetadata artifactMetadata : artifactMetaDataList) + { + + facet = (MavenArtifactFacet) artifactMetadata.getFacet(MavenArtifactFacet.FACET_ID); + + if (facet != null) + { + artifactList.add(new ArchivaArtifact(gruopId, artifactId, version, facet.getClassifier(), facet.getType(), repoId)); + + } else + { + artifactList.add(new ArchivaArtifact(gruopId, artifactId, version, "", "jar", repoId)); + } + + } + return artifactList; + } +} Property changes on: archiva-modules/plugins/stage-repository-merge/src/main/java/org/apache/archiva/stagerepository/merge/repodetails/SourceAritfacts.java ___________________________________________________________________ Added: svn:executable + * Index: archiva-modules/plugins/stage-repository-merge/pom.xml =================================================================== --- archiva-modules/plugins/stage-repository-merge/pom.xml (revision 0) +++ archiva-modules/plugins/stage-repository-merge/pom.xml (revision 0) @@ -0,0 +1,118 @@ + + + 4.0.0 + + plugins + org.apache.archiva + 1.4-SNAPSHOT + + org.apache.archiva + stage-repository-merge + 1.0-SNAPSHOT + stage-repository-merge + http://maven.apache.org + + + junit + junit + 4.5 + test + + + org.codehaus.plexus + plexus-spring + test + + + org.apache.archiva + metadata-repository-api + 1.4-SNAPSHOT + + + org.apache.archiva + archiva-repository-layer + 1.4-SNAPSHOT + + + org.apache.archiva + maven2-repository + 1.4-SNAPSHOT + + + org.apache.archiva + archiva-model + 1.4-SNAPSHOT + + + org.mockito + mockito-all + 1.8.1 + test + + + org.apache.archiva + test-repository + test + + + org.slf4j + slf4j-jdk14 + test + + + + UTF-8 + + + + + + + + + org.apache.maven.plugins + maven-dependency-plugin + + + test-repository + generate-test-resources + + unpack-dependencies + + + test-repository + target/test-repository + META-INF/** + + + + + + + + + + org.codehaus.plexus + plexus-component-metadata + 1.0-beta-3.0.5 + + + process-classes + + generate-metadata + + + + process-test-classes + + generate-test-metadata + + + + + + + + + Property changes on: archiva-modules/plugins/stage-repository-merge/pom.xml ___________________________________________________________________ Added: svn:executable + *