public ProjectRolesHandler(Service service, String projectLink) { AssertUtil.assertNotNull(service, "service"); AssertUtil.assertNotEmpty(projectLink, "projectLink"); this.service = service; this.projectLink = projectLink; }
static String apiPrefix(KubernetesContext context, String apiVersion) { AssertUtil.assertNotNull(context.host, "context.host"); AssertUtil.assertNotNullOrEmpty(context.host.address, "context.host.address"); return context.host.address + apiVersion; }
/** * Sets the retry delays for this task. They will be used in sequence until the maximum number * of retries are exceeded. If the maximum number of retries is bigger than the number of * delays, the last delay will be repeated. */ public RetriableTaskBuilder<T> withRetryDelays(List<Long> retryDelays) { assertTaskNotExecuted(); AssertUtil.assertNotNull(retryDelays, "retryDelays"); AssertUtil.assertTrue(retryDelays.size() > 0, "retryDelays must contain at least one delay declaration"); AssertUtil.assertTrue(retryDelays.stream().noneMatch(l -> l == null || l < 0), "retryDelays must contain only non-negative integers"); this.taskConfiguration.retryDelays = Collections.unmodifiableList(retryDelays); return this; }
public void validate() { AssertUtil.assertNotNullOrEmpty(endpointLink, FIELD_NAME_ENDPOINT_LINK); AssertUtil.assertNotNull(cluster, FIELD_NAME_CLUSTER); AssertUtil.assertNotNull(cluster.uuid, "cluster.uuid"); AssertUtil.assertNotNull(cluster.name, "cluster.name"); AssertUtil.assertNotNull(getExternalAddress(), "external-hostname"); AssertUtil.assertNotEmpty(tenantLinks, FIELD_NAME_TENANT_LINKS); }
@Override protected void validateStateOnStart(ClosureProvisionTaskState state) throws IllegalArgumentException { assertNotNull(state.resourceDescriptionLink, "resourceDescriptionLink"); assertNotNull(state.resourceLinks, "resourceLinks"); }
@Override protected void validateStateOnStart(ClosureRemovalTaskState state) throws IllegalArgumentException { assertNotEmpty(state.resourceLinks, "resourceLinks"); }
private void validateTaskAndCalculateOptionalFields() { assertTaskNotExecuted(); AssertUtil.assertNotNullOrEmpty(taskConfiguration.taskId, "taskId"); AssertUtil.assertNotNull(taskConfiguration.serviceHost, "serviceHost"); AssertUtil.assertNotNull(taskConfiguration.taskFunction, "taskBody"); AssertUtil.assertNotNull(taskConfiguration.retryDelays, "retryDelays"); AssertUtil.assertNotNull(taskConfiguration.retryDelaysTimeUnit, "retryDelaysTimeUnit"); if (taskConfiguration.maxRetries == null) { taskConfiguration.maxRetries = taskConfiguration.retryDelays.size(); } else { AssertUtil.assertTrue(taskConfiguration.maxRetries >= 0, "maxRetries must be a non-negative integer"); } }
private void validate(ContainerHostSpec hostSpec) { final ComputeState cs = hostSpec.hostState; AssertUtil.assertNotNull(cs, "computeState"); AssertUtil.assertNotEmpty(cs.address, "address"); AssertUtil.assertNotEmpty(cs.customProperties, "customProperties"); String adapterDockerType = cs.customProperties.get(HOST_DOCKER_ADAPTER_TYPE_PROP_NAME); AssertUtil.assertNotEmpty(adapterDockerType, HOST_DOCKER_ADAPTER_TYPE_PROP_NAME); DockerAdapterType adapterType = DockerAdapterType.valueOf(adapterDockerType); AssertUtil.assertNotNull(adapterType, "adapterType"); cs.address = cs.address.trim(); String kubernetesNamespace = cs.customProperties.get( KubernetesHostConstants.KUBERNETES_HOST_NAMESPACE_PROP_NAME); if (kubernetesNamespace == null || kubernetesNamespace.isEmpty()) { cs.customProperties.put( KubernetesHostConstants.KUBERNETES_HOST_NAMESPACE_PROP_NAME, KubernetesHostConstants.KUBERNETES_HOST_DEFAULT_NAMESPACE); } else { kubernetesNamespace = kubernetesNamespace.trim(); AssertUtil.assertTrue(!kubernetesNamespace.contains("/") && !kubernetesNamespace.contains("\\"), "Namespace cannot contain" + " slashes."); AssertUtil.assertTrue(kubernetesNamespace.matches( KubernetesHostConstants.KUBERNETES_NAMESPACE_REGEX), "Invalid namespace."); cs.customProperties.put( KubernetesHostConstants.KUBERNETES_HOST_NAMESPACE_PROP_NAME, kubernetesNamespace); } }
/** * Sets the ID of the task. */ public RetriableTaskBuilder<T> withTaskId(String taskId) { assertTaskNotExecuted(); AssertUtil.assertNotNullOrEmpty(taskId, "taskId"); this.taskConfiguration.taskId = taskId; return this; }
public static DeferredResult<Void> handlePatch(Service service, Operation op) { ResourcePoolState patchState = op.getBody(ResourcePoolState.class); Operation getOp = Operation.createGet(op.getUri()).setReferer(service.getUri()); return service.getHost().sendWithDeferredResult(getOp, ResourcePoolState.class) .thenCompose(currentState -> { AssertUtil.assertNotNull(currentState, "currentState"); ResourcePoolState rp = new ResourcePoolState(); rp.customProperties = PropertyUtils.mergeCustomProperties( currentState.customProperties, patchState.customProperties); // Now check whether the unified state is a scheduler if (PlacementZoneUtil.isSchedulerPlacementZone(rp)) { try { // shcedulers can have no tags AssertUtil.assertEmpty(currentState.tagLinks, "tagLinks"); AssertUtil.assertEmpty(patchState.tagLinks, "tagLinks"); } catch (LocalizableValidationException ex) { return DeferredResult.failed(ex); } // schedulers can have a single scheduler host at most return verifyZoneContainsSingleSchedulerOrNoHost( currentState.documentSelfLink, op, service); } else { // docker placement zones can have only docker hosts return verifyZoneContainsNoSchedulers(currentState.documentSelfLink, op, service); } }).thenAccept(ignore -> { }); }
@Override protected void validateStateOnStart(CompositionSubTaskState state) throws IllegalArgumentException { boolean descAndResourcesEmpty = (state.resourceDescriptionLink == null || state.resourceDescriptionLink .isEmpty()) && (state.resourceLinks == null || state.resourceLinks.isEmpty()); assertTrue(!descAndResourcesEmpty, "resourceDescriptionLink and resourceLinks are empty"); }
public static DeferredResult<Void> handlePostOrPut(Service service, Operation op) { ResourcePoolState placementZone = op.getBody(ResourcePoolState.class); if (PlacementZoneUtil.isSchedulerPlacementZone(placementZone)) { try { AssertUtil.assertEmpty(placementZone.tagLinks, "tagLinks"); } catch (LocalizableValidationException ex) { return DeferredResult.failed(ex); } return verifyZoneContainsSingleSchedulerOrNoHost(placementZone.documentSelfLink, op, service); } else { return verifyZoneContainsNoSchedulers(placementZone.documentSelfLink, op, service); } }
public PrincipalRolesHandler setService(Service service) { assertNotNull(service, "service"); this.service = service; return this; }
@Override protected void validateStateOnStart(PKSProvisioningTaskState task) throws IllegalArgumentException { AssertUtil.assertNotNull(task, "task"); AssertUtil.assertNotNull(task.customProperties, "customProperties"); AssertUtil.assertNotEmpty(task.getCustomProperty(PKS_CLUSTER_NAME_PROP_NAME), "customProperties [" + PKS_CLUSTER_NAME_PROP_NAME + "]"); AssertUtil.assertNotEmpty(task.getCustomProperty(PKS_PLAN_NAME_FIELD), "customProperties [" + PKS_PLAN_NAME_FIELD + "]"); AssertUtil.assertNotEmpty(task.getCustomProperty(PKS_MASTER_HOST_FIELD), "customProperties [" + PKS_MASTER_HOST_FIELD + "]"); AssertUtil.assertNotNullOrEmpty(task.endpointLink, "endpointLink"); AssertUtil.assertNotNull(task.tenantLinks, "tenantLinks"); AssertUtil.assertNotEmpty(TenantLinksUtil.getProjectAndGroupLinks(task.tenantLinks), "tenantLinks(project/group links only)"); }
@Override protected void validateStateOnStart(CompositionTaskState state) { assertNotEmpty(state.resourceDescriptionLink, "resourceDescriptionLink"); }
/** * Extracts a version string in the format xxx.yyy.zzz (with variable number of segments) out of * a raw string. E.g. it will extract <code>1.3.0</code> out of <code>v1.3.0-abcdef</code>. * * @throws IllegalArgumentException * if the extraction is not possible. */ public static String extractNumericVersion(String rawVersion) { AssertUtil.assertNotNullOrEmpty(rawVersion, "rawVersion"); Matcher matcher = EXTRACT_NUMERIC_VERSION_PATTERN.matcher(rawVersion); if (matcher.matches()) { return matcher.group(VERSION_GROUP_NAME); } throw new IllegalArgumentException( String.format("%s %s", CANNOT_EXTRACT_NUMERIC_VERSION_MESSAGE, rawVersion)); }
private static double memoryConversion(double inMagnitude, String inUnit, String outUnit, boolean isDecimal) { int base = isDecimal ? 1000 : 1024; List<String> listOfUnits = isDecimal ? DECIMAL_MEMORY_UNITS : BINARY_MEMORY_UNITS; int inPow = listOfUnits.indexOf(inUnit.toLowerCase()); assertTrue(inPow >= 0, "inMagnitude set to incorrect unit."); int outPow = listOfUnits.indexOf(outUnit.toLowerCase()); assertTrue(outPow >= 0, "outMagnitude set to incorrect unit."); int pow = inPow - outPow; return inMagnitude * Math.pow(base, pow); }
AssertUtil.assertEmpty(hostState.tagLinks, "tagLinks"); } catch (LocalizableValidationException ex) { op.fail(ex);
@Override protected void validateStateOnStart(PKSClusterRemovalTaskState task) throws IllegalArgumentException { AssertUtil.assertNotNull(task, "task"); AssertUtil.assertNotEmpty(task.resourceLink, "resourceLink"); }
private void validateStateOnStart(EventLogState state) { assertNotNull(state.description, "description"); assertNotNull(state.resourceType, "resourceType"); assertNotNull(state.eventLogType, "eventLogType"); } }