Added 2020-02-10 features. (#692)

* Added 2020-02-10 features.

* Resolved comments.

Author: katmsft

sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_directory_client.hpp

@@ -137,6 +137,27 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         bool Recursive,
         const DeleteDirectoryOptions& options = DeleteDirectoryOptions()) const;
 
+    /**
+     * @brief Sets POSIX access control rights on files and directories under given directory
+     * recursively.
+     * @param mode Mode PathSetAccessControlRecursiveMode::Set sets POSIX access control rights on
+     * files and directories, PathSetAccessControlRecursiveMode::Modify modifies one or more POSIX
+     * access control rights  that pre-exist on files and directories,
+     * PathSetAccessControlRecursiveMode::Remove removes one or more POSIX access control rights
+     * that were present earlier on files and directories
+     * @param acls Sets POSIX access control rights on files and directories. Each access control
+     * entry (ACE) consists of a scope, a type, a user or group identifier, and permissions.
+     * @param options Optional parameters to set an access control recursively to the resource the
+     * directory points to.
+     * @return Azure::Core::Response<SetDirectoryAccessControlRecursiveResult>
+     * @remark This request is sent to dfs endpoint.
+     */
+    Azure::Core::Response<SetDirectoryAccessControlRecursiveResult> SetAccessControlRecursive(
+        PathSetAccessControlRecursiveMode mode,
+        std::vector<Acl> acls,
+        const SetDirectoryAccessControlRecursiveOptions& options
+        = SetDirectoryAccessControlRecursiveOptions()) const;
+
   private:
     explicit DirectoryClient(
         Azure::Core::Http::Url dfsUri,

sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_options.hpp

@@ -647,6 +647,43 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     PathAccessConditions AccessConditions;
   };
 
+  /**
+   * @brief Optional parameters for PathClient::SetAccessControlRecursive
+   */
+  struct SetDirectoryAccessControlRecursiveOptions
+  {
+    /**
+     * @brief Context for cancelling long running operations.
+     */
+    Azure::Core::Context Context;
+
+    /**
+     * @brief When performing setAccessControlRecursive on a directory, the number of paths that
+     *        are processed with each invocation is limited.  If the number of paths to be processed
+     *        exceeds this limit, a continuation token is returned in this response header.  When a
+     *        continuation token is returned in the response, it must be specified in a subsequent
+     *        invocation of the setAccessControlRecursive operation to continue the
+     *        setAccessControlRecursive operation on the directory.
+     */
+    Azure::Core::Nullable<std::string> Continuation;
+
+    /**
+     * @brief It specifies the maximum number of files or directories on which the acl change will
+     *        be applied. If omitted or greater than 2,000, the request will process up to 2,000
+     *        items.
+     */
+    Azure::Core::Nullable<int32_t> MaxRecords;
+
+    /**
+     * @brief  Optional. Valid for "SetAccessControlRecursive" operation. If set to false, the
+     * operation will terminate quickly on encountering user errors (4XX). If true, the operation
+     * will ignore user errors and proceed with the operation on other sub-entities of the
+     * directory. Continuation token will only be returned when forceFlag is true in case of user
+     * errors. If not set the default value is false for this.
+     */
+    Azure::Core::Nullable<bool> ForceFlag;
+  };
+
   using CreateFileOptions = CreatePathOptions;
   using CreateDirectoryOptions = CreatePathOptions;
 

sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/datalake_responses.hpp

@@ -183,7 +183,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     Azure::Core::Nullable<std::string> Continuation;
   };
 
-  using DirectorySetAccessControlRecursiveInfo = PathSetAccessControlRecursiveResult;
+  using SetDirectoryAccessControlRecursiveResult = PathSetAccessControlRecursiveResult;
   using CreateDirectoryResult = CreatePathResult;
   using DeleteDirectoryResult = PathDeleteResult;
 

sdk/storage/azure-storage-files-datalake/inc/azure/storage/files/datalake/protocol/datalake_rest_client.hpp

