Examples with MetadataNested io.fabric8.kubernetes.api.model.apiextensions.v1beta1.CustomResourceDefinitionFluent.MetadataNested used on opensource projects

Example 11 with MetadataNested

use of io.fabric8.kubernetes.api.model.apiextensions.v1beta1.CustomResourceDefinitionFluent.MetadataNested in project entando-k8s-controller-coordinator by entando-k8s.

the class CrdManagementTest method testCustomResourceEvent.

@Test
@Description("New instances of my CustomResources should result in my controller image to be executed against the resource")
void testCustomResourceEvent() throws IOException {
    step("Given I have prepared a cluster scoped deployment of the EntandoOperator", () -> System.setProperty(EntandoOperatorConfigProperty.ENTANDO_NAMESPACES_TO_OBSERVE.getJvmSystemProperty(), "*"));
    step("And I have started the Entando Operator", () -> entandoControllerCoordinator.onStartup(new StartupEvent()));
    ObjectMapper objectMapper = new ObjectMapper(new YAMLFactory());
    final CustomResourceDefinition value = objectMapper.readValue(Thread.currentThread().getContextClassLoader().getResource("mycrds.test.org.crd.yaml"), CustomResourceDefinition.class);
    final MetadataNested<CustomResourceDefinitionBuilder> builder = new CustomResourceDefinitionBuilder(value).editMetadata();
    step("And I have a CustomResourceDefinition with", () -> {
        step(format("the %s label ", LabelNames.CRD_OF_INTEREST.getName()), () -> {
            builder.addToLabels(LabelNames.CRD_OF_INTEREST.getName(), "MyCRD");
        });
        step(format("and the %s annotation ", AnnotationNames.CONTROLLER_IMAGE.getName()), () -> {
            builder.addToAnnotations(AnnotationNames.CONTROLLER_IMAGE.getName(), "test/my-controller");
        });
    });
    step("And I have registered my custom resource definition", () -> {
        client.getCluster().putCustomResourceDefinition(builder.endMetadata().build());
    });
    final SerializedEntandoResource resource = new SerializedEntandoResource();
    resource.setMetadata(new ObjectMetaBuilder().withName("my-resource").withNamespace(MY_NAMESPACE).build());
    resource.setDefinition(CustomResourceDefinitionContext.fromCrd(builder.endMetadata().build()));
    step("When I create a new custom resource based on my CustomResourceDefinition my controller image is used to execute a " + "Controller pod that runs to completion", () -> client.createOrPatchEntandoResource(resource));
    step(format("Then a controller pod has been created with the image that I specified in the %s annotation", AnnotationNames.CONTROLLER_IMAGE.getName()), () -> {
        await().atMost(10, TimeUnit.SECONDS).ignoreExceptions().until(() -> client.loadPod(AbstractK8SClientDouble.CONTROLLER_NAMESPACE, CoordinatorUtils.podLabelsFor(resource)) != null);
        assertThat(client.loadPod(AbstractK8SClientDouble.CONTROLLER_NAMESPACE, CoordinatorUtils.podLabelsFor(resource)).getSpec().getContainers().get(0).getImage()).contains("test/my-controller");
    });
}

Example 12 with MetadataNested

use of io.fabric8.kubernetes.api.model.apiextensions.v1beta1.CustomResourceDefinitionFluent.MetadataNested in project che-server by eclipse-che.

the class OpenShiftProjectTest method setUp.

@BeforeMethod
public void setUp() throws Exception {
    lenient().when(clientFactory.create(anyString())).thenReturn(kubernetesClient);
    lenient().when(clientFactory.createOC()).thenReturn(openShiftClient);
    lenient().when(clientFactory.createOC(anyString())).thenReturn(openShiftClient);
    lenient().when(cheServerOpenshiftClientFactory.createOC()).thenReturn(openShiftCheServerClient);
    lenient().when(openShiftClient.adapt(OpenShiftClient.class)).thenReturn(openShiftClient);
    final MixedOperation mixedOperation = mock(MixedOperation.class);
    final NonNamespaceOperation namespaceOperation = mock(NonNamespaceOperation.class);
    lenient().doReturn(mixedOperation).when(kubernetesClient).serviceAccounts();
    lenient().when(mixedOperation.inNamespace(anyString())).thenReturn(namespaceOperation);
    lenient().when(namespaceOperation.withName(anyString())).thenReturn(serviceAccountResource);
    lenient().when(serviceAccountResource.get()).thenReturn(mock(ServiceAccount.class));
    lenient().doReturn(projectRequestOperation).when(openShiftClient).projectrequests();
    lenient().doReturn(metadataNested).when(metadataNested).withName(anyString());
    openShiftProject = new OpenShiftProject(clientFactory, cheClientFactory, cheServerOpenshiftClientFactory, WORKSPACE_ID, PROJECT_NAME, deployments, services, routes, pvcs, ingresses, secrets, configsMaps);
}

