/*
* 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.
*/
package org.apache.felix.obr.plugin;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import org.apache.maven.artifact.manager.WagonConfigurationException;
import org.apache.maven.artifact.manager.WagonManager;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.logging.Log;
import org.apache.maven.settings.Proxy;
import org.apache.maven.settings.Settings;
import org.apache.maven.wagon.ConnectionException;
import org.apache.maven.wagon.ResourceDoesNotExistException;
import org.apache.maven.wagon.TransferFailedException;
import org.apache.maven.wagon.UnsupportedProtocolException;
import org.apache.maven.wagon.Wagon;
import org.apache.maven.wagon.authentication.AuthenticationException;
import org.apache.maven.wagon.authorization.AuthorizationException;
import org.apache.maven.wagon.proxy.ProxyInfo;
import org.apache.maven.wagon.repository.Repository;
/**
* this class is used to manage all connections by wagon.
* @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
*/
public class RemoteFileManager
{
/**
* save the connection.
*/
private Wagon m_wagon;
/**
* the wagon manager.
*/
private WagonManager m_wagonManager;
/**
* the project settings.
*/
private Settings m_settings;
/**
* logger instance.
*/
private Log m_log;
/**
* initialize main information.
* @param wm WagonManager provides by maven
* @param settings settings of the current project provides by maven
* @param log logger
*/
public RemoteFileManager( WagonManager wm, Settings settings, Log log )
{
m_wagonManager = wm;
m_settings = settings;
m_log = log;
m_wagon = null;
}
/**
* disconnect the current object.
*/
public void disconnect()
{
try
{
if ( m_wagon != null )
{
m_wagon.disconnect();
}
}
catch ( ConnectionException e )
{
m_log.error( "Error disconnecting Wagon", e );
}
}
/**
* connect the current object to repository given in constructor.
* @param id repository id
* @param url repository url
* @throws MojoExecutionException
*/
public void connect( String id, String url ) throws MojoExecutionException
{
Repository repository = new Repository( id, url );
try
{
m_wagon = m_wagonManager.getWagon( repository );
}
catch ( UnsupportedProtocolException e )
{
throw new MojoExecutionException( "Unsupported protocol: '" + repository.getProtocol() + "'", e );
}
catch ( WagonConfigurationException e )
{
throw new MojoExecutionException( "Unable to configure Wagon: '" + repository.getProtocol() + "'", e );
}
try
{
ProxyInfo proxyInfo = getProxyInfo( m_settings );
if ( proxyInfo != null )
{
m_wagon.connect( repository, m_wagonManager.getAuthenticationInfo( id ), proxyInfo );
}
else
{
m_wagon.connect( repository, m_wagonManager.getAuthenticationInfo( id ) );
}
}
catch ( ConnectionException e )
{
throw new MojoExecutionException( "Connection failed", e );
}
catch ( AuthenticationException e )
{
throw new MojoExecutionException( "Authentication failed", e );
}
}
/**
* get a file from the current repository connected.
* @param url url to the targeted file
* @param suffix suggested file suffix
* @return get a file descriptor on the required resource
* @throws MojoExecutionException
*/
public File get( String url, String suffix ) throws MojoExecutionException
{
if ( m_wagon == null )
{
m_log.error( "must be connected first!" );
return null;
}
File file = null;
try
{
file = File.createTempFile( String.valueOf( System.currentTimeMillis() ), suffix );
}
catch ( IOException e )
{
throw new MojoExecutionException( "I/O problem", e );
}
try
{
m_wagon.get( url, file );
}
catch ( TransferFailedException e )
{
file.delete(); // cleanup on failure
throw new MojoExecutionException( "Transfer failed", e );
}
catch ( AuthorizationException e )
{
file.delete(); // cleanup on failure
throw new MojoExecutionException( "Authorization failed", e );
}
catch ( ResourceDoesNotExistException e )
{
file.delete(); // return non-existent file
}
return file;
}
/**
* put a file on the current repository connected.
* @param file file to upload
* @param url url to copy file
* @throws MojoExecutionException
*/
public void put( File file, String url ) throws MojoExecutionException
{
if ( m_wagon == null )
{
m_log.error( "must be connected first!" );
return;
}
try
{
m_wagon.put( file, url );
}
catch ( TransferFailedException e )
{
throw new MojoExecutionException( "Transfer failed", e );
}
catch ( AuthorizationException e )
{
throw new MojoExecutionException( "Authorization failed", e );
}
catch ( ResourceDoesNotExistException e )
{
throw new MojoExecutionException( "Resource does not exist:" + file, e );
}
}
/**
* Convenience method to map a Proxy object from the user system settings to a ProxyInfo object.
* @param settings project settings given by maven
* @return a proxyInfo object instancied or null if no active proxy is define in the settings.xml
*/
public static ProxyInfo getProxyInfo( Settings settings )
{
ProxyInfo proxyInfo = null;
if ( settings != null && settings.getActiveProxy() != null )
{
Proxy settingsProxy = settings.getActiveProxy();
proxyInfo = new ProxyInfo();
proxyInfo.setHost( settingsProxy.getHost() );
proxyInfo.setType( settingsProxy.getProtocol() );
proxyInfo.setPort( settingsProxy.getPort() );
proxyInfo.setNonProxyHosts( settingsProxy.getNonProxyHosts() );
proxyInfo.setUserName( settingsProxy.getUsername() );
proxyInfo.setPassword( settingsProxy.getPassword() );
}
return proxyInfo;
}
public void lockFile( String fileName, boolean ignoreLock ) throws MojoExecutionException
{
if ( !ignoreLock )
{
int countError = 0;
while ( isLockedFile( fileName ) && countError < 2 )
{
countError++;
m_log.warn( "File is currently locked, retry in 10s" );
try
{
Thread.sleep( 10000 );
}
catch ( InterruptedException e )
{
m_log.warn( "Sleep interrupted" );
}
}
if ( countError == 2 )
{
m_log.error( "File " + fileName + " is locked. Use -DignoreLock to force uploading" );
throw new MojoExecutionException( "Remote file locked" );
}
}
File file = null;
try
{
// create a non-empty file used to lock the remote file
file = File.createTempFile( String.valueOf( System.currentTimeMillis() ), ".lock" );
Writer writer = new BufferedWriter( new FileWriter( file ) );
writer.write( "LOCKED" );
writer.close();
put( file, fileName + ".lock" );
}
catch ( IOException e )
{
throw new MojoExecutionException( "I/O problem", e );
}
finally
{
if ( null != file )
{
file.delete();
}
}
}
public void unlockFile( String fileName ) throws MojoExecutionException
{
File file = null;
try
{
// clear the contents of the file used to lock the remote file
file = File.createTempFile( String.valueOf( System.currentTimeMillis() ), ".lock" );
Writer writer = new BufferedWriter( new FileWriter( file ) );
writer.write( " " ); // write 1 byte to force wagon upload
writer.close();
put( file, fileName + ".lock" );
}
catch ( IOException e )
{
throw new MojoExecutionException( "I/O problem", e );
}
finally
{
if ( null != file )
{
file.delete();
}
}
}
/**
* this method indicates if the targeted file is locked or not.
* @param remote connection manager
* @param fileName name targeted
* @return true if the required file is locked, else false
* @throws MojoExecutionException
*/
public boolean isLockedFile( String fileName ) throws MojoExecutionException
{
File file = null;
try
{
file = get( fileName + ".lock", ".lock" );
// file is locked with contents "LOCKED"
if ( null != file && file.length() <= 2 )
{
return false;
}
}
finally
{
if ( null != file )
{
file.delete();
}
}
return true;
}
public String toString()
{
return m_wagon.getRepository().getUrl();
}
}