Merge pull request #42684 from MicrosoftDocs/repo_sync_working_branch

Confirm merge from repo_sync_working_branch to master to sync with https://github.com/Microsoft/azure-docs (branch master)

Author: huypub

articles/cognitive-services/video-indexer/video-indexer-use-apis.md

@@ -50,9 +50,13 @@ Once you subscribed to the Authorization API, you will be able to obtain access
 
 Each call to the Operations API should be associated with an access token, matching the authorization scope of the call.
 
-- User level -  user level access tokens let you perform operations on the user level. For example,  get associated accounts.
-- Account level – account level access tokens let you perform operations on the account level. for example, Upload video, list all videos, create a language model, etc.
-- Video level – video level access tokens let you perform operations on specific videos. for example, get video insights, download captions, get widgets, etc. 
+- User level -  user level access tokens let you perform operations on the **user** level. For example, get associated accounts.
+- Account level – account level access tokens let you perform operations on the **account** level or the **video** level. For example, Upload video, list all videos, get video insights, etc.
+- Video level – video level access tokens let you perform operations on a specific **video**. For example, get video insights, download captions, get widgets, etc. 
+
+You can control whether these tokens are readonly or they allow editing by specifying **allowEdit=true/false**.
+
+For most server-to-server scenarios, you will probably use the same **account** token since it covers both **account** operations and **video** operations. However, if you are planning to make client side calls to Video Indexer (e.g. from javascript), you would want to use a **video** access token, to prevent clients from getting access to the entire account. That is also the reason that when embedding VideoIndexer client code in your client (e.g. using **Get Insights Widget** or **Get Player Widget**) you must provide a **video** access token.
 
 To make things easier, you can use the **Authorization** API > **GetAccounts** to get your accounts without obtaining a user token first. You can also ask to get the accounts with valid tokens, enabling you to skip an additional call to get an account token.
 

articles/cosmos-db/sql-api-nodejs-get-started.md

@@ -15,15 +15,14 @@ ms.author: sngun
 
 ---
 # Node.js tutorial: Use the SQL API in Azure Cosmos DB to create a Node.js console application
+
 > [!div class="op_single_selector"]
 > * [.NET](sql-api-get-started.md)
 > * [.NET Core](sql-api-dotnetcore-get-started.md)
 > * [Node.js for MongoDB](mongodb-samples.md)
 > * [Node.js](sql-api-nodejs-get-started.md)
 > * [Java](sql-api-java-get-started.md)
 > * [C++](sql-api-cpp-get-started.md)
->  
-> 
 
 Welcome to the Node.js tutorial for the Azure Cosmos DB Node.js SDK! After following this tutorial, you'll have a console application that creates and queries Azure Cosmos DB resources.
 
@@ -46,6 +45,7 @@ After you've completed the Node.js tutorial, please use the voting buttons at th
 Now let's get started!
 
 ## Prerequisites for the Node.js tutorial
+
 Please make sure you have the following:
 
 * An active Azure account. If you don't have one, you can sign up for a [Free Azure Trial](https://azure.microsoft.com/pricing/free-trial/). 
