public WorkspaceImpl(Workspace workspace, Account account) { this( workspace.getId(), account, workspace.getConfig(), workspace.getRuntime(), workspace.getAttributes(), workspace.isTemporary(), workspace.getStatus()); }
/** Returns 'rel -> url' map of links for the given workspace. */ public Map<String, String> genLinks(Workspace workspace, ServiceContext serviceContext) throws ServerException { final UriBuilder uriBuilder = serviceContext.getServiceUriBuilder(); final LinkedHashMap<String, String> links = new LinkedHashMap<>(); links.put( LINK_REL_SELF, uriBuilder .clone() .path(WorkspaceService.class, "getByKey") .build(workspace.getId()) .toString()); links.put( LINK_REL_IDE_URL, uriBuilder .clone() .replacePath("") .path(workspace.getNamespace()) .path(workspace.getConfig().getName()) .build() .toString()); if (workspace.getStatus() != WorkspaceStatus.STOPPED) { addRuntimeLinks(links, workspace.getId(), serviceContext); } return links; }
/** * Ensure workspace has running status, or throw IllegalStateException. * * @param workspace workspace description to get status and id. * @throws IllegalStateException if workspace with certain workspaceId doesn't have RUNNING * status. */ @Override public void ensureRunningStatus(Workspace workspace) throws IllegalStateException { if (workspace.getStatus() != WorkspaceStatus.RUNNING) { throw new IllegalStateException( format( "Workspace with id='%s' should has '%s' status, but its actual state='%s'", workspace.getId(), WorkspaceStatus.RUNNING, workspace.getStatus())); } }
private void handleStartupSuccess(Workspace workspace) { workspace.getAttributes().remove(STOPPED_ATTRIBUTE_NAME); workspace.getAttributes().remove(STOPPED_ABNORMALLY_ATTRIBUTE_NAME); workspace.getAttributes().remove(ERROR_MESSAGE_ATTRIBUTE_NAME); try { updateWorkspace(workspace.getId(), workspace); } catch (NotFoundException | ServerException | ValidationException | ConflictException e) { LOG.warn( String.format( "Cannot clear error status status of the workspace %s. Error is: %s", workspace.getId(), e.getMessage())); } }
@Override public void run() { String workspaceId = workspace.getId(); try { runtime.start(options); workspace.getNamespace(), workspace.getConfig().getName(), workspaceId, sessionUserNameOr("undefined")); workspace.getNamespace(), workspace.getConfig().getName(), workspaceId, failureCause);
private boolean isSshServerIsRunning(String machineName) { Workspace workspace = appContext.getWorkspace(); Runtime runtime = workspace.getRuntime(); if (runtime == null) { return false; } Machine machine = runtime.getMachines().get(machineName); if (machine == null) { return false; } Server server = machine.getServers().get(SERVER_SSH_REFERENCE); if (server == null) { return false; } return workspace.getStatus() == WorkspaceStatus.RUNNING; }
public CompletableFuture<Void> stopAsync(Workspace workspace, Map<String, String> options) throws NotFoundException, ConflictException { String workspaceId = workspace.getId(); WorkspaceStatus status = statuses.get(workspaceId); if (status == null) { sessionUserNameOr(workspace.getAttributes().get(WORKSPACE_STOPPED_BY)), "undefined"); LOG.info( "Workspace '{}/{}' with id '{}' is stopping by user '{}'", workspace.getNamespace(), workspace.getConfig().getName(), workspace.getId(), stoppedBy); publishWorkspaceStatusEvent(workspaceId, STOPPING, status, options.get(WORKSPACE_STOP_REASON));
private static EnvironmentImpl copyEnv(Workspace workspace, String envName) { requireNonNull(workspace, "Workspace should not be null."); requireNonNull(envName, "Environment name should not be null."); final Environment environment = workspace.getConfig().getEnvironments().get(envName); if (environment == null) { throw new IllegalArgumentException( format("Workspace '%s' doesn't contain environment '%s'", workspace.getId(), envName)); } return new EnvironmentImpl(environment); }
public void waitStatus( String workspaceName, String userName, WorkspaceStatus expectedStatus, int timeoutSeconds) throws Exception { WaitUtils.waitSuccessCondition( () -> { try { if (getByName(workspaceName, userName).getStatus() == expectedStatus) { return true; } } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } return false; }, timeoutSeconds, 1000, TimeUnit.SECONDS); }
/** * Updates an existing workspace with a new configuration. * * <p> * * <p>Replace strategy is used for workspace update, it means that existing workspace data will be * replaced with given {@code update}. * * @param update workspace update * @return updated instance of the workspace * @throws NullPointerException when either {@code workspaceId} or {@code update} is null * @throws NotFoundException when workspace with given id doesn't exist * @throws ConflictException when any conflict occurs (e.g Workspace with such name already exists * in {@code namespace}) * @throws ServerException when any other error occurs */ public WorkspaceImpl updateWorkspace(String id, Workspace update) throws ConflictException, ServerException, NotFoundException, ValidationException { requireNonNull(id, "Required non-null workspace id"); requireNonNull(update, "Required non-null workspace update"); requireNonNull(update.getConfig(), "Required non-null workspace configuration update"); validator.validateConfig(update.getConfig()); validator.validateAttributes(update.getAttributes()); WorkspaceImpl workspace = workspaceDao.get(id); workspace.setConfig(new WorkspaceConfigImpl(update.getConfig())); workspace.setAttributes(update.getAttributes()); workspace.getAttributes().put(UPDATED_ATTRIBUTE_NAME, Long.toString(currentTimeMillis())); workspace.setTemporary(update.isTemporary()); return normalizeState(workspaceDao.update(workspace), true); }
/** Checks whether the server is running in the machine. */ private boolean isServerRunning(String machineName, String serverName) { Workspace workspace = appContext.getWorkspace(); Runtime runtime = workspace.getRuntime(); if (runtime == null) { return false; } Machine machine = runtime.getMachines().get(machineName); if (machine == null) { return false; } Server server = machine.getServers().get(serverName); if (server == null) { return false; } return server.getStatus() == ServerStatus.RUNNING; }
@Override public WorkspaceImpl updateWorkspace(String id, Workspace update) throws ConflictException, ServerException, NotFoundException, ValidationException { checkMaxEnvironmentRam(update.getConfig()); WorkspaceImpl workspace = this.getWorkspace(id); String accountId = workspace.getAccount().getId(); // Workspace must not be updated while the manager checks it's resources to allow start try (@SuppressWarnings("unused") Unlocker u = resourcesLocks.lock(accountId)) { return super.updateWorkspace(id, update); } }
@Override public void run() { String workspaceId = workspace.getId(); workspace.getNamespace(), workspace.getConfig().getName(), workspaceId, stoppedBy);
if (workspace.getStatus() == STOPPING) { waitStatus(workspaceName, userName, STOPPED); } else if (workspace.getStatus() != STOPPED) { stop(workspaceName, userName); requestFactory.fromUrl(getIdBasedUrl(workspace.getId())).useDeleteMethod().request(); format( "Error of waiting on workspace name='%s', id='%s', username='%s' removal.", workspaceName, workspace.getId(), userName), e); "Workspace name='{}', id='{}', username='{}' removed", workspaceName, workspace.getId(), userName);
WorkspaceConfig workspaceConfig = workspace.getConfig(); if (identity.getEnvName() != null) { environment = workspaceConfig.getEnvironments().get(identity.getEnvName()); runtime = infra.prepare(identity, internalEnv).getRuntime(); WorkspaceStatus runtimeStatus = runtime.getStatus(); try (Unlocker ignored = lockService.writeLock(workspace.getId())) { statuses.replace(identity.getWorkspaceId(), runtimeStatus); runtimes.putIfAbsent(identity.getWorkspaceId(), runtime);
/** Waits workspace is started. */ @Override public void waitWorkspaceStart(String workspaceName, String userName) throws Exception { WaitUtils.sleepQuietly(5); // delay 5 secs to obtain starting status for sure WaitUtils.waitSuccessCondition( () -> { WorkspaceStatus status; try { status = getByName(workspaceName, userName).getStatus(); } catch (Exception e) { throw new RuntimeException(e.getMessage(), e); } switch (status) { case RUNNING: return true; case STARTING: return false; default: throw new RuntimeException( format("Workspace with name '%s' didn't start", workspaceName)); } }, 600, 1000, TimeUnit.SECONDS); }
private void handleStartupError(Workspace workspace, Throwable t) { workspace .getAttributes() .put( ERROR_MESSAGE_ATTRIBUTE_NAME, t instanceof RuntimeException ? t.getCause().getMessage() : t.getMessage()); workspace.getAttributes().put(STOPPED_ATTRIBUTE_NAME, Long.toString(currentTimeMillis())); workspace.getAttributes().put(STOPPED_ABNORMALLY_ATTRIBUTE_NAME, Boolean.toString(true)); try { updateWorkspace(workspace.getId(), workspace); } catch (NotFoundException | ServerException | ValidationException | ConflictException e) { LOG.warn( String.format( "Cannot set error status of the workspace %s. Error is: %s", workspace.getId(), e.getMessage())); } }
/** * Return server URL related with defined port * * @deprecated use {@link #getServerFromDevMachineBySymbolicName(String, String)} to retrieve * server URL from instead */ @Override @Deprecated @Nullable public String getServerAddressByPort(String workspaceId, int port) throws Exception { Workspace workspace = getById(workspaceId); ensureRunningStatus(workspace); Map<String, ? extends Machine> machines = workspace.getRuntime().getMachines(); for (Machine machine : machines.values()) { if (containsWsAgentServer(machine)) { return machine.getServers().get(valueOf(port) + "/tcp").getUrl(); } } return null; }