AzureRT PR

src/ResourceManager/Compute/Commands.Compute.Test/ScenarioTests/AvailabilitySetTests.ps1

@@ -43,7 +43,9 @@ function Test-AvailabilitySet
         Assert-AreEqual $aset.PlatformUpdateDomainCount $nonDefaultUD;
         Assert-AreEqual $aset.PlatformFaultDomainCount $nonDefaultFD;
 
-        Remove-AzureAvailabilitySet -ResourceGroupName $rgname -Name $asetName;
+        Assert-ThrowsContains { Remove-AzureAvailabilitySet -ResourceGroupName $rgname -Name $asetName; } "This cmdlet will remove the specified availability set. Do you want to continue?"
+
+        Remove-AzureAvailabilitySet -ResourceGroupName $rgname -Name $asetName -Force;
 
         $asets = Get-AzureAvailabilitySet -ResourceGroupName $rgname;
         Assert-AreEqual $asets $null;

src/ResourceManager/Compute/Commands.Compute.Test/ScenarioTests/ComputeTestCommon.ps1

@@ -211,7 +211,7 @@ function Get-DefaultCRPImage
         $defaultVersion = $result[0];
     }
 
-    $vmimg = Get-AzureVMImageDetail -Location $loc -Offer $defaultOffer -PublisherName $defaultPublisher -Skus $defaultSku -Version $defaultVersion;
+    $vmimg = Get-AzureVMImage -Location $loc -Offer $defaultOffer -PublisherName $defaultPublisher -Skus $defaultSku -Version $defaultVersion;
 
     return $vmimg;
 }

src/ResourceManager/Compute/Commands.Compute.Test/ScenarioTests/VirtualMachineProfileTests.ps1

@@ -26,14 +26,26 @@ function Test-VirtualMachineProfile
 
     # Network
     $ipname = 'hpfip' + ((Get-Random) % 10000);
-    $ipRefUri = "https://test.foo.bar/$ipname";
+    $ipRefUri1 = "https://test.foo.bar/$ipname";
     $nicName = $ipname + 'nic1';
     $publicIPName = $ipname + 'name1';
 
-    $p = Add-AzureVMNetworkInterface -VM $p -Id $ipRefUri;
+    $p = Add-AzureVMNetworkInterface -VM $p -Id $ipRefUri1;
+
+    $ipname = 'hpfip' + ((Get-Random) % 10000);
+    $ipRefUri2 = "https://test.foo.bar/$ipname";
+    $p = Add-AzureVMNetworkInterface -VM $p -Id $ipRefUri2;
+
+    # Remove all NICs
+    $p = $p | Remove-AzureVMNetworkInterface
+    Assert-AreEqual $p.NetworkProfile.NetworkInterfaces.Count 0;
+
+    $p = Add-AzureVMNetworkInterface -VM $p -Id $ipRefUri1;
+    $p = Add-AzureVMNetworkInterface -VM $p -Id $ipRefUri2;
+    $p = Remove-AzureVMNetworkInterface -VM $p -Id $ipRefUri2;
 
     Assert-AreEqual $p.NetworkProfile.NetworkInterfaces.Count 1;
-    Assert-AreEqual $p.NetworkProfile.NetworkInterfaces[0].ReferenceUri $ipRefUri;
+    Assert-AreEqual $p.NetworkProfile.NetworkInterfaces[0].ReferenceUri $ipRefUri1;
 
     # Storage
     $stoname = 'hpfteststo' + ((Get-Random) % 10000);
@@ -66,6 +78,23 @@ function Test-VirtualMachineProfile
     Assert-AreEqual $p.StorageProfile.DataDisks[1].Lun 1;
     Assert-AreEqual $p.StorageProfile.DataDisks[1].VirtualHardDisk.Uri $dataDiskVhdUri2;
 