@@ -55,11 +55,13 @@ Please make sure you have the following:
 * [Node.js](https://nodejs.org/) version v0.10.29 or higher.
 
 ## Step 1: Create an Azure Cosmos DB account
+
 Let's create an Azure Cosmos DB account. If you already have an account you want to use, you can skip ahead to [Set up your Node.js application](#SetupNode). If you are using the Azure Cosmos DB Emulator, please follow the steps at [Azure Cosmos DB Emulator](local-emulator.md) to setup the emulator and skip ahead to [Set up your Node.js application](#SetupNode).
 
 [!INCLUDE [cosmos-db-create-dbaccount](../../includes/cosmos-db-create-dbaccount.md)]
 
 ## <a id="SetupNode"></a>Step 2: Set up your Node.js application
+
 1. Open your favorite terminal.
 2. Locate the folder or directory where you'd like to save your Node.js application.
 3. Create two empty JavaScript files with the following commands:
@@ -75,6 +77,7 @@ Let's create an Azure Cosmos DB account. If you already have an account you want
 Great! Now that you've finished setting up, let's start writing some code.
 
 ## <a id="Config"></a>Step 3: Set your app's configurations
+
 Open ```config.js``` in your favorite text editor.
 
 Then, copy and paste the code snippet below and set properties ```config.endpoint``` and ```config.primaryKey``` to your Azure Cosmos DB endpoint uri and primary key. Both these configurations can be found in the [Azure portal](https://portal.azure.com).
@@ -158,7 +161,6 @@ Copy and paste the ```database id```, ```collection id```, and ```JSON documents
         }
     };
 
-
 The database, collection, and document definitions will act as your Azure Cosmos DB ```database id```, ```collection id```, and documents' data.
 
 Finally, export your ```config``` object, so that you can reference it within the ```app.js``` file.
@@ -172,50 +174,49 @@ Finally, export your ```config``` object, so that you can reference it within th
     module.exports = config;
 
 ## <a id="Connect"></a> Step 4: Connect to an Azure Cosmos DB account
+
 Open your empty ```app.js``` file in the text editor. Copy and paste the code below to import the ```documentdb``` module and your newly created ```config``` module.
 
     // ADD THIS PART TO YOUR CODE
     "use strict";
 
     var documentClient = require("documentdb").DocumentClient;
+    const uriFactory = require('documentdb').UriFactory;
     var config = require("./config");
-    var url = require('url');
 
 Copy and paste the code to use the previously saved ```config.endpoint``` and ```config.primaryKey``` to create a new DocumentClient.
 
     var config = require("./config");
-    var url = require('url');
 
     // ADD THIS PART TO YOUR CODE
     var client = new documentClient(config.endpoint, { "masterKey": config.primaryKey });
 
 Now that you have the code to initialize the Azure Cosmos DB client, let's take a look at working with Azure Cosmos DB resources.
 
 ## Step 5: Create a Node database
-Copy and paste the code below to set the HTTP status for Not Found, the database url, and the collection url. These urls are how the Azure Cosmos DB client will find the right database and collection.
+
+Copy and paste the code below to set the HTTP status for Not Found, the database id, and the collection id. These ids are how the Azure Cosmos DB client will find the right database and collection.
 
     var client = new documentClient(config.endpoint, { "masterKey": config.primaryKey });
 
     // ADD THIS PART TO YOUR CODE
     var HttpStatusCodes = { NOTFOUND: 404 };
-    var databaseUrl = `dbs/${config.database.id}`;
-    var collectionUrl = `${databaseUrl}/colls/${config.collection.id}`;
+    var databaseId = config.database.id;
+    var collectionId = config.collection.id;
 
 A [database](sql-api-resources.md#databases) can be created by using the [createDatabase](https://azure.github.io/azure-documentdb-node/DocumentClient.html) function of the **DocumentClient** class. A database is the logical container of document storage partitioned across collections.
 
-Copy and paste the **getDatabase** function for creating your new database in the app.js file with the ```id``` specified in the ```config``` object. The function will check if the database with the same ```FamilyRegistry``` id does not already exist. If it does exist, we'll return that database instead of creating a new one.
-
-    var collectionUrl = `${databaseUrl}/colls/${config.collection.id}`;
+Copy and paste the **getDatabase** function for creating your new database in the app.js file with the ```databaseId``` specified from the ```config``` object. The function will check if the database with the same ```FamilyRegistry``` id does not already exist. If it does exist, we'll return that database instead of creating a new one.
 
     // ADD THIS PART TO YOUR CODE
     function getDatabase() {
-        console.log(`Getting database:\n${config.database.id}\n`);
-
+        console.log(`Getting database:\n${databaseId}\n`);
+        let databaseUrl = uriFactory.createDatabaseUri(databaseId);
         return new Promise((resolve, reject) => {
             client.readDatabase(databaseUrl, (err, result) => {
                 if (err) {
                     if (err.code == HttpStatusCodes.NOTFOUND) {
-                        client.createDatabase(config.database, (err, created) => {
+                        client.createDatabase({ id: databaseId }, (err, created) => {
                             if (err) reject(err)
                             else resolve(created);
                         });
@@ -227,7 +228,7 @@ Copy and paste the **getDatabase** function for creating your new database in th
                 }
             });
         });
-    }
+    };
 
 Copy and paste the code below where you set the **getDatabase** function to add the helper function **exit** that will print the exit message and the call to **getDatabase** function.
 
@@ -245,7 +246,7 @@ Copy and paste the code below where you set the **getDatabase** function to add
         process.stdin.setRawMode(true);
         process.stdin.resume();
         process.stdin.on('data', process.exit.bind(process, 0));
-    }
+    };
 
     getDatabase()
     .then(() => { exit(`Completed successfully`); })
@@ -256,31 +257,31 @@ In your terminal, locate your ```app.js``` file and run the command: ```node app
 Congratulations! You have successfully created an Azure Cosmos DB database.
 
 ## <a id="CreateColl"></a>Step 6: Create a collection
+
 > [!WARNING]
 > **createCollection** will create a new collection, which has pricing implications. For more details, please visit our [pricing page](https://azure.microsoft.com/pricing/details/cosmos-db/).
-> 
-> 
 
 A [collection](sql-api-resources.md#collections) can be created by using the [createCollection](https://azure.github.io/azure-documentdb-node/DocumentClient.html) function of the **DocumentClient** class. A collection is a container of JSON documents and associated JavaScript application logic.
 
-Copy and paste the **getCollection** function underneath the **getDatabase** function in the app.js file to create your new collection with the ```id``` specified in the ```config``` object. Again, we'll check to make sure a collection with the same ```FamilyCollection``` id does not already exist. If it does exist, we'll return that collection instead of creating a new one.
+Copy and paste the **getCollection** function underneath the **getDatabase** function in the app.js file to create your new collection with the ```collectionId``` specified from the ```config``` object. Again, we'll check to make sure a collection with the same ```FamilyCollection``` id does not already exist. If it does exist, we'll return that collection instead of creating a new one.
 
                 } else {
                     resolve(result);
                 }
             });
         });
