@Override public String getState() { return svc.getState(); } }
private boolean needToReconcile(Service service, ServiceDeploymentPlanner planner) { if (service.getState().equals(CommonStatesConstants.INACTIVE)) { return true; } return planner.needToReconcileDeployment(); }
@Override public boolean isActiveService(Service service) { return (getServiceActiveStates().contains(service.getState())); }
private void activateServices(final Service service) { /* * Trigger activate for all the services */ try { if (service.getState().equalsIgnoreCase(CommonStatesConstants.INACTIVE)) { objectProcessMgr.scheduleStandardProcess(StandardProcess.ACTIVATE, service, null); } else if (service.getState().equalsIgnoreCase(CommonStatesConstants.ACTIVE)) { objectProcessMgr.scheduleStandardProcess(StandardProcess.UPDATE, service, null); } } catch (IdempotentRetryException ex) { // if not caught, the process will keep on spinning forever // figure out better solution } }
private void deactivateServices(List<? extends Service> services) { List<String> validStates = Arrays.asList(CommonStatesConstants.ACTIVE, CommonStatesConstants.ACTIVATING, CommonStatesConstants.UPDATING_ACTIVE, CommonStatesConstants.UPDATING_INACTIVE, ServiceConstants.STATE_RESTARTING); List<String> statesToSkip = Arrays.asList(CommonStatesConstants.REMOVED, CommonStatesConstants.REMOVING, CommonStatesConstants.INACTIVE, CommonStatesConstants.DEACTIVATING); for (Service service : services) { if (validStates.contains(service.getState())) { objectProcessManager.scheduleProcessInstance(ServiceConstants.PROCESS_SERVICE_DEACTIVATE, service, null); } else if (statesToSkip.contains(service.getState())) { continue; } else { throw new ValidationErrorException(ValidationErrorCodes.INVALID_STATE, "Service " + service.getName() + " is not in valid state to be deactivated: " + service.getState()); } } } }
@Override public void run() { final Service service = objectMgr.loadResource(Service.class, client.getResourceId()); if (service != null && (service.getState().equalsIgnoreCase(CommonStatesConstants.ACTIVE) || service.getState() .equalsIgnoreCase(CommonStatesConstants.UPDATING_ACTIVE))) { activity.run(service, "service.trigger", "Re-evaluating state", new Runnable() { @Override public void run() { activate(service, false, true); } }); } } });
protected Service stateCheck(Service service, String currentProcess) { service = objectManager.reload(service); List<String> states = Arrays.asList(ServiceConstants.STATE_UPGRADING, ServiceConstants.STATE_ROLLINGBACK, ServiceConstants.STATE_RESTARTING, ServiceConstants.STATE_FINISHING_UPGRADE); if (!states.contains(service.getState())) { throw new ProcessExecutionExitException(ExitReason.STATE_CHANGED); } if (StringUtils.equals(currentProcess, ServiceConstants.STATE_RESTARTING)) { return service; } // rollback should cancel upgarde, and vice versa if (!StringUtils.equals(currentProcess, service.getState())) { throw new ProcessExecutionExitException(ExitReason.STATE_CHANGED); } return service; }
private boolean isNetworkUpgrading(long accountId) { Service networkDriverService = null; List<Service> networkDriverServices = objectManager.find(Service.class, SERVICE.ACCOUNT_ID, accountId, SERVICE.REMOVED, null, SERVICE.KIND, ServiceConstants.KIND_NETWORK_DRIVER_SERVICE); for(Service service : networkDriverServices) { if(invalidStates.contains(service.getState())) { continue; } networkDriverService = service; } if (networkDriverService == null) { return false; } List<Service> services = objectManager.find(Service.class, SERVICE.ACCOUNT_ID, accountId, SERVICE.REMOVED, null, SERVICE.STACK_ID, networkDriverService.getStackId()); for (Service service : services) { if (upgradingStates.contains(service.getState())) { return true; } } return false; }
@SuppressWarnings("unchecked") protected void activateService(Service service, Map<Long, Service> servicesToActivate, List<Long> alreadySeenServices, List<Long> alreadyActivatedServices) { if (alreadyActivatedServices.contains(service.getId())) { return; } alreadySeenServices.add(service.getId()); List<Long> consumedServicesIds = (List<Long>) CollectionUtils.collect( consumeMapDao.findConsumedServices(service.getId()), TransformerUtils.invokerTransformer("getConsumedServiceId")); for (Long consumedServiceId : consumedServicesIds) { Service consumedService = servicesToActivate.get(consumedServiceId); if (consumedService != null && !alreadySeenServices.contains(consumedService.getId())) { activateService(consumedService, servicesToActivate, alreadySeenServices, alreadyActivatedServices); } } if (service.getState().equalsIgnoreCase(CommonStatesConstants.INACTIVE)) { Map<String, Object> data = new HashMap<>(); List<Long> consumedServicesToWaitFor = new ArrayList<>(); consumedServicesToWaitFor.addAll(consumedServicesIds); consumedServicesToWaitFor.retainAll(alreadyActivatedServices); data.put(ServiceConstants.FIELD_WAIT_FOR_CONSUMED_SERVICES_IDS, consumedServicesToWaitFor); objectProcessManager.scheduleStandardProcess(StandardProcess.ACTIVATE, service, data); } alreadyActivatedServices.add(service.getId()); } }
@Override public Object perform(String name, Object obj, ApiRequest request) { if (!(obj instanceof Stack)) { return null; } Stack stack = (Stack) obj; List<? extends Long> serviceIds = DataAccessor.fromMap(request.getRequestObject()) .withKey(ServiceConstants.FIELD_SERVICE_IDS).asList(jsonMapper, Long.class); List<? extends Service> services = objectManager.mappedChildren(stack, Service.class); List<Service> toExport = new ArrayList<>(); for (Service service : services) { // export only non-removed requested services if ((serviceIds == null || serviceIds.isEmpty()) || serviceIds.contains(service.getId())) { if (service.getRemoved() == null && !service.getState().equals(CommonStatesConstants.REMOVED)) { toExport.add(service); } } } Map.Entry<String, String> composeConfig = svcDiscoveryServer.buildComposeConfig(toExport, stack); return new ComposeConfig(composeConfig.getKey(), composeConfig.getValue()); } }
protected void validateLinks(final Map<String, ServiceLink> newServiceLinks) { for (ServiceLink link : newServiceLinks.values()) { if (link.getServiceId() == null) { continue; } Service targetService = objMgr.loadResource(Service.class, link.getServiceId()); if (targetService == null || targetService.getRemoved() != null || targetService.getState().equalsIgnoreCase(CommonStatesConstants.REMOVING)) { Object obfuscatedId = idFormatter.formatId("service", link.getServiceId()); String obfuscatedIdStr = obfuscatedId != null ? obfuscatedId.toString() : null; String svcName = targetService != null ? targetService.getName() : obfuscatedIdStr; ValidationErrorCodes.throwValidationError(ValidationErrorCodes.INVALID_REFERENCE, "Service " + svcName + " is removed"); } } }
List<String> validUpgradeStates = Arrays.asList(CommonStatesConstants.ACTIVE, CommonStatesConstants.INACTIVE, CommonStatesConstants.UPDATING_ACTIVE); if (validUpgradeStates.contains(lbService.getState())) {
SERVICE.REMOVED, null, SERVICE.KIND, ServiceConstants.KIND_LOAD_BALANCER_SERVICE); for (Service lb : lbs) { if (INVALID_STATES.contains(lb.getState())) { continue;
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { final Service service = (Service) state.getResource(); // on inactive service update, do nothing if (process.getName().equalsIgnoreCase(ServiceConstants.PROCESS_SERVICE_UPDATE) && service.getState().equalsIgnoreCase(CommonStatesConstants.UPDATING_INACTIVE)) { return null; } activity.run(service, process.getName(), getMessage(process.getName()), new Runnable() { @Override public void run() { waitForConsumedServicesActivate(state, service); deploymentMgr.activate(service); } }); objectManager.reload(state.getResource()); return new HandlerResult(ServiceConstants.FIELD_CURRENT_SCALE, exposeDao.getCurrentScale(service.getId())); }
if(existingSvc.getState().equals(CommonStatesConstants.REMOVING)) { continue;
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); } }
protected ServiceConsumeMap createServiceLinkImpl(Service service, ServiceLink serviceLink) { Service linkFrom = objectManager.reload(service); if (linkFrom == null || linkFrom.getRemoved() != null || linkFrom.getState().equalsIgnoreCase(CommonStatesConstants.REMOVING)) { return null; Service linkTo = objectManager.loadResource(Service.class, serviceLink.getServiceId()); if (linkTo == null || linkTo.getRemoved() != null || linkTo.getState().equalsIgnoreCase(CommonStatesConstants.REMOVING)) { return null;
this.primary_service_name = service.getName(); this.environment_uuid = account.getUuid(); this.state = service.getState(); this.metadata_kind = "service"; this.token = DataAccessor.fieldString(service, ServiceConstants.FIELD_TOKEN);
/** * {@inheritDoc} */ @Override public void from(io.cattle.platform.core.model.Service 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()); setStackId(from.getStackId()); setVip(from.getVip()); setCreateIndex(from.getCreateIndex()); setSelectorLink(from.getSelectorLink()); setSelectorContainer(from.getSelectorContainer()); setExternalId(from.getExternalId()); setHealthState(from.getHealthState()); setSystem(from.getSystem()); setSkip(from.getSkip()); }