[_]: Feat/fallback permission

src/apps/main/preload.d.ts

@@ -168,5 +168,6 @@ declare interface Window {
     openUrl: (url: string) => Promise<void>;
     getPreferredAppLanguage: () => Promise<Array<string>>;
     syncManually: () => Promise<void>;
+    getRecentlywasSyncing: () => Promise<boolean>;
   };
 }

src/apps/main/preload.js

@@ -299,5 +299,9 @@ contextBridge.exposeInMainWorld('electron', {
   syncManually() {
     return ipcRenderer.invoke('SYNC_MANUALLY');
   },
+  getRecentlywasSyncing()  {
+    return ipcRenderer.invoke('CHECK_SYNC_IN_PROGRESS');
+  },
+
   path,
 });

src/apps/main/remote-sync/RemoteSyncManager.ts

@@ -6,6 +6,7 @@ import {
   RemoteSyncedFile,
   SyncConfig,
   SYNC_OFFSET_MS,
+  WAITING_AFTER_SYNCING
 } from './helpers';
 import { reportError } from '../bug-report/service';
 
@@ -24,6 +25,8 @@ export class RemoteSyncManager {
   > = [];
   private totalFilesSynced = 0;
   private totalFoldersSynced = 0;
+  private lastSyncingFinishedTimestamp: Date | null = null;
+
   constructor(
     private db: {
       files: DatabaseCollectionAdapter<DriveFile>;
@@ -47,10 +50,15 @@ export class RemoteSyncManager {
     if (typeof callback !== 'function') return;
     this.onStatusChangeCallbacks.push(callback);
   }
+
   getSyncStatus(): RemoteSyncStatus {
     return this.status;
   }
 
+  private getLastSyncingFinishedTimestamp() {
+    return this.lastSyncingFinishedTimestamp;
+  }
+
   /**
    * Check if the RemoteSyncManager is in SYNCED status
    *
@@ -60,10 +68,22 @@ export class RemoteSyncManager {
     return this.status === 'SYNCED';
   }
 
+  /**
+   * Consult if recently the RemoteSyncManager was syncing
+   * @returns True if the RemoteSyncManager was syncing recently
+   * @returns False if the RemoteSyncManager was not syncing recently
+   */
+  recentlyWasSyncing() {
+    const passedTime = Date.now() - ( this.getLastSyncingFinishedTimestamp()?.getTime() ?? Date.now() );
+    return passedTime < WAITING_AFTER_SYNCING;
+  }
+
   resetRemoteSync() {
     this.changeStatus('IDLE');
     this.filesSyncStatus = 'IDLE';
     this.foldersSyncStatus = 'IDLE';
+    this._placeholdersStatus = 'IDLE';
+    this.lastSyncingFinishedTimestamp = null;
     this.totalFilesSynced = 0;
     this.totalFoldersSynced = 0;
   }
@@ -148,6 +168,7 @@ export class RemoteSyncManager {
     return true;
   }
   private changeStatus(newStatus: RemoteSyncStatus) {
+    this.addLastSyncingFinishedTimestamp();
     if (newStatus === this.status) return;
     Logger.info(`RemoteSyncManager ${this.status} -> ${newStatus}`);
     this.status = newStatus;
@@ -157,6 +178,12 @@ export class RemoteSyncManager {
     });
   }
 
+  private addLastSyncingFinishedTimestamp() {
+    if (this.status !== 'SYNCING') return;
+    Logger.info('Adding last syncing finished timestamp');
+    this.lastSyncingFinishedTimestamp = new Date();
+  }
+
   private checkRemoteSyncStatus() {
     if (this._placeholdersStatus === 'SYNCING') {
       this.changeStatus('SYNCING');

src/apps/main/remote-sync/handlers.ts

@@ -2,7 +2,7 @@ import eventBus from '../event-bus';
 import { RemoteSyncManager } from './RemoteSyncManager';
 import { DriveFilesCollection } from '../database/collections/DriveFileCollection';
 import { DriveFoldersCollection } from '../database/collections/DriveFolderCollection';
-import { clearRemoteSyncStore } from './helpers';
+import { clearRemoteSyncStore, RemoteSyncStatus } from './helpers';
 import { getNewTokenClient } from '../../shared/HttpClient/main-process-client';
 import Logger from 'electron-log';
 import { ipcMain } from 'electron';
@@ -120,16 +120,18 @@ eventBus.on('USER_LOGGED_OUT', () => {
 
 ipcMain.on('CHECK_SYNC', (event) => {
   Logger.info('Checking sync');
-  event.sender.send(
-    'CHECK_SYNC_ENGINE_RESPONSE',
-    'Dato obtenido del proceso de sincronización'
-  );
+  event.sender.send('CHECK_SYNC_ENGINE_RESPONSE', '');
 });
 
 ipcMain.on('CHECK_SYNC_CHANGE_STATUS', async (_, placeholderStates) => {
-  await sleep(2_000);
-  Logger.info('[SYNC ENGINE] Changing status');
-  remoteSyncManager.placeholderStatus = 'SYNCING';
-  await sleep(7_00);
+  Logger.info('[SYNC ENGINE] Changing status', placeholderStates);
+  await sleep(5_000);
   remoteSyncManager.placeholderStatus = placeholderStates;
 });
+
+ipcMain.handle('CHECK_SYNC_IN_PROGRESS', async () => {
+  const syncingStatus: RemoteSyncStatus = 'SYNCING';
+  const isSyncing = remoteSyncManager.getSyncStatus() === syncingStatus;
+  const recentlySyncing = remoteSyncManager.recentlyWasSyncing();
+  return isSyncing || recentlySyncing; // If it's syncing or recently was syncing
+});

src/apps/main/remote-sync/helpers.ts

@@ -99,6 +99,7 @@ export type SyncConfig = {
 };
 
 export const SYNC_OFFSET_MS = 0;
+export const WAITING_AFTER_SYNCING = 1000 * 60 * 3;
 
 export const lastSyncedAtIsNewer = (
   itemUpdatedAt: Date,

src/apps/renderer/pages/Widget/Header.tsx

@@ -12,6 +12,7 @@ import useUsage from '../../hooks/useUsage';
 import useVirtualDriveStatus from '../../hooks/VirtualDriveStatus';
 import { reportError } from '../../utils/errors';
 
+
 export default function Header() {
   const { translate } = useTranslationContext();
   const { virtualDriveCanBeOpened } = useVirtualDriveStatus();
@@ -45,10 +46,19 @@ export default function Header() {
     window.electron.quit();
   }
 
-  function onSyncClick() {
+  const wasSyncing =  () => {
+    return window.electron.getRecentlywasSyncing();
+  };
+
+  async function onSyncClick() {
+    const notAllowed = await wasSyncing();
+    if (notAllowed) {
+      return;
+    }
     window.electron.syncManually();
   }
 
+
   const handleOpenURL = async (URL: string) => {
     try {
       await window.electron.openUrl(URL);
@@ -200,13 +210,15 @@ export default function Header() {
                   )}
                 </Menu.Item>
                 <Menu.Item>
-                  {({ active }) => (
-                    <div>
-                      <DropdownItem active={active} onClick={onSyncClick}>
+                  {({active}) => {
+
+                    return (<div>
+                      <DropdownItem active={active} onClick={onSyncClick}  >
                         <span>{translate('widget.header.dropdown.sync')}</span>
                       </DropdownItem>
-                    </div>
-                  )}
+                    </div>);
+                  }
+                  }
                 </Menu.Item>
                 <Menu.Item>
                   {({ active }) => (

src/apps/sync-engine/BindingManager.ts

@@ -322,6 +322,7 @@ export class BindingsManager {
   }
 
   private async pollingStart() {
+    Logger.debug('[SYNC ENGINE] Starting polling');
     return this.container.pollingMonitorStart.run(this.polling.bind(this));
   }
 

src/context/virtual-drive/files/application/FileCheckerStatusInRoot.ts

@@ -27,16 +27,16 @@ export class FileCheckerStatusInRoot {
 
       const ps = placeholderStatus.pinState;
       const ss = placeholderStatus.syncState;
-      const status =
+      const notSynced =
         ps &&
         ss &&
         ps !== PinState.AlwaysLocal &&
         ps !== PinState.OnlineOnly &&
         ss !== SyncState.InSync;
 
-      if (status) {
+      if (notSynced) {
         Logger.debug(
-          `[File Checker Status In Root] item ${path} with status: ${status}`
+          `[File Checker Status In Root] item ${path} with status: ${notSynced}`
         );
         finalStatus = 'SYNC_PENDING';
         break;

src/context/virtual-drive/shared/application/PollingMonitorStart.ts

@@ -1,8 +1,21 @@
 import { MonitorFn, PollingMonitor } from '../domain/PollingMonitor';
+import { ipcRenderer } from 'electron';
+import Logger from 'electron-log';
 
 export class PollingMonitorStart {
   constructor(private readonly polling: PollingMonitor) {}
   run(fn: MonitorFn) {
-    return this.polling.start(fn);
+    Logger.info('[START FALLBAK] Starting fallback sync...');
+
+    const permission = this.permissionFn.bind(this);
+    return this.polling.start(fn, permission);
+  }
+
+  private async permissionFn() {
+    const isSyncing = await ipcRenderer.invoke('CHECK_SYNC_IN_PROGRESS');
+    Logger.info('[START FALLBAK] Not permitted to start fallback sync: ', isSyncing);
+
+    const isPermitted = !isSyncing;
+    return isPermitted;
   }
 }

src/context/virtual-drive/shared/domain/PollingMonitor.ts

@@ -1,4 +1,5 @@
 export type MonitorFn = () => Promise<void>;
+export type PermissionFn = () => Promise<boolean>;
 export class PollingMonitor {
   constructor(private readonly delay: number) {}
 
@@ -11,16 +12,25 @@ export class PollingMonitor {
     }
   }
 
-  private setTimeout(fn: MonitorFn) {
+  private setTimeout(fn: MonitorFn, permissionFn: PermissionFn) {
     this.clearTimeout();
     this.timeout = setTimeout(async () => {
+      if (!(await permissionFn())) {
+        // wait for the next interval
+        this.repeatDelay(fn, permissionFn);
+        return;
+      }
       await fn();
-      this.setTimeout(fn);
+      this.repeatDelay(fn, permissionFn);
     }, this.delay);
   }
 
-  start(fn: MonitorFn) {
-    this.setTimeout(fn);
+  private repeatDelay(fn: MonitorFn, runPermissionFn: PermissionFn) {
+    this.setTimeout(fn, runPermissionFn);
+  }
+
+  start(fn: MonitorFn, runPermissionFn: PermissionFn) {
+    this.setTimeout(fn, runPermissionFn);
   }
 
   stop() {