sync with java: d3ec2c31bb8774b8cf3e07b3df4a759b277da483

Author: ml054

src/Documents/Indexes/RollingIndexDeployment.ts

@@ -0,0 +1,8 @@
+import { RollingIndexState } from "./RollingIndexState";
+
+export interface RollingIndexDeployment {
+    state: RollingIndexState;
+    createdAt: Date;
+    startedAt: Date;
+    finishedAt: Date;
+}

src/Documents/Operations/Revisions/GetRevisionsOperation.ts

@@ -0,0 +1,89 @@
+import { IOperation, OperationResultType } from "../OperationAbstractions";
+import { RevisionsResult } from "./RevisionsResult";
+import { DocumentType } from "../../DocumentAbstractions";
+import { IDocumentStore } from "../../IDocumentStore";
+import { DocumentConventions } from "../../Conventions/DocumentConventions";
+import { HttpCache } from "../../../Http/HttpCache";
+import { RavenCommand } from "../../../Http/RavenCommand";
+import { GetRevisionsCommand } from "../../Commands/GetRevisionsCommand";
+import { ServerNode } from "../../../Http/ServerNode";
+import { HttpRequestParameters } from "../../../Primitives/Http";
+import * as stream from "readable-stream";
+
+export class GetRevisionsOperation<T extends object> implements IOperation<RevisionsResult<T>> {
+    private readonly _parameters: GetRevisionsParameters<T>;
+    private readonly _id: string;
+
+    public constructor(id: string, parameters: GetRevisionsParameters<T> = {}) {
+        this._id = id;
+        this._parameters = parameters;
+    }
+
+    public get resultType(): OperationResultType {
+        return "CommandResult";
+    }
+
+
+    getCommand(store: IDocumentStore, conventions: DocumentConventions, httpCache: HttpCache): RavenCommand<RevisionsResult<T>> {
+        return new GetRevisionsResultCommand(this._id, this._parameters, conventions);
+    }
+}
+class GetRevisionsResultCommand<T extends object> extends RavenCommand<RevisionsResult<T>> {
+    private readonly _parameters: GetRevisionsParameters<T>;
+    private readonly conventions: DocumentConventions;
+    private readonly _id: string;
+    private readonly _cmd: GetRevisionsCommand;
+
+    public constructor(id: string, parameters: GetRevisionsParameters<T>, conventions: DocumentConventions) {
+        super();
+        this.conventions = conventions;
+        this._id = id;
+        this._parameters = parameters;
+        this._cmd = new GetRevisionsCommand(conventions, id, parameters.start, parameters.pageSize);
+    }
+
+    get isReadRequest(): boolean {
+        return true;
+    }
+
+    createRequest(node: ServerNode): HttpRequestParameters {
+        return this._cmd.createRequest(node);
+    }
+
+
+    async setResponseAsync(bodyStream: stream.Stream, fromCache: boolean): Promise<string> {
+        if (!bodyStream) {
+            return ;
+        }
+
+        let body: string;
+
+        const responseNode = await this._pipeline<any>()
+            .parseJsonSync()
+            .collectBody(b => body = b)
+            .process(bodyStream);
+
+        if (!responseNode.Results) {
+            return body;
+        }
+
+        const revisions = responseNode.Results;
+
+        const total = responseNode.TotalResults;
+
+        const result = new RevisionsResult<T>();
+        result.totalResults = total;
+        result.results = revisions.filter(x => x).map(x => {
+            const entityType = this.conventions.getJsTypeByDocumentType(this._parameters.documentType);
+            return this.conventions.deserializeEntityFromJson(entityType, x);
+        });
+
+        this.result = result;
+    }
+}
+
+export interface GetRevisionsParameters<T extends object> {
+    documentType?: DocumentType<T>;
+    start?: number;
+    pageSize?: number;
+}

src/Documents/Session/Operations/Lazy/LazyRevisionOperations.ts

@@ -57,9 +57,16 @@ export class LazyRevisionOperations implements ILazyRevisionsOperations {
     private _get<TEntity extends object>(changeVectorOrVectors: string | string[],
                                                documentType?: DocumentType<TEntity>)
         : Lazy<RevisionsCollectionObject<TEntity> | TEntity> {
-        const operation = new GetRevisionOperation(this.delegate, changeVectorOrVectors as string);
-        const lazyRevisionOperation = new LazyRevisionOperation(documentType, operation, "Map");
-        return this.delegate.addLazyOperation(lazyRevisionOperation);
+        if (TypeUtil.isArray(changeVectorOrVectors)) {
+            const operation = new GetRevisionOperation(this.delegate, changeVectorOrVectors);
+            const lazyRevisionOperation = new LazyRevisionOperation(documentType, operation, "Map");
+            return this.delegate.addLazyOperation(lazyRevisionOperation);
+        } else {
+            const operation = new GetRevisionOperation(this.delegate, changeVectorOrVectors);
+            const lazyRevisionOperation = new LazyRevisionOperation(documentType, operation, "Single");
+            return this.delegate.addLazyOperation(lazyRevisionOperation);
+        }
+
     }
 
     private _getByIdAndDate<TEntity extends object>(id: string, date: Date, clazz?: DocumentType<TEntity>): Lazy<TEntity> {

src/ServerWide/Operations/GetDatabaseRecordOperation.ts

@@ -7,6 +7,8 @@ import { RavenCommand } from "../../Http/RavenCommand";
 import { ServerNode } from "../../Http/ServerNode";
 import { TimeSeriesConfiguration } from "../../Documents/Operations/TimeSeries/TimeSeriesConfiguration";
 import { ServerResponse } from "../../Types";
+import { RollingIndexDeployment } from "../../Documents/Indexes/RollingIndexDeployment";
+import { DateUtil } from "../../Utility/DateUtil";
 
 export class GetDatabaseRecordOperation implements IServerOperation<DatabaseRecordWithEtag> {
     private readonly _database: string;
@@ -58,25 +60,37 @@ export class GetDatabaseRecordCommand extends RavenCommand<DatabaseRecordWithEta
             .objectKeysTransform({
                 defaultTransform: "camel",
                 ignorePaths: [
-                    /^(indexes|sorters|autoIndexes|settings|indexesHistory|ravenConnectionStrings|sqlConnectionStrings)\.[^.]+$/i,
+                    /^(indexes|sorters|autoIndexes|settings|indexesHistory|ravenConnectionStrings|sqlConnectionStrings|rollingIndexes)\.[^.]+$/i,
+                    /^rollingIndexes\.[^.]+\.activeDeployments\.[^.]+$/i,
+                    /^indexesHistory\.[^.]+\.[^.]+\.rollingDeployment\.[^.]+$/i,
                     /^timeSeries\./i
                 ]
             })
             .process(bodyStream);
 
+        const dateUtil = this._conventions.dateUtil;
+
+        if (this.result.rollingIndexes) {
+            Object.values(this.result.rollingIndexes).forEach(index => {
+                if (index.activeDeployments) {
+                    index.activeDeployments = GetDatabaseRecordCommand.mapRollingDeployment(dateUtil, index.activeDeployments as any);
+                }
+            });
+        }
 
         const history = this.result.indexesHistory;
         if (history) {
-            const dateUtil = this._conventions.dateUtil;
+
             for (const indexName of Object.keys(history)) {
                 const indexHistory = history[indexName];
 
                 history[indexName] = indexHistory.map(item => {
-                    const { createdAt, ...otherHistoryProps } = item as unknown as ServerResponse<IndexHistoryEntry>;
+                    const { createdAt, rollingDeployment, ...otherHistoryProps } = item as unknown as ServerResponse<IndexHistoryEntry>;
 
                     return {
                         ...otherHistoryProps,
-                        createdAt: dateUtil.parse(createdAt)
+                        createdAt: dateUtil.parse(createdAt),
+                        rollingDeployment: GetDatabaseRecordCommand.mapRollingDeployment(dateUtil, rollingDeployment)
                     } as IndexHistoryEntry;
                 });
             }
@@ -88,4 +102,23 @@ export class GetDatabaseRecordCommand extends RavenCommand<DatabaseRecordWithEta
 
         return body;
     }
+
+    static mapRollingDeployment(dateUtil: DateUtil, input: ServerResponse<Record<string, RollingIndexDeployment>>): Record<string, RollingIndexDeployment> {
+        if (!input) {
+            return null;
+        }
+
+        const result: Record<string, RollingIndexDeployment> = {};
+        for (const tag of Object.keys(input)) {
+            const deployment = input[tag];
+            result[tag] = {
+                state: deployment.state,
+                createdAt: dateUtil.parse(deployment.createdAt),
+                startedAt: dateUtil.parse(deployment.startedAt),
+                finishedAt: dateUtil.parse(deployment.finishedAt),
+            }
+        }
+
+        return result;
+    }
 }

test/Ported/RevisionsTest.ts

@@ -372,7 +372,7 @@ describe("RevisionsTest", function () {
 
             const revisionsLazilyResult = await revisionsLazy.getValue();
 
-            assertThat(revisionsLazilyResult[0] instanceof Company)
+            assertThat(revisionsLazilyResult[0] instanceof User)
                 .isTrue();
 
             assertThat(revision.map(x => x.name).join(","))

test/ServerWide/RollingIndexingTest.ts

@@ -0,0 +1,74 @@
+import { UsersIndex } from "../Assets/Indexes";
+import { DocumentConventions, DocumentStore, GetDatabaseRecordOperation } from "../../src";
+import { ClusterTestContext, RavenTestContext } from "../Utils/TestUtil";
+import { User } from "../Assets/Entities";
+import { assertThat } from "../Utils/AssertExtensions";
+
+(RavenTestContext.isPullRequest ? describe.skip : describe)("ClusterModesForRequestExecutorTest", function () {
+
+    let testContext: ClusterTestContext;
+
+    beforeEach(async function () {
+        testContext = new ClusterTestContext();
+    });
+
+    afterEach(async () => testContext.dispose());
+
+    it("can map rolling indexes types", async function () {
+        const cluster = await testContext.createRaftCluster(2);
+        try {
+
+            const databaseName = testContext.getDatabaseName();
+            const numberOfNodes = 2;
+
+            await cluster.createDatabase({
+                databaseName
+            }, numberOfNodes, cluster.getInitialLeader().url);
+
+
+            let leaderStore: DocumentStore;
+            try {
+                leaderStore = new DocumentStore(cluster.getInitialLeader().url, databaseName);
+                leaderStore.initialize();
+
+                {
+                    const session = leaderStore.openSession();
+                    const user = new User();
+                    user.name = "John";
+                    await session.store(user, "users/1-A");
+                    await session.saveChanges();
+                }
+
+                const index = new UsersIndex();
+                index.deploymentMode = "Rolling";
+
+                await leaderStore.executeIndexes([index]);
+
+                await testContext.waitForIndexingInTheCluster(leaderStore, leaderStore.database, 10_000);
+
+                const databaseRecord = await leaderStore.maintenance.server.send(new GetDatabaseRecordOperation(leaderStore.database));
+
+                const indexHistory = databaseRecord.indexesHistory["UsersIndex"][0];
+                assertThat(indexHistory)
+                    .isNotNull();
+
+                assertThat(indexHistory.rollingDeployment)
+                    .isNotNull();
+
+                assertThat(indexHistory.rollingDeployment["A"])
+                    .isNotNull();
+
+                assertThat(indexHistory.rollingDeployment["A"].startedAt instanceof Date)
+                    .isTrue();
+                assertThat(indexHistory.rollingDeployment["A"].createdAt instanceof Date)
+                    .isTrue();
+                assertThat(indexHistory.rollingDeployment["A"].finishedAt instanceof Date)
+                    .isTrue();
+            } finally {
+                leaderStore.dispose();
+            }
+        } finally {
+            cluster.dispose();
+        }
+    });
+});