Examples with Indexable com.microsoft.azure.management.resources.fluentcore.model.Indexable used on opensource projects

Example 6 with Indexable

use of com.microsoft.azure.management.resources.fluentcore.model.Indexable in project azure-sdk-for-java by Azure.

the class ManageWebAppSourceControlAsync method runSample.

/**
     * Main function which runs the actual sample.
     * @param azure instance of the azure client
     * @return true if sample runs successfully
     */
public static boolean runSample(final Azure azure) {
    // New resources
    final String suffix = ".azurewebsites.net";
    final String app1Name = SdkContext.randomResourceName("webapp1-", 20);
    final String app2Name = SdkContext.randomResourceName("webapp2-", 20);
    final String app3Name = SdkContext.randomResourceName("webapp3-", 20);
    final String app4Name = SdkContext.randomResourceName("webapp4-", 20);
    final String app1Url = app1Name + suffix;
    final String app2Url = app2Name + suffix;
    final String app3Url = app3Name + suffix;
    final String app4Url = app4Name + suffix;
    final String planName = SdkContext.randomResourceName("jplan_", 15);
    final String rgName = SdkContext.randomResourceName("rg1NEMV_", 24);
    try {
        //============================================================
        // Create a web app with a new app service plan
        System.out.println("Creating web app " + app1Name + " in resource group " + rgName + "...");
        Observable<?> app1Observable = azure.webApps().define(app1Name).withRegion(Region.US_WEST).withNewResourceGroup(rgName).withNewWindowsPlan(PricingTier.STANDARD_S1).withJavaVersion(JavaVersion.JAVA_8_NEWEST).withWebContainer(WebContainer.TOMCAT_8_0_NEWEST).createAsync().flatMap(new Func1<Indexable, Observable<?>>() {

            @Override
            public Observable<?> call(Indexable indexable) {
                if (indexable instanceof WebApp) {
                    WebApp app = (WebApp) indexable;
                    System.out.println("Created web app " + app.name());
                    return Observable.merge(Observable.just(indexable), app.getPublishingProfileAsync().map(new Func1<PublishingProfile, PublishingProfile>() {

                        @Override
                        public PublishingProfile call(PublishingProfile publishingProfile) {
                            System.out.println("Deploying helloworld.war to " + app1Name + " through FTP...");
                            Utils.uploadFileToFtp(publishingProfile, "helloworld.war", ManageWebAppSourceControlAsync.class.getResourceAsStream("/helloworld.war"));
                            System.out.println("Deployment helloworld.war to web app " + app1Name + " completed");
                            return publishingProfile;
                        }
                    }));
                }
                return Observable.just(indexable);
            }
        });
        System.out.println("Creating another web app " + app2Name + " in resource group " + rgName + "...");
        System.out.println("Creating another web app " + app3Name + "...");
        System.out.println("Creating another web app " + app4Name + "...");
        Observable<?> app234Observable = azure.appServices().appServicePlans().getByResourceGroupAsync(rgName, planName).flatMap(new Func1<AppServicePlan, Observable<Indexable>>() {

            @Override
            public Observable<Indexable> call(AppServicePlan plan) {
                return Observable.merge(azure.webApps().define(app2Name).withExistingWindowsPlan(plan).withExistingResourceGroup(rgName).withLocalGitSourceControl().withJavaVersion(JavaVersion.JAVA_8_NEWEST).withWebContainer(WebContainer.TOMCAT_8_0_NEWEST).createAsync(), azure.webApps().define(app3Name).withExistingWindowsPlan(plan).withNewResourceGroup(rgName).defineSourceControl().withPublicGitRepository("https://github.com/Azure-Samples/app-service-web-dotnet-get-started").withBranch("master").attach().createAsync(), azure.webApps().define(app4Name).withExistingWindowsPlan(plan).withExistingResourceGroup(rgName).createAsync());
            }
        }).flatMap(new Func1<Indexable, Observable<?>>() {

            @Override
            public Observable<?> call(Indexable indexable) {
                if (indexable instanceof WebApp) {
                    WebApp app = (WebApp) indexable;
                    System.out.println("Created web app " + app.name());
                    if (!app.name().equals(app2Name)) {
                        return Observable.just(indexable);
                    }
                    // for the second web app Deploy a local Tomcat
                    return app.getPublishingProfileAsync().map(new Func1<PublishingProfile, PublishingProfile>() {

                        @Override
                        public PublishingProfile call(PublishingProfile profile) {
                            System.out.println("Deploying a local Tomcat source to " + app2Name + " through Git...");
                            Git git = null;
                            try {
                                git = Git.init().setDirectory(new File(ManageWebAppSourceControlAsync.class.getResource("/azure-samples-appservice-helloworld/").getPath())).call();
                                git.add().addFilepattern(".").call();
                                git.commit().setMessage("Initial commit").call();
                                PushCommand command = git.push();
                                command.setRemote(profile.gitUrl());
                                command.setCredentialsProvider(new UsernamePasswordCredentialsProvider(profile.gitUsername(), profile.gitPassword()));
                                command.setRefSpecs(new RefSpec("master:master"));
                                command.setForce(true);
                                command.call();
                            } catch (GitAPIException e) {
                                e.printStackTrace();
                            }
                            System.out.println("Deployment to web app " + app2Name + " completed");
                            return profile;
                        }
                    });
                }
                return Observable.just(indexable);
            }
        });
        Observable.merge(app1Observable, app234Observable).toBlocking().subscribe();
        // warm up
        System.out.println("Warming up " + app1Url + "/helloworld...");
        curl("http://" + app1Url + "/helloworld");
        System.out.println("Warming up " + app2Url + "/helloworld...");
        curl("http://" + app2Url + "/helloworld");
        System.out.println("Warming up " + app3Url + "...");
        curl("http://" + app3Url);
        System.out.println("Warming up " + app4Url + "...");
        curl("http://" + app4Url);
        Thread.sleep(5000);
        System.out.println("CURLing " + app1Url + "/helloworld...");
        System.out.println(curl("http://" + app1Url + "/helloworld"));
        System.out.println("CURLing " + app2Url + "/helloworld...");
        System.out.println(curl("http://" + app2Url + "/helloworld"));
        System.out.println("CURLing " + app3Url + "...");
        System.out.println(curl("http://" + app3Url));
        System.out.println("CURLing " + app4Url + "...");
        System.out.println(curl("http://" + app4Url));
        return true;
    } catch (Exception e) {
        System.err.println(e.getMessage());
        e.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().beginDeleteByNameAsync(rgName).toBlocking().subscribe();
            System.out.println("Deleted Resource Group: " + rgName);
        } catch (NullPointerException npe) {
            System.out.println("Did not create any resources in Azure. No clean up is necessary");
        } catch (Exception g) {
            g.printStackTrace();
        }
    }
    return false;
}