-    }
+    };
 
     // ADD THIS PART TO YOUR CODE
     function getCollection() {
-        console.log(`Getting collection:\n${config.collection.id}\n`);
-
+        console.log(`Getting collection:\n${collectionId}\n`);
+        let collectionUrl = uriFactory.createDocumentCollectionUri(databaseId, collectionId);
         return new Promise((resolve, reject) => {
             client.readCollection(collectionUrl, (err, result) => {
                 if (err) {
                     if (err.code == HttpStatusCodes.NOTFOUND) {
-                        client.createCollection(databaseUrl, config.collection, { offerThroughput: 400 }, (err, created) => {
+                        let databaseUrl = uriFactory.createDatabaseUri(databaseId);
+                        client.createCollection(databaseUrl, { id: collectionId }, { offerThroughput: 400 }, (err, created) => {
                             if (err) reject(err)
                             else resolve(created);
                         });
@@ -292,7 +293,7 @@ Copy and paste the **getCollection** function underneath the **getDatabase** fun
                 }
             });
         });
-    }
+    };
 
 Copy and paste the code below the call to **getDatabase** to execute the **getCollection** function.
 
@@ -310,6 +311,7 @@ In your terminal, locate your ```app.js``` file and run the command: ```node app
 Congratulations! You have successfully created an Azure Cosmos DB collection.
 
 ## <a id="CreateDoc"></a>Step 7: Create a document
+
 A [document](sql-api-resources.md#documents) can be created by using the [createDocument](https://azure.github.io/azure-documentdb-node/DocumentClient.html) function of the **DocumentClient** class. Documents are user defined (arbitrary) JSON content. You can now insert a document into Azure Cosmos DB.
 
 Copy and paste the **getFamilyDocument** function underneath the **getCollection** function for creating the documents containing the JSON data saved in the ```config``` object. Again, we'll check to make sure a document with the same id does not already exist.
@@ -319,17 +321,17 @@ Copy and paste the **getFamilyDocument** function underneath the **getCollection
                 }
             });
         });
-    }
+    };
 
     // ADD THIS PART TO YOUR CODE
     function getFamilyDocument(document) {
-        let documentUrl = `${collectionUrl}/docs/${document.id}`;
         console.log(`Getting document:\n${document.id}\n`);
-
+        let documentUrl = uriFactory.createDocumentUri(databaseId, collectionId, document.id);
         return new Promise((resolve, reject) => {
             client.readDocument(documentUrl, (err, result) => {
                 if (err) {
                     if (err.code == HttpStatusCodes.NOTFOUND) {
+                        let collectionUrl = uriFactory.createDocumentCollectionUri(databaseId, collectionId);
                         client.createDocument(collectionUrl, document, (err, created) => {
                             if (err) reject(err)
                             else resolve(created);
@@ -373,12 +375,12 @@ Copy and paste the **queryCollection** function underneath the **getFamilyDocume
                 }
             });
         });
-    }
+    };
 
     // ADD THIS PART TO YOUR CODE
     function queryCollection() {
-        console.log(`Querying collection through index:\n${config.collection.id}`);
-
+        console.log(`Querying collection through index:\n${collectionId}`);
+        let collectionUrl = uriFactory.createDocumentCollectionUri(databaseId, collectionId);
         return new Promise((resolve, reject) => {
             client.queryDocuments(
                 collectionUrl,
@@ -397,7 +399,6 @@ Copy and paste the **queryCollection** function underneath the **getFamilyDocume
         });
     };
 
-
 The following diagram illustrates how the Azure Cosmos DB SQL query syntax is called against the collection you created.
 
 ![Node.js tutorial - Diagram illustrating the scope and meaning of the query - Node database](./media/sql-api-nodejs-get-started/node-js-tutorial-collection-documents.png)
@@ -431,14 +432,13 @@ Copy and paste the **replaceFamilyDocument** function underneath the **queryColl
                 }
             });
         });
-    }
+    };
 
     // ADD THIS PART TO YOUR CODE
     function replaceFamilyDocument(document) {
-        let documentUrl = `${collectionUrl}/docs/${document.id}`;
         console.log(`Replacing document:\n${document.id}\n`);
+        let documentUrl = uriFactory.createDocumentUri(databaseId, collectionId, document.id);
         document.children[0].grade = 6;
-
         return new Promise((resolve, reject) => {
             client.replaceDocument(documentUrl, document, (err, result) => {
                 if (err) reject(err);
@@ -468,6 +468,7 @@ In your terminal, locate your ```app.js``` file and run the command: ```node app
 Congratulations! You have successfully replaced an Azure Cosmos DB document.
 
 ## <a id="DeleteDocument"></a>Step 10: Delete a document
+
 Azure Cosmos DB supports deleting JSON documents.
 
 Copy and paste the **deleteFamilyDocument** function underneath the **replaceFamilyDocument** function.
@@ -481,9 +482,8 @@ Copy and paste the **deleteFamilyDocument** function underneath the **replaceFam
 
     // ADD THIS PART TO YOUR CODE
     function deleteFamilyDocument(document) {
-        let documentUrl = `${collectionUrl}/docs/${document.id}`;
         console.log(`Deleting document:\n${document.id}\n`);
-
+        let documentUrl = uriFactory.createDocumentUri(databaseId, collectionId, document.id);
         return new Promise((resolve, reject) => {
             client.deleteDocument(documentUrl, (err, result) => {
                 if (err) reject(err);
@@ -512,6 +512,7 @@ In your terminal, locate your ```app.js``` file and run the command: ```node app
 Congratulations! You have successfully deleted an Azure Cosmos DB document.
 
 ## <a id="DeleteDatabase"></a>Step 11: Delete the Node database
+
 Deleting the created database will remove the database and all children resources (collections, documents, etc.).
 
 Copy and paste the **cleanup** function underneath the **deleteFamilyDocument** function to remove the database and all the children resources.
@@ -525,15 +526,15 @@ Copy and paste the **cleanup** function underneath the **deleteFamilyDocument**
 
     // ADD THIS PART TO YOUR CODE
     function cleanup() {
-        console.log(`Cleaning up by deleting database ${config.database.id}`);
-
+        console.log(`Cleaning up by deleting database ${databaseId}`);
+        let databaseUrl = uriFactory.createDatabaseUri(databaseId);
         return new Promise((resolve, reject) => {
             client.deleteDatabase(databaseUrl, (err) => {
                 if (err) reject(err)
                 else resolve(null);
             });
         });
-    }
+    };
 
 Copy and paste the code below the call to **deleteFamilyDocument** to execute the **cleanup** function.
 
@@ -547,6 +548,7 @@ Copy and paste the code below the call to **deleteFamilyDocument** to execute th
     .catch((error) => { exit(`Completed with error ${JSON.stringify(error)}`) });
 
 ## <a id="Run"></a>Step 12: Run your Node.js application all together!
+
 Altogether, the sequence for calling your functions should look like this:
 
     getDatabase()
@@ -598,6 +600,7 @@ You should see the output of your get started app. The output should match the e
 Congratulations! You've created you've completed the Node.js tutorial and have your first Azure Cosmos DB console application!
 
 ## <a id="GetSolution"></a>Get the complete Node.js tutorial solution
+
 If you didn't have time to complete the steps in this tutorial, or just want to download the code, you can get it from [GitHub](https://github.com/Azure-Samples/documentdb-node-getting-started).
 
 To run the GetStarted solution that contains all the samples in this article, you will need the following:

articles/event-hubs/event-hubs-availability-and-consistency.md

@@ -23,7 +23,7 @@ ms.author: sethm
 ## Overview
 Azure Event Hubs uses a [partitioning model](event-hubs-features.md#partitions) to improve availability and parallelization within a single event hub. For example, if an event hub has four partitions, and one of those partitions is moved from one server to another in a load balancing operation, you can still send and receive from three other partitions. Additionally, having more partitions enables you to have more concurrent readers processing your data, improving your aggregate throughput. Understanding the implications of partitioning and ordering in a distributed system is a critical aspect of solution design.
 
-To help explain the trade-off between ordering and availability, see the [CAP theorem](https://en.wikipedia.org/wiki/CAP_theorem), also known as Brewer's theorem. This theorem discusses the choice between consistency, availability, and partition tolerance.
+To help explain the trade-off between ordering and availability, see the [CAP theorem](https://en.wikipedia.org/wiki/CAP_theorem), also known as Brewer's theorem. This theorem discusses the choice between consistency, availability, and partition tolerance. It states that for the systems partitioned by network there is always tradeoff between consistency and availability.
 
 Brewer's theorem defines consistency and availability as follows:
 * Partition tolerance: the ability of a data processing system to continue processing data even if a partition failure occurs.