PageRenderTime 68ms CodeModel.GetById 32ms RepoModel.GetById 0ms app.codeStats 1ms

/sdk/compute/mgmt/src/test/java/com/azure/management/compute/VirtualMachineOperationsTests.java

http://github.com/WindowsAzure/azure-sdk-for-java
Java | 797 lines | 667 code | 73 blank | 57 comment | 26 complexity | e3852f8fced879cc3181bff1d2aaafbe MD5 | raw file
Possible License(s): MIT 
    

  1. // Copyright (c) Microsoft Corporation. All rights reserved.
    2. 

  2. // Licensed under the MIT License.
    3. 

  3. 

  4. package com.azure.management.compute;
    5. 

  5. 

  6. import com.azure.core.http.HttpPipeline;
    7. 

  7. import com.azure.core.http.rest.PagedIterable;
    8. 

  8. import com.azure.core.management.CloudException;
    9. 

  9. import com.azure.management.network.Network;
    10. 

  10. import com.azure.management.network.NetworkInterface;
    11. 

  11. import com.azure.management.network.NetworkSecurityGroup;
    12. 

  12. import com.azure.management.network.NicIPConfiguration;
    13. 

  13. import com.azure.management.network.PublicIPAddress;
    14. 

  14. import com.azure.management.network.SecurityRuleProtocol;
    15. 

  15. import com.azure.management.network.Subnet;
    16. 

  16. import com.azure.management.resources.ResourceGroup;
    17. 

  17. import com.azure.management.resources.fluentcore.arm.Region;
    18. 

  18. import com.azure.management.resources.fluentcore.arm.models.Resource;
    19. 

  19. import com.azure.management.resources.fluentcore.model.Creatable;
    20. 

  20. import com.azure.management.resources.fluentcore.model.CreatedResources;
    21. 

  21. import com.azure.management.resources.fluentcore.profile.AzureProfile;
    22. 

  22. import com.azure.management.storage.SkuName;
    23. 

  23. import com.azure.management.storage.StorageAccount;
    24. 

  24. import java.util.ArrayList;
    25. 

  25. import java.util.HashMap;
    26. 

  26. import java.util.HashSet;
    27. 

  27. import java.util.List;
    28. 

  28. import java.util.Map;
    29. 

  29. import java.util.Set;
    30. 

  30. import java.util.concurrent.atomic.AtomicInteger;
    31. 

  31. import org.junit.jupiter.api.Assertions;
    32. 

  32. import org.junit.jupiter.api.Test;
    33. 

  33. 

  34. public class VirtualMachineOperationsTests extends ComputeManagementTest {
    35. 

  35.     private String rgName = "";
    36. 

  36.     private String rgName2 = "";
    37. 

  37.     private final Region region = Region.US_EAST;
    38. 

  38.     private final Region regionProxPlacementGroup = Region.US_WEST_CENTRAL;
    39. 

  39.     private final Region regionProxPlacementGroup2 = Region.US_SOUTH_CENTRAL;
    40. 

  40.     private final String vmName = "javavm";
    41. 

  41.     private final String proxGroupName = "testproxgroup1";
    42. 

  42.     private final String proxGroupName2 = "testproxgroup2";
    43. 

  43.     private final String availabilitySetName = "availset1";
    44. 

  44.     private final String availabilitySetName2 = "availset2";
    45. 

  45.     private final ProximityPlacementGroupType proxGroupType = ProximityPlacementGroupType.STANDARD;
    46. 

  46. 

  47.     @Override
    48. 

  48.     protected void initializeClients(HttpPipeline httpPipeline, AzureProfile profile) {
    49. 

  49.         rgName = generateRandomResourceName("javacsmrg", 15);
    50. 

  50.         rgName2 = generateRandomResourceName("javacsmrg2", 15);
    51. 

  51.         super.initializeClients(httpPipeline, profile);
    52. 

  52.     }
    53. 

  53. 

  54.     @Override
    55. 

  55.     protected void cleanUpResources() {
    56. 

  56.         resourceManager.resourceGroups().beginDeleteByName(rgName);
    57. 

  57.     }
    58. 

  58. 

  59.     @Test
    60. 

  60.     public void canCreateVirtualMachineWithNetworking() throws Exception {
    61. 

  61.         NetworkSecurityGroup nsg =
    62. 

  62.             this
    63. 

  63.                 .networkManager
    64. 

  64.                 .networkSecurityGroups()
    65. 

  65.                 .define("nsg")
    66. 

  66.                 .withRegion(region)
    67. 

  67.                 .withNewResourceGroup(rgName)
    68. 

  68.                 .defineRule("rule1")
    69. 

  69.                 .allowInbound()
    70. 

  70.                 .fromAnyAddress()
    71. 

  71.                 .fromPort(80)
    72. 

  72.                 .toAnyAddress()
    73. 

  73.                 .toPort(80)
    74. 

  74.                 .withProtocol(SecurityRuleProtocol.TCP)
    75. 

  75.                 .attach()
    76. 

  76.                 .create();
    77. 

  77. 

  78.         Creatable<Network> networkDefinition =
    79. 

  79.             this
    80. 

  80.                 .networkManager
    81. 

  81.                 .networks()
    82. 

  82.                 .define("network1")
    83. 

  83.                 .withRegion(region)
    84. 

  84.                 .withNewResourceGroup(rgName)
    85. 

  85.                 .withAddressSpace("10.0.0.0/28")
    86. 

  86.                 .defineSubnet("subnet1")
    87. 

  87.                 .withAddressPrefix("10.0.0.0/29")
    88. 

  88.                 .withExistingNetworkSecurityGroup(nsg)
    89. 

  89.                 .attach();
    90. 

  90. 

  91.         // Create
    92. 

  92.         VirtualMachine vm =
    93. 

  93.             computeManager
    94. 

  94.                 .virtualMachines()
    95. 

  95.                 .define(vmName)
    96. 

  96.                 .withRegion(region)
    97. 

  97.                 .withNewResourceGroup(rgName)
    98. 

  98.                 .withNewPrimaryNetwork(networkDefinition)
    99. 

  99.                 .withPrimaryPrivateIPAddressDynamic()
    100. 

  100.                 .withoutPrimaryPublicIPAddress()
    101. 

  101.                 .withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
    102. 

  102.                 .withRootUsername("Foo12")
    103. 

  103.                 .withRootPassword("abc!@#F0orL")
    104. 

  104.                 .create();
    105. 

  105. 

  106.         NetworkInterface primaryNic = vm.getPrimaryNetworkInterface();
    107. 

  107.         Assertions.assertNotNull(primaryNic);
    108. 

  108.         NicIPConfiguration primaryIpConfig = primaryNic.primaryIPConfiguration();
    109. 

  109.         Assertions.assertNotNull(primaryIpConfig);
    110. 

  110. 

  111.         // Fetch the NSG the way before v1.2
    112. 

  112.         Assertions.assertNotNull(primaryIpConfig.networkId());
    113. 

  113.         Network network = primaryIpConfig.getNetwork();
    114. 

  114.         Assertions.assertNotNull(primaryIpConfig.subnetName());
    115. 

  115.         Subnet subnet = network.subnets().get(primaryIpConfig.subnetName());
    116. 

  116.         Assertions.assertNotNull(subnet);
    117. 

  117.         nsg = subnet.getNetworkSecurityGroup();
    118. 

  118.         Assertions.assertNotNull(nsg);
    119. 

  119.         Assertions.assertEquals("nsg", nsg.name());
    120. 

  120.         Assertions.assertEquals(1, nsg.securityRules().size());
    121. 

  121. 

  122.         // Fetch the NSG the v1.2 way
    123. 

  123.         nsg = primaryIpConfig.getNetworkSecurityGroup();
    124. 

  124.         Assertions.assertEquals("nsg", nsg.name());
    125. 

  125.     }
    126. 

  126. 

  127.     @Test
    128. 

  128.     public void canCreateVirtualMachine() throws Exception {
    129. 

  129.         // Create
    130. 

  130.         computeManager
    131. 

  131.             .virtualMachines()
    132. 

  132.             .define(vmName)
    133. 

  133.             .withRegion(region)
    134. 

  134.             .withNewResourceGroup(rgName)
    135. 

  135.             .withNewPrimaryNetwork("10.0.0.0/28")
    136. 

  136.             .withPrimaryPrivateIPAddressDynamic()
    137. 

  137.             .withoutPrimaryPublicIPAddress()
    138. 

  138.             .withPopularWindowsImage(KnownWindowsVirtualMachineImage.WINDOWS_SERVER_2012_DATACENTER)
    139. 

  139.             .withAdminUsername("Foo12")
    140. 

  140.             .withAdminPassword("abc!@#F0orL")
    141. 

  141.             .withUnmanagedDisks()
    142. 

  142.             .withSize(VirtualMachineSizeTypes.STANDARD_D3)
    143. 

  143.             .withOSDiskCaching(CachingTypes.READ_WRITE)
    144. 

  144.             .withOSDiskName("javatest")
    145. 

  145.             .withLicenseType("Windows_Server")
    146. 

  146.             .create();
    147. 

  147. 

  148.         VirtualMachine foundVM = null;
    149. 

  149.         PagedIterable<VirtualMachine> vms = computeManager.virtualMachines().listByResourceGroup(rgName);
    150. 

  150.         for (VirtualMachine vm1 : vms) {
    151. 

  151.             if (vm1.name().equals(vmName)) {
    152. 

  152.                 foundVM = vm1;
    153. 

  153.                 break;
    154. 

  154.             }
    155. 

  155.         }
    156. 

  156.         Assertions.assertNotNull(foundVM);
    157. 

  157.         Assertions.assertEquals(region, foundVM.region());
    158. 

  158.         // Get
    159. 

  159.         foundVM = computeManager.virtualMachines().getByResourceGroup(rgName, vmName);
    160. 

  160.         Assertions.assertNotNull(foundVM);
    161. 

  161.         Assertions.assertEquals(region, foundVM.region());
    162. 

  162.         Assertions.assertEquals("Windows_Server", foundVM.licenseType());
    163. 

  163. 

  164.         // Fetch instance view
    165. 

  165.         PowerState powerState = foundVM.powerState();
    166. 

  166.         Assertions.assertEquals(powerState, PowerState.RUNNING);
    167. 

  167.         VirtualMachineInstanceView instanceView = foundVM.instanceView();
    168. 

  168.         Assertions.assertNotNull(instanceView);
    169. 

  169.         Assertions.assertNotNull(instanceView.statuses().size() > 0);
    170. 

  170. 

  171.         // Delete VM
    172. 

  172.         computeManager.virtualMachines().deleteById(foundVM.id());
    173. 

  173.     }
    174. 

  174. 

  175.     @Test
    176. 

  176.     public void canCreateUpdatePriorityAndPrice() throws Exception {
    177. 

  177.         // Create
    178. 

  178.         computeManager
    179. 

  179.             .virtualMachines()
    180. 

  180.             .define(vmName)
    181. 

  181.             .withRegion(region)
    182. 

  182.             .withNewResourceGroup(rgName)
    183. 

  183.             .withNewPrimaryNetwork("10.0.0.0/28")
    184. 

  184.             .withPrimaryPrivateIPAddressDynamic()
    185. 

  185.             .withoutPrimaryPublicIPAddress()
    186. 

  186.             .withPopularWindowsImage(KnownWindowsVirtualMachineImage.WINDOWS_SERVER_2012_DATACENTER)
    187. 

  187.             .withAdminUsername("Foo12")
    188. 

  188.             .withAdminPassword("abc!@#F0orL")
    189. 

  189.             .withUnmanagedDisks()
    190. 

  190.             .withSize(VirtualMachineSizeTypes.STANDARD_A2)
    191. 

  191.             .withOSDiskCaching(CachingTypes.READ_WRITE)
    192. 

  192.             .withOSDiskName("javatest")
    193. 

  193.             .withLowPriority(VirtualMachineEvictionPolicyTypes.DEALLOCATE)
    194. 

  194.             .withMaxPrice(1000.0)
    195. 

  195.             .withLicenseType("Windows_Server")
    196. 

  196.             .create();
    197. 

  197. 

  198.         VirtualMachine foundVM = null;
    199. 

  199.         PagedIterable<VirtualMachine> vms = computeManager.virtualMachines().listByResourceGroup(rgName);
    200. 

  200.         for (VirtualMachine vm1 : vms) {
    201. 

  201.             if (vm1.name().equals(vmName)) {
    202. 

  202.                 foundVM = vm1;
    203. 

  203.                 break;
    204. 

  204.             }
    205. 

  205.         }
    206. 

  206.         Assertions.assertNotNull(foundVM);
    207. 

  207.         Assertions.assertEquals(region, foundVM.region());
    208. 

  208.         // Get
    209. 

  209.         foundVM = computeManager.virtualMachines().getByResourceGroup(rgName, vmName);
    210. 

  210.         Assertions.assertNotNull(foundVM);
    211. 

  211.         Assertions.assertEquals(region, foundVM.region());
    212. 

  212.         Assertions.assertEquals("Windows_Server", foundVM.licenseType());
    213. 

  213.         Assertions.assertEquals((Double) 1000.0, foundVM.billingProfile().maxPrice());
    214. 

  214.         Assertions.assertEquals(VirtualMachineEvictionPolicyTypes.DEALLOCATE, foundVM.evictionPolicy());
    215. 

  215. 

  216.         // change max price
    217. 

  217.         try {
    218. 

  218.             foundVM.update().withMaxPrice(1500.0).apply();
    219. 

  219.             // not run to assert
    220. 

  220.             Assertions.assertEquals((Double) 1500.0, foundVM.billingProfile().maxPrice());
    221. 

  221.             Assertions.fail();
    222. 

  222.         } catch (CloudException e) {
    223. 

  223.         } // cannot change max price when vm is running
    224. 

  224. 

  225.         foundVM.deallocate();
    226. 

  226.         foundVM.update().withMaxPrice(2000.0).apply();
    227. 

  227.         foundVM.start();
    228. 

  228. 

  229.         Assertions.assertEquals((Double) 2000.0, foundVM.billingProfile().maxPrice());
    230. 

  230. 

  231.         // change priority types
    232. 

  232.         foundVM = foundVM.update().withPriority(VirtualMachinePriorityTypes.SPOT).apply();
    233. 

  233. 

  234.         Assertions.assertEquals(VirtualMachinePriorityTypes.SPOT, foundVM.priority());
    235. 

  235. 

  236.         foundVM = foundVM.update().withPriority(VirtualMachinePriorityTypes.LOW).apply();
    237. 

  237. 

  238.         Assertions.assertEquals(VirtualMachinePriorityTypes.LOW, foundVM.priority());
    239. 

  239.         try {
    240. 

  240.             foundVM.update().withPriority(VirtualMachinePriorityTypes.REGULAR).apply();
    241. 

  241.             // not run to assert
    242. 

  242.             Assertions.assertEquals(VirtualMachinePriorityTypes.REGULAR, foundVM.priority());
    243. 

  243.             Assertions.fail();
    244. 

  244.         } catch (CloudException e) {
    245. 

  245.         } // cannot change priority from low to regular
    246. 

  246. 

  247.         // Delete VM
    248. 

  248.         computeManager.virtualMachines().deleteById(foundVM.id());
    249. 

  249.     }
    250. 

  250. 

  251.     @Test
    252. 

  252.     public void cannotUpdateProximityPlacementGroupForVirtualMachine() throws Exception {
    253. 

  253.         AvailabilitySet setCreated =
    254. 

  254.             computeManager
    255. 

  255.                 .availabilitySets()
    256. 

  256.                 .define(availabilitySetName)
    257. 

  257.                 .withRegion(regionProxPlacementGroup)
    258. 

  258.                 .withNewResourceGroup(rgName)
    259. 

  259.                 .withNewProximityPlacementGroup(proxGroupName, proxGroupType)
    260. 

  260.                 .create();
    261. 

  261. 

  262.         Assertions.assertEquals(availabilitySetName, setCreated.name());
    263. 

  263.         Assertions.assertNotNull(setCreated.proximityPlacementGroup());
    264. 

  264.         Assertions.assertEquals(proxGroupType, setCreated.proximityPlacementGroup().proximityPlacementGroupType());
    265. 

  265.         Assertions.assertNotNull(setCreated.proximityPlacementGroup().availabilitySetIds());
    266. 

  266.         Assertions.assertFalse(setCreated.proximityPlacementGroup().availabilitySetIds().isEmpty());
    267. 

  267.         Assertions
    268. 

  268.             .assertTrue(
    269. 

  269.                 setCreated.id().equalsIgnoreCase(setCreated.proximityPlacementGroup().availabilitySetIds().get(0)));
    270. 

  270.         Assertions.assertEquals(setCreated.regionName(), setCreated.proximityPlacementGroup().location());
    271. 

  271. 

  272.         AvailabilitySet setCreated2 =
    273. 

  273.             computeManager
    274. 

  274.                 .availabilitySets()
    275. 

  275.                 .define(availabilitySetName2)
    276. 

  276.                 .withRegion(regionProxPlacementGroup2)
    277. 

  277.                 .withNewResourceGroup(rgName2)
    278. 

  278.                 .withNewProximityPlacementGroup(proxGroupName2, proxGroupType)
    279. 

  279.                 .create();
    280. 

  280. 

  281.         Assertions.assertEquals(availabilitySetName2, setCreated2.name());
    282. 

  282.         Assertions.assertNotNull(setCreated2.proximityPlacementGroup());
    283. 

  283.         Assertions.assertEquals(proxGroupType, setCreated2.proximityPlacementGroup().proximityPlacementGroupType());
    284. 

  284.         Assertions.assertNotNull(setCreated2.proximityPlacementGroup().availabilitySetIds());
    285. 

  285.         Assertions.assertFalse(setCreated2.proximityPlacementGroup().availabilitySetIds().isEmpty());
    286. 

  286.         Assertions
    287. 

  287.             .assertTrue(
    288. 

  288.                 setCreated2.id().equalsIgnoreCase(setCreated2.proximityPlacementGroup().availabilitySetIds().get(0)));
    289. 

  289.         Assertions.assertEquals(setCreated2.regionName(), setCreated2.proximityPlacementGroup().location());
    290. 

  290. 

  291.         // Create
    292. 

  292.         computeManager
    293. 

  293.             .virtualMachines()
    294. 

  294.             .define(vmName)
    295. 

  295.             .withRegion(regionProxPlacementGroup)
    296. 

  296.             .withExistingResourceGroup(rgName)
    297. 

  297.             .withNewPrimaryNetwork("10.0.0.0/28")
    298. 

  298.             .withPrimaryPrivateIPAddressDynamic()
    299. 

  299.             .withoutPrimaryPublicIPAddress()
    300. 

  300.             .withProximityPlacementGroup(setCreated.proximityPlacementGroup().id())
    301. 

  301.             .withPopularWindowsImage(KnownWindowsVirtualMachineImage.WINDOWS_SERVER_2012_DATACENTER)
    302. 

  302.             .withAdminUsername("Foo12")
    303. 

  303.             .withAdminPassword("abc!@#F0orL")
    304. 

  304.             .withUnmanagedDisks()
    305. 

  305.             .withSize(VirtualMachineSizeTypes.STANDARD_DS3_V2)
    306. 

  306.             .withOSDiskCaching(CachingTypes.READ_WRITE)
    307. 

  307.             .withOSDiskName("javatest")
    308. 

  308.             .withLicenseType("Windows_Server")
    309. 

  309.             .create();
    310. 

  310. 

  311.         VirtualMachine foundVM = null;
    312. 

  312.         PagedIterable<VirtualMachine> vms = computeManager.virtualMachines().listByResourceGroup(rgName);
    313. 

  313.         for (VirtualMachine vm1 : vms) {
    314. 

  314.             if (vm1.name().equals(vmName)) {
    315. 

  315.                 foundVM = vm1;
    316. 

  316.                 break;
    317. 

  317.             }
    318. 

  318.         }
    319. 

  319.         Assertions.assertNotNull(foundVM);
    320. 

  320.         Assertions.assertEquals(regionProxPlacementGroup, foundVM.region());
    321. 

  321.         // Get
    322. 

  322.         foundVM = computeManager.virtualMachines().getByResourceGroup(rgName, vmName);
    323. 

  323.         Assertions.assertNotNull(foundVM);
    324. 

  324.         Assertions.assertEquals(regionProxPlacementGroup, foundVM.region());
    325. 

  325.         Assertions.assertEquals("Windows_Server", foundVM.licenseType());
    326. 

  326. 

  327.         // Fetch instance view
    328. 

  328.         PowerState powerState = foundVM.powerState();
    329. 

  329.         Assertions.assertEquals(powerState, PowerState.RUNNING);
    330. 

  330.         VirtualMachineInstanceView instanceView = foundVM.instanceView();
    331. 

  331.         Assertions.assertNotNull(instanceView);
    332. 

  332.         Assertions.assertNotNull(instanceView.statuses().size() > 0);
    333. 

  333. 

  334.         Assertions.assertNotNull(foundVM.proximityPlacementGroup());
    335. 

  335.         Assertions.assertEquals(proxGroupType, foundVM.proximityPlacementGroup().proximityPlacementGroupType());
    336. 

  336.         Assertions.assertNotNull(foundVM.proximityPlacementGroup().availabilitySetIds());
    337. 

  337.         Assertions.assertFalse(foundVM.proximityPlacementGroup().availabilitySetIds().isEmpty());
    338. 

  338.         Assertions
    339. 

  339.             .assertTrue(
    340. 

  340.                 setCreated.id().equalsIgnoreCase(foundVM.proximityPlacementGroup().availabilitySetIds().get(0)));
    341. 

  341.         Assertions.assertNotNull(foundVM.proximityPlacementGroup().virtualMachineIds());
    342. 

  342.         Assertions.assertFalse(foundVM.proximityPlacementGroup().virtualMachineIds().isEmpty());
    343. 

  343.         Assertions
    344. 

  344.             .assertTrue(foundVM.id().equalsIgnoreCase(setCreated.proximityPlacementGroup().virtualMachineIds().get(0)));
    345. 

  345. 

  346.         try {
    347. 

  347.             // Update Vm to remove it from proximity placement group
    348. 

  348.             VirtualMachine updatedVm =
    349. 

  349.                 foundVM.update().withProximityPlacementGroup(setCreated2.proximityPlacementGroup().id()).apply();
    350. 

  350.         } catch (CloudException clEx) {
    351. 

  351.             Assertions
    352. 

  352.                 .assertTrue(
    353. 

  353.                     clEx
    354. 

  354.                         .getMessage()
    355. 

  355.                         .contains(
    356. 

  356.                             "Updating proximity placement group of VM javavm is not allowed while the VM is running."
    357. 

  357.                                 + " Please stop/deallocate the VM and retry the operation."));
    358. 

  358.         }
    359. 

  359. 

  360.         // Delete VM
    361. 

  361.         computeManager.virtualMachines().deleteById(foundVM.id());
    362. 

  362.         computeManager.availabilitySets().deleteById(setCreated.id());
    363. 

  363.     }
    364. 

  364. 

  365.     @Test
    366. 

  366.     public void canCreateVirtualMachinesAndAvailabilitySetInSameProximityPlacementGroup() throws Exception {
    367. 

  367.         AvailabilitySet setCreated =
    368. 

  368.             computeManager
    369. 

  369.                 .availabilitySets()
    370. 

  370.                 .define(availabilitySetName)
    371. 

  371.                 .withRegion(regionProxPlacementGroup)
    372. 

  372.                 .withNewResourceGroup(rgName)
    373. 

  373.                 .withNewProximityPlacementGroup(proxGroupName, proxGroupType)
    374. 

  374.                 .create();
    375. 

  375. 

  376.         Assertions.assertEquals(availabilitySetName, setCreated.name());
    377. 

  377.         Assertions.assertNotNull(setCreated.proximityPlacementGroup());
    378. 

  378.         Assertions.assertEquals(proxGroupType, setCreated.proximityPlacementGroup().proximityPlacementGroupType());
    379. 

  379.         Assertions.assertNotNull(setCreated.proximityPlacementGroup().availabilitySetIds());
    380. 

  380.         Assertions.assertFalse(setCreated.proximityPlacementGroup().availabilitySetIds().isEmpty());
    381. 

  381.         Assertions
    382. 

  382.             .assertTrue(
    383. 

  383.                 setCreated.id().equalsIgnoreCase(setCreated.proximityPlacementGroup().availabilitySetIds().get(0)));
    384. 

  384.         Assertions.assertEquals(setCreated.regionName(), setCreated.proximityPlacementGroup().location());
    385. 

  385. 

  386.         // Create
    387. 

  387.         computeManager
    388. 

  388.             .virtualMachines()
    389. 

  389.             .define(vmName)
    390. 

  390.             .withRegion(regionProxPlacementGroup)
    391. 

  391.             .withExistingResourceGroup(rgName)
    392. 

  392.             .withNewPrimaryNetwork("10.0.0.0/28")
    393. 

  393.             .withPrimaryPrivateIPAddressDynamic()
    394. 

  394.             .withoutPrimaryPublicIPAddress()
    395. 

  395.             .withProximityPlacementGroup(setCreated.proximityPlacementGroup().id())
    396. 

  396.             .withPopularWindowsImage(KnownWindowsVirtualMachineImage.WINDOWS_SERVER_2012_DATACENTER)
    397. 

  397.             .withAdminUsername("Foo12")
    398. 

  398.             .withAdminPassword("abc!@#F0orL")
    399. 

  399.             .withUnmanagedDisks()
    400. 

  400.             .withSize(VirtualMachineSizeTypes.STANDARD_DS3_V2)
    401. 

  401.             .withOSDiskCaching(CachingTypes.READ_WRITE)
    402. 

  402.             .withOSDiskName("javatest")
    403. 

  403.             .withLicenseType("Windows_Server")
    404. 

  404.             .create();
    405. 

  405. 

  406.         VirtualMachine foundVM = null;
    407. 

  407.         PagedIterable<VirtualMachine> vms = computeManager.virtualMachines().listByResourceGroup(rgName);
    408. 

  408.         for (VirtualMachine vm1 : vms) {
    409. 

  409.             if (vm1.name().equals(vmName)) {
    410. 

  410.                 foundVM = vm1;
    411. 

  411.                 break;
    412. 

  412.             }
    413. 

  413.         }
    414. 

  414.         Assertions.assertNotNull(foundVM);
    415. 

  415.         Assertions.assertEquals(regionProxPlacementGroup, foundVM.region());
    416. 

  416.         // Get
    417. 

  417.         foundVM = computeManager.virtualMachines().getByResourceGroup(rgName, vmName);
    418. 

  418.         Assertions.assertNotNull(foundVM);
    419. 

  419.         Assertions.assertEquals(regionProxPlacementGroup, foundVM.region());
    420. 

  420.         Assertions.assertEquals("Windows_Server", foundVM.licenseType());
    421. 

  421. 

  422.         // Fetch instance view
    423. 

  423.         PowerState powerState = foundVM.powerState();
    424. 

  424.         Assertions.assertEquals(powerState, PowerState.RUNNING);
    425. 

  425.         VirtualMachineInstanceView instanceView = foundVM.instanceView();
    426. 

  426.         Assertions.assertNotNull(instanceView);
    427. 

  427.         Assertions.assertNotNull(instanceView.statuses().size() > 0);
    428. 

  428. 

  429.         Assertions.assertNotNull(foundVM.proximityPlacementGroup());
    430. 

  430.         Assertions.assertEquals(proxGroupType, foundVM.proximityPlacementGroup().proximityPlacementGroupType());
    431. 

  431.         Assertions.assertNotNull(foundVM.proximityPlacementGroup().availabilitySetIds());
    432. 

  432.         Assertions.assertFalse(foundVM.proximityPlacementGroup().availabilitySetIds().isEmpty());
    433. 

  433.         Assertions
    434. 

  434.             .assertTrue(
    435. 

  435.                 setCreated.id().equalsIgnoreCase(foundVM.proximityPlacementGroup().availabilitySetIds().get(0)));
    436. 

  436.         Assertions.assertNotNull(foundVM.proximityPlacementGroup().virtualMachineIds());
    437. 

  437.         Assertions.assertFalse(foundVM.proximityPlacementGroup().virtualMachineIds().isEmpty());
    438. 

  438.         Assertions
    439. 

  439.             .assertTrue(foundVM.id().equalsIgnoreCase(setCreated.proximityPlacementGroup().virtualMachineIds().get(0)));
    440. 

  440. 

  441.         // Update Vm to remove it from proximity placement group
    442. 

  442.         VirtualMachine updatedVm = foundVM.update().withoutProximityPlacementGroup().apply();
    443. 

  443. 

  444.         Assertions.assertNotNull(updatedVm.proximityPlacementGroup());
    445. 

  445.         Assertions.assertEquals(proxGroupType, updatedVm.proximityPlacementGroup().proximityPlacementGroupType());
    446. 

  446.         Assertions.assertNotNull(updatedVm.proximityPlacementGroup().availabilitySetIds());
    447. 

  447.         Assertions.assertFalse(updatedVm.proximityPlacementGroup().availabilitySetIds().isEmpty());
    448. 

  448.         Assertions
    449. 

  449.             .assertTrue(
    450. 

  450.                 setCreated.id().equalsIgnoreCase(updatedVm.proximityPlacementGroup().availabilitySetIds().get(0)));
    451. 

  451. 

  452.         // TODO: this does not work... can not remove cvm from the placement group
    453. 

  453.         // Assertions.assertNull(foundVM.proximityPlacementGroup().virtualMachineIds());
    454. 

  454. 

  455.         // Delete VM
    456. 

  456.         computeManager.virtualMachines().deleteById(foundVM.id());
    457. 

  457.         computeManager.availabilitySets().deleteById(setCreated.id());
    458. 

  458.     }
    459. 

  459. 

  460.     @Test
    461. 

  461.     public void canCreateVirtualMachinesAndRelatedResourcesInParallel() throws Exception {
    462. 

  462.         String vmNamePrefix = "vmz";
    463. 

  463.         String publicIpNamePrefix = generateRandomResourceName("pip-", 15);
    464. 

  464.         String networkNamePrefix = generateRandomResourceName("vnet-", 15);
    465. 

  465.         int count = 5;
    466. 

  466. 

  467.         CreatablesInfo creatablesInfo =
    468. 

  468.             prepareCreatableVirtualMachines(region, vmNamePrefix, networkNamePrefix, publicIpNamePrefix, count);
    469. 

  469.         List<Creatable<VirtualMachine>> virtualMachineCreatables = creatablesInfo.virtualMachineCreatables;
    470. 

  470.         List<String> networkCreatableKeys = creatablesInfo.networkCreatableKeys;
    471. 

  471.         List<String> publicIpCreatableKeys = creatablesInfo.publicIpCreatableKeys;
    472. 

  472. 

  473.         CreatedResources<VirtualMachine> createdVirtualMachines =
    474. 

  474.             computeManager.virtualMachines().create(virtualMachineCreatables);
    475. 

  475.         Assertions.assertTrue(createdVirtualMachines.size() == count);
    476. 

  476. 

  477.         Set<String> virtualMachineNames = new HashSet<>();
    478. 

  478.         for (int i = 0; i < count; i++) {
    479. 

  479.             virtualMachineNames.add(String.format("%s-%d", vmNamePrefix, i));
    480. 

  480.         }
    481. 

  481.         for (VirtualMachine virtualMachine : createdVirtualMachines.values()) {
    482. 

  482.             Assertions.assertTrue(virtualMachineNames.contains(virtualMachine.name()));
    483. 

  483.             Assertions.assertNotNull(virtualMachine.id());
    484. 

  484.         }
    485. 

  485. 

  486.         Set<String> networkNames = new HashSet<>();
    487. 

  487.         for (int i = 0; i < count; i++) {
    488. 

  488.             networkNames.add(String.format("%s-%d", networkNamePrefix, i));
    489. 

  489.         }
    490. 

  490.         for (String networkCreatableKey : networkCreatableKeys) {
    491. 

  491.             Network createdNetwork = (Network) createdVirtualMachines.createdRelatedResource(networkCreatableKey);
    492. 

  492.             Assertions.assertNotNull(createdNetwork);
    493. 

  493.             Assertions.assertTrue(networkNames.contains(createdNetwork.name()));
    494. 

  494.         }
    495. 

  495. 

  496.         Set<String> publicIPAddressNames = new HashSet<>();
    497. 

  497.         for (int i = 0; i < count; i++) {
    498. 

  498.             publicIPAddressNames.add(String.format("%s-%d", publicIpNamePrefix, i));
    499. 

  499.         }
    500. 

  500.         for (String publicIpCreatableKey : publicIpCreatableKeys) {
    501. 

  501.             PublicIPAddress createdPublicIPAddress =
    502. 

  502.                 (PublicIPAddress) createdVirtualMachines.createdRelatedResource(publicIpCreatableKey);
    503. 

  503.             Assertions.assertNotNull(createdPublicIPAddress);
    504. 

  504.             Assertions.assertTrue(publicIPAddressNames.contains(createdPublicIPAddress.name()));
    505. 

  505.         }
    506. 

  506.     }
    507. 

  507. 

  508.     @Test
    509. 

  509.     public void canStreamParallelCreatedVirtualMachinesAndRelatedResources() throws Exception {
    510. 

  510.         String vmNamePrefix = "vmz";
    511. 

  511.         String publicIpNamePrefix = generateRandomResourceName("pip-", 15);
    512. 

  512.         String networkNamePrefix = generateRandomResourceName("vnet-", 15);
    513. 

  513.         int count = 5;
    514. 

  514. 

  515.         final Set<String> virtualMachineNames = new HashSet<>();
    516. 

  516.         for (int i = 0; i < count; i++) {
    517. 

  517.             virtualMachineNames.add(String.format("%s-%d", vmNamePrefix, i));
    518. 

  518.         }
    519. 

  519. 

  520.         final Set<String> networkNames = new HashSet<>();
    521. 

  521.         for (int i = 0; i < count; i++) {
    522. 

  522.             networkNames.add(String.format("%s-%d", networkNamePrefix, i));
    523. 

  523.         }
    524. 

  524. 

  525.         final Set<String> publicIPAddressNames = new HashSet<>();
    526. 

  526.         for (int i = 0; i < count; i++) {
    527. 

  527.             publicIPAddressNames.add(String.format("%s-%d", publicIpNamePrefix, i));
    528. 

  528.         }
    529. 

  529. 

  530.         final CreatablesInfo creatablesInfo =
    531. 

  531.             prepareCreatableVirtualMachines(region, vmNamePrefix, networkNamePrefix, publicIpNamePrefix, count);
    532. 

  532.         final AtomicInteger resourceCount = new AtomicInteger(0);
    533. 

  533.         List<Creatable<VirtualMachine>> virtualMachineCreatables = creatablesInfo.virtualMachineCreatables;
    534. 

  534.         computeManager
    535. 

  535.             .virtualMachines()
    536. 

  536.             .createAsync(virtualMachineCreatables)
    537. 

  537.             .map(
    538. 

  538.                 createdResource -> {
    539. 

  539.                     if (createdResource instanceof Resource) {
    540. 

  540.                         Resource resource = (Resource) createdResource;
    541. 

  541.                         System.out.println("Created: " + resource.id());
    542. 

  542.                         if (resource instanceof VirtualMachine) {
    543. 

  543.                             VirtualMachine virtualMachine = (VirtualMachine) resource;
    544. 

  544.                             Assertions.assertTrue(virtualMachineNames.contains(virtualMachine.name()));
    545. 

  545.                             Assertions.assertNotNull(virtualMachine.id());
    546. 

  546.                         } else if (resource instanceof Network) {
    547. 

  547.                             Network network = (Network) resource;
    548. 

  548.                             Assertions.assertTrue(networkNames.contains(network.name()));
    549. 

  549.                             Assertions.assertNotNull(network.id());
    550. 

  550.                         } else if (resource instanceof PublicIPAddress) {
    551. 

  551.                             PublicIPAddress publicIPAddress = (PublicIPAddress) resource;
    552. 

  552.                             Assertions.assertTrue(publicIPAddressNames.contains(publicIPAddress.name()));
    553. 

  553.                             Assertions.assertNotNull(publicIPAddress.id());
    554. 

  554.                         }
    555. 

  555.                     }
    556. 

  556.                     resourceCount.incrementAndGet();
    557. 

  557.                     return createdResource;
    558. 

  558.                 })
    559. 

  559.             .collectList()
    560. 

  560.             .block();
    561. 

  561.         // 1 resource group, 1 storage, 5 network, 5 publicIp, 5 nic, 5 virtual machines
    562. 

  562.         // Additional one for CreatableUpdatableResourceRoot.
    563. 

  563.         // TODO: - ans - We should not emit CreatableUpdatableResourceRoot.
    564. 

  564.         Assertions.assertEquals(resourceCount.get(), 23);
    565. 

  565.     }
    566. 

  566. 

  567.     @Test
    568. 

  568.     public void canSetStorageAccountForUnmanagedDisk() {
    569. 

  569.         final String storageName = sdkContext.randomResourceName("st", 14);
    570. 

  570.         // Create a premium storage account for virtual machine data disk
    571. 

  571.         //
    572. 

  572.         StorageAccount storageAccount =
    573. 

  573.             storageManager
    574. 

  574.                 .storageAccounts()
    575. 

  575.                 .define(storageName)
    576. 

  576.                 .withRegion(region)
    577. 

  577.                 .withNewResourceGroup(rgName)
    578. 

  578.                 .withSku(SkuName.PREMIUM_LRS)
    579. 

  579.                 .create();
    580. 

  580. 

  581.         // Creates a virtual machine with an unmanaged data disk that gets stored in the above
    582. 

  582.         // premium storage account
    583. 

  583.         //
    584. 

  584.         VirtualMachine virtualMachine =
    585. 

  585.             computeManager
    586. 

  586.                 .virtualMachines()
    587. 

  587.                 .define(vmName)
    588. 

  588.                 .withRegion(region)
    589. 

  589.                 .withExistingResourceGroup(rgName)
    590. 

  590.                 .withNewPrimaryNetwork("10.0.0.0/28")
    591. 

  591.                 .withPrimaryPrivateIPAddressDynamic()
    592. 

  592.                 .withoutPrimaryPublicIPAddress()
    593. 

  593.                 .withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
    594. 

  594.                 .withRootUsername("Foo12")
    595. 

  595.                 .withRootPassword("abc!@#F0orL")
    596. 

  596.                 .withUnmanagedDisks()
    597. 

  597.                 .defineUnmanagedDataDisk("disk1")
    598. 

  598.                 .withNewVhd(100)
    599. 

  599.                 .withLun(2)
    600. 

  600.                 .storeAt(storageAccount.name(), "diskvhds", "datadisk1vhd.vhd")
    601. 

  601.                 .attach()
    602. 

  602.                 .defineUnmanagedDataDisk("disk2")
    603. 

  603.                 .withNewVhd(100)
    604. 

  604.                 .withLun(3)
    605. 

  605.                 .storeAt(storageAccount.name(), "diskvhds", "datadisk2vhd.vhd")
    606. 

  606.                 .attach()
    607. 

  607.                 .withSize(VirtualMachineSizeTypes.STANDARD_DS2_V2)
    608. 

  608.                 .withOSDiskCaching(CachingTypes.READ_WRITE)
    609. 

  609.                 .create();
    610. 

  610. 

  611.         // Validate the unmanaged data disks
    612. 

  612.         //
    613. 

  613.         Map<Integer, VirtualMachineUnmanagedDataDisk> unmanagedDataDisks = virtualMachine.unmanagedDataDisks();
    614. 

  614.         Assertions.assertNotNull(unmanagedDataDisks);
    615. 

  615.         Assertions.assertEquals(2, unmanagedDataDisks.size());
    616. 

  616.         VirtualMachineUnmanagedDataDisk firstUnmanagedDataDisk = unmanagedDataDisks.get(2);
    617. 

  617.         Assertions.assertNotNull(firstUnmanagedDataDisk);
    618. 

  618.         VirtualMachineUnmanagedDataDisk secondUnmanagedDataDisk = unmanagedDataDisks.get(3);
    619. 

  619.         Assertions.assertNotNull(secondUnmanagedDataDisk);
    620. 

  620.         String createdVhdUri1 = firstUnmanagedDataDisk.vhdUri();
    621. 

  621.         String createdVhdUri2 = secondUnmanagedDataDisk.vhdUri();
    622. 

  622.         Assertions.assertNotNull(createdVhdUri1);
    623. 

  623.         Assertions.assertNotNull(createdVhdUri2);
    624. 

  624.         // delete the virtual machine
    625. 

  625.         //
    626. 

  626.         computeManager.virtualMachines().deleteById(virtualMachine.id());
    627. 

  627.         // Creates another virtual machine by attaching existing unmanaged data disk detached from the
    628. 

  628.         // above virtual machine.
    629. 

  629.         //
    630. 

  630.         virtualMachine =
    631. 

  631.             computeManager
    632. 

  632.                 .virtualMachines()
    633. 

  633.                 .define(vmName)
    634. 

  634.                 .withRegion(region)
    635. 

  635.                 .withExistingResourceGroup(rgName)
    636. 

  636.                 .withNewPrimaryNetwork("10.0.0.0/28")
    637. 

  637.                 .withPrimaryPrivateIPAddressDynamic()
    638. 

  638.                 .withoutPrimaryPublicIPAddress()
    639. 

  639.                 .withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
    640. 

  640.                 .withRootUsername("Foo12")
    641. 

  641.                 .withRootPassword("abc!@#F0orL")
    642. 

  642.                 .withUnmanagedDisks()
    643. 

  643.                 .withExistingUnmanagedDataDisk(storageAccount.name(), "diskvhds", "datadisk1vhd.vhd")
    644. 

  644.                 .withSize(VirtualMachineSizeTypes.STANDARD_DS2_V2)
    645. 

  645.                 .create();
    646. 

  646.         // Gets the vm
    647. 

  647.         //
    648. 

  648.         virtualMachine = computeManager.virtualMachines().getById(virtualMachine.id());
    649. 

  649.         // Validate the unmanaged data disks
    650. 

  650.         //
    651. 

  651.         unmanagedDataDisks = virtualMachine.unmanagedDataDisks();
    652. 

  652.         Assertions.assertNotNull(unmanagedDataDisks);
    653. 

  653.         Assertions.assertEquals(1, unmanagedDataDisks.size());
    654. 

  654.         firstUnmanagedDataDisk = null;
    655. 

  655.         for (VirtualMachineUnmanagedDataDisk unmanagedDisk : unmanagedDataDisks.values()) {
    656. 

  656.             firstUnmanagedDataDisk = unmanagedDisk;
    657. 

  657.             break;
    658. 

  658.         }
    659. 

  659.         Assertions.assertNotNull(firstUnmanagedDataDisk.vhdUri());
    660. 

  660.         Assertions.assertTrue(firstUnmanagedDataDisk.vhdUri().equalsIgnoreCase(createdVhdUri1));
    661. 

  661.         // Update the VM by attaching another existing data disk
    662. 

  662.         //
    663. 

  663.         virtualMachine
    664. 

  664.             .update()
    665. 

  665.             .withExistingUnmanagedDataDisk(storageAccount.name(), "diskvhds", "datadisk2vhd.vhd")
    666. 

  666.             .apply();
    667. 

  667.         // Gets the vm
    668. 

  668.         //
    669. 

  669.         virtualMachine = computeManager.virtualMachines().getById(virtualMachine.id());
    670. 

  670.         // Validate the unmanaged data disks
    671. 

  671.         //
    672. 

  672.         unmanagedDataDisks = virtualMachine.unmanagedDataDisks();
    673. 

  673.         Assertions.assertNotNull(unmanagedDataDisks);
    674. 

  674.         Assertions.assertEquals(2, unmanagedDataDisks.size());
    675. 

  675.     }
    676. 

  676. 

  677.     @Test
    678. 

  678.     public void canUpdateTagsOnVM() {
    679. 

  679.         // Create
    680. 

  680.         VirtualMachine virtualMachine =
    681. 

  681.             computeManager
    682. 

  682.                 .virtualMachines()
    683. 

  683.                 .define(vmName)
    684. 

  684.                 .withRegion(region)
    685. 

  685.                 .withNewResourceGroup(rgName)
    686. 

  686.                 .withNewPrimaryNetwork("10.0.0.0/28")
    687. 

  687.                 .withPrimaryPrivateIPAddressDynamic()
    688. 

  688.                 .withoutPrimaryPublicIPAddress()
    689. 

  689.                 .withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
    690. 

  690.                 .withRootUsername("firstuser")
    691. 

  691.                 .withRootPassword("afh123RVS!")
    692. 

  692.                 .withSize(VirtualMachineSizeTypes.STANDARD_D3_V2)
    693. 

  693.                 .create();
    694. 

  694. 

  695.         // checking to see if withTag correctly update
    696. 

  696.         virtualMachine.update().withTag("test", "testValue").apply();
    697. 

  697.         Assertions.assertEquals("testValue", virtualMachine.inner().tags().get("test"));
    698. 

  698. 

  699.         // checking to see if withTags correctly updates
    700. 

  700.         Map<String, String> testTags = new HashMap<String, String>();
    701. 

  701.         testTags.put("testTag", "testValue");
    702. 

  702.         virtualMachine.update().withTags(testTags).apply();
    703. 

  703.         Assertions.assertEquals(testTags, virtualMachine.inner().tags());
    704. 

  704.     }
    705. 

  705. 

  706.     @Test
    707. 

  707.     public void canRunScriptOnVM() {
    708. 

  708.         // Create
    709. 

  709.         VirtualMachine virtualMachine =
    710. 

  710.             computeManager
    711. 

  711.                 .virtualMachines()
    712. 

  712.                 .define(vmName)
    713. 

  713.                 .withRegion(region)
    714. 

  714.                 .withNewResourceGroup(rgName)
    715. 

  715.                 .withNewPrimaryNetwork("10.0.0.0/28")
    716. 

  716.                 .withPrimaryPrivateIPAddressDynamic()
    717. 

  717.                 .withoutPrimaryPublicIPAddress()
    718. 

  718.                 .withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
    719. 

  719.                 .withRootUsername("firstuser")
    720. 

  720.                 .withRootPassword("afh123RVS!")
    721. 

  721.                 .create();
    722. 

  722. 

  723.         List<String> installGit = new ArrayList<>();
    724. 

  724.         installGit.add("sudo apt-get update");
    725. 

  725.         installGit.add("sudo apt-get install -y git");
    726. 

  726. 

  727.         RunCommandResult runResult =
    728. 

  728.             virtualMachine.runShellScript(installGit, new ArrayList<RunCommandInputParameter>());
    729. 

  729.         Assertions.assertNotNull(runResult);
    730. 

  730.         Assertions.assertNotNull(runResult.value());
    731. 

  731.         Assertions.assertTrue(runResult.value().size() > 0);
    732. 

  732.     }
    733. 

  733. 

  734.     private CreatablesInfo prepareCreatableVirtualMachines(
    735. 

  735.         Region region, String vmNamePrefix, String networkNamePrefix, String publicIpNamePrefix, int vmCount) {
    736. 

  736. 

  737.         Creatable<ResourceGroup> resourceGroupCreatable =
    738. 

  738.             resourceManager.resourceGroups().define(rgName).withRegion(region);
    739. 

  739. 

  740.         Creatable<StorageAccount> storageAccountCreatable =
    741. 

  741.             storageManager
    742. 

  742.                 .storageAccounts()
    743. 

  743.                 .define(generateRandomResourceName("stg", 20))
    744. 

  744.                 .withRegion(region)
    745. 

  745.                 .withNewResourceGroup(resourceGroupCreatable);
    746. 

  746. 

  747.         List<String> networkCreatableKeys = new ArrayList<>();
    748. 

  748.         List<String> publicIpCreatableKeys = new ArrayList<>();
    749. 

  749.         List<Creatable<VirtualMachine>> virtualMachineCreatables = new ArrayList<>();
    750. 

  750.         for (int i = 0; i < vmCount; i++) {
    751. 

  751.             Creatable<Network> networkCreatable =
    752. 

  752.                 networkManager
    753. 

  753.                     .networks()
    754. 

  754.                     .define(String.format("%s-%d", networkNamePrefix, i))
    755. 

  755.                     .withRegion(region)
    756. 

  756.                     .withNewResourceGroup(resourceGroupCreatable)
    757. 

  757.                     .withAddressSpace("10.0.0.0/28");
    758. 

  758.             networkCreatableKeys.add(networkCreatable.key());
    759. 

  759. 

  760.             Creatable<PublicIPAddress> publicIPAddressCreatable =
    761. 

  761.                 networkManager
    762. 

  762.                     .publicIPAddresses()
    763. 

  763.                     .define(String.format("%s-%d", publicIpNamePrefix, i))
    764. 

  764.                     .withRegion(region)
    765. 

  765.                     .withNewResourceGroup(resourceGroupCreatable);
    766. 

  766.             publicIpCreatableKeys.add(publicIPAddressCreatable.key());
    767. 

  767. 

  768.             Creatable<VirtualMachine> virtualMachineCreatable =
    769. 

  769.                 computeManager
    770. 

  770.                     .virtualMachines()
    771. 

  771.                     .define(String.format("%s-%d", vmNamePrefix, i))
    772. 

  772.                     .withRegion(region)
    773. 

  773.                     .withNewResourceGroup(resourceGroupCreatable)
    774. 

  774.                     .withNewPrimaryNetwork(networkCreatable)
    775. 

  775.                     .withPrimaryPrivateIPAddressDynamic()
    776. 

  776.                     .withNewPrimaryPublicIPAddress(publicIPAddressCreatable)
    777. 

  777.                     .withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS)
    778. 

  778.                     .withRootUsername("tirekicker")
    779. 

  779.                     .withRootPassword("BaR@12!#")
    780. 

  780.                     .withUnmanagedDisks()
    781. 

  781.                     .withNewStorageAccount(storageAccountCreatable);
    782. 

  782. 

  783.             virtualMachineCreatables.add(virtualMachineCreatable);
    784. 

  784.         }
    785. 

  785.         CreatablesInfo creatablesInfo = new CreatablesInfo();
    786. 

  786.         creatablesInfo.virtualMachineCreatables = virtualMachineCreatables;
    787. 

  787.         creatablesInfo.networkCreatableKeys = networkCreatableKeys;
    788. 

  788.         creatablesInfo.publicIpCreatableKeys = publicIpCreatableKeys;
    789. 

  789.         return creatablesInfo;
    790. 

  790.     }
    791. 

  791. 

  792.     class CreatablesInfo {
    793. 

  793.         private List<Creatable<VirtualMachine>> virtualMachineCreatables;
    794. 

  794.         List<String> networkCreatableKeys;
    795. 

  795.         List<String> publicIpCreatableKeys;
    796. 

  796.     }
    797. 

  797. }
    798. 

  798.