Example 7 with Indexable

use of com.microsoft.azure.management.resources.fluentcore.model.Indexable in project azure-sdk-for-java by Azure.

the class TestNSG method createResource.

@Override
public NetworkSecurityGroup createResource(NetworkSecurityGroups nsgs) throws Exception {
    final String newName = "nsg" + this.testId;
    final String resourceGroupName = "rg" + this.testId;
    final String nicName = "nic" + this.testId;
    final Region region = Region.US_WEST;
    final SettableFuture<NetworkSecurityGroup> nsgFuture = SettableFuture.create();
    // Create
    Observable<Indexable> resourceStream = nsgs.define(newName).withRegion(region).withNewResourceGroup(resourceGroupName).defineRule("rule1").allowOutbound().fromAnyAddress().fromPort(80).toAnyAddress().toPort(80).withProtocol(SecurityRuleProtocol.TCP).attach().defineRule("rule2").allowInbound().fromAnyAddress().fromAnyPort().toAnyAddress().toPortRange(22, 25).withAnyProtocol().withPriority(200).withDescription("foo!!").attach().createAsync();
    Utils.<NetworkSecurityGroup>rootResource(resourceStream).subscribe(new Subscriber<NetworkSecurityGroup>() {

        @Override
        public void onCompleted() {
            System.out.print("completed");
        }

        @Override
        public void onError(Throwable throwable) {
            nsgFuture.setException(throwable);
        }

        @Override
        public void onNext(NetworkSecurityGroup networkSecurityGroup) {
            nsgFuture.set(networkSecurityGroup);
        }
    });
    NetworkSecurityGroup nsg = nsgFuture.get();
    NetworkInterface nic = nsgs.manager().networkInterfaces().define(nicName).withRegion(region).withExistingResourceGroup(resourceGroupName).withNewPrimaryNetwork("10.0.0.0/28").withPrimaryPrivateIPAddressDynamic().withExistingNetworkSecurityGroup(nsg).create();
    nsg.refresh();
    // Verify
    Assert.assertTrue(nsg.region().equals(region));
    Assert.assertTrue(nsg.securityRules().size() == 2);
    // Confirm NIC association
    Assert.assertEquals(1, nsg.networkInterfaceIds().size());
    Assert.assertTrue(nsg.networkInterfaceIds().contains(nic.id()));
    return nsg;
}

