#106 Make paths in progress panels show actual file being worked on regardless of batching

ylexus · ylexus · commit d7bc5c56fcea · 2021-05-22T12:29:46.000+01:00
diff --git a/build.gradle b/build.gradle
@@ -51,7 +51,7 @@ dependencies {
     ext.orgJunitJupiterVersion = '5.6.0'
     ext.orgMockitoVersion = '3.2.4'
     ext.orgImmutablesVersion = '2.8.3'
-    ext.netYudichevJiottyVersion = '1.7'
+    ext.netYudichevJiottyVersion = '1.7.1'
 
     annotationProcessor "org.immutables:value:$orgImmutablesVersion"
     testAnnotationProcessor "org.immutables:value:$orgImmutablesVersion"
diff --git a/src/main/java/net/yudichev/googlephotosupload/core/AddToAlbumAfterCreatingStrategy.java b/src/main/java/net/yudichev/googlephotosupload/core/AddToAlbumAfterCreatingStrategy.java
@@ -12,6 +12,7 @@
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.function.BiFunction;
 import java.util.function.Function;
@@ -43,19 +44,23 @@ final class AddToAlbumAfterCreatingStrategy implements AddToAlbumStrategy {
     public CompletableFuture<Void> addToAlbum(CompletableFuture<List<PathState>> createMediaDataResultsFuture,
                                               Optional<GooglePhotosAlbum> googlePhotosAlbum,
                                               ProgressStatus fileProgressStatus,
+                                              ProgressStatus directoryProgressStatus,
                                               BiFunction<Optional<String>, List<PathState>, CompletableFuture<List<PathMediaItemOrError>>> createMediaItems,
                                               Function<Path, ItemState> itemStateRetriever) {
         return createMediaDataResultsFuture
                 .thenCompose(createMediaDataResults -> partition(createMediaDataResults, GOOGLE_PHOTOS_API_BATCH_SIZE).stream()
                         .collect(toFutureOfListChaining(pathStates -> createMediaItems.apply(Optional.empty(), pathStates)))
                         .thenApply(lists -> lists.stream().flatMap(Collection::stream)))
-                .thenCompose(pathMediaItemOrErrorStream -> addToAlbum(googlePhotosAlbum, pathMediaItemOrErrorStream, fileProgressStatus, itemStateRetriever));
+                .thenCompose(pathMediaItemOrErrorStream -> addToAlbum(googlePhotosAlbum,
+                        pathMediaItemOrErrorStream,
+                        fileProgressStatus,
+                        directoryProgressStatus));
     }
 
     private CompletionStage<Void> addToAlbum(Optional<GooglePhotosAlbum> googlePhotosAlbum,
                                              Stream<PathMediaItemOrError> pathMediaItemOrErrorStream,
                                              ProgressStatus fileProgressStatus,
-                                             Function<Path, ItemState> itemStateRetriever) {
+                                             ProgressStatus directoryProgressStatus) {
         return googlePhotosAlbum
                 .map(album -> {
                     var pathMediaItemOrErrors = pathMediaItemOrErrorStream
@@ -69,7 +74,8 @@ private CompletionStage<Void> addToAlbum(Optional<GooglePhotosAlbum> googlePhoto
                             .collect(toImmutableList());
                     return cloudOperationHelper.withBackOffAndRetry("add items to album",
                             () -> partition(mediaItemsToAddToAlbum, GOOGLE_PHOTOS_API_BATCH_SIZE).stream()
-                                    .collect(toFutureOfListChaining(mediaItems -> album.addMediaItems(mediaItems, executorServiceProvider.get())))
+                                    .collect(toFutureOfListChaining(mediaItems -> album
+                                            .addMediaItems(mediaItems, statusUpdatingExecutor(album, directoryProgressStatus))))
                                     .<Void>thenApply(ignored -> null),
                             fileProgressStatus::onBackoffDelay)
                             .exceptionallyCompose(exception -> fatalUserCorrectableHandler.handle(
@@ -84,4 +90,11 @@ private CompletionStage<Void> addToAlbum(Optional<GooglePhotosAlbum> googlePhoto
                 })
                 .orElseGet(CompletableFutures::completedFuture);
     }
+
+    private Executor statusUpdatingExecutor(GooglePhotosAlbum album, ProgressStatus directoryProgressStatus) {
+        return command -> executorServiceProvider.get().execute(() -> {
+            directoryProgressStatus.updateDescription(album.getTitle());
+            command.run();
+        });
+    }
 }
diff --git a/src/main/java/net/yudichev/googlephotosupload/core/AddToAlbumStrategy.java b/src/main/java/net/yudichev/googlephotosupload/core/AddToAlbumStrategy.java
@@ -13,6 +13,7 @@ interface AddToAlbumStrategy {
     CompletableFuture<Void> addToAlbum(CompletableFuture<List<PathState>> createMediaDataResultsFuture,
                                        Optional<GooglePhotosAlbum> googlePhotosAlbum,
                                        ProgressStatus fileProgressStatus,
+                                       ProgressStatus directoryProgressStatus,
                                        BiFunction<Optional<String>, List<PathState>, CompletableFuture<List<PathMediaItemOrError>>> createMediaItems,
                                        Function<Path, ItemState> itemStateRetriever);
 }
diff --git a/src/main/java/net/yudichev/googlephotosupload/core/AddToAlbumWhileCreatingStrategy.java b/src/main/java/net/yudichev/googlephotosupload/core/AddToAlbumWhileCreatingStrategy.java
@@ -18,11 +18,15 @@ final class AddToAlbumWhileCreatingStrategy implements AddToAlbumStrategy {
     public CompletableFuture<Void> addToAlbum(CompletableFuture<List<PathState>> createMediaDataResultsFuture,
                                               Optional<GooglePhotosAlbum> googlePhotosAlbum,
                                               ProgressStatus fileProgressStatus,
+                                              ProgressStatus directoryProgressStatus,
                                               BiFunction<Optional<String>, List<PathState>, CompletableFuture<List<PathMediaItemOrError>>> createMediaItems,
                                               Function<Path, ItemState> itemStateRetriever) {
         return createMediaDataResultsFuture
                 .thenCompose(createMediaDataResults -> partition(createMediaDataResults, GOOGLE_PHOTOS_API_BATCH_SIZE).stream()
-                        .map(pathStates -> createMediaItems.apply(googlePhotosAlbum.map(GooglePhotosAlbum::getId), pathStates))
+                        .map(pathStates -> {
+                            directoryProgressStatus.updateDescription(googlePhotosAlbum.map(GooglePhotosAlbum::getTitle).orElse(""));
+                            return createMediaItems.apply(googlePhotosAlbum.map(GooglePhotosAlbum::getId), pathStates);
+                        })
                         .collect(toFutureOfList())
                         .thenApply(voids -> null));
     }
diff --git a/src/main/java/net/yudichev/googlephotosupload/core/GooglePhotosUploaderImpl.java b/src/main/java/net/yudichev/googlephotosupload/core/GooglePhotosUploaderImpl.java
@@ -19,6 +19,7 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 
 import static com.google.common.base.Preconditions.checkNotNull;
@@ -86,23 +87,20 @@ public CompletableFuture<Void> uploadDirectory(Optional<GooglePhotosAlbum> googl
                     directoryProgressStatus.updateDescription(googlePhotosAlbum.map(GooglePhotosAlbum::getTitle).orElse(""));
                     var createMediaDataResultsFuture = paths.stream()
                             .sorted(comparing(path -> path.getFileName().toString()))
-                            .map(path -> {
-                                fileProgressStatus.updateDescription(path.toAbsolutePath().toString());
-                                return createMediaData(path)
-                                        .thenApply(itemState -> {
-                                            itemState.toFailure().ifPresentOrElse(
-                                                    error -> fileProgressStatus.addFailure(KeyedError.of(path, error)),
-                                                    fileProgressStatus::incrementSuccess);
-                                            return PathState.of(path, itemState);
-                                        });
-                            })
+                            .map(path -> createMediaData(path, fileProgressStatus)
+                                    .thenApply(itemState -> {
+                                        itemState.toFailure().ifPresentOrElse(
+                                                error -> fileProgressStatus.addFailure(KeyedError.of(path, error)),
+                                                fileProgressStatus::incrementSuccess);
+                                        return PathState.of(path, itemState);
+                                    }))
                             .collect(toFutureOfList());
                     return addToAlbumStrategy.addToAlbum(
                             createMediaDataResultsFuture,
                             googlePhotosAlbum,
                             fileProgressStatus,
-                            (albumId, pathStates) -> createMediaItems(albumId, fileProgressStatus, pathStates),
-                            this::getItemState);
+                            directoryProgressStatus,
+                            (albumId, pathStates) -> createMediaItems(albumId, fileProgressStatus, pathStates), this::getItemState);
                 });
     }
 
@@ -212,14 +210,14 @@ private void forgetUploadState() {
         memoryBarrier = true;
     }
 
-    private CompletableFuture<ResultOrFailure<ItemState>> createMediaData(Path file) {
+    private CompletableFuture<ResultOrFailure<ItemState>> createMediaData(Path file, ProgressStatus fileProgressStatus) {
         checkStarted();
         checkState(memoryBarrier);
         return uploadedItemStateByPath.compute(file,
                 (theFile, currentFuture) -> {
                     if (currentFuture == null || currentFuture.isCompletedExceptionally()) {
                         logger.info("Scheduling upload of {}", file);
-                        currentFuture = doCreateMediaData(theFile);
+                        currentFuture = doCreateMediaData(theFile, fileProgressStatus);
                     } else {
                         var itemState = currentFuture.getNow(null);
                         if (itemState != null) {
@@ -236,7 +234,7 @@ private CompletableFuture<ResultOrFailure<ItemState>> createMediaData(Path file)
                                     })
                                     .orElseGet(() -> {
                                         logger.info("Uploaded, but upload token expired, re-uploading: {}", file);
-                                        return doCreateMediaData(theFile);
+                                        return doCreateMediaData(theFile, fileProgressStatus);
                                     });
                         } else {
                             logger.error("Unexpected future state for {}: {}", file, currentFuture);
@@ -257,7 +255,7 @@ private CompletableFuture<ResultOrFailure<ItemState>> createMediaData(Path file)
                             .orElseGet(() -> {
                                 if (backOffHandler.handle(operationName, exception).isPresent()) {
                                     logger.debug("Retrying upload of {}", file);
-                                    return createMediaData(file);
+                                    return createMediaData(file, fileProgressStatus);
                                 } else {
                                     throw new RuntimeException(exception);
                                 }
@@ -274,8 +272,8 @@ private boolean uploadTokenNotExpired(Path file, UploadMediaItemState uploadMedi
         return notExpired;
     }
 
-    private CompletableFuture<ItemState> doCreateMediaData(Path file) {
-        return googlePhotosClient.uploadMediaData(file, executorService)
+    private CompletableFuture<ItemState> doCreateMediaData(Path file, ProgressStatus fileProgressStatus) {
+        return googlePhotosClient.uploadMediaData(file, statusUpdatingExecutor(file, fileProgressStatus))
                 .thenApply(uploadToken -> {
                     logger.info("Uploaded file {}", file);
                     logger.debug("Upload token {}", uploadToken);
@@ -284,4 +282,11 @@ private CompletableFuture<ItemState> doCreateMediaData(Path file) {
                             .build();
                 });
     }
+
+    private Executor statusUpdatingExecutor(Path file, ProgressStatus fileProgressStatus) {
+        return command -> executorService.execute(() -> {
+            fileProgressStatus.updateDescription(file.toAbsolutePath().toString());
+            command.run();
+        });
+    }
 }
diff --git a/src/main/java/net/yudichev/googlephotosupload/core/SelectingAddToAlbumStrategy.java b/src/main/java/net/yudichev/googlephotosupload/core/SelectingAddToAlbumStrategy.java
@@ -37,9 +37,15 @@ final class SelectingAddToAlbumStrategy implements AddToAlbumStrategy {
     public CompletableFuture<Void> addToAlbum(CompletableFuture<List<PathState>> createMediaDataResultsFuture,
                                               Optional<GooglePhotosAlbum> googlePhotosAlbum,
                                               ProgressStatus fileProgressStatus,
+                                              ProgressStatus directoryProgressStatus,
                                               BiFunction<Optional<String>, List<PathState>, CompletableFuture<List<PathMediaItemOrError>>> createMediaItems,
                                               Function<Path, ItemState> itemStateRetriever) {
-        return selectDelegate().addToAlbum(createMediaDataResultsFuture, googlePhotosAlbum, fileProgressStatus, createMediaItems, itemStateRetriever);
+        return selectDelegate().addToAlbum(createMediaDataResultsFuture,
+                googlePhotosAlbum,
+                fileProgressStatus,
+                directoryProgressStatus,
+                createMediaItems,
+                itemStateRetriever);
     }
 
     private AddToAlbumStrategy selectDelegate() {

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ interface AddToAlbumStrategy {`
`13`	`13`	`CompletableFuture<Void> addToAlbum(CompletableFuture<List<PathState>> createMediaDataResultsFuture,`
`14`	`14`	`Optional<GooglePhotosAlbum> googlePhotosAlbum,`
`15`	`15`	`ProgressStatus fileProgressStatus,`
	`16`	`+ ProgressStatus directoryProgressStatus,`
`16`	`17`	`BiFunction<Optional<String>, List<PathState>, CompletableFuture<List<PathMediaItemOrError>>> createMediaItems,`
`17`	`18`	`Function<Path, ItemState> itemStateRetriever);`
`18`	`19`	`}`