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

   1 package org.apache.archiva.webdav;
   2
   3 /*
   4  * Licensed to the Apache Software Foundation (ASF) under one
   5  * or more contributor license agreements.  See the NOTICE file
   6  * distributed with this work for additional information
   7  * regarding copyright ownership.  The ASF licenses this file
   8  * to you under the Apache License, Version 2.0 (the
   9  * "License"); you may not use this file except in compliance
  10  * with the License.  You may obtain a copy of the License at
  11  *
  12  *  http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  17  * KIND, either express or implied.  See the License for the
  18  * specific language governing permissions and limitations
  19  * under the License.
  20  */
  21
  22 import com.meterware.httpunit.WebConversation;
  23 import com.meterware.httpunit.WebResponse;
  24 import org.apache.archiva.configuration.ProxyConnectorConfiguration;
  25 import org.apache.archiva.configuration.RemoteRepositoryConfiguration;
  26 import org.apache.archiva.policies.CachedFailuresPolicy;
  27 import org.apache.archiva.policies.ChecksumPolicy;
  28 import org.apache.archiva.policies.ReleasesPolicy;
  29 import org.apache.archiva.policies.SnapshotsPolicy;
  30 import org.apache.commons.io.FileUtils;
  31 import org.eclipse.jetty.server.Server;
  32 import org.eclipse.jetty.server.handler.ContextHandler;
  33 import org.eclipse.jetty.server.handler.ContextHandlerCollection;
  34 import org.eclipse.jetty.servlet.DefaultServlet;
  35 import org.eclipse.jetty.servlet.ServletContextHandler;
  36 import org.eclipse.jetty.servlet.ServletHandler;
  37 import org.eclipse.jetty.servlet.ServletHolder;
  38 import org.junit.After;
  39 import org.junit.Before;
  40
  41 import java.io.File;
  42
  43 /**
  44  * AbstractRepositoryServletProxiedTestCase
  45  *
  46  * @version $Id$
  47  */
  48 public abstract class AbstractRepositoryServletProxiedTestCase
  49     extends AbstractRepositoryServletTestCase
  50 {
  51     class RemoteRepoInfo
  52     {
  53         public String id;
  54
  55         public String url;
  56
  57         public String context;
  58
  59         public Server server;
  60
  61         public File root;
  62
  63         public RemoteRepositoryConfiguration config;
  64     }
  65
  66     protected static final long ONE_SECOND = ( 1000 /* milliseconds */ );
  67
  68     protected static final long ONE_MINUTE = ( ONE_SECOND * 60 );
  69
  70     protected static final long ONE_HOUR = ( ONE_MINUTE * 60 );
  71
  72     protected static final long ONE_DAY = ( ONE_HOUR * 24 );
  73
  74     protected static final long OVER_ONE_HOUR = ( ONE_HOUR + ONE_MINUTE );
  75
  76     protected static final long OVER_ONE_DAY = ( ONE_DAY + ONE_HOUR );
  77
  78     protected static final long OLDER = ( -1 );
  79
  80     protected static final long NEWER = 0;
  81
  82     protected static final int EXPECT_MANAGED_CONTENTS = 1;
  83
  84     protected static final int EXPECT_REMOTE_CONTENTS = 2;
  85
  86     protected static final int EXPECT_NOT_FOUND = 3;
  87
  88     protected static final boolean HAS_MANAGED_COPY = true;
  89
  90     protected static final boolean NO_MANAGED_COPY = false;
  91
  92     protected RemoteRepoInfo remoteCentral;
  93
  94     protected RemoteRepoInfo remoteSnapshots;
  95
  96     @Before
  97     public void setUp()
  98         throws Exception
  99     {
 100         super.setUp();
 101     }
 102
 103     protected RemoteRepoInfo createServer( String id )
 104         throws Exception
 105     {
 106         RemoteRepoInfo repo = new RemoteRepoInfo();
 107         repo.id = id;
 108         repo.context = "/" + id;
 109         repo.root = new File( "target/remote-repos/" + id + "/" );
 110
 111         // Remove exising root contents.
 112         if ( repo.root.exists() )
 113         {
 114             FileUtils.deleteDirectory( repo.root );
 115         }
 116
 117         // Establish root directory.
 118         if ( !repo.root.exists() )
 119         {
 120             repo.root.mkdirs();
 121         }
 122
 123         repo.server = new Server( 0 );
 124         ContextHandlerCollection contexts = new ContextHandlerCollection();
 125         repo.server.setHandler( contexts );
 126
 127         ServletContextHandler context = new ServletContextHandler();
 128         context.setContextPath( repo.context );
 129         context.setResourceBase( repo.root.getAbsolutePath() );
 130         context.setAttribute( "dirAllowed", true );
 131         context.setAttribute( "maxCacheSize", 0 );
 132
 133         ServletHolder sh = new ServletHolder( DefaultServlet.class );
 134         context.addServlet( sh, "/" );
 135
 136         contexts.addHandler( context );
 137
 138         repo.server.start();
 139
 140         int port = repo.server.getConnectors()[0].getLocalPort();
 141         repo.url = "http://localhost:" + port + repo.context;
 142         log.info( "Remote HTTP Server started on " + repo.url );
 143
 144         repo.config = createRemoteRepository( repo.id, "Testable [" + repo.id + "] Remote Repo", repo.url );
 145
 146         return repo;
 147     }
 148
 149     protected void assertServerSetupCorrectly( RemoteRepoInfo remoteRepo )
 150         throws Exception
 151     {
 152         WebConversation wc = new WebConversation();
 153         WebResponse response = wc.getResponse( remoteRepo.url );
 154         assertResponseOK( response );
 155     }
 156
 157     private void setupConnector( String repoId, RemoteRepoInfo remoteRepo, String releasesPolicy,
 158                                  String snapshotsPolicy )
 159     {
 160         ProxyConnectorConfiguration connector = new ProxyConnectorConfiguration();
 161         connector.setSourceRepoId( repoId );
 162         connector.setTargetRepoId( remoteRepo.id );
 163         connector.addPolicy( ProxyConnectorConfiguration.POLICY_RELEASES, releasesPolicy );
 164         connector.addPolicy( ProxyConnectorConfiguration.POLICY_SNAPSHOTS, snapshotsPolicy );
 165         connector.addPolicy( ProxyConnectorConfiguration.POLICY_CHECKSUM, ChecksumPolicy.IGNORE );
 166         connector.addPolicy( ProxyConnectorConfiguration.POLICY_CACHE_FAILURES, CachedFailuresPolicy.NO );
 167
 168         archivaConfiguration.getConfiguration().addProxyConnector( connector );
 169     }
 170
 171     protected void shutdownServer( RemoteRepoInfo remoteRepo )
 172     {
 173         if ( remoteRepo != null )
 174         {
 175             if ( remoteRepo.server != null )
 176             {
 177                 if ( remoteRepo.server.isRunning() )
 178                 {
 179                     try
 180                     {
 181                         remoteRepo.server.stop();
 182                         // int graceful = remoteRepo.server.getGracefulShutdown();
 183                         // System.out.println( "server set to graceful shutdown: " + graceful );
 184                         // remoteRepo = null;
 185                     }
 186                     catch ( Exception e )
 187                     {
 188                         e.printStackTrace( System.err );
 189                     }
 190                 }
 191             }
 192         }
 193     }
 194
 195     protected File populateRepo( RemoteRepoInfo remoteRepo, String path, String contents )
 196         throws Exception
 197     {
 198         File destFile = new File( remoteRepo.root, path );
 199         if (destFile.exists())
 200         {
 201             destFile.delete();
 202         }
 203         destFile.getParentFile().mkdirs();
 204         FileUtils.writeStringToFile( destFile, contents, null );
 205         return destFile;
 206     }
 207
 208     protected void setupCentralRemoteRepo()
 209         throws Exception
 210     {
 211         remoteCentral = createServer( "central" );
 212
 213         assertServerSetupCorrectly( remoteCentral );
 214
 215         RemoteRepositoryConfiguration remoteRepositoryConfiguration =
 216             archivaConfiguration.getConfiguration().getRemoteRepositoriesAsMap().get( remoteCentral.id );
 217         if ( remoteRepositoryConfiguration != null )
 218         {
 219             archivaConfiguration.getConfiguration().removeRemoteRepository( remoteRepositoryConfiguration );
 220         }
 221
 222         archivaConfiguration.getConfiguration().addRemoteRepository( remoteCentral.config );
 223         setupCleanRepo( remoteCentral.root );
 224     }
 225
 226     protected void setupConnector( String repoId, RemoteRepoInfo remoteRepo )
 227     {
 228         setupConnector( repoId, remoteRepo, ReleasesPolicy.ALWAYS, SnapshotsPolicy.ALWAYS );
 229     }
 230
 231     protected void setupReleaseConnector( String managedRepoId, RemoteRepoInfo remoteRepo, String releasePolicy )
 232     {
 233         setupConnector( managedRepoId, remoteRepo, releasePolicy, SnapshotsPolicy.ALWAYS );
 234     }
 235
 236     protected void setupSnapshotConnector( String managedRepoId, RemoteRepoInfo remoteRepo, String snapshotsPolicy )
 237     {
 238         setupConnector( managedRepoId, remoteRepo, ReleasesPolicy.ALWAYS, snapshotsPolicy );
 239     }
 240
 241     protected void setupSnapshotsRemoteRepo()
 242         throws Exception
 243     {
 244         remoteSnapshots = createServer( "snapshots" );
 245
 246         assertServerSetupCorrectly( remoteSnapshots );
 247         RemoteRepositoryConfiguration remoteRepositoryConfiguration =
 248             archivaConfiguration.getConfiguration().getRemoteRepositoriesAsMap().get( remoteSnapshots.id );
 249         if ( remoteRepositoryConfiguration != null )
 250         {
 251             archivaConfiguration.getConfiguration().removeRemoteRepository( remoteRepositoryConfiguration );
 252         }
 253         archivaConfiguration.getConfiguration().addRemoteRepository( remoteSnapshots.config );
 254         setupCleanRepo( remoteSnapshots.root );
 255     }
 256
 257     @Override
 258     @After
 259     public void tearDown()
 260         throws Exception
 261     {
 262         shutdownServer( remoteCentral );
 263         shutdownServer( remoteSnapshots );
 264         super.tearDown();
 265     }
 266 }