refactor URI parsing and transport security selection

Agent-Logs-Url: https://github.com/larohra/azure-functions-java-worker/sessions/f12a179d-bf43-486b-b716-cf4f837012ff

Co-authored-by: larohra <41490930+larohra@users.noreply.github.com>

Author: Copilot

src/main/java/com/microsoft/azure/functions/worker/Application.java

@@ -1,8 +1,8 @@
 package com.microsoft.azure.functions.worker;
 
-import java.net.MalformedURLException;
+import java.net.URI;
 import java.net.URISyntaxException;
-import java.net.URL;
+import java.util.Locale;
 import java.util.logging.*;
 import javax.annotation.*;
 
@@ -162,10 +162,6 @@ public String getFunctionsUri() {
         return this.uri;
     }
 
-    public String getUri() {
-        return this.getFunctionsUri();
-    }
-
     @Override
     public boolean logToConsole() {
         return this.logToConsole;
@@ -190,17 +186,44 @@ private boolean isCommandlineValid() {
 
     private String parseUri(String uri) throws ParseException {
         try {
-            URL url = new URL(uri);
-            url.toURI();
-            this.host = url.getHost();
-            this.port = url.getPort();
+            URI parsedUri = new URI(uri);
+            String host = parsedUri.getHost();
+            String scheme = parsedUri.getScheme();
+            int port = parsedUri.getPort();
+
+            if (scheme == null || scheme.isEmpty()) {
+                throw new IllegalArgumentException("URI scheme is missing");
+            }
+
+            switch (scheme.toLowerCase(Locale.ROOT)) {
+                case "http":
+                    if (port == -1) {
+                        port = 80;
+                    }
+                    break;
+                case "https":
+                    if (port == -1) {
+                        port = 443;
+                    }
+                    break;
+                default:
+                    throw new IllegalArgumentException("Unsupported URI scheme");
+            }
+
+            if (host == null || host.isEmpty()) {
+                throw new IllegalArgumentException("URI host is missing");
+            }
+
             if (port < 1 || port > 65535) {
                 throw new IndexOutOfBoundsException("port number out of range");
             }
+
+            this.host = host;
+            this.port = port;
             return uri;
-        } catch (MalformedURLException | URISyntaxException | IndexOutOfBoundsException e) {
+        } catch (URISyntaxException | IllegalArgumentException | IndexOutOfBoundsException e) {
             throw new ParseException(String.format(
-                    "Error parsing URI \"%s\". Please provide a valid URI", uri));
+                    "Error parsing URI \"%s\". Please provide a valid http or https URI", uri));
         }
     }
 

src/main/java/com/microsoft/azure/functions/worker/JavaWorkerClient.java

@@ -1,7 +1,5 @@
 package com.microsoft.azure.functions.worker;
 
-import java.net.URI;
-import java.net.URISyntaxException;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
@@ -150,34 +148,7 @@ private synchronized void send(String requestId, MessageHandler<?, ?> marshaller
      * @param functionsUri Host endpoint URI, or null for legacy startup args that only provide host and port.
      */
     static boolean useTransportSecurity(String functionsUri) {
-        if (functionsUri == null) {
-            return false;
-        }
-
-        String scheme = parseFunctionsUriScheme(functionsUri);
-        switch (scheme.toLowerCase(Locale.ROOT)) {
-            case "http":
-                return false;
-            case "https":
-                return true;
-            default:
-                throw new IllegalArgumentException(String.format(
-                    "Unsupported functions URI scheme \"%s\" in functions URI \"%s\". Only http and https are supported.",
-                    scheme, functionsUri));
-        }
-    }
-
-    private static String parseFunctionsUriScheme(String functionsUri) {
-        try {
-            String scheme = new URI(functionsUri).getScheme();
-            if (scheme == null || scheme.isEmpty()) {
-                throw new IllegalArgumentException(String.format(
-                    "Unsupported functions URI \"%s\". Only http and https are supported.", functionsUri));
-            }
-            return scheme;
-        } catch (URISyntaxException ex) {
-            throw new IllegalArgumentException(String.format(
-                "Error parsing functions URI \"%s\". Please provide a valid http or https URI.", functionsUri), ex);
-        }
+        return functionsUri != null
+            && functionsUri.regionMatches(true, 0, "https://", 0, "https://".length());
     }
 }

src/test/java/com/microsoft/azure/functions/worker/ApplicationTest.java

@@ -6,6 +6,7 @@
 import java.lang.reflect.Method;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -32,7 +33,6 @@ public void prefixedStartupArgumentsTakePrecedenceOverLegacyValues() throws Exce
 
         assertTrue(isCommandLineValid(application));
         assertEquals("https://functions.example:8443", application.getFunctionsUri());
-        assertEquals("https://functions.example:8443", application.getUri());
         assertEquals("functions.example", application.getHost());
         assertEquals(8443, application.getPort());
         assertEquals(Integer.valueOf(2048), application.getMaxMessageSize());
@@ -56,6 +56,43 @@ public void legacyHostAndPortRemainAvailableWhenFunctionsUriIsAbsent() throws Ex
         assertEquals(Integer.valueOf(4096), application.getMaxMessageSize());
     }
 
+    @Test
+    public void httpsFunctionsUriDefaultsToPort443WhenPortIsMissing() throws Exception {
+        Application application = createApplication(
+                "--functions-uri", "https://functions.example/path",
+                "--functions-worker-id", "prefixed-worker",
+                "--functions-request-id", "prefixed-request",
+                "--functions-grpc-max-message-length", "2048");
+
+        assertTrue(isCommandLineValid(application));
+        assertEquals("functions.example", application.getHost());
+        assertEquals(443, application.getPort());
+    }
+
+    @Test
+    public void httpFunctionsUriDefaultsToPort80WhenPortIsMissing() throws Exception {
+        Application application = createApplication(
+                "--functions-uri", "http://functions.example/path",
+                "--functions-worker-id", "prefixed-worker",
+                "--functions-request-id", "prefixed-request",
+                "--functions-grpc-max-message-length", "2048");
+
+        assertTrue(isCommandLineValid(application));
+        assertEquals("functions.example", application.getHost());
+        assertEquals(80, application.getPort());
+    }
+
+    @Test
+    public void unsupportedFunctionsUriSchemeFailsCommandLineValidation() throws Exception {
+        Application application = createApplication(
+                "--functions-uri", "unix:///tmp/functions.sock",
+                "--functions-worker-id", "prefixed-worker",
+                "--functions-request-id", "prefixed-request",
+                "--functions-grpc-max-message-length", "2048");
+
+        assertFalse(isCommandLineValid(application));
+    }
+
     private static Application createApplication(String... args) throws Exception {
         Constructor<Application> constructor = Application.class.getDeclaredConstructor(String[].class);
         constructor.setAccessible(true);

src/test/java/com/microsoft/azure/functions/worker/JavaWorkerClientTest.java

@@ -3,7 +3,6 @@
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 public class JavaWorkerClientTest {
@@ -23,10 +22,7 @@ public void httpsFunctionsUriUsesTransportSecurity() {
     }
 
     @Test
-    public void unsupportedFunctionsUriSchemeFailsFast() {
-        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
-            () -> JavaWorkerClient.useTransportSecurity("unix:///tmp/functions.sock"));
-
-        assertTrue(exception.getMessage().contains("Only http and https are supported."));
+    public void httpsFunctionsUriSchemeIsCaseInsensitive() {
+        assertTrue(JavaWorkerClient.useTransportSecurity("HTTPS://functions.example:8443"));
     }
 }