From 30ec493a6dae644b0907f6ee6e86696c06aa11b4 Mon Sep 17 00:00:00 2001
From: Sam Wilkins <samwilkins333@gmail.com>
Date: Wed, 18 Sep 2019 04:31:53 -0400
Subject: additional timeunit

---
 src/client/northstar/utils/Extensions.ts          | 15 +++++++++++++--
 src/client/util/UtilExtensions.ts                 | 21 +++++++++++++++++----
 src/server/apis/google/GooglePhotosUploadUtils.ts |  6 +++++-
 src/server/index.ts                               |  4 +++-
 4 files changed, 38 insertions(+), 8 deletions(-)

(limited to 'src')

diff --git a/src/client/northstar/utils/Extensions.ts b/src/client/northstar/utils/Extensions.ts
index 3722bfd52..ad3e06806 100644
--- a/src/client/northstar/utils/Extensions.ts
+++ b/src/client/northstar/utils/Extensions.ts
@@ -42,6 +42,17 @@ interface PredicateBatcherAsync<I, A> {
 type Batcher<I, A> = FixedBatcher | PredicateBatcher<I, A>;
 type BatcherAsync<I, A> = Batcher<I, A> | PredicateBatcherAsync<I, A>;
 
+enum TimeUnit {
+    Milliseconds,
+    Seconds,
+    Minutes
+}
+
+interface Interval {
+    magnitude: number;
+    unit: TimeUnit;
+}
+
 interface Array<T> {
     fixedBatch<T>(batcher: FixedBatcher): T[][];
     predicateBatch<T, A = undefined>(batcher: PredicateBatcher<T, A>): T[][];
@@ -55,8 +66,8 @@ interface Array<T> {
     batchedForEachAsync<A = undefined>(batcher: Batcher<T, A>, handler: BatchHandler<T>): Promise<void>;
     batchedMapAsync<O, A = undefined>(batcher: Batcher<T, A>, handler: BatchConverter<T, O>): Promise<O[]>;
 
-    batchedForEachInterval<A = undefined>(batcher: Batcher<T, A>, handler: BatchHandler<T>, interval: number): Promise<void>;
-    batchedMapInterval<O, A = undefined>(batcher: Batcher<T, A>, handler: BatchConverter<T, O>, interval: number): Promise<O[]>;
+    batchedForEachInterval<A = undefined>(batcher: Batcher<T, A>, handler: BatchHandler<T>, interval: Interval): Promise<void>;
+    batchedMapInterval<O, A = undefined>(batcher: Batcher<T, A>, handler: BatchConverter<T, O>, interval: Interval): Promise<O[]>;
 
     lastElement(): T;
 }
diff --git a/src/client/util/UtilExtensions.ts b/src/client/util/UtilExtensions.ts
index 8bd8fd581..da47fc1bc 100644
--- a/src/client/util/UtilExtensions.ts
+++ b/src/client/util/UtilExtensions.ts
@@ -174,7 +174,20 @@ module.exports.ConvertInBatchesAsync = async function <I, O, A>(batcher: Batcher
     return collector;
 };
 
-module.exports.ExecuteInBatchesAtInterval = async function <I, A>(batcher: BatcherAsync<I, A>, handler: BatchHandler<I>, interval: number): Promise<void> {
+const convert = (interval: Interval) => {
+    const { magnitude, unit } = interval;
+    switch (unit) {
+        default:
+        case TimeUnit.Milliseconds:
+            return magnitude;
+        case TimeUnit.Seconds:
+            return magnitude * 1000;
+        case TimeUnit.Minutes:
+            return magnitude * 1000 * 60;
+    }
+};
+
+module.exports.ExecuteInBatchesAtInterval = async function <I, A>(batcher: BatcherAsync<I, A>, handler: BatchHandler<I>, interval: Interval): Promise<void> {
     if (!this.length) {
         return;
     }
@@ -194,7 +207,7 @@ module.exports.ExecuteInBatchesAtInterval = async function <I, A>(batcher: Batch
                     };
                     await handler(batch, context);
                     resolve();
-                }, interval * 1000);
+                }, convert(interval));
             });
             if (++completed === quota) {
                 break;
@@ -204,7 +217,7 @@ module.exports.ExecuteInBatchesAtInterval = async function <I, A>(batcher: Batch
     });
 };
 
-module.exports.ConvertInBatchesAtInterval = async function <I, O, A>(batcher: BatcherAsync<I, A>, handler: BatchConverter<I, O>, interval: number): Promise<O[]> {
+module.exports.ConvertInBatchesAtInterval = async function <I, O, A>(batcher: BatcherAsync<I, A>, handler: BatchConverter<I, O>, interval: Interval): Promise<O[]> {
     if (!this.length) {
         return [];
     }
@@ -225,7 +238,7 @@ module.exports.ConvertInBatchesAtInterval = async function <I, O, A>(batcher: Ba
                     };
                     collector.push(...(await handler(batch, context)));
                     resolve();
-                }, interval * 1000);
+                }, convert(interval));
             });
             if (++completed === quota) {
                 resolve(collector);
diff --git a/src/server/apis/google/GooglePhotosUploadUtils.ts b/src/server/apis/google/GooglePhotosUploadUtils.ts
index 9733c7ec5..9275bf125 100644
--- a/src/server/apis/google/GooglePhotosUploadUtils.ts
+++ b/src/server/apis/google/GooglePhotosUploadUtils.ts
@@ -80,7 +80,11 @@ export namespace GooglePhotosUploadUtils {
                 });
             })).newMediaItemResults;
         };
-        const newMediaItemResults = await newMediaItems.batchedMapInterval({ batchSize: 50 }, createFromUploadTokens, 0.1);
+        const batcher = { batchSize: 50 };
+        const interval = { magnitude: 100, unit: TimeUnit.Milliseconds };
+
+        const newMediaItemResults = await newMediaItems.batchedMapInterval(batcher, createFromUploadTokens, interval);
+
         return { newMediaItemResults };
     };
 
diff --git a/src/server/index.ts b/src/server/index.ts
index 7fe2ba132..83bbe734b 100644
--- a/src/server/index.ts
+++ b/src/server/index.ts
@@ -869,8 +869,10 @@ app.post(RouteStore.googlePhotosMediaUpload, async (req, res) => {
         }
         return newMediaItems;
     };
+    const batcher = { batchSize: 25 };
+    const interval = { magnitude: 100, unit: TimeUnit.Milliseconds };
 
-    const newMediaItems = await mediaInput.batchedMapInterval({ batchSize: 25 }, dispatchUpload, 0.1);
+    const newMediaItems = await mediaInput.batchedMapInterval(batcher, dispatchUpload, interval);
 
     if (failed) {
         return _error(res, tokenError);
-- 
cgit v1.2.3-70-g09d2