/** * {@inheritDoc} */ @Override public void from(io.cattle.platform.core.model.Stack from) { setId(from.getId()); setName(from.getName()); setAccountId(from.getAccountId()); setKind(from.getKind()); setUuid(from.getUuid()); setDescription(from.getDescription()); setState(from.getState()); setCreated(from.getCreated()); setRemoved(from.getRemoved()); setRemoveTime(from.getRemoveTime()); setData(from.getData()); setExternalId(from.getExternalId()); setHealthState(from.getHealthState()); setGroup(from.getGroup()); setSystem(from.getSystem()); }
@Override protected Object getAgentResource(ProcessState state, ProcessInstance process, Object dataResource) { Stack env = (Stack)state.getResource(); if (!DockerConstants.TYPE_COMPOSE_PROJECT.equals(env.getKind())) { return null; } Long accountId = env.getAccountId(); List<Long> agentIds = agentInstanceDao.getAgentProvider(SystemLabels.LABEL_AGENT_SERVICE_COMPOSE_PROVIDER, accountId); return agentIds.size() == 0 ? null : agentIds.get(0); }
private void removeVolumeTemplates(Stack stack) { List<? extends VolumeTemplate> templates = objectManager.find(VolumeTemplate.class, VOLUME_TEMPLATE.ACCOUNT_ID, stack.getAccountId(), VOLUME_TEMPLATE.REMOVED, null, VOLUME_TEMPLATE.STACK_ID, stack.getId()); for (VolumeTemplate template : templates) { objectProcessManager.scheduleStandardProcessAsync(StandardProcess.REMOVE, template, null); } }
protected List<Stack> getStacksToCleanup(Stack systemStack, String systemStackType) { List<Stack> all = objectManager.find(Stack.class, STACK.ACCOUNT_ID, systemStack.getAccountId(), STACK.REMOVED, null); if (all.isEmpty()) { return new ArrayList<>(); } List<Stack> toCleanup = new ArrayList<>(); List<String> stackExternalIdPrefixes = STACKS_TO_CLEANUP_EXTERNAL_ID.get(systemStackType); for (Stack stack : all) { boolean removeByExternalId = false; if (stack.getExternalId() != null && stackExternalIdPrefixes != null) { for (String prefix : stackExternalIdPrefixes) { if (stack.getExternalId().startsWith(prefix)) { toCleanup.add(stack); removeByExternalId = true; break; } } if (removeByExternalId) { continue; } if (STACKS_TO_CLEANUP_KIND.get(systemStackType) != null && STACKS_TO_CLEANUP_KIND.get(systemStackType).contains(stack.getKind())) { toCleanup.add(stack); } } } return toCleanup; }
@Override protected Long getId(Object obj) { if (obj instanceof Stack) { return ((Stack) obj).getId(); } return null; }
protected void checkAndDelete(Service service, Stack env) { service = objectManager.reload(service); env = objectManager.reload(env); boolean found = false; for (ServiceExposeMap map : serviceExportMapDao.getUnmanagedServiceInstanceMapsToRemove(service.getId())) { found = true; if (isRemoved(service.getRemoved(), service.getState())) { Instance instance = objectManager.loadResource(Instance.class, map.getInstanceId()); DefaultDeploymentUnitInstance.removeInstance(instance, objectProcessManager); } } if (!found && !isRemoved(service.getRemoved(), service.getState())) { objectProcessManager.scheduleStandardProcess(StandardProcess.REMOVE, service, null); } env = objectManager.reload(env); if (isRemoved(env.getRemoved(), env.getState())) { return; } List<Service> services = objectManager.find(Service.class, SERVICE.STACK_ID, env.getId(), ObjectMetaDataManager.STATE_FIELD, new Condition(ConditionType.NE, CommonStatesConstants.REMOVING), ObjectMetaDataManager.REMOVED_FIELD, null); if (services.size() == 0) { objectProcessManager.scheduleStandardProcess(StandardProcess.REMOVE, env, null); } }
String templateId = catalogService.getTemplateIdFromExternalId(stack.getExternalId()); if (StringUtils.isBlank(templateId)) { continue; SCHEDULED_UPGRADE.ACCOUNT_ID, stack.getAccountId(), SCHEDULED_UPGRADE.STACK_ID, stack.getId());
protected void process(ProcessState state, ProcessInstance process) throws IOException { ScheduledUpgrade upgrade = (ScheduledUpgrade)state.getResource(); Stack stack = objectManager.loadResource(Stack.class, upgrade.getStackId()); if (StringUtils.isBlank(stack.getExternalId()) || stack.getRemoved() != null) { return; if (ServiceConstants.STATE_UPGRADED.equals(stack.getState())) { objectProcessManager.scheduleProcessInstance(ServiceConstants.PROCESS_STACK_FINISH_UPGRADE, stack, null); throw new ProcessDelayException(new Date(System.currentTimeMillis() + 15000)); if (CommonStatesConstants.ACTIVE.equals(stack.getState())) { String upgradeToExternalId = catalogService.getDefaultExternalId(stack); if (StringUtils.isBlank(upgradeToExternalId)) { if (upgradeToExternalId.equals(stack.getExternalId())) { return; } else { String setting = UpgradeManager.UPGRADE_MANAGER.get(); if (setting.equalsIgnoreCase("manadatory") && !stack.getExternalId().contains(UpgradeManager.METADATA)) { return;
@Override public String getState() { return stack.getState(); } }
VOLUME_TEMPLATE.STACK_ID, stack.getId()); if (template == null) { return; final String postfix = io.cattle.platform.util.resource.UUID.randomUUID().toString(); if (template.getPerContainer()) { String name = stack.getName() + "_" + volumeNamePostfix + "_" + this.unit.getServiceIndex() + "_" + uuid + "_"; .find(Volume.class, VOLUME.ACCOUNT_ID, service.getAccountId(), VOLUME.REMOVED, null, VOLUME.VOLUME_TEMPLATE_ID, template.getId(), VOLUME.STACK_ID, stack.getId(), VOLUME.DEPLOYMENT_UNIT_ID, unit.getId()); for (Volume vol : volumes) { if (vol.getName().startsWith(name)) { .find(Volume.class, VOLUME.ACCOUNT_ID, service.getAccountId(), VOLUME.REMOVED, null, VOLUME.VOLUME_TEMPLATE_ID, template.getId(), VOLUME.STACK_ID, stack.getId()); for (Volume testVolume : volumes) { if (testVolume.getDeploymentUnitId() == null) { final String name = stack.getName() + "_" + volumeNamePostfix + "_"; volume = context.lockMgr.lock(new StackVolumeLock(stack, name), new LockCallback<Volume>() { @Override
public static String generateServiceInstanceName(Stack env, Service service, String launchConfigName, int finalOrder) { String configName = launchConfigName == null || launchConfigName.equals(ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME) ? "" : launchConfigName + "-"; String name = String.format("%s-%s-%s%d", env.getName(), service.getName(), configName, finalOrder); return name; }
@Override public void cleanupResources(final Service service) { if (!DockerConstants.TYPE_COMPOSE_SERVICE.equals(service.getKind())) { return; } final Stack env = objectManager.loadResource(Stack.class, service.getStackId()); lockManager.lock(new DefaultMultiLockDefinition(new ComposeProjectLock(env.getAccountId(), env.getName()), new ComposeServiceLock(env.getAccountId(), service.getName())), new LockCallbackNoReturn() { @Override public void doWithLockNoResult() { checkAndDelete(service, env); } }); }
List<String> externalIds = new ArrayList<>(); for (Stack stack : stacks) { if (!ServiceConstants.isSystem(stack) || CommonStatesConstants.REMOVING.equals(stack.getState())) { continue; externalIds.add(stack.getExternalId()); String orcType = getStackTypeFromExternalId(stack.getExternalId()); if (VIRTUAL_MACHINE.equals(orcType)) { virtualMachine = true;
ScheduledUpgrade upgrade = (ScheduledUpgrade)state.getResource(); Stack stack = objectManager.loadResource(Stack.class, upgrade.getStackId()); if (stack.getRemoved() != null) { return new HandlerResult() .withChainProcessName(processManager.getStandardProcessName(StandardProcess.REMOVE, upgrade)); if (StringUtils.isNotBlank(stack.getExternalId()) && stack.getExternalId().contains(UpgradeManager.METADATA)) { priority = 100L; delay = 0L;
protected void migrateCommunityStacks() { for (String orc : COMMUNITY_STACKS) { String fromLike = String.format("%%catalog://community:%s:%%", orc); for (Stack stack : objectManager.find(Stack.class, STACK.EXTERNAL_ID, new Condition(ConditionType.LIKE, fromLike), STACK.REMOVED, null)) { String[] parts = stack.getExternalId().split(":"); String to = String.format("catalog://community:infra*%s:%s", orc, parts[parts.length-1]); stack.setExternalId(to); objectManager.persist(stack); } } }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { Object resource = state.getResource(); if (resource instanceof Stack) { Stack stack = (Stack)resource; if (!ServiceConstants.isSystem(stack)) { Account account = objectManager.loadResource(Account.class, stack.getAccountId()); if (DataAccessor.fieldString(account, AccountConstants.FIELD_ORCHESTRATION) != null) { return null; } } trigger(stack.getAccountId()); } else if (resource instanceof Host) { trigger(((Host) resource).getAccountId()); } return null; }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { Stack systemStack = (Stack) state.getResource(); if (systemStack.getExternalId() == null) { return null; } String systemStackType = SystemStackUpdate.getStackTypeFromExternalId(systemStack.getExternalId()); if (systemStackType == null) { return null; } for (Stack toCleanup : getStacksToCleanup(systemStack, systemStackType)) { objectProcessManager.scheduleStandardProcess(StandardProcess.REMOVE, toCleanup, null); } return null; }
if (env.getRemoved() != null) { continue;
public StackVolumeLock(Stack stack, String volumeName) { super("STACK.VOLUME." + stack.getId() + "." + volumeName); }
private void removeVolumes(Stack stack) { List<? extends Volume> volumes = objectManager.find(Volume.class, VOLUME.ACCOUNT_ID, stack.getAccountId(), VOLUME.REMOVED, null, VOLUME.STACK_ID, stack.getId()); for (Volume volume : volumes) { String state = volume.getState(); if (!REMOVED.equals(state) && !REMOVING.equals(state)){ try { objectProcessManager.scheduleStandardProcessAsync(StandardProcess.REMOVE, volume, null); } catch (ProcessCancelException e) { volume = resourceMonitor.waitForState(volume, STATE_DETACHED, 3000L); objectProcessManager.scheduleStandardProcessAsync(StandardProcess.REMOVE, volume, null); } } } }