public static boolean isOpenShiftClient(KubernetesClient kubernetes) { return asOpenShiftClient(kubernetes) != null; } }
public boolean isOpenShift(Logger log) { try { return this.client == null ? OpenshiftHelper.isOpenShift(createKubernetesClient()) : OpenshiftHelper.isOpenShift(this.client); } catch (KubernetesClientException exp) { Throwable cause = exp.getCause(); String prefix = cause instanceof UnknownHostException ? "Unknown host " : ""; log.warn("Cannot access cluster for detecting mode: %s%s", prefix, cause != null ? cause.getMessage() : exp.getMessage()); } return false; }
public Object processTemplate(Template entity, String sourceName) { try { return OpenshiftHelper.processTemplatesLocally(entity, false); } catch (IOException e) { onApplyError("Failed to process template " + sourceName + ". " + e + ". " + entity, e); return null; } }
public static boolean isFinished(String status) { return isCompleted(status) || isFailed(status) || isCancelled(status); }
if (OpenshiftHelper.isFinished(KubernetesResourceUtil.getBuildStatusPhase(lastBuild))) { log.debug("Build %s is already finished", buildName); buildHolder.set(lastBuild); if (OpenshiftHelper.isFailed(status) || OpenshiftHelper.isCancelled(status)) { throw new MojoExecutionException("OpenShift Build " + buildName + " failed: " + KubernetesResourceUtil.getBuildStatusReason(build)); if (!OpenshiftHelper.isFinished(status)) { log.warn("Could not wait for the completion of build %s. It may be may be still running (status=%s)", buildName, status); } else {
public static Template combineTemplates(Template firstTemplate, Template template) { List<HasMetadata> objects = template.getObjects(); if (objects != null) { for (HasMetadata object : objects) { addTemplateObject(firstTemplate, object); } } List<Parameter> parameters = firstTemplate.getParameters(); if (parameters == null) { parameters = new ArrayList<>(); firstTemplate.setParameters(parameters); } combineParameters(parameters, template.getParameters()); String name = KubernetesHelper.getName(template); if (StringUtils.isNotBlank(name)) { // lets merge all the fabric8 annotations using the template id qualifier as a postfix Map<String, String> annotations = KubernetesHelper.getOrCreateAnnotations(firstTemplate); Map<String, String> otherAnnotations = KubernetesHelper.getOrCreateAnnotations(template); Set<Map.Entry<String, String>> entries = otherAnnotations.entrySet(); for (Map.Entry<String, String> entry : entries) { String key = entry.getKey(); String value = entry.getValue(); if (!annotations.containsKey(key)) { annotations.put(key, value); } } } return firstTemplate; }
private Template extractAndRemoveTemplates(List<HasMetadata> items) { Template extractedTemplate = null; for (HasMetadata item : new ArrayList<>(items)) { if (item instanceof Template && !KubernetesResourceUtil.isAppCatalogResource(item)) { Template template = (Template) item; if (extractedTemplate == null) { extractedTemplate = template; } else { extractedTemplate = OpenshiftHelper.combineTemplates(extractedTemplate, template); } items.remove(item); } } if (extractedTemplate != null) { extractedTemplate.setObjects(items); } return extractedTemplate; }
@Override public void eventReceived(Action action, Build build) { buildHolder.set(build); String status = KubernetesResourceUtil.getBuildStatusPhase(build); log.verbose("BuildWatch: Received event %s , build status: %s", action, build.getStatus()); if (!lastStatus.equals(status)) { lastStatus = status; log.verbose("Build %s status: %s", buildName, status); } if (OpenshiftHelper.isFinished(status)) { latch.countDown(); } }
public OpenShiftClient getOpenShiftClient() { return OpenshiftHelper.asOpenShiftClient(kubernetesClient); }
@Override protected synchronized void executeInternal(ServiceHub hub) throws MojoExecutionException { this.hub = hub; URL masterUrl = kubernetes.getMasterUrl(); KubernetesResourceUtil.validateKubernetesMasterUrl(masterUrl); File manifest; boolean isOpenshift = OpenshiftHelper.isOpenShift(kubernetes); if (isOpenshift) { manifest = openshiftManifest; } else { manifest = kubernetesManifest; } try { Set<HasMetadata> resources = KubernetesResourceUtil.loadResources(manifest); WatcherContext context = getWatcherContext(); WatcherManager.watch(getResolvedImages(), resources, context); } catch (KubernetesClientException ex) { KubernetesResourceUtil.handleKubernetesClientException(ex, this.log); } catch (Exception ex) { throw new MojoExecutionException("An error has occurred while while trying to watch the resources", ex); } }
private KubernetesList replaceTemplateExpressions(KubernetesList kubernetesResources, Template template) throws MojoExecutionException { Template customTemplate = createTemplateWithObjects(kubernetesResources, template); if (customTemplate != null) { try { return OpenshiftHelper.processTemplatesLocally(customTemplate, false); } catch (IOException e) { throw new MojoExecutionException("Failed to replace template expressions in kubernetes manifest: " + e, e); } } return kubernetesResources; }
public static void deleteEntities(KubernetesClient kubernetes, String namespace, Set<HasMetadata> entities, String s2iBuildNameSuffix, Logger log) { List<HasMetadata> list = new ArrayList<>(entities); // For OpenShift cluster, also delete s2i buildconfig OpenShiftClient openshiftClient = OpenshiftHelper.asOpenShiftClient(kubernetes); if (openshiftClient != null) { for (HasMetadata entity : list) { if ("ImageStream".equals(KubernetesHelper.getKind(entity))) { ImageName imageName = new ImageName(entity.getMetadata().getName()); String buildName = getS2IBuildName(imageName, s2iBuildNameSuffix); log.info("Deleting resource BuildConfig " + namespace + "/" + buildName); openshiftClient.buildConfigs().inNamespace(namespace).withName(buildName).delete(); } } } // lets delete in reverse order Collections.reverse(list); for (HasMetadata entity : list) { log.info("Deleting resource " + KubernetesHelper.getKind(entity) + " " + namespace + "/" + KubernetesHelper.getName(entity)); kubernetes.resource(entity).inNamespace(namespace).cascading(true).delete(); } }
if (OpenshiftHelper.isOpenShift(kubernetes)) { manifest = openshiftManifest; } else { if (OpenshiftHelper.isOpenShift(kubernetes)) { clusterKind = "OpenShift"; applyService.setRollingUpgradePreserveScale(isRollingUpgradePreserveScale()); boolean openShift = OpenshiftHelper.isOpenShift(kubernetes); if (openShift) { getLog().info("OpenShift platform detected");
public static Set<HasMetadata> loadResources(File manifest) throws IOException { Object dto = ResourceUtil.load(manifest, KubernetesResource.class); if (dto == null) { throw new IllegalStateException("Cannot load kubernetes manifest " + manifest); } if (dto instanceof Template) { Template template = (Template) dto; dto = OpenshiftHelper.processTemplatesLocally(template, false); } Set<HasMetadata> entities = new TreeSet<>(new HasMetadataComparator()); entities.addAll(KubernetesHelper.toItemList(dto)); return entities; }
private static EntityPatcher<ImageStream> isPatcher() { return (KubernetesClient client, String namespace, ImageStream newObj, ImageStream oldObj) -> { if (UserConfigurationCompare.configEqual(newObj, oldObj)) { return oldObj; } OpenShiftClient openShiftClient = OpenshiftHelper.asOpenShiftClient(client); if (openShiftClient == null) { throw new IllegalArgumentException("ImageStream can only be patched when connected to an OpenShift cluster"); } DoneableImageStream entity = openShiftClient.imageStreams() .inNamespace(namespace) .withName(oldObj.getMetadata().getName()) .edit(); if (!UserConfigurationCompare.configEqual(newObj.getMetadata(), oldObj.getMetadata())) { entity.withMetadata(newObj.getMetadata()); } if(!UserConfigurationCompare.configEqual(newObj.getSpec(), oldObj.getSpec())) { entity.withSpec(newObj.getSpec()); } return entity.done(); }; }
if (OpenshiftHelper.isOpenShift(client)) { OpenShiftClient openShiftClient = client.adapt(OpenShiftClient.class); Route route = openShiftClient.routes().inNamespace(actualNamespace).withName(serviceName).get();
private static EntityPatcher<BuildConfig> bcPatcher() { return (KubernetesClient client, String namespace, BuildConfig newObj, BuildConfig oldObj) -> { if (UserConfigurationCompare.configEqual(newObj, oldObj)) { return oldObj; } OpenShiftClient openShiftClient = OpenshiftHelper.asOpenShiftClient(client); if (openShiftClient == null) { throw new IllegalArgumentException("BuildConfig can only be patched when connected to an OpenShift cluster"); } DoneableBuildConfig entity = openShiftClient.buildConfigs() .inNamespace(namespace) .withName(oldObj.getMetadata().getName()) .edit(); if (!UserConfigurationCompare.configEqual(newObj.getMetadata(), oldObj.getMetadata())) { entity.withMetadata(newObj.getMetadata()); } if(!UserConfigurationCompare.configEqual(newObj.getSpec(), oldObj.getSpec())) { entity.withSpec(newObj.getSpec()); } return entity.done(); }; }
new PluginServiceFactory<>(watcherCtx); boolean isOpenshift = OpenshiftHelper.isOpenShift(watcherCtx.getKubernetesClient()); PlatformMode mode = isOpenshift ? PlatformMode.openshift : PlatformMode.kubernetes;
public static void resizeApp(KubernetesClient kubernetes, String namespace, Set<HasMetadata> entities, int replicas, Logger log) { for (HasMetadata entity : entities) { String name = KubernetesHelper.getName(entity); Scaleable<?> scalable = null; if (entity instanceof Deployment) { scalable = kubernetes.extensions().deployments().inNamespace(namespace).withName(name); } else if (entity instanceof ReplicaSet) { scalable = kubernetes.extensions().replicaSets().inNamespace(namespace).withName(name); } else if (entity instanceof ReplicationController) { scalable = kubernetes.replicationControllers().inNamespace(namespace).withName(name); } else if (entity instanceof DeploymentConfig) { OpenShiftClient openshiftClient = OpenshiftHelper.asOpenShiftClient(kubernetes); if (openshiftClient == null) { log.warn("Ignoring DeploymentConfig %s as not connected to an OpenShift cluster", name); continue; } scalable = openshiftClient.deploymentConfigs().inNamespace(namespace).withName(name); } if (scalable != null) { log.info("Scaling " + KubernetesHelper.getKind(entity) + " " + namespace + "/" + name + " to replicas: " + replicas); scalable.scale(replicas, true); } } }
if (spec != null) { if (updateImageName(entity, spec.getTemplate(), imagePrefix, imageName)) { OpenShiftClient openshiftClient = OpenshiftHelper.asOpenShiftClient(kubernetes); if (openshiftClient == null) { log.warn("Ignoring DeploymentConfig %s as not connected to an OpenShift cluster", name);