org.apache.maven.wagon.events.TransferEvent Java Examples

@Override
public void get(String resourceName, File destination)
		throws TransferFailedException, ResourceDoesNotExistException,
		AuthorizationException {
	Resource resource = new Resource(resourceName);
	fireGetInitiated(resource, destination);
	fireGetStarted(resource, destination);

	try {
		File remote = new File(checkoutDirectory, resourceName);
		if (remote.exists()){
			transfer(resource, new FileInputStream(remote), new FileOutputStream(destination), TransferEvent.REQUEST_GET);
		}
	} catch (Exception e) {
		fireTransferError(resource, e, TransferEvent.REQUEST_GET);
		throw new TransferFailedException("Unable to get file", e);
	}

	fireGetCompleted(resource, destination);
}
 

@Test
public void putTransferFailedException() throws TransferFailedException, ResourceDoesNotExistException,
        AuthorizationException {
    TransferFailedException exception = new TransferFailedException("");
    doThrow(exception).when(this.wagon).putResource(eq(new File("foo")), eq("bar"), any(TransferProgress.class));

    try {
        this.wagon.put(new File("foo"), "bar");
        fail();
    } catch (TransferFailedException e) {
        verify(this.transferListenerSupport).fireTransferInitiated(new Resource("bar"), TransferEvent.REQUEST_PUT);
        verify(this.transferListenerSupport).fireTransferStarted(new Resource("bar"), TransferEvent.REQUEST_PUT);
        verify(this.transferListenerSupport).fireTransferError(new Resource("bar"), TransferEvent.REQUEST_PUT,
                exception);
    }
}
 

@Test
public void putResourceDoesNotExistException() throws TransferFailedException, ResourceDoesNotExistException,
        AuthorizationException {
    ResourceDoesNotExistException exception = new ResourceDoesNotExistException("");
    doThrow(exception).when(this.wagon).putResource(eq(new File("foo")), eq("bar"), any(TransferProgress.class));

    try {
        this.wagon.put(new File("foo"), "bar");
        fail();
    } catch (ResourceDoesNotExistException e) {
        verify(this.transferListenerSupport).fireTransferInitiated(new Resource("bar"), TransferEvent.REQUEST_PUT);
        verify(this.transferListenerSupport).fireTransferStarted(new Resource("bar"), TransferEvent.REQUEST_PUT);
        verify(this.transferListenerSupport).fireTransferError(new Resource("bar"), TransferEvent.REQUEST_PUT,
                exception);
    }
}
 

@Test
public void putAuthorizationException() throws TransferFailedException, ResourceDoesNotExistException,
        AuthorizationException {
    AuthorizationException exception = new AuthorizationException("");
    doThrow(exception).when(this.wagon).putResource(eq(new File("foo")), eq("bar"), any(TransferProgress.class));

    try {
        this.wagon.put(new File("foo"), "bar");
        fail();
    } catch (AuthorizationException e) {
        verify(this.transferListenerSupport).fireTransferInitiated(new Resource("bar"), TransferEvent.REQUEST_PUT);
        verify(this.transferListenerSupport).fireTransferStarted(new Resource("bar"), TransferEvent.REQUEST_PUT);
        verify(this.transferListenerSupport).fireTransferError(new Resource("bar"), TransferEvent.REQUEST_PUT,
                exception);
    }
}
 

@Test
public void getAuthorizationException() throws TransferFailedException, ResourceDoesNotExistException,
        AuthorizationException {
    AuthorizationException exception = new AuthorizationException("");
    doThrow(exception).when(this.wagon).getResource(eq("foo"), eq(new File("bar")), any(TransferProgress.class));

    try {
        this.wagon.get("foo", new File("bar"));
        fail();
    } catch (AuthorizationException e) {
        verify(this.transferListenerSupport).fireTransferInitiated(new Resource("foo"), TransferEvent.REQUEST_GET);
        verify(this.transferListenerSupport).fireTransferStarted(new Resource("foo"), TransferEvent.REQUEST_GET);
        verify(this.transferListenerSupport).fireTransferError(new Resource("foo"), TransferEvent.REQUEST_GET,
                exception);
    }
}
 