Example 13 with MetadataNested

use of io.fabric8.kubernetes.api.model.apiextensions.v1beta1.CustomResourceDefinitionFluent.MetadataNested in project devspaces-images by redhat-developer.

the class OpenShiftProjectTest method testOpenShiftProjectPreparingWhenProjectDoesNotExistWithCheServerSA.

@Test
public void testOpenShiftProjectPreparingWhenProjectDoesNotExistWithCheServerSA() throws Exception {
    // given
    prepareNamespaceGet(PROJECT_NAME);
    Resource resource = prepareProjectResource(PROJECT_NAME);
    doThrow(new KubernetesClientException("error", 403, null)).when(resource).get();
    final MixedOperation mixedOperation = mock(MixedOperation.class);
    final NonNamespaceOperation namespaceOperation = mock(NonNamespaceOperation.class);
    doReturn(mixedOperation).when(openShiftCheServerClient).serviceAccounts();
    when(mixedOperation.inNamespace(anyString())).thenReturn(namespaceOperation);
    when(namespaceOperation.withName(anyString())).thenReturn(serviceAccountResource);
    when(serviceAccountResource.get()).thenReturn(mock(ServiceAccount.class));
    doReturn(projectRequestOperation).when(openShiftCheServerClient).projectrequests();
    // doReturn(metadataNested).when(metadataNested).withName(anyString());
    when(openShiftCheServerClient.roleBindings()).thenReturn(mixedRoleBindingOperation);
    lenient().when(mixedRoleBindingOperation.inNamespace(anyString())).thenReturn(nonNamespaceRoleBindingOperation);
    when(openShiftClient.currentUser()).thenReturn(new UserBuilder().withNewMetadata().withName("user").endMetadata().build());
    // when
    openShiftProject.prepare(true, true, Map.of(), Map.of());
    // then
    ArgumentCaptor<ProjectRequest> captor = ArgumentCaptor.forClass(ProjectRequest.class);
    verify(projectRequestOperation).create(captor.capture());
    Assert.assertEquals(captor.getValue().getMetadata().getName(), PROJECT_NAME);
    verifyNoMoreInteractions(openShiftCheServerClient);
    verifyNoMoreInteractions(kubernetesClient);
    ArgumentCaptor<RoleBinding> roleBindingArgumentCaptor = ArgumentCaptor.forClass(RoleBinding.class);
    verify(nonNamespaceRoleBindingOperation).createOrReplace(roleBindingArgumentCaptor.capture());
    assertNotNull(roleBindingArgumentCaptor.getValue());
}

Example 14 with MetadataNested

use of io.fabric8.kubernetes.api.model.apiextensions.v1beta1.CustomResourceDefinitionFluent.MetadataNested in project devspaces-images by redhat-developer.

the class OpenShiftProjectTest method testOpenShiftProjectPreparingRoleBindingWhenProjectDoesNotExistWithCheServerSA.

@Test(dependsOnMethods = "testOpenShiftProjectPreparingWhenProjectDoesNotExistWithCheServerSA")
public void testOpenShiftProjectPreparingRoleBindingWhenProjectDoesNotExistWithCheServerSA() throws Exception {
    // given
    prepareNamespaceGet(PROJECT_NAME);
    Resource resource = prepareProjectResource(PROJECT_NAME);
    doThrow(new KubernetesClientException("error", 403, null)).when(resource).get();
    final MixedOperation mixedOperation = mock(MixedOperation.class);
    final NonNamespaceOperation namespaceOperation = mock(NonNamespaceOperation.class);
    doReturn(mixedOperation).when(openShiftCheServerClient).serviceAccounts();
    when(mixedOperation.inNamespace(anyString())).thenReturn(namespaceOperation);
    when(namespaceOperation.withName(anyString())).thenReturn(serviceAccountResource);
    when(serviceAccountResource.get()).thenReturn(mock(ServiceAccount.class));
    doReturn(projectRequestOperation).when(openShiftCheServerClient).projectrequests();
    // doReturn(metadataNested).when(metadataNested).withName(anyString());
    when(openShiftCheServerClient.roleBindings()).thenReturn(mixedRoleBindingOperation);
    lenient().when(mixedRoleBindingOperation.inNamespace(anyString())).thenReturn(nonNamespaceRoleBindingOperation);
    when(openShiftClient.currentUser()).thenReturn(new UserBuilder().withNewMetadata().withName("jdoe").endMetadata().build());
    // when
    openShiftProject.prepare(true, true, Map.of(), Map.of());
    // then
    ArgumentCaptor<RoleBinding> roleBindingArgumentCaptor = ArgumentCaptor.forClass(RoleBinding.class);
    verify(nonNamespaceRoleBindingOperation).createOrReplace(roleBindingArgumentCaptor.capture());
    RoleBinding roleBinding = roleBindingArgumentCaptor.getValue();
    assertNotNull(roleBinding);
    assertEquals(roleBinding.getMetadata().getName(), "admin");
    assertEquals(roleBinding.getRoleRef().getName(), "admin");
    assertEquals(roleBinding.getUserNames(), ImmutableList.of("jdoe"));
}

Example 15 with MetadataNested

use of io.fabric8.kubernetes.api.model.apiextensions.v1beta1.CustomResourceDefinitionFluent.MetadataNested in project kubernetes-plugin by jenkinsci.

the class PodTemplateBuilder method build.

/**
 * Create a Pod object from a PodTemplate
 */
public Pod build() {
    // Build volumes and volume mounts.
    Map<String, Volume> volumes = new HashMap<>();
    Map<String, VolumeMount> volumeMounts = new HashMap<>();
    if (agent == null) {
        throw new IllegalStateException("No KubernetesSlave is set");
    }
    String podName = agent.getPodName();
    int i = 0;
    for (final PodVolume volume : template.getVolumes()) {
        final String volumeName = "volume-" + i;
        final String mountPath = normalizePath(volume.getMountPath());
        if (!volumeMounts.containsKey(mountPath)) {
            VolumeMountBuilder volumeMountBuilder = // 
            new VolumeMountBuilder().withMountPath(mountPath).withName(volumeName).withReadOnly(false);
            if (volume instanceof ConfigMapVolume) {
                final ConfigMapVolume configmapVolume = (ConfigMapVolume) volume;
                String subPath = configmapVolume.getSubPath();
                if (subPath != null) {
                    volumeMountBuilder = volumeMountBuilder.withSubPath(normalizePath(subPath));
                }
            }
            volumeMounts.put(mountPath, volumeMountBuilder.build());
            volumes.put(volumeName, volume.buildVolume(volumeName, podName));
            i++;
        }
    }
    volumes.put(WORKSPACE_VOLUME_NAME, template.getWorkspaceVolume().buildVolume(WORKSPACE_VOLUME_NAME, podName));
    Map<String, Container> containers = new HashMap<>();
    // containers from pod template
    for (ContainerTemplate containerTemplate : template.getContainers()) {
        containers.put(containerTemplate.getName(), createContainer(containerTemplate, template.getEnvVars(), volumeMounts.values()));
    }
    MetadataNested<PodBuilder> metadataBuilder = new PodBuilder().withNewMetadata();
    if (agent != null) {
        metadataBuilder.withName(agent.getPodName());
    }
    Map<String, String> labels = new HashMap<>();
    if (agent != null) {
        labels.putAll(agent.getKubernetesCloud().getPodLabelsMap());
    }
    labels.putAll(template.getLabelsMap());
    if (!labels.isEmpty()) {
        metadataBuilder.withLabels(labels);
    }
    Map<String, String> annotations = getAnnotationsMap(template.getAnnotations());
    if (!annotations.isEmpty()) {
        metadataBuilder.withAnnotations(annotations);
    }
    SpecNested<PodBuilder> builder = metadataBuilder.endMetadata().withNewSpec();
    if (template.getActiveDeadlineSeconds() > 0) {
        builder = builder.withActiveDeadlineSeconds(Long.valueOf(template.getActiveDeadlineSeconds()));
    }
    if (!volumes.isEmpty()) {
        builder.withVolumes(volumes.values().toArray(new Volume[volumes.size()]));
    }
    if (template.getServiceAccount() != null) {
        builder.withServiceAccountName(substituteEnv(template.getServiceAccount()));
    }
    if (template.getSchedulerName() != null) {
        builder.withSchedulerName(substituteEnv(template.getSchedulerName()));
    }
    List<LocalObjectReference> imagePullSecrets = template.getImagePullSecrets().stream().map((x) -> x.toLocalObjectReference()).collect(Collectors.toList());
    if (!imagePullSecrets.isEmpty()) {
        builder.withImagePullSecrets(imagePullSecrets);
    }
    Map<String, String> nodeSelector = getNodeSelectorMap(template.getNodeSelector());
    if (!nodeSelector.isEmpty()) {
        builder.withNodeSelector(nodeSelector);
    }
    if (template.getTerminationGracePeriodSeconds() != null) {
        builder.withTerminationGracePeriodSeconds(template.getTerminationGracePeriodSeconds());
    }
    builder.withContainers(containers.values().toArray(new Container[containers.size()]));
    Long runAsUser = template.getRunAsUserAsLong();
    Long runAsGroup = template.getRunAsGroupAsLong();
    String supplementalGroups = template.getSupplementalGroups();
    if (runAsUser != null || runAsGroup != null || supplementalGroups != null) {
        PodSpecFluent.SecurityContextNested<SpecNested<PodBuilder>> securityContext = builder.editOrNewSecurityContext();
        if (runAsUser != null) {
            securityContext.withRunAsUser(runAsUser);
        }
        if (runAsGroup != null) {
            securityContext.withRunAsGroup(runAsGroup);
        }
        if (supplementalGroups != null) {
            securityContext.withSupplementalGroups(parseSupplementalGroupList(supplementalGroups));
        }
        securityContext.endSecurityContext();
    }
    if (template.isHostNetworkSet()) {
        builder.withHostNetwork(template.isHostNetwork());
    }
    // merge with the yaml fragments
    Pod pod = combine(template.getYamlsPod(), builder.endSpec().build());
    // Apply defaults
    // default jnlp container
    Optional<Container> jnlpOpt = pod.getSpec().getContainers().stream().filter(c -> JNLP_NAME.equals(c.getName())).findFirst();
    Container jnlp = jnlpOpt.orElse(new ContainerBuilder().withName(JNLP_NAME).withVolumeMounts(volumeMounts.values().toArray(new VolumeMount[volumeMounts.values().size()])).build());
    if (!jnlpOpt.isPresent()) {
        pod.getSpec().getContainers().add(jnlp);
    }
    pod.getSpec().getContainers().stream().filter(c -> c.getWorkingDir() == null).forEach(c -> c.setWorkingDir(jnlp.getWorkingDir()));
    if (StringUtils.isBlank(jnlp.getImage())) {
        String jnlpImage = DEFAULT_JNLP_IMAGE;
        if (StringUtils.isNotEmpty(DEFAULT_JNLP_DOCKER_REGISTRY_PREFIX)) {
            jnlpImage = Util.ensureEndsWith(DEFAULT_JNLP_DOCKER_REGISTRY_PREFIX, "/") + jnlpImage;
        }
        jnlp.setImage(jnlpImage);
    }
    Map<String, EnvVar> envVars = new HashMap<>();
    envVars.putAll(jnlpEnvVars(jnlp.getWorkingDir()));
    envVars.putAll(defaultEnvVars(template.getEnvVars()));
    Optional.ofNullable(jnlp.getEnv()).ifPresent(jnlpEnv -> {
        jnlpEnv.forEach(var -> envVars.put(var.getName(), var));
    });
    jnlp.setEnv(new ArrayList<>(envVars.values()));
    if (jnlp.getResources() == null) {
        Map<String, Quantity> reqMap = new HashMap<>();
        Map<String, Quantity> limMap = new HashMap<>();
        reqMap.put("cpu", new Quantity(DEFAULT_JNLP_CONTAINER_CPU_REQUEST));
        reqMap.put("memory", new Quantity(DEFAULT_JNLP_CONTAINER_MEMORY_REQUEST));
        if (DEFAULT_JNLP_CONTAINER_CPU_LIMIT != null) {
            limMap.put("cpu", new Quantity(DEFAULT_JNLP_CONTAINER_CPU_LIMIT));
        }
        if (DEFAULT_JNLP_CONTAINER_MEMORY_LIMIT != null) {
            limMap.put("memory", new Quantity(DEFAULT_JNLP_CONTAINER_MEMORY_LIMIT));
        }
        ResourceRequirements reqs = new ResourceRequirementsBuilder().withRequests(reqMap).withLimits(limMap).build();
        jnlp.setResources(reqs);
    }
    if (cloud != null) {
        pod = PodDecorator.decorateAll(cloud, pod);
    }
    Pod finalPod = pod;
    LOGGER.finest(() -> "Pod built: " + Serialization.asYaml(finalPod));
    return pod;
}