protected String addPortToIP(String podIP, Integer containerPort, String portNumberOrName) { if (containerPort != null) { if (containerPort > 0 && containerPort != 80) { return podIP + ":" + containerPort; } } if (Strings.isNotBlank(portNumberOrName)) { return podIP + ":" + portNumberOrName; } else { return podIP; } }
protected void extractOrganisationAndUserFromUrl() { if (Strings.isNotBlank(url)) { String text = Strings.stripSuffix(url, "./"); text = Strings.stripSuffix(text, ".git"); text = Strings.stripSuffix(text, "/"); String[] split = text.split("/"); if (split != null && split.length > 1) { if (Strings.isNullOrBlank(user)) { user = split[split.length - 2]; } if (Strings.isNullOrBlank(repoName)) { repoName = split[split.length - 1]; } } } }
private static String getOrBlank(List<String> values) { if (values != null && values.size() > 0) { return Strings.join(values, ", "); } return ""; }
protected static String stripSlashesAndGit(String path) { path = Strings.stripPrefix(path, "/"); path = Strings.stripPrefix(path, "/"); path = Strings.stripSuffix(path, "/"); path = Strings.stripSuffix(path, ".git"); return path; }
private static void configureProtocolHandlers(Map<String, String> conf) { Set<String> handlers = new LinkedHashSet<>(); handlers.addAll(Strings.splitAndTrimAsList(System.getProperty(JAVA_PROTOCOL_HANDLER, ""), " ")); handlers.addAll(Strings.splitAndTrimAsList(conf.containsKey(PROTOCOL_HANDLERS) ? conf.get(PROTOCOL_HANDLERS) : DEFAULT_MAVEN_PROTOCOL_HANDLER, " ")); System.setProperty(JAVA_PROTOCOL_HANDLER, Strings.join(handlers, " ")); } }
dto = KubernetesHelper.loadJson(resources); } else { dto = KubernetesHelper.loadYaml(resources.getBytes(), KubernetesResource.class); entities.addAll(KubernetesHelper.toItemList(dto)); if (Strings.isNotBlank(registry)) { listener.getLogger().println("Adapting resources to use pull images from registry: " + registry); addRegistryToImageNameIfNotPresent(entities, registry); answer = kubernetes.resourceList(items).accept(new TypedVisitor<ObjectMetaBuilder>() { 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 { editMetadata().addToAnnotations("environment.services.fabric8.io/" + environment, yaml); String version = deploymentVersions.get(this.buildConfigName); if (Strings.isNotBlank(version)) { builder.addToAnnotations("fabric8.io/version", version); } else {
private String getRegistry() { if (Strings.isNullOrBlank(step.getRegistry())) { // lets try and find an external docker registry in the users home namespace pipeline config KubernetesClient client = getKubernetes(); ConfigMap cm = client.configMaps().inNamespace(this.buildConfigNamespace).withName(Constants.USERS_PIPELINE_CONFIGMAP_NAME).get(); if (cm != null){ Map<String, String> data = cm.getData(); if (data != null){ String rs = data.get(Constants.EXTERNAL_DOCKER_REGISTRY_URL); if (Strings.isNotBlank(rs)){ return rs; } } } // fall back to namespace env vars to support old fabric8 version if (isOpenShift() && openShiftClient().supportsOpenShiftAPIGroup(OpenShiftAPIGroups.IMAGE)) { if (Strings.isNotBlank(env.get(Constants.OPENSHIFT_DOCKER_REGISTRY_SERVICE_HOST))){ return env.get(Constants.OPENSHIFT_DOCKER_REGISTRY_SERVICE_HOST) + ":" + env.get(Constants.OPENSHIFT_DOCKER_REGISTRY_SERVICE_PORT); } } else if (Strings.isNotBlank(env.get(Constants.FABRIC8_DOCKER_REGISTRY_SERVICE_HOST))) { return env.get(Constants.FABRIC8_DOCKER_REGISTRY_SERVICE_HOST) + ":" + env.get(Constants.FABRIC8_DOCKER_REGISTRY_SERVICE_PORT); } return null; } else { return step.getRegistry(); } }
String replicationControllerName = getReplicationControllerName(qualifiers); if (Strings.isNotBlank(serviceName)) { Service service = client.services().inNamespace(session.getNamespace()).withName(serviceName).get(); if (service != null) { return jolokiaClients.clientForService(service); if (Strings.isNotBlank(podName)) { Pod pod = client.pods().inNamespace(session.getNamespace()).withName(serviceName).get(); if (pod != null) { return jolokiaClients.clientForPod(pod); if (Strings.isNotBlank(replicationControllerName)) { ReplicationController replicationController = client.replicationControllers().inNamespace(session.getNamespace()).withName(replicationControllerName).get(); if (replicationController != null) { return jolokiaClients.clientForReplicationController(replicationController);
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) {
private String loadKubernetesExposeControllerCommandLine(KubernetesClient kubernetes, String commands) throws Exception { String namespace = System.getenv("KUBERNETES_NAMESPACE"); if (Strings.isNullOrBlank(namespace)) { namespace = KubernetesHelper.getNamespace(kubernetes); } ConfigMap configMap = kubernetes.configMaps().inNamespace(namespace).withName("exposecontroller").get(); if (configMap == null) { listener.getLogger().println("WARNING: no ConfigMap in namespace " + namespace + " called: exposecontroller so cannot run exposecontroller to expose Service URLs"); return null; } String configYaml = null; Map<String, String> data = configMap.getData(); if (data != null) { configYaml = data.get("config.yml"); } if (Strings.isNullOrBlank(configYaml)) { throw new Exception("ConfigMap " + namespace + "/exposecontroller does not have a `config.yml` data entry"); } Map map; try { map = KubernetesHelper.loadYaml(configYaml, Map.class); } catch (IOException e) { throw new Exception("Could not parse YAML in ConfigMap " + namespace + "/exposecontroller entry `config.yml`: " + e, e); } StringBuilder builder = new StringBuilder(commands); appendCliArgument(builder, "--http", map.get("http")); appendCliArgument(builder, "--exposer", map.get("exposer")); appendCliArgument(builder, "--domain", map.get("domain")); return builder.toString(); }
if (Strings.isNotBlank(registry)) { log.status("Adapting resources to pull images from registry: " + registry); addRegistryToImageNameIfNotPresent(entities, registry); boolean isOpenshift = client.isAdaptable(OpenShiftClient.class); String namespace = session.getNamespace(); String routeDomain = null; if (Strings.isNotBlank(configuration.getKubernetesDomain())) { routeDomain = configuration.getKubernetesDomain(); 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); log.status("Applying replication controller:" + getName(replicationController)); Set<Secret> secrets = generateSecrets(client, session, replicationController.getSpec().getTemplate().getMetadata()); String serviceAccountName = replicationController.getSpec().getTemplate().getSpec().getServiceAccountName(); if (Strings.isNotBlank(serviceAccountName)) { generateServiceAccount(client, session, secrets, serviceAccountName); String namespaceSuffix = "-" + namespace; String redirectUri = "http://" + name + namespaceSuffix; if (Strings.isNotBlank(routeDomain)) { redirectUri += "." + Strings.stripPrefix(routeDomain, ".");
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(); configuration.namespace = NAMESPACE_PREFIX + configuration.sessionId; } else { String namespace = Strings.isNotBlank(providedNamespace) ? providedNamespace : developNamespace;; if (Strings.isNullOrBlank(namespace)) { namespace = kubernetesClient.getNamespace(); if (Strings.isNullOrBlank(namespace)) { namespace = KubernetesHelper.defaultNamespace(); configuration.namespaceCleanupEnabled = getBooleanProperty(NAMESPACE_CLEANUP_ENABLED, map, Strings.isNullOrBlank(providedNamespace));
/** * 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; }
if (Strings.isNullOrBlank(branch)) { branch = "master"; if (Strings.isNullOrBlank(uri)) { if (Strings.isNullOrBlank(uri)) { throw new NotFoundException("No BuildConfig git URI for " + remoteRepository); if (Strings.isNullOrBlank(secretNamespace)) { secretNamespace = namespace; if (Strings.isNullOrBlank(sourceSecretName) && source != null) { LocalObjectReference sourceSecret = source.getSourceSecret(); if (sourceSecret != null) { String username = decodeSecretData(data.get(USERNAME_DATA_KEY)); String password = decodeSecretData(data.get(PASSWORD_DATA_KEY)); if (Strings.isNotBlank(username)) { userDetails.setUser(username); if (LOG.isDebugEnabled()) { if (Strings.isNotBlank(password)) { userDetails.setPassword(password); if (Strings.isNotBlank(message)) { resource.setMessage(message);
public void appendOut(String text) { if (Strings.isNullOrBlank(this.output)) { this.output = text; } else { this.output += "\n" + text; } }
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 String getGitUrl() { if (Strings.isNullOrBlank(gitUrl) && Strings.isNotBlank(url)) { if (isGitHubProject()) { gitUrl = url + ".git"; } } return gitUrl; }
public String getCurrentNamespace() { String answer = kubernetesClient.getNamespace(); if (Strings.isNullOrBlank(answer)) { answer = KubernetesHelper.defaultNamespace(); } if (Strings.isNullOrBlank(answer)) { answer = System.getenv("KUBERNETES_NAMESPACE"); } if (Strings.isNullOrBlank(answer)) { answer = "default"; } return answer; }
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)); } }
@Override public void process(NamespaceName name, BuildConfig buildConfig) throws Exception { String uri = KubernetesHelper.getOrCreateAnnotations(buildConfig).get(GIT_CLONE_URL); GitBuildSource git = gitBuildSource(buildConfig); if (git != null) { if (Strings.isNullOrBlank(uri)) { uri = git.getUri(); } if (Strings.isNotBlank(uri)) { processGitRepo(name, buildConfig, git, uri); } } }