ambari-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rle...@apache.org
Subject ambari git commit: AMBARI-12774. Kerberos: Test KDC Connection succeeds but prints ERROR to ambari server log (rlevas)
Date Wed, 12 Aug 2015 19:29:46 GMT
Repository: ambari
Updated Branches:
  refs/heads/branch-2.1 bc32ce12d -> 7970945d0


AMBARI-12774. Kerberos: Test KDC Connection succeeds but prints ERROR to ambari server log
(rlevas)


Project: http://git-wip-us.apache.org/repos/asf/ambari/repo
Commit: http://git-wip-us.apache.org/repos/asf/ambari/commit/7970945d
Tree: http://git-wip-us.apache.org/repos/asf/ambari/tree/7970945d
Diff: http://git-wip-us.apache.org/repos/asf/ambari/diff/7970945d

Branch: refs/heads/branch-2.1
Commit: 7970945d0a3af2813e6d3a063c26f0cce1765c50
Parents: bc32ce1
Author: Robert Levas <rlevas@hortonworks.com>
Authored: Wed Aug 12 15:29:51 2015 -0400
Committer: Robert Levas <rlevas@hortonworks.com>
Committed: Wed Aug 12 15:29:51 2015 -0400

----------------------------------------------------------------------
 .../server/KdcServerConnectionVerification.java | 147 +++++------
 .../KdcServerConnectionVerificationTest.java    | 243 ++++++++++++-------
 2 files changed, 241 insertions(+), 149 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ambari/blob/7970945d/ambari-server/src/main/java/org/apache/ambari/server/KdcServerConnectionVerification.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/main/java/org/apache/ambari/server/KdcServerConnectionVerification.java
b/ambari-server/src/main/java/org/apache/ambari/server/KdcServerConnectionVerification.java
index e464800..aa23e44 100644
--- a/ambari-server/src/main/java/org/apache/ambari/server/KdcServerConnectionVerification.java
+++ b/ambari-server/src/main/java/org/apache/ambari/server/KdcServerConnectionVerification.java
@@ -18,10 +18,6 @@
 
 package org.apache.ambari.server;
 
-import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.net.Socket;
-import java.net.UnknownHostException;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.FutureTask;
@@ -46,12 +42,12 @@ import com.google.inject.Singleton;
  * It has two potential clients.
  * <ul>
  * <li>Ambari Agent:
- * 		Uses it to make sure host can talk to specified KDC Server
+ * Uses it to make sure host can talk to specified KDC Server
  * </li>
- *
+ * <p/>
  * <li>Ambari Server:
- * 		Uses it for connection check, like agent, and also validates
- * 		the credentials provided on Server side.
+ * Uses it for connection check, like agent, and also validates
+ * the credentials provided on Server side.
  * </li>
  * </ul>
  * </p>