@@ -196,4 +196,21 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
     return DataLakeRestClient::Path::Delete(
         m_dfsUri, *m_pipeline, options.Context, protocolLayerOptions);
   }
+
+  Azure::Core::Response<SetDirectoryAccessControlRecursiveResult>
+  DirectoryClient::SetAccessControlRecursive(
+      PathSetAccessControlRecursiveMode mode,
+      std::vector<Acl> acls,
+      const SetDirectoryAccessControlRecursiveOptions& options) const
+  {
+    DataLakeRestClient::Path::SetAccessControlRecursiveOptions protocolLayerOptions;
+    protocolLayerOptions.Mode = mode;
+    protocolLayerOptions.Continuation = options.Continuation;
+    protocolLayerOptions.MaxRecords = options.MaxRecords;
+    protocolLayerOptions.ForceFlag = options.ForceFlag;
+    protocolLayerOptions.Acl = Acl::SerializeAcls(acls);
+    return DataLakeRestClient::Path::SetAccessControlRecursive(
+        m_dfsUri, *m_pipeline, options.Context, protocolLayerOptions);
+  }
+
 }}}} // namespace Azure::Storage::Files::DataLake

sdk/storage/azure-storage-files-datalake/src/datalake_directory_client.cpp

@@ -105,8 +105,8 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
   {
     auto parsedConnectionString = Azure::Storage::Details::ParseConnectionString(connectionString);
     auto fileUri = std::move(parsedConnectionString.DataLakeServiceUri);
-    fileUri.AppendPath(fileSystemName, true);
-    fileUri.AppendPath(filePath, true);
+    fileUri.AppendPath(fileSystemName);
+    fileUri.AppendPath(filePath);
 
     if (parsedConnectionString.KeyCredential)
     {

sdk/storage/azure-storage-files-datalake/src/datalake_file_client.cpp

@@ -295,4 +295,42 @@ namespace Azure { namespace Storage { namespace Test {
     }
   }
 
+  TEST_F(DataLakeDirectoryClientTest, DirectorySetAccessControlRecursive)
+  {
+    // Setup directories.
+    auto rootDirectoryName = LowercaseRandomString();
+    auto directoryName1 = LowercaseRandomString();
+    auto directoryName2 = LowercaseRandomString();
+    auto rootDirectoryClient = m_fileSystemClient->GetDirectoryClient(rootDirectoryName);
+    rootDirectoryClient.Create();
+    auto directoryClient1
+        = m_fileSystemClient->GetDirectoryClient(rootDirectoryName + "/" + directoryName1);
+    directoryClient1.Create();
+    auto directoryClient2
+        = m_fileSystemClient->GetDirectoryClient(rootDirectoryName + "/" + directoryName2);
+    directoryClient2.Create();
+
+    {
+      // Set/Get Acls recursive works.
+      std::vector<Files::DataLake::Acl> acls = GetValidAcls();
+      EXPECT_NO_THROW(directoryClient1.SetAccessControl(acls));
+      EXPECT_NO_THROW(rootDirectoryClient.SetAccessControlRecursive(
+          Files::DataLake::PathSetAccessControlRecursiveMode::Modify, acls));
+      std::vector<Files::DataLake::Acl> resultAcls1;
+      std::vector<Files::DataLake::Acl> resultAcls2;
+      EXPECT_NO_THROW(resultAcls1 = directoryClient1.GetAccessControls()->Acls);
+      EXPECT_NO_THROW(resultAcls2 = directoryClient2.GetAccessControls()->Acls);
+      for (const auto& acl : resultAcls2)
+      {
+        auto iter = std::find_if(
+            resultAcls1.begin(), resultAcls1.end(), [&acl](const Files::DataLake::Acl& targetAcl) {
+              return (targetAcl.Type == acl.Type) && (targetAcl.Id == acl.Id)
+                  && (targetAcl.Scope == acl.Scope);
+            });
+        EXPECT_TRUE(iter != resultAcls1.end());
+        EXPECT_EQ(iter->Permissions, acl.Permissions);
+      }
+    }
+  }
+
 }}} // namespace Azure::Storage::Test