Refine search
for (Pod pod : list.getItems()) { if (podIpAddress.equals(pod.getStatus().getPodIP())) { containerId = pod.getMetadata().getName(); currentPod = pod; break; List<EnvVar> podEnvironmentVariables = currentPod.getSpec().getContainers().get(0).getEnv(); Optional<EnvVar> noVncPort = podEnvironmentVariables.stream().filter(env -> "NOVNC_PORT".equals(env.getName())).findFirst();
private void discoverFolderMounts() { List<VolumeMount> volumeMounts = zaleniumPod.getSpec().getContainers().get(0).getVolumeMounts(); List<VolumeMount> validMounts = new ArrayList<>(); volumeMounts.stream() .filter(volumeMount -> !Arrays.asList(PROTECTED_NODE_MOUNT_POINTS).contains(volumeMount.getMountPath())) .forEach(validMounts::add); // Look through the volume mounts to see if the shared folder is mounted if (!validMounts.isEmpty()) { List<Volume> volumes = zaleniumPod.getSpec().getVolumes(); for (VolumeMount validMount : validMounts) { volumes.stream() .filter(volume -> validMount.getName().equalsIgnoreCase(volume.getName())) .findFirst() .ifPresent(volume -> mountedSharedFoldersMap.put(validMount, volume)); } } }
@Override public void contribute(Builder builder) { try { Pod current = utils.currentPod().get(); Map<String, Object> details = new HashMap<>(); if (current != null) { details.put("inside", true); details.put("namespace", current.getMetadata().getNamespace()); details.put("podName", current.getMetadata().getName()); details.put("podIp", current.getStatus().getPodIP()); details.put("serviceAccount", current.getSpec().getServiceAccountName()); details.put("nodeName", current.getSpec().getNodeName()); details.put("hostIp", current.getStatus().getHostIP()); } else { details.put("inside", false); } builder.withDetail("kubernetes", details); } catch (Exception e) { LOG.warn("Failed to get pod details", e); } } }
private void collectLogs(Pod pod) { if (logWatches.containsKey(pod.getMetadata().getName())) { return; } while (!"Running".equals(pod.getStatus().getPhase())) { try { Thread.sleep(1000); } catch (InterruptedException e) { } pod = kubernetes.getPod(pod.getMetadata().getName()); } log.info("Collecting logs for pod {} with uuid {}", pod.getMetadata().getName(), uuid); for (Container container : pod.getSpec().getContainers()) { try { File outputFile = new File(logDir, pod.getMetadata().getName() + "." + container.getName()); FileOutputStream outputFileStream = new FileOutputStream(outputFile); synchronized (logWatches) { logWatches.put(pod.getMetadata().getName(), kubernetes.watchPodLog(pod.getMetadata().getName(), container.getName(), outputFileStream)); } } catch (Exception e) { log.info("Unable to save log for " + pod.getMetadata().getName() + "." + container.getName()); } } }
ObjectNode n = mapper.createObjectNode(); n.put("selfLink", meta.getSelfLink()); n.put("restartPolicy", spec.getRestartPolicy()); n.put("hostNetwork", spec.getHostNetwork()); n.put("activeDeadlineSeconds", spec.getActiveDeadlineSeconds()); n.put("automountServiceAccountToken", spec.getAutomountServiceAccountToken()); n.put("dnsPolicy", spec.getDnsPolicy()); n.put("hostIPC", spec.getHostIPC()); n.put("hostname", spec.getHostname()); n.put("hostPID", spec.getHostPID()); n.put("nodeName", spec.getNodeName()); n.put("schedulerName", spec.getSchedulerName()); n.put("serviceAccount", spec.getServiceAccount()); n.put("serviceAccountName", spec.getServiceAccountName()); n.put("subdomain", spec.getSubdomain()); n.put("terminationGracePeriodSeconds", spec.getTerminationGracePeriodSeconds()); spec.getContainers().forEach(it -> { ObjectNode cspec = mapper.createObjectNode(); ArrayNode args = mapper.createArrayNode(); it.getArgs().forEach(arg -> { args.add(arg); }); cspec.set("args", args); cspec.put("workingDir", it.getWorkingDir()); cspec.put("tty", it.getTty());
@Override protected Future<ReconcileResult<DeploymentConfig>> internalPatch(String namespace, String name, DeploymentConfig current, DeploymentConfig desired) { desired.getSpec().getTemplate().getSpec().getContainers().get(0).setImage(current.getSpec().getTemplate().getSpec().getContainers().get(0).getImage()); return super.internalPatch(namespace, name, current, desired); } }
@Override protected boolean findResourceAddress(LocationSpec<? extends KubernetesMachineLocation> locationSpec, Entity entity, HasMetadata metadata, String resourceType, String resourceName, String namespace) { if (super.findResourceAddress(locationSpec, entity, metadata, resourceType, resourceName, namespace)) { return true; } if (resourceType.equals(OpenShiftResource.DEPLOYMENT_CONFIG)) { DeploymentConfig deploymentConfig = (DeploymentConfig) metadata; Map<String, String> labels = deploymentConfig.getSpec().getTemplate().getMetadata().getLabels(); Pod pod = getPod(namespace, labels); entity.sensors().set(OpenShiftPod.KUBERNETES_POD, pod.getMetadata().getName()); InetAddress node = Networking.getInetAddressWithFixedName(pod.getSpec().getNodeName()); String podAddress = pod.getStatus().getPodIP(); locationSpec.configure("address", node); locationSpec.configure(SshMachineLocation.PRIVATE_ADDRESSES, ImmutableSet.of(podAddress)); return true; } else { return false; } }
public PodSpecFluentImpl(PodSpec instance){ this.withActiveDeadlineSeconds(instance.getActiveDeadlineSeconds()); this.withContainers(instance.getContainers()); this.withDnsPolicy(instance.getDnsPolicy()); this.withHost(instance.getHost()); this.withHostIPC(instance.getHostIPC()); this.withHostNetwork(instance.getHostNetwork()); this.withHostPID(instance.getHostPID()); this.withHostname(instance.getHostname()); this.withImagePullSecrets(instance.getImagePullSecrets()); this.withNodeName(instance.getNodeName()); this.withNodeSelector(instance.getNodeSelector()); this.withRestartPolicy(instance.getRestartPolicy()); this.withSecurityContext(instance.getSecurityContext()); this.withServiceAccount(instance.getServiceAccount()); this.withServiceAccountName(instance.getServiceAccountName()); this.withSubdomain(instance.getSubdomain()); this.withTerminationGracePeriodSeconds(instance.getTerminationGracePeriodSeconds()); this.withVolumes(instance.getVolumes()); }
if (StringUtils.isBlank(pod.getSpec().getRestartPolicy())) { pod.getSpec().setRestartPolicy("Never"); Optional<Container> jnlpOpt = pod.getSpec().getContainers().stream().filter(c -> JNLP_NAME.equals(c.getName())) .findFirst(); Container jnlp = jnlpOpt.orElse(new ContainerBuilder().withName(JNLP_NAME).build()); if (!jnlpOpt.isPresent()) { pod.getSpec().getContainers().add(jnlp); if (StringUtils.isBlank(jnlp.getImage())) { jnlp.setImage(DEFAULT_JNLP_IMAGE); if (pod.getSpec().getVolumes().stream().noneMatch(v -> WORKSPACE_VOLUME_NAME.equals(v.getName()))) { pod.getSpec().getVolumes() .add(new VolumeBuilder().withName(WORKSPACE_VOLUME_NAME).withNewEmptyDir().endEmptyDir().build()); pod.getSpec().getContainers().stream() .filter(c -> c.getVolumeMounts().stream() .noneMatch(vm -> vm.getMountPath().equals(
private boolean enableDebugging(HasMetadata entity, PodTemplateSpec template) { if (template != null) { PodSpec podSpec = template.getSpec(); if (podSpec != null) { List<Container> containers = podSpec.getContainers(); if (containers.size() > 0) { Container container = containers.get(0); List<EnvVar> env = container.getEnv(); if (env == null) { env = new ArrayList<>(); boolean enabled = false; if (KubernetesResourceUtil.setEnvVar(env, ENV_VAR_JAVA_DEBUG, "true")) { container.setEnv(env); enabled = true; List<ContainerPort> ports = container.getPorts(); if (ports == null) { ports = new ArrayList<>();
public PodSpecBuilder( PodSpecFluent<?> fluent , PodSpec instance ){ this.fluent = fluent; fluent.withActiveDeadlineSeconds(instance.getActiveDeadlineSeconds()); fluent.withContainers(instance.getContainers()); fluent.withDnsPolicy(instance.getDnsPolicy()); fluent.withHost(instance.getHost()); fluent.withHostNetwork(instance.getHostNetwork()); fluent.withImagePullSecrets(instance.getImagePullSecrets()); fluent.withNodeSelector(instance.getNodeSelector()); fluent.withRestartPolicy(instance.getRestartPolicy()); fluent.withServiceAccount(instance.getServiceAccount()); fluent.withTerminationGracePeriodSeconds(instance.getTerminationGracePeriodSeconds()); fluent.withVolumes(instance.getVolumes()); } public PodSpecBuilder( PodSpec instance ){
LOGGER.log(Level.FINE, "Combining pods, template: {0}", template); Map<String, String> nodeSelector = mergeMaps(parent.getSpec().getNodeSelector(), template.getSpec().getNodeSelector()); String serviceAccount = Strings.isNullOrEmpty(template.getSpec().getServiceAccount()) ? parent.getSpec().getServiceAccount() : template.getSpec().getServiceAccount(); Map<String, String> podAnnotations = mergeMaps(parent.getMetadata().getAnnotations(), imagePullSecrets.addAll(parent.getSpec().getImagePullSecrets()); imagePullSecrets.addAll(template.getSpec().getImagePullSecrets()); Map<String, Container> parentContainers = parent.getSpec().getContainers().stream() .collect(toMap(c -> c.getName(), c -> c)); combinedContainers.putAll(parentContainers); combinedContainers.putAll(template.getSpec().getContainers().stream() .collect(toMap(c -> c.getName(), c -> combine(parentContainers.get(c.getName()), c)))); Optional.ofNullable(parent.getSpec().getVolumes()).ifPresent(combinedVolumes::addAll); Optional.ofNullable(template.getSpec().getVolumes()).ifPresent(combinedVolumes::addAll); Optional.ofNullable(parent.getSpec().getTolerations()).ifPresent(combinedTolerations::addAll); Optional.ofNullable(template.getSpec().getTolerations()).ifPresent(combinedTolerations::addAll);
public Pod(io.fabric8.kubernetes.api.model.Pod pod) { this.name = pod.getMetadata().getName(); if (pod.getMetadata().getAnnotations() != null) { this.annotations.putAll(pod.getMetadata().getAnnotations()); } this.kind = pod.getKind(); this.host = pod.getStatus().getPodIP(); this.phase = pod.getStatus().getPhase(); this.ready = getReadyCondition(pod.getStatus().getConditions()); this.portMap = getPortMap(pod.getSpec().getContainers()); }
private void validatePod(Pod pod, boolean fromYaml) { assertThat(pod.getMetadata().getLabels(), hasEntry("some-label", "some-label-value")); Map<String, Container> containers = pod.getSpec().getContainers().stream() .collect(Collectors.toMap(Container::getName, Function.identity())); assertEquals(2, containers.size()); assertEquals("busybox", containers.get("busybox").getImage()); assertEquals("jenkins/jnlp-slave:alpine", containers.get("jnlp").getImage()); Map<String, Volume> volumes = pod.getSpec().getVolumes().stream() .collect(Collectors.toMap(Volume::getName, Function.identity())); assertEquals(3, volumes.size()); List<VolumeMount> mounts = containers.get("busybox").getVolumeMounts(); if (fromYaml) { assertEquals(2, mounts.size());
public void addRegistryToImageNameIfNotPresent(Iterable<HasMetadata> items, String registry) throws Exception { if (items != null) { for (HasMetadata item : items) { if (item instanceof KubernetesList) { KubernetesList list = (KubernetesList) item; addRegistryToImageNameIfNotPresent(list.getItems(), registry); } else if (item instanceof Template) { Template template = (Template) item; addRegistryToImageNameIfNotPresent(template.getObjects(), registry); } else if (item instanceof Pod) { List<Container> containers = ((Pod) item).getSpec().getContainers(); prefixRegistryIfNotPresent(containers, registry); } else if (item instanceof ReplicationController) { List<Container> containers = ((ReplicationController) item).getSpec().getTemplate().getSpec().getContainers(); prefixRegistryIfNotPresent(containers, registry); } else if (item instanceof ReplicaSet) { List<Container> containers = ((ReplicaSet) item).getSpec().getTemplate().getSpec().getContainers(); prefixRegistryIfNotPresent(containers, registry); } else if (item instanceof DeploymentConfig) { List<Container> containers = ((DeploymentConfig) item).getSpec().getTemplate().getSpec().getContainers(); prefixRegistryIfNotPresent(containers, registry); } else if (item instanceof Deployment) { List<Container> containers = ((Deployment) item).getSpec().getTemplate().getSpec().getContainers(); prefixRegistryIfNotPresent(containers, registry); } } } }
public List<String> getPodContainerNames(String podName) { return kubernetesClient .pods() .inNamespace(environment.getKubernetesNamespace()) .withName(podName) .get() .getSpec() .getContainers() .stream() .map(Container::getName) .collect(Collectors.toList()); }
public static void mergePodSpec(PodSpecBuilder builder, PodSpec defaultPodSpec, String defaultName) { List<Container> containers = builder.buildContainers(); List<Container> defaultContainers = defaultPodSpec.getContainers(); int size = defaultContainers.size(); if (size > 0) { container = containers.get(idx); } else { container = new Container(); containers.add(container); List<EnvVar> defaultEnv = defaultContainer.getEnv(); if (defaultEnv != null) { for (EnvVar envVar : defaultEnv) { List<ContainerPort> defaultPorts = defaultContainer.getPorts(); if (defaultPorts != null) { for (ContainerPort port : defaultPorts) {
@Override public List<InetSocketAddress> findSeedNodes(String cluster) throws HekateException { if (log.isDebugEnabled()) { log.debug("Searching for seed node addresses [namespace={}, container-port-name={}]", config.getNamespace(), containerPortName); } try (KubernetesClient client = new DefaultKubernetesClient(config)) { List<InetSocketAddress> seedNodes = new ArrayList<>(); PodList pods = client.pods().list(); // Search through Pods -> Containers -> Ports. nullSafe(pods.getItems()) .filter(pod -> pod.getSpec() != null && pod.getStatus() != null && pod.getStatus().getPodIP() != null) .filter(pod -> ACTIVE_POD_PHASES.contains(pod.getStatus().getPhase())) .forEach(pod -> { String ip = pod.getStatus().getPodIP(); nullSafe(pod.getSpec().getContainers()) .flatMap(container -> nullSafe(container.getPorts())) .filter(port -> containerPortName.equals(port.getName()) && port.getContainerPort() != null) .map(ContainerPort::getContainerPort) .forEach(port -> seedNodes.add(new InetSocketAddress(ip, port)) ); }); return seedNodes; } catch (KubernetesClientException e) { throw new HekateException("Kubernetes seed node discovery failure [" + "namespace=" + config.getNamespace() + ", " + "container-port-name=" + containerPortName + "]", e); } }
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); ReplicationController replicationController = (ReplicationController) entity; 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);
@Test public void testBuildFromYaml() throws Exception { PodTemplate template = new PodTemplate(); template.setYaml(new String(IOUtils.toByteArray(getClass().getResourceAsStream("pod-busybox.yaml")))); setupStubs(); Pod pod = new PodTemplateBuilder(template).withSlave(slave).build(); validatePod(pod); assertThat(pod.getMetadata().getLabels(), hasEntry("jenkins", "slave")); Map<String, Container> containers = pod.getSpec().getContainers().stream() .collect(Collectors.toMap(Container::getName, Function.identity())); assertEquals(2, containers.size()); Container container0 = containers.get("busybox"); assertNotNull(container0.getResources()); assertNotNull(container0.getResources().getRequests()); assertNotNull(container0.getResources().getLimits()); assertThat(container0.getResources().getRequests(), hasEntry("example.com/dongle", new Quantity("42"))); assertThat(container0.getResources().getLimits(), hasEntry("example.com/dongle", new Quantity("42"))); }