@Override public Object create(String type, ApiRequest request, ResourceManager next) { validateInfraAccess(request, "create"); return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Map<?, ?> labels = DataUtils.getFieldFromRequest(request, InstanceConstants.FIELD_LABELS, Map.class); if (labels != null) { Object l = labels.get(SystemLabels.LABEL_VOLUME_CLEANUP_STRATEGY); if (l != null && !InstanceConstants.VOLUME_REMOVE_STRATEGIES.contains(l)) { throw new ClientVisibleException(ResponseCodes.BAD_REQUEST, ValidationErrorCodes.INVALID_OPTION, String.format( "%s is an invalid value for the %s label.", l.toString(), SystemLabels.LABEL_VOLUME_CLEANUP_STRATEGY), null); } } return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Service service = request.proxyRequestObject(Service.class); validateSelectorOnlyService(request, service); return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { List<?> ports = DataUtils.getFieldFromRequest(request, InstanceConstants.FIELD_PORTS, List.class); if (ports != null) { for (Object port : ports) { if (port == null) { throw new ValidationErrorException(ValidationErrorCodes.MISSING_REQUIRED, InstanceConstants.FIELD_PORTS); } /* This will parse the PortSpec and throw an error */ new PortSpec(port.toString()); } } return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { VolumeTemplate template = request.proxyRequestObject(VolumeTemplate.class); validateNameUniqueness(template); validateScope(template); return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { String url = DataAccessor.fromMap(request.getRequestObject()).withKey("url").as(String.class); MachineDriver md = request.proxyRequestObject(MachineDriver.class); if (url != null && StringUtils.isBlank(md.getName())) { String[] parts = url.split("/"); String name = parts[parts.length-1]; name = StringUtils.removeStart(name, "docker-machine-driver-"); name = StringUtils.removeStart(name, "docker-machine-"); name = name.split("[^a-zA-Z0-9]")[0]; md.setName(name); } return super.create(type, request, next); } }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Stack env = request.proxyRequestObject(Stack.class); validateStackName(type, request, env.getName()); return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { String cert = DataUtils.getFieldFromRequest(request, "cert", String.class); Certificate certificate = request.proxyRequestObject(Certificate.class); setCertificateFields(cert, certificate); return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { validateInfraAccess(request, "create"); // Don't validate hosts for v1 API if (HostConstants.TYPE.equals(type) && ("v1".equals(request.getVersion()) || AccountConstants.SUPER_ADMIN_KIND.equals(request.getSchemaFactory().getId()))) { return super.create(type, request, next); } Map<String, Object> data = CollectionUtils.toMap(request.getRequestObject()); boolean alreadyFound = false; for (Map.Entry<String, Object> field : data.entrySet()) { if (StringUtils.endsWithIgnoreCase(field.getKey(), CONFIG_FIELD_SUFFIX) && field.getValue() != null) { if (alreadyFound) { throw new ClientVisibleException(ResponseCodes.UNPROCESSABLE_ENTITY, DRIVER_CONFIG_EXACTLY_ONE_REQUIRED); } alreadyFound = true; } } if (!alreadyFound && data.get(HostConstants.FIELD_HOST_TEMPLATE_ID) == null) { throw new ClientVisibleException(ResponseCodes.UNPROCESSABLE_ENTITY, DRIVER_CONFIG_EXACTLY_ONE_REQUIRED); } return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Account account = request.proxyRequestObject(Account.class); ProjectTemplate template = objectManager.loadResource(ProjectTemplate.class, account.getProjectTemplateId()); if (template == null) { return super.create(type, request, next); } List<CatalogTemplate> templates = DataAccessor.fieldObjectList(template, ProjectTemplateConstants.FIELD_STACKS, CatalogTemplate.class, jsonMapper); if (templates == null) { return super.create(type, request, next); } List<String> ids = new ArrayList<>(); for (CatalogTemplate catalogTemplate : templates) { String id = catalogTemplate.getTemplateVersionId(); if (StringUtils.isBlank(id)) { id = catalogTemplate.getTemplateId(); } if (StringUtils.isNotBlank(id)) { ids.add(id); } } Map<String, Object> input = CollectionUtils.toMap(request.getRequestObject()); input.put(AccountConstants.FIELD_ORCHESTRATION, SystemStackUpdate.chooseOrchestration(ids)); return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Secret s = request.proxyRequestObject(Secret.class); if (!Base64.isBase64(s.getValue())) { throw new ValidationErrorException("InvalidBase64", "value", "Invalid base64 content"); }; Base64.decodeBase64(s.getValue()); return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { UserPreference userPreference = request.proxyRequestObject(UserPreference.class); long accountId; try { accountId = ((Policy) ApiContext.getContext().getPolicy()).getAccountId(); if (!userPreferenceDao.isUnique(userPreference, accountId)) { throw new ValidationErrorException(ValidationErrorCodes.NOT_UNIQUE, CredentialConstants.PUBLIC_VALUE); } return super.create(type, request, next); } catch (NullPointerException e) { return super.create(type, request, next); } } }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Policy policy = ApiUtils.getPolicy(); Agent agent = objectManager.loadResource(Agent.class, policy.getOption(Policy.AGENT_ID)); if (agent == null) { throw new ClientVisibleException(ResponseCodes.FORBIDDEN, VERIFY_AGENT); } return super.create(type, request, next); } }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Map<String, Object> requestObject = CollectionUtils.toMap(request.getRequestObject()); String serverAddress = (String) requestObject.get(StoragePoolConstants.SERVER_ADDRESS); long accountId = ((Policy) ApiContext.getContext().getPolicy()).getAccountId(); List<StoragePool> registries = objectManager.find(StoragePool.class, ObjectMetaDataManager.KIND_FIELD, StoragePoolConstants.KIND_REGISTRY, ObjectMetaDataManager.ACCOUNT_FIELD, accountId, ObjectMetaDataManager.REMOVED_FIELD, null); for (StoragePool registry: registries){ if (!CommonStatesConstants.PURGED.equalsIgnoreCase(registry.getState())) { if (serverAddress.equalsIgnoreCase( (String) CollectionUtils.getNestedValue(registry.getData(), "fields", StoragePoolConstants.SERVER_ADDRESS))) { throw new ClientVisibleException(ResponseCodes.BAD_REQUEST, "ServerAddressUsed"); } } } return super.create(type, request, next); }
return super.create(type, request, next);
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Instance container = request.proxyRequestObject(Instance.class); if (REQUIRE_INSTANCE_IMAGE.get()) { Long imageId = container.getImageId(); String imageUuid = DataUtils.getFieldFromRequest(request, InstanceConstants.FIELD_IMAGE_UUID, String.class); if (imageId == null && imageUuid == null) { throw new ValidationErrorException(ValidationErrorCodes.MISSING_REQUIRED, InstanceConstants.FIELD_IMAGE_UUID, "image is required, but not specified"); } } Long imageId = container.getImageId(); Image image = getObjectManager().loadResource(Image.class, imageId); if (image != null && image.getInstanceKind() != null) { if (!image.getInstanceKind().equals(type)) { throw new ClientVisibleException(ResponseCodes.UNPROCESSABLE_ENTITY, "InvalidImageInstanceKind"); } } return super.create(type, request, next); }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { ContainerEvent event = request.proxyRequestObject(ContainerEvent.class); Policy policy = ApiUtils.getPolicy(); Agent agent = objectManager.loadResource(Agent.class, policy.getOption(Policy.AGENT_ID)); if (agent == null) { throw new ClientVisibleException(ResponseCodes.FORBIDDEN, VERIFY_AGENT); } Map<String, Host> hosts = agentDao.getHosts(agent.getId()); Host host = hosts.get(event.getReportedHostUuid()); if ( host == null ) { throw new ValidationErrorException(ValidationErrorCodes.INVALID_REFERENCE, HOST_PARAM); } if (!containerEventDao.canCreate(host.getId(), event.getExternalStatus())) { log.info("Dropping container event from agent for host [{}]", host.getId()); throw new ClientVisibleException(ResponseCodes.CONFLICT, TOO_MANY); } event.setHostId(host.getId()); return super.create(type, request, next); } }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { Credential cred = request.proxyRequestObject(Credential.class); if (cred.getPublicValue() == null) { String[] keys = generateKeys(); cred.setPublicValue(keys[0]); cred.setSecretValue(keys[1]); } String clearSecret = cred.getSecretValue(); if (clearSecret != null) { cred.setSecretValue(ApiContext.getContext().getTransformationService().transform(clearSecret, "HASH")); } cred = (Credential) super.create(type, request, next); cred.setSecretValue(clearSecret); return cred; }
@Override public Object create(String type, ApiRequest request, ResourceManager next) { String ip = request.getClientIp(); Agent agent = request.proxyRequestObject(Agent.class); /* * This ensures that the accountId is always set from the request and * never overwritten by the default accountId setting logic. In the * situation in which the client doesn't have access to the accountId * field, the result will be null, which is correct. You want it to be * null so that the AgentCreate logic will create an account for this * Agent */ agent.setAccountId(agent.getAccountId()); String uri = agent.getUri(); String user = DataUtils.getFieldFromRequest(request, AgentConstants.USER, String.class); if (uri == null) { uri = getUri(user, ip); if (uri != null) { isUnique(uri); agent.setUri(uri); } } return super.create(type, request, next); }
@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); }