sync with java: 53f2b0e43ad67f9cdd0e3908836d9d3baea17395

Author: ml054

src/Documents/BulkInsertOperation.ts

@@ -31,6 +31,7 @@ export class BulkInsertOperation {
 
     private _first: boolean = true;
     private _operationId = -1;
+    private _nodeTag: string;
 
     private _useCompression: boolean = false;
 
@@ -45,6 +46,9 @@ export class BulkInsertOperation {
 
     public constructor(database: string, store: IDocumentStore) {
         this._conventions = store.conventions;
+        if (StringUtil.isNullOrEmpty(database)) {
+            this._throwNoDatabase();
+        }
         this._requestExecutor = store.getRequestExecutor(database);
 
         this._generateEntityIdOnTheClient = new GenerateEntityIdOnTheClient(this._requestExecutor.conventions,
@@ -65,8 +69,23 @@ export class BulkInsertOperation {
     }
 
     private async _throwBulkInsertAborted(e: Error) {
-        const error = await this._getExceptionFromOperation();
-        throwError("BulkInsertAbortedException", "Failed to execute bulk insert", error || e);
+        let errorFromServer: Error;
+        try {
+            errorFromServer = await this._getExceptionFromOperation();
+        } catch (ee) {
+            // server is probably down, will propagate the original exception
+        }
+
+        if (errorFromServer) {
+            throw errorFromServer;
+        }
+
+        throwError("BulkInsertAbortedException", "Failed to execute bulk insert", e);
+    }
+
+    private _throwNoDatabase(): void {
+        throwError("InvalidOperationException", "Cannot start bulk insert operation without specifying a name of a database to operate on."
+            + "Database name can be passed as an argument when bulk insert is being created or default database can be defined using 'DocumentStore.setDatabase' method.");
     }
 
     private async _waitForId(): Promise<void> {
@@ -77,6 +96,7 @@ export class BulkInsertOperation {
         const bulkInsertGetIdRequest = new GetNextOperationIdCommand();
         await this._requestExecutor.execute(bulkInsertGetIdRequest);
         this._operationId = bulkInsertGetIdRequest.result;
+        this._nodeTag = bulkInsertGetIdRequest.nodeTag;
     }
 
     private static _typeCheckStoreArgs(
@@ -242,7 +262,7 @@ export class BulkInsertOperation {
     }
 
     private async _getExceptionFromOperation(): Promise<Error> {
-        const stateRequest = new GetOperationStateCommand(this._conventions, this._operationId);
+        const stateRequest = new GetOperationStateCommand(this._conventions, this._operationId, this._nodeTag);
         await this._requestExecutor.execute(stateRequest);
         if (!stateRequest.result) {
             return null;
@@ -263,7 +283,8 @@ export class BulkInsertOperation {
 
             this._requestBodyStream = new stream.PassThrough();
             const bulkCommand =
-                new BulkInsertCommand(this._operationId, this._requestBodyStream, this._useCompression);
+                new BulkInsertCommand(this._operationId, this._requestBodyStream, this._nodeTag);
+            bulkCommand.useCompression = this._useCompression;
 
             const bulkCommandPromise = this._requestExecutor.execute(bulkCommand);
 
@@ -298,7 +319,7 @@ export class BulkInsertOperation {
             await this._waitForId();
 
             try {
-                await this._requestExecutor.execute(new KillOperationCommand(this._operationId));
+                await this._requestExecutor.execute(new KillOperationCommand(this._operationId, this._nodeTag));
             } catch (err) {
                 const bulkInsertError = getError("BulkInsertAbortedException",
                     "Unable to kill bulk insert operation, because it was not found on the server.", err);
@@ -365,14 +386,14 @@ export class BulkInsertCommand extends RavenCommand<void> {
 
     private readonly _stream: stream.Readable;
     private readonly _id: number;
-    private _useCompression: boolean;
+    public useCompression: boolean;
 
-    public constructor(id: number, stream: stream.Readable, useCompression: boolean) {
+    public constructor(id: number, stream: stream.Readable, nodeTag: string) {
         super();
 
         this._stream = stream;
         this._id = id;
-        this._useCompression = useCompression;
+        this._selectedNodeTag = nodeTag;
     }
 
     public createRequest(node: ServerNode): HttpRequestParameters {

src/Documents/Commands/CreateSubscriptionCommand.ts

@@ -7,6 +7,7 @@ import { DocumentConventions } from "../Conventions/DocumentConventions";
 import { ServerNode } from "../../Http/ServerNode";
 import { IRaftCommand } from "../../Http/IRaftCommand";
 import { RaftIdGenerator } from "../../Utility/RaftIdGenerator";
+import { throwError } from "../../Exceptions";
 
 export class CreateSubscriptionCommand extends RavenCommand<CreateSubscriptionResult> implements IRaftCommand {
     private readonly _conventions: DocumentConventions;
@@ -16,6 +17,9 @@ export class CreateSubscriptionCommand extends RavenCommand<CreateSubscriptionRe
     public constructor(conventions: DocumentConventions, options: SubscriptionCreationOptions, id?: string) {
         super();
         this._conventions = conventions;
+        if (!options) {
+            throwError("InvalidArgumentException", "Options cannot be null");
+        }
         this._options = options;
         this._id = id;
     }

src/Documents/Commands/DropSubscriptionConnectionCommand.ts

@@ -1,6 +1,7 @@
 import { RavenCommand } from "../../Http/RavenCommand";
 import { HttpRequestParameters } from "../../Primitives/Http";
 import { ServerNode } from "../../Http/ServerNode";
+import { StringUtil } from "../../Utility/StringUtil";
 
 export class DropSubscriptionConnectionCommand extends RavenCommand<void> {
 
@@ -12,7 +13,11 @@ export class DropSubscriptionConnectionCommand extends RavenCommand<void> {
     }
 
     public createRequest(node: ServerNode): HttpRequestParameters {
-        const uri = node.url + "/databases/" + node.database + "/subscriptions/drop?name=" + this._name;
+        let uri = node.url + "/databases/" + node.database + "/subscriptions/drop";
+
+        if (!StringUtil.isNullOrEmpty(this._name)) {
+            uri += "?name=" + encodeURIComponent(this._name);
+        }
 
         return {
             method: "POST",

src/Documents/Commands/GetDocumentsCommand.ts

@@ -194,6 +194,7 @@ export class GetDocumentsCommand extends RavenCommand<GetDocumentsResult> {
         // if it is too big, we fallback to POST (note that means that we can't use the HTTP cache any longer)
         // we are fine with that, requests to load > 1024 items are going to be rare
         const isGet: boolean = Array.from(uniqueIds)
+            .filter(x => x)
             .map(x => x.length)
             .reduce((result, next) => result + next, 0) < 1024;
 

src/Documents/Commands/GetNextOperationIdCommand.ts

@@ -5,6 +5,12 @@ import * as stream from "readable-stream";
 
 export class GetNextOperationIdCommand extends RavenCommand<number> {
 
+    private _nodeTag: string;
+
+    public get nodeTag(): string {
+        return this._nodeTag;
+    }
+
     public get isReadRequest(): boolean {
         return false; // disable caching
     }
@@ -22,6 +28,11 @@ export class GetNextOperationIdCommand extends RavenCommand<number> {
                 if (typeof id !== "undefined") {
                     this.result = id;
                 }
+
+                const nodeTag = results["nodeTag"];
+                if (nodeTag) {
+                    this._nodeTag = nodeTag;
+                }
             });
         return body;
     }

src/Documents/Commands/KillOperationCommand.ts

@@ -7,13 +7,19 @@ export class KillOperationCommand extends RavenCommand<void> {
 
     private readonly _id: number;
 
-    public constructor(id: number) {
+    public constructor(id: number)
+    public constructor(id: number, nodeTag: string)
+    public constructor(id: number, nodeTag?: string) {
         super();
 
         if (!id) {
             throwError("InvalidArgumentException", "Id cannot be null.");
         }
         this._id = id;
+
+        if (nodeTag) {
+            this._selectedNodeTag = nodeTag;
+        }
     }
 
     public get isReadRequest(): boolean {

src/Documents/Commands/MultiGet/MultiGetCommand.ts

@@ -8,6 +8,7 @@ import { ServerNode } from "../../../Http/ServerNode";
 import { StatusCodes } from "../../../Http/StatusCode";
 import { getEtagHeader } from "../../../Utility/HttpUtil";
 import { DocumentConventions } from "../../Conventions/DocumentConventions";
+import { throwError } from "../../../Exceptions";
 
 export class MultiGetCommand extends RavenCommand<GetResponse[]> {
     private _cache: HttpCache;
@@ -17,6 +18,15 @@ export class MultiGetCommand extends RavenCommand<GetResponse[]> {
 
     public constructor(cache: HttpCache, conventions: DocumentConventions, commands: GetRequest[]) {
         super();
+
+        if (!cache) {
+            throwError("InvalidArgumentException", "Cache cannot be null");
+        }
+
+        if (!commands) {
+            throwError("InvalidArgumentException", "Commands cannot be null");
+        }
+
         this._cache = cache;
         this._commands = commands;
         this._conventions = conventions;

src/Documents/Operations/Backups/RestoreBackupOperation.ts

@@ -5,6 +5,7 @@ import { DocumentConventions } from "../../Conventions/DocumentConventions";
 import { RavenCommand } from "../../../Http/RavenCommand";
 import { ServerNode } from "../../../Http/ServerNode";
 import { RestoreBackupConfigurationBase } from "./RestoreBackupConfigurationBase";
+import { throwError } from "../../../Exceptions";
 
 export class RestoreBackupOperation implements IServerOperation<OperationIdResult> {
     private readonly _restoreConfiguration: RestoreBackupConfigurationBase;
@@ -16,7 +17,7 @@ export class RestoreBackupOperation implements IServerOperation<OperationIdResul
     }
 
     public getCommand(conventions: DocumentConventions): RavenCommand<OperationIdResult> {
-        return new RestoreBackupCommand(conventions, this._restoreConfiguration, this._nodeTag);
+        return new RestoreBackupCommand(this._restoreConfiguration, this._nodeTag);
     }
 
     public get resultType(): OperationResultType {
@@ -31,9 +32,13 @@ export class RestoreBackupOperation implements IServerOperation<OperationIdResul
 class RestoreBackupCommand extends RavenCommand<OperationIdResult> {
     private readonly _restoreConfiguration: RestoreBackupConfigurationBase;
 
-    public constructor(conventions: DocumentConventions, restoreConfiguration: RestoreBackupConfigurationBase, nodeTag: string) {
+    public constructor(restoreConfiguration: RestoreBackupConfigurationBase, nodeTag: string) {
         super();
 
+        if (!restoreConfiguration) {
+            throwError("InvalidArgumentException", "RestoreConfiguration cannot be null");
+        }
+
         this._restoreConfiguration = restoreConfiguration;
         this._selectedNodeTag = nodeTag;
     }

src/Documents/Operations/Backups/UpdatePeriodicBackupOperation.ts

@@ -21,18 +21,16 @@ export class UpdatePeriodicBackupOperation implements IMaintenanceOperation<Upda
     }
 
     public getCommand(conventions: DocumentConventions): RavenCommand<UpdatePeriodicBackupOperationResult> {
-        return new UpdatePeriodicBackupCommand(conventions, this._configuration);
+        return new UpdatePeriodicBackupCommand(this._configuration);
     }
 }
 
 class UpdatePeriodicBackupCommand extends RavenCommand<UpdatePeriodicBackupOperationResult> implements IRaftCommand {
-    private readonly _conventions: DocumentConventions;
     private readonly _configuration: PeriodicBackupConfiguration;
 
-    public constructor(conventions: DocumentConventions, configuration: PeriodicBackupConfiguration) {
+    public constructor(configuration: PeriodicBackupConfiguration) {
         super();
 
-        this._conventions = conventions;
         this._configuration = configuration;
     }
 

src/Documents/Operations/CompareExchange/GetCompareExchangeValuesOperation.ts

@@ -112,12 +112,12 @@ export class GetCompareExchangeValuesCommand<T> extends RavenCommand<{ [key: str
 
             if (this._operation.start) {
                 pathBuilder.append("&start=")
-                    .append(this._operation.start);
+                    .append(this._operation.start.toString());
             }
 
             if (this._operation.pageSize) {
                 pathBuilder.append("&pageSize=")
-                    .append(this._operation.pageSize);
+                    .append(this._operation.pageSize.toString());
             }
         }