@Override public void handleStart(Operation startPost) { checkForDefaultHostDescription(DOCKER_COMPUTE_DESC_LINK, DOCKER_COMPUTE_DESC_ID); checkForDefaultHostDescription(VIC_COMPUTE_DESC_LINK, VIC_COMPUTE_DESC_ID); checkForDefaultHostDescription(KubernetesHostConstants.KUBERNETES_COMPUTE_DESC_LINK, KubernetesHostConstants.KUBERNETES_COMPUTE_DESC_ID); super.handleStart(startPost); }
private void validateVicHost(ContainerHostSpec hostSpec, Operation op) { String computeAddress = hostSpec.hostState.address; EndpointCertificateUtil.validateSslTrust(this, hostSpec, op, () -> { fetchSslTrustAliasProperty(hostSpec, () -> { getHostInfo(hostSpec, op, hostSpec.sslTrust, (computeState) -> { if (ContainerHostUtil.isVicHost(computeState)) { logInfo("VIC host verification passed for %s", computeAddress); completeOperationSuccess(op); } else { logInfo("VIC host verification failed for %s", computeAddress); op.fail(new LocalizableValidationException( CONTAINER_HOST_IS_NOT_VCH_MESSAGE, CONTAINER_HOST_IS_NOT_VCH_MESSAGE_CODE)); } }); }); }); }
private void updateHost(ContainerHostSpec hostSpec, Operation op) { fetchSslTrustAliasProperty(hostSpec, () -> { ComputeState cs = hostSpec.hostState; sendRequest(Operation.createPut(this, cs.documentSelfLink) .setBody(cs) .setCompletion((o, e) -> { if (e != null) { op.fail(e); return; } createHostPortProfile(cs, op); // when host is updated and ssl property cannot be fetch (power state is // UNKNOWN) do not run data collection (DC) to avoid endless loop. DC will // check for the ssl property and send new update for the host, and so on. if (ComputeService.PowerState.UNKNOWN != hostSpec.hostState.powerState) { // run data collection only if there's no error getting its certificate updateContainerHostInfo(cs.documentSelfLink); triggerEpzEnumeration(); } })); }); }
private void storeDockerHost(ContainerHostSpec hostSpec, Operation op) { if (hostSpec.acceptHostAddress) { doStoreHost(hostSpec, op); } else { // Docker hosts are validated by a ping call. pingHost(hostSpec, op, hostSpec.sslTrust, () -> { doStoreHost(hostSpec, op); }); } }
private void validateConnection(ContainerHostSpec hostSpec, Operation op) { EndpointCertificateUtil.validateSslTrust(this, hostSpec, op, () -> { fetchSslTrustAliasProperty(hostSpec, () -> { pingHost(hostSpec, op, hostSpec.sslTrust, () -> completeOperationSuccess(op)); }); }); }
cs.descriptionLink = getDescriptionForType(hostType); cs.adapterManagementReference = getAdapterManagementReferenceForType(hostType); store = Operation.createPost(getHost(), ComputeService.FACTORY_LINK) .addPragmaDirective(Operation.PRAGMA_DIRECTIVE_FORCE_INDEX_UPDATE); store = Operation.createPut(getHost(), cs.documentSelfLink); sendRequest(store .setBody(cs) .setCompletion((o, e) -> { createHostPortProfile(storedHost, op); updateContainerHostInfo(documentSelfLink); triggerEpzEnumeration(); }));
private <T> void sendAdapterRequest(AdapterRequest request, ComputeState cs, Operation op, Consumer<T> callbackFunction, Class<T> callbackResultClass) { URI adapterManagementReference = getAdapterManagementReferenceForType( ContainerHostUtil.getDeclaredContainerHostType(cs)); .createPatch(adapterManagementReference) .setBody(request) .setContextId(Service.getId(getSelfLink())) .setCompletion((o, ex) -> { if (ex != null) { String innerMessage = toReadableErrorMessage(ex, op); String message = String.format("Error connecting to %s: %s", cs.address, innerMessage); op); logWarning("Error sending adapter request with type %s : %s. Cause: %s", request.operationTypeId, rsp.message, Utils.toString(ex)); postEventlogError(cs, rsp.message); op.setStatusCode(o.getStatusCode()); op.setContentType(Operation.MEDIA_TYPE_APPLICATION_JSON); patchOp.addRequestHeader(Operation.ACCEPT_LANGUAGE_HEADER, languageHeader); sendRequest(patchOp);
private void checkForDefaultHostDescription(String descriptionLink, String descriptionId) { new ServiceDocumentQuery<>(getHost(), ComputeDescription.class) .queryDocument(descriptionLink, (r) -> { if (r.hasException()) { r.throwRunTimeException(); } else if (r.hasResult()) { logFine("Default docker compute description exists."); } else { ComputeDescription desc = new ComputeDescription(); desc.documentSelfLink = descriptionId; desc.id = descriptionId; sendRequest(Operation .createPost(this, ComputeDescriptionService.FACTORY_LINK) .setBody(desc) .setCompletion((o, e) -> { if (e != null) { logWarning("Default host description can't be created." + " Exception: %s", e instanceof CancellationException return; logInfo("Default host description created with self link: %s", descriptionLink); }));
PlacementZoneUtil.generatePlacementZone(getHost(), hostState) .thenCompose((generatedZone) -> { generatedResourcesIds.add(generatedZone.documentSelfLink); hostState.resourcePoolLink = generatedZone.documentSelfLink; return PlacementZoneUtil.generatePlacement(getHost(), generatedZone); }) .thenAccept((generatedPlacement) -> { generatedResourcesIds.add(generatedPlacement.documentSelfLink); storeVchHost(hostSpec, op); }).exceptionally((ex) -> { op.fail(ex); doStoreHost(hostSpec, op); } else { getHostInfo(hostSpec, op, hostSpec.sslTrust, (computeState) -> { if (ContainerHostUtil.isVicHost(computeState)) { String version = ContainerHostUtil.getHostServerVersion(computeState); ContainerHostUtil.verifyVchVersionIsSupported(getHost(), version) .whenComplete((ignore, ex) -> { if (ex != null) { Throwable cause = ex instanceof CompletionException ? ex.getCause() : ex; logWarning("Unsupported VCH version: %s", Utils.toString(cause)); op.fail(cause); } else { doStoreHost(hostSpec, op);
validate(hostSpec); validateHostTypeAndConnection(hostSpec, op); } else if (hostSpec.isUpdateOperation != null && hostSpec.isUpdateOperation.booleanValue()) { updateHost(hostSpec, op); } else { QueryTask q = QueryUtil.buildPropertyQuery(ComputeState.class, new ServiceDocumentQuery<>(getHost(), ComputeState.class) .query(q, (r) -> { CONTAINER_HOST_ALREADY_EXISTS_MESSAGE_CODE)); } else if (!found.get()) { createHost(hostSpec, op);
private void updateContainerHostInfo(String documentSelfLink) { URI uri = UriUtils.buildUri(getHost(), ContainerHostDataCollectionService.HOST_INFO_DATA_COLLECTION_LINK); ContainerHostDataCollectionState state = new ContainerHostDataCollectionState(); state.createOrUpdateHost = true; state.computeContainerHostLinks = Collections.singleton(documentSelfLink); sendRequest(Operation.createPatch(uri) .setBody(state) .setCompletion((o, ex) -> { if (ex != null) { logWarning("Failed to update host data collection: %s", ex.getMessage()); } })); }
private void createHostPortProfile(ComputeState computeState, Operation operation) { HostPortProfileService.HostPortProfileState hostPortProfileState = new HostPortProfileService.HostPortProfileState(); hostPortProfileState.hostLink = computeState.documentSelfLink; // Make sure there is only one HostPortProfile per Host by generating profile id based on // host id hostPortProfileState.id = computeState.id; hostPortProfileState.documentSelfLink = HostPortProfileService.getHostPortProfileLink( computeState.documentSelfLink); // POST will be converted to PUT if profile with this id already exists sendRequest(OperationUtil .createForcedPost(this, HostPortProfileService.FACTORY_LINK) .setBody(hostPortProfileState) .setCompletion((o, ex) -> { if (ex != null) { operation.fail(ex); return; } HostPortProfileService.HostPortProfileState result = o.getBody( HostPortProfileService.HostPortProfileState.class); logInfo("Created HostPortProfile for host %s with port range %s-%s.", result.hostLink, result.startPort, result.endPort); completeOperationSuccess(operation); })); }
private void createHost(ContainerHostSpec hostSpec, Operation op) { fetchSslTrustAliasProperty(hostSpec, () -> { if (hostSpec.acceptHostAddress) { if (hostSpec.acceptCertificate) { Operation o = Operation.createGet(null) .setCompletion((completedOp, e) -> { if (e != null) { storeHost(hostSpec, op); } else { op.setStatusCode(completedOp.getStatusCode()); op.transferResponseHeadersFrom(completedOp); op.setBodyNoCloning(completedOp.getBodyRaw()); op.complete(); } }); EndpointCertificateUtil .validateSslTrust(this, hostSpec, o, () -> storeHost(hostSpec, op)); } else { storeHost(hostSpec, op); } } else { EndpointCertificateUtil .validateSslTrust(this, hostSpec, op, () -> storeHost(hostSpec, op)); } }); }
private URI getAdapterManagementReferenceForType(ContainerHostType type) { switch (type) { case DOCKER: return UriUtils.buildUri(getHost(), ManagementUriParts.ADAPTER_DOCKER_HOST); case VCH: return UriUtils.buildUri(getHost(), ManagementUriParts.ADAPTER_DOCKER_HOST); case KUBERNETES: return UriUtils.buildUri(getHost(), ManagementUriParts.ADAPTER_KUBERNETES_HOST); default: throw new LocalizableValidationException(String.format( ContainerHostUtil.CONTAINER_HOST_TYPE_NOT_SUPPORTED_MESSAGE_FORMAT, type), ContainerHostUtil.CONTAINER_HOST_TYPE_NOT_SUPPORTED_MESSAGE_CODE, type); } }
@Test public void testToReadableErrorMessage() throws Throwable { ContainerHostService service = new ContainerHostService(); Method m = service.getClass().getDeclaredMethod("toReadableErrorMessage", Throwable.class, Operation.class);
private void storeKubernetesHost(ContainerHostSpec hostSpec, Operation op) { if (hostSpec.acceptHostAddress) { doStoreHost(hostSpec, op); } else { // Kubernetes hosts are validated by a ping call. pingHost(hostSpec, op, hostSpec.sslTrust, () -> { doStoreHost(hostSpec, op); }); } }
private AdapterRequest prepareAdapterRequest(ContainerHostOperationType operationType, ComputeState cs, SslTrustCertificateState sslTrust) { AdapterRequest request = new AdapterRequest(); request.operationTypeId = operationType.id; request.serviceTaskCallback = ServiceTaskCallback.createEmpty(); request.resourceReference = UriUtils.buildUri(getHost(), ComputeService.FACTORY_LINK); request.customProperties = cs.customProperties == null ? new HashMap<>() : new HashMap<>(cs.customProperties); request.customProperties.putIfAbsent(ComputeConstants.HOST_URI_PROP_NAME, cs.address); if (sslTrust != null) { request.customProperties.put(SSL_TRUST_CERT_PROP_NAME, sslTrust.certificate); request.customProperties.put(SSL_TRUST_ALIAS_PROP_NAME, SslTrustCertificateFactoryService.generateFingerprint(sslTrust)); } return request; }
private void verifyPlacementZoneIsEmpty(ContainerHostSpec hostSpec, Operation op, Runnable successCallback) { String placementZoneLink = hostSpec.hostState.resourcePoolLink; if (placementZoneLink == null || placementZoneLink.isEmpty()) { // no placement zone to verify successCallback.run(); return; } AtomicBoolean emptyZone = new AtomicBoolean(true); QueryTask queryTask = QueryUtil.buildPropertyQuery(ComputeState.class, ComputeState.FIELD_NAME_RESOURCE_POOL_LINK, placementZoneLink); QueryUtil.addCountOption(queryTask); new ServiceDocumentQuery<>(getHost(), ComputeState.class) .query(queryTask, (r) -> { if (r.hasException()) { op.fail(r.getException()); } else if (r.getCount() > 0) { emptyZone.set(false); op.fail(new LocalizableValidationException(PLACEMENT_ZONE_NOT_EMPTY_MESSAGE, PLACEMENT_ZONE_NOT_EMPTY_MESSAGE_CODE)); } else { if (emptyZone.get()) { successCallback.run(); } } }); }
private void verifyNoSchedulersInPlacementZone(ContainerHostSpec hostSpec, Operation op, Runnable successCallback) { String placementZoneLink = hostSpec.hostState.resourcePoolLink; if (placementZoneLink == null || placementZoneLink.isEmpty()) { // no placement zone => no schedulers successCallback.run(); return; } AtomicBoolean schedulerFound = new AtomicBoolean(false); QueryTask queryTask = QueryUtil.buildPropertyQuery(ComputeState.class, ComputeState.FIELD_NAME_RESOURCE_POOL_LINK, placementZoneLink); QueryUtil.addExpandOption(queryTask); new ServiceDocumentQuery<>(getHost(), ComputeState.class) .query(queryTask, (r) -> { if (r.hasException()) { op.fail(r.getException()); } else if (r.hasResult()) { if (ContainerHostUtil.isTreatedLikeSchedulerHost(r.getResult())) { schedulerFound.set(true); op.fail(new LocalizableValidationException( PLACEMENT_ZONE_CONTAINS_SCHEDULERS_MESSAGE, PLACEMENT_ZONE_CONTAINS_SCHEDULERS_MESSAGE_CODE)); } } else { if (!schedulerFound.get()) { successCallback.run(); } } }); }
Operation.createGet(getHost(), hostSpec.hostState.resourcePoolLink) .setCompletion((o, e) -> { if (e != null) {