import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
@Test
public void testSimple() throws SQLException {
    MySQLContainer mysql = (MySQLContainer) new MySQLContainer()
            .withConfigurationOverride("somepath/mysql_conf_override")
            .withLogConsumer(new Slf4jLogConsumer(logger));
    mysql.start();

    try {
        ResultSet resultSet = performQuery(mysql, "SELECT 1");
        int resultSetInt = resultSet.getInt(1);

        assertEquals("A basic SELECT query succeeds", 1, resultSetInt);
    } finally {
        mysql.stop();
    }
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
@Test
public void testSpecificVersion() throws SQLException {
    MySQLContainer mysqlOldVersion = (MySQLContainer) new MySQLContainer("mysql:5.5")
            .withConfigurationOverride("somepath/mysql_conf_override")
            .withLogConsumer(new Slf4jLogConsumer(logger));
    mysqlOldVersion.start();

    try {
        ResultSet resultSet = performQuery(mysqlOldVersion, "SELECT VERSION()");
        String resultSetString = resultSet.getString(1);

        assertTrue("The database version can be set using a container rule parameter", resultSetString.startsWith("5.5"));
    } finally {
        mysqlOldVersion.stop();
    }
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
@Override protected ElasticsearchHttpStorage compute() {
  try {
    container = new GenericContainer(image)
        .withExposedPorts(9200)
        .withEnv("ES_JAVA_OPTS", "-Dmapper.allow_dots_in_name=true -Xms512m -Xmx512m")
        .waitingFor(new HttpWaitStrategy().forPath("/"));
    container.start();
    if (Boolean.valueOf(System.getenv("ES_DEBUG"))) {
      container.followOutput(new Slf4jLogConsumer(LoggerFactory.getLogger(image)));
    }
    System.out.println("Starting docker image " + image);
  } catch (RuntimeException e) {
    // Ignore
  }

  ElasticsearchHttpStorage result = computeStorageBuilder().build();
  CheckResult check = result.check();
  if (check.ok()) {
    return result;
  } else {
    throw new AssumptionViolatedException(check.error().getMessage(), check.error());
  }
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
@Override
protected void configure() {
    super.configure();
    withLogConsumer(new Slf4jLogConsumer(log));
    withExposedPorts(5701);
    setWaitStrategy(Wait.forListeningPort());
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
public void start() {
    consulContainer.start();
    consulContainer.followOutput(new Slf4jLogConsumer(logger).withPrefix("consul"));
    await("Consul is ready")
            .atMost(10, TimeUnit.SECONDS)
            .until(() -> {
                try {
                    consul.set(Consul.builder().withUrl(getConsulUrl()).build());
                    return true;
                } catch (Exception e) {
                    logger.info("Failed to create consul client, probably consul is not ready yet", e);
                    return false;
                }
            });
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
@BeforeClass
public static void startConsulTestContainer() {
    consulContainer = new GenericContainer("quay.io/coreos/etcd:v3.2.4")
            .withExposedPorts(2379)
            .withCommand("etcd",
                    "--advertise-client-urls", "http://0.0.0.0:2379",
                    "--listen-client-urls", "http://0.0.0.0:2379"
            );

    consulContainer.start();
    consulContainer.followOutput(new Slf4jLogConsumer(logger).withPrefix("etcd"));
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
@Override
//  public void beforeEach(ExtensionContext context) throws Exception {
  public void beforeEach(TestExtensionContext context) throws Exception {
    BrowserWebDriverContainer webDriverContainer
        = new BrowserWebDriverContainer()
        .withDesiredCapabilities(DesiredCapabilities.chrome()); // only one per container

    webDriverContainer.start();

    Slf4jLogConsumer logConsumer = new Slf4jLogConsumer(LoggerFactory.getLogger(this.getClass()));
    webDriverContainer.followOutput(logConsumer);

    storeTestcontainer().accept(context, webDriverContainer);
    storeWebDriver().accept(context, webDriverContainer::getWebDriver);
  }
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
private void tailChildContainerLogs() {
    listChildContainers().forEach(container ->
            LogUtils.followOutput(dockerClient,
                    container.getId(),
                    new Slf4jLogConsumer(logger()).withPrefix(container.getNames()[0]),
                    OutputFrame.OutputType.STDOUT,
                    OutputFrame.OutputType.STDERR)
    );
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
@Override
public void invoke() {
    super.start();

    this.followOutput(new Slf4jLogConsumer(logger()));

    // wait for the compose container to stop, which should only happen after it has spawned all the service containers
    logger().info("Docker Compose container is running for command: {}", Joiner.on(" ").join(this.getCommandParts()));
    while (this.isRunning()) {
        logger().trace("Compose container is still running");
        Uninterruptibles.sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
    }
    logger().info("Docker Compose has finished running");

    AuditLogger.doComposeLog(this.getCommandParts(), this.getEnv());

    final Integer exitCode = this.dockerClient.inspectContainerCmd(containerId)
            .exec()
            .getState()
            .getExitCode();

    if (exitCode == null || exitCode != 0) {
        throw new ContainerLaunchException(
                "Containerised Docker Compose exited abnormally with code " +
                        exitCode +
                        " whilst running command: " +
                        StringUtils.join(this.getCommandParts(), ' '));
    }
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
@Test
public void testLogConsumer() throws TimeoutException {

    WaitingConsumer waitingConsumer = new WaitingConsumer();
    Slf4jLogConsumer logConsumer = new Slf4jLogConsumer(LOGGER);

    Consumer<OutputFrame> composedConsumer = logConsumer.andThen(waitingConsumer);
    container.followOutput(composedConsumer);

    waitingConsumer.waitUntil(frame -> frame.getType() == STDOUT && frame.getUtf8String().contains("seq=2"));
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
@Test
public void zookeeperUrl() {
  zooCp.followOutput(new Slf4jLogConsumer(log));
  System.out.println(zooCp.zookeeperUrl());
}
 

import org.testcontainers.containers.output.Slf4jLogConsumer; //导入依赖的package包/类
private void tryStart(Profiler profiler) {
    try {
        String dockerImageName = image.get();
        logger().debug("Starting container: {}", dockerImageName);

        logger().info("Creating container for image: {}", dockerImageName);
        profiler.start("Create container");
        CreateContainerCmd createCommand = dockerClient.createContainerCmd(dockerImageName);
        applyConfiguration(createCommand);
        createContainerCmdModifiers.forEach(hook -> hook.accept(createCommand));

        containerId = createCommand.exec().getId();
        ResourceReaper.instance().registerContainerForCleanup(containerId, dockerImageName);

        logger().info("Starting container with ID: {}", containerId);
        profiler.start("Start container");
        dockerClient.startContainerCmd(containerId).exec();

        // For all registered output consumers, start following as close to container startup as possible
        this.logConsumers.forEach(this::followOutput);

        logger().info("Container {} is starting: {}", dockerImageName, containerId);

        // Tell subclasses that we're starting
        profiler.start("Inspecting container");
        containerInfo = dockerClient.inspectContainerCmd(containerId).exec();
        containerName = containerInfo.getName();
        profiler.start("Call containerIsStarting on subclasses");
        containerIsStarting(containerInfo);

        // Wait until the container is running (may not be fully started)
        profiler.start("Wait until container has started properly, or there's evidence it failed to start.");

        if (!this.startupCheckStrategy.waitUntilStartupSuccessful(dockerClient, containerId)) {
            // Bail out, don't wait for the port to start listening.
            // (Exception thrown here will be caught below and wrapped)
            throw new IllegalStateException("Container did not start correctly.");
        }

        profiler.start("Wait until container started properly");
        waitUntilContainerStarted();

        logger().info("Container {} started", dockerImageName);
        containerIsStarted(containerInfo);
    } catch (Exception e) {
        logger().error("Could not start container", e);

        // Log output if startup failed, either due to a container failure or exception (including timeout)
        logger().error("Container log output (if any) will follow:");
        FrameConsumerResultCallback resultCallback = new FrameConsumerResultCallback();
        resultCallback.addConsumer(STDOUT, new Slf4jLogConsumer(logger()));
        resultCallback.addConsumer(STDERR, new Slf4jLogConsumer(logger()));
        dockerClient.logContainerCmd(containerId).withStdOut(true).withStdErr(true).exec(resultCallback);

        // Try to ensure that container log output is shown before proceeding
        try {
            resultCallback.getCompletionLatch().await(1, TimeUnit.MINUTES);
        } catch (InterruptedException ignored) {
            // Cannot do anything at this point
        }

        throw new ContainerLaunchException("Could not create/start container", e);
    } finally {
        profiler.stop();
    }
}