.setServerProperty("sonar.cluster.ce.disabled", "true")
// override the default watcher provided by Orchestrator
// which waits for Compute Engine to be up
- .setStartupLogWatcher(log -> log.contains("Process[web] is up"))
+ .setStartupLogWatcher(log -> log.contains("SonarQube is up"))
.build();
web.start();
@Override
public Status getStatus() {
- checkState(ceMainThread != null, "isUp() can not be called before start()");
+ checkState(ceMainThread != null, "getStatus() can not be called before start()");
if (ceMainThread.isStarted()) {
- return Status.UP;
+ return Status.OPERATIONAL;
}
return Status.DOWN;
}
}
@Test
- public void isUp_throws_ISE_when_called_before_start() throws IOException {
+ public void getStatus_throws_ISE_when_called_before_start() throws IOException {
CeServer ceServer = newCeServer();
expectedException.expect(IllegalStateException.class);
- expectedException.expectMessage("isUp() can not be called before start()");
+ expectedException.expectMessage("getStatus() can not be called before start()");
ceServer.getStatus();
}
@Test
- public void isUp_does_not_return_true_until_ComputeEngine_startup_returns() throws InterruptedException, IOException {
+ public void getStatus_does_not_return_OPERATIONAL_until_ComputeEngine_startup_returns() throws InterruptedException, IOException {
BlockingStartupComputeEngine computeEngine = new BlockingStartupComputeEngine(null);
CeServer ceServer = newCeServer(computeEngine);
while (ceServer.getStatus() == Monitored.Status.DOWN) {
// wait for isReady to change to true, otherwise test will fail with timeout
}
- assertThat(ceServer.getStatus()).isEqualTo(Monitored.Status.UP);
+ assertThat(ceServer.getStatus()).isEqualTo(Monitored.Status.OPERATIONAL);
}
@Test
- public void isUp_returns_true_when_ComputeEngine_startup_throws_any_Exception_or_Error() throws InterruptedException, IOException {
+ public void getStatus_returns_OPERATIONAL_when_ComputeEngine_startup_throws_any_Exception_or_Error() throws InterruptedException, IOException {
Throwable startupException = new Throwable("Faking failing ComputeEngine#startup()");
BlockingStartupComputeEngine computeEngine = new BlockingStartupComputeEngine(startupException);
computeEngine.releaseStartup();
while (ceServer.getStatus() == Monitored.Status.DOWN) {
- // wait for isReady to change to true, otherwise test will fail with timeout
+ // wait for isReady to change to not DOWN, otherwise test will fail with timeout
}
- assertThat(ceServer.getStatus()).isEqualTo(Monitored.Status.UP);
+ assertThat(ceServer.getStatus()).isEqualTo(Monitored.Status.OPERATIONAL);
}
@Test
- public void isUp_returns_true_when_waiting_for_WebServer_failed() throws InterruptedException {
+ public void getStatus_returns_OPERATIONAL_when_waiting_for_WebServer_failed() throws InterruptedException {
final CountDownLatch webServerWatcherCalled = new CountDownLatch(1);
CeServer ceServer = newCeServer(() -> {
webServerWatcherCalled.countDown();
ceServer.start();
ceServer.awaitStop();
- assertThat(ceServer.getStatus()).isEqualTo(Monitored.Status.UP);
+ assertThat(ceServer.getStatus()).isEqualTo(Monitored.Status.OPERATIONAL);
}
@Test
private final MigrationContainerPopulator populator;
private final MigrationSteps migrationSteps;
- public MigrationEngineImpl(MigrationHistory migrationHistory, ComponentContainer serverContainer, MigrationContainerPopulator populator, MigrationSteps migrationSteps) {
+ public MigrationEngineImpl(MigrationHistory migrationHistory, ComponentContainer serverContainer,
+ MigrationContainerPopulator populator, MigrationSteps migrationSteps) {
this.migrationHistory = migrationHistory;
this.serverContainer = serverContainer;
this.populator = populator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
-import java.util.Objects;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.annotation.CheckForNull;
import org.slf4j.Logger;
import org.sonar.process.ProcessUtils;
import org.sonar.process.SystemExit;
+import static java.util.Objects.requireNonNull;
import static org.sonar.process.DefaultProcessCommands.reset;
public class Monitor {
private final SystemExit systemExit;
private final boolean watchForHardStop;
private final Thread shutdownHook = new Thread(new MonitorShutdownHook(), "Monitor Shutdown Hook");
+ private final boolean waitForOperational;
private final List<WatcherThread> watcherThreads = new CopyOnWriteArrayList<>();
private final Lifecycle lifecycle;
@CheckForNull
HardStopWatcherThread hardStopWatcher;
- Monitor(int processNumber, FileSystem fileSystem, SystemExit exit, boolean watchForHardStop, Lifecycle.LifecycleListener... listeners) {
- this.processNumber = processNumber;
- this.fileSystem = fileSystem;
- this.systemExit = exit;
- this.watchForHardStop = watchForHardStop;
- this.lifecycle = new Lifecycle(listeners);
+ private Monitor(Builder builder) {
+ this.processNumber = builder.processNumber;
+ this.fileSystem = requireNonNull(builder.fileSystem, "FileSystem can't be null²");
+ this.systemExit = builder.exit == null ? new SystemExit() : builder.exit;
+ this.watchForHardStop = builder.watchForHardStop;
+ this.waitForOperational = builder.waitForOperational;
+ this.lifecycle = builder.listeners == null ? new Lifecycle() : new Lifecycle(builder.listeners.stream().toArray(Lifecycle.LifecycleListener[]::new));
}
- public static Monitor create(int processNumber, FileSystem fileSystem, boolean watchForHardStop) {
- return new Monitor(processNumber, fileSystem, new SystemExit(), watchForHardStop);
+ public static Builder newMonitorBuilder() {
+ return new Builder();
}
- public static Monitor create(int processNumber, FileSystem fileSystem, boolean watchForHardStop, Lifecycle.LifecycleListener listener) {
- return new Monitor(processNumber, fileSystem, new SystemExit(), watchForHardStop, Objects.requireNonNull(listener));
+ public static class Builder {
+ private int processNumber;
+ private FileSystem fileSystem;
+ private SystemExit exit;
+ private boolean watchForHardStop;
+ private boolean waitForOperational = false;
+ private List<Lifecycle.LifecycleListener> listeners;
+
+ private Builder() {
+ // use static factory method
+ }
+
+ public Builder setProcessNumber(int processNumber) {
+ this.processNumber = processNumber;
+ return this;
+ }
+
+ public Builder setFileSystem(FileSystem fileSystem) {
+ this.fileSystem = fileSystem;
+ return this;
+ }
+
+ public Builder setExit(SystemExit exit) {
+ this.exit = exit;
+ return this;
+ }
+
+ public Builder setWatchForHardStop(boolean watchForHardStop) {
+ this.watchForHardStop = watchForHardStop;
+ return this;
+ }
+
+ public Builder setWaitForOperational() {
+ this.waitForOperational = true;
+ return this;
+ }
+
+ public Builder addListener(Lifecycle.LifecycleListener listener) {
+ if (this.listeners == null) {
+ this.listeners = new ArrayList<>(1);
+ }
+ this.listeners.add(requireNonNull(listener, "LifecycleListener can't be null"));
+ return this;
+ }
+
+ public Monitor build() {
+ return new Monitor(this);
+ }
}
/**
- * Starts commands and blocks current thread until all processes are in state {@link State#STARTED}.
- * @throws java.lang.IllegalArgumentException if commands list is empty
- * @throws java.lang.IllegalStateException if already started or if at least one process failed to start. In this case
- * all processes are terminated. No need to execute {@link #stop()}
+ * Starts commands and blocks current thread until all processes are in state {@link State#STARTED} (or
+ * {@link State#OPERATIONAL} if {@link #waitForOperational} is {@code true}).
+ *
+ * @throws IllegalArgumentException if commands list is empty
+ * @throws IllegalStateException if already started or if at least one process failed to start. In this case
+ * all processes are terminated. No need to execute {@link #stop()}
*/
public void start(List<JavaCommand> commands) throws InterruptedException {
if (commands.isEmpty()) {
// start watching for restart requested by child process
restartWatcher.start();
- javaCommands = commands;
+ javaCommands = new ArrayList<>(commands);
startProcesses();
}
startAndMonitorProcesses();
stopIfAnyProcessDidNotStart();
+ waitForOperationalProcesses();
}
}
}
}
- private void startAndMonitorProcesses() throws InterruptedException{
+ private void startAndMonitorProcesses() throws InterruptedException {
File tempDir = fileSystem.getTempDir();
this.launcher = new JavaProcessLauncher(TIMEOUTS, tempDir);
for (JavaCommand command : javaCommands) {
}
}
+ private void waitForOperationalProcesses() throws InterruptedException {
+ if (!waitForOperational) {
+ return;
+ }
+
+ for (WatcherThread watcherThread : watcherThreads) {
+ waitForOperationalProcess(watcherThread.getProcessRef());
+ }
+ lifecycle.tryToMoveTo(State.OPERATIONAL);
+ }
+
+ private static void waitForOperationalProcess(ProcessRef processRef) throws InterruptedException {
+ LOG.debug("Waiting for {} to be operational", processRef);
+ while (!processRef.getCommands().isOperational()) {
+ Thread.sleep(WATCH_DELAY_MS);
+ }
+ LOG.debug("{} is operational", processRef);
+ }
+
/**
* Blocks until all processes are terminated
*/
@Override
public void run() {
while (lifecycle.getState() != Lifecycle.State.STOPPED) {
- if (lifecycle.getState() == Lifecycle.State.STARTED && didAnyProcessRequestRestart()) {
+ Lifecycle.State state = lifecycle.getState();
+ if ((state == Lifecycle.State.STARTED || state == Lifecycle.State.OPERATIONAL) && didAnyProcessRequestRestart()) {
restartAsync();
}
try {
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import static org.sonar.process.monitor.Monitor.newMonitorBuilder;
import static org.sonar.process.monitor.MonitorTest.HttpProcessClientAssert.assertThat;
public class MonitorTest {
private Monitor newDefaultMonitor(File tempDir, boolean watchForHardStop) throws IOException {
when(fileSystem.getTempDir()).thenReturn(tempDir);
- return new Monitor(1, fileSystem, exit, watchForHardStop);
+ return newMonitorBuilder()
+ .setProcessNumber(1)
+ .setFileSystem(fileSystem)
+ .setExit(exit)
+ .setWatchForHardStop(watchForHardStop)
+ .build();
}
/**
import static org.sonar.process.Lifecycle.State.HARD_STOPPING;
import static org.sonar.process.Lifecycle.State.INIT;
+import static org.sonar.process.Lifecycle.State.OPERATIONAL;
import static org.sonar.process.Lifecycle.State.RESTARTING;
import static org.sonar.process.Lifecycle.State.STARTED;
import static org.sonar.process.Lifecycle.State.STARTING;
private static final Logger LOG = LoggerFactory.getLogger(Lifecycle.class);
public enum State {
- INIT, STARTING, STARTED, RESTARTING, STOPPING, HARD_STOPPING, STOPPED
+ INIT, STARTING, STARTED, OPERATIONAL, RESTARTING, STOPPING, HARD_STOPPING, STOPPED
}
private static final Map<State, Set<State>> TRANSITIONS = buildTransitions();
Map<State, Set<State>> res = new EnumMap<>(State.class);
res.put(INIT, toSet(STARTING));
res.put(STARTING, toSet(STARTED, STOPPING, HARD_STOPPING));
- res.put(STARTED, toSet(RESTARTING, STOPPING, HARD_STOPPING));
+ res.put(STARTED, toSet(OPERATIONAL, RESTARTING, STOPPING, HARD_STOPPING));
+ res.put(OPERATIONAL, toSet(RESTARTING, STOPPING, HARD_STOPPING));
res.put(RESTARTING, toSet(STARTING, HARD_STOPPING));
res.put(STOPPING, toSet(STOPPED));
res.put(HARD_STOPPING, toSet(STOPPED));
void start();
/**
- * {@link Status#UP} if the process is done starting, {@link Status#FAILED} if the process failed to start,
- * {@link Status#DOWN} otherwise.
+ * @return {@link Status#UP} if the process is done starting, {@link Status#OPERATIONAL} if the service is operation,
+ * {@link Status#FAILED} if the process failed to start, {@link Status#DOWN} otherwise.
*/
Status getStatus();
enum Status {
- UP, DOWN, FAILED
+ DOWN, UP, OPERATIONAL, FAILED
}
/**
Logger logger = LoggerFactory.getLogger(getClass());
try {
- logger.info("Starting " + getKey());
- Runtime.getRuntime().addShutdownHook(shutdownHook);
- stopWatcher.start();
-
- monitored.start();
- Monitored.Status status = waitForNotDownStatus();
- if (status == Monitored.Status.UP) {
- // notify monitor that process is ready
- commands.setUp();
-
- if (lifecycle.tryToMoveTo(Lifecycle.State.STARTED)) {
- monitored.awaitStop();
- }
- } else {
- stop();
- }
+ launch(logger);
} catch (Exception e) {
logger.warn("Fail to start " + getKey(), e);
} finally {
}
}
+ private void launch(Logger logger) throws InterruptedException {
+ logger.info("Starting " + getKey());
+ Runtime.getRuntime().addShutdownHook(shutdownHook);
+ stopWatcher.start();
+
+ monitored.start();
+ Monitored.Status status = waitForNotDownStatus();
+ if (status == Monitored.Status.UP || status == Monitored.Status.OPERATIONAL) {
+ // notify monitor that process is ready
+ commands.setUp();
+
+ if (lifecycle.tryToMoveTo(Lifecycle.State.STARTED)) {
+ Monitored.Status newStatus = waitForOperational(status);
+ if (newStatus == Monitored.Status.OPERATIONAL && lifecycle.tryToMoveTo(Lifecycle.State.OPERATIONAL)) {
+ commands.setOperational();
+ }
+
+ monitored.awaitStop();
+ }
+ } else {
+ stop();
+ }
+ }
+
private Monitored.Status waitForNotDownStatus() throws InterruptedException {
Monitored.Status status = Monitored.Status.DOWN;
while (status == Monitored.Status.DOWN) {
return status;
}
+ private Monitored.Status waitForOperational(Monitored.Status currentStatus) throws InterruptedException {
+ Monitored.Status status = currentStatus;
+ // wait for operation or stop waiting if going to OPERATIONAL failed
+ while (status != Monitored.Status.OPERATIONAL && status != Monitored.Status.FAILED) {
+ status = monitored.getStatus();
+ Thread.sleep(20L);
+ }
+ return status;
+ }
+
boolean isStarted() {
return lifecycle.getState() == Lifecycle.State.STARTED;
}
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.process.Lifecycle.State;
import static org.sonar.process.Lifecycle.State.INIT;
+import static org.sonar.process.Lifecycle.State.OPERATIONAL;
import static org.sonar.process.Lifecycle.State.RESTARTING;
import static org.sonar.process.Lifecycle.State.STARTED;
import static org.sonar.process.Lifecycle.State.STARTING;
}
@Test
- public void can_move_to_STOPPING_from_STARTING_and_STARTED_only() {
+ public void can_move_to_STOPPING_from_STARTING_STARTED_OPERATIONAL_only() {
for (State state : values()) {
TestLifeCycleListener listener = new TestLifeCycleListener();
boolean tryToMoveTo = newLifeCycle(state, listener).tryToMoveTo(STOPPING);
- if (state == STARTING || state == STARTED) {
+ if (state == STARTING || state == STARTED || state == OPERATIONAL) {
assertThat(tryToMoveTo).describedAs("from state " + state).isTrue();
assertThat(listener.getTransitions()).containsOnly(new Transition(state, STOPPING));
} else {
}
}
+ @Test
+ public void can_move_to_OPERATIONAL_from_STARTED_only() {
+ for (State state : values()) {
+ TestLifeCycleListener listener = new TestLifeCycleListener();
+ boolean tryToMoveTo = newLifeCycle(state, listener).tryToMoveTo(OPERATIONAL);
+ if (state == STARTED) {
+ assertThat(tryToMoveTo).describedAs("from state " + state).isTrue();
+ assertThat(listener.getTransitions()).containsOnly(new Transition(state, OPERATIONAL));
+ } else {
+ assertThat(tryToMoveTo).describedAs("from state " + state).isFalse();
+ assertThat(listener.getTransitions()).isEmpty();
+ }
+ }
+ }
+
@Test
public void can_move_to_STARTING_from_RESTARTING() {
TestLifeCycleListener listener = new TestLifeCycleListener();
return newLifeCycle(INIT, state, listeners);
case STARTED:
return newLifeCycle(STARTING, state, listeners);
- case RESTARTING:
+ case OPERATIONAL:
return newLifeCycle(STARTED, state, listeners);
+ case RESTARTING:
+ return newLifeCycle(OPERATIONAL, state, listeners);
case STOPPING:
- return newLifeCycle(STARTED, state, listeners);
+ return newLifeCycle(OPERATIONAL, state, listeners);
case HARD_STOPPING:
return newLifeCycle(STARTING, state, listeners);
case STOPPED:
@Override
public Status getStatus() {
- return Status.UP;
+ return Status.OPERATIONAL;
}
@Override
@Override
public Status getStatus() {
if (ready) {
- return Status.UP;
+ return Status.OPERATIONAL;
}
if (server.isStarted()) {
ready = true;
writeTimeToFile("readyAt");
}
- return ready ? Status.UP : Status.DOWN;
+ return ready ? Status.OPERATIONAL : Status.DOWN;
}
@Override
@Override
public Status getStatus() {
- return state == State.STARTED ? Status.UP : Status.DOWN;
+ return state == State.STARTED ? Status.OPERATIONAL : Status.DOWN;
}
@Override
@Override
public Status getStatus() {
- return state == State.STARTED ? Status.UP : Status.DOWN;
+ return state == State.STARTED ? Status.OPERATIONAL : Status.DOWN;
}
@Override
.setTimeout(TimeValue.timeValueSeconds(30L))
.get()
.getStatus() != ClusterHealthStatus.RED;
- return esStatus ? Status.UP : Status.DOWN;
+ if (esStatus) {
+ return Status.OPERATIONAL;
+ }
+ return Status.DOWN;
}
@Override
underTest = new SearchServer(props);
underTest.start();
- assertThat(underTest.getStatus()).isEqualTo(Monitored.Status.UP);
+ assertThat(underTest.getStatus()).isEqualTo(Monitored.Status.OPERATIONAL);
Settings settings = Settings.builder().put("cluster.name", A_CLUSTER_NAME).build();
client = TransportClient.builder().settings(settings).build()
package org.sonar.server.app;
import com.google.common.collect.ImmutableMap;
+import java.io.File;
+import org.sonar.process.DefaultProcessCommands;
import org.sonar.process.MinimumViableSystem;
import org.sonar.process.Monitored;
import org.sonar.process.ProcessEntryPoint;
+import org.sonar.process.ProcessId;
import org.sonar.process.Props;
public class WebServer implements Monitored {
+ public static final String PROPERTY_SHARED_PATH = "process.sharedDir";
+ private final File sharedDir;
private final EmbeddedTomcat tomcat;
WebServer(Props props) {
new MinimumViableSystem()
.checkWritableTempDir()
.checkRequiredJavaOptions(ImmutableMap.of("file.encoding", "UTF-8"));
+ this.sharedDir = getSharedDir(props);
this.tomcat = new EmbeddedTomcat(props);
}
+ private static File getSharedDir(Props props) {
+ return props.nonNullValueAsFile(PROPERTY_SHARED_PATH);
+ }
+
@Override
public void start() {
tomcat.start();
case DOWN:
return Status.DOWN;
case UP:
- return Status.UP;
+ return isOperational() ? Status.OPERATIONAL : Status.UP;
case FAILED:
default:
return Status.FAILED;
}
}
+ private boolean isOperational() {
+ try (DefaultProcessCommands processCommands = DefaultProcessCommands.secondary(sharedDir, ProcessId.WEB_SERVER.getIpcIndex())) {
+ return processCommands.isOperational();
+ }
+ }
+
@Override
public void stop() {
tomcat.terminate();
private final Monitor monitor;
public App(AppFileSystem appFileSystem, boolean watchForHardStop) {
- this(Monitor.create(APP.getIpcIndex(), appFileSystem, watchForHardStop, new AppLifecycleListener()));
+ this(Monitor.newMonitorBuilder()
+ .setProcessNumber(APP.getIpcIndex())
+ .setFileSystem(appFileSystem)
+ .setWatchForHardStop(watchForHardStop)
+ .setWaitForOperational()
+ .addListener(new AppLifecycleListener())
+ .build());
}
App(Monitor monitor) {
@Override
public void successfulTransition(State from, State to) {
- if (to == State.STARTED) {
+ if (to == State.OPERATIONAL) {
LOGGER.info("SonarQube is up");
}
}
projects / sonarqube.git / commitdiff