private Set<String> getServiceNamesInStack(long stackId) { Set<String> servicesInEnv = new HashSet<String>(); List<? extends Service> services = objectManager.find(Service.class, SERVICE.STACK_ID, stackId, SERVICE.REMOVED, null); for (Service service : services) { servicesInEnv.add(service.getName().toLowerCase()); } return servicesInEnv; }
public static String getServiceNamespace(Stack stack, Service service) { return new StringBuilder().append(service.getName()).append(".").append(getStackNamespace(stack, service)) .toString().toLowerCase(); }
private Map<String, String> getLaunchConfigToCurrentVersion(Service service, InServiceUpgradeStrategy strategy) { Map<String, String> lcToV = new HashMap<>(); Map<String, Pair<String, Map<String, Object>>> vToC = strategy.getNameToVersionToConfig(service.getName(), false); for (String lc : vToC.keySet()) { lcToV.put(lc, vToC.get(lc).getLeft()); } return lcToV; }
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; }
public static boolean isServiceGeneratedName(Stack env, Service service, String instanceName) { for (String divider : SERVICE_INSTANCE_NAME_DIVIDORS) { if (instanceName.startsWith(String.format("%s%s%s", env.getName(), divider, service.getName()))) { return true; } } return false; }
protected Map<String, Map<Object, Object>> getExistingLaunchConfigs(Service service) { Map<String, Map<Object, Object>> serviceLCs = ServiceDiscoveryUtil.getServiceLaunchConfigsWithNames(service); Map<Object, Object> primaryLC = serviceLCs.get(ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME); serviceLCs.remove(ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME); serviceLCs.put(service.getName(), primaryLC); return serviceLCs; }
@SuppressWarnings("unchecked") public List<String> getSidekickRefs(Service service, String launchConfigName) { List<String> configNames = new ArrayList<>(); for (DeploymentUnit.SidekickType sidekickType : DeploymentUnit.SidekickType.supportedTypes) { Object sidekicksLaunchConfigObj = ServiceDiscoveryUtil.getLaunchConfigObject(service, launchConfigName, sidekickType.launchConfigType); if (sidekicksLaunchConfigObj != null) { if (sidekickType.isList) { configNames.addAll((List<String>) sidekicksLaunchConfigObj); } else { configNames.add(sidekicksLaunchConfigObj.toString()); } } } List<String> toReturn = new ArrayList<>(); for (String name : configNames) { if (name.equalsIgnoreCase(service.getName())) { toReturn.add(ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME); } else { toReturn.add(name); } } return toReturn; }
protected Map<String, String> getLabels(DeploymentUnitInstance instance) { Map<String, String> labels = new HashMap<>(); String serviceName = instance.getService().getName(); if (!ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME.equals(instance.getLaunchConfigName())) { serviceName = serviceName + '/' + instance.getLaunchConfigName(); } String envName = stack.getName(); labels.put(ServiceConstants.LABEL_STACK_NAME, envName); labels.put(ServiceConstants.LABEL_STACK_SERVICE_NAME, envName + "/" + serviceName); // LEGACY: keeping backwards compatibility with 'project' labels.put(ServiceConstants.LABEL_PROJECT_NAME, envName); labels.put(ServiceConstants.LABEL_PROJECT_SERVICE_NAME, envName + "/" + serviceName); /* * Put label 'io.rancher.deployment.unit=this.uuid' on each one. This way * we can reference a set of containers later. */ labels.put(ServiceConstants.LABEL_SERVICE_DEPLOYMENT_UNIT, uuid); /* * Put label with launch config name */ labels.put(ServiceConstants.LABEL_SERVICE_LAUNCH_CONFIG, instance.getLaunchConfigName()); labels.putAll(this.unitLabels); return labels; }
@SuppressWarnings("unchecked") protected Map<String, Map<Object, Object>> getLaunchConfigsToUpdateInitial(Service service, InServiceUpgradeStrategy strategy, Map<String, Map<Object, Object>> serviceLCs) { Map<String, Map<Object, Object>> lCsToUpdateInitial = new HashMap<>(); if (strategy.getLaunchConfig() != null) { lCsToUpdateInitial.put(service.getName(), (Map<Object, Object>) strategy.getLaunchConfig()); } if (strategy.getSecondaryLaunchConfigs() != null) { for (Object secondaryLC : strategy.getSecondaryLaunchConfigs()) { String lcName = CollectionUtils.toMap(secondaryLC).get("name").toString(); lCsToUpdateInitial.put(lcName, (Map<Object, Object>) secondaryLC); } } return lCsToUpdateInitial; }
protected String generateService(Service service, Stack stack) throws Exception { @SuppressWarnings("unchecked") Map<String, Object> metadata = DataAccessor.fields(service).withKey(ServiceConstants.FIELD_METADATA) .withDefault(Collections.EMPTY_MAP).as(Map.class); String serviceName = service.getName(); List<? extends String> configuredSans = DataAccessor.fromMap(metadata).withKey("sans") .withDefault(Collections.emptyList()).asList(jsonMapper, String.class); List<String> sans = new ArrayList<>(configuredSans); sans.add(serviceName.toLowerCase()); sans.add(String.format("%s.%s", serviceName, stack.getName()).toLowerCase()); sans.add(String.format("%s.%s.%s", serviceName, stack.getName(), NetworkConstants.INTERNAL_DNS_SEARCH_DOMAIN) .toLowerCase()); CertSet certSet = keyProvider.generateCertificate(serviceName, sans.toArray(new String[sans.size()])); ByteArrayOutputStream baos = new ByteArrayOutputStream(); certSet.writeZip(baos); return Base64.encodeBase64String(baos.toByteArray()); }
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 Object perform(String name, Object obj, ApiRequest request) { if (!(obj instanceof Service)) { return null; } Service service = (Service)obj; String serviceName = service.getName(); try { String certs = sdApiService.getServiceCertificate(service); if (certs == null) { return null; } ApiKeyCertificateDownloadLinkHandler.prepareRequest(serviceName + "-certs.zip", request); request.getOutputStream().write(Base64.decodeBase64(certs)); } catch (Exception e) { log.error("Failed to generate certificate for service [{}]", service.getId(), e); throw new ClientVisibleException(ResponseCodes.INTERNAL_SERVER_ERROR, "CertGenerationFailed"); } return new Object(); }
@Override public String getServiceCertificate(final Service service) { if (service == null) { return null; } final Stack stack = objectManager.loadResource(Stack.class, service.getStackId()); if (stack == null) { return null; } String newKey = String.format("service.v3.%d.%s.cert", service.getAccountId(), service.getName()); return dataDao.getOrCreate(newKey, false, new Callable<String>() { @Override public String call() throws Exception { return generateService(service, stack); } }); }
protected void validateLaunchConfigs(Service service, ApiRequest request) { Map<String, Object> data = CollectionUtils.toMap(request.getRequestObject()); Object newName = data.get("name"); String serviceName = newName != null ? newName.toString() : service.getName(); List<Map<String, Object>> launchConfigs = populateLaunchConfigs(service, request); validateLaunchConfigNames(service, serviceName, launchConfigs); validateLaunchConfigsCircularRefs(service, serviceName, launchConfigs); validateLaunchConfigScale(service, request); }
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"); } } }
private Object createDriver(String driverKey, Service service, Map<String, Object> fields) { Class<?> driverClass = objectManager.getSchemaFactory().getSchemaClass(driverKey); String name = getString(fields, ObjectMetaDataManager.NAME_FIELD); if (name == null) { name = service.getName(); } Map<String, Object> data = CollectionUtils.asMap("fields", fields); return objectManager.create(driverClass, ObjectMetaDataManager.NAME_FIELD, name, ObjectMetaDataManager.ACCOUNT_FIELD, service.getAccountId(), "serviceId", service.getId(), ObjectMetaDataManager.DATA_FIELD, data); } }
@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); } }); }
@Override public List<? extends Instance> getInstancesToUpgrade(Service service, String launchConfigName, String toVersion) { Condition condition = null; if (launchConfigName == null || launchConfigName.equals(service.getName()) || launchConfigName.equals(ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME)) { condition = SERVICE_EXPOSE_MAP.DNS_PREFIX.isNull(); } else { condition = SERVICE_EXPOSE_MAP.DNS_PREFIX.eq(launchConfigName); } // add all managed return create() .select(INSTANCE.fields()) .from(INSTANCE) .join(SERVICE_EXPOSE_MAP) .on(SERVICE_EXPOSE_MAP.INSTANCE_ID.eq(INSTANCE.ID) .and(SERVICE_EXPOSE_MAP.SERVICE_ID.eq(service.getId())) .and(SERVICE_EXPOSE_MAP.MANAGED.eq(true)) .and(SERVICE_EXPOSE_MAP.STATE.in(CommonStatesConstants.ACTIVATING, CommonStatesConstants.ACTIVE, CommonStatesConstants.REQUESTED)) .and(INSTANCE.STATE.notIn(CommonStatesConstants.PURGING, CommonStatesConstants.PURGED, CommonStatesConstants.REMOVED, CommonStatesConstants.REMOVING)).and(condition) .and(INSTANCE.VERSION.ne(toVersion))) .fetchInto(InstanceRecord.class); }
@Override public List<? extends Instance> getInstancesToCleanup(Service service, String launchConfigName, String toVersion) { Condition condition = null; if (launchConfigName == null || launchConfigName.equals(service.getName()) || launchConfigName.equals(ServiceConstants.PRIMARY_LAUNCH_CONFIG_NAME)) { condition = SERVICE_EXPOSE_MAP.DNS_PREFIX.isNull(); } else { condition = SERVICE_EXPOSE_MAP.DNS_PREFIX.eq(launchConfigName); } // add unmanaged and marked for upgrade return create() .select(INSTANCE.fields()) .from(INSTANCE) .join(SERVICE_EXPOSE_MAP) .on(SERVICE_EXPOSE_MAP.INSTANCE_ID.eq(INSTANCE.ID) .and(SERVICE_EXPOSE_MAP.SERVICE_ID.eq(service.getId())) .and(SERVICE_EXPOSE_MAP.MANAGED.eq(false)) .and(SERVICE_EXPOSE_MAP.UPGRADE.eq(true)) .and(SERVICE_EXPOSE_MAP.STATE.in(CommonStatesConstants.ACTIVATING, CommonStatesConstants.ACTIVE, CommonStatesConstants.REQUESTED)) .and(INSTANCE.STATE.notIn(CommonStatesConstants.PURGING, CommonStatesConstants.PURGED, CommonStatesConstants.REMOVED, CommonStatesConstants.REMOVING)).and(condition) .and(INSTANCE.VERSION.ne(toVersion))) .fetchInto(InstanceRecord.class); }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { InstanceLink link = (InstanceLink)state.getResource(); if (link.getServiceConsumeMapId() == null) { return null; } ServiceConsumeMap map = objectManager.loadResource(ServiceConsumeMap.class, link.getServiceConsumeMapId()); String serviceName = map.getName(); if (StringUtils.isBlank(serviceName)) { Service service = objectManager.loadResource(Service.class, map.getConsumedServiceId()); serviceName = service.getName(); } Instance instance = consumeMapDao.findOneInstanceForService(map.getConsumedServiceId()); List<String> names = consumeMapDao.findInstanceNamesForService(map.getConsumedServiceId()); return new HandlerResult(INSTANCE_LINK.LINK_NAME, serviceName, InstanceLinkConstants.FIELD_INSTANCE_NAMES, names, INSTANCE_LINK.TARGET_INSTANCE_ID, instance == null ? null : instance.getId()); }