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