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

   1 package org.apache.archiva.proxy;
   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 org.apache.commons.io.FileUtils;
  23 import org.apache.maven.wagon.ConnectionException;
  24 import org.apache.maven.wagon.ResourceDoesNotExistException;
  25 import org.apache.maven.wagon.TransferFailedException;
  26 import org.apache.maven.wagon.Wagon;
  27 import org.apache.maven.wagon.authentication.AuthenticationException;
  28 import org.apache.maven.wagon.authentication.AuthenticationInfo;
  29 import org.apache.maven.wagon.authorization.AuthorizationException;
  30 import org.apache.maven.wagon.events.SessionListener;
  31 import org.apache.maven.wagon.events.TransferListener;
  32 import org.apache.maven.wagon.proxy.ProxyInfo;
  33 import org.apache.maven.wagon.proxy.ProxyInfoProvider;
  34 import org.apache.maven.wagon.repository.Repository;
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37 import org.springframework.stereotype.Service;
  38
  39 import java.io.File;
  40 import java.io.IOException;
  41 import java.nio.charset.Charset;
  42 import java.util.List;
  43
  44 /**
  45  * A dummy wagon implementation
  46  */
  47 @Service ("wagon#test")
  48 public class WagonDelegate
  49     implements Wagon
  50 {
  51     private Logger log = LoggerFactory.getLogger( WagonDelegate.class );
  52
  53     private Wagon delegate;
  54
  55     private String contentToGet;
  56
  57     public void get( String resourceName, File destination )
  58         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
  59     {
  60         log.debug( ".get({}, {})", resourceName, destination );
  61         delegate.get( resourceName, destination );
  62         create( destination );
  63     }
  64
  65     public boolean getIfNewer( String resourceName, File destination, long timestamp )
  66         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
  67     {
  68         log.info( ".getIfNewer({}, {}, {})", resourceName, destination, timestamp );
  69
  70         boolean result = delegate.getIfNewer( resourceName, destination, timestamp );
  71         createIfMissing( destination );
  72         return result;
  73     }
  74
  75     public void put( File source, String destination )
  76         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
  77     {
  78         delegate.put( source, destination );
  79     }
  80
  81     public void putDirectory( File sourceDirectory, String destinationDirectory )
  82         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
  83     {
  84         delegate.putDirectory( sourceDirectory, destinationDirectory );
  85     }
  86
  87     public boolean resourceExists( String resourceName )
  88         throws TransferFailedException, AuthorizationException
  89     {
  90         return delegate.resourceExists( resourceName );
  91     }
  92
  93     @SuppressWarnings ("unchecked")
  94     public List<String> getFileList( String destinationDirectory )
  95         throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException
  96     {
  97         return delegate.getFileList( destinationDirectory );
  98     }
  99
 100     public boolean supportsDirectoryCopy()
 101     {
 102         return delegate.supportsDirectoryCopy();
 103     }
 104
 105     public void setTimeout( int val )
 106     {
 107         // ignore
 108     }
 109
 110     public int getTimeout()
 111     {
 112         return 0;
 113     }
 114
 115     public void setReadTimeout( int timeoutValue )
 116     {
 117         // ignore
 118     }
 119
 120     public int getReadTimeout()
 121     {
 122         return 0;
 123     }
 124
 125     public Repository getRepository()
 126     {
 127         return delegate.getRepository();
 128     }
 129
 130     public void connect( Repository source )
 131         throws ConnectionException, AuthenticationException
 132     {
 133         delegate.connect( source );
 134     }
 135
 136     public void connect( Repository source, ProxyInfo proxyInfo )
 137         throws ConnectionException, AuthenticationException
 138     {
 139         delegate.connect( source, proxyInfo );
 140     }
 141
 142     public void connect( Repository source, ProxyInfoProvider proxyInfoProvider )
 143         throws ConnectionException, AuthenticationException
 144     {
 145         delegate.connect( source, proxyInfoProvider );
 146     }
 147
 148     public void connect( Repository source, AuthenticationInfo authenticationInfo )
 149         throws ConnectionException, AuthenticationException
 150     {
 151         delegate.connect( source, authenticationInfo );
 152     }
 153
 154     public void connect( Repository source, AuthenticationInfo authenticationInfo, ProxyInfo proxyInfo )
 155         throws ConnectionException, AuthenticationException
 156     {
 157         delegate.connect( source, authenticationInfo, proxyInfo );
 158     }
 159
 160     public void connect( Repository source, AuthenticationInfo authenticationInfo, ProxyInfoProvider proxyInfoProvider )
 161         throws ConnectionException, AuthenticationException
 162     {
 163         delegate.connect( source, authenticationInfo, proxyInfoProvider );
 164     }
 165
 166     @SuppressWarnings ("deprecation")
 167     public void openConnection()
 168         throws ConnectionException, AuthenticationException
 169     {
 170         delegate.openConnection();
 171     }
 172
 173     public void disconnect()
 174         throws ConnectionException
 175     {
 176         delegate.disconnect();
 177     }
 178
 179     public void addSessionListener( SessionListener listener )
 180     {
 181         delegate.addSessionListener( listener );
 182     }
 183
 184     public void removeSessionListener( SessionListener listener )
 185     {
 186         delegate.removeSessionListener( listener );
 187     }
 188
 189     public boolean hasSessionListener( SessionListener listener )
 190     {
 191         return delegate.hasSessionListener( listener );
 192     }
 193
 194     public void addTransferListener( TransferListener listener )
 195     {
 196         delegate.addTransferListener( listener );
 197     }
 198
 199     public void removeTransferListener( TransferListener listener )
 200     {
 201         delegate.removeTransferListener( listener );
 202     }
 203
 204     public boolean hasTransferListener( TransferListener listener )
 205     {
 206         return delegate.hasTransferListener( listener );
 207     }
 208
 209     public boolean isInteractive()
 210     {
 211         return delegate.isInteractive();
 212     }
 213
 214     public void setInteractive( boolean interactive )
 215     {
 216         delegate.setInteractive( interactive );
 217     }
 218
 219     public void setDelegate( Wagon delegate )
 220     {
 221         this.delegate = delegate;
 222     }
 223
 224     void setContentToGet( String content )
 225     {
 226         contentToGet = content;
 227     }
 228
 229     private void createIfMissing( File destination )
 230     {
 231         // since the mock won't actually copy a file, create an empty one to simulate file existence
 232         if ( !destination.exists() )
 233         {
 234             create( destination );
 235         }
 236     }
 237
 238     private void create( File destination )
 239     {
 240         try
 241         {
 242             destination.getParentFile().mkdirs();
 243             if ( contentToGet == null )
 244             {
 245                 destination.createNewFile();
 246             }
 247             else
 248             {
 249                 FileUtils.writeStringToFile( new File( destination.getAbsolutePath() ), contentToGet,
 250                                              Charset.defaultCharset() );
 251             }
 252         }
 253         catch ( IOException e )
 254         {
 255             throw new RuntimeException( e.getMessage(), e );
 256         }
 257     }
 258 }