org.testcontainers.containers.ContainerLaunchException Java Examples

private WaitStrategy waitStrategy() {
    return new AbstractWaitStrategy() {
        @Override
        protected void waitUntilReady() {
            final DockerClient client = DockerClientFactory.instance().client();
            final WaitingConsumer waitingConsumer = new WaitingConsumer();

            LogUtils.followOutput(client, waitStrategyTarget.getContainerId(), waitingConsumer);

            try {
                waitingConsumer.waitUntil(
                    f -> f.getUtf8String().contains("etcdserver: published"),
                    startupTimeout.getSeconds(),
                    TimeUnit.SECONDS,
                    1
                );
            } catch (TimeoutException e) {
                throw new ContainerLaunchException("Timed out");
            }
        }
    };
}
 

@Override
protected void waitUntilReady() {
    // execute select version query until success or timeout
    try {
        retryUntilSuccess((int) startupTimeout.getSeconds(), TimeUnit.SECONDS, () -> {
            getRateLimiter().doWhenReady(() -> {
                try (DatabaseDelegate databaseDelegate = getDatabaseDelegate()) {
                    databaseDelegate.execute(SELECT_VERSION_QUERY, "", 1, false, false);
                }
            });
            return true;
        });
    } catch (TimeoutException e) {
        throw new ContainerLaunchException(TIMEOUT_ERROR);
    }
}
 

private void expectToFailWithNotFoundException(GenericContainer<?> container) {
    try {
        container.start();
        fail("Should fail");
    } catch (ContainerLaunchException e) {
        Throwable throwable = e;
        while (throwable.getCause() != null) {
            throwable = throwable.getCause();
            if (throwable.getCause() instanceof NotFoundException) {
                VisibleAssertions.pass("Caused by NotFoundException");
                return;
            }
        }
        VisibleAssertions.fail("Caused by NotFoundException");
    }
}
 

@Override
protected void waitUntilReady()
{
    Callable<Boolean> internalCheck = new InternalCommandPortListeningCheck(waitStrategyTarget, exposedPorts);

    Set<Integer> externalPorts = exposedPorts.stream()
            .map(waitStrategyTarget::getMappedPort)
            .collect(toImmutableSet());
    Callable<Boolean> externalCheck = new ExternalPortListeningCheck(waitStrategyTarget, externalPorts);

    Failsafe.with(new RetryPolicy<>()
            .withMaxDuration(startupTimeout)
            .withMaxAttempts(Integer.MAX_VALUE) // limited by MaxDuration
            .abortOn(e -> getExitCode().isPresent()))
            .run(() -> {
                if (!getRateLimiter().getWhenReady(() -> internalCheck.call() && externalCheck.call())) {
                    // We say "timed out" immediately. Failsafe will propagate this only when timeout reached.
                    throw new ContainerLaunchException(format(
                            "Timed out waiting for container port to open (%s ports: %s should be listening)",
                            waitStrategyTarget.getContainerIpAddress(),
                            exposedPorts));
                }
            });
}
 

@Override protected void waitUntilContainerStarted() {
  Unreliables.retryUntilSuccess(2, TimeUnit.MINUTES, () -> {
    if (!isRunning()) {
      throw new ContainerLaunchException("Container failed to start");
    }

    InetSocketAddress address =
      new InetSocketAddress(getContainerIpAddress(), getMappedPort(9042));

    try (Cluster cluster = getCluster(address); Session session = cluster.newSession()) {
      session.execute("SELECT now() FROM system.local");
      logger().info("Obtained a connection to container ({})", cluster.getClusterName());
      return null; // unused value
    }
  });
}
 

@Override protected void waitUntilContainerStarted() {
  Unreliables.retryUntilSuccess(2, TimeUnit.MINUTES, () -> {
    if (!isRunning()) {
      throw new ContainerLaunchException("Container failed to start");
    }

    InetSocketAddress address =
      new InetSocketAddress(getContainerIpAddress(), getMappedPort(9042));

    try (Cluster cluster = getCluster(address); Session session = cluster.newSession()) {
      session.execute("SELECT now() FROM system.local");
      logger().info("Obtained a connection to container ({})", cluster.getClusterName());
      return null; // unused value
    }
  });
}
 

protected Callable<Boolean> containerStartedCondition(String statusUrl) {
  return () -> {
    if (!isRunning()) {
      throw new ContainerLaunchException("Container failed to start");
    }

    Request request = new Request.Builder()
        .url(statusUrl)
        .head()
        .build();
    try (Response response = okHttpClient.newCall(request).execute()) {
      return response.code() == 200;
    } catch (ConnectException ex) {
      return false;
    }
  };
}
 

private static Path createDataDirectory(String name) {
    try {
        final String prefix = "jetcd_test_" + name + "_";
        final FileAttribute<?> attribute = PosixFilePermissions.asFileAttribute(EnumSet.allOf(PosixFilePermission.class));

        // https://github.com/etcd-io/jetcd/issues/489
        // Resolve symlink (/var -> /private/var) to don't fail for Mac OS because of docker thing with /var/folders
        return Files.createTempDirectory(prefix, attribute).toRealPath();
    } catch (IOException e) {
        throw new ContainerLaunchException("Error creating data directory", e);
    }
}
 