@@ -64,9 +60,9 @@ public class KdcServerConnectionVerification {
   private Configuration config;
 
   /**
-   * UDP connection timeout in seconds.
+   * The connection timeout in seconds.
    */
-  private int udpTimeout = 10;
+  private int connectionTimeout = 10;
 
   @Inject
   public KdcServerConnectionVerification(Configuration config) {
@@ -88,7 +84,7 @@ public class KdcServerConnectionVerification {
         throw new IllegalArgumentException("Invalid hostname for KDC server");
       }
       String[] kdcDetails = kdcHost.split(":");
-      if (kdcDetails.length == 1)  {
+      if (kdcDetails.length == 1) {
         return isKdcReachable(kdcDetails[0], parsePort(config.getDefaultKdcPort()));
       } else {
         return isKdcReachable(kdcDetails[0], parsePort(kdcDetails[1]));
@@ -107,70 +103,47 @@ public class KdcServerConnectionVerification {
    * process for the give host and port.
    *
    * @param server KDC server IP or hostname
-   * @param port	 KDC port
-   * @return	true, if server is accepting connection given port; false otherwise.
+   * @param port   KDC port
+   * @return true, if server is accepting connection given port; false otherwise.
    */
   public boolean isKdcReachable(String server, int port) {
-    return isKdcReachableViaTCP(server, port) || isKdcReachableViaUDP(server, port);
-  }
+    boolean success = isKdcReachable(server, port, ConnectionProtocol.TCP) || isKdcReachable(server,
port, ConnectionProtocol.UDP);
 
-  /**
-   * Attempt to connect to KDC server over TCP.
-   *
-   * @param server KDC server IP or hostname
-   * @param port	 KDC server port
-   * @return	true, if server is accepting connection given port; false otherwise.
-   */
-  public boolean isKdcReachableViaTCP(String server, int port) {
-    Socket socket = null;
-    try {
-      socket = new Socket();
-      socket.connect(new InetSocketAddress(server, port), config.getKdcConnectionCheckTimeout());
-    } catch (UnknownHostException e) {
-      LOG.error("Unable to resolve Kerberos Server hostname");
-      return false;
-    } catch (IOException e) {
-      LOG.error("Unable to connect to Kerberos Server");
-      return false;
-    } finally {
-      if (socket != null) {
-        try {
-          socket.close();
-        } catch (IOException e) {
-          LOG.debug("Error while closing socket connection to Kerberos Server. Can be ignored.");
-        }
-      }
+    if (!success) {
+      LOG.error("Failed to connect to the KDC at {}:{} using either TCP or UDP", server,
port);
     }
 
-    return true;
+    return success;
   }
 
   /**
-   * Attempt to communicate with KDC server over UDP.
-   * @param server KDC hostname or IP address
-   * @param port   KDC server port
-   * @return  true if communication is successful; false otherwise
+   * Attempt to communicate with KDC server over a specified communication protocol (TCP
or UDP).
+   *
+   * @param server         KDC hostname or IP address
+   * @param port           KDC server port
+   * @param connectionProtocol the type of connection to use
+   * @return true if communication is successful; false otherwise
    */
-  public boolean isKdcReachableViaUDP(final String server, final int port) {
-    int timeoutMillis = udpTimeout * 1000;
+  public boolean isKdcReachable(final String server, final int port, final ConnectionProtocol
connectionProtocol) {
+    int timeoutMillis = connectionTimeout * 1000;
     final KdcConfig config = KdcConfig.getDefaultConfig();
     config.setHostName(server);
     config.setKdcPort(port);
-    config.setUseUdp(true);
+    config.setUseUdp(ConnectionProtocol.UDP == connectionProtocol);
     config.setTimeout(timeoutMillis);
 
-    final KdcConnection connection = getKdcUdpConnection(config);
     FutureTask<Boolean> future = new FutureTask<Boolean>(new Callable<Boolean>()
{
       @Override
       public Boolean call() {
         try {
+          KdcConnection connection = getKdcConnection(config);
           // we are only testing whether we can communicate with server and not
           // validating credentials
           connection.getTgt("noUser@noRealm", "noPassword");
         } catch (KerberosException e) {
           // unfortunately, need to look at msg as error 60 is a generic error code
-          return ! (e.getErrorCode() == ErrorType.KRB_ERR_GENERIC.getValue() &&
-                    e.getMessage().contains("TimeOut"));
+          return !(e.getErrorCode() == ErrorType.KRB_ERR_GENERIC.getValue() &&
+              e.getMessage().contains("TimeOut"));
           //todo: evaluate other error codes to provide better information
           //todo: as there may be other error codes where we should return false
         } catch (Exception e) {
@@ -186,15 +159,44 @@ public class KdcServerConnectionVerification {
     try {
       // timeout after specified timeout
       result = future.get(timeoutMillis, TimeUnit.MILLISECONDS);
+
+      if (result) {
+        LOG.info(String.format("Successfully connected to the KDC server at %s:%d over %s",
+            server, port, connectionProtocol.name()));
+      } else {
+        LOG.warn(String.format("Failed to connect to the KDC server at %s:%d over %s",
+            server, port, connectionProtocol.name()));
+      }
     } catch (InterruptedException e) {
-      LOG.error("Interrupted while trying to communicate with KDC server over UDP");
+      String message = String.format("Interrupted while trying to communicate with KDC server
at %s:%d over %s",
+          server, port, connectionProtocol.name());
+      if (LOG.isDebugEnabled()) {
+        LOG.warn(message, e);
+      } else {
+        LOG.warn(message);
+      }
+
       result = false;
       future.cancel(true);
     } catch (ExecutionException e) {
-      LOG.error("An unexpected exception occurred while attempting to communicate with the
KDC server over UDP", e);
+      String message = String.format("An unexpected exception occurred while attempting to
communicate with the KDC server at %s:%d over %s",
+          server, port, connectionProtocol.name());
+      if (LOG.isDebugEnabled()) {
+        LOG.warn(message, e);
+      } else {
+        LOG.warn(message);
+      }
+
       result = false;
     } catch (TimeoutException e) {
-      LOG.error("Timeout occurred while attempting to to communicate with KDC server over
UDP");
+      String message = String.format("Timeout occurred while attempting to to communicate
with KDC server at %s:%d over %s",
+          server, port, connectionProtocol.name());
+      if (LOG.isDebugEnabled()) {
+        LOG.warn(message, e);
+      } else {
+        LOG.warn(message);
+      }
+
       result = false;
       future.cancel(true);
     }
@@ -210,40 +212,49 @@ public class KdcServerConnectionVerification {
    * @param config KDC connection configuration
    * @return new KDC connection
    */
-  protected KdcConnection getKdcUdpConnection(KdcConfig config) {
+  protected KdcConnection getKdcConnection(KdcConfig config) {
     return new KdcConnection(config);
   }
 
   /**
-   * Set the UDP connection timeout.
-   * This is the amount of time that we will attempt to read data from UDP connection.
+   * Set the connection timeout.
+   * This is the amount of time that we will attempt to read data from connection.
    *
-   * @param timeoutSeconds  timeout in seconds
+   * @param timeoutSeconds timeout in seconds
    */
-  public void setUdpTimeout(int timeoutSeconds) {
-    udpTimeout = (timeoutSeconds < 1) ? 1 : timeoutSeconds;
+  public void setConnectionTimeout(int timeoutSeconds) {
+    connectionTimeout = (timeoutSeconds < 1) ? 1 : timeoutSeconds;
   }
 
   /**
-   * Get the UDP timeout value.
+   * Get the timeout value.
    *
-   * @return the UDP connection timeout value in seconds
+   * @return the connection timeout value in seconds
    */
-  public int getUdpTimeout() {
-    return udpTimeout;
+  public int getConnectionTimeout() {
+    return connectionTimeout;
   }
 
   /**
    * Parses port number from given string.
+   *
    * @param port port number string
-   * @throws NumberFormatException if given string cannot be parsed
-   * @throws IllegalArgumentException if given string is null or empty
    * @return parsed port number
+   * @throws NumberFormatException    if given string cannot be parsed
+   * @throws IllegalArgumentException if given string is null or empty
    */
-  private int parsePort(String port) {
+  protected int parsePort(String port) {
     if (StringUtils.isEmpty(port)) {
       throw new IllegalArgumentException("Port number must be non-empty, non-null positive
integer");
     }
     return Integer.parseInt(port);
   }
+
+  /**
+   * A connection protocol to use to for connecting to the KDC
+   */
+  public enum ConnectionProtocol {
+    TCP,
+    UDP
+  }
 }

http://git-wip-us.apache.org/repos/asf/ambari/blob/7970945d/ambari-server/src/test/java/org/apache/ambari/server/api/rest/KdcServerConnectionVerificationTest.java
----------------------------------------------------------------------
diff --git a/ambari-server/src/test/java/org/apache/ambari/server/api/rest/KdcServerConnectionVerificationTest.java
b/ambari-server/src/test/java/org/apache/ambari/server/api/rest/KdcServerConnectionVerificationTest.java
index da47eb2..948b6db 100644
--- a/ambari-server/src/test/java/org/apache/ambari/server/api/rest/KdcServerConnectionVerificationTest.java
+++ b/ambari-server/src/test/java/org/apache/ambari/server/api/rest/KdcServerConnectionVerificationTest.java
@@ -17,6 +17,8 @@
  */
 package org.apache.ambari.server.api.rest;
 
+import static org.apache.ambari.server.KdcServerConnectionVerification.ConnectionProtocol.TCP;
+import static org.apache.ambari.server.KdcServerConnectionVerification.ConnectionProtocol.UDP;
 import static org.easymock.EasyMock.createStrictMock;
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.replay;
@@ -25,25 +27,18 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 
-import java.io.IOException;
-import java.net.ServerSocket;
-import java.net.SocketException;
 import java.util.Properties;
 
 import org.apache.ambari.server.KdcServerConnectionVerification;
 import org.apache.ambari.server.configuration.Configuration;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
 import org.apache.directory.kerberos.client.KdcConfig;
 import org.apache.directory.kerberos.client.KdcConnection;
 import org.apache.directory.kerberos.client.TgTicket;
 import org.apache.directory.shared.kerberos.exceptions.ErrorType;
 import org.apache.directory.shared.kerberos.exceptions.KerberosException;
-import org.junit.AfterClass;
 import org.junit.Before;
-import org.junit.BeforeClass;
+import org.junit.Ignore;
 import org.junit.Test;
-import org.springframework.test.annotation.ExpectedException;
 
 
 /**
@@ -51,64 +46,175 @@ import org.springframework.test.annotation.ExpectedException;
  */
 public class KdcServerConnectionVerificationTest  {
 
-  private static Log LOG = LogFactory.getLog(KdcServerConnectionVerificationTest.class);
-
-  private KdcServerConnectionVerification kdcConnectionVerifier;
-  private Properties configProps;
   private Configuration configuration;
 
-  private static ServerSocket serverSocket = null;
-  private static boolean serverStop = false;
-
   private static final int KDC_TEST_PORT = 8090;
-  // Some dummy port to test a non-listening KDC server
-  private static final int DUMMY_KDC_PORT = 11234;
 
-  @BeforeClass
-  public static void beforeClass() throws Exception {
-    createSocketServer(KDC_TEST_PORT);
-  }
-
-  @AfterClass
-  public static void afterClass() throws Exception {
-    closeServerSocket();
-  }
-  
   @Before
   public void before() throws Exception {
-    configProps = new Properties();
+    Properties configProps = new Properties();
     configProps.setProperty(Configuration.KDC_PORT_KEY, Integer.toString(KDC_TEST_PORT));
     configuration = new Configuration(configProps);
-    kdcConnectionVerifier = new KdcServerConnectionVerification(configuration);     
   }
 
   @Test
-  public void testWithPortSuccess() throws Exception {
-    assertTrue(kdcConnectionVerifier.isKdcReachable(String.format("localhost:%d", KDC_TEST_PORT)));
+  public void testValidate__Fail_InvalidPort() throws Exception {
+    assertFalse(new KdcServerConnectionVerification(configuration).isKdcReachable("test-host:abcd"));
   }
 
   @Test
-  public void testWithoutPortSuccess() throws Exception {
-    assertTrue(kdcConnectionVerifier.isKdcReachable("localhost"));
+  public void testValidate__Success() throws Exception {
+    KdcConnection connection = createStrictMock(KdcConnection.class);
+
+    expect(connection.getTgt("noUser@noRealm", "noPassword")).andReturn(null).once();
+    replay(connection);
+
+    TestKdcServerConnectionVerification kdcConnVerifier =
+        new TestKdcServerConnectionVerification(configuration, connection);
+
+    boolean result = kdcConnVerifier.isKdcReachable("test-host:11111");
+    assertTrue(result);
+
+    KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
+    assertEquals("test-host", kdcConfig.getHostName());
+    assertEquals(11111, kdcConfig.getKdcPort());
+    assertEquals(10 * 1000, kdcConfig.getTimeout());
+
+    verify(connection);
   }
 
   @Test
-  public void testWithoutPortFailure() throws Exception {
-    // Assumption: test machine has no KDC so nothing listening on port DUMMY_KDC_PORT
-    configProps.setProperty(Configuration.KDC_PORT_KEY, Integer.toString(DUMMY_KDC_PORT));
-    assertFalse(kdcConnectionVerifier.isKdcReachable("localhost"));
+  public void testValidateTCP__Successful() throws Exception {
+    KdcConnection connection = createStrictMock(KdcConnection.class);
+
+    expect(connection.getTgt("noUser@noRealm", "noPassword")).andReturn(null).once();
+    replay(connection);
+
+    TestKdcServerConnectionVerification kdcConnVerifier =
+        new TestKdcServerConnectionVerification(configuration, connection);
+
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, TCP);
+    assertTrue(result);
+
+    KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
+    assertFalse(kdcConfig.isUseUdp());
+    assertEquals("test-host", kdcConfig.getHostName());
+    assertEquals(11111, kdcConfig.getKdcPort());
+    assertEquals(10 * 1000, kdcConfig.getTimeout());
+
+    verify(connection);
   }
 
   @Test
-  public void testWithPortFailure() throws Exception {
-    assertFalse(kdcConnectionVerifier.isKdcReachable("localhost:8091"));
+  public void testValidateTCP__Successful2() throws Exception {
+    KdcConnection connection = createStrictMock(KdcConnection.class);
+
+    expect(connection.getTgt("noUser@noRealm", "noPassword")).andThrow(
+        new KerberosException(ErrorType.KDC_ERR_C_PRINCIPAL_UNKNOWN));
+    replay(connection);
+
+    TestKdcServerConnectionVerification kdcConnVerifier =
+        new TestKdcServerConnectionVerification(configuration, connection);
+
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, TCP);
+    assertTrue(result);
+
+    KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
+    assertFalse(kdcConfig.isUseUdp());
+    assertEquals("test-host", kdcConfig.getHostName());
+    assertEquals(11111, kdcConfig.getKdcPort());
+    assertEquals(10 * 1000, kdcConfig.getTimeout());
+
+    verify(connection);
   }
 
+  @Test
+  public void testValidateTCP__Fail_UnknownException() throws Exception {
+    KdcConnection connection = createStrictMock(KdcConnection.class);
+
+    expect(connection.getTgt("noUser@noRealm", "noPassword")).andThrow(
+        new RuntimeException("This is a really bad exception"));
+    replay(connection);
+
+    TestKdcServerConnectionVerification kdcConnVerifier =
+        new TestKdcServerConnectionVerification(configuration, connection);
+
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, TCP);
+    assertFalse(result);
+
+    KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
+    assertFalse(kdcConfig.isUseUdp());
+    assertEquals("test-host", kdcConfig.getHostName());
+    assertEquals(11111, kdcConfig.getKdcPort());
+    assertEquals(10 * 1000, kdcConfig.getTimeout());
+
+    verify(connection);
+  }
+
+  @Test
+  public void testValidateTCP__Fail_Timeout() throws Exception {
+    int timeout = 1;
+    KdcConnection connection = new BlockingKdcConnection(null);
+
+    TestKdcServerConnectionVerification kdcConnVerifier =
+        new TestKdcServerConnectionVerification(configuration, connection);
+
+    kdcConnVerifier.setConnectionTimeout(timeout);
+
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, TCP);
+    assertFalse(result);
+
+    KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
+    assertFalse(kdcConfig.isUseUdp());
+    assertEquals("test-host", kdcConfig.getHostName());
+    assertEquals(11111, kdcConfig.getKdcPort());
+    assertEquals(timeout * 1000, kdcConfig.getTimeout());
+  }
+
+  @Test
+  public void testValidateTCP__Fail_TimeoutErrorCode() throws Exception {
+    KdcConnection connection = createStrictMock(KdcConnection.class);
+
+    expect(connection.getTgt("noUser@noRealm", "noPassword")).andThrow(
+        new KerberosException(ErrorType.KRB_ERR_GENERIC, "TimeOut occurred"));
+    replay(connection);
+
+    TestKdcServerConnectionVerification kdcConnVerifier =
+        new TestKdcServerConnectionVerification(configuration, connection);
+
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, TCP);
+    assertFalse(result);
+
+    KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
+    assertFalse(kdcConfig.isUseUdp());
+    assertEquals("test-host", kdcConfig.getHostName());
+    assertEquals(11111, kdcConfig.getKdcPort());
+    assertEquals(10 * 1000, kdcConfig.getTimeout());
+
+    verify(connection);
+  }
 
   @Test
-  @ExpectedException(NumberFormatException.class)
-  public void testPortParsingFailure() throws Exception {
-    assertFalse(kdcConnectionVerifier.isKdcReachable("localhost:abc"));
+  public void testValidateTCP__Fail_GeneralErrorCode_NotTimeout() throws Exception {
+    KdcConnection connection = createStrictMock(KdcConnection.class);
+
+    expect(connection.getTgt("noUser@noRealm", "noPassword")).andThrow(
+        new KerberosException(ErrorType.KRB_ERR_GENERIC, "foo"));
+    replay(connection);
+
+    TestKdcServerConnectionVerification kdcConnVerifier =
+        new TestKdcServerConnectionVerification(configuration, connection);
+
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, TCP);
+    assertTrue(result);
+
+    KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
+    assertFalse(kdcConfig.isUseUdp());
+    assertEquals("test-host", kdcConfig.getHostName());
+    assertEquals(11111, kdcConfig.getKdcPort());
+    assertEquals(10 * 1000, kdcConfig.getTimeout());
+
+    verify(connection);
   }
 
   @Test
@@ -121,7 +227,7 @@ public class KdcServerConnectionVerificationTest  {
     TestKdcServerConnectionVerification kdcConnVerifier =
         new TestKdcServerConnectionVerification(configuration, connection);
 
-    boolean result = kdcConnVerifier.isKdcReachableViaUDP("test-host", 11111);
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, UDP);
     assertTrue(result);
 
     KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
@@ -144,7 +250,7 @@ public class KdcServerConnectionVerificationTest  {
     TestKdcServerConnectionVerification kdcConnVerifier =
         new TestKdcServerConnectionVerification(configuration, connection);
 
-    boolean result = kdcConnVerifier.isKdcReachableViaUDP("test-host", 11111);
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, UDP);
     assertTrue(result);
 
     KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
@@ -167,7 +273,7 @@ public class KdcServerConnectionVerificationTest  {
     TestKdcServerConnectionVerification kdcConnVerifier =
         new TestKdcServerConnectionVerification(configuration, connection);
 
-    boolean result = kdcConnVerifier.isKdcReachableViaUDP("test-host", 11111);
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, UDP);
     assertFalse(result);
 
     KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
@@ -187,9 +293,9 @@ public class KdcServerConnectionVerificationTest  {
     TestKdcServerConnectionVerification kdcConnVerifier =
         new TestKdcServerConnectionVerification(configuration, connection);
 
-    kdcConnVerifier.setUdpTimeout(timeout);
+    kdcConnVerifier.setConnectionTimeout(timeout);
 
-    boolean result = kdcConnVerifier.isKdcReachableViaUDP("test-host", 11111);
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, UDP);
     assertFalse(result);
 
     KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
@@ -210,7 +316,7 @@ public class KdcServerConnectionVerificationTest  {
     TestKdcServerConnectionVerification kdcConnVerifier =
         new TestKdcServerConnectionVerification(configuration, connection);
 
-    boolean result = kdcConnVerifier.isKdcReachableViaUDP("test-host", 11111);
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, UDP);
     assertFalse(result);
 
     KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
@@ -233,7 +339,7 @@ public class KdcServerConnectionVerificationTest  {
     TestKdcServerConnectionVerification kdcConnVerifier =
         new TestKdcServerConnectionVerification(configuration, connection);
 
-    boolean result = kdcConnVerifier.isKdcReachableViaUDP("test-host", 11111);
+    boolean result = kdcConnVerifier.isKdcReachable("test-host", 11111, UDP);
     assertTrue(result);
 
     KdcConfig kdcConfig = kdcConnVerifier.getConfigUsedInConnectionCreation();
@@ -245,39 +351,14 @@ public class KdcServerConnectionVerificationTest  {
     verify(connection);
   }
 
-
-  /**
-   * Socket server for test
-   * We need a separate thread as accept() is a blocking call
-   */
-  private static class SocketThread extends Thread {
-    public void run() {
-      while (serverSocket != null && !serverStop) {
-        try {
-          serverSocket.accept();
-        } catch (SocketException se) {
-          LOG.debug("SocketException during tearDown. Can be safely ignored");
-        } catch (IOException e) {
-          LOG.error("Unexpected exception while accepting connection request");
-        }
-      }
-
-    }
-  }
-
-  private static void createSocketServer(int port) throws Exception {
-    serverSocket = new ServerSocket(port);
-    new SocketThread().start();
+  @Test
+  @Ignore
+  public void testValidate__Live() throws Exception {
+    KdcServerConnectionVerification kdcConnVerifier = new KdcServerConnectionVerification(configuration);
+    boolean result = kdcConnVerifier.isKdcReachable("c6501:88");
+    assertTrue(result);
   }
 
-  private static void closeServerSocket() throws Exception {
-    serverStop = true;
-    try{
-      serverSocket.close();
-    } catch (IOException ioe) {
-      LOG.debug("IOException during tearDown. Can be safely ignored");
-    }
-  }
 
   // Test implementation which allows a mock KDC connection to be used.
   private static class TestKdcServerConnectionVerification extends KdcServerConnectionVerification
{
@@ -290,7 +371,7 @@ public class KdcServerConnectionVerificationTest  {
     }
 
     @Override
-    protected KdcConnection getKdcUdpConnection(KdcConfig config) {
+    protected KdcConnection getKdcConnection(KdcConfig config) {
       kdcConfig = config;
       return connection;
     }


Mime
View raw message