+    # Remove all data disks
+    $p = $p | Remove-AzureVMDataDisk;
+    Assert-AreEqual $p.StorageProfile.DataDisks.Count 0;
+
+    $p = Add-AzureVMDataDisk -VM $p -Name 'testDataDisk1' -Caching 'ReadOnly' -DiskSizeInGB 10 -Lun 0 -VhdUri $dataDiskVhdUri1 -CreateOption Empty;
+    $p = Add-AzureVMDataDisk -VM $p -Name 'testDataDisk2' -Caching 'ReadOnly' -DiskSizeInGB 11 -Lun 1 -VhdUri $dataDiskVhdUri2 -CreateOption Empty;
+
+    Assert-AreEqual $p.StorageProfile.DataDisks.Count 2;
+    Assert-AreEqual $p.StorageProfile.DataDisks[0].Caching 'ReadOnly';
+    Assert-AreEqual $p.StorageProfile.DataDisks[0].DiskSizeGB 10;
+    Assert-AreEqual $p.StorageProfile.DataDisks[0].Lun 0;
+    Assert-AreEqual $p.StorageProfile.DataDisks[0].VirtualHardDisk.Uri $dataDiskVhdUri1;
+    Assert-AreEqual $p.StorageProfile.DataDisks[1].Caching 'ReadOnly';
+    Assert-AreEqual $p.StorageProfile.DataDisks[1].DiskSizeGB 11;
+    Assert-AreEqual $p.StorageProfile.DataDisks[1].Lun 1;
+    Assert-AreEqual $p.StorageProfile.DataDisks[1].VirtualHardDisk.Uri $dataDiskVhdUri2;
+
     # Windows OS
     $user = "Foo12";
     $password = 'BaR@000' + ((Get-Random) % 10000);

src/ResourceManager/Compute/Commands.Compute.Test/ScenarioTests/VirtualMachineTests.ps1

