Implement target instance IP list query

Author: webprofusion-chrisc

src/Certify.Core/Management/CertifyManager/CertifyManager.ManagementHub.cs

@@ -636,6 +636,10 @@ public async Task<InstanceCommandResult> PerformHubCommandWithResult(InstanceCom
 
                 val = await PerformDeploymentTask(null, managedCertificateIdArg.Value, taskIdArg.Value, isPreviewOnly: false, skipDeferredTasks: false, forceTaskExecution: false);
             }
+            else if (arg.CommandType == ManagementHubCommands.GetTargetIPAddresses)
+            {
+                val = await GetTargetIPAddresses();
+            }
             else if (arg.CommandType == ManagementHubCommands.GetTargetServiceTypes)
             {
                 val = await GetTargetServiceTypes();

src/Certify.Core/Management/CertifyManager/CertifyManager.ServerType.cs

@@ -9,6 +9,23 @@ namespace Certify.Management
 {
     public partial class CertifyManager
     {
+        private async Task<ICollection<IPAddressOption>> GetTargetIPAddresses()
+        {
+            try
+            {
+                var ipAddressOptions = Certify.Utils.Networking.GetIPAddresses();
+
+                ipAddressOptions.Insert(0, new IPAddressOption { Description = "* (All Unassigned)", IPAddress = "*", IsIPv6 = false }); //add wildcard option
+
+                return ipAddressOptions;
+            }
+            catch (Exception)
+            {
+                //return empty list
+                return [];
+            }
+        }
+
         private async Task<ICollection<string>> GetTargetServiceTypes()
         {
             var list = new List<string>();

src/Certify.Models/Hub/ManagementHubMessages.cs

@@ -47,6 +47,7 @@ public class ManagementHubCommands
         public const string GetTargetServiceTypes = "GetTargetServiceTypes";
         public const string GetTargetServiceItems = "GetTargetServiceItems";
         public const string GetTargetServiceItemIdentifiers = "GetTargetServiceItemIdentifiers";
+        public const string GetTargetIPAddresses = "GetTargetIPAddresses";
 
         public const string PerformImport = "PerformImport";
         public const string PerformExport = "PerformExport";

src/Certify.Server/Certify.Server.Hub.Api.Client/Certify.Server.Hub.Api.Client.cs

@@ -6087,6 +6087,95 @@ public virtual async System.Threading.Tasks.Task<ActionResult> UpdateServiceCore
             }
         }
 
+        /// <summary>
+        /// Get list of IP addresses available on the target for service binding (IIS, nginx etc) [Generated]
+        /// </summary>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual System.Threading.Tasks.Task<System.Collections.Generic.ICollection<IPAddressOption>> GetTargetIPAddressesAsync(string instanceId)
+        {
+            return GetTargetIPAddressesAsync(instanceId, System.Threading.CancellationToken.None);
+        }
+
+        /// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
+        /// <summary>
+        /// Get list of IP addresses available on the target for service binding (IIS, nginx etc) [Generated]
+        /// </summary>
+        /// <returns>OK</returns>
+        /// <exception cref="ApiException">A server side error occurred.</exception>
+        public virtual async System.Threading.Tasks.Task<System.Collections.Generic.ICollection<IPAddressOption>> GetTargetIPAddressesAsync(string instanceId, System.Threading.CancellationToken cancellationToken)
+        {
+            if (instanceId == null)
+                throw new System.ArgumentNullException("instanceId");
+
+            var client_ = _httpClient;
+            var disposeClient_ = false;
+            try
+            {
+                using (var request_ = new System.Net.Http.HttpRequestMessage())
+                {
+                    request_.Method = new System.Net.Http.HttpMethod("GET");
+                    request_.Headers.Accept.Add(System.Net.Http.Headers.MediaTypeWithQualityHeaderValue.Parse("text/plain"));
+
+                    var urlBuilder_ = new System.Text.StringBuilder();
+                    if (!string.IsNullOrEmpty(_baseUrl)) urlBuilder_.Append(_baseUrl);
+                    // Operation Path: "internal/v1/target/{instanceId}/ipaddresses"
+                    urlBuilder_.Append("internal/v1/target/");
+                    urlBuilder_.Append(System.Uri.EscapeDataString(ConvertToString(instanceId, System.Globalization.CultureInfo.InvariantCulture)));
+                    urlBuilder_.Append("/ipaddresses");
+
+                    PrepareRequest(client_, request_, urlBuilder_);
+
+                    var url_ = urlBuilder_.ToString();
+                    request_.RequestUri = new System.Uri(url_, System.UriKind.RelativeOrAbsolute);
+
+                    PrepareRequest(client_, request_, url_);
+
+                    var response_ = await client_.SendAsync(request_, System.Net.Http.HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+                    var disposeResponse_ = true;
+                    try
+                    {
+                        var headers_ = new System.Collections.Generic.Dictionary<string, System.Collections.Generic.IEnumerable<string>>();
+                        foreach (var item_ in response_.Headers)
+                            headers_[item_.Key] = item_.Value;
+                        if (response_.Content != null && response_.Content.Headers != null)
+                        {
+                            foreach (var item_ in response_.Content.Headers)
+                                headers_[item_.Key] = item_.Value;
+                        }
+
+                        ProcessResponse(client_, response_);
+
+                        var status_ = (int)response_.StatusCode;
+                        if (status_ == 200)
+                        {
+                            var objectResponse_ = await ReadObjectResponseAsync<System.Collections.Generic.ICollection<IPAddressOption>>(response_, headers_, cancellationToken).ConfigureAwait(false);
+                            if (objectResponse_.Object == null)
+                            {
+                                throw new ApiException("Response was null which was not expected.", status_, objectResponse_.Text, headers_, null);
+                            }
+                            return objectResponse_.Object;
+                        }
+                        else
+                        {
+                            var responseData_ = response_.Content == null ? null : await response_.Content.ReadAsStringAsync().ConfigureAwait(false);
+                            throw new ApiException("The HTTP status code of the response was not expected (" + status_ + ").", status_, responseData_, headers_, null);
+                        }
+                    }
+                    finally
+                    {
+                        if (disposeResponse_)
+                            response_.Dispose();
+                    }
+                }
+            }
+            finally
+            {
+                if (disposeClient_)
+                    client_.Dispose();
+            }
+        }
+
         /// <summary>
         /// Get Service Types present on instance (IIS, nginx etc) [Generated]
         /// </summary>

src/Certify.Shared/Utils/Networking.cs

@@ -1,5 +1,5 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Linq;
 using System.Net.NetworkInformation;
 using Certify.Models;
 
@@ -70,13 +70,12 @@ public static List<IPAddressOption> GetIPAddresses()
                     }
                 }
             }
-            catch (Exception)
+            catch
             {
-                ;
                 ; // could not retrieve networking information
             }
 
-            return list;
+            return list.OrderBy(ip => ip.IPAddress).ToList();
         }
     }
 }

src/Certify.SourceGenerators/ApiMethods.cs

@@ -448,6 +448,21 @@ public static List<GeneratedAPI> GetApiDefinitions()
                         { "instanceId", "string" }
                     }
                 },
+                new()
+                 {
+                     OperationName = "GetTargetIPAddresses",
+                     OperationMethod = HttpGet,
+                     Comment = "Get list of IP addresses available on the target for service binding (IIS, nginx etc)",
+                     UseManagementAPI = true,
+                     ManagementHubCommandType = Models.Hub.ManagementHubCommands.GetTargetIPAddresses,
+                     PublicAPIController = "Target",
+                     PublicAPIRoute = "{instanceId}/ipaddresses",
+                     ReturnType = "ICollection<IPAddressOption>",
+                     Params = new Dictionary<string, string>
+                     {
+                         { "instanceId", "string" }
+                     }
+                 },
                 new()
                 {
                     OperationName = "GetTargetServiceTypes",