public static void main(String[] args) { try { OpenShiftClient client = new DefaultOpenShiftClient(); String namespace = client.getNamespace(); System.out.println("Watching BuildConfigs in namespace " + namespace); try (Watch watchable = client.buildConfigs().inNamespace(namespace).watch(new Watcher<BuildConfig>() { @Override public void eventReceived(Action action, BuildConfig resource) { System.out.println(">> Action: " + action + " on BuildConfig " + resource.getMetadata().getName() + " with version: " + resource.getApiVersion()); } @Override public void onClose(KubernetesClientException cause) { System.out.println("Watch Closed: " + cause); if (cause != null) { cause.printStackTrace(); } } })) { System.out.println("Created watchable " + watchable); } } catch (KubernetesClientException e) { System.out.println("Failed: " + e); e.printStackTrace(); } }
public static void main(String[] args) { try { OpenShiftClient client = new DefaultOpenShiftClient(); if (!client.supportsOpenShiftAPIGroup(OpenShiftAPIGroups.BUILD)) { System.out.println("WARNING this cluster does not support the API Group " + OpenShiftAPIGroups.BUILD); return; } BuildConfigList list = client.buildConfigs().list(); if (list == null) { System.out.println("ERROR no list returned!"); return; } List<BuildConfig> items = list.getItems(); for (BuildConfig item : items) { System.out.println("BuildConfig " + item.getMetadata().getName() + " has version: " + item.getApiVersion()); } } catch (KubernetesClientException e) { System.out.println("Failed: " + e); e.printStackTrace(); } }
@Override protected MixedOperation<BuildConfig, BuildConfigList, DoneableBuildConfig, BuildConfigResource<BuildConfig, DoneableBuildConfig, Void, Build>> operation() { return client.buildConfigs(); }
@Override protected void mocker(OpenShiftClient mockClient, MixedOperation mockCms) { when(mockClient.buildConfigs()).thenReturn(mockCms); }
protected void doGetBuildConfig(Exchange exchange, String operation) throws Exception { BuildConfig buildConfig = null; String buildConfigName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_BUILD_CONFIG_NAME, String.class); String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class); if (ObjectHelper.isEmpty(buildConfigName)) { LOG.error("Get a specific Build Config require specify a Build Config name"); throw new IllegalArgumentException("Get a specific Build Config require specify a Build Config name"); } if (ObjectHelper.isEmpty(namespaceName)) { LOG.error("Get a specific Build Config require specify a namespace name"); throw new IllegalArgumentException("Get a specific Build Config require specify a namespace name"); } buildConfig = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).buildConfigs() .inNamespace(namespaceName).withName(buildConfigName).get(); MessageHelper.copyHeaders(exchange.getIn(), exchange.getOut(), true); exchange.getOut().setBody(buildConfig); } }
protected void doList(Exchange exchange, String operation) throws Exception { BuildConfigList buildConfigsList = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class) .buildConfigs().inAnyNamespace().list(); exchange.getOut().setBody(buildConfigsList.getItems()); }
public void doCreateBuildConfig(BuildConfig entity, String namespace , String sourceName) { OpenShiftClient openShiftClient = getOpenShiftClient(); if (openShiftClient != null) { try { openShiftClient.buildConfigs().inNamespace(namespace).create(entity); } catch (Exception e) { onApplyError("Failed to create BuildConfig from " + sourceName + ". " + e, e); } } }
protected void doListBuildConfigsByLabels(Exchange exchange, String operation) throws Exception { BuildConfigList buildConfigsList = null; Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_BUILD_CONFIGS_LABELS, Map.class); String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class); if (!ObjectHelper.isEmpty(namespaceName)) { NonNamespaceOperation<BuildConfig, BuildConfigList, DoneableBuildConfig, BuildConfigResource<BuildConfig, DoneableBuildConfig, Void, Build>> buildConfigs; buildConfigs = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).buildConfigs() .inNamespace(namespaceName); for (Map.Entry<String, String> entry : labels.entrySet()) { buildConfigs.withLabel(entry.getKey(), entry.getValue()); } buildConfigsList = buildConfigs.list(); } else { FilterWatchListMultiDeletable<BuildConfig, BuildConfigList, Boolean, Watch, Watcher<BuildConfig>> buildConfigs; buildConfigs = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).buildConfigs().inAnyNamespace(); for (Map.Entry<String, String> entry : labels.entrySet()) { buildConfigs.withLabel(entry.getKey(), entry.getValue()); } buildConfigsList = buildConfigs.list(); } MessageHelper.copyHeaders(exchange.getIn(), exchange.getOut(), true); exchange.getOut().setBody(buildConfigsList.getItems()); }
public BuildConfig getBuildConfig() { BuildConfig bc = getOpenShiftClient().buildConfigs().inNamespace(namespace).withName(name).get(); if (bc != null && bc.getMetadata().getUid().equals(uid)) { return bc; } return null; }
.done()); log("Created build config", client.buildConfigs().inNamespace("thisisatest").createNew() .withNewMetadata() .withName("custom-build-config") .done()); Build build = client.buildConfigs().inNamespace("thisisatest").withName("custom-build-config").instantiate(new BuildRequestBuilder() .withNewMetadata().withName("custom-build-config").endMetadata() .build()); log("Build:", build.getMetadata().getName()); client.buildConfigs().inNamespace("thisisatest").withName("custom-build-config") .withSecret("secret101") .withType("github")
private void logBuildFailedDetails(OpenShiftClient client, String buildName) { try { BuildConfig build = client.buildConfigs().withName(buildName).get(); ObjectReference ref = build.getSpec().getStrategy().getSourceStrategy().getFrom(); String kind = ref.getKind(); String name = ref.getName(); if ("DockerImage".equals(kind)) { log.error("Please, ensure that the Docker image '%s' exists and is accessible by OpenShift", name); } else if ("ImageStreamTag".equals(kind)) { String namespace = ref.getNamespace(); String namespaceInfo = "current"; String namespaceParams = ""; if (namespace != null && !namespace.isEmpty()) { namespaceInfo = "'" + namespace + "'"; namespaceParams = " -n " + namespace; } log.error("Please, ensure that the ImageStream Tag '%s' exists in the %s namespace (with 'oc get is%s')", name, namespaceInfo, namespaceParams); } } catch (Exception ex) { log.error("Unable to get detailed information from the BuildServiceConfig: " + ex.getMessage()); } }
@Override public void onDeleted(Item item) { super.onDeleted(item); if (item instanceof WorkflowJob) { WorkflowJob job = (WorkflowJob) item; if (job.getProperty(BuildConfigProjectProperty.class) != null && StringUtils.isNotBlank(job.getProperty(BuildConfigProjectProperty.class).getNamespace()) && StringUtils.isNotBlank(job.getProperty(BuildConfigProjectProperty.class).getName())) { NamespaceName buildName = OpenShiftUtils.buildConfigNameFromJenkinsJobName(job.getName(), defaultNamespace); logger.info("Deleting BuildConfig " + buildName); String namespace = buildName.getNamespace(); String buildConfigName = buildName.getName(); try { getOpenShiftClient().buildConfigs().inNamespace(namespace).withName(buildConfigName).delete(); } catch (Exception e) { logger.log(Level.WARNING, "Failed to delete BuildConfig in namespace: " + namespace + " for name: " + buildConfigName); } } } }
private Build startBuild(OpenShiftClient client, File dockerTar, String buildName) { log.info("Starting Build %s", buildName); try { return client.buildConfigs().withName(buildName) .instantiateBinary() .fromFile(dockerTar); } catch (KubernetesClientException exp) { Status status = exp.getStatus(); if (status != null) { log.error("OpenShift Error: [%d %s] [%s] %s", status.getCode(), status.getStatus(), status.getReason(), status.getMessage()); } if (exp.getCause() instanceof IOException && exp.getCause().getMessage().contains("Stream Closed")) { log.error("Build for %s failed: %s", buildName, exp.getCause().getMessage()); logBuildFailedDetails(client, buildName); } throw exp; } }
public static Job getJobFromBuild(Build build) { String buildConfigName = build.getStatus().getConfig().getName(); if (StringUtils.isEmpty(buildConfigName)) { return null; } BuildConfig buildConfig = getOpenShiftClient().buildConfigs().inNamespace(build.getMetadata().getNamespace()).withName(buildConfigName).get(); if (buildConfig == null) { return null; } return BuildTrigger.DESCRIPTOR.getJobFromBuildConfigUid(buildConfig.getMetadata().getUid()); } }
private String updateBuildConfig(OpenShiftClient client, String buildName, BuildStrategy buildStrategy, BuildOutput buildOutput, BuildConfigSpec spec) { // lets check if the strategy or output has changed and if so lets update the BC // e.g. the S2I builder image or the output tag and if (!Objects.equals(buildStrategy, spec.getStrategy()) || !Objects.equals(buildOutput, spec.getOutput())) { client.buildConfigs().withName(buildName).edit() .editSpec() .withStrategy(buildStrategy) .withOutput(buildOutput) .endSpec() .done(); log.info("Updating BuildServiceConfig %s for %s strategy", buildName, buildStrategy.getType()); } else { log.info("Using BuildServiceConfig %s for %s strategy", buildName, buildStrategy.getType()); } return buildName; }
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(); } }
@Override public boolean shouldSchedule(Queue.Task p, List<Action> actions) { if (p instanceof WorkflowJob && !isOpenShiftBuildCause(actions)) { WorkflowJob wj = (WorkflowJob) p; BuildConfigProjectProperty buildConfigProjectProperty = wj.getProperty(BuildConfigProjectProperty.class); if (buildConfigProjectProperty != null && StringUtils.isNotBlank(buildConfigProjectProperty.getNamespace()) && StringUtils.isNotBlank(buildConfigProjectProperty.getName())) { getOpenShiftClient().buildConfigs() .inNamespace(buildConfigProjectProperty.getNamespace()).withName(buildConfigProjectProperty.getName()) .instantiate( new BuildRequestBuilder() .withNewMetadata().withName(buildConfigProjectProperty.getName()).endMetadata() .build() ); return false; } } return true; }
private void upsertBuildConfigForJob(WorkflowJob job) { BuildConfigProjectProperty buildConfigProjectProperty = job.getProperty(BuildConfigProjectProperty.class); if (buildConfigProjectProperty == null || buildConfigProjectProperty.getNamespace() == null || buildConfigProjectProperty.getName() == null || buildConfigProjectProperty.getUid() == null) { return; } BuildConfig jobBuildConfig = buildConfigProjectProperty.getBuildConfig(); if (jobBuildConfig == null) { logger.log(Level.WARNING, "Failed to find BuildConfig in namespace: " + buildConfigProjectProperty.getNamespace() + " for name: " + buildConfigProjectProperty.getName()); return; } updateBuildConfigFromJob(job, jobBuildConfig); try { getOpenShiftClient().buildConfigs().inNamespace(jobBuildConfig.getMetadata().getNamespace()).withName(jobBuildConfig.getMetadata().getName()).replace(jobBuildConfig); } catch (Exception e) { logger.log(Level.WARNING, "Failed to update BuildConfig: " + NamespaceName.create(jobBuildConfig) + ". " + e, e); } } }
@Override protected boolean handleResourceDelete(String resourceType, String resourceName, String namespace) { if (super.handleResourceDelete(resourceType, resourceName, namespace)) { return true; } try { switch (resourceType) { case OpenShiftResource.DEPLOYMENT_CONFIG: return client.deploymentConfigs().inNamespace(namespace).withName(resourceName).delete(); case OpenShiftResource.PROJECT: return client.projects().withName(resourceName).delete(); case OpenShiftResource.TEMPLATE: return client.templates().inNamespace(namespace).withName(resourceName).delete(); case OpenShiftResource.BUILD_CONFIG: return client.buildConfigs().inNamespace(namespace).withName(resourceName).delete(); } } catch (KubernetesClientException kce) { LOG.warn("Error deleting resource {}: {}", resourceName, kce); } return false; }
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(); }; }