Java LogContainerCmd类代码示例

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
@Override
protected Stream<LogEntry> run() throws Exception {
  LogContainerCmd cmd = dockerClient.logContainerCmd(containerId);
  if (params.isWithStdOut()) {
    cmd.withStdOut(true);
  }
  if (params.isWithStdErr()) {
    cmd.withStdErr(true);
  }
  if (params.isWithTimestamps()) {
    cmd.withTimestamps(true);
  }
  if (params.getTail() > 0) {
    cmd.withTail(params.getTail());
  }

  LogContainerCallback callBack = new LogContainerCallback();
  Sssh.waitForCompletion(cmd.exec(callBack));
  return callBack.entries.stream();
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
/**
 * Synchronized method for returning logs of docker container
 *
 * @param containerId - ID of the container ot lookup logs
 * @return list of strings, where every string is log line
 */
public static List<String> getDockerLogs(String containerId) {

    final List<String> logs = new ArrayList<>();

    LogContainerCmd logContainerCmd = DockerClientFactory.build().logContainerCmd(containerId);
    logContainerCmd.withStdOut(true).withStdErr(true);
    try {
        logContainerCmd.exec(new LogContainerResultCallback() {
            @Override
            public void onNext(Frame item) {
                logs.add(item.toString());
            }
        }).awaitCompletion();
    } catch (InterruptedException e) {
        throw new MinimesosException("Failed to retrieve logs of container " + containerId, e);
    }

    return logs;
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void followOutput(DockerClient dockerClient, String containerId,
                         Consumer<OutputFrame> consumer, OutputFrame.OutputType... types) {

    final LogContainerCmd cmd = dockerClient.logContainerCmd(containerId)
            .withFollowStream(true)
            .withSince(0);

    final FrameConsumerResultCallback callback = new FrameConsumerResultCallback();
    for (OutputFrame.OutputType type : types) {
        callback.addConsumer(type, consumer);
        if (type == STDOUT) cmd.withStdOut(true);
        if (type == STDERR) cmd.withStdErr(true);
    }

    cmd.exec(callback);
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
@Override
protected AbstractCallbackNotifier<Frame> callbackNotifier(LogContainerCmd command,
        ResultCallback<Frame> resultCallback) {

    WebTarget webTarget = getBaseResource().path("/containers/{id}/logs").resolveTemplate("id",
            command.getContainerId());

    if (command.getTail() != null) {
        webTarget = webTarget.queryParam("tail", command.getTail());
    }

    if (command.getSince() != null) {
        webTarget = webTarget.queryParam("since", command.getSince());
    }

    webTarget = booleanQueryParam(webTarget, "timestamps", command.hasTimestampsEnabled());
    webTarget = booleanQueryParam(webTarget, "stdout", command.hasStdoutEnabled());
    webTarget = booleanQueryParam(webTarget, "stderr", command.hasStderrEnabled());
    webTarget = booleanQueryParam(webTarget, "follow", command.hasFollowStreamEnabled());

    LOGGER.trace("GET: {}", webTarget);

    return new GETCallbackNotifier<Frame>(new FrameStreamProcessor(), resultCallback, webTarget.request());
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
@Override
protected Void execute0(LogContainerCmd command, ResultCallback<Frame> resultCallback) {

    WebTarget webTarget = getBaseResource().path("/containers/{id}/logs").resolveTemplate("id",
            command.getContainerId());

    if (command.getTail() != null) {
        webTarget = webTarget.queryParam("tail", command.getTail());
    }

    if (command.getSince() != null) {
        webTarget = webTarget.queryParam("since", command.getSince());
    }

    webTarget = booleanQueryParam(webTarget, "timestamps", command.hasTimestampsEnabled());
    webTarget = booleanQueryParam(webTarget, "stdout", command.hasStdoutEnabled());
    webTarget = booleanQueryParam(webTarget, "stderr", command.hasStderrEnabled());
    webTarget = booleanQueryParam(webTarget, "follow", command.hasFollowStreamEnabled());

    LOGGER.trace("GET: {}", webTarget);

    webTarget.request().get(resultCallback);

    return null;
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
public void containerTailStream (
									String id,
									String name,
									HttpServletResponse response,
									int numberOfLines ) {
	try {
		String targetId = getContainerId( id, name );
		// docker.startContainer( container.id());
		DockerContainerLogCallback loggingCallback = new DockerContainerLogCallback( response.getWriter() );
		LogContainerCmd logCommand = dockerClient
			.logContainerCmd( targetId )
			.withStdErr( true )
			.withStdOut( true );

		if ( numberOfLines > 0 ) {
			logCommand.withTail( numberOfLines );
		}

		logCommand.exec( loggingCallback );

		loggingCallback.awaitCompletion( 3, TimeUnit.SECONDS );

	} catch (Exception e) {
		String reason = CSAP.getCsapFilteredStackTrace( e );
		logger.warn( "Failed starting {}, {}", name, reason );
		try {
			response.getWriter().println( "Failed getting file: " + reason );
		} catch (IOException e1) {
			// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}

	return;
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
public void copyLog(String containerId, boolean follow, boolean stdout, boolean stderr, boolean timestamps, int tail,
    OutputStream outputStream) throws IOException {
    this.readWriteLock.readLock().lock();
    try {
        LogContainerCmd logContainerCmd =
            dockerClient.logContainerCmd(containerId).withStdErr(false).withStdOut(false);

        logContainerCmd.withFollowStream(follow);
        logContainerCmd.withStdOut(stdout);
        logContainerCmd.withStdErr(stderr);
        logContainerCmd.withTimestamps(timestamps);

        if (tail < 0) {
            logContainerCmd.withTailAll();
        } else {
            logContainerCmd.withTail(tail);
        }

        OutputStreamLogsResultCallback outputStreamLogsResultCallback =
            new OutputStreamLogsResultCallback(outputStream);
        logContainerCmd.exec(outputStreamLogsResultCallback);
        try {
            outputStreamLogsResultCallback.awaitCompletion();
        } catch (InterruptedException e) {
            throw new IOException(e);
        }
    } finally {
        this.readWriteLock.readLock().unlock();
    }
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
public ObjectNode containerTail (
									String id,
									String name,
									int numberOfLines,
									int since ) {

	ObjectNode result = jacksonMapper.createObjectNode();
	result.put( "since", since );
	try {
		String targetId = getContainerId( id, name );
		// docker.startContainer( container.id());
		if ( targetId == null ) {
			result.put( "result", "View logs: " + targetId );
			result.put( "plainText", "Unable to locate container - verify it is created and running" );
			return result;
		}
		DockerContainerLogCallback loggingCallback = new DockerContainerLogCallback( true );
		LogContainerCmd logCommand = dockerClient
			.logContainerCmd( targetId )
			.withStdErr( true )
			.withStdOut( true )
			.withTail( numberOfLines );

		if ( since < 0 ) {
			int timestamp = (int) (System.currentTimeMillis() / 1000) - 1;
			since = timestamp;
		}

		if ( since > 0 ) {
			logCommand.withSince( since );
		}

		result.put( "since", since );

		logCommand.exec( loggingCallback );
		loggingCallback.awaitCompletion( 3, TimeUnit.SECONDS );

		result.put( "result", "View logs: " + targetId );
		result.put( "plainText", loggingCallback.toString() );
		String parameterName = "?id=" + id;
		if ( id == null )
			parameterName = "?name=" + name;
		result.put( "url", parameterName + "&numberOfLines="
				+ numberOfLines );

	} catch (Exception e) {
		String reason = CSAP.getCsapFilteredStackTrace( e );
		logger.warn( "Failed getting logs {}, {}", name, reason );
		result.put( DockerJson.error.key, "Failed starting: " + name );
		result.put( DockerJson.errorReason.key, reason );
	}

	return result;
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
@Override
public LogContainerCmd.Exec createLogContainerCmdExec() {
    return new LogContainerCmdExec(getBaseResource(), getDockerClientConfig());
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
@Override
public LogContainerCmd logContainerCmd(String containerId) {
    return new LogContainerCmdImpl(getDockerCmdExecFactory().createLogContainerCmdExec(), containerId);
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
public LogContainerCmdImpl(LogContainerCmd.Exec exec, String containerId) {
    super(exec);
    withContainerId(containerId);
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
@Override
public LogContainerCmd withContainerId(String containerId) {
    checkNotNull(containerId, "containerId was not specified");
    this.containerId = containerId;
    return this;
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
@Override
public LogContainerCmd withFollowStream(Boolean followStream) {
    this.followStream = followStream;
    return this;
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
@Override
public LogContainerCmd withTimestamps(Boolean timestamps) {
    this.timestamps = timestamps;
    return this;
}
 

import com.github.dockerjava.api.command.LogContainerCmd; //导入依赖的package包/类
@Override
public LogContainerCmd withStdOut(Boolean stdout) {
    this.stdout = stdout;
    return this;
}