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 import java.nio.charset.Charset;
  43
  44 /**
  45  * AbstractRepositoryServletProxiedTestCase
  46  *
  47  *
  48  */
  49 public abstract class AbstractRepositoryServletProxiedTestCase
  50     extends AbstractRepositoryServletTestCase
  51 {
  52     class RemoteRepoInfo
  53     {
  54         public String id;
  55
  56         public String url;
  57
  58         public String context;
  59
  60         public Server server;
  61
  62         public File root;
  63
  64         public RemoteRepositoryConfiguration config;
  65     }
  66
  67     protected static final long ONE_SECOND = ( 1000 /* milliseconds */ );
  68
  69     protected static final long ONE_MINUTE = ( ONE_SECOND * 60 );
  70
  71     protected static final long ONE_HOUR = ( ONE_MINUTE * 60 );
  72
  73     protected static final long ONE_DAY = ( ONE_HOUR * 24 );
  74
  75     protected static final long OVER_ONE_HOUR = ( ONE_HOUR + ONE_MINUTE );
  76
  77     protected static final long OVER_ONE_DAY = ( ONE_DAY + ONE_HOUR );
  78
  79     protected static final long OLDER = ( -1 );
  80
  81     protected static final long NEWER = 0;
  82
  83     protected static final int EXPECT_MANAGED_CONTENTS = 1;
  84
  85     protected static final int EXPECT_REMOTE_CONTENTS = 2;
  86
  87     protected static final int EXPECT_NOT_FOUND = 3;
  88
  89     protected static final boolean HAS_MANAGED_COPY = true;
  90
  91     protected static final boolean NO_MANAGED_COPY = false;
  92
  93     protected RemoteRepoInfo remoteCentral;
  94
  95     protected RemoteRepoInfo remoteSnapshots;
  96
  97     @Before
  98     public void setUp()
  99         throws Exception
 100     {
 101         super.setUp();
 102     }
 103
 104     @Override
 105     @After
 106     public void tearDown()
 107         throws Exception
 108     {
 109         shutdownServer( remoteCentral );
 110         shutdownServer( remoteSnapshots );
 111         super.tearDown();
 112     }
 113
 114     protected RemoteRepoInfo createServer( String id )
 115         throws Exception
 116     {
 117         RemoteRepoInfo repo = new RemoteRepoInfo();
 118         repo.id = id;
 119         repo.context = "/" + id;
 120         repo.root = new File( "target/remote-repos/" + id + "/" );
 121
 122         // Remove exising root contents.
 123         if ( repo.root.exists() )
 124         {
 125             FileUtils.deleteDirectory( repo.root );
 126         }
 127
 128         // Establish root directory.
 129         if ( !repo.root.exists() )
 130         {
 131             repo.root.mkdirs();
 132         }
 133
 134         repo.server = new Server( 0 );
 135         ContextHandlerCollection contexts = new ContextHandlerCollection();
 136         repo.server.setHandler( contexts );
 137
 138         ServletContextHandler context = new ServletContextHandler();
 139         context.setContextPath( repo.context );
 140         context.setResourceBase( repo.root.getAbsolutePath() );
 141         context.setAttribute( "dirAllowed", true );
 142         context.setAttribute( "maxCacheSize", 0 );
 143
 144         ServletHolder sh = new ServletHolder( DefaultServlet.class );
 145         context.addServlet( sh, "/" );
 146
 147         contexts.addHandler( context );
 148
 149         repo.server.start();
 150
 151         int port = repo.server.getConnectors()[0].getLocalPort();
 152         repo.url = "http://localhost:" + port + repo.context;
 153         log.info( "Remote HTTP Server started on {}", repo.url );
 154
 155         repo.config = createRemoteRepository( repo.id, "Testable [" + repo.id + "] Remote Repo", repo.url );
 156
 157         return repo;
 158     }
 159
 160     protected void assertServerSetupCorrectly( RemoteRepoInfo remoteRepo )
 161         throws Exception
 162     {
 163         WebConversation wc = new WebConversation();
 164         WebResponse response = wc.getResponse( remoteRepo.url );
 165         assertResponseOK( response );
 166     }
 167
 168     private void setupConnector( String repoId, RemoteRepoInfo remoteRepo, String releasesPolicy,
 169                                  String snapshotsPolicy )
 170     {
 171         ProxyConnectorConfiguration connector = new ProxyConnectorConfiguration();
 172         connector.setSourceRepoId( repoId );
 173         connector.setTargetRepoId( remoteRepo.id );
 174         connector.addPolicy( ProxyConnectorConfiguration.POLICY_RELEASES, releasesPolicy );
 175         connector.addPolicy( ProxyConnectorConfiguration.POLICY_SNAPSHOTS, snapshotsPolicy );
 176         connector.addPolicy( ProxyConnectorConfiguration.POLICY_CHECKSUM, ChecksumPolicy.IGNORE );
 177         connector.addPolicy( ProxyConnectorConfiguration.POLICY_CACHE_FAILURES, CachedFailuresPolicy.NO );
 178
 179         archivaConfiguration.getConfiguration().addProxyConnector( connector );
 180     }
 181
 182     protected void shutdownServer( RemoteRepoInfo remoteRepo )
 183     {
 184         if ( remoteRepo != null )
 185         {
 186             if ( remoteRepo.server != null )
 187             {
 188                 if ( remoteRepo.server.isRunning() )
 189                 {
 190                     try
 191                     {
 192                         remoteRepo.server.stop();
 193                         // int graceful = remoteRepo.server.getGracefulShutdown();
 194                         // System.out.println( "server set to graceful shutdown: " + graceful );
 195                         // remoteRepo = null;
 196                     }
 197                     catch ( Exception e )
 198                     {
 199                         e.printStackTrace( System.err );
 200                     }
 201                 }
 202             }
 203         }
 204     }
 205
 206     protected File populateRepo( RemoteRepoInfo remoteRepo, String path, String contents )
 207         throws Exception
 208     {
 209         File destFile = new File( remoteRepo.root, path );
 210         if (destFile.exists())
 211         {
 212             destFile.delete();
 213         }
 214         destFile.getParentFile().mkdirs();
 215         FileUtils.writeStringToFile( destFile, contents, Charset.defaultCharset()  );
 216         return destFile;
 217     }
 218
 219     protected void setupCentralRemoteRepo()
 220         throws Exception
 221     {
 222         remoteCentral = createServer( "central" );
 223
 224         assertServerSetupCorrectly( remoteCentral );
 225
 226         RemoteRepositoryConfiguration remoteRepositoryConfiguration =
 227             archivaConfiguration.getConfiguration().getRemoteRepositoriesAsMap().get( remoteCentral.id );
 228         if ( remoteRepositoryConfiguration != null )
 229         {
 230             archivaConfiguration.getConfiguration().removeRemoteRepository( remoteRepositoryConfiguration );
 231         }
 232
 233         archivaConfiguration.getConfiguration().addRemoteRepository( remoteCentral.config );
 234         setupCleanRepo( remoteCentral.root );
 235     }
 236
 237     protected void setupConnector( String repoId, RemoteRepoInfo remoteRepo )
 238     {
 239         setupConnector( repoId, remoteRepo, ReleasesPolicy.ALWAYS, SnapshotsPolicy.ALWAYS );
 240     }
 241
 242     protected void setupReleaseConnector( String managedRepoId, RemoteRepoInfo remoteRepo, String releasePolicy )
 243     {
 244         setupConnector( managedRepoId, remoteRepo, releasePolicy, SnapshotsPolicy.ALWAYS );
 245     }
 246
 247     protected void setupSnapshotConnector( String managedRepoId, RemoteRepoInfo remoteRepo, String snapshotsPolicy )
 248     {
 249         setupConnector( managedRepoId, remoteRepo, ReleasesPolicy.ALWAYS, snapshotsPolicy );
 250     }
 251
 252     protected void setupSnapshotsRemoteRepo()
 253         throws Exception
 254     {
 255         remoteSnapshots = createServer( "snapshots" );
 256
 257         assertServerSetupCorrectly( remoteSnapshots );
 258         RemoteRepositoryConfiguration remoteRepositoryConfiguration =
 259             archivaConfiguration.getConfiguration().getRemoteRepositoriesAsMap().get( remoteSnapshots.id );
 260         if ( remoteRepositoryConfiguration != null )
 261         {
 262             archivaConfiguration.getConfiguration().removeRemoteRepository( remoteRepositoryConfiguration );
 263         }
 264         archivaConfiguration.getConfiguration().addRemoteRepository( remoteSnapshots.config );
 265         setupCleanRepo( remoteSnapshots.root );
 266     }
 267
 268
 269 }