Beispiel #1
0
 /// <summary>
 /// Update a Big Data pool.
 /// </summary>
 /// <remarks>
 /// Patch a Big Data pool.
 /// </remarks>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='resourceGroupName'>
 /// The name of the resource group. The name is case insensitive.
 /// </param>
 /// <param name='workspaceName'>
 /// The name of the workspace.
 /// </param>
 /// <param name='bigDataPoolName'>
 /// Big Data pool name
 /// </param>
 /// <param name='bigDataPoolPatchInfo'>
 /// The updated Big Data pool properties
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <BigDataPoolResourceInfo> UpdateAsync(this IBigDataPoolsOperations operations, string resourceGroupName, string workspaceName, string bigDataPoolName, BigDataPoolPatchInfo bigDataPoolPatchInfo, CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.UpdateWithHttpMessagesAsync(resourceGroupName, workspaceName, bigDataPoolName, bigDataPoolPatchInfo, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
Beispiel #2
0
 /// <summary>
 /// Update a Big Data pool.
 /// </summary>
 /// <remarks>
 /// Patch a Big Data pool.
 /// </remarks>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='resourceGroupName'>
 /// The name of the resource group. The name is case insensitive.
 /// </param>
 /// <param name='workspaceName'>
 /// The name of the workspace.
 /// </param>
 /// <param name='bigDataPoolName'>
 /// Big Data pool name
 /// </param>
 /// <param name='bigDataPoolPatchInfo'>
 /// The updated Big Data pool properties
 /// </param>
 public static BigDataPoolResourceInfo Update(this IBigDataPoolsOperations operations, string resourceGroupName, string workspaceName, string bigDataPoolName, BigDataPoolPatchInfo bigDataPoolPatchInfo)
 {
     return(operations.UpdateAsync(resourceGroupName, workspaceName, bigDataPoolName, bigDataPoolPatchInfo).GetAwaiter().GetResult());
 }
Beispiel #3
0
        public void TestSparkPoolLifeCycle()
        {
            TestInitialize();

            // create workspace
            string workspaceName         = TestUtilities.GenerateName("synapsesdkworkspace");
            var    createWorkspaceParams = CommonData.PrepareWorkspaceCreateParams();
            var    workspaceCreate       = SynapseClient.Workspaces.CreateOrUpdate(CommonData.ResourceGroupName, workspaceName, createWorkspaceParams);

            Assert.Equal(CommonTestFixture.WorkspaceType, workspaceCreate.Type);
            Assert.Equal(workspaceName, workspaceCreate.Name);
            Assert.Equal(CommonData.Location, workspaceCreate.Location);

            for (int i = 0; i < 60; i++)
            {
                var workspaceGet = SynapseClient.Workspaces.Get(CommonData.ResourceGroupName, workspaceName);
                if (workspaceGet.ProvisioningState.Equals("Succeeded"))
                {
                    Assert.Equal(CommonTestFixture.WorkspaceType, workspaceGet.Type);
                    Assert.Equal(workspaceName, workspaceGet.Name);
                    Assert.Equal(CommonData.Location, workspaceGet.Location);
                    break;
                }

                Thread.Sleep(30000);
                Assert.True(i < 60, "Synapse Workspace is not in succeeded state even after 30 min.");
            }

            // create sparkpool unableautoscale
            string sparkpoolName            = TestUtilities.GenerateName("sparkpool");
            var    createSparkpoolParams    = CommonData.PrepareSparkpoolCreateParams(enableAutoScale: false, enableAutoPause: false);
            var    sparkpoolUnableAutoScale = SynapseClient.BigDataPools.CreateOrUpdate(CommonData.ResourceGroupName, workspaceName, sparkpoolName, createSparkpoolParams);

            Assert.Equal(CommonTestFixture.SparkpoolType, sparkpoolUnableAutoScale.Type);
            Assert.Equal(sparkpoolName, sparkpoolUnableAutoScale.Name);
            Assert.Equal(CommonData.Location, sparkpoolUnableAutoScale.Location);

            // get sparkpool
            for (int i = 0; i < 60; i++)
            {
                var sparkpoolGet = SynapseClient.BigDataPools.Get(CommonData.ResourceGroupName, workspaceName, sparkpoolName);
                if (sparkpoolGet.ProvisioningState.Equals("Succeeded"))
                {
                    Assert.Equal(CommonTestFixture.SparkpoolType, sparkpoolUnableAutoScale.Type);
                    Assert.Equal(sparkpoolName, sparkpoolUnableAutoScale.Name);
                    Assert.Equal(CommonData.Location, sparkpoolUnableAutoScale.Location);
                    break;
                }

                Thread.Sleep(30000);
                Assert.True(i < 60, "Synapse SparkPool is not in succeeded state even after 30 min.");
            }

            // update sparkpool
            Dictionary <string, string> tagsToUpdate = new Dictionary <string, string> {
                { "TestTag", "TestUpdate" }
            };
            BigDataPoolPatchInfo bigdataPoolPatchInfo = new BigDataPoolPatchInfo
            {
                Tags = tagsToUpdate
            };

            SynapseClient.BigDataPools.Update(CommonData.ResourceGroupName, workspaceName, sparkpoolName, bigdataPoolPatchInfo);
            var sparkpoolUpdate = SynapseClient.BigDataPools.Get(CommonData.ResourceGroupName, workspaceName, sparkpoolName);

            Thread.Sleep(30000);
            Assert.NotNull(sparkpoolUpdate.Tags);
            Assert.Equal("TestUpdate", sparkpoolUpdate.Tags["TestTag"]);

            // Enable Auto-scale and Auto-pause
            createSparkpoolParams = CommonData.PrepareSparkpoolCreateParams(enableAutoScale: true, enableAutoPause: true);
            var sparkpoolEnableAutoScale = SynapseClient.BigDataPools.CreateOrUpdate(CommonData.ResourceGroupName, workspaceName, sparkpoolName, createSparkpoolParams);

            Assert.Equal(CommonTestFixture.SparkpoolType, sparkpoolUnableAutoScale.Type);
            Assert.Equal(sparkpoolName, sparkpoolUnableAutoScale.Name);
            Assert.Equal(CommonData.Location, sparkpoolUnableAutoScale.Location);
            Assert.True(sparkpoolEnableAutoScale.AutoScale.Enabled);
            Assert.Equal(CommonData.AutoScaleMaxNodeCount, sparkpoolEnableAutoScale.AutoScale.MaxNodeCount);
            Assert.Equal(CommonData.AutoScaleMinNodeCount, sparkpoolEnableAutoScale.AutoScale.MinNodeCount);
            Assert.True(sparkpoolEnableAutoScale.AutoPause.Enabled);
            Assert.Equal(CommonData.AutoPauseDelayInMinute, sparkpoolEnableAutoScale.AutoPause.DelayInMinutes);

            // list sparkpool from workspace
            var firstPage = SynapseClient.BigDataPools.ListByWorkspace(CommonData.ResourceGroupName, workspaceName);
            var sparkpoolFromWorkspace = SynapseManagementTestUtilities.ListResources(firstPage, SynapseClient.BigDataPools.ListByWorkspaceNext);

            Assert.True(1 <= sparkpoolFromWorkspace.Count);

            bool isFound        = false;
            int  sparkpoolCount = sparkpoolFromWorkspace.Count;

            for (int i = 0; i < sparkpoolCount; i++)
            {
                if (sparkpoolFromWorkspace[i].Name.Equals(sparkpoolName))
                {
                    isFound = true;
                    Assert.Equal(CommonTestFixture.SparkpoolType, sparkpoolFromWorkspace[i].Type);
                    Assert.Equal(CommonData.Location, sparkpoolFromWorkspace[i].Location);
                    break;
                }
            }

            Assert.True(isFound, string.Format("Sparkpool created earlier is not found when listing all in workspace {0}", workspaceName));

            // delete sqlpool
            SynapseClient.BigDataPools.Delete(CommonData.ResourceGroupName, workspaceName, sparkpoolName);
            firstPage = SynapseClient.BigDataPools.ListByWorkspace(CommonData.ResourceGroupName, workspaceName);
            var sparkpoolAfterDelete = SynapseManagementTestUtilities.ListResources(firstPage, SynapseClient.BigDataPools.ListByWorkspaceNext);

            Assert.True(sparkpoolCount - 1 == sparkpoolAfterDelete.Count);
        }