Example 8 with Indexable

use of com.microsoft.azure.management.resources.fluentcore.model.Indexable in project azure-sdk-for-java by Azure.

the class ManageStorageAccountAsync method runSample.

/**
     * Main function which runs the actual sample.
     * @param azure instance of the azure client
     * @return true if sample runs successfully
     */
public static boolean runSample(final Azure azure) {
    final String storageAccountName = Utils.createRandomName("sa");
    final String storageAccountName2 = Utils.createRandomName("sa2");
    final String rgName = Utils.createRandomName("rgSTMS");
    try {
        // ============================================================
        // Create storage accounts
        System.out.println("Creating a Storage Accounts");
        Observable.merge(azure.storageAccounts().define(storageAccountName).withRegion(Region.US_EAST).withNewResourceGroup(rgName).createAsync(), azure.storageAccounts().define(storageAccountName2).withRegion(Region.US_EAST).withNewResourceGroup(rgName).createAsync()).map(new Func1<Indexable, Indexable>() {

            @Override
            public Indexable call(Indexable indexable) {
                if (indexable instanceof StorageAccount) {
                    StorageAccount storageAccount = (StorageAccount) indexable;
                    System.out.println("Created a Storage Account:");
                    Utils.print(storageAccount);
                }
                return indexable;
            }
        }).toBlocking().last();
        // ============================================================
        // List storage accounts and regenerate storage account access keys
        System.out.println("Listing storage accounts");
        StorageAccounts storageAccounts = azure.storageAccounts();
        storageAccounts.listByResourceGroupAsync(rgName).flatMap(new Func1<StorageAccount, Observable<List<StorageAccountKey>>>() {

            @Override
            public Observable<List<StorageAccountKey>> call(final StorageAccount storageAccount) {
                System.out.println("Getting storage account access keys for Storage Account " + storageAccount.name() + " created @ " + storageAccount.creationTime());
                return storageAccount.getKeysAsync().flatMap(new Func1<List<StorageAccountKey>, Observable<List<StorageAccountKey>>>() {

                    @Override
                    public Observable<List<StorageAccountKey>> call(List<StorageAccountKey> storageAccountKeys) {
                        System.out.println("Regenerating first storage account access key");
                        return storageAccount.regenerateKeyAsync(storageAccountKeys.get(0).keyName());
                    }
                });
            }
        }).map(new Func1<List<StorageAccountKey>, List<StorageAccountKey>>() {

            @Override
            public List<StorageAccountKey> call(List<StorageAccountKey> storageAccountKeys) {
                Utils.print(storageAccountKeys);
                return storageAccountKeys;
            }
        }).toBlocking().last();
        // ============================================================
        // Delete storage accounts
        storageAccounts.listByResourceGroupAsync(rgName).flatMap(new Func1<StorageAccount, Observable<Void>>() {

            @Override
            public Observable<Void> call(StorageAccount storageAccount) {
                System.out.println("Deleting a storage account - " + storageAccount.name() + " created @ " + storageAccount.creationTime());
                return azure.storageAccounts().deleteByIdAsync(storageAccount.id()).toObservable();
            }
        }).toCompletable().await();
        return true;
    } catch (Exception f) {
        System.out.println(f.getMessage());
        f.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().deleteByNameAsync(rgName).await();
            System.out.println("Deleted Resource Group: " + rgName);
        } catch (Exception e) {
            System.out.println("Did not create any resources in Azure. No clean up is necessary");
        }
    }
    return false;
}

Example 9 with Indexable

use of com.microsoft.azure.management.resources.fluentcore.model.Indexable in project azure-sdk-for-java by Azure.

the class VirtualMachineOperationsTests method canDeleteRelatedResourcesFromFailedParallelVMCreations.

@Test
@Ignore("Can't be played from recording for some reason...")
public void canDeleteRelatedResourcesFromFailedParallelVMCreations() {
    final int desiredVMCount = 40;
    final Region region = Region.US_EAST;
    final String resourceGroupName = RG_NAME;
    // Create one resource group for everything, to ensure no reliance on resource groups
    ResourceGroup resourceGroup = resourceManager.resourceGroups().define(resourceGroupName).withRegion(region).create();
    // Needed for tracking related resources
    final Map<String, Collection<Creatable<? extends Resource>>> vmNonNicResourceDefinitions = new HashMap<>();
    // Tracking NICs separately because they have to be deleted first
    final Map<String, Creatable<NetworkInterface>> nicDefinitions = new HashMap<>();
    final Map<String, Creatable<VirtualMachine>> vmDefinitions = new HashMap<>();
    final Map<String, String> createdResourceIds = new HashMap<>();
    final List<Throwable> errors = new ArrayList<>();
    // Prepare a number of VM definitions along with their related resource definitions
    for (int i = 0; i < desiredVMCount; i++) {
        Collection<Creatable<? extends Resource>> relatedDefinitions = new ArrayList<>();
        // Define a network for each VM
        String networkName = SdkContext.randomResourceName("net", 14);
        Creatable<Network> networkDefinition = networkManager.networks().define(networkName).withRegion(region).withExistingResourceGroup(resourceGroup).withAddressSpace("10.0." + i + ".0/29");
        relatedDefinitions.add(networkDefinition);
        // Define a PIP for each VM
        String pipName = SdkContext.randomResourceName("pip", 14);
        PublicIPAddress.DefinitionStages.WithCreate pipDefinition = this.networkManager.publicIPAddresses().define(pipName).withRegion(region).withExistingResourceGroup(resourceGroup);
        relatedDefinitions.add(pipDefinition);
        // Define a NIC for each VM
        String nicName = SdkContext.randomResourceName("nic", 14);
        Creatable<NetworkInterface> nicDefinition = networkManager.networkInterfaces().define(nicName).withRegion(region).withExistingResourceGroup(resourceGroup).withNewPrimaryNetwork(networkDefinition).withPrimaryPrivateIPAddressDynamic().withNewPrimaryPublicIPAddress(pipDefinition);
        // Define a storage account for each VM
        String storageAccountName = SdkContext.randomResourceName("st", 14);
        Creatable<StorageAccount> storageAccountDefinition = storageManager.storageAccounts().define(storageAccountName).withRegion(region).withExistingResourceGroup(resourceGroup);
        relatedDefinitions.add(storageAccountDefinition);
        // Define an availability set for each VM
        String availabilitySetName = SdkContext.randomResourceName("as", 14);
        Creatable<AvailabilitySet> availabilitySetDefinition = computeManager.availabilitySets().define(availabilitySetName).withRegion(region).withExistingResourceGroup(resourceGroup);
        relatedDefinitions.add(availabilitySetDefinition);
        String vmName = SdkContext.randomResourceName("vm", 14);
        // Define a VM
        String userName;
        if (i == desiredVMCount / 2) {
            // Intentionally cause a failure in one of the VMs
            userName = "";
        } else {
            userName = "tester";
        }
        Creatable<VirtualMachine> vmDefinition = computeManager.virtualMachines().define(vmName).withRegion(region).withExistingResourceGroup(resourceGroup).withNewPrimaryNetworkInterface(nicDefinition).withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withRootPassword("Abcdef.123456!").withNewStorageAccount(storageAccountDefinition).withSize(VirtualMachineSizeTypes.STANDARD_DS1_V2).withNewAvailabilitySet(availabilitySetDefinition);
        // Keep track of all the related resource definitions based on the VM definition
        vmNonNicResourceDefinitions.put(vmDefinition.key(), relatedDefinitions);
        nicDefinitions.put(vmDefinition.key(), nicDefinition);
        vmDefinitions.put(vmDefinition.key(), vmDefinition);
    }
    // Start the parallel creation of everything
    computeManager.virtualMachines().createAsync(new ArrayList<>(vmDefinitions.values())).map(new Func1<Indexable, Indexable>() {

        @Override
        public Indexable call(Indexable createdResource) {
            if (createdResource instanceof Resource) {
                Resource resource = (Resource) createdResource;
                System.out.println("Created: " + resource.id());
                if (resource instanceof VirtualMachine) {
                    VirtualMachine virtualMachine = (VirtualMachine) resource;
                    // Record that this VM was created successfully
                    vmDefinitions.remove(virtualMachine.key());
                    // Remove the associated resources from cleanup list
                    vmNonNicResourceDefinitions.remove(virtualMachine.key());
                    // Remove the associated NIC from cleanup list
                    nicDefinitions.remove(virtualMachine.key());
                } else {
                    // Add this related resource to potential cleanup list
                    createdResourceIds.put(resource.key(), resource.id());
                }
            }
            return createdResource;
        }
    }).onErrorReturn(new Func1<Throwable, Indexable>() {

        @Override
        public Indexable call(Throwable throwable) {
            errors.add(throwable);
            return null;
        }
    }).toBlocking().last();
    // Delete remaining successfully created NICs of failed VM creations
    Collection<String> nicIdsToDelete = new ArrayList<>();
    for (Creatable<NetworkInterface> nicDefinition : nicDefinitions.values()) {
        String nicId = createdResourceIds.get(nicDefinition.key());
        if (nicId != null) {
            nicIdsToDelete.add(nicId);
        }
    }
    if (!nicIdsToDelete.isEmpty()) {
        networkManager.networkInterfaces().deleteByIds(nicIdsToDelete);
    }
    // Delete remaining successfully created resources of failed VM creations
    Collection<Completable> deleteObservables = new ArrayList<>();
    for (Collection<Creatable<? extends Resource>> relatedResources : vmNonNicResourceDefinitions.values()) {
        for (Creatable<? extends Resource> resource : relatedResources) {
            String createdResourceId = createdResourceIds.get(resource.key());
            if (createdResourceId != null) {
                deleteObservables.add(resourceManager.genericResources().deleteByIdAsync(createdResourceId));
            }
        }
    }
    // Delete as much as possible, postponing the errors till the end
    Completable.mergeDelayError(deleteObservables).await();
    // Show any errors
    for (Throwable error : errors) {
        System.out.println("\n### ERROR ###\n");
        if (error instanceof CloudException) {
            CloudException ce = (CloudException) error;
            System.out.println("CLOUD EXCEPTION: " + ce.getMessage());
        } else {
            error.printStackTrace();
        }
    }
    System.out.println("Number of failed/cleaned up VM creations: " + vmNonNicResourceDefinitions.size());
    // Verifications
    final int successfulVMCount = desiredVMCount - vmNonNicResourceDefinitions.size();
    final int actualVMCount = computeManager.virtualMachines().listByResourceGroup(resourceGroupName).size();
    System.out.println("Number of actual successful VMs: " + actualVMCount);
    Assert.assertEquals(successfulVMCount, actualVMCount);
    final int actualNicCount = networkManager.networkInterfaces().listByResourceGroup(resourceGroupName).size();
    Assert.assertEquals(successfulVMCount, actualNicCount);
    final int actualNetworkCount = networkManager.networks().listByResourceGroup(resourceGroupName).size();
    Assert.assertEquals(successfulVMCount, actualNetworkCount);
    final int actualPipCount = networkManager.publicIPAddresses().listByResourceGroup(resourceGroupName).size();
    Assert.assertEquals(successfulVMCount, actualPipCount);
    final int actualAvailabilitySetCount = computeManager.availabilitySets().listByResourceGroup(resourceGroupName).size();
    Assert.assertEquals(successfulVMCount, actualAvailabilitySetCount);
    final int actualStorageAccountCount = storageManager.storageAccounts().listByResourceGroup(resourceGroupName).size();
    Assert.assertEquals(successfulVMCount, actualStorageAccountCount);
    // Verify that at least one VM failed.
    // TODO: Ideally only one, but today the internal RX logic terminates eagerly -- need to change that for parallel creation to terminate more "lazily" in the future
    Assert.assertTrue(successfulVMCount < desiredVMCount);
}

Example 10 with Indexable

use of com.microsoft.azure.management.resources.fluentcore.model.Indexable in project azure-sdk-for-java by Azure.

the class ManageVirtualNetworkAsync method runSample.

/**
     * Main function which runs the actual sample.
     * @param azure instance of the azure client
     * @return true if sample runs successfully
     */
public static boolean runSample(final Azure azure) {
    final String vnetName1 = SdkContext.randomResourceName("vnet1", 20);
    final String vnetName2 = SdkContext.randomResourceName("vnet2", 20);
    final String vnet1FrontEndSubnetName = "frontend";
    final String vnet1BackEndSubnetName = "backend";
    final String vnet1FrontEndSubnetNsgName = "frontendnsg";
    final String vnet1BackEndSubnetNsgName = "backendnsg";
    final String frontEndVMName = SdkContext.randomResourceName("fevm", 24);
    final String backEndVMName = SdkContext.randomResourceName("bevm", 24);
    final String publicIPAddressLeafDnsForFrontEndVM = SdkContext.randomResourceName("pip1", 24);
    final String userName = "tirekicker";
    final String sshKey = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCfSPC2K7LZcFKEO+/t3dzmQYtrJFZNxOsbVgOVKietqHyvmYGHEC0J2wPdAqQ/63g/hhAEFRoyehM+rbeDri4txB3YFfnOK58jqdkyXzupWqXzOrlKY4Wz9SKjjN765+dqUITjKRIaAip1Ri137szRg71WnrmdP3SphTRlCx1Bk2nXqWPsclbRDCiZeF8QOTi4JqbmJyK5+0UqhqYRduun8ylAwKKQJ1NJt85sYIHn9f1Rfr6Tq2zS0wZ7DHbZL+zB5rSlAr8QyUdg/GQD+cmSs6LvPJKL78d6hMGk84ARtFo4A79ovwX/Fj01znDQkU6nJildfkaolH2rWFG/qttD azjava@javalib.com";
    final String rgName = SdkContext.randomResourceName("rgNEMV", 24);
    try {
        //============================================================
        // Create a virtual network with specific address-space and two subnet
        // Creates a network security group for backend subnet
        System.out.println("Creating a network security group for virtual network backend subnet...");
        // Creates a network security group for frontend subnet
        System.out.println("Creating a network security group for virtual network backend subnet...");
        final Map<String, Indexable> createdResources = new TreeMap<>();
        Observable.merge(azure.networkSecurityGroups().define(vnet1BackEndSubnetNsgName).withRegion(Region.US_EAST).withNewResourceGroup(rgName).defineRule("DenyInternetInComing").denyInbound().fromAddress("INTERNET").fromAnyPort().toAnyAddress().toAnyPort().withAnyProtocol().attach().defineRule("DenyInternetOutGoing").denyOutbound().fromAnyAddress().fromAnyPort().toAddress("INTERNET").toAnyPort().withAnyProtocol().attach().createAsync().flatMap(new Func1<Indexable, Observable<Indexable>>() {

            @Override
            public Observable<Indexable> call(Indexable indexable) {
                if (indexable instanceof NetworkSecurityGroup) {
                    NetworkSecurityGroup backEndNsg = (NetworkSecurityGroup) indexable;
                    System.out.println("Creating virtual network #1...");
                    return Observable.merge(Observable.just(indexable), azure.networks().define(vnetName1).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).withAddressSpace("192.168.0.0/16").withSubnet(vnet1FrontEndSubnetName, "192.168.1.0/24").defineSubnet(vnet1BackEndSubnetName).withAddressPrefix("192.168.2.0/24").withExistingNetworkSecurityGroup(backEndNsg).attach().createAsync());
                }
                return Observable.just(indexable);
            }
        }), azure.networkSecurityGroups().define(vnet1FrontEndSubnetNsgName).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).defineRule("AllowHttpInComing").allowInbound().fromAddress("INTERNET").fromAnyPort().toAnyAddress().toPort(80).withProtocol(SecurityRuleProtocol.TCP).attach().defineRule("DenyInternetOutGoing").denyOutbound().fromAnyAddress().fromAnyPort().toAddress("INTERNET").toAnyPort().withAnyProtocol().attach().createAsync()).map(new Func1<Indexable, Indexable>() {

            @Override
            public Indexable call(Indexable indexable) {
                if (indexable instanceof NetworkSecurityGroup) {
                    NetworkSecurityGroup nsg = (NetworkSecurityGroup) indexable;
                    System.out.println("Created network security group");
                    // Print the network security group
                    Utils.print(nsg);
                    createdResources.put(nsg.name(), nsg);
                } else if (indexable instanceof Network) {
                    Network vn = (Network) indexable;
                    System.out.println("Created a virtual network");
                    // Print the virtual network details
                    Utils.print(vn);
                    createdResources.put(vn.name(), vn);
                }
                return indexable;
            }
        }).toBlocking().subscribe();
        NetworkSecurityGroup frontEndSubnetNsg = (NetworkSecurityGroup) createdResources.get(vnet1FrontEndSubnetNsgName);
        Network virtualNetwork1 = (Network) createdResources.get(vnetName1);
        //============================================================
        // Update a virtual network
        // Update the virtual network frontend subnet by associating it with network security group
        System.out.println("Associating network security group rule to frontend subnet");
        virtualNetwork1.update().updateSubnet(vnet1FrontEndSubnetName).withExistingNetworkSecurityGroup(frontEndSubnetNsg).parent().applyAsync().toCompletable().await();
        System.out.println("Network security group rule associated with the frontend subnet");
        // Print the virtual network details
        Utils.print(virtualNetwork1);
        //============================================================
        // Create a virtual machine in each subnet and another virtual network
        // Creates the first virtual machine in frontend subnet
        System.out.println("Creating a Linux virtual machine in the frontend subnet");
        // Creates the second virtual machine in the backend subnet
        System.out.println("Creating a Linux virtual machine in the backend subnet");
        // Create a virtual network with default address-space and one default subnet
        System.out.println("Creating virtual network #2...");
        final Date t1 = new Date();
        Observable.merge(azure.virtualMachines().define(frontEndVMName).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).withExistingPrimaryNetwork(virtualNetwork1).withSubnet(vnet1FrontEndSubnetName).withPrimaryPrivateIPAddressDynamic().withNewPrimaryPublicIPAddress(publicIPAddressLeafDnsForFrontEndVM).withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withSsh(sshKey).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).createAsync(), azure.virtualMachines().define(backEndVMName).withRegion(Region.US_EAST).withExistingResourceGroup(rgName).withExistingPrimaryNetwork(virtualNetwork1).withSubnet(vnet1BackEndSubnetName).withPrimaryPrivateIPAddressDynamic().withoutPrimaryPublicIPAddress().withPopularLinuxImage(KnownLinuxVirtualMachineImage.UBUNTU_SERVER_16_04_LTS).withRootUsername(userName).withSsh(sshKey).withSize(VirtualMachineSizeTypes.STANDARD_D3_V2).createAsync(), azure.networks().define(vnetName2).withRegion(Region.US_EAST).withNewResourceGroup(rgName).createAsync()).map(new Func1<Indexable, Indexable>() {

            @Override
            public Indexable call(Indexable indexable) {
                Date t2 = new Date();
                long duration = ((t2.getTime() - t1.getTime()) / 1000);
                if (indexable instanceof VirtualMachine) {
                    VirtualMachine vm = (VirtualMachine) indexable;
                    System.out.println("Created Linux VM: (took " + duration + " seconds) " + vm.id());
                    // Print virtual machine details
                    Utils.print(vm);
                } else if (indexable instanceof Network) {
                    Network vn = (Network) indexable;
                    System.out.println("Created a virtual network: took " + duration + " seconds) " + vn.id());
                    // Print the virtual network details
                    Utils.print(vn);
                }
                return indexable;
            }
        });
        //============================================================
        // List virtual networks and print details
        azure.networks().listByResourceGroupAsync(rgName).map(new Func1<Network, Network>() {

            @Override
            public Network call(Network network) {
                Utils.print(network);
                return network;
            }
        }).toBlocking().subscribe();
        return true;
    } catch (Exception e) {
        System.err.println(e.getMessage());
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().deleteByNameAsync(rgName).await();
            System.out.println("Deleted Resource Group: " + rgName);
        } catch (NullPointerException npe) {
            System.out.println("Did not create any resources in Azure. No clean up is necessary");
        } catch (Exception g) {
            g.printStackTrace();
        }
    }
    return false;
}