protected DeploymentUnitInstance(DeploymentServiceContext context, String uuid, Service service, String launchConfigName) { this.context = context; this.uuid = uuid; this.launchConfigName = launchConfigName; this.service = service; this.stack = context.objectManager.loadResource(Stack.class, service.getStackId()); }
private boolean isNetworkStack(long accountId, long instanceId) { List<? extends Service> services = instanceDao.findServicesForInstanceId(instanceId); if(services.size() > 0) { if(services.get(0).getKind().equals(ServiceConstants.KIND_NETWORK_DRIVER_SERVICE)) { return true; } List<Service> network_services = objectManager.find(Service.class, SERVICE.ACCOUNT_ID, accountId, SERVICE.REMOVED, null, SERVICE.STACK_ID, services.get(0).getStackId(), SERVICE.KIND, ServiceConstants.KIND_NETWORK_DRIVER_SERVICE); if(network_services.size() > 0) { return true; } } return false; } }
private Volume createVolume(Service service, VolumeTemplate template, String name) { Map<String, Object> params = new HashMap<>(); if (template.getPerContainer()) { params.put(ServiceConstants.FIELD_DEPLOYMENT_UNIT_ID, unit.getId()); } params.put("name", name); params.put("accountId", service.getAccountId()); params.put(ServiceConstants.FIELD_STACK_ID, service.getStackId()); params.put(ServiceConstants.FIELD_VOLUME_TEMPLATE_ID, template.getId()); params.put(VolumeConstants.FIELD_VOLUME_DRIVER_OPTS, DataAccessor.fieldMap(template, VolumeConstants.FIELD_VOLUME_DRIVER_OPTS)); String driver = StringUtils.isBlank(template.getDriver()) ? VolumeConstants.LOCAL_DRIVER : template.getDriver(); params.put(VolumeConstants.FIELD_VOLUME_DRIVER, driver); params.put(VolumeConstants.FIELD_DEVICE_NUM, -1); return context.resourceDao.createAndSchedule(Volume.class, params); }
List<String> ports = DataAccessor.fieldStringList(map, LoadBalancerConstants.FIELD_LB_TARGET_PORTS); String consumedServiceName = consumedService.getName(); if (!service.getStackId().equals(consumedService.getStackId())) { Stack env = objectManager.loadResource(Stack.class, consumedService.getStackId()); consumedServiceName = env.getName() + "/" + consumedServiceName;
@Override public List<DeploymentUnit> collectDeploymentUnits(Service service, DeploymentServiceContext context) { /* * 1. find all containers related to the service through the serviceexposemaps * Then group all the objects * by the label 'io.rancher.deployment.unit'. When containers are deployed through service discovery that * label will be placed on them. * * 2. put all the containers to the deploymentUnit */ Map<String, Map<String, String>> uuidToLabels = new HashMap<>(); Map<String, List<DeploymentUnitInstance>> uuidToInstances = new HashMap<>(); List<DeploymentUnit> units = new ArrayList<>(); Map<String, io.cattle.platform.core.model.DeploymentUnit> uuidToExistingDU = new HashMap<>(); if (ServiceConstants.SERVICE_LIKE.contains(service.getKind())) { collectDefaultServiceInstances(context, uuidToLabels, uuidToInstances, service, uuidToExistingDU); } else if (service.getKind().equalsIgnoreCase(ServiceConstants.KIND_EXTERNAL_SERVICE)) { collectExternalServiceInstances(context, uuidToLabels, uuidToInstances, service, uuidToExistingDU); } Stack stack = context.objectManager.findOne(Stack.class, STACK.ID, service.getStackId()); for (String uuid : uuidToInstances.keySet()) { DeploymentUnit unit = new DeploymentUnit(context, uuid, service, uuidToInstances.get(uuid), uuidToLabels.get(uuid), stack, uuidToExistingDU); units.add(unit); } return units; }
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; }
@Override public List<Integer> getServiceInstanceUsedSuffixes(Service service, String launchConfigName) { Stack env = objectManager.findOne(Stack.class, STACK.ID, service.getStackId()); // get all existing instances to check if the name is in use by the instance of the same service List<Integer> usedSuffixes = new ArrayList<>(); List<? extends Instance> serviceInstances = exposeMapDao.listServiceManagedInstances(service, launchConfigName); for (Instance instance : serviceInstances) { if (ServiceDiscoveryUtil.isServiceGeneratedName(env, service, instance.getName())) { // legacy code - to support old data where service suffix wasn't set usedSuffixes.add(Integer.valueOf(ServiceDiscoveryUtil.getServiceSuffixFromInstanceName(instance .getName()))); } } return usedSuffixes; }
@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); } }); }
private boolean isSystem(Instance instance) { List<? extends Service> services = instanceDao.findServicesNonRemovedLinksOnly(instance); for (Service service : services) { Stack stack = objectManager.loadResource(Stack.class, service.getStackId()); if (ServiceConstants.isSystem(stack) || isLBSystemService(service)) { return true; } } return false; }
@Override public Object delete(String type, String id, ApiRequest request, ResourceManager next) { Service service = objectManager.loadResource(Service.class, id); Stack stack = objectManager.loadResource(Stack.class, service.getStackId()); validateInfraAccess(request, "delete", stack, service); return super.delete(type, id, request, next); }
protected void mapService(ApiRequest apiRequest, Object original, Resource converted) { UrlBuilder urlBuilder = apiRequest.getUrlBuilder(); IdFormatter idF = ApiContext.getContext().getIdFormatter(); if (original instanceof Service) { Long stackId = ((Service) original).getStackId(); if (stackId != null) { converted.getFields().put("environmentId", idF.formatId("environment", stackId)); converted.getLinks().put("environment", urlBuilder.resourceReferenceLink("environment", stackId.toString())); converted.getLinks().remove("stack"); } } convertURLs(converted, "/stacks/", "/environments/", converted.getLinks()); convertURLs(converted, "/stacks/", "/environments/", converted.getActions()); }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { List<Service> services = new ArrayList<>(); Set<Long> stackIds = new HashSet<>(); if (state.getResource() instanceof Stack) { stackIds.add(((Stack) state.getResource()).getId()); } else if (state.getResource() instanceof Service) { services.add((Service) state.getResource()); } else if (state.getResource() instanceof Instance) { services.addAll(instanceDao.findServicesFor((Instance) state.getResource())); } for (Service service : services) { stackIds.add(service.getStackId()); } for (Long stackId : stackIds) { ConfigUpdateRequest request = ConfigUpdateRequest.forResource(Stack.class, stackId); request.addItem(STACK); request.withDeferredTrigger(true); itemManager.updateConfig(request); } return null; }
@Override public ServiceDeploymentPlanner createServiceDeploymentPlanner(Service service, List<DeploymentUnit> units, DeploymentServiceContext context) { if (service == null) { return null; } Stack stack = context.objectManager.findOne(Stack.class, STACK.ID, service.getStackId()); boolean isGlobalDeploymentStrategy = isGlobalDeploymentStrategy(context, service); boolean isSelectorOnlyStrategy = isNoopStrategy(context, service); if (isSelectorOnlyStrategy || service.getKind().equalsIgnoreCase(ServiceConstants.KIND_EXTERNAL_SERVICE) || service.getKind().equalsIgnoreCase(ServiceConstants.KIND_DNS_SERVICE)) { return new NoOpServiceDeploymentPlanner(service, stack, units, context); } else if (isGlobalDeploymentStrategy) { return new GlobalServiceDeploymentPlanner(service, stack, units, context); } else { return new DefaultServiceDeploymentPlanner(service, stack, units, context); } }
protected void formatLBConfig(Service service, Map<String, Object> composeServiceData) { if (composeServiceData.get(ServiceConstants.FIELD_LB_CONFIG) != null) { LbConfig lbConfig = DataAccessor.field(service, ServiceConstants.FIELD_LB_CONFIG, jsonMapper, LbConfig.class); Map<Long, Service> serviceIdsToService = new HashMap<>(); Map<Long, Stack> stackIdsToStack = new HashMap<>(); Map<Long, Certificate> certIdsToCert = new HashMap<>(); for (Service svc : objectManager.find(Service.class, SERVICE.ACCOUNT_ID, service.getAccountId(), SERVICE.REMOVED, null)) { serviceIdsToService.put(svc.getId(), svc); } for (Stack stack : objectManager.find(Stack.class, STACK.ACCOUNT_ID, service.getAccountId(), STACK.REMOVED, null)) { stackIdsToStack.put(stack.getId(), stack); } for (Certificate cert : objectManager.find(Certificate.class, CERTIFICATE.ACCOUNT_ID, service.getAccountId(), CERTIFICATE.REMOVED, null)) { certIdsToCert.put(cert.getId(), cert); } composeServiceData.put(ServiceConstants.FIELD_LB_CONFIG, new LBConfigMetadataStyle(lbConfig.getPortRules(), lbConfig.getCertificateIds(), lbConfig.getDefaultCertificateId(), lbConfig.getConfig(), lbConfig.getStickinessPolicy(), serviceIdsToService, stackIdsToStack, certIdsToCert, service.getStackId(), true, false)); } }
@Override public HandlerResult handle(ProcessState state, ProcessInstance process) { final Service service = (Service)state.getResource(); for (final String driverKey : DRIVERS) { @SuppressWarnings("unchecked") final Map<String, Object> driverMap = DataAccessor.fields(service).withKey(driverKey) .withDefault(Collections.EMPTY_MAP).as(Map.class); if (driverMap.size() == 0) { continue; } Stack stack = objectManager.loadResource(Stack.class, service.getStackId()); if (stack == null) { continue; } if (ServiceConstants.isSystem(stack)) { lockManager.lock(new DriverLock(service, driverKey), new LockCallbackNoReturn() { @Override public void doWithLockNoResult() { addDriver(driverKey, service, driverMap); } }); } } return null; }
@Override public Object update(String type, String id, ApiRequest request, ResourceManager next) { Service service = objectManager.loadResource(Service.class, id); Stack stack = objectManager.loadResource(Stack.class, service.getStackId()); validateInfraAccess(request, "update", stack, service); validateLaunchConfigs(service, request); validateSelector(request); validateLbConfig(request, type); validateScalePolicy(service, request, true); validatePorts(service, type, request); return super.update(type, id, request, next); }
@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 HandlerResult handle(ProcessState state, ProcessInstance process) { Service service = (Service) state.getResource(); sdService.setVIP(service); sdService.setPorts(service); sdService.setToken(service); Stack stack = objectManager.loadResource(Stack.class, service.getStackId()); boolean system = ServiceConstants.isSystem(stack); if (DataAccessor.fieldBool(service, ServiceConstants.FIELD_START_ON_CREATE)) { return new HandlerResult(ServiceConstants.FIELD_SYSTEM, system).withShouldContinue(true) .withChainProcessName(ServiceConstants.PROCESS_SERVICE_ACTIVATE); } return new HandlerResult(ServiceConstants.FIELD_SYSTEM, system); } }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Service service = request.proxyRequestObject(Service.class); Stack stack = objectManager.loadResource(Stack.class, service.getStackId()); validateInfraAccess(request, "create", stack, service); validateStack(stack, service); validateSelector(request); validateMetadata(request); validateLaunchConfigs(service, request); validateIpsHostName(request); request = validateAndSetImage(request, service, type); validatePorts(service, type, request); validateScalePolicy(service, request, false); request = setServiceIndexStrategy(type, request); request = setLBServiceEnvVarsAndHealthcheck(type, service, request); validateLbConfig(request, type); return super.create(type, request, next); }
/** * {@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()); }