@Override public Void repeat(final PasswordCallback callback) { scheduler.execute(new Callable<R>() { @Override public R call() throws Exception { return operate(callback, file); } }); return null; }
@Override public void shutdown() { scheduler.shutdown(false); } }
public ConcurrentTransferWorker(final SessionPool source, final SessionPool destination, final Transfer transfer, final ThreadPool.Priority priority, final TransferOptions options, final TransferSpeedometer meter, final TransferPrompt prompt, final TransferErrorCallback error, final ConnectionCallback connectionCallback, final PasswordCallback passwordCallback, final ProgressListener progressListener, final StreamListener streamListener, final NotificationService notification) { super(transfer, options, prompt, meter, error, progressListener, streamListener, connectionCallback, passwordCallback, notification); this.source = source; this.destination = destination; this.pool = ThreadPoolFactory.get(String.format("%s-transfer", new AlphanumericRandomStringService().random()), transfer.getSource().getTransferType() == Host.TransferType.newconnection ? 1 : PreferencesFactory.get().getInteger("queue.connections.limit"), priority); this.completion = new ExecutorCompletionService<TransferStatus>(pool.executor()); }
@Override public void cleanup(final Boolean result) { pool.shutdown(result); }
private Future<MultipartPart> submit(final Path source, final MultipartUpload multipart, final int partNumber, final long offset, final long length) { if(log.isInfoEnabled()) { log.info(String.format("Submit part %d of %s to queue with offset %d and length %d", partNumber, source, offset, length)); } return pool.execute(new Callable<MultipartPart>() { @Override public MultipartPart call() throws BackgroundException { try { final HttpRange range = HttpRange.byLength(offset, length); final MultipartPart part = session.getClient().multipartUploadPartCopy(multipart, partNumber, containerService.getContainer(source).getName(), containerService.getKey(source), null, null, null, null, range.getStart(), range.getEnd(), source.attributes().getVersionId()); if(log.isInfoEnabled()) { log.info(String.format("Received response %s for part number %d", part, partNumber)); } // Populate part with response data that is accessible via the object's metadata return new MultipartPart(partNumber, null == part.getLastModified() ? new Date(System.currentTimeMillis()) : part.getLastModified(), null == part.getEtag() ? StringUtils.EMPTY : part.getEtag(), part.getSize()); } catch(S3ServiceException e) { throw new S3ExceptionMappingService().map("Cannot copy {0}", e, source); } } }); } }
@Override public void shutdown() { if(log.isInfoEnabled()) { log.info(String.format("Terminating concurrent executor thread pool %s", concurrentExecutor)); } concurrentExecutor.shutdown(false); } }
@Override public boolean open(final Local file, final Application application, final ApplicationQuitCallback callback) { try { final Process process = runtime.exec(String.format("%s %s", application.getIdentifier(), file.getAbsolute())); pool.execute(new Callable<Boolean>() { @Override public Boolean call() { try { process.waitFor(); callback.callback(); return true; } catch(InterruptedException e) { log.warn(String.format("Failure waiting for application %s to exit", process)); return false; } } }); return true; } catch(IOException e) { log.warn(String.format("Failure launching application %s", e.getMessage())); return false; } }
public void close() { try { monitor.close(); pool.shutdown(false); } catch(IOException e) { log.error("Failure closing file watcher monitor", e); } } }
log.info(String.format("Submit part %d of %s to queue with offset %d and length %d", partNumber, file, offset, length)); return pool.execute(new DefaultRetryCallable<B2UploadPartResponse>(new BackgroundExceptionCallable<B2UploadPartResponse>() { @Override public B2UploadPartResponse call() throws BackgroundException {
pool.shutdown(false);
@Override public <T> Future<T> execute(final Controller controller, final BackgroundActionRegistry registry, final BackgroundAction<T> action) { if(log.isDebugEnabled()) { log.debug(String.format("Run action %s in background", action)); } // Add action to registry of controller. Will be removed automatically when stopped registry.add(action); action.init(); // Start background task final Callable<T> command = new BackgroundCallable<T>(action, controller); try { final Future<T> task = concurrentExecutor.execute(command); if(log.isInfoEnabled()) { log.info(String.format("Scheduled background runnable %s for execution", action)); } return task; } catch(RejectedExecutionException e) { log.error(String.format("Error scheduling background task %s for execution. %s", action, e.getMessage())); action.cancel(); action.cleanup(); return ConcurrentUtils.constantFuture(null); } }
pool.shutdown(false);
pool.execute(new Callable<Boolean>() { @Override public Boolean call() {
pool.shutdown(false);
private Future<Path> submit(final ThreadPool pool, final Path bucket, final String common) { return pool.execute(new BackgroundExceptionCallable<Path>() { @Override public Path call() throws BackgroundException {
pool.shutdown(false);
private Future<StorageObject> submit(final ThreadPool pool, final Path segment, final Local local, final BandwidthThrottle throttle, final StreamListener listener, final TransferStatus overall, final Long offset, final Long length, final ConnectionCallback callback) { return pool.execute(new DefaultRetryCallable<StorageObject>(new BackgroundExceptionCallable<StorageObject>() { @Override public StorageObject call() throws BackgroundException {
pool.shutdown(false);
log.info(String.format("Submit part %d of %s to queue with offset %d and length %d", partNumber, file, offset, length)); return pool.execute(new DefaultRetryCallable<MultipartPart>(new BackgroundExceptionCallable<MultipartPart>() { @Override public MultipartPart call() throws BackgroundException {