How to use

ExternalHandlerServer

in

co.cask.coopr.http

 public HttpResponse call() throws Exception {
  return doSecureGet(String.format("http://%s:%d/status", HOSTNAME,
                   externalHandlerServer.getBindAddress().getPort()));
 }
});

@Before
public void startServer() {
 externalHandlerServer = injector.getInstance(ExternalHandlerServer.class);
 externalHandlerServer.startAndWait();
}

 @Override
 void addSSLConfig(NettyHttpService.Builder builder, Configuration conf) {
  boolean enableSSL = conf.getBoolean(Constants.EXTERNAL_ENABLE_SSL);
  if (enableSSL) {
   builder.enableSSL(getSSLConfig(conf, Constants.EXTERNAL_SSL_KEYSTORE_PATH,
                   Constants.EXTERNAL_SSL_KEYSTORE_PASSWORD,
                   Constants.EXTERNAL_SSL_KEYPASSWORD,
                   Constants.EXTERNAL_SSL_TRUST_KEYSTORE_PATH,
                   Constants.EXTERNAL_SSL_TRUST_KEYPASSWORD));
  }
 }
}

@BeforeClass
public static void setup() throws IOException, InterruptedException {
 initAuthTestProps();
 externalHandlerServer = injector.getInstance(ExternalHandlerServer.class);
 externalHandlerServer.startAndWait();
 externalAuthenticationServer = injector.getInstance(ExternalAuthenticationServer.class);
 externalAuthenticationServer.startAndWait();
 // Wait *SLEEP_TIME_IN_SEC* for the complete service start
 Thread.sleep(1000 * SLEEP_TIME_IN_SEC);
 testServerPort = externalHandlerServer.getBindAddress().getPort();
 authURL = String.format("http://%s:%d/token",
             externalAuthenticationServer.getSocketAddress().getHostName(),
             externalAuthenticationServer.getSocketAddress().getPort());
}

@After
public void stopServer() {
 externalHandlerServer.stopAndWait();
}

LOG.info("Internal API handler service started on {}", internalHandlerServer.getBindAddress());
externalHandlerServer = injector.getInstance(ExternalHandlerServer.class);
externalHandlerServer.startAndWait();
LOG.info("External API handler service started on {}", externalHandlerServer.getBindAddress());

@AfterClass
public static void cleanupServiceBase() {
 internalHandlerServer.stopAndWait();
 externalHandlerServer.stopAndWait();
}

@BeforeClass
public static void setupServiceBase() throws Exception {
 balancerQueue = injector.getInstance(Key.get(TrackingQueue.class, Names.named(Constants.Queue.WORKER_BALANCE)));
 provisionerQueues = queueService.getQueueGroup(QueueType.PROVISIONER);
 clusterQueues = queueService.getQueueGroup(QueueType.CLUSTER);
 solverQueues = queueService.getQueueGroup(QueueType.SOLVER);
 jobQueues = queueService.getQueueGroup(QueueType.JOB);
 callbackQueues = queueService.getQueueGroup(QueueType.CALLBACK);
 internalHandlerServer = injector.getInstance(InternalHandlerServer.class);
 internalHandlerServer.startAndWait();
 internalPort = internalHandlerServer.getBindAddress().getPort();
 externalHandlerServer = injector.getInstance(ExternalHandlerServer.class);
 externalHandlerServer.startAndWait();
 externalPort = externalHandlerServer.getBindAddress().getPort();
 tenantProvisionerService = injector.getInstance(TenantProvisionerService.class);
 internalBase = "http://" + HOSTNAME + ":" + internalPort + Constants.API_BASE;
 externalBase = "http://" + HOSTNAME + ":" + externalPort + Constants.API_BASE;
}

@Test
public void testStatus() throws Exception {
 HttpResponse response = doSecureGet(String.format("https://%s:%d/status", HOSTNAME,
                       externalHandlerServer.getBindAddress().getPort()));
 Assert.assertEquals(200, response.getStatusLine().getStatusCode());
 Assert.assertEquals("OK\n", EntityUtils.toString(response.getEntity()));
}

@AfterClass
public static void shutDown() {
 externalHandlerServer.stopAndWait();
 externalAuthenticationServer.stopAndWait();
}