@Override public Service createServiceInstance() throws Throwable { return new ContainerHostRemovalTaskService(); } }
private void doRemoveTrustCerts(ContainerHostRemovalTaskState state) { collectTrustCert(state) .thenApply(trustCertSelfLinks -> { return trustCertSelfLinks.stream() .filter(Objects::nonNull) .filter(link -> link.startsWith(SslTrustCertificateService.FACTORY_LINK)) .collect(Collectors.toSet()); }) .thenCompose(trustCertSelfLinks -> { return CertificateCleanupUtil.removeTrustCertsIfUnused(getHost(), trustCertSelfLinks, state.resourceLinks); }) .whenComplete((ignore, ex) -> { if (ex != null) { logWarning("Failed to remove unused trust certificates.", ex); } proceedTo(SubStage.REMOVED_CERTIFICATES); }); }
switch (state.taskSubStage) { case CREATED: disableContainerHosts(state, null); break; case SUSPENDING_HOSTS: break; case SUSPENDED_HOSTS: queryContainers(state); break; case REMOVING_CONTAINERS: break; case REMOVED_CONTAINERS: queryNetworks(state); break; case REMOVING_NETWORKS: break; case REMOVED_NETWORKS: queryVolumes(state); break; case REMOVING_VOLUMES: break; case REMOVED_VOLUMES: filterKubernetesHosts(state); break; case REMOVING_KUBERNETES_RESOURCES: break; case REMOVED_KUBERNETES_RESOURCES: queryPortProfiles(state); break;
private void removePortProfiles(ContainerHostRemovalTaskState state, ArrayList<String> hostPortProfileLinks, String subTaskLink) { if (subTaskLink == null) { // create counter subtask to remove every host port profile. Go to REMOVED_PORT_PROFILES when complete createCounterSubTask(state, hostPortProfileLinks.size(), SubStage.REMOVED_PORT_PROFILES, (link) -> removePortProfiles(state, hostPortProfileLinks, link)); return; } // delete host port profiles for (String profileLink : hostPortProfileLinks) { sendRequest(Operation.createDelete(this, profileLink) .setCompletion((o, ex) -> { if (ex != null) { failTask("Failed to delete host port profile: %s", ex); return; } completeSubTasksCounter(subTaskLink, null); })); } }
private void filterKubernetesHosts(ContainerHostRemovalTaskState state) { filterKubernetesHostLinks(this, state.resourceLinks, (kubernetesHostLinks, errors) -> { if (errors != null) { failTask("Couldn't filter kubernetes host links: %s", new IllegalStateException(Utils.toString(errors))); return; } removeKubernetesResources(state, kubernetesHostLinks); }); }
private void removeHosts(ContainerHostRemovalTaskState state, String subTaskLink) { if (subTaskLink == null && !state.skipComputeHostRemoval) { createCounterSubTask(state, state.resourceLinks.size(), (link) -> removeHosts(state, link)); return; logInfo("Starting delete of %d container hosts", state.resourceLinks.size()); URI uri = UriUtils.buildUri(getHost(), ContainerHostDataCollectionService.HOST_INFO_DATA_COLLECTION_LINK); ContainerHostDataCollectionService.ContainerHostDataCollectionState dataCollectionState dataCollectionState.computeContainerHostLinks = state.resourceLinks; dataCollectionState.remove = true; sendRequest(Operation.createPatch(uri) .setBody(dataCollectionState) .setCompletion((o1, ex1) -> { if (ex1 != null) { logWarning("Failed to update host data collection: %s", ex1.getMessage()); proceedTo(SubStage.COMPLETED); return; sendRequest(Operation .createDelete(this, resourceLink) .setBody(new ServiceDocument()) .setCompletion((o, e) -> { if (e != null) { logWarning("Failed deleting ComputeState: %s",
private void removeKubernetesResources(ContainerHostRemovalTaskState state, Set<String> kubernetesHostLinks) { if (kubernetesHostLinks == null || kubernetesHostLinks.isEmpty()) { queryPortProfiles(state); return; } CompositeKubernetesRemovalTaskState kubernetesRemovalTask = new CompositeKubernetesRemovalTaskState(); kubernetesRemovalTask.resourceLinks = kubernetesHostLinks; kubernetesRemovalTask.cleanupOnly = true; kubernetesRemovalTask.serviceTaskCallback = ServiceTaskCallback.create( getSelfLink(), TaskStage.STARTED, SubStage.REMOVED_KUBERNETES_RESOURCES, TaskStage.STARTED, SubStage.ERROR); kubernetesRemovalTask.requestTrackerLink = state.requestTrackerLink; Operation startPost = Operation .createPost(this, CompositeKubernetesRemovalTaskService.FACTORY_LINK) .setBody(kubernetesRemovalTask) .setCompletion((o, e) -> { if (e != null) { failTask("Failure creating kubernetes composite removal task", e); return; } proceedTo(SubStage.REMOVING_KUBERNETES_RESOURCES); }); sendRequest(startPost); }
.getDefaultTaskExpirationTimeInMicros(); subTaskInitState.serviceTaskCallback = ServiceTaskCallback.create( getSelfLink(), TaskStage.STARTED, SubStage.SUSPENDED_HOSTS, TaskStage.STARTED, SubStage.ERROR); (link) -> disableContainerHosts(state, link)); return; AtomicBoolean error = new AtomicBoolean(); for (String resourceLink : state.resourceLinks) { sendRequest(Operation .createPatch(this, resourceLink) .setBody(computeState) if (e != null) { if (error.compareAndSet(false, true)) { logWarning("Failed suspending ComputeState: %s", resourceLink); completeSubTasksCounter(subTaskLink, e); completeSubTasksCounter(subTaskLink, null); })); proceedTo(SubStage.SUSPENDING_HOSTS); } catch (Throwable e) { failTask("Unexpected exception while suspending container host", e);
new ServiceDocumentQuery<ContainerNetworkState>(getHost(), ContainerNetworkState.class) .query(networkQuery, (r) -> { if (r.hasException()) { failTask("Failure retrieving query results", r.getException()); return; } else if (r.hasResult()) { } else { networkState.parentLinks = parentLinks; updateNetworkParentLinks(networkState); queryVolumes(state); return; removeNetworks(state, networkLinks);
private void removeTrustCerts(ContainerHostRemovalTaskState state) { QueryTask queryTask = new QueryTask(); queryTask.querySpec = new QueryTask.QuerySpecification(); queryTask.taskInfo.isDirect = true; Query q = Query.Builder.create() .addFieldClause(QuerySpecification .buildCompositeFieldName(ComputeState.FIELD_NAME_CUSTOM_PROPERTIES, ComputeConstants.HOST_TRUST_CERTS_PROP_NAME), UriUtils.URI_WILDCARD_CHAR, MatchType.WILDCARD, Occurance.MUST_NOT_OCCUR).build(); q.addBooleanClause(createKindClause(ComputeState.class)); queryTask.querySpec.query.addBooleanClause(q); sendWithDeferredResult(Operation .createPost(UriUtils.buildUri(getHost(), ServiceUriPaths.CORE_QUERY_TASKS)) .setBody(queryTask) .setReferer(getHost().getUri()), QueryTask.class) .thenAccept(qrt -> { if (qrt.results.documentCount == 0) { doRemoveTrustCerts(state); } else { proceedTo(SubStage.REMOVED_CERTIFICATES); } }).exceptionally(e -> { logWarning("Failed to remove unused trust certificate.", e); proceedTo(SubStage.REMOVED_CERTIFICATES); return null; }); }
private void queryVolumes(ContainerHostRemovalTaskState state) { QueryTask volumeQuery = QueryUtil.buildQuery(ContainerVolumeState.class, false); QueryUtil.addListValueClause(volumeQuery, ContainerVolumeState.FIELD_NAME_ORIGINATING_HOST_LINK, state.resourceLinks); Set<String> volumeLinks = new HashSet<>(); new ServiceDocumentQuery<ContainerVolumeState>(getHost(), ContainerVolumeState.class).query( volumeQuery, (r) -> { if (r.hasException()) { failTask("Failure retrieving query results", r.getException()); return; } else if (r.hasResult()) { volumeLinks.add(r.getDocumentSelfLink()); } else { if (volumeLinks.isEmpty()) { filterKubernetesHosts(state); return; } removeVolumes(state, volumeLinks); } }); }
private void queryContainers(ContainerHostRemovalTaskState state) { QueryTask containerQuery = QueryUtil.buildQuery(ContainerState.class, true); QueryUtil.addListValueClause(containerQuery, ContainerState.FIELD_NAME_PARENT_LINK, state.resourceLinks); Set<String> containerLinks = new HashSet<>(); new ServiceDocumentQuery<ContainerState>(getHost(), ContainerState.class).query( containerQuery, (r) -> { if (r.hasException()) { failTask("Failure retrieving query results", r.getException()); return; } else if (r.hasResult()) { containerLinks.add(r.getDocumentSelfLink()); } else { if (containerLinks.isEmpty()) { queryNetworks(state); return; } removeContainers(state, containerLinks); } }); }
private void queryPortProfiles(ContainerHostRemovalTaskState state) { QueryTask q = QueryUtil .buildQuery(HostPortProfileService.HostPortProfileState.class, false); QueryUtil.addListValueClause(q, HostPortProfileService.HostPortProfileState.FIELD_HOST_LINK, state.resourceLinks); ServiceDocumentQuery<HostPortProfileService.HostPortProfileState> query = new ServiceDocumentQuery<>( getHost(), HostPortProfileService.HostPortProfileState.class); QueryUtil.addBroadcastOption(q); ArrayList<String> hostPortProfileLinks = new ArrayList<>(); query.query(q, (r) -> { if (r.hasException()) { failTask("Failure retrieving query results", r.getException()); return; } else if (r.hasResult()) { hostPortProfileLinks.add(r.getDocumentSelfLink()); } else { // if there are no host port profiles, go to the next stage if (hostPortProfileLinks.isEmpty()) { proceedTo(SubStage.REMOVED_PORT_PROFILES); return; } removePortProfiles(state, hostPortProfileLinks, null); proceedTo(SubStage.REMOVING_PORT_PROFILES); } }); }
private void removeVolumes(ContainerHostRemovalTaskState state, Set<String> volumeSelfLinks) { // run a sub task for removing the volumes ContainerVolumeRemovalTaskState volumeRemovalTask = new ContainerVolumeRemovalTaskState(); volumeRemovalTask.resourceLinks = volumeSelfLinks; volumeRemovalTask.removeOnly = true; volumeRemovalTask.serviceTaskCallback = ServiceTaskCallback.create( getSelfLink(), TaskStage.STARTED, SubStage.REMOVED_VOLUMES, TaskStage.STARTED, SubStage.ERROR); volumeRemovalTask.requestTrackerLink = state.requestTrackerLink; Operation startPost = Operation .createPost(this, ContainerVolumeRemovalTaskService.FACTORY_LINK) .setBody(volumeRemovalTask) .setCompletion((o, e) -> { if (e != null) { failTask("Failure creating container volume removal task", e); return; } proceedTo(SubStage.REMOVING_VOLUMES); }); sendRequest(startPost); }
private void removeContainers(ContainerHostRemovalTaskState state, Set<String> containerSelfLinks) { // run a sub task for removing the containers ContainerRemovalTaskState containerRemovalTask = new ContainerRemovalTaskState(); containerRemovalTask.resourceLinks = containerSelfLinks; containerRemovalTask.removeOnly = true; containerRemovalTask.serviceTaskCallback = ServiceTaskCallback.create( getSelfLink(), TaskStage.STARTED, SubStage.REMOVED_CONTAINERS, TaskStage.STARTED, SubStage.ERROR); containerRemovalTask.requestTrackerLink = state.requestTrackerLink; Operation startPost = Operation .createPost(this, ContainerRemovalTaskFactoryService.SELF_LINK) .setBody(containerRemovalTask) .setCompletion((o, e) -> { if (e != null) { failTask("Failure creating container removal task", e); return; } proceedTo(SubStage.REMOVING_CONTAINERS); }); sendRequest(startPost); }
private void removeNetworks(ContainerHostRemovalTaskState state, Set<String> networkSelfLinks) { // run a sub task for removing the networks ContainerNetworkRemovalTaskState networkRemovalTask = new ContainerNetworkRemovalTaskState(); networkRemovalTask.resourceLinks = networkSelfLinks; networkRemovalTask.removeOnly = true; networkRemovalTask.serviceTaskCallback = ServiceTaskCallback.create( getSelfLink(), TaskStage.STARTED, SubStage.REMOVED_NETWORKS, TaskStage.STARTED, SubStage.ERROR); networkRemovalTask.requestTrackerLink = state.requestTrackerLink; Operation startPost = Operation .createPost(this, ContainerNetworkRemovalTaskService.FACTORY_LINK) .setBody(networkRemovalTask) .setCompletion((o, e) -> { if (e != null) { failTask("Failure creating container network removal task", e); return; } proceedTo(SubStage.REMOVING_NETWORKS); }); sendRequest(startPost); }