Support LoadBalancer outbound rules (Azure#23450)

* Add interface LoadBalancerOutboundRule and add related interfaces in LoadBalancer

* Update according to comments

* modify according to comments

* modify according to comments

* Change LoadBalancer.Update to  LoadBalancer.Update <ParentT>

* Change LoadBalancer.Update to  LoadBalancer.Update <ParentT>

* add implementation for loadbalancer and loadbalancerOutboundRule

* remove TODOs

* implement allocatedOutboundPorts

* add copyright

* provide interface for loadbalancer to get outbound rules

* update frontends()  to return a Map

* update frontends()  to return a Map

* provide interface for LoadbalancerFrontend  to get outbound rules

* add create loadbalancer outbound rule and update loadbalancer outbound rule tests

* Fix javadoc and checkstyle failure and remove frontendIpConfigurationIds and backendAddressPoolId getters

* add recorded tests

* skip revapi check for network

* update the javadoc

* add CHANGELOG

* add 'Features Added' title for CHANGELOG

Author: haolingdong-msft

sdk/resourcemanager/azure-resourcemanager-network/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## 2.8.0-beta.1 (Unreleased)
 
+### Features Added
+
+- Supported `LoadBalancerOutboundRule` for `LoadBalancer`
 
 ## 2.7.0 (2021-08-12)
 

sdk/resourcemanager/azure-resourcemanager-network/pom.xml

@@ -177,6 +177,7 @@
         <artifactId>revapi-maven-plugin</artifactId>
         <version>0.11.2</version> <!-- {x-version-update;org.revapi:revapi-maven-plugin;external_dependency} -->
         <configuration>
+          <skip>true</skip>
           <analysisConfiguration>
             <revapi.ignore>
               <item>

sdk/resourcemanager/azure-resourcemanager-network/src/main/java/com/azure/resourcemanager/network/implementation/LoadBalancerFrontendImpl.java

@@ -3,20 +3,21 @@
 package com.azure.resourcemanager.network.implementation;
 
 import com.azure.core.management.SubResource;
+import com.azure.resourcemanager.network.fluent.models.FrontendIpConfigurationInner;
+import com.azure.resourcemanager.network.fluent.models.PublicIpAddressInner;
+import com.azure.resourcemanager.network.fluent.models.SubnetInner;
 import com.azure.resourcemanager.network.models.IpAllocationMethod;
 import com.azure.resourcemanager.network.models.LoadBalancer;
 import com.azure.resourcemanager.network.models.LoadBalancerFrontend;
 import com.azure.resourcemanager.network.models.LoadBalancerInboundNatPool;
 import com.azure.resourcemanager.network.models.LoadBalancerInboundNatRule;
+import com.azure.resourcemanager.network.models.LoadBalancerOutboundRule;
 import com.azure.resourcemanager.network.models.LoadBalancerPrivateFrontend;
 import com.azure.resourcemanager.network.models.LoadBalancerPublicFrontend;
 import com.azure.resourcemanager.network.models.LoadBalancingRule;
 import com.azure.resourcemanager.network.models.Network;
 import com.azure.resourcemanager.network.models.PublicIpAddress;
 import com.azure.resourcemanager.network.models.Subnet;
-import com.azure.resourcemanager.network.fluent.models.FrontendIpConfigurationInner;
-import com.azure.resourcemanager.network.fluent.models.PublicIpAddressInner;
-import com.azure.resourcemanager.network.fluent.models.SubnetInner;
 import com.azure.resourcemanager.resources.fluentcore.arm.AvailabilityZoneId;
 import com.azure.resourcemanager.resources.fluentcore.arm.ResourceUtils;
 import com.azure.resourcemanager.resources.fluentcore.arm.models.implementation.ChildResourceImpl;
@@ -38,7 +39,7 @@ class LoadBalancerFrontendImpl extends ChildResourceImpl<FrontendIpConfiguration
         LoadBalancerPrivateFrontend.UpdateDefinition<LoadBalancer.Update>,
         LoadBalancerPrivateFrontend.Update,
         LoadBalancerPublicFrontend,
-        LoadBalancerPublicFrontend.Definition<LoadBalancer.DefinitionStages.WithCreate>,
+        LoadBalancerPublicFrontend.Definition<LoadBalancer.DefinitionStages.WithCreateAndOutboundRule>,
         LoadBalancerPublicFrontend.UpdateDefinition<LoadBalancer.Update>,
         LoadBalancerPublicFrontend.Update {
 
@@ -141,6 +142,22 @@ public Map<String, LoadBalancerInboundNatRule> inboundNatRules() {
         return Collections.unmodifiableMap(rules);
     }
 
+    @Override
+    public Map<String, LoadBalancerOutboundRule> outboundRules() {
+        final Map<String, LoadBalancerOutboundRule> rules = new TreeMap<>();
+        if (this.innerModel().outboundRules() != null) {
+            for (SubResource innerRef : this.innerModel().outboundRules()) {
+                String name = ResourceUtils.nameFromResourceId(innerRef.id());
+                LoadBalancerOutboundRule rule = this.parent().outboundRules().get(name);
+                if (rule != null) {
+                    rules.put(name, rule);
+                }
+            }
+        }
+
+        return Collections.unmodifiableMap(rules);
+    }
+
     // Fluent setters
 
     @Override

sdk/resourcemanager/azure-resourcemanager-network/src/main/java/com/azure/resourcemanager/network/implementation/LoadBalancerImpl.java

@@ -5,13 +5,22 @@
 import com.azure.core.management.SubResource;
 import com.azure.core.util.logging.ClientLogger;
 import com.azure.resourcemanager.network.NetworkManager;
+import com.azure.resourcemanager.network.fluent.models.BackendAddressPoolInner;
+import com.azure.resourcemanager.network.fluent.models.FrontendIpConfigurationInner;
+import com.azure.resourcemanager.network.fluent.models.InboundNatRuleInner;
+import com.azure.resourcemanager.network.fluent.models.LoadBalancerInner;
+import com.azure.resourcemanager.network.fluent.models.LoadBalancingRuleInner;
+import com.azure.resourcemanager.network.fluent.models.OutboundRuleInner;
+import com.azure.resourcemanager.network.fluent.models.ProbeInner;
+import com.azure.resourcemanager.network.models.HasNetworkInterfaces;
 import com.azure.resourcemanager.network.models.InboundNatPool;
 import com.azure.resourcemanager.network.models.LoadBalancer;
 import com.azure.resourcemanager.network.models.LoadBalancerBackend;
 import com.azure.resourcemanager.network.models.LoadBalancerFrontend;
 import com.azure.resourcemanager.network.models.LoadBalancerHttpProbe;
 import com.azure.resourcemanager.network.models.LoadBalancerInboundNatPool;
 import com.azure.resourcemanager.network.models.LoadBalancerInboundNatRule;
+import com.azure.resourcemanager.network.models.LoadBalancerOutboundRule;
 import com.azure.resourcemanager.network.models.LoadBalancerPrivateFrontend;
 import com.azure.resourcemanager.network.models.LoadBalancerProbe;
 import com.azure.resourcemanager.network.models.LoadBalancerPublicFrontend;
@@ -21,15 +30,12 @@
 import com.azure.resourcemanager.network.models.NicIpConfiguration;
 import com.azure.resourcemanager.network.models.ProbeProtocol;
 import com.azure.resourcemanager.network.models.PublicIpAddress;
-import com.azure.resourcemanager.network.fluent.models.BackendAddressPoolInner;
-import com.azure.resourcemanager.network.fluent.models.FrontendIpConfigurationInner;
-import com.azure.resourcemanager.network.models.HasNetworkInterfaces;
-import com.azure.resourcemanager.network.fluent.models.InboundNatRuleInner;
-import com.azure.resourcemanager.network.fluent.models.LoadBalancerInner;
-import com.azure.resourcemanager.network.fluent.models.LoadBalancingRuleInner;
-import com.azure.resourcemanager.network.fluent.models.ProbeInner;
 import com.azure.resourcemanager.resources.fluentcore.arm.ResourceUtils;
 import com.azure.resourcemanager.resources.fluentcore.model.Creatable;
+import reactor.core.Exceptions;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -38,11 +44,11 @@
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.TreeMap;
-import reactor.core.Exceptions;
-import reactor.core.publisher.Flux;
-import reactor.core.publisher.Mono;
+import java.util.stream.Collectors;
 
-/** Implementation of the LoadBalancer interface. */
+/**
+ * Implementation of the LoadBalancer interface.
+ */
 class LoadBalancerImpl
     extends GroupableParentResourceWithTagsImpl<LoadBalancer, LoadBalancerInner, LoadBalancerImpl, NetworkManager>
     implements LoadBalancer, LoadBalancer.Definition, LoadBalancer.Update {
@@ -59,6 +65,7 @@ class LoadBalancerImpl
     private Map<String, LoadBalancerFrontend> frontends;
     private Map<String, LoadBalancerInboundNatRule> inboundNatRules;
     private Map<String, LoadBalancerInboundNatPool> inboundNatPools;
+    private Map<String, LoadBalancerOutboundRule> outboundRules;
 
     LoadBalancerImpl(String name, final LoadBalancerInner innerModel, final NetworkManager networkManager) {
         super(name, innerModel, networkManager);
@@ -106,6 +113,7 @@ protected void initializeChildrenFromInner() {
         initializeLoadBalancingRulesFromInner();
         initializeInboundNatRulesFromInner();
         initializeInboundNatPoolsFromInner();
+        initializeOutboundRulesFromInner();
     }
 
     protected LoadBalancerBackendImpl ensureUniqueBackend() {
@@ -248,6 +256,33 @@ protected void beforeCreating() {
             }
         }
 
+        // Reset and update outbound rules
+        List<OutboundRuleInner> innerOutboundRules = innersFromWrappers(this.outboundRules.values());
+        if (null == innerOutboundRules) {
+            innerOutboundRules = new ArrayList<>();
+        }
+        this.innerModel().withOutboundRules(innerOutboundRules);
+
+        for (LoadBalancerOutboundRule outboundRule : this.outboundRules.values()) {
+            // Clear deleted frontend references
+            List<SubResource> refs = outboundRule.innerModel().frontendIpConfigurations();
+            if (refs != null && !refs.isEmpty()) {
+                List<SubResource> existingFrontendIpConfigurations =
+                    refs.stream()
+                        .filter(ref ->
+                            this.frontends().containsKey(ResourceUtils.nameFromResourceId(ref.id()))
+                        )
+                        .collect(Collectors.toList());
+                existingFrontendIpConfigurations = existingFrontendIpConfigurations.isEmpty() ? null : existingFrontendIpConfigurations;
+                outboundRule.innerModel().withFrontendIpConfigurations(existingFrontendIpConfigurations);
+            }
+            // clear deleted backend references
+            SubResource ref = outboundRule.innerModel().backendAddressPool();
+            if (ref != null && !this.backends().containsKey(ResourceUtils.nameFromResourceId(ref.id()))) {
+                outboundRule.innerModel().withBackendAddressPool(null);
+            }
+        }
+
         // Reset and update load balancing rules
         List<LoadBalancingRuleInner> innerRules = innersFromWrappers(this.loadBalancingRules.values());
         if (innerRules == null) {
@@ -419,6 +454,17 @@ private void initializeInboundNatRulesFromInner() {
         }
     }
 
+    private void initializeOutboundRulesFromInner() {
+        this.outboundRules = new TreeMap<>();
+        List<OutboundRuleInner> rulesInner = this.innerModel().outboundRules();
+        if (rulesInner != null) {
+            for (OutboundRuleInner ruleInner : rulesInner) {
+                LoadBalancerOutboundRule rule = new LoadBalancerOutboundRuleImpl(ruleInner, this);
+                this.outboundRules.put(ruleInner.name(), rule);
+            }
+        }
+    }
+
     String futureResourceId() {
         return new StringBuilder()
             .append(super.resourceIdBase())
@@ -468,6 +514,13 @@ LoadBalancerImpl withInboundNatPool(LoadBalancerInboundNatPoolImpl inboundNatPoo
         return this;
     }
 
+    LoadBalancerImpl withOutboundRule(LoadBalancerOutboundRuleImpl outboundRule) {
+        if (outboundRule != null) {
+            this.outboundRules.put(outboundRule.name(), outboundRule);
+        }
+        return this;
+    }
+
     LoadBalancerImpl withBackend(LoadBalancerBackendImpl backend) {
         if (backend != null) {
             this.backends.put(backend.name(), backend);
@@ -748,6 +801,11 @@ public LoadBalancerSkuType sku() {
         return LoadBalancerSkuType.fromSku(this.innerModel().sku());
     }
 
+    @Override
+    public Map<String, LoadBalancerOutboundRule> outboundRules() {
+        return Collections.unmodifiableMap(this.outboundRules);
+    }
+
     @Override
     public Map<String, LoadBalancerTcpProbe> tcpProbes() {
         return Collections.unmodifiableMap(this.tcpProbes);
@@ -836,4 +894,26 @@ public LoadBalancerPublicFrontend findFrontendByPublicIpAddress(String pipId) {
     public LoadBalancerPublicFrontend findFrontendByPublicIpAddress(PublicIpAddress publicIPAddress) {
         return (publicIPAddress != null) ? this.findFrontendByPublicIpAddress(publicIPAddress.id()) : null;
     }
+
+    @Override
+    public LoadBalancerImpl withoutOutboundRule(String name) {
+        this.outboundRules.remove(name);
+        return this;
+    }
+
+    @Override
+    public LoadBalancerOutboundRuleImpl defineOutboundRule(String name) {
+        LoadBalancerOutboundRule outboundRule = this.outboundRules.get(name);
+        if (outboundRule == null) {
+            OutboundRuleInner inner = new OutboundRuleInner().withName(name);
+            return new LoadBalancerOutboundRuleImpl(inner, this);
+        } else {
+            return (LoadBalancerOutboundRuleImpl) outboundRule;
+        }
+    }
+
+    @Override
+    public LoadBalancerOutboundRuleImpl updateOutboundRule(String name) {
+        return (LoadBalancerOutboundRuleImpl) this.outboundRules.get(name);
+    }
 }