core-3nweb-client-lib 0.25.6 → 0.27.0

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

@@ -1,58 +1,119 @@
-import { ObjId } from '../../../lib-client/3nstorage/xsp-fs/common';
+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';
+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;
+}
+export interface LocalVersions extends VersionsInfo {
     isArchived?: boolean;
-    deletedOnRemote?: boolean;
-    syncState: SyncState;
-    versions: {
-        latestSynced?: number;
-        conflictingRemote?: number[];
-        current?: number;
-        archived?: number[];
-        unsynchedArchived?: number[];
-        remote?: number;
-    };
-    gcWorkInfo?: object;
+    archived?: undefined;
+    upload?: UploadInfo;
+}
+export interface SyncMarker {
+    version?: number;
+    isArchived?: boolean;
+    base?: number;
+}
+export interface VersionsOnServer extends VersionsInfo {
+    isArchived?: boolean;
+}
+export interface UploadInfo {
+    localVersion: number;
+    uploadVersion: number;
+    baseVersion?: number;
+    needUpload?: WholeVerOrderedUpload | DiffVerOrderedUpload;
 }
-export declare class ObjStatus {
+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 NonGarbage {
+    local?: NonGarbageVersions;
+    remote: NonGarbageVersions;
+    uploadVersion?: number;
+}
+export declare const STATUS_FILE_NAME = "status";
+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): Promise<ObjStatus>;
-    static makeNew(objFolder: string, objId: ObjId): Promise<ObjStatus>;
-    static makeForDownloadedVersion(objFolder: string, objId: ObjId, version: number): Promise<ObjStatus>;
+    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>;
-    private saveFile;
+    private updateStateIndicator;
     isArchived(): boolean;
-    getCurrentVersionOrThrow(): number;
-    isRemoteVersionGreaterOrEqualTo(newRemoteVersion: number): boolean;
-    isDeletedOnRemote(): boolean;
-    syncedVersionGreaterOrEqual(version: number): boolean;
-    removeCurrentVersion(verObjs: ContainerWithDelete<number>): Promise<void>;
-    setDeletedOnRemote(): Promise<void>;
-    setRemoteVersion(version: number): Promise<void>;
-    setSyncedCurrentVersion(version: number): Promise<void>;
-    setUnsyncedCurrentVersion(version: number): Promise<void>;
+    getCurrentLocalOrSynced(): number;
+    getNonGarbageVersions(): NonGarbage;
+    removeCurrentVersion(): Promise<void>;
+    private triggerSaveProc;
+    recordUploadStart(info: UploadInfo): Promise<void>;
+    recordUploadInterimState(info: UploadInfo): Promise<void>;
+    recordUploadCancellation(info: UploadInfo): Promise<void>;
+    recordArchVersionRemoval(version: number): Promise<void>;
+    recordVersionArchival(version: number): Promise<void>;
+    recordRemoteRemoval(): Promise<void>;
+    recordRemoteChange(version: number): Promise<void>;
+    recordSyncOfObjRemoval(): 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;
-}
-interface ContainerWithDelete<T> {
-    delete(key: T): void;
+    baseOfLocalVersion(version: number): {
+        localBases?: number[];
+        syncedBase?: number;
+    } | undefined;
+    markLocalVersionSynced(localVersion: number, uploadVersion: number): Promise<void>;
+    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;
+    adoptRemoteVersion(version?: number, dropLocalVer?: boolean): Promise<void>;
 }
+export declare function readAndCheckStatus(objFolder: string, objId: ObjId): Promise<ObjStatusInfo>;
 export {};