Add equals/hashcode for Destination (#341)

Author: newtork

cloudplatform/cloudplatform-connectivity/src/main/java/com/sap/cloud/sdk/cloudplatform/connectivity/DefaultHttpDestination.java

@@ -4,6 +4,9 @@
 
 package com.sap.cloud.sdk.cloudplatform.connectivity;
 
+import static com.sap.cloud.sdk.cloudplatform.connectivity.DestinationKeyStoreComparator.resolveCertificatesOnly;
+import static com.sap.cloud.sdk.cloudplatform.connectivity.DestinationKeyStoreComparator.resolveKeyStoreHashCode;
+
 import java.net.URI;
 import java.security.KeyStore;
 import java.util.ArrayList;
@@ -20,6 +23,9 @@
 import javax.annotation.Nullable;
 import javax.net.ssl.SSLContext;
 
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 import com.google.common.net.HttpHeaders;
@@ -36,36 +42,30 @@
 import io.vavr.control.Option;
 import io.vavr.control.Try;
 import lombok.AccessLevel;
-import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.experimental.Delegate;
 import lombok.extern.slf4j.Slf4j;
 
 /**
  * Immutable default implementation of the {@link HttpDestination} interface.
  */
-@EqualsAndHashCode
 @Slf4j
 public final class DefaultHttpDestination implements HttpDestination
 {
     @Delegate
     private final DestinationProperties baseProperties;
 
-    @EqualsAndHashCode.Exclude
     private final KeyStore keyStore;
-    @EqualsAndHashCode.Exclude
     private final KeyStore trustStore;
 
     @Nonnull
     final ImmutableList<Header> customHeaders;
 
     @Nonnull
     @Getter( AccessLevel.PACKAGE )
-    @EqualsAndHashCode.Exclude
     private final ImmutableList<DestinationHeaderProvider> customHeaderProviders;
 
     @Nonnull
-    @EqualsAndHashCode.Exclude
     private final ImmutableList<DestinationHeaderProvider> headerProvidersFromClassLoading;
 
     // the following 'cached' fields are ALWAYS derived from the baseProperties and stored in the corresponding fields
@@ -77,27 +77,21 @@ public final class DefaultHttpDestination implements HttpDestination
     // furthermore, it is safe to exclude these fields from the equals and hashCode methods because their values are
     // purely derived from the baseProperties, which are included in the equals and hashCode methods.
     @Nonnull
-    @EqualsAndHashCode.Exclude
     private final Option<ProxyConfiguration> cachedProxyConfiguration;
 
     @Nonnull
-    @EqualsAndHashCode.Exclude
     private final Option<ProxyType> cachedProxyType;
 
     @Nonnull
-    @EqualsAndHashCode.Exclude
     private final Option<BasicCredentials> cachedBasicCredentials;
 
     @Nonnull
-    @EqualsAndHashCode.Exclude
     private final AuthenticationType cachedAuthenticationType;
 
     @Nonnull
-    @EqualsAndHashCode.Exclude
     private final ImmutableList<Header> cachedHeadersFromProperties;
 
     @Nonnull
-    @EqualsAndHashCode.Exclude
     private final ImmutableList<Header> cachedProxyAuthorizationHeaders;
 
     private DefaultHttpDestination(
@@ -511,6 +505,37 @@ public static Builder fromDestination( @Nonnull final Destination destination )
         return builder;
     }
 
+    @Override
+    public boolean equals( @Nullable final Object o )
+    {
+        if( this == o ) {
+            return true;
+        }
+
+        if( o == null || getClass() != o.getClass() ) {
+            return false;
+        }
+
+        final DefaultHttpDestination that = (DefaultHttpDestination) o;
+        return new EqualsBuilder()
+            .append(baseProperties, that.baseProperties)
+            .append(customHeaders, that.customHeaders)
+            .append(resolveCertificatesOnly(keyStore), resolveCertificatesOnly(that.keyStore))
+            .append(resolveCertificatesOnly(trustStore), resolveCertificatesOnly(that.trustStore))
+            .isEquals();
+    }
+
+    @Override
+    public int hashCode()
+    {
+        return new HashCodeBuilder(17, 37)
+            .append(baseProperties)
+            .append(customHeaders)
+            .append(resolveKeyStoreHashCode(keyStore))
+            .append(resolveKeyStoreHashCode(trustStore))
+            .toHashCode();
+    }
+
     /**
      * Builder class to allow for easy creation of an immutable {@code DefaultHttpDestination} instance.
      */

cloudplatform/cloudplatform-connectivity/src/main/java/com/sap/cloud/sdk/cloudplatform/connectivity/DestinationKeyStoreComparator.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2024 SAP SE or an SAP affiliate company. All rights reserved.
+ */
+
+package com.sap.cloud.sdk.cloudplatform.connectivity;
+
+import java.security.KeyStore;
+import java.security.cert.Certificate;
+import java.util.ArrayList;
+import java.util.Enumeration;
+
+import javax.annotation.Nonnull;
+
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+
+import lombok.extern.slf4j.Slf4j;
+
+@Slf4j
+class DestinationKeyStoreComparator
+{
+    static int INITIAL_HASH_CODE = 17;
+
+    /**
+     * Calculate the SAP Cloud SDK compatible KeyStore hash code. The method may return a static number
+     * {@link DestinationKeyStoreComparator#INITIAL_HASH_CODE} in case the key-store was not initialized or contains
+     * non-certificate based elements.
+     *
+     * @param ks
+     *            The KeyStore to calculate the hash code for.
+     * @return The key-store hash code dynamically computed on behalf of stored certificates.
+     */
+    static int resolveKeyStoreHashCode( @Nonnull final KeyStore ks )
+    {
+        final HashCodeBuilder out = new HashCodeBuilder(INITIAL_HASH_CODE, 37);
+        final Certificate[] certificates = resolveCertificatesOnly(ks);
+        out.append(certificates);
+        return out.toHashCode();
+    }
+
+    /**
+     * Resolve certificates-only from a KeyStore.
+     *
+     * @param ks
+     *            The KeyStore to iterate.
+     * @return An array with certificates, or empty in case of error or non-certificate based keystore entries.
+     */
+    @Nonnull
+    static Certificate[] resolveCertificatesOnly( @Nonnull final KeyStore ks )
+    {
+        final ArrayList<Certificate> out = new ArrayList<>();
+        try {
+            final Enumeration<String> aliases = ks.aliases();
+            while( aliases.hasMoreElements() ) {
+                final String alias = aliases.nextElement();
+                if( ks.getCertificate(alias) == null ) {
+                    return new Certificate[0];
+                }
+                out.add(ks.getCertificate(alias));
+            }
+        }
+        catch( final Exception e ) {
+            log.debug("Error while resolving certificates from KeyStore", e);
+            return new Certificate[0];
+        }
+        return out.toArray(new Certificate[0]);
+    }
+}

cloudplatform/cloudplatform-connectivity/src/test/java/com/sap/cloud/sdk/cloudplatform/connectivity/DefaultHttpDestinationTest.java

@@ -10,7 +10,9 @@
 
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.security.KeyPair;
 import java.security.KeyStore;
+import java.security.cert.Certificate;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
@@ -139,6 +141,37 @@ void testEqualsIsImplemented()
         assertThat(firstDestination).isEqualTo(secondDestination).isNotSameAs(secondDestination);
     }
 
+    @SneakyThrows
+    @Test
+    void testEqualsWithKeyStore()
+    {
+        final KeyPair keyPair = DestinationKeyStoreComparatorTest.generateKeyPair();
+        final Certificate cert = DestinationKeyStoreComparatorTest.generateCertificate(keyPair, "a");
+
+        final KeyStore keystore1 = KeyStore.getInstance("JKS");
+        keystore1.load(null);
+        keystore1.setKeyEntry("a", keyPair.getPrivate(), new char[0], new Certificate[] { cert });
+
+        final KeyStore keystore2 = KeyStore.getInstance("JKS");
+        keystore2.load(null);
+        keystore2.setKeyEntry("a", keyPair.getPrivate(), new char[0], new Certificate[] { cert });
+
+        // check for destinations with comparable key-stores
+        final DefaultHttpDestination dest1 = DefaultHttpDestination.builder(VALID_URI).keyStore(keystore1).build();
+        final DefaultHttpDestination dest2 = DefaultHttpDestination.builder(VALID_URI).keyStore(keystore2).build();
+
+        assertThat(dest1).isEqualTo(dest2);
+        assertThat(dest1).hasSameHashCodeAs(dest2);
+
+        // check for destination with empty key-store
+        final KeyStore keystore3 = KeyStore.getInstance("JKS");
+        keystore3.load(null);
+
+        final DefaultHttpDestination dest3 = DefaultHttpDestination.builder(VALID_URI).keyStore(keystore3).build();
+        assertThat(dest1).isNotEqualTo(dest3);
+        assertThat(dest1).doesNotHaveSameHashCodeAs(dest3);
+    }
+
     @Test
     void testHashCodeIsImplemented()
     {