/*******************************************************************************
* Copyright (c) 2012-2017 Codenvy, S.A.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Codenvy, S.A. - initial API and implementation
*******************************************************************************/
package org.eclipse.che.plugin.docker.machine;
import com.google.inject.assistedinject.Assisted;
import org.eclipse.che.api.core.ConflictException;
import org.eclipse.che.api.core.NotFoundException;
import org.eclipse.che.api.core.model.machine.Command;
import org.eclipse.che.api.core.util.LineConsumer;
import org.eclipse.che.api.core.util.ListLineConsumer;
import org.eclipse.che.api.core.util.ValueHolder;
import org.eclipse.che.api.machine.server.exception.MachineException;
import org.eclipse.che.api.machine.server.spi.InstanceProcess;
import org.eclipse.che.api.machine.server.spi.impl.AbstractMachineProcess;
import org.eclipse.che.commons.annotation.Nullable;
import org.eclipse.che.plugin.docker.client.DockerConnector;
import org.eclipse.che.plugin.docker.client.DockerConnectorProvider;
import org.eclipse.che.plugin.docker.client.Exec;
import org.eclipse.che.plugin.docker.client.LogMessage;
import org.eclipse.che.plugin.docker.client.MessageProcessor;
import org.eclipse.che.plugin.docker.client.params.CreateExecParams;
import org.eclipse.che.plugin.docker.client.params.StartExecParams;
import javax.inject.Inject;
import java.io.IOException;
import java.net.SocketTimeoutException;
import java.util.Arrays;
import static com.google.common.base.MoreObjects.firstNonNull;
import static java.lang.String.format;
/**
* Docker implementation of {@link InstanceProcess}
*
* @author andrew00x
* @author Alexander Garagatyi
*/
public class DockerProcess extends AbstractMachineProcess implements InstanceProcess {
private final DockerConnector docker;
private final String container;
private final String pidFilePath;
private final String commandLine;
private final String shellInvoker;
private volatile boolean started;
@Inject
public DockerProcess(DockerConnectorProvider dockerProvider,
@Assisted Command command,
@Assisted("container") String container,
@Nullable @Assisted("outputChannel") String outputChannel,
@Assisted("pid_file_path") String pidFilePath,
@Assisted int pid) {
super(command, pid, outputChannel);
this.docker = dockerProvider.get();
this.container = container;
this.commandLine = command.getCommandLine();
this.shellInvoker = firstNonNull(command.getAttributes().get("shell"), "/bin/sh");
this.pidFilePath = pidFilePath;
this.started = false;
}
@Override
public boolean isAlive() {
if (!started) {
return false;
}
try {
checkAlive();
return true;
} catch (MachineException | NotFoundException e) {
// when process is not found (may be finished or killed)
// when process is not running yet
// when docker is not accessible or responds in an unexpected way - should never happen
return false;
}
}
@Override
public void start() throws ConflictException, MachineException {
start(null);
}
@Override
public void start(LineConsumer output) throws ConflictException, MachineException {
if (started) {
throw new ConflictException("Process already started.");
}
started = true;
// Trap is invoked when bash session ends. Here we kill all sub-processes of shell and remove pid-file.
final String trap = format("trap '[ -z \"$(jobs -p)\" ] || kill $(jobs -p); [ -e %1$s ] && rm %1$s' EXIT", pidFilePath);
// 'echo' saves shell pid in file, then run command
final String shellCommand = trap + "; echo $$>" + pidFilePath + "; " + commandLine;
final String[] command = {shellInvoker, "-c", shellCommand};
Exec exec;
try {
exec = docker.createExec(CreateExecParams.create(container, command).withDetach(output == null));
} catch (IOException e) {
throw new MachineException(format("Error occurs while initializing command %s in docker container %s: %s",
Arrays.toString(command), container, e.getMessage()), e);
}
try {
docker.startExec(StartExecParams.create(exec.getId()), output == null ? null : new LogMessagePrinter(output));
} catch (IOException e) {
if (output != null && e instanceof SocketTimeoutException) {
throw new MachineException(getErrorMessage());
} else {
throw new MachineException(format("Error occurs while executing command %s: %s",
Arrays.toString(exec.getCommand()), e.getMessage()), e);
}
}
}
@Override
public void checkAlive() throws MachineException, NotFoundException {
// Read pid from file and run 'kill -0 [pid]' command.
final String isAliveCmd = format("[ -r %1$s ] && kill -0 $(cat %1$s) || echo 'Unable read PID file'", pidFilePath);
final ListLineConsumer output = new ListLineConsumer();
final String[] command = {"/bin/sh", "-c", isAliveCmd};
Exec exec;
try {
exec = docker.createExec(CreateExecParams.create(container, command).withDetach(false));
} catch (IOException e) {
throw new MachineException(format("Error occurs while initializing command %s in docker container %s: %s",
Arrays.toString(command), container, e.getMessage()), e);
}
try {
docker.startExec(StartExecParams.create(exec.getId()), new LogMessagePrinter(output));
} catch (IOException e) {
throw new MachineException(format("Error occurs while executing command %s in docker container %s: %s",
Arrays.toString(exec.getCommand()), container, e.getMessage()), e);
}
// 'kill -0 [pid]' is silent if process is running or print "No such process" message otherwise
if (!output.getText().isEmpty()) {
throw new NotFoundException(format("Process with pid %s not found", getPid()));
}
}
@Override
public void kill() throws MachineException {
if (started) {
// Read pid from file and run 'kill [pid]' command.
final String killCmd = format("[ -r %1$s ] && kill $(cat %1$s)", pidFilePath);
final String[] command = {"/bin/sh", "-c", killCmd};
Exec exec;
try {
exec = docker.createExec(CreateExecParams.create(container, command).withDetach(true));
} catch (IOException e) {
throw new MachineException(format("Error occurs while initializing command %s in docker container %s: %s",
Arrays.toString(command), container, e.getMessage()), e);
}
try {
docker.startExec(StartExecParams.create(exec.getId()), MessageProcessor.DEV_NULL);
} catch (IOException e) {
throw new MachineException(format("Error occurs while executing command %s in docker container %s: %s",
Arrays.toString(exec.getCommand()), container, e.getMessage()), e);
}
}
}
private String getErrorMessage() {
final StringBuilder errorMessage = new StringBuilder("Command output read timeout is reached.");
try {
// check if process is alive
final Exec checkProcessExec = docker.createExec(
CreateExecParams.create(container,
new String[] {"/bin/sh",
"-c",
format("if kill -0 $(cat %1$s 2>/dev/null) 2>/dev/null; then cat %1$s; fi",
pidFilePath)})
.withDetach(false));
ValueHolder<String> pidHolder = new ValueHolder<>();
docker.startExec(StartExecParams.create(checkProcessExec.getId()), message -> {
if (message.getType() == LogMessage.Type.STDOUT) {
pidHolder.set(message.getContent());
}
});
if (pidHolder.get() != null) {
errorMessage.append(" Process is still running and has id ").append(pidHolder.get()).append(" inside machine");
}
} catch (IOException ignore) {
}
return errorMessage.toString();
}
}