use of org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity in project che-server by eclipse-che.
the class KubernetesInternalRuntime method markStopping.
@Override
protected void markStopping() throws InfrastructureException {
RuntimeIdentity runtimeId = getContext().getIdentity();
// Check if runtime is in STARTING phase to actualize state of startSynchronizer.
Optional<WorkspaceStatus> statusOpt = runtimeStates.getStatus(runtimeId);
if (statusOpt.isPresent() && statusOpt.get() == WorkspaceStatus.STARTING) {
startSynchronizer.start();
}
if (!runtimeStates.updateStatus(runtimeId, s -> s == WorkspaceStatus.RUNNING || s == WorkspaceStatus.STARTING, WorkspaceStatus.STOPPING)) {
throw new StateException("The environment must be running or starting");
}
}
use of org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity in project che-server by eclipse-che.
the class KubernetesRuntimeContext method getRuntime.
@Override
public KubernetesInternalRuntime getRuntime() throws InfrastructureException {
Optional<KubernetesRuntimeState> runtimeStateOpt = runtimeStatuses.get(getIdentity());
String workspaceId = getIdentity().getWorkspaceId();
if (!runtimeStateOpt.isPresent()) {
// there is no cached runtime, create a new one
return runtimeFactory.create(this, namespaceFactory.getOrCreate(getIdentity()));
}
// there is cached runtime, restore cached one
KubernetesRuntimeState runtimeState = runtimeStateOpt.get();
RuntimeIdentity runtimeId = runtimeState.getRuntimeId();
LOG.debug("Restoring runtime `{}:{}:{}`", runtimeId.getWorkspaceId(), runtimeId.getEnvName(), runtimeId.getOwnerId());
KubernetesInternalRuntime runtime = runtimeFactory.create(this, namespaceFactory.access(workspaceId, runtimeState.getNamespace()));
runtime.scheduleRuntimeStateChecks();
return runtime;
}
use of org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity in project che-server by eclipse-che.
the class KubernetesInternalRuntime method checkServers.
/**
* Returns a function, the result of which the completable stage that performs servers checks and
* start of servers probes.
*/
private Function<Void, CompletionStage<Void>> checkServers(List<CompletableFuture<?>> toCancelFutures, KubernetesMachineImpl machine) {
// Need to get active span here to allow use in returned function;
final Span activeSpan = tracer.activeSpan();
return ignored -> {
// Span must be created within this lambda block, otherwise the span begins as soon as
// this function is called (i.e. before the previous steps in the machine boot chain
// are complete
final Span tracingSpan = tracer.buildSpan(CHECK_SERVERS).asChildOf(activeSpan).start();
TracingTags.WORKSPACE_ID.set(tracingSpan, getContext().getIdentity().getWorkspaceId());
TracingTags.MACHINE_NAME.set(tracingSpan, machine.getName());
// This completable future is used to unity the servers checks and start of probes
final CompletableFuture<Void> serversAndProbesFuture = new CompletableFuture<>();
final String machineName = machine.getName();
final RuntimeIdentity runtimeId = getContext().getIdentity();
final ServersChecker serverCheck = serverCheckerFactory.create(runtimeId, machineName, machine.getServers());
final CompletableFuture<?> serversReadyFuture;
LOG.debug("Performing servers check for machine '{}' in workspace '{}'", machineName, runtimeId.getWorkspaceId());
try {
serversReadyFuture = serverCheck.startAsync(new ServerReadinessHandler(machineName));
toCancelFutures.add(serversReadyFuture);
serversAndProbesFuture.whenComplete((ok, ex) -> {
LOG.debug("Servers checks done for machine '{}' in workspace '{}'", machineName, runtimeId.getWorkspaceId());
serversReadyFuture.cancel(true);
});
} catch (InfrastructureException ex) {
serversAndProbesFuture.completeExceptionally(ex);
TracingTags.setErrorStatus(tracingSpan, ex);
tracingSpan.finish();
return serversAndProbesFuture;
}
serversReadyFuture.whenComplete((BiConsumer<Object, Throwable>) (ok, ex) -> {
if (ex != null) {
serversAndProbesFuture.completeExceptionally(ex);
TracingTags.setErrorStatus(tracingSpan, ex);
tracingSpan.finish();
return;
}
try {
probeScheduler.schedule(probesFactory.getProbes(runtimeId, machineName, machine.getServers()), new ServerLivenessHandler());
} catch (InfrastructureException iex) {
serversAndProbesFuture.completeExceptionally(iex);
}
serversAndProbesFuture.complete(null);
tracingSpan.finish();
});
return serversAndProbesFuture;
};
}
use of org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity in project che-server by eclipse-che.
the class KubernetesInternalRuntime method internalStop.
@Traced
@Override
protected void internalStop(Map<String, String> stopOptions) throws InfrastructureException {
RuntimeIdentity identity = getContext().getIdentity();
TracingTags.WORKSPACE_ID.set(identity.getWorkspaceId());
runtimeHangingDetector.stopTracking(getContext().getIdentity());
if (startSynchronizer.interrupt()) {
// runtime is STARTING. Need to wait until start will be interrupted properly
try {
if (!startSynchronizer.awaitInterruption(workspaceStartTimeoutMin, TimeUnit.MINUTES)) {
// Runtime is not interrupted yet. It may occur when start was performing by another
// Che Server that is crashed so start is hung up in STOPPING phase.
// Need to clean up runtime resources
probeScheduler.cancel(identity.getWorkspaceId());
runtimeCleaner.cleanUp(namespace, identity.getWorkspaceId());
}
} catch (InterruptedException e) {
throw new InfrastructureException("Interrupted while waiting for start task cancellation", e);
}
} else {
// runtime is RUNNING. Clean up used resources
// Cancels workspace servers probes if any
probeScheduler.cancel(identity.getWorkspaceId());
runtimeCleaner.cleanUp(namespace, identity.getWorkspaceId());
}
}
use of org.eclipse.che.api.core.model.workspace.runtime.RuntimeIdentity in project che-server by eclipse-che.
the class InconsistentRuntimesDetector method checkOne.
@VisibleForTesting
void checkOne(String workspaceId) throws InfrastructureException {
LOG.debug("Checking consistency of runtime for workspace `{}`", workspaceId);
KubernetesInternalRuntime k8sRuntime = getKubernetesInternalRuntime(workspaceId);
RuntimeIdentity runtimeId = k8sRuntime.getContext().getIdentity();
try {
if (k8sRuntime.isConsistent()) {
return;
}
} catch (InfrastructureException e) {
throw new InfrastructureException(format("Error occurred during runtime '%s:%s' consistency checking. Cause: %s", runtimeId.getWorkspaceId(), runtimeId.getOwnerId(), e.getMessage()), e);
}
// not to initialize abnormal stop for a runtime that is not RUNNING anymore
if (!isRunning(k8sRuntime)) {
return;
}
LOG.warn("Found runtime `{}:{}` with inconsistent state. It's going to be stopped automatically", runtimeId.getWorkspaceId(), runtimeId.getOwnerId());
stopAbnormally(k8sRuntime);
LOG.debug("Checking consistency of runtime for workspace `{}` is finished", workspaceId);
}
Aggregations