core-3nweb-client-lib 0.26.1 → 0.27.3

package/build/core/storage/synced/obj-status.d.ts

@@ -1,117 +1,130 @@
-import { ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
-import { VersionsInfo } from '../common/obj-info-file';
+import { ObjId, SyncedObjStatus } from '../../../lib-client/3nstorage/xsp-fs/common';
+import { NonGarbageVersions, VersionsInfo } from '../common/obj-info-file';
 import { LogError } from '../../../lib-client/logging/log-to-file';
-declare type Stats = web3n.files.Stats;
+import { DiffInfo, ObjStatus as RemoteObjStatus } from '../../../lib-common/service-api/3nstorage/owner';
+import { FiniteChunk } from '../../../lib-common/objs-on-disk/file-layout';
+import { UploadStatusRecorder } from './upsyncer';
+declare type SyncStatus = web3n.files.SyncStatus;
 /**
- * Storage object can be in following states:
- * 1. Synced state indicates that current local version and one on the server
- *    are same.
- * 2. Behind state indicates that while current local version is synced,
- *    server already has a newer version.
- * 3. Unsynced state indicates that current local version hasn't been uploaded
- *    to the server. Current is just the next version, following the server one.
- * 4. Conflicting state indicates that current unsynced local version conflicts
- *    with version on the server, uploaded by other client.
+ * This is status information of an object in synced storage.
+ * Local references versions that haven't been synced/uploaded.
+ * Remote enumerates versions on the server.
+ * Synced marks version of latest synchronized moment.
+ * Local versions must be on disk as it is the only copy. Remote versions can
+ * be present as needed/desired.
  */
-export declare type SyncState = 'synced' | 'behind' | 'unsynced' | 'conflicting';
 export interface ObjStatusInfo {
     objId: ObjId;
+    local?: LocalVersions;
+    synced?: SyncMarker;
+    remote: VersionsOnServer;
+    upload?: UploadInfo;
+}
+export interface LocalVersions extends VersionsInfo {
     isArchived?: boolean;
-    versions: VersionsInfo;
-    sync: {
-        state: SyncState;
-        latest?: number;
-        conflictingRemote?: number[];
-        remote?: number;
-        deletedOnRemote?: true;
-    };
-    syncTasks?: {
-        queued: UpSyncTaskInfo[];
-        current?: UpSyncTaskInfo;
-    };
+    archived?: undefined;
 }
-export interface UploadInfo {
-    type: 'upload';
-    transactionId?: string;
-    createObj?: true;
-    needUpload?: {
-        header?: number;
-        segs: BytesSection[];
-        allByteOnDisk?: true;
-    };
-    version: number;
+export interface SyncMarker {
+    version?: number;
+    isArchived?: boolean;
+    base?: number;
+}
+export interface VersionsOnServer extends VersionsInfo {
+    isArchived?: boolean;
+}
+export declare type UploadInfo = NewVersionUpload | RemovalUpload;
+export interface NewVersionUpload {
+    type: 'new-version';
+    localVersion: number;
+    uploadVersion: number;
     baseVersion?: number;
+    needUpload?: WholeVerOrderedUpload | DiffVerOrderedUpload;
+}
+export interface RemovalUpload {
+    type: 'removal';
+    isPostponed: boolean;
+    localVersion?: number;
+}
+export interface WholeVerOrderedUpload {
+    type: 'ordered-whole';
+    createObj?: boolean;
+    header?: number;
+    segsLeft: number;
+    segsOfs: number;
+    transactionId?: string;
+}
+export interface DiffVerOrderedUpload {
+    type: 'ordered-diff';
+    diff: DiffInfo;
+    header?: number;
+    newSegsLeft: FiniteChunk[];
+    transactionId?: string;
 }
 export interface BytesSection {
     ofs: number;
     len: number;
 }
-export interface RemovalInfo {
-    type: 'removal';
-    archivedVersions?: number[] | number;
-    currentVersion?: true;
-}
-export interface ArchivalInfo {
-    type: 'archiving';
-    archivalOfCurrent?: true;
-}
-export declare type UpSyncTaskInfo = UploadInfo | RemovalInfo | ArchivalInfo;
-export interface UpSyncStatus {
-    queueTask(t: UpSyncTaskInfo): void;
-    getTaskForProcessing(): Promise<UpSyncTaskInfo | undefined>;
-    glanceOnNextTask(): UpSyncTaskInfo | undefined;
-    recordInterimStateOfCurrentTask(t: UploadInfo): Promise<void>;
-    recordTaskCompletion(t: UpSyncTaskInfo): Promise<void>;
-    isSyncDone(): boolean;
-    stat(): NonNullable<Stats['sync']>;
+export interface NonGarbage {
+    local?: NonGarbageVersions;
+    remote: NonGarbageVersions;
+    uploadVersion?: number;
 }
 export declare const STATUS_FILE_NAME = "status";
-export declare class ObjStatus implements UpSyncStatus {
+export declare class ObjStatus implements SyncedObjStatus, UploadStatusRecorder {
     private readonly objFolder;
     private readonly status;
     private readonly logError;
     private readonly saveProc;
+    private stateIndicator;
     private constructor();
     static readFrom(objFolder: string, objId: ObjId, logError: LogError): Promise<ObjStatus>;
     static makeNew(objFolder: string, objId: ObjId, logError: LogError): Promise<ObjStatus>;
     static makeForDownloadedVersion(objFolder: string, objId: ObjId, version: number, currentRemote: number, logError: LogError): Promise<ObjStatus>;
     static fileShowsObjNotInSyncedState(objFolder: string, objId: ObjId): Promise<boolean>;
+    static fileShowsObjNeedsRemovalOnRemote(objFolder: string, objId: ObjId): Promise<boolean>;
+    needsRemovalOnRemote(): boolean;
+    clearPostponeFlagInRemovalOnRemote(): Promise<boolean>;
+    private updateStateIndicator;
     isArchived(): boolean;
-    getCurrentVersionOrThrow(): number;
-    getNonGarbageVersions(): {
-        gcMaxVer?: number;
-        nonGarbage: Set<number>;
-    };
-    isRemoteVersionGreaterOrEqualTo(newRemoteVersion: number): boolean;
-    isDeletedOnRemote(): boolean;
-    syncedVersionGreaterOrEqual(version: number): boolean;
-    removeCurrentVersion(verObjs: ContainerWithDelete<number>): Promise<void>;
+    getCurrentLocalOrSynced(): number;
+    getNonGarbageVersions(): NonGarbage;
+    removeCurrentVersion(): Promise<void>;
     private triggerSaveProc;
-    setDeletedOnRemote(): Promise<void>;
-    setRemoteVersion(version: number): Promise<void>;
-    markVersionSynced(version: number): Promise<void>;
-    setUnsyncedCurrentVersion(version: number, baseVer: number | undefined): Promise<void>;
+    recordUploadStart(info: NewVersionUpload): Promise<void>;
+    recordUploadInterimState(info: NewVersionUpload): Promise<void>;
+    recordUploadCancellation(info: NewVersionUpload): Promise<void>;
+    recordUploadCompletion(localVersion: number, uploadVersion: number): Promise<void>;
+    recordArchVersionRemoval(version: number): Promise<void>;
+    recordVersionArchival(version: number): Promise<void>;
+    recordRemoteRemoval(): Promise<void>;
+    recordRemoteRemovalCompletion(): Promise<void>;
+    recordRemoteChange(version: number): Promise<void>;
+    recordStatusFromServer({ archived, current }: RemoteObjStatus): Promise<void>;
     /**
-     * This method ignores remote conflicting versions.
-     * @param version
+     * When given object version is a diff on some base, this method returns
+     * a whole trace of local base versions up to synced one.
+     * Local bases, if present, are return in an array with highest version
+     * first.
+     * This returns undefined, when given object version is not a diff.
+     * @param version that is local, for which we want to get base versions, if
+     * it is a diff version.
      */
-    isVersionSynced(version: number): boolean;
-    isVersionArchived(version: number): boolean;
-    queueTask(t: UpSyncTaskInfo): void;
-    private addUploadToQueue;
-    private addRemoveCurrentToQueue;
-    private addRemoveArchivedToQueue;
-    private addArchivalToQueue;
-    getTaskForProcessing(): Promise<UpSyncTaskInfo | undefined>;
-    glanceOnNextTask(): UpSyncTaskInfo | undefined;
-    recordInterimStateOfCurrentTask(t: UploadInfo): Promise<void>;
-    recordTaskCompletion(t: UpSyncTaskInfo): Promise<void>;
-    isSyncDone(): boolean;
-    isFileSaved(): boolean;
-    stat(): NonNullable<Stats['sync']>;
-}
-interface ContainerWithDelete<T> {
-    delete(key: T): void;
+    baseOfLocalVersion(version: number): {
+        localBases?: number[];
+        syncedBase?: number;
+    } | undefined;
+    setLocalCurrentVersion(version: number, baseVer: number | undefined): Promise<void>;
+    listVersions(): {
+        current?: number;
+        archived?: number[];
+    };
+    archiveCurrentVersion(): Promise<void>;
+    absorbLocalVersionBase(version: number, localBase: number): Promise<void>;
+    latestSyncedVersion(): number | undefined;
+    syncStatus(): SyncStatus;
+    neverUploaded(): boolean;
+    versionBeforeUnsyncedRemoval(): number | undefined;
+    adoptRemoteVersion(version?: number, dropLocalVer?: boolean): Promise<void>;
 }
 export declare function readAndCheckStatus(objFolder: string, objId: ObjId): Promise<ObjStatusInfo>;
 export {};