Java tutorial
package org.apache.archiva.proxy; /* * 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 net.sf.ehcache.CacheManager; import org.apache.archiva.admin.model.beans.ManagedRepository; import org.apache.archiva.admin.model.managed.ManagedRepositoryAdmin; import org.apache.archiva.admin.repository.managed.DefaultManagedRepositoryAdmin; import org.apache.archiva.common.plexusbridge.PlexusSisuBridge; import org.apache.archiva.configuration.ArchivaConfiguration; import org.apache.archiva.configuration.ManagedRepositoryConfiguration; import org.apache.archiva.configuration.ProxyConnectorConfiguration; import org.apache.archiva.configuration.RemoteRepositoryConfiguration; import org.apache.archiva.policies.CachedFailuresPolicy; import org.apache.archiva.policies.ChecksumPolicy; import org.apache.archiva.policies.PropagateErrorsDownloadPolicy; import org.apache.archiva.policies.PropagateErrorsOnUpdateDownloadPolicy; import org.apache.archiva.policies.ReleasesPolicy; import org.apache.archiva.policies.SnapshotsPolicy; import org.apache.archiva.proxy.model.RepositoryProxyConnectors; import org.apache.archiva.repository.ManagedRepositoryContent; import org.apache.archiva.test.utils.ArchivaSpringJUnit4ClassRunner; import org.apache.commons.io.FileUtils; import org.apache.maven.index.NexusIndexer; import org.apache.maven.index.context.IndexingContext; import org.apache.maven.wagon.Wagon; import org.easymock.EasyMock; import org.easymock.IMocksControl; import org.junit.After; import org.junit.Before; import org.junit.runner.RunWith; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.context.ApplicationContext; import org.springframework.test.context.ContextConfiguration; import javax.inject.Inject; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; import java.nio.charset.Charset; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Calendar; import java.util.Collection; import java.util.Date; import java.util.Locale; import static org.junit.Assert.*; /** * AbstractProxyTestCase */ @RunWith(ArchivaSpringJUnit4ClassRunner.class) @ContextConfiguration(locations = { "classpath*:/META-INF/spring-context.xml", "classpath:/spring-context.xml" }) public abstract class AbstractProxyTestCase { @Inject protected ApplicationContext applicationContext; protected static final String ID_PROXIED1 = "proxied1"; protected static final String ID_PROXIED1_TARGET = "proxied1-target"; protected static final String ID_PROXIED2 = "proxied2"; protected static final String ID_PROXIED2_TARGET = "proxied2-target"; protected static final String ID_DEFAULT_MANAGED = "default-managed-repository"; protected static final String REPOPATH_PROXIED1 = "src/test/repositories/proxied1"; protected static final String REPOPATH_PROXIED1_TARGET = "target/test-repository/proxied1"; protected static final String REPOPATH_PROXIED2 = "src/test/repositories/proxied2"; protected static final String REPOPATH_PROXIED2_TARGET = "target/test-repository/proxied2"; protected static final String REPOPATH_DEFAULT_MANAGED = "src/test/repositories/managed"; // protected static final String REPOPATH_DEFAULT_MANAGED_TARGET = "target/test-repository/managed"; protected IMocksControl wagonMockControl; protected Wagon wagonMock; protected RepositoryProxyConnectors proxyHandler; protected ManagedRepositoryContent managedDefaultRepository; protected File managedDefaultDir; protected MockConfiguration config; protected Logger log = LoggerFactory.getLogger(getClass()); WagonDelegate delegate; @Inject protected ManagedRepositoryAdmin managedRepositoryAdmin; @Inject protected PlexusSisuBridge plexusSisuBridge; @Before public void setUp() throws Exception { config = (MockConfiguration) applicationContext.getBean("archivaConfiguration#mock", ArchivaConfiguration.class); config.getConfiguration().setManagedRepositories(new ArrayList<ManagedRepositoryConfiguration>()); config.getConfiguration().setRemoteRepositories(new ArrayList<RemoteRepositoryConfiguration>()); config.getConfiguration().setProxyConnectors(new ArrayList<ProxyConnectorConfiguration>()); // Setup source repository (using default layout) String name = getClass().getSimpleName(); String repoPath = "target/test-repository/managed/" + name; managedDefaultRepository = createRepository(ID_DEFAULT_MANAGED, "Default Managed Repository", repoPath, "default"); managedDefaultDir = new File(managedDefaultRepository.getRepoRoot()); ManagedRepository repoConfig = managedDefaultRepository.getRepository(); ((DefaultManagedRepositoryAdmin) applicationContext.getBean(ManagedRepositoryAdmin.class)) .setArchivaConfiguration(config); applicationContext.getBean(ManagedRepositoryAdmin.class).addManagedRepository(repoConfig, false, null); // to prevent windauze file leaking removeMavenIndexes(); ManagedRepositoryAdmin managedRepositoryAdmin = applicationContext.getBean(ManagedRepositoryAdmin.class); if (managedRepositoryAdmin.getManagedRepository(repoConfig.getId()) != null) { managedRepositoryAdmin.deleteManagedRepository(repoConfig.getId(), null, true); } managedRepositoryAdmin.addManagedRepository(repoConfig, false, null); // Setup target (proxied to) repository. saveRemoteRepositoryConfig(ID_PROXIED1, "Proxied Repository 1", new File(REPOPATH_PROXIED1).toURL().toExternalForm(), "default"); // Setup target (proxied to) repository. saveRemoteRepositoryConfig(ID_PROXIED2, "Proxied Repository 2", new File(REPOPATH_PROXIED2).toURL().toExternalForm(), "default"); // Setup the proxy handler. //proxyHandler = applicationContext.getBean (RepositoryProxyConnectors) lookup( RepositoryProxyConnectors.class.getName() ); proxyHandler = applicationContext.getBean("repositoryProxyConnectors#test", RepositoryProxyConnectors.class); // Setup the wagon mock. wagonMockControl = EasyMock.createNiceControl(); wagonMock = wagonMockControl.createMock(Wagon.class); delegate = (WagonDelegate) applicationContext.getBean("wagon#test", Wagon.class); delegate.setDelegate(wagonMock); CacheManager.getInstance().clearAll(); log.info("\n.\\ {}() \\._________________________________________\n", name); } @After public void shutdown() throws Exception { removeMavenIndexes(); } protected void removeMavenIndexes() throws Exception { NexusIndexer nexusIndexer = plexusSisuBridge.lookup(NexusIndexer.class); for (IndexingContext indexingContext : nexusIndexer.getIndexingContexts().values()) { nexusIndexer.removeIndexingContext(indexingContext, false); } } /* protected static final ArgumentsMatcher customWagonGetIfNewerMatcher = new ArgumentsMatcher() { public boolean matches( Object[] expected, Object[] actual ) { if ( expected.length < 1 || actual.length < 1 ) { return false; } return MockControl.ARRAY_MATCHER.matches( ArrayUtils.remove( expected, 1 ), ArrayUtils.remove( actual, 1 ) ); } public String toString( Object[] arguments ) { return ArrayUtils.toString( arguments ); } }; protected static final ArgumentsMatcher customWagonGetMatcher = new ArgumentsMatcher() { public boolean matches( Object[] expected, Object[] actual ) { if ( expected.length == 2 && actual.length == 2 ) { if ( expected[0] == null && actual[0] == null ) { return true; } if ( expected[0] == null ) { return actual[0] == null; } if ( actual[0] == null ) { return expected[0] == null; } return expected[0].equals( actual[0] ); } return false; } public String toString( Object[] arguments ) { return ArrayUtils.toString( arguments ); } }; */ protected void assertChecksums(File expectedFile, String expectedSha1Contents, String expectedMd5Contents) throws Exception { File sha1File = new File(expectedFile.getAbsolutePath() + ".sha1"); File md5File = new File(expectedFile.getAbsolutePath() + ".md5"); if (expectedSha1Contents == null) { assertFalse("SHA1 File should NOT exist: " + sha1File.getPath(), sha1File.exists()); } else { assertTrue("SHA1 File should exist: " + sha1File.getPath(), sha1File.exists()); String actualSha1Contents = readChecksumFile(sha1File); assertEquals("SHA1 File contents: " + sha1File.getPath(), expectedSha1Contents, actualSha1Contents); } if (expectedMd5Contents == null) { assertFalse("MD5 File should NOT exist: " + md5File.getPath(), md5File.exists()); } else { assertTrue("MD5 File should exist: " + md5File.getPath(), md5File.exists()); String actualMd5Contents = readChecksumFile(md5File); assertEquals("MD5 File contents: " + md5File.getPath(), expectedMd5Contents, actualMd5Contents); } } protected void assertFileEquals(File expectedFile, File actualFile, File sourceFile) throws Exception { assertNotNull("Expected File should not be null.", expectedFile); assertNotNull("Actual File should not be null.", actualFile); assertTrue("Check actual file exists.", actualFile.exists()); assertEquals("Check filename path is appropriate.", expectedFile.getCanonicalPath(), actualFile.getCanonicalPath()); assertEquals("Check file path matches.", expectedFile.getAbsolutePath(), actualFile.getAbsolutePath()); String expectedContents = org.apache.commons.io.FileUtils.readFileToString(sourceFile, Charset.defaultCharset()); String actualContents = org.apache.commons.io.FileUtils.readFileToString(actualFile, Charset.defaultCharset()); assertEquals("Check file contents.", expectedContents, actualContents); } protected void assertNotDownloaded(File downloadedFile) { assertNull("Found file: " + downloadedFile + "; but was expecting a failure", downloadedFile); } @SuppressWarnings("unchecked") protected void assertNoTempFiles(File expectedFile) { File workingDir = expectedFile.getParentFile(); if ((workingDir == null) || !workingDir.isDirectory()) { return; } Collection<File> tmpFiles = org.apache.commons.io.FileUtils.listFiles(workingDir, new String[] { "tmp" }, false); if (!tmpFiles.isEmpty()) { StringBuilder emsg = new StringBuilder(); emsg.append("Found Temp Files in dir: ").append(workingDir.getPath()); for (File tfile : tmpFiles) { emsg.append("\n ").append(tfile.getName()); } fail(emsg.toString()); } } /** * A faster recursive copy that omits .svn directories. * * @param sourceDirectory the source directory to copy * @param destDirectory the target location * @throws java.io.IOException if there is a copying problem * @todo get back into plexus-utils, share with converter module */ protected void copyDirectoryStructure(File sourceDirectory, File destDirectory) throws IOException { if (!sourceDirectory.exists()) { throw new IOException("Source directory doesn't exists (" + sourceDirectory.getAbsolutePath() + ")."); } File[] files = sourceDirectory.listFiles(); String sourcePath = sourceDirectory.getAbsolutePath(); for (int i = 0; i < files.length; i++) { File file = files[i]; String dest = file.getAbsolutePath(); dest = dest.substring(sourcePath.length() + 1); File destination = new File(destDirectory, dest); if (file.isFile()) { destination = destination.getParentFile(); org.apache.commons.io.FileUtils.copyFile(file, new File(destination, file.getName()), false); // TODO: Change when there is a FileUtils.copyFileToDirectory(file, destination, boolean) option //FileUtils.copyFileToDirectory( file, destination ); } else if (file.isDirectory()) { if (!".svn".equals(file.getName())) { if (!destination.exists() && !destination.mkdirs()) { throw new IOException( "Could not create destination directory '" + destination.getAbsolutePath() + "'."); } copyDirectoryStructure(file, destination); } } else { throw new IOException("Unknown file type: " + file.getAbsolutePath()); } } } protected ManagedRepositoryContent createRepository(String id, String name, String path, String layout) throws Exception { ManagedRepository repo = new ManagedRepository(); repo.setId(id); repo.setName(name); repo.setLocation(path); repo.setLayout(layout); ManagedRepositoryContent repoContent = applicationContext.getBean("managedRepositoryContent#" + layout, ManagedRepositoryContent.class); repoContent.setRepository(repo); return repoContent; } /** * Read the first line from the checksum file, and return it (trimmed). */ protected String readChecksumFile(File checksumFile) throws Exception { FileReader freader = null; BufferedReader buf = null; try { freader = new FileReader(checksumFile); buf = new BufferedReader(freader); return buf.readLine(); } finally { if (buf != null) { buf.close(); } if (freader != null) { freader.close(); } } } protected void saveConnector(String sourceRepoId, String targetRepoId, boolean disabled) { saveConnector(sourceRepoId, targetRepoId, ChecksumPolicy.IGNORE, ReleasesPolicy.ALWAYS, SnapshotsPolicy.ALWAYS, CachedFailuresPolicy.NO, disabled); } protected void saveConnector(String sourceRepoId, String targetRepoId, String checksumPolicy, String releasePolicy, String snapshotPolicy, String cacheFailuresPolicy, boolean disabled) { saveConnector(sourceRepoId, targetRepoId, checksumPolicy, releasePolicy, snapshotPolicy, cacheFailuresPolicy, PropagateErrorsDownloadPolicy.QUEUE, disabled); } protected void saveConnector(String sourceRepoId, String targetRepoId, String checksumPolicy, String releasePolicy, String snapshotPolicy, String cacheFailuresPolicy, String errorPolicy, boolean disabled) { saveConnector(sourceRepoId, targetRepoId, checksumPolicy, releasePolicy, snapshotPolicy, cacheFailuresPolicy, errorPolicy, PropagateErrorsOnUpdateDownloadPolicy.NOT_PRESENT, disabled); } protected void saveConnector(String sourceRepoId, String targetRepoId, String checksumPolicy, String releasePolicy, String snapshotPolicy, String cacheFailuresPolicy, String errorPolicy, String errorOnUpdatePolicy, boolean disabled) { ProxyConnectorConfiguration connectorConfig = new ProxyConnectorConfiguration(); connectorConfig.setSourceRepoId(sourceRepoId); connectorConfig.setTargetRepoId(targetRepoId); connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_CHECKSUM, checksumPolicy); connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_RELEASES, releasePolicy); connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_SNAPSHOTS, snapshotPolicy); connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_CACHE_FAILURES, cacheFailuresPolicy); connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_PROPAGATE_ERRORS, errorPolicy); connectorConfig.addPolicy(ProxyConnectorConfiguration.POLICY_PROPAGATE_ERRORS_ON_UPDATE, errorOnUpdatePolicy); connectorConfig.setDisabled(disabled); int count = config.getConfiguration().getProxyConnectors().size(); config.getConfiguration().addProxyConnector(connectorConfig); // Proper Triggering ... String prefix = "proxyConnectors.proxyConnector(" + count + ")"; config.triggerChange(prefix + ".sourceRepoId", connectorConfig.getSourceRepoId()); config.triggerChange(prefix + ".targetRepoId", connectorConfig.getTargetRepoId()); config.triggerChange(prefix + ".proxyId", connectorConfig.getProxyId()); config.triggerChange(prefix + ".policies.releases", connectorConfig.getPolicy("releases", "")); config.triggerChange(prefix + ".policies.checksum", connectorConfig.getPolicy("checksum", "")); config.triggerChange(prefix + ".policies.snapshots", connectorConfig.getPolicy("snapshots", "")); config.triggerChange(prefix + ".policies.cache-failures", connectorConfig.getPolicy("cache-failures", "")); config.triggerChange(prefix + ".policies.propagate-errors", connectorConfig.getPolicy("propagate-errors", "")); config.triggerChange(prefix + ".policies.propagate-errors-on-update", connectorConfig.getPolicy("propagate-errors-on-update", "")); } protected void saveManagedRepositoryConfig(String id, String name, String path, String layout) { ManagedRepositoryConfiguration repoConfig = new ManagedRepositoryConfiguration(); repoConfig.setId(id); repoConfig.setName(name); repoConfig.setLayout(layout); repoConfig.setLocation(path); int count = config.getConfiguration().getManagedRepositories().size(); config.getConfiguration().addManagedRepository(repoConfig); String prefix = "managedRepositories.managedRepository(" + count + ")"; config.triggerChange(prefix + ".id", repoConfig.getId()); config.triggerChange(prefix + ".name", repoConfig.getName()); config.triggerChange(prefix + ".location", repoConfig.getLocation()); config.triggerChange(prefix + ".layout", repoConfig.getLayout()); } protected void saveRemoteRepositoryConfig(String id, String name, String url, String layout) { RemoteRepositoryConfiguration repoConfig = new RemoteRepositoryConfiguration(); repoConfig.setId(id); repoConfig.setName(name); repoConfig.setLayout(layout); repoConfig.setUrl(url); int count = config.getConfiguration().getRemoteRepositories().size(); config.getConfiguration().addRemoteRepository(repoConfig); String prefix = "remoteRepositories.remoteRepository(" + count + ")"; config.triggerChange(prefix + ".id", repoConfig.getId()); config.triggerChange(prefix + ".name", repoConfig.getName()); config.triggerChange(prefix + ".url", repoConfig.getUrl()); config.triggerChange(prefix + ".layout", repoConfig.getLayout()); } protected File saveTargetedRepositoryConfig(String id, String originalPath, String targetPath, String layout) throws IOException { File repoLocation = new File(targetPath); FileUtils.deleteDirectory(repoLocation); copyDirectoryStructure(new File(originalPath), repoLocation); saveRemoteRepositoryConfig(id, "Target Repo-" + id, targetPath, layout); return repoLocation; } /** * Copy the specified resource directory from the src/test/repository/managed/ to * the testable directory under target/test-repository/managed/${testName}/ * * @param resourcePath * @throws IOException */ protected void setupTestableManagedRepository(String resourcePath) throws IOException { String resourceDir = resourcePath; if (!resourcePath.endsWith("/")) { int idx = resourcePath.lastIndexOf('/'); resourceDir = resourcePath.substring(0, idx); } File sourceRepoDir = new File(REPOPATH_DEFAULT_MANAGED); File sourceDir = new File(sourceRepoDir, resourceDir); File destRepoDir = managedDefaultDir; File destDir = new File(destRepoDir, resourceDir); // Cleanout destination dirs. if (destDir.exists()) { FileUtils.deleteDirectory(destDir); } // Make the destination dir. destDir.mkdirs(); // Test the source dir. if (!sourceDir.exists()) { // This is just a warning. log.error("[WARN] Skipping setup of testable managed repository, source dir does not exist: {}", // sourceDir); } else { // Test that the source is a dir. if (!sourceDir.isDirectory()) { fail("Unable to setup testable managed repository, source is not a directory: " + sourceDir); } // Copy directory structure. copyDirectoryStructure(sourceDir, destDir); } } protected void setManagedNewerThanRemote(File managedFile, File remoteFile) { setManagedNewerThanRemote(managedFile, remoteFile, 55000); } protected void setManagedNewerThanRemote(File managedFile, File remoteFile, long time) { assertTrue("Managed File should exist: ", managedFile.exists()); assertTrue("Remote File should exist: ", remoteFile.exists()); managedFile.setLastModified(remoteFile.lastModified() + time); assertTrue(managedFile.lastModified() > remoteFile.lastModified()); } protected void setManagedOlderThanRemote(File managedFile, File remoteFile) { setManagedOlderThanRemote(managedFile, remoteFile, 55000); } protected void setManagedOlderThanRemote(File managedFile, File remoteFile, long time) { assertTrue("Managed File should exist: ", managedFile.exists()); assertTrue("Remote File should exist: ", remoteFile.exists()); managedFile.setLastModified(remoteFile.lastModified() - time); assertTrue(managedFile.lastModified() < remoteFile.lastModified()); } protected void assertNotModified(File file, long expectedModificationTime) { assertEquals("File <" + file.getAbsolutePath() + "> not have been modified.", expectedModificationTime, file.lastModified()); } protected void assertNotExistsInManagedDefaultRepo(File file) throws Exception { String managedDefaultPath = managedDefaultDir.getCanonicalPath(); String testFile = file.getCanonicalPath(); assertTrue("Unit Test Failure: File <" + testFile + "> should be have been defined within the managed default path of <" + managedDefaultPath + ">", testFile.startsWith(managedDefaultPath)); assertFalse("File < " + testFile + "> should not exist in managed default repository.", file.exists()); } protected static Date getFutureDate() throws ParseException { Calendar cal = Calendar.getInstance(); cal.add(Calendar.YEAR, 1); return cal.getTime(); } protected static Date getPastDate() throws ParseException { return new SimpleDateFormat("yyyy-MM-dd", Locale.US).parse("2000-01-01"); } }