Add transfer item callback. Reset failure repeat counter for every co…

…mpleted transfer. Fix #8223.

Former-commit-id: f52919c4bb7eed0a0d467c7adaedcaf51bf88647

source/ch/cyberduck/core/editor/EditBackgroundAction.java

@@ -24,6 +24,7 @@
 import ch.cyberduck.core.ProgressListener;
 import ch.cyberduck.core.Session;
 import ch.cyberduck.core.exception.BackgroundException;
+import ch.cyberduck.core.transfer.DisabledTransferItemCallback;
 import ch.cyberduck.core.transfer.DisabledTransferPrompt;
 import ch.cyberduck.core.transfer.DownloadTransfer;
 import ch.cyberduck.core.transfer.Transfer;
@@ -83,7 +84,7 @@ public Transfer run() throws BackgroundException {
         options.open = false;
         final SingleTransferWorker worker
                 = new SingleTransferWorker(session, download, options, new TransferSpeedometer(download),
-                new DisabledTransferPrompt(), callback, listener, new DisabledLoginController());
+                new DisabledTransferPrompt(), callback, new DisabledTransferItemCallback(), listener, new DisabledLoginController());
         worker.run();
         if(!download.isComplete()) {
             log.warn(String.format("File size changed for %s", file));

source/ch/cyberduck/core/editor/SaveBackgroundAction.java

@@ -23,6 +23,7 @@
 import ch.cyberduck.core.ProgressListener;
 import ch.cyberduck.core.Session;
 import ch.cyberduck.core.exception.BackgroundException;
+import ch.cyberduck.core.transfer.DisabledTransferItemCallback;
 import ch.cyberduck.core.transfer.DisabledTransferPrompt;
 import ch.cyberduck.core.transfer.Transfer;
 import ch.cyberduck.core.transfer.TransferAction;
@@ -86,7 +87,7 @@ public Transfer run() throws BackgroundException {
         }
         final SingleTransferWorker worker
                 = new SingleTransferWorker(session, upload, new TransferOptions(),
-                new TransferSpeedometer(upload), new DisabledTransferPrompt(), callback, listener, new DisabledLoginController());
+                new TransferSpeedometer(upload), new DisabledTransferPrompt(), callback, new DisabledTransferItemCallback(), listener, new DisabledLoginController());
         worker.run();
         if(!upload.isComplete()) {
             log.warn(String.format("File size changed for %s", editor.getRemote()));

source/ch/cyberduck/core/transfer/DisabledTransferItemCallback.java

@@ -0,0 +1,30 @@
+package ch.cyberduck.core.transfer;
+
+/*
+ * Copyright (c) 2002-2014 David Kocher. All rights reserved.
+ * http://cyberduck.io/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Bug fixes, suggestions and comments should be sent to:
+ * feedback@cyberduck.io
+ */
+
+/**
+ * @version $Id$
+ */
+public class DisabledTransferItemCallback implements TransferItemCallback {
+
+    @Override
+    public void complete(final TransferItem item) {
+        //
+    }
+}

source/ch/cyberduck/core/transfer/TransferItemCallback.java

@@ -0,0 +1,26 @@
+package ch.cyberduck.core.transfer;
+
+/*
+ * Copyright (c) 2002-2014 David Kocher. All rights reserved.
+ * http://cyberduck.io/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * Bug fixes, suggestions and comments should be sent to:
+ * feedback@cyberduck.io
+ */
+
+/**
+ * @version $Id$
+ */
+public interface TransferItemCallback {
+    void complete(final TransferItem item);
+}

source/ch/cyberduck/ui/action/AbstractTransferWorker.java

@@ -36,6 +36,7 @@
 import ch.cyberduck.core.transfer.TransferAction;
 import ch.cyberduck.core.transfer.TransferErrorCallback;
 import ch.cyberduck.core.transfer.TransferItem;
+import ch.cyberduck.core.transfer.TransferItemCallback;
 import ch.cyberduck.core.transfer.TransferOptions;
 import ch.cyberduck.core.transfer.TransferPathFilter;
 import ch.cyberduck.core.transfer.TransferPrompt;
@@ -74,6 +75,8 @@ public abstract class AbstractTransferWorker extends Worker<Boolean> implements
      */
     private TransferErrorCallback error;
 
+    private TransferItemCallback callback;
+
     /**
      * Login prompt
      */
@@ -102,19 +105,20 @@ public abstract class AbstractTransferWorker extends Worker<Boolean> implements
 
     public AbstractTransferWorker(final Transfer transfer, final TransferOptions options,
                                   final TransferPrompt prompt, final TransferSpeedometer meter, final TransferErrorCallback error,
-                                  final ProgressListener listener, final LoginCallback login) {
+                                  final TransferItemCallback callback, final ProgressListener listener, final LoginCallback login) {
         this.transfer = transfer;
         this.prompt = prompt;
         this.meter = meter;
         this.error = error;
         this.login = login;
         this.options = options;
         this.listener = listener;
+        this.callback = callback;
     }
 
     public AbstractTransferWorker(final Transfer transfer, final TransferOptions options,
                                   final TransferPrompt prompt, final TransferSpeedometer meter, final TransferErrorCallback error,
-                                  final ProgressListener listener, final LoginCallback login, final Cache<TransferItem> cache) {
+                                  final TransferItemCallback callback, final ProgressListener listener, final LoginCallback login, final Cache<TransferItem> cache) {
         this.transfer = transfer;
         this.options = options;
         this.prompt = prompt;
@@ -123,11 +127,12 @@ public AbstractTransferWorker(final Transfer transfer, final TransferOptions opt
         this.login = login;
         this.cache = cache;
         this.listener = listener;
+        this.callback = callback;
     }
 
     public AbstractTransferWorker(final Transfer transfer, final TransferOptions options,
                                   final TransferPrompt prompt, final TransferSpeedometer meter, final LoginCallback login,
-                                  final TransferErrorCallback error, final ProgressListener listener,
+                                  final TransferErrorCallback error, final TransferItemCallback callback, final ProgressListener listener,
                                   final Map<Path, TransferStatus> table) {
         this.transfer = transfer;
         this.options = options;
@@ -137,6 +142,7 @@ public AbstractTransferWorker(final Transfer transfer, final TransferOptions opt
         this.login = login;
         this.table = table;
         this.listener = listener;
+        this.callback = callback;
     }
 
     protected abstract Session<?> borrow() throws BackgroundException;
@@ -193,7 +199,7 @@ public Boolean run() throws BackgroundException {
                 meter.reset();
                 // Transfer all files sequentially
                 for(TransferItem next : transfer.getRoots()) {
-                    this.transfer(next.remote, next.local, filter);
+                    this.transfer(next, filter);
                 }
                 this.await();
             }
@@ -313,13 +319,13 @@ public String toString() {
      * @param file   File
      * @param filter Filter to apply to exclude files from transfer
      */
-    public void transfer(final Path file, final Local local, final TransferPathFilter filter) throws BackgroundException {
+    public void transfer(final TransferItem item, final TransferPathFilter filter) throws BackgroundException {
         if(this.isCanceled()) {
             throw new ConnectionCanceledException();
         }
         // Only transfer if accepted by filter and stored in table with transfer status
-        if(table.containsKey(file)) {
-            final TransferStatus status = table.get(file);
+        if(table.containsKey(item.remote)) {
+            final TransferStatus status = table.get(item.remote);
             this.submit(new TransferCallable() {
                 @Override
                 public TransferStatus call() throws BackgroundException {
@@ -329,11 +335,12 @@ public TransferStatus call() throws BackgroundException {
                         try {
                             if(status.isRename()) {
                                 // Save with different name
-                                transfer.transfer(session, status.getRename().remote, local, options, status, login, listener);
+                                transfer.transfer(session, status.getRename().remote, item.local, options, status, login, listener);
                             }
                             else {
-                                transfer.transfer(session, file, local, options, status, login, listener);
+                                transfer.transfer(session, item.remote, item.local, options, status, login, listener);
                             }
+                            callback.complete(item);
                         }
                         catch(ConnectionCanceledException e) {
                             throw e;
@@ -353,23 +360,23 @@ public TransferStatus call() throws BackgroundException {
                             }
                         }
                         // Recursive
-                        if(file.isDirectory()) {
-                            for(TransferItem f : cache.get(file.getReference())) {
+                        if(item.remote.isDirectory()) {
+                            for(TransferItem f : cache.get(item.remote.getReference())) {
                                 // Recursive
-                                transfer(f.remote, f.local, filter);
+                                transfer(f, filter);
                             }
-                            cache.remove(file.getReference());
+                            cache.remove(item.remote.getReference());
                         }
                         if(!status.isFailure()) {
                             // Post process of file.
                             try {
-                                filter.complete(file, local, options, status, listener);
+                                filter.complete(item.remote, item.local, options, status, listener);
                             }
                             catch(BackgroundException e) {
-                                log.warn(String.format("Ignore failure in completion filter for %s", file));
+                                log.warn(String.format("Ignore failure in completion filter for %s", item));
                             }
                         }
-                        return table.remove(file);
+                        return table.remove(item.remote);
                     }
                     finally {
                         release(session);
@@ -379,15 +386,14 @@ public TransferStatus call() throws BackgroundException {
                 @Override
                 public String toString() {
                     final StringBuilder sb = new StringBuilder("TransferCallable{");
-                    sb.append("file=").append(file);
-                    sb.append(", local=").append(local);
+                    sb.append("item=").append(item);
                     sb.append('}');
                     return sb.toString();
                 }
             });
         }
         else {
-            log.warn(String.format("Skip file %s with unknown transfer status", file));
+            log.warn(String.format("Skip file %s with unknown transfer status", item));
         }
     }
 

source/ch/cyberduck/ui/action/ConcurrentTransferWorker.java

@@ -33,6 +33,7 @@
 import ch.cyberduck.core.threading.NamedThreadFactory;
 import ch.cyberduck.core.transfer.Transfer;
 import ch.cyberduck.core.transfer.TransferErrorCallback;
+import ch.cyberduck.core.transfer.TransferItemCallback;
 import ch.cyberduck.core.transfer.TransferOptions;
 import ch.cyberduck.core.transfer.TransferPrompt;
 import ch.cyberduck.core.transfer.TransferSpeedometer;
@@ -73,19 +74,19 @@ public class ConcurrentTransferWorker extends AbstractTransferWorker {
     public ConcurrentTransferWorker(final ConnectionService connect,
                                     final Transfer transfer, final TransferOptions options,
                                     final TransferSpeedometer meter, final TransferPrompt prompt, final TransferErrorCallback error,
-                                    final LoginCallback login, final ProgressListener progressListener,
+                                    final TransferItemCallback callback, final LoginCallback login, final ProgressListener progressListener,
                                     final TranscriptListener transcriptListener) {
-        this(connect, transfer, options, meter, prompt, error, login, progressListener, transcriptListener,
+        this(connect, transfer, options, meter, prompt, error, callback, login, progressListener, transcriptListener,
                 Preferences.instance().getInteger("queue.session.pool.size"));
     }
 
     public ConcurrentTransferWorker(final ConnectionService connect,
                                     final Transfer transfer, final TransferOptions options,
                                     final TransferSpeedometer meter, final TransferPrompt prompt, final TransferErrorCallback error,
-                                    final LoginCallback login, final ProgressListener progressListener,
+                                    final TransferItemCallback callback, final LoginCallback login, final ProgressListener progressListener,
                                     final TranscriptListener transcriptListener,
                                     final Integer connections) {
-        super(transfer, options, prompt, meter, error, progressListener, login);
+        super(transfer, options, prompt, meter, error, callback, progressListener, login);
         this.connect = connect;
         final GenericObjectPoolConfig configuration = new GenericObjectPoolConfig();
         configuration.setJmxEnabled(false);

source/ch/cyberduck/ui/action/SingleTransferWorker.java

@@ -27,6 +27,7 @@
 import ch.cyberduck.core.transfer.Transfer;
 import ch.cyberduck.core.transfer.TransferErrorCallback;
 import ch.cyberduck.core.transfer.TransferItem;
+import ch.cyberduck.core.transfer.TransferItemCallback;
 import ch.cyberduck.core.transfer.TransferOptions;
 import ch.cyberduck.core.transfer.TransferPrompt;
 import ch.cyberduck.core.transfer.TransferSpeedometer;
@@ -43,25 +44,25 @@ public class SingleTransferWorker extends AbstractTransferWorker {
 
     public SingleTransferWorker(final Session session, final Transfer transfer, final TransferOptions options,
                                 final TransferSpeedometer meter, final TransferPrompt prompt,
-                                final TransferErrorCallback error, final ProgressListener listener,
+                                final TransferErrorCallback error, final TransferItemCallback callback, final ProgressListener listener,
                                 final LoginCallback login) {
-        super(transfer, options, prompt, meter, error, listener, login);
+        super(transfer, options, prompt, meter, error, callback, listener, login);
         this.session = session;
     }
 
     public SingleTransferWorker(final Session session, final Transfer transfer, final TransferOptions options,
                                 final TransferSpeedometer meter, final TransferPrompt prompt,
-                                final TransferErrorCallback error, final ProgressListener listener,
+                                final TransferErrorCallback error, final TransferItemCallback callback, final ProgressListener listener,
                                 final LoginCallback login, final Cache<TransferItem> cache) {
-        super(transfer, options, prompt, meter, error, listener, login, cache);
+        super(transfer, options, prompt, meter, error, callback, listener, login, cache);
         this.session = session;
     }
 
     public SingleTransferWorker(final Session session, final Transfer transfer, final TransferOptions options,
                                 final TransferSpeedometer meter, final TransferPrompt prompt,
-                                final TransferErrorCallback error, final ProgressListener listener,
+                                final TransferErrorCallback error, final TransferItemCallback callback, final ProgressListener listener,
                                 final LoginCallback login, final Map<Path, TransferStatus> table) {
-        super(transfer, options, prompt, meter, login, error, listener, table);
+        super(transfer, options, prompt, meter, login, error, callback, listener, table);
         this.session = session;
     }
 

source/ch/cyberduck/ui/threading/TransferBackgroundAction.java

@@ -33,6 +33,8 @@
 import ch.cyberduck.core.transfer.CopyTransfer;
 import ch.cyberduck.core.transfer.Transfer;
 import ch.cyberduck.core.transfer.TransferErrorCallback;
+import ch.cyberduck.core.transfer.TransferItem;
+import ch.cyberduck.core.transfer.TransferItemCallback;
 import ch.cyberduck.core.transfer.TransferListener;
 import ch.cyberduck.core.transfer.TransferOptions;
 import ch.cyberduck.core.transfer.TransferPrompt;
@@ -57,7 +59,7 @@
 /**
  * @version $Id$
  */
-public class TransferBackgroundAction extends ControllerBackgroundAction<Boolean> {
+public class TransferBackgroundAction extends ControllerBackgroundAction<Boolean> implements TransferItemCallback {
     private static final Logger log = Logger.getLogger(TransferBackgroundAction.class);
 
     private Transfer transfer;
@@ -87,8 +89,6 @@ public class TransferBackgroundAction extends ControllerBackgroundAction<Boolean
 
     private Growl growl = GrowlFactory.get();
 
-    private int repeat = 0;
-
     public TransferBackgroundAction(final Controller controller,
                                     final Session session,
                                     final TransferListener listener,
@@ -118,10 +118,10 @@ public TransferBackgroundAction(final Controller controller,
         this.listener = listener;
         this.prompt = prompt;
         if(Preferences.instance().getInteger("queue.session.pool.size") == 1) {
-            this.worker = new SingleTransferWorker(session, transfer, options, meter, prompt, error, progress, login);
+            this.worker = new SingleTransferWorker(session, transfer, options, meter, prompt, error, this, progress, login);
         }
         else {
-            this.worker = new ConcurrentTransferWorker(connection, transfer, options, meter, prompt, error, login, progress, controller);
+            this.worker = new ConcurrentTransferWorker(connection, transfer, options, meter, prompt, error, this, login, progress, controller);
         }
     }
 
@@ -147,6 +147,12 @@ protected void close(final Session session) throws BackgroundException {
         }
     }
 
+    @Override
+    public void complete(final TransferItem item) {
+        // Reset repeat counter. #8223
+        repeat = 0;
+    }
+
     @Override
     public void prepare() throws ConnectionCanceledException {
         listener.start(transfer);
@@ -181,11 +187,6 @@ public void finish() {
         timerPool.shutdown();
     }
 
-    @Override
-    protected int retry() {
-        return super.retry();
-    }
-
     @Override
     public void pause() {
         if(log.isDebugEnabled()) {