Merge pull request #324 from ml054/v5.2

sync with java: dee478bacb488851da66d3b849f93e84b339e00d

Author: ml054

src/Documents/Session/Tokens/GroupByKeyToken.ts

@@ -23,7 +23,8 @@ export class GroupByKeyToken extends QueryToken {
         }
 
         writer
-            .append(" as ")
-            .append(this._projectedName);
+            .append(" as '")
+            .append(this._projectedName)
+            .append("'");
     }
 }

src/Documents/Subscriptions/SubscriptionWorker.ts

@@ -240,8 +240,8 @@ export class SubscriptionWorker<T extends object> implements IDisposable {
 
     private _ensureParser(socket: Socket) {
         const keysTransformProfile = getTransformJsonKeysProfile(
-            this._revisions 
-                ? "SubscriptionRevisionsResponsePayload" 
+            this._revisions
+                ? "SubscriptionRevisionsResponsePayload"
                 : "SubscriptionResponsePayload", this._store.conventions);
 
         this._parser = stream.pipeline([
@@ -438,7 +438,7 @@ export class SubscriptionWorker<T extends object> implements IDisposable {
                     }
 
                     const lastReceivedChangeVector = batch.initialize(incomingBatch);
-                    notifiedSubscriber = this._emitBatchAndWaitForProcessing(batch) 
+                    notifiedSubscriber = this._emitBatchAndWaitForProcessing(batch)
                         .catch((err) => {
                             this._logger.error(err, "Subscription " + this._options.subscriptionName
                                 + ". Subscriber threw an exception on document batch");
@@ -580,9 +580,9 @@ export class SubscriptionWorker<T extends object> implements IDisposable {
                 return data.value;
             }
         }
-        
+
         return new Promise<void>((resolve, reject) => {
-            stream.once("readable", readableListener); 
+            stream.once("readable", readableListener);
             stream.once("error", errorHandler);
             stream.once("end", endHandler);
 
@@ -592,7 +592,7 @@ export class SubscriptionWorker<T extends object> implements IDisposable {
                 resolve();
             }
 
-            function errorHandler(err) { 
+            function errorHandler(err) {
                 stream.removeListener("readable", readableListener);
                 stream.removeListener("end", endHandler);
                 reject(err);
@@ -646,7 +646,8 @@ export class SubscriptionWorker<T extends object> implements IDisposable {
                         const curTopology = reqEx.getTopologyNodes();
                         const nextNodeIndex = (this._forcedTopologyUpdateAttempts++) % curTopology.length;
                         try {
-                            this._redirectNode = curTopology[nextNodeIndex];
+                            const indexAndNode = await reqEx.getRequestedNode(curTopology[nextNodeIndex].clusterTag, true);
+                            this._redirectNode = indexAndNode.currentNode;
 
                             this._logger.info("Subscription " + this._options.subscriptionName + ". Will modify redirect node from null to " + this._redirectNode.clusterTag);
                         } catch (e) {
@@ -759,7 +760,7 @@ export class SubscriptionWorker<T extends object> implements IDisposable {
     public on(event: "connectionRetry",
               handler: (error?: Error) => void);
     public on(event: EventTypes,
-              handler: 
+              handler:
                   ((batchOrError: SubscriptionBatch<T>, callback: EmptyCallback) => void)
                   | ((error: Error) => void)) {
         this._emitter.on(event, handler);

src/Exceptions/index.ts

@@ -46,7 +46,9 @@ export function getError(
 }
 
 export type RavenErrorType = "RavenException"
+    | "RavenTimeoutException"
     | "NotSupportedException"
+    | "IndexCompactionInProgressException"
     | "InvalidOperationException"
     | "InvalidArgumentException"
     | "ErrorResponseException"
@@ -176,8 +178,8 @@ export class ExceptionDispatcher {
             return getError("ConcurrencyException", schema.error, inner);
         }
 
-        const error = 
-            schema.error + os.EOL 
+        const error =
+            schema.error + os.EOL
             + "The server at " + schema.url + " responded with status code: " + code;
 
         const determinedType = this._getType(typeAsString) as RavenErrorType;
@@ -200,6 +202,8 @@ export class ExceptionDispatcher {
                 const determinedType = this._getType(schema.type) as RavenErrorType;
                 errorToThrow = getError(determinedType || "RavenException", schema.error);
             }
+
+            ExceptionDispatcher._fillException(errorToThrow, schema);
         } catch (errThrowing) {
             errorToThrow = getError("RavenException", errThrowing.message, errThrowing);
         } finally {
@@ -209,6 +213,12 @@ export class ExceptionDispatcher {
         throw errorToThrow;
     }
 
+    private static _fillException(exception: Error, json: any) {
+        if (exception.name === "RavenTimeoutException") {
+            (exception as any).failImmediately = !!json.FailImmediately;
+        }
+    }
+
     private static _getConflictError(schema: ExceptionSchema, json: string) {
         if (schema.type.includes("DocumentConflictException")) {
             return getError("DocumentConflictException", schema.message, null, { json });

src/Http/NodeSelector.ts

@@ -15,12 +15,22 @@ class NodeSelectorState {
     public fastestRecords: number[];
     public fastest: number;
     public speedTestMode = 1;
+    public unlikelyEveryoneFaultedChoiceIndex: number;
 
     constructor(topology: Topology) {
         this.topology = topology;
         this.nodes = topology.nodes;
         this.failures = ArrayUtil.range(topology.nodes.length, () => 0);
         this.fastestRecords = ArrayUtil.range(topology.nodes.length, () => 0);
+        this.unlikelyEveryoneFaultedChoiceIndex = 0;
+    }
+
+    public getNodeWhenEveryoneMarkedAsFaulted(): CurrentIndexAndNode {
+        const index = this.unlikelyEveryoneFaultedChoiceIndex;
+        this.unlikelyEveryoneFaultedChoiceIndex = (this.unlikelyEveryoneFaultedChoiceIndex + 1) % this.nodes.length;
+
+
+        return new CurrentIndexAndNode(index, this.nodes[index]);
     }
 }
 
@@ -91,18 +101,11 @@ export class NodeSelector {
 
     public getRequestedNode(nodeTag: string): CurrentIndexAndNode {
         const state = this._state;
-
-        const stateFailures = state.failures;
         const serverNodes = state.nodes;
-        const len = Math.min(serverNodes.length, stateFailures.length);
 
-        for (let i = 0; i < len; i++) {
+        for (let i = 0; i < serverNodes.length; i++) {
             if (serverNodes[i].clusterTag === nodeTag) {
-                if (stateFailures[i] === 0 && !StringUtil.isNullOrEmpty(serverNodes[i].url)) {
-                    return new CurrentIndexAndNode(i, serverNodes[i]);
-                }
-
-                throwError("RequestedNodeUnavailableException", "Requested node " + nodeTag + " currently unavailable, please try again later.");
+                return new CurrentIndexAndNode(i, serverNodes[i]);
             }
         }
 
@@ -113,6 +116,10 @@ export class NodeSelector {
         throwError("RequestedNodeUnavailableException", "Could not find requested node " + nodeTag);
     }
 
+    public nodeIsAvailable(index: number) {
+        return this._state.failures[index] === 0;
+    }
+
     public getPreferredNode(): CurrentIndexAndNode {
         const state = this._state;
         return NodeSelector.getPreferredNodeInternal(state);
@@ -124,7 +131,7 @@ export class NodeSelector {
         const len = Math.min(serverNodes.length, stateFailures.length);
 
         for (let i = 0; i < len; i++) {
-            if (stateFailures[i] === 0 && serverNodes[i].url) {
+            if (stateFailures[i] === 0) {
                 return new CurrentIndexAndNode(i, serverNodes[i]);
             }
         }
@@ -144,13 +151,13 @@ export class NodeSelector {
     }
 
     private static _unlikelyEveryoneFaultedChoice(state: NodeSelectorState): CurrentIndexAndNode {
-        // if there are all marked as failed, we'll chose the first
+        // if there are all marked as failed, we'll choose the next (the one in CurrentNodeIndex)
         // one so the user will get an error (or recover :-) );
         if (state.nodes.length === 0) {
             throwError("DatabaseDoesNotExistException", "There are no nodes in the topology at all.");
         }
 
-        return new CurrentIndexAndNode(0, state.nodes[0]);
+        return state.getNodeWhenEveryoneMarkedAsFaulted();
     }
 
     public getFastestNode(): CurrentIndexAndNode {

src/Http/RequestExecutor.ts

@@ -403,7 +403,7 @@ export class RequestExecutor implements IDisposable {
 
         // this is just to get rid of unhandled rejection, we're handling it later on
         executor._firstTopologyUpdatePromise.catch(TypeUtil.NOOP);
-        
+
         return executor;
     }
 
@@ -1464,7 +1464,11 @@ export class RequestExecutor implements IDisposable {
             command.failedNodes = new Map();
         }
 
-        command.failedNodes.set(chosenNode, RequestExecutor._readExceptionFromServer(req, response, body, error));
+        const exception = RequestExecutor._readExceptionFromServer(req, response, body, error);
+        if (exception.name === "RavenTimeoutException" && (exception as any).failImmediately) {
+            throw exception;
+        }
+        command.failedNodes.set(chosenNode, exception);
 
         if (nodeIndex === null) {
             return false;
@@ -1817,10 +1821,16 @@ export class RequestExecutor implements IDisposable {
         this._disposeAllFailedNodesTimers();
     }
 
-    public async getRequestedNode(nodeTag: string): Promise<CurrentIndexAndNode> {
+    public async getRequestedNode(nodeTag: string, throwIfContainsFailures = false): Promise<CurrentIndexAndNode> {
         await this._ensureNodeSelector();
 
-        return this._nodeSelector.getRequestedNode(nodeTag);
+        const currentIndexAndNode = this._nodeSelector.getRequestedNode(nodeTag);
+
+        if (throwIfContainsFailures && !this._nodeSelector.nodeIsAvailable(currentIndexAndNode.currentIndex)) {
+            throwError("RequestedNodeUnavailableException", "Requested node " + nodeTag + " currently unavailable, please try again later.");
+        }
+
+        return currentIndexAndNode;
     }
 
     public async getPreferredNode(): Promise<CurrentIndexAndNode> {

src/ServerWide/Operations/Certificates/CertificateMetadata.ts

@@ -6,8 +6,9 @@ export interface CertificateMetadata {
     securityClearance: SecurityClearance;
     thumbprint: string;
     notAfter: Date;
+    notBefore: Date;
     permissions?: Record<string, DatabaseAccess>;
     collectionSecondaryKeys?: string[];
     collectionPrimaryKey?: string;
     publicKeyPinningHash: string;
-}
+}

src/ServerWide/Operations/Certificates/GetCertificateMetadataOperation.ts

@@ -65,11 +65,12 @@ class GetCertificateMetadataCommand extends RavenCommand<CertificateMetadata> {
         const dateUtil = this._conventions.dateUtil;
 
         const resultsMapped: CertificateMetadata[] = response.results.map(cert => {
-            const { notAfter } = cert;
+            const { notAfter, notBefore } = cert;
 
             return {
                 ...cert,
-                notAfter: dateUtil.parse(notAfter)
+                notAfter: dateUtil.parse(notAfter),
+                notBefore: dateUtil.parse(notBefore)
             }
         })
 

src/ServerWide/Operations/Certificates/GetCertificateOperation.ts

@@ -63,7 +63,8 @@ class GetCertificateCommand extends RavenCommand<CertificateDefinition> {
         const results = await this._defaultPipeline(_ => body = _).process(bodyStream);
         const mapped = this._conventions.objectMapper.fromObjectLiteral<{ results: CertificateDefinition[] }>(results, {
             nestedTypes: {
-                "results[].notAfter": "date"
+                "results[].notAfter": "date",
+                "results[].notBefore": "date"
             }
         }).results;
 

src/ServerWide/Operations/Certificates/GetCertificatesMetadataOperation.ts

@@ -63,10 +63,11 @@ class GetCertificatesMetadataCommand extends RavenCommand<CertificateMetadata[]>
         const results = await this._defaultPipeline(_ => body = _).process(bodyStream);
         this.result = this._conventions.objectMapper.fromObjectLiteral<{ results: CertificateMetadata[] }>(results, {
             nestedTypes: {
-                "results[].notAfter": "date"
+                "results[].notAfter": "date",
+                "results[].notBefore": "date",
             }
         }).results;
 
         return body;
     }
-}
+}

src/ServerWide/Operations/Certificates/GetCertificatesOperation.ts

@@ -60,7 +60,8 @@ class GetCertificatesCommand extends RavenCommand<CertificateDefinition[]> {
         const results = await this._defaultPipeline(_ => body = _).process(bodyStream);
         this.result = this._conventions.objectMapper.fromObjectLiteral<{ results: CertificateDefinition[] }>(results, {
             nestedTypes: {
-                "results[].notAfter": "date"
+                "results[].notAfter": "date",
+                "results[].notBefore": "date"
             }
         }).results;
         return body;