private String createSubscriptionName(SubscribeRequest request, String namespace, String prefix) { Set<String> configMapNames = new TreeSet<>(); ConfigMapList configMapList = kubernetesClient.configMaps().inNamespace(namespace).list(); List<ConfigMap> list = notNullList(configMapList.getItems()); for (ConfigMap configMap : list) { configMapNames.add(KubernetesHelper.getName(configMap)); } int idx = 0; while (true) { String name = prefix + (++idx); if (!configMapNames.contains(name)) { return name; } } }
public static GitlabClient createGitRepoClient(KubernetesClient kubernetes, String userName, String password) { if (Strings.isNullOrBlank(userName)) { userName = Systems.getEnvVarOrSystemProperty(JENKINS_GOGS_USER, "gogsadmin"); } if (Strings.isNullOrBlank(password)) { password = Systems.getEnvVarOrSystemProperty(JENKINS_GOGS_PASSWORD, "RedHat$1"); } String namespace = KubernetesHelper.defaultNamespace(); String address; try { address = KubernetesHelper.getServiceURL(kubernetes, ServiceNames.GITLAB, namespace, "http", true); if (Strings.isNullOrBlank(address)) { LOG.warn("No Gitlab service could be found in kubernetes " + namespace + " on address: " + kubernetes.getMasterUrl()); return null; } } catch (IllegalArgumentException e) { LOG.warn("No Gitlab service could be found in kubernetes " + namespace + " on address: " + kubernetes.getMasterUrl()); return null; } LOG.info("Logging into Gitlab at " + address + " as user " + userName); return new GitlabClient(address, userName, password); } }
public static KubernetesNames loadFile(File kubernetesJsonOrYamlFile) throws IOException { KubernetesNames answer = new KubernetesNames(); if (kubernetesJsonOrYamlFile.isFile() && kubernetesJsonOrYamlFile.exists()) { Object value = KubernetesHelper.loadJson(kubernetesJsonOrYamlFile); if (value != null) { answer.addNamesFromDTO(value); } } return answer; }
/** * Returns the service URL of the given service name */ @Override public String getServiceUrl(String serviceName) { // TODO we could cache these and update them in the background! Map<String, Service> serviceMap = KubernetesHelper.getServiceMap(kubernetes); Service service = serviceMap.get(serviceName); return KubernetesHelper.getServiceURL(service); }
private void addDeploymentVersion(Map<String, String> deploymentVersions, HasMetadata resource) { String name = KubernetesHelper.getName(resource); String version = KubernetesHelper.getLabels(resource).get("version"); // TODO if there is no version label could we find it from somewhere else? if (Strings.isNotBlank(version)) { deploymentVersions.put(name, version); } else { listener.getLogger().println("No version label for " + KubernetesHelper.getKind(resource) + " " + KubernetesHelper.getName(resource) + " in namespace " + KubernetesHelper.getNamespace(resource)); } }
public AppServiceSummaryDTO(Service service) { this.id = KubernetesHelper.getId(service); this.name = KubernetesHelper.getName(service); this.namespace = service.getNamespace(); this.portalIP = KubernetesHelper.getPortalIP(service); this.port = KubernetesHelper.getPort(service); this.labels = service.getLabels(); }
dto = KubernetesHelper.loadJson(resources); } else { dto = KubernetesHelper.loadYaml(resources.getBytes(), KubernetesResource.class); entities.addAll(KubernetesHelper.toItemList(dto)); listener.getLogger().println("Applying " + KubernetesHelper.getKind(entity) + " name: " + KubernetesHelper.getKind(entity) + " data: " + entity); if (entity instanceof Pod) { Pod pod = (Pod) entity; String serviceName = KubernetesHelper.getName(service); String url = KubernetesHelper.getServiceURL(kubernetes, serviceName, environment, "http", true); if (url != null && !url.isEmpty()) { listener.getLogger().println("Service " + serviceName + " in environment " + environmentName + " namespace " + environment + " is at URL: " + url); String yaml = KubernetesHelper.toYaml(environmentRollout); OpenShiftClient oClient = openShiftClient(); BuildResource<Build, DoneableBuild, String, LogWatch> resource = oClient.builds().inNamespace(this.buildConfigNamespace).withName(buildName); try { Build build = resource.get(); listener.getLogger().println("Failed to annotate Build " + buildName + " in namespace " + this.buildConfigNamespace + " due to not found!"); } else { Map<String, String> annotations = KubernetesHelper.getOrCreateAnnotations(build); annotations.put("environment.services.fabric8.io/" + environment, yaml); String version = deploymentVersions.get(this.buildConfigName); if (Strings.isNotBlank(version)) { annotations.put("fabric8.io/version", version); } else {
return; if (client.isAdaptable(OpenShiftClient.class)){ OpenShiftClient oClient = client.adapt(OpenShiftClient.class); List<DeploymentConfig> deploymentConfigs = oClient.deploymentConfigs().inNamespace(session.getNamespace()).list().getItems(); if (deploymentConfigs == null) { throw new MultiException("No deployment configs found in namespace" + session.getNamespace()); session.getLogger().info("Deployment config:" + KubernetesHelper.getName(deploymentConfig)); List<Deployment> deployments = client.extensions().deployments().inNamespace(session.getNamespace()).list().getItems(); if (deployments == null) { throw new MultiException("No deployments found in namespace" + session.getNamespace()); session.getLogger().info("Deployment:" + KubernetesHelper.getName(deployment)); List<Pod> pods = client.pods().inNamespace(session.getNamespace()).list().getItems(); if (pods == null) { throw new MultiException("No pods found in namespace" + session.getNamespace()); session.getLogger().info("Pod:" + KubernetesHelper.getName(pod) + " Status:" + pod.getStatus()); session.getLogger().info("Service:" + KubernetesHelper.getName(service) + " IP:" + getPortalIP(service) + " Port:" + getPorts(service));
try { KubernetesClient kubernetes = getKubernetes(); String ns = kubernetes.getNamespace(); if (Strings.isNullOrBlank(ns)) { ns = getNamespace(); Service service = kubernetes.services().inNamespace(ns).withName(serviceName).get(); return service != null ? KubernetesHelper.getServiceURL(kubernetes, serviceName, ns, protocol, true) : null; } catch (Throwable e) {
protected void killPod() { String namespace = getNamespace(); PodList pods = kubernetes.pods().inNamespace(namespace).list(); List<Pod> targets = new ArrayList<>(); if (pods != null) { message = "No matching pods available to kill. Boo!"; } else { String name = KubernetesHelper.getName(pod); try { kubernetes.pods().inNamespace(namespace).withName(KubernetesHelper.getName(pod)).delete(); message = "Chaos Monkey killed pod " + name + " in namespace " + namespace; killed = true;
@Override public Boolean call() throws Exception { boolean result = true; List<Pod> pods = notNullList(kubernetesClient.pods().inNamespace(session.getNamespace()).list().getItems()); if (!KubernetesHelper.isPodReady(pod)) { PodStatus podStatus = pod.getStatus(); int restartCount = 0; String name = KubernetesHelper.getName(pod); File yamlFile = new File(session.getBaseDir(), "target/test-pod-status/" + name + ".yml"); yamlFile.getParentFile().mkdirs(); try { KubernetesHelper.saveYaml(pod, yamlFile); } catch (IOException e) { session.getLogger().warn("Failed to write " + yamlFile + ". " + e); if (KubernetesHelper.isPodRunning(pod)) { List<Container> containers = pod.getSpec().getContainers(); for (Container container : containers) { File logFile = LogHelpers.getLogFileName(session.getBaseDir(), name, container, restartCount); String log = kubernetesClient.pods().inNamespace(session.getNamespace()).withName(name).inContainer(container.getName()).getLog(); IOHelpers.writeFully(logFile, log);
if (entity instanceof Pod) { Pod pod = (Pod) entity; log.status("Applying pod:" + getName(pod)); Set<Secret> secrets = generateSecrets(client, session, pod.getMetadata()); String serviceAccountName = pod.getSpec().getServiceAccountName(); if (Strings.isNotBlank(serviceAccountName)) { generateServiceAccount(client, session, secrets, serviceAccountName); controller.applyPod(pod, session.getId()); conditions.put(1, sessionPodsReady); } else if (entity instanceof Service) { Service service = (Service) entity; String serviceName = getName(service); log.status("Applying service:" + serviceName); controller.applyService(service, session.getId()); conditions.put(2, servicesReady); log.status("Applying replication controller:" + getName(replicationController)); Set<Secret> secrets = generateSecrets(client, session, replicationController.getSpec().getTemplate().getMetadata()); String serviceAccountName = replicationController.getSpec().getTemplate().getSpec().getServiceAccountName(); ObjectMeta metadata = KubernetesHelper.getOrCreateMetadata(oc); String name = metadata.getName(); if (isOpenshift) { OpenShiftClient openShiftClient = client.adapt(OpenShiftClient.class); OAuthClient current = openShiftClient.oAuthClients().withName(name).get(); boolean create = false; if (current == null) {
String serviceStatus = null; boolean result = false; String sid = getName(s); String namespace = session.getNamespace(); Endpoints endpoints = kubernetesClient.endpoints().inNamespace(namespace).withName(sid).get(); ServiceSpec spec = s.getSpec(); if (endpoints != null && spec != null) {
new ObjectReferenceBuilder() .withNamespace(session.getNamespace()) .withName(KubernetesHelper.getName(secret)) .build() ); SecurityContextConstraints securityContextConstraints = client.securityContextConstraints().withName(session.getNamespace()).get(); if (securityContextConstraints == null) { client.securityContextConstraints().createNew() .withNewMetadata() .withName(session.getNamespace()) ServiceAccount serviceAccount = client.serviceAccounts() .inNamespace(session.getNamespace()) .withName(serviceAccountName) .get(); client.serviceAccounts().inNamespace(session.getNamespace()).createNew() .withNewMetadata() .withName(serviceAccountName) .done(); } else { client.serviceAccounts().inNamespace(session.getNamespace()) .withName(serviceAccountName) .replace(new ServiceAccountBuilder(serviceAccount)
Map<String, String> annotations = KubernetesHelper.getOrCreateAnnotations(resource); Set<Map.Entry<String, String>> entries = mapEnvVarToAnnotation.entrySet(); for (Map.Entry<String, String> entry : entries) { String envVar = entry.getKey(); String annotation = entry.getValue(); if (Strings.isNotBlank(envVar) && Strings.isNotBlank(annotation)) { String value = Systems.getEnvVarOrSystemProperty(envVar); if (Strings.isNullOrBlank(value)) { value = tryDefaultAnnotationEnvVar(envVar); String oldValue = annotations.get(annotation); if (Strings.isNotBlank(oldValue)) { listener.getLogger().println("Not adding annotation `" + annotation + "` to " + KubernetesHelper.getKind(resource) + " " + KubernetesHelper.getName(resource) + " with value `" + value + "` as there is already an annotation value of `" + oldValue + "`"); } else { annotations.put(annotation, value);
public SubscribeResponse subscribe(SubscribeRequest request) throws InternalException { String namespace = request.getNamespace(); Objects.notNull(namespace, "namespace"); ConfigMap configMap = createSubscriptionResource(request, namespace); kubernetesClient.configMaps().inNamespace(namespace).create(configMap); return new SubscribeResponse(namespace, KubernetesHelper.getName(configMap)); }
configuration.environmentInitEnabled = getBooleanProperty(ENVIRONMENT_INIT_ENABLED, map, true); configuration.environmentConfigUrl = getKubernetesConfigurationUrl(map); configuration.environmentDependencies = Strings.splitAndTrimAsList(getStringProperty(ENVIRONMENT_DEPENDENCIES, map, ""), "\\s+"); configuration.waitForServiceList = Strings.splitAndTrimAsList(getStringProperty(WAIT_FOR_SERVICE_LIST, map, ""), "\\s+"); configuration.waitForServiceConnectionEnabled = getBooleanProperty(WAIT_FOR_SERVICE_CONNECTION_ENABLED, map, DEFAULT_WAIT_FOR_SERVICE_CONNECTION_ENABLED); configuration.waitForServiceConnectionTimeout = getLongProperty(WAIT_FOR_SERVICE_CONNECTION_TIMEOUT, map, DEFAULT_NAMESPACE_CLEANUP_TIMEOUT); if (Strings.isNullOrBlank(defaultDevelopNamespace)) { defaultDevelopNamespace = kubernetesClient.getNamespace(); String namespace = Strings.isNotBlank(providedNamespace) ? providedNamespace : developNamespace;; if (Strings.isNullOrBlank(namespace)) { namespace = kubernetesClient.getNamespace(); if (Strings.isNullOrBlank(namespace)) { namespace = KubernetesHelper.defaultNamespace();
/** * Returns the URL to the fabric8 console */ public static String getBuildConfigConsoleURL(KubernetesClient kubernetes, String consoleNamespace, BuildConfig buildConfig) { String name = getName(buildConfig); String namespace = getNamespace(buildConfig); if (Strings.isNullOrBlank(namespace)) { namespace = consoleNamespace; } String consoleURL = getFabric8ConsoleServiceUrl(kubernetes, namespace); if (Strings.isNotBlank(consoleURL)) { if (Strings.isNotBlank(name)) { return URLUtils.pathJoin(consoleURL, "workspaces", namespace, "projects",name); } return URLUtils.pathJoin(consoleURL, "workspaces", namespace); } return null; }
protected void replicationControllerChanged(ReplicationController entity, boolean remove) { if (remove) { String id = getName(entity); if (Strings.isNotBlank(id)) { memoryModel.deleteReplicationController(id, KubernetesHelper.getNamespace(entity)); replicationControllerListeners.entityDeleted(id, entity); } } else { String id = memoryModel.getOrCreateId(getName(entity), NodeHelper.KIND_REPLICATION_CONTROLLER); if (entity.getMetadata().getUid() == null) { entity.getMetadata().setUid(getNamespace() + '/' + id); } memoryModel.updateReplicationController(id, entity); replicationControllerListeners.entityChanged(id, entity); } }
private String getDefaultServiceName(Service defaultService) { String defaultServiceName = KubernetesHelper.getName(defaultService); if (Strings.isNullOrBlank(defaultServiceName)) { defaultServiceName = getProject().getArtifactId(); } return defaultServiceName; }