@Test
public void getResourceDoesNotExistException() throws TransferFailedException, ResourceDoesNotExistException,
        AuthorizationException {
    ResourceDoesNotExistException exception = new ResourceDoesNotExistException("");
    doThrow(exception).when(this.wagon).getResource(eq("foo"), eq(new File("bar")), any(TransferProgress.class));

    try {
        this.wagon.get("foo", new File("bar"));
        fail();
    } catch (ResourceDoesNotExistException e) {
        verify(this.transferListenerSupport).fireTransferInitiated(new Resource("foo"), TransferEvent.REQUEST_GET);
        verify(this.transferListenerSupport).fireTransferStarted(new Resource("foo"), TransferEvent.REQUEST_GET);
        verify(this.transferListenerSupport).fireTransferError(new Resource("foo"), TransferEvent.REQUEST_GET,
                exception);
    }
}
 

@Test
public void getTransferFailedException() throws ResourceDoesNotExistException, AuthorizationException,
        TransferFailedException {
    TransferFailedException exception = new TransferFailedException("");
    doThrow(exception).when(this.wagon).getResource(eq("foo"), eq(new File("bar")), any(TransferProgress.class));

    try {
        this.wagon.get("foo", new File("bar"));
        fail();
    } catch (TransferFailedException e) {
        verify(this.transferListenerSupport).fireTransferInitiated(new Resource("foo"), TransferEvent.REQUEST_GET);
        verify(this.transferListenerSupport).fireTransferStarted(new Resource("foo"), TransferEvent.REQUEST_GET);
        verify(this.transferListenerSupport).fireTransferError(new Resource("foo"), TransferEvent.REQUEST_GET,
                exception);
    }
}
 

@Override
public final void get(String resourceName, File destination) throws TransferFailedException,
        ResourceDoesNotExistException, AuthorizationException {
    Resource resource = new Resource(resourceName);
    this.transferListenerSupport.fireTransferInitiated(resource, TransferEvent.REQUEST_GET);
    this.transferListenerSupport.fireTransferStarted(resource, TransferEvent.REQUEST_GET);

    try {
        getResource(resourceName, destination, new StandardTransferProgress(resource, TransferEvent.REQUEST_GET,
                this.transferListenerSupport));
        this.transferListenerSupport.fireTransferCompleted(resource, TransferEvent.REQUEST_GET);
    } catch (TransferFailedException | ResourceDoesNotExistException | AuthorizationException e) {
        this.transferListenerSupport.fireTransferError(resource, TransferEvent.REQUEST_GET, e);
        throw e;
    }
}
 

@Test
public void putDirectory() throws IOException, TransferFailedException, ResourceDoesNotExistException,
        AuthorizationException {
    File directory = new File("target/test");
    directory.mkdirs();
    File file = new File(directory, "test.txt");
    file.createNewFile();

    this.wagon.putDirectory(directory, "foo");

    verify(this.transferListenerSupport).fireTransferInitiated(new Resource("foo/test.txt"),
            TransferEvent.REQUEST_PUT);
    verify(this.transferListenerSupport).fireTransferStarted(new Resource("foo/test.txt"),
            TransferEvent.REQUEST_PUT);
    verify(this.wagon).putResource(eq(new File("target/test/test.txt")), eq("foo/test.txt"),
            any(TransferProgress.class));
    verify(this.transferListenerSupport).fireTransferCompleted(new Resource("foo/test.txt"),
            TransferEvent.REQUEST_PUT);
}
 

@Override
public final boolean getIfNewer(String resourceName, File destination, long timestamp)
        throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException {
    Resource resource = new Resource(resourceName);
    try {
        if (isRemoteResourceNewer(resourceName, timestamp)) {
            get(resourceName, destination);
            return true;
        }

        return false;
    } catch (TransferFailedException | ResourceDoesNotExistException | AuthorizationException e) {
        this.transferListenerSupport.fireTransferError(resource, TransferEvent.REQUEST_GET, e);
        throw e;
    }
}
 

@Override
public final void put(File source, String destination) throws TransferFailedException,
        ResourceDoesNotExistException, AuthorizationException {
    Resource resource = new Resource(destination);
    this.transferListenerSupport.fireTransferInitiated(resource, TransferEvent.REQUEST_PUT);
    this.transferListenerSupport.fireTransferStarted(resource, TransferEvent.REQUEST_PUT);

    try {
        putResource(source, destination, new StandardTransferProgress(resource, TransferEvent.REQUEST_PUT,
                this.transferListenerSupport));
        this.transferListenerSupport.fireTransferCompleted(resource, TransferEvent.REQUEST_PUT);
    } catch (TransferFailedException | ResourceDoesNotExistException | AuthorizationException e) {
        this.transferListenerSupport.fireTransferError(resource, TransferEvent.REQUEST_PUT, e);
        throw e;
    }
}
 

@Override
public void transferStarted( TransferEvent transferEvent )
{
    this.totalLength = 0;
    resourceName = transferEvent.getResource( ).getName( );
    log.info( "start transfer of {}", transferEvent.getResource( ).getName( ) );
}
 

@Test
public void resourceExistsTransferFailedException() throws TransferFailedException, AuthorizationException {
    TransferFailedException exception = new TransferFailedException("");
    when(this.wagon.doesRemoteResourceExist("foo")).thenThrow(exception);

    try {
        this.wagon.resourceExists("foo");
        fail();
    } catch (TransferFailedException e) {
        verify(this.transferListenerSupport).fireTransferError(new Resource("foo"), TransferEvent.REQUEST_GET,
                exception);
    }
}
 

@Override
public void transferInitiated( TransferEvent transferEvent )
{
    startTime = System.currentTimeMillis( );
    resourceName = transferEvent.getResource( ).getName( );
    log.debug( "initiate transfer of {}", resourceName );
}
 

@Override
public void transferCompleted( TransferEvent transferEvent )
{
    resourceName = transferEvent.getResource().getName();
    long endTime = System.currentTimeMillis();
    log.info( "end of transfer file {}: {}b, {}ms", transferEvent.getResource().getName(),
              this.totalLength, ( endTime - startTime ) );
}
 

@Override
public void transferStarted( TransferEvent transferEvent )
{
    this.totalLength = 0;
    resourceName = transferEvent.getResource().getName();
    log.info("Transferring: {}, {}",  transferEvent.getResource().getContentLength(), transferEvent.getLocalFile().toString());
    log.info( "start transfer of {}", transferEvent.getResource().getName() );
}
 

@Override
public void transferInitiated( TransferEvent transferEvent )
{
    startTime = System.currentTimeMillis( );
    resourceName = transferEvent.getResource( ).getName( );
    log.debug( "initiate transfer of {}", resourceName );
}
 

@Override
public void transferInitiated( TransferEvent transferEvent )
{
    startTime = System.currentTimeMillis( );
    resourceName = transferEvent.getResource( ).getName( );
    log.debug( "initiate transfer of {}", resourceName );
}
 

public @Override void transferStarted(TransferEvent e) {
    checkCancel();
    long contentLength = e.getResource().getContentLength();
    LOG.log(Level.FINE, "contentLength: {0}", contentLength);
    // #189806: could be resumed due to FNFE in DefaultIndexUpdater (*.gz -> *.zip)
    this.units = contentLength / 1024;        
    handle.switchToDeterminate(100);
}
 

@Override
public void transferCompleted( TransferEvent transferEvent )
{
    resourceName = transferEvent.getResource( ).getName( );
    long endTime = System.currentTimeMillis( );
    log.info( "end of transfer file {} {} kb: {}s", transferEvent.getResource( ).getName( ),
            this.totalLength / 1024, ( endTime - startTime ) / 1000 );
}
 

@Override
public void transferCompleted( TransferEvent transferEvent )
{
    resourceName = transferEvent.getResource( ).getName( );
    long endTime = System.currentTimeMillis( );
    log.info( "end of transfer file {} {} kb: {}s", transferEvent.getResource( ).getName( ),
            this.totalLength / 1024, ( endTime - startTime ) / 1000 );
}
 

@Override
public void transferCompleted( TransferEvent transferEvent )
{
    resourceName = transferEvent.getResource( ).getName( );
    long endTime = System.currentTimeMillis( );
    log.info( "end of transfer file {} {} kb: {}s", transferEvent.getResource( ).getName( ),
            this.totalLength / 1024, ( endTime - startTime ) / 1000 );
}
 

@Override
public void put(File source, String destination)
		throws TransferFailedException, ResourceDoesNotExistException,
		AuthorizationException {
       if ( source.isDirectory() ) {
           throw new IllegalArgumentException( "Source is a directory: " + source );
       }
       
	String resourceName = FilenameUtils.separatorsToUnix(destination);
	Resource resource = new Resource(resourceName);

	firePutInitiated(resource, source);
	firePutStarted(resource, source);

	try {

		File file = new File(checkoutDirectory, destination);
		file.getParentFile().mkdirs();
		transfer(resource, source, new FileOutputStream(file), true);

	} catch (Exception e) {
		fireTransferError(resource, e, TransferEvent.REQUEST_PUT);
		throw new TransferFailedException("Unable to put file", e);
	}

	firePutCompleted(resource, source);
}
 

@Override
public void transferInitiated( TransferEvent transferEvent )
{
    startTime = System.currentTimeMillis();
    resourceName = transferEvent.getResource().getName();
    log.debug( "initiate transfer of {}", resourceName );
}
 

@Override
public void transferStarted( TransferEvent transferEvent )
{
    this.totalLength = 0;
    resourceName = transferEvent.getResource( ).getName( );
    log.info( "start transfer of {}", transferEvent.getResource( ).getName( ) );
}
 

@Override
public void transferInitiated( TransferEvent transferEvent )
{
    startTime = System.currentTimeMillis( );
    resourceName = transferEvent.getResource( ).getName( );
    log.debug( "initiate transfer of {}", resourceName );
}
 

@Override
public void transferStarted( TransferEvent transferEvent )
{
    this.totalLength = 0;
    resourceName = transferEvent.getResource( ).getName( );
    log.info( "start transfer of {}", transferEvent.getResource( ).getName( ) );
}
 

@Test
public void resourceExistsAuthorizationException() throws TransferFailedException, AuthorizationException {
    AuthorizationException exception = new AuthorizationException("");
    when(this.wagon.doesRemoteResourceExist("foo")).thenThrow(exception);

    try {
        this.wagon.resourceExists("foo");
        fail();
    } catch (AuthorizationException e) {
        verify(this.transferListenerSupport).fireTransferError(new Resource("foo"), TransferEvent.REQUEST_GET,
                exception);
    }
}
 

@Test
public void put() throws TransferFailedException, ResourceDoesNotExistException, AuthorizationException {
    this.wagon.put(new File("foo"), "bar");

    verify(this.transferListenerSupport).fireTransferInitiated(new Resource("bar"), TransferEvent.REQUEST_PUT);
    verify(this.transferListenerSupport).fireTransferStarted(new Resource("bar"), TransferEvent.REQUEST_PUT);
    verify(this.wagon).putResource(eq(new File("foo")), eq("bar"), any(TransferProgress.class));
    verify(this.transferListenerSupport).fireTransferCompleted(new Resource("bar"), TransferEvent.REQUEST_PUT);
}
 

@Test
public void getIfNewerAuthorizationException() throws TransferFailedException, ResourceDoesNotExistException,
        AuthorizationException {
    AuthorizationException exception = new AuthorizationException("");
    when(this.wagon.isRemoteResourceNewer("foo", 0)).thenThrow(exception);

    try {
        this.wagon.getIfNewer("foo", new File("bar"), 0);
        fail();
    } catch (AuthorizationException e) {
        verify(this.transferListenerSupport).fireTransferError(new Resource("foo"), TransferEvent.REQUEST_GET,
                exception);
    }
}