Transparent proxy: TP Loader Cloud SDK native integration

Author: VladislavAtanasov95

cloudplatform/connectivity-destination-service/src/main/java/com/sap/cloud/sdk/cloudplatform/connectivity/TransparentProxyLoader.java

@@ -0,0 +1,195 @@
+package com.sap.cloud.sdk.cloudplatform.connectivity;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.UnknownHostException;
+
+import javax.annotation.Nonnull;
+
+import com.sap.cloud.sdk.cloudplatform.connectivity.exception.DestinationAccessException;
+
+import io.vavr.control.Try;
+
+public class TransparentProxyLoader implements DestinationLoader
+{
+    public static final String HTTP_SCHEME = "http://";
+    private static final String SCHEME_SEPARATOR = "://";
+    private static final String PATH_SEPARATOR = "/";
+    private static final String PORT_SEPARATOR = ":";
+
+    static String uri;
+    static boolean isRegistered = false;
+    static NetworkValidator networkValidator = new DefaultNetworkValidator();
+
+    public static void register( @Nonnull final String host )
+    {
+        registerLoader(host, null);
+    }
+
+    public static void register( @Nonnull final String host, @Nonnull final Integer port )
+    {
+        registerLoader(host, port);
+    }
+
+    private static void registerLoader( @Nonnull final String host, final Integer port )
+    {
+        if( isRegistered ) {
+            throw new DestinationAccessException(
+                "TransparentProxyLoader is already registered. Only one registration is allowed.");
+        }
+
+        validateHostHasNoPath(host);
+
+        final String normalizedHost = normalizeHostWithScheme(host);
+        final String hostForValidation = extractHostForValidation(normalizedHost);
+
+        final String finalUri;
+        if( port != null ) {
+            finalUri = normalizedHost + PORT_SEPARATOR + port;
+            validateHostAndPortReachability(hostForValidation, port);
+        } else {
+            finalUri = normalizedHost;
+            validateHostReachability(hostForValidation);
+        }
+
+        TransparentProxyLoader.uri = finalUri;
+        TransparentProxyLoader.isRegistered = true;
+        DestinationAccessor.prependDestinationLoader(new TransparentProxyLoader());
+    }
+
+    @Nonnull
+    private static String normalizeHostWithScheme( @Nonnull final String host )
+    {
+        if( host.contains(SCHEME_SEPARATOR) ) {
+            return host;
+        }
+        return HTTP_SCHEME + host;
+    }
+
+    private static String extractHostForValidation( @Nonnull final String normalizedHost )
+    {
+        try {
+            final URI uri = new URI(normalizedHost);
+            return uri.getHost();
+        }
+        catch( final URISyntaxException e ) {
+            String host = normalizedHost;
+            if( host.contains(SCHEME_SEPARATOR) ) {
+                host = host.substring(host.indexOf(SCHEME_SEPARATOR) + 3);
+            }
+            if( host.contains(PORT_SEPARATOR) ) {
+                host = host.substring(0, host.indexOf(PORT_SEPARATOR));
+            }
+            if( host.contains(PATH_SEPARATOR) ) {
+                host = host.substring(0, host.indexOf(PATH_SEPARATOR));
+            }
+            return host;
+        }
+    }
+
+    private static void validateHostReachability( @Nonnull final String host )
+    {
+        networkValidator.validateHostReachability(host);
+    }
+
+    private static void validateHostAndPortReachability( @Nonnull final String host, final int port )
+    {
+        networkValidator.validateHostAndPortReachability(host, port);
+    }
+
+    private static void validateHostHasNoPath( @Nonnull final String host )
+    {
+        try {
+            final URI uri = new URI(host.contains(SCHEME_SEPARATOR) ? host : HTTP_SCHEME + host);
+            final String path = uri.getPath();
+            if( path != null && !path.isEmpty() ) {
+                throw new DestinationAccessException(
+                    "Host '" + host + "' contains a path '" + path + "'. Paths are not allowed in host registration.");
+            }
+        }
+        catch( final URISyntaxException e ) {
+            final String hostToCheck =
+                host.contains(SCHEME_SEPARATOR) ? host.substring(host.indexOf(SCHEME_SEPARATOR) + 3) : host;
+            if( hostToCheck.contains(PATH_SEPARATOR) ) {
+                final String pathPart = hostToCheck.substring(hostToCheck.indexOf(PATH_SEPARATOR));
+                if( !"/".equals(pathPart) ) {
+                    throw new DestinationAccessException(
+                        "Host '"
+                            + host
+                            + "' contains a path '"
+                            + pathPart
+                            + "'. Paths are not allowed in host registration.");
+                }
+            }
+        }
+    }
+
+    @Nonnull
+    @Override
+    public Try<Destination> tryGetDestination( @Nonnull String destinationName )
+    {
+        return Try.success(TransparentProxyDestination.gateway(destinationName, uri).build());
+    }
+
+    @Nonnull
+    @Override
+    public Try<Destination> tryGetDestination( @Nonnull String destinationName, @Nonnull DestinationOptions options )
+    {
+        return Try.success(TransparentProxyDestination.gateway(destinationName, uri).build());
+    }
+
+    interface NetworkValidator
+    {
+        void validateHostReachability( @Nonnull String host )
+            throws DestinationAccessException;
+
+        void validateHostAndPortReachability( @Nonnull String host, int port )
+            throws DestinationAccessException;
+    }
+
+    /**
+     * Default implementation of network validation
+     */
+    static class DefaultNetworkValidator implements NetworkValidator
+    {
+        private static final int HOST_REACH_TIMEOUT = 5000;
+
+        @Override
+        public void validateHostReachability( @Nonnull final String host )
+            throws DestinationAccessException
+        {
+            try {
+                final InetAddress address = InetAddress.getByName(host);
+                if( !address.isReachable(HOST_REACH_TIMEOUT) ) {
+                    throw new DestinationAccessException("Host '" + host + "' is not reachable");
+                }
+            }
+            catch( final UnknownHostException e ) {
+                throw new DestinationAccessException("Host '" + host + "' could not be resolved", e);
+            }
+            catch( final IOException e ) {
+                throw new DestinationAccessException("Failed to check reachability of host '" + host + "'", e);
+            }
+        }
+
+        @Override
+        public void validateHostAndPortReachability( @Nonnull final String host, final int port )
+            throws DestinationAccessException
+        {
+            try( Socket socket = new Socket() ) {
+                socket.connect(new InetSocketAddress(host, port), HOST_REACH_TIMEOUT);
+            }
+            catch( final UnknownHostException e ) {
+                throw new DestinationAccessException("Host '" + host + "' could not be resolved", e);
+            }
+            catch( final IOException e ) {
+                throw new DestinationAccessException("Host '" + host + "' on port " + port + " is not reachable", e);
+            }
+        }
+    }
+
+}