@Override
protected void waitUntilContainerStarted() {
  Unreliables.retryUntilSuccess(120, TimeUnit.SECONDS, () -> {
    if (!isRunning()) {
      throw new ContainerLaunchException("Container failed to start");
    }

    try (Cluster cluster = getCluster(); Session session = cluster.newSession()) {
      session.execute("SELECT now() FROM system.local");
      logger().info("Obtained a connection to container ({})", cluster.getClusterName());
      return null; // unused value
    }
  });
}
 

private void await(CountDownLatch latch) {
  	try {
  		latch.await( getStartupTimeoutSeconds(), TimeUnit.SECONDS );
} catch (InterruptedException e) {
	throw new ContainerLaunchException("Container startup wait was interrupted", e);
}
  }
 

@Test(expected = ContainerLaunchException.class)
public void testEmptyPasswordWithNonRootUser() {
    try (MySQLContainer<?> container = new MySQLContainer<>("mysql:5.5")
                .withDatabaseName("TEST")
                .withUsername("test")
                .withPassword("")
                .withEnv("MYSQL_ROOT_HOST", "%")){
        container.start();
        fail("ContainerLaunchException expected to be thrown");
    }
}
 

@Override
protected void waitUntilReady() {
    final Set<Integer> externalLivenessCheckPorts = getLivenessCheckPorts();
    if (externalLivenessCheckPorts.isEmpty()) {
        if (log.isDebugEnabled()) {
            log.debug("Liveness check ports of {} is empty. Not waiting.", waitStrategyTarget.getContainerInfo().getName());
        }
        return;
    }

    @SuppressWarnings("unchecked")
    List<Integer> exposedPorts = waitStrategyTarget.getExposedPorts();

    final Set<Integer> internalPorts = getInternalPorts(externalLivenessCheckPorts, exposedPorts);

    Callable<Boolean> internalCheck = new InternalCommandPortListeningCheck(waitStrategyTarget, internalPorts);

    Callable<Boolean> externalCheck = new ExternalPortListeningCheck(waitStrategyTarget, externalLivenessCheckPorts);

    try {
        Unreliables.retryUntilTrue((int) startupTimeout.getSeconds(), TimeUnit.SECONDS,
            () -> getRateLimiter().getWhenReady(() -> internalCheck.call() && externalCheck.call()));

    } catch (TimeoutException e) {
        throw new ContainerLaunchException("Timed out waiting for container port to open (" +
                waitStrategyTarget.getHost() +
                " ports: " +
                externalLivenessCheckPorts +
                " should be listening)");
    }
}
 

@Override
@SneakyThrows(IOException.class)
protected void waitUntilReady() {
    WaitingConsumer waitingConsumer = new WaitingConsumer();

    LogContainerCmd cmd = DockerClientFactory.instance().client().logContainerCmd(waitStrategyTarget.getContainerId())
        .withFollowStream(true)
        .withSince(0)
        .withStdOut(true)
        .withStdErr(true);

    try (FrameConsumerResultCallback callback = new FrameConsumerResultCallback()) {
        callback.addConsumer(STDOUT, waitingConsumer);
        callback.addConsumer(STDERR, waitingConsumer);

        cmd.exec(callback);

        Predicate<OutputFrame> waitPredicate = outputFrame ->
            // (?s) enables line terminator matching (equivalent to Pattern.DOTALL)
            outputFrame.getUtf8String().matches("(?s)" + regEx);

        try {
            waitingConsumer.waitUntil(waitPredicate, startupTimeout.getSeconds(), TimeUnit.SECONDS, times);
        } catch (TimeoutException e) {
            throw new ContainerLaunchException("Timed out waiting for log output matching '" + regEx + "'");
        }
    }
}
 

@Override
protected void waitUntilReady() {

    try {
        Unreliables.retryUntilTrue((int) startupTimeout.getSeconds(), TimeUnit.SECONDS, waitStrategyTarget::isHealthy);
    } catch (TimeoutException e) {
        throw new ContainerLaunchException("Timed out waiting for container to become healthy");
    }
}
 

/**
 * Expects that the WaitStrategy throws a {@link RetryCountExceededException} after unsuccessful connection
 * to a container with a listening port.
 *
 * @param container the container to start
 */
protected void waitUntilReadyAndTimeout(GenericContainer container) {
    // start() blocks until successful or timeout
    VisibleAssertions.assertThrows("an exception is thrown when timeout occurs (" + WAIT_TIMEOUT_MILLIS + "ms)",
            ContainerLaunchException.class,
            container::start);

}
 

public SqlConnection createVertxConnection() {
	String url = getVertxUrl();
	CountDownLatch countDown = new CountDownLatch( 1 );
	AtomicReference<AsyncResult<SqlConnection>> result = new AtomicReference<>();
	MySQLPool.pool( url ).getConnection( ar -> {
		result.set( ar );
		countDown.countDown();
	});
	await(countDown);
	SqlConnection con = result.get().result();
	if (con != null)
		return con;
	else
		throw new ContainerLaunchException( "Failed to obtain a connection", result.get().cause() );
}
 

/**
 * Initialize the replicaSet by calling `rs.initialize()` in mongo shell.
 */
public int initializeReplicaSet() {
    ExecResult execResult;
    try {
        execResult = execInContainer("mongo", "--eval", "rs.initiate()");
        return execResult.getExitCode();
    } catch (Exception e) {
        throw new ContainerLaunchException("Error during initialization of replicaSet for container: " + self(), e);
    }
}
 

@Test
public void containerStartFailsIfContainerIsUnhealthy() {
    container.withCommand("tail", "-f", "/dev/null");
    assertThrows("Container launch fails when unhealthy", ContainerLaunchException.class, container::start);
}