@@ -252,15 +252,15 @@ function Test-VirtualMachineImageList
                             {
                                 $versions = $s4 | select -ExpandProperty Version;
 
-                                $s6 = Get-AzureVMImage -Location $locStr -PublisherName $pub -Offer $offer -Sku $sku -FilterExpression ('name -eq *');
-                                Assert-NotNull $s6;
-                                Assert-NotNull $s6.Count -gt 0;
-                                $verNames = $s6 | select -ExpandProperty Version;
+                                $s5 = Get-AzureVMImage -Location $locStr -PublisherName $pub -Offer $offer -Sku $sku -FilterExpression ('name -eq *');
+                                Assert-NotNull $s5;
+                                Assert-NotNull $s5.Count -gt 0;
+                                $verNames = $s5 | select -ExpandProperty Version;
 
                                 foreach ($ver in $versions)
                                 {
                                     if ($ver -eq $null -or $ver -eq '') { continue; }
-                                    $s6 = Get-AzureVMImageDetail -Location $locStr -PublisherName $pub -Offer $offer -Sku $sku -Version $ver;
+                                    $s6 = Get-AzureVMImage -Location $locStr -PublisherName $pub -Offer $offer -Sku $sku -Version $ver;
                                     Assert-NotNull $s6;
                                     $s6;
 
@@ -299,7 +299,7 @@ function Test-VirtualMachineImageList
                     $versions = $s2 | select -ExpandProperty Version;
                     foreach ($ver in $versions)
                     {
-                        $s3 = Get-AzureVMExtensionImageDetail -Location $locStr -PublisherName $pub -Type $type -Version $ver -FilterExpression '*';
+                        $s3 = Get-AzureVMExtensionImage -Location $locStr -PublisherName $pub -Type $type -Version $ver -FilterExpression '*';
 
                         Assert-NotNull $s3;
                         Assert-True { $s3.Version -eq $ver; }
@@ -316,11 +316,11 @@ function Test-VirtualMachineImageList
 
         # Test Piping
         $pubNameFilter = '*Microsoft*Windows*Server*';
-        $imgs = Get-AzureVMImagePublisher -Location $locStr | where { $_.PublisherName -like $pubNameFilter } | Get-AzureVMImageOffer | Get-AzureVMImageSku | Get-AzureVMImage | Get-AzureVMImageDetail;
+        $imgs = Get-AzureVMImagePublisher -Location $locStr | where { $_.PublisherName -like $pubNameFilter } | Get-AzureVMImageOffer | Get-AzureVMImageSku | Get-AzureVMImage | Get-AzureVMImage;
         Assert-True { $imgs.Count -gt 0 };
 
         $pubNameFilter = '*Microsoft.Compute*';
-        $extimgs = Get-AzureVMImagePublisher -Location $locStr | where { $_.PublisherName -like $pubNameFilter } | Get-AzureVMExtensionImageType | Get-AzureVMExtensionImage | Get-AzureVMExtensionImageDetail;
+        $extimgs = Get-AzureVMImagePublisher -Location $locStr | where { $_.PublisherName -like $pubNameFilter } | Get-AzureVMExtensionImageType | Get-AzureVMExtensionImage | Get-AzureVMExtensionImage;
         Assert-True { $extimgs.Count -gt 0 };
 
         # Negative Tests
@@ -341,12 +341,12 @@ function Test-VirtualMachineImageList
         Assert-ThrowsContains { $s5 = Get-AzureVMImage -Location $locStr -PublisherName $publisherName -Offer $offerName -Skus $skusName -FilterExpression $filter; } "was not found";
 
         $version = '1.0.0';
-        Assert-ThrowsContains { $s6 = Get-AzureVMImageDetail -Location $locStr -PublisherName $publisherName -Offer $offerName -Skus $skusName -Version $version; } "was not found";
+        Assert-ThrowsContains { $s6 = Get-AzureVMImage -Location $locStr -PublisherName $publisherName -Offer $offerName -Skus $skusName -Version $version; } "was not found";
 
         # Extension Images
         $type = Get-ComputeTestResourceName;
-        Assert-ThrowsContains { $s7 = Get-AzureVMExtensionImageDetail -Location $locStr -PublisherName $publisherName -Type $type -FilterExpression $filter -Version $version; } "was not found";
-        
+        Assert-ThrowsContains { $s7 = Get-AzureVMExtensionImage -Location $locStr -PublisherName $publisherName -Type $type -FilterExpression $filter -Version $version; } "was not found";
+
         Assert-ThrowsContains { $s8 = Get-AzureVMExtensionImageType -Location $locStr -PublisherName $publisherName; } "was not found";
 
         Assert-ThrowsContains { $s9 = Get-AzureVMExtensionImage -Location $locStr -PublisherName $publisherName -Type $type -FilterExpression $filter; } "was not found";
@@ -987,7 +987,7 @@ function Test-VirtualMachinePlan2
         $vmmImgOfferName = 'a10-vthunder-adc';
         $vmmImgSkusName = 'vthunder_byol';
         $vmmImgVerName = '1.0.0';
-        $imgRef = Get-AzureVMImageDetail -PublisherName $vmmImgPubName -Location $loc -Offer $vmmImgOfferName -Skus $vmmImgSkusName -Version $vmmImgVerName;
+        $imgRef = Get-AzureVMImage -PublisherName $vmmImgPubName -Location $loc -Offer $vmmImgOfferName -Skus $vmmImgSkusName -Version $vmmImgVerName;
         $plan = $imgRef.PurchasePlan;
         $p = Set-AzureVMSourceImage -VM $p -PublisherName $imgRef.PublisherName -Offer $imgRef.Offer -Skus $imgRef.Skus -Version $imgRef.Version;
         $p.Plan = New-Object Microsoft.Azure.Management.Compute.Models.Plan;

src/ResourceManager/Compute/Commands.Compute/AvailabilitySets/RemoveAzureAvailabilitySetCommand.cs

@@ -12,13 +12,16 @@
 // limitations under the License.
 // ----------------------------------------------------------------------------------
 
+using AutoMapper;
 using Microsoft.Azure.Commands.Compute.Common;
+using Microsoft.Azure.Commands.Compute.Models;
 using Microsoft.Azure.Management.Compute;
 using System.Management.Automation;
 
 namespace Microsoft.Azure.Commands.Compute
 {
     [Cmdlet(VerbsCommon.Remove, ProfileNouns.AvailabilitySet)]
+    [OutputType(typeof(PSOperationResponse))]
     public class RemoveAzureAvailabilitySetCommand : AvailabilitySetBaseCmdlet
     {
         [Parameter(
@@ -37,13 +40,24 @@ public class RemoveAzureAvailabilitySetCommand : AvailabilitySetBaseCmdlet
         [ValidateNotNullOrEmpty]
         public string Name { get; set; }
 
+        [Parameter(
+           Position = 2,
+           HelpMessage = "To force the removal.")]
+        [ValidateNotNullOrEmpty]
+        public SwitchParameter Force { get; set; }
+
         public override void ExecuteCmdlet()
         {
             base.ExecuteCmdlet();
 
-            var op = this.AvailabilitySetClient.Delete(this.ResourceGroupName, this.Name);
-
-            WriteObject(op);
+            if (this.Force.IsPresent
+            || this.ShouldContinue(Properties.Resources.AvailabilitySetRemovalConfirmation,
+                                   Properties.Resources.AvailabilitySetRemovalCaption))
+            {
+                AzureOperationResponse op = this.AvailabilitySetClient.Delete(this.ResourceGroupName, this.Name);
+                var result = Mapper.Map<PSOperationResponse>(op);
+                WriteObject(result);
+            }
         }
     }
 }

src/ResourceManager/Compute/Commands.Compute/Commands.Compute.csproj

@@ -177,6 +177,7 @@
     <Compile Include="Images\GetAzureVMImageOfferCommand.cs" />
     <Compile Include="Images\GetAzureVMImageDetailCommand.cs" />
     <Compile Include="Images\VirtualMachineImageBaseCmdlet.cs" />
+    <Compile Include="Models\PSOperationResponse.cs" />
     <Compile Include="Models\PSUsage.cs" />
     <Compile Include="Models\PSVirtualMachineExtensionImage.cs" />
     <Compile Include="Models\PSVirtualMachineImage.cs" />

src/ResourceManager/Compute/Commands.Compute/Common/ComputeAutoMapperProfile.cs

@@ -72,8 +72,8 @@ protected override void Configure()
             Mapper.CreateMap<FROM.VirtualMachine, TO.PSVirtualMachine>();
             Mapper.CreateMap<FROM.VirtualMachineSize, TO.PSVirtualMachineSize>();
             Mapper.CreateMap<FROM.Usage, TO.PSUsage>();
-
             Mapper.CreateMap<FROM.ComputeLongRunningOperationResponse, TO.PSComputeLongRunningOperation>();
+            Mapper.CreateMap<Microsoft.Azure.AzureOperationResponse, TO.PSOperationResponse>();
         }
     }
 }

src/ResourceManager/Compute/Commands.Compute/ExtensionImages/GetAzureVMExtensionImageCommand.cs

@@ -21,8 +21,9 @@
 
 namespace Microsoft.Azure.Commands.Compute
 {
-    [Cmdlet(VerbsCommon.Get, ProfileNouns.VirtualMachineExtensionImage)]
-    [OutputType(typeof(PSVirtualMachineExtensionImage))]
+    [Cmdlet(VerbsCommon.Get,
+        ProfileNouns.VirtualMachineExtensionImage)]
+    [OutputType(typeof(PSVirtualMachineExtensionImageDetails))]
     public class GetAzureVMExtensionImageCommand : VirtualMachineExtensionImageBaseCmdlet
     {
         [Parameter(Mandatory = true, ValueFromPipelineByPropertyName = true), ValidateNotNullOrEmpty]
@@ -37,34 +38,73 @@ public class GetAzureVMExtensionImageCommand : VirtualMachineExtensionImageBaseC
         [Parameter, ValidateNotNullOrEmpty]
         public string FilterExpression { get; set; }
 
+        [Parameter(Mandatory = false, ValueFromPipelineByPropertyName = true)]
+        public string Version { get; set; }
+
         public override void ExecuteCmdlet()
         {
             base.ExecuteCmdlet();
 
-            var parameters = new VirtualMachineExtensionImageListVersionsParameters
+            if (string.IsNullOrEmpty(this.Version))
+            {
+                var parameters = new VirtualMachineExtensionImageListVersionsParameters
+                {
+                    Location = Location.Canonicalize(),
+                    PublisherName = PublisherName,
+                    Type = Type,
+                    FilterExpression = FilterExpression
+                };
+
+                VirtualMachineImageResourceList result = this.VirtualMachineExtensionImageClient.ListVersions(parameters);
+
+                var images = from r in result.Resources
+                             select new PSVirtualMachineExtensionImage
+                             {
+                                 RequestId = result.RequestId,
+                                 StatusCode = result.StatusCode,
+                                 Id = r.Id,
+                                 Location = r.Location,
+                                 Version = r.Name,
+                                 PublisherName = this.PublisherName,
+                                 Type = this.Type,
+                                 FilterExpression = this.FilterExpression
+                             };
+
+                WriteObject(images, true);
+            }
+            else
             {
-                Location = Location.Canonicalize(),
-                PublisherName = PublisherName,
-                Type = Type,
-                FilterExpression = FilterExpression
-            };
 
-            VirtualMachineImageResourceList result = this.VirtualMachineExtensionImageClient.ListVersions(parameters);
+                var parameters = new VirtualMachineExtensionImageGetParameters
+                {
+                    Location = Location.Canonicalize(),
+                    PublisherName = PublisherName,
+                    Type = Type,
+                    FilterExpression = FilterExpression,
+                    Version = Version
+                };
+
+                VirtualMachineExtensionImageGetResponse result = this.VirtualMachineExtensionImageClient.Get(parameters);
 
-            var images = from r in result.Resources
-                         select new PSVirtualMachineExtensionImage
-                         {
-                             RequestId = result.RequestId,
-                             StatusCode = result.StatusCode,
-                             Id = r.Id,
-                             Location = r.Location,
-                             Version = r.Name,
-                             PublisherName = this.PublisherName,
-                             Type = this.Type,
-                             FilterExpression = this.FilterExpression
-                         };
+                var image = new PSVirtualMachineExtensionImageDetails
+                {
+                    RequestId = result.RequestId,
+                    StatusCode = result.StatusCode,
+                    Id = result.VirtualMachineExtensionImage.Id,
+                    Location = result.VirtualMachineExtensionImage.Location,
+                    Name = result.VirtualMachineExtensionImage.Name,
+                    HandlerSchema = result.VirtualMachineExtensionImage.HandlerSchema,
+                    OperatingSystem = result.VirtualMachineExtensionImage.OperatingSystem,
+                    ComputeRole = result.VirtualMachineExtensionImage.ComputeRole,
+                    SupportsMultipleExtensions = result.VirtualMachineExtensionImage.SupportsMultipleExtensions,
+                    VMScaleSetEnabled = result.VirtualMachineExtensionImage.VMScaleSetEnabled,
+                    PublisherName = this.PublisherName,
+                    Type = this.Type,
+                    Version = this.Version
+                };
 
-            WriteObject(images, true);
+                WriteObject(image);
+            }
         }
     }
 }

src/ResourceManager/Compute/Commands.Compute/ExtensionImages/GetAzureVMExtensionImageDetailCommand.cs

@@ -43,6 +43,8 @@ public override void ExecuteCmdlet()
         {
             base.ExecuteCmdlet();
 
+            WriteWarning(Properties.Resources.DeprecationOfGetAzureVMExtensionImageDetail);
+
             var parameters = new VirtualMachineExtensionImageGetParameters
             {
                 Location = Location.Canonicalize(),