private FileRepositoryWorker( TransferWrapper transfer, RemoteRepository repository, Direction direction, RepositorySystemSession session ) { if ( repository == null ) { throw new IllegalArgumentException( "RemoteRepository may not be null." ); } if ( session == null ) { throw new IllegalArgumentException( "RepositorySystemSession may not be null." ); } this.catapult = new TransferEventCatapult( session.getTransferListener() ); resource = newResource( transfer, repository ); eventBuilder = new TransferEvent.Builder( session, resource ); switch ( direction ) { case UPLOAD: eventBuilder.setRequestType( RequestType.PUT ); break; case DOWNLOAD: eventBuilder.setRequestType( transfer.isExistenceCheck() ? RequestType.GET_EXISTENCE : RequestType.GET ); break; } this.direction = direction; this.repository = repository; this.transfer = transfer; }
long length = Long.parseLong(contentLength); transferResource.setContentLength(length); transferStarted(download, newEvent(transferResource, null, requestType, EventType.STARTED).setTransferredBytes(bytesTransferred).build()); os.write(buffer, 0, n); if (emitProgressEvent) { transferProgressed(download, newEvent(transferResource, null, requestType, EventType.PROGRESSED).setTransferredBytes(n).setDataBuffer(buffer, 0, n).build());
event.setException( e ); catapult.fireCorrupted( event );
listener.transferInitiated( event.build() ); event.setException( e ); listener.transferCorrupted( event.build() ); listener.transferSucceeded( event.build() ); event.setException( e ); listener.transferFailed( event.build() );
event.setTransferredBytes( totalTransferred ); catapult.fireSucceeded( event );
transferInitiated(download, newEvent(transferResource, RequestType.GET, EventType.INITIATED).build()); transferSucceeded(download, newEvent(transferResource, RequestType.GET, EventType.SUCCEEDED).setTransferredBytes(temporaryFileInLocalRepository.bytesTransferred).build()); } catch (Throwable t) { if (Exception.class.isAssignableFrom(t.getClass())) { exception = new Exception(t); transferFailed(download, newEvent(transferResource, exception, RequestType.GET, EventType.FAILED).build()); } finally { latch.countDown();
listener.transferInitiated( event.build() ); listener.transferSucceeded( event.build() ); event.setException( e ); listener.transferFailed( event.build() );
String uri = buildUrl(path); transferInitiated(upload, newEvent(transferResource, exception, RequestType.PUT, EventType.INITIATED).build()); transferStarted(upload, newEvent(transferResource, null, RequestType.PUT, EventType.STARTED).build()); transferSucceeded(upload, newEvent(transferResource, null, RequestType.PUT, EventType.SUCCEEDED).setTransferredBytes(source.getBytesTransferred()).build()); exception = e; } finally { transferFailed(upload, newEvent(transferResource, exception, RequestType.PUT, EventType.FAILED).build());
@Override public void copyTo(OutputStream os) throws IOException { Closer closer = Closer.create(); try { InputStream is = closer.register(new FileInputStream(resource.getFile())); closer.register(os); int n = 0; final byte[] buffer = new byte[4 * 1024]; while (-1 != (n = is.read(buffer))) { os.write(buffer, 0, n); transferProgressed(transfer, newEvent(resource, null, RequestType.PUT, EventType.PROGRESSED).setTransferredBytes(bytesTransferred) .setDataBuffer(buffer, 0, n).build()); bytesTransferred = bytesTransferred + n; } } catch (TransferCancelledException e) { this.exception = e; } finally { closer.close(); } }
@Override public void transferStarted( TransferEvent event ) { eventBuilder.setTransferredBytes( 0 ); resource.setContentLength( event.getResource().getContentLength() ); try { delegate.transferStarted( newEvent( EventType.STARTED ).build() ); } catch ( TransferCancelledException e ) { /* * NOTE: Wagon transfers are not freely abortable. In particular, aborting from * AbstractWagon.fire(Get|Put)Started() would result in unclosed streams so we avoid this case. */ } }
private TransferEvent.Builder newEventBuilder( TransferResource resource, boolean upload, boolean peek ) { TransferEvent.Builder builder = new TransferEvent.Builder( session, resource ); if ( upload ) { builder.setRequestType( TransferEvent.RequestType.PUT ); } else if ( !peek ) { builder.setRequestType( TransferEvent.RequestType.GET ); } else { builder.setRequestType( TransferEvent.RequestType.GET_EXISTENCE ); } return builder; }
public void progressed( ByteBuffer buffer ) throws IOException { total += buffer.remaining(); TransferEvent.Builder event = newEvent( transfer ); event.setDataBuffer( buffer ).setTransferredBytes( total ); try { catapult.fireProgressed( event ); } catch ( TransferCancelledException e ) { throw new IOException( "Transfer was cancelled: " + e.getMessage() ); } } } );
@Override public void transportStarted( long dataOffset, long dataLength ) throws TransferCancelledException { if ( checksumCalculator != null ) { checksumCalculator.init( dataOffset ); } if ( listener != null ) { eventBuilder.resetType( EventType.STARTED ).setTransferredBytes( dataOffset ); TransferEvent event = eventBuilder.build(); event.getResource().setContentLength( dataLength ).setResumeOffset( dataOffset ); listener.transferStarted( event ); } }
private void validateChecksums(File temporaryFileInLocalRepository, File fileInLocalRepository, String uri, TransferResource transferResource) throws Exception { boolean failOnInvalidOrMissingCheckums = RepositoryPolicy.CHECKSUM_POLICY_FAIL.equals(checksumPolicy); try { Map<String, Object> checksums = ChecksumUtils.calc(temporaryFileInLocalRepository, checksumAlgos.keySet()); if (!verifyChecksums(temporaryFileInLocalRepository, fileInLocalRepository, uri, checksums)) { throw new ChecksumFailureException("Checksum validation failed" + ", no checksums available from the repository"); } } catch (Exception e) { transferCorrupted(download, newEvent(transferResource, e, RequestType.GET, EventType.CORRUPTED).build()); if (failOnInvalidOrMissingCheckums) { transferFailed(download, newEvent(transferResource, e, RequestType.GET, EventType.FAILED).build()); throw e; } } }
@Override public void transportStarted( long dataOffset, long dataLength ) throws TransferCancelledException { if ( checksumCalculator != null ) { checksumCalculator.init( dataOffset ); } if ( listener != null ) { eventBuilder.resetType( EventType.STARTED ).setTransferredBytes( dataOffset ); TransferEvent event = eventBuilder.build(); event.getResource().setContentLength( dataLength ).setResumeOffset( dataOffset ); listener.transferStarted( event ); } }
private TransferEvent.Builder newEventBuilder( TransferResource resource, boolean upload, boolean peek ) { TransferEvent.Builder builder = new TransferEvent.Builder( session, resource ); if ( upload ) { builder.setRequestType( TransferEvent.RequestType.PUT ); } else if ( !peek ) { builder.setRequestType( TransferEvent.RequestType.GET ); } else { builder.setRequestType( TransferEvent.RequestType.GET_EXISTENCE ); } return builder; }
/** * Sets the byte buffer holding the transferred bytes since the last event. * * @param buffer The byte buffer holding the transferred bytes since the last event, may be {@code null} if not * applicable to the event. * @param offset The starting point of valid bytes in the array. * @param length The number of valid bytes, must not be negative. * @return This event builder for chaining, never {@code null}. */ public Builder setDataBuffer( byte[] buffer, int offset, int length ) { return setDataBuffer( ( buffer != null ) ? ByteBuffer.wrap( buffer, offset, length ) : null ); }
@Override public void transportProgressed( ByteBuffer data ) throws TransferCancelledException { if ( checksumCalculator != null ) { checksumCalculator.update( data ); } if ( listener != null ) { eventBuilder.resetType( EventType.PROGRESSED ).addTransferredBytes( data.remaining() ).setDataBuffer( data ); listener.transferProgressed( eventBuilder.build() ); } }
/** * Sets the byte buffer holding the transferred bytes since the last event. * * @param buffer The byte buffer holding the transferred bytes since the last event, may be {@code null} if not * applicable to the event. * @param offset The starting point of valid bytes in the array. * @param length The number of valid bytes, must not be negative. * @return This event builder for chaining, never {@code null}. */ public Builder setDataBuffer( byte[] buffer, int offset, int length ) { return setDataBuffer( ( buffer != null ) ? ByteBuffer.wrap( buffer, offset, length ) : null ); }