#122

Committed 01 Nov 2025 08:29PM UTC coverage: 8.077% (-0.1%) from 8.203%

Build # #122

Build Type

push

Committed by

Commit Message

Upgrade build script

Run Details

21 of 260 relevant lines covered (8.08%)

0.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

9.68

/src/main/java/com/github/nfalco79/jenkins/plugins/k8s/JobPVCWorkspaceVolume.java

/*
 * Copyright 2021 Nikolas Falco
 *
 * Licensed under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package com.github.nfalco79.jenkins.plugins.k8s;

import static java.util.logging.Level.INFO;
import static org.csanchez.jenkins.plugins.kubernetes.KubernetesCloud.DEFAULT_POD_LABELS;

import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.csanchez.jenkins.plugins.kubernetes.volumes.DynamicPVC;
import org.csanchez.jenkins.plugins.kubernetes.volumes.workspace.WorkspaceVolume;
import org.jenkinsci.Symbol;
import org.kohsuke.accmod.Restricted;
import org.kohsuke.accmod.restrictions.DoNotUse;
import org.kohsuke.stapler.DataBoundConstructor;
import org.kohsuke.stapler.interceptor.RequirePOST;

import edu.umd.cs.findbugs.annotations.CheckForNull;
import edu.umd.cs.findbugs.annotations.NonNull;
import hudson.Extension;
import hudson.model.Descriptor;
import hudson.util.ListBoxModel;
import io.fabric8.kubernetes.api.model.ObjectMeta;
import io.fabric8.kubernetes.api.model.PersistentVolumeClaim;
import io.fabric8.kubernetes.api.model.PersistentVolumeClaimBuilder;
import io.fabric8.kubernetes.api.model.Quantity;
import io.fabric8.kubernetes.api.model.Volume;
import io.fabric8.kubernetes.client.KubernetesClient;

@SuppressWarnings("serial")
public class JobPVCWorkspaceVolume extends WorkspaceVolume implements DynamicPVC {
    private static final Logger LOGGER = Logger.getLogger(JobPVCWorkspaceVolume.class.getName());

    private final String claimName;
    private final String storageClassName;
    private final String requestsSize;
    private final String accessModes;

    @DataBoundConstructor
    public JobPVCWorkspaceVolume(@NonNull String claimName,
                                 String storageClassName,
                                 @NonNull String requestsSize,
                                 String accessModes) {
        this.claimName = claimName;
        this.storageClassName = storageClassName;
        this.requestsSize = requestsSize;
        this.accessModes = accessModes;
    }

    public String getClaimName() {
        return claimName;
    }

    @Override
    @CheckForNull
    public String getAccessModes() {
        return accessModes;
    }

    @Override
    @CheckForNull
    public String getRequestsSize() {
        return requestsSize;
    }

    @Override
    @CheckForNull
    public String getStorageClassName() {
        return storageClassName;
    }

    @Override
    public Volume buildVolume(String volumeName, String podName) {
        return buildPVC(volumeName, podName);
    }

    @Override
    public String getPvcName(String podName) {
        return PVCUtil.normalize(getClaimName());
    }

    @Override
    public PersistentVolumeClaim createVolume(KubernetesClient client, ObjectMeta podMetaData) {
        String namespace = podMetaData.getNamespace();
        String podId = podMetaData.getName();
        String pvcName = getPvcName(podId);
        LOGGER.log(Level.FINE, "Adding workspace volume {0} from pod: {1}/{2}", new Object[] { pvcName, namespace, podId });

        List<PersistentVolumeClaim> pvcs = client.persistentVolumeClaims().list().getItems();
        PersistentVolumeClaim pvc = pvcs.stream().filter(p -> Objects.equals(p.getMetadata().getName(), pvcName)).findFirst().orElse(null);

        if (pvc != null) {
            // check if size has been changed
            Quantity actualStorage = PVCUtil.getRequestSize(pvc);
            Quantity requestStorage = Quantity.parse(getRequestsSizeOrDefault());
            if (!actualStorage.equals(requestStorage)) {
                LOGGER.log(INFO, "PVC request is different than actual storage, from {0} to {1}. Request new one", new Object[] { actualStorage, requestStorage });

                client.persistentVolumeClaims().resource(pvc).delete();
                LOGGER.log(INFO, "Removed PVC: {0}/{1}", new Object[] { pvc.getMetadata().getNamespace(), pvc.getFullResourceName() });
                pvc = null;
            }
        }

        if (pvc == null) {
            pvc = new PersistentVolumeClaimBuilder() //
                    .withNewMetadata() //
                    .withName(pvcName) //
                    .withLabels(DEFAULT_POD_LABELS) //
                    .endMetadata() //
                    .withNewSpec() //
                    .withAccessModes(getAccessModesOrDefault()) //
                    .withNewResources() //
                    .withRequests(getResourceMap()) //
                    .endResources() //
                    .withStorageClassName(getStorageClassNameOrDefault()) //
                    .endSpec() //
                    .build();
            pvc = client.persistentVolumeClaims() //
                    .inNamespace(podMetaData.getNamespace()) //
                    .resource(pvc).create();
            LOGGER.log(INFO, "Created PVC: {0}/{1}", new Object[] { namespace, pvcName });
        }
        return pvc;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        JobPVCWorkspaceVolume that = (JobPVCWorkspaceVolume) o;
        return Objects.equals(storageClassName, that.storageClassName) &&
                Objects.equals(requestsSize, that.requestsSize) &&
                Objects.equals(accessModes, that.accessModes);
    }

    @Override
    public int hashCode() {
        return Objects.hash(storageClassName, requestsSize, accessModes);
    }

    @Extension
    @Symbol("jobPVC")
    public static class DescriptorImpl extends Descriptor<WorkspaceVolume> {

        private static final ListBoxModel ACCESS_MODES_BOX = new ListBoxModel() //
                .add("ReadWriteOnce") //
                .add("ReadOnlyMany") //
                .add("ReadWriteMany");

        @Override
        public String getDisplayName() {
            return "Per Job Persistent Volume Claim Workspace Volume";
        }

        @RequirePOST
        @Restricted(DoNotUse.class) // stapler only
        public ListBoxModel doFillAccessModesItems() {
            return ACCESS_MODES_BOX;
        }
    }

}

1	/*
2	* Copyright 2021 Nikolas Falco
3	*
4	* Licensed under the Apache License, Version 2.0 (the
5	* "License"); you may not use this file except in compliance
6	* with the License. You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing,
11	* software distributed under the License is distributed on an
12	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
13	* KIND, either express or implied. See the License for the
14	* specific language governing permissions and limitations
15	* under the License.
16	*/
17	package com.github.nfalco79.jenkins.plugins.k8s;
18
19	import static java.util.logging.Level.INFO;
20	import static org.csanchez.jenkins.plugins.kubernetes.KubernetesCloud.DEFAULT_POD_LABELS;
21
22	import java.util.List;
23	import java.util.Objects;
24	import java.util.logging.Level;
25	import java.util.logging.Logger;
26
27	import org.csanchez.jenkins.plugins.kubernetes.volumes.DynamicPVC;
28	import org.csanchez.jenkins.plugins.kubernetes.volumes.workspace.WorkspaceVolume;
29	import org.jenkinsci.Symbol;
30	import org.kohsuke.accmod.Restricted;
31	import org.kohsuke.accmod.restrictions.DoNotUse;
32	import org.kohsuke.stapler.DataBoundConstructor;
33	import org.kohsuke.stapler.interceptor.RequirePOST;
34
35	import edu.umd.cs.findbugs.annotations.CheckForNull;
36	import edu.umd.cs.findbugs.annotations.NonNull;
37	import hudson.Extension;
38	import hudson.model.Descriptor;
39	import hudson.util.ListBoxModel;
40	import io.fabric8.kubernetes.api.model.ObjectMeta;
41	import io.fabric8.kubernetes.api.model.PersistentVolumeClaim;
42	import io.fabric8.kubernetes.api.model.PersistentVolumeClaimBuilder;
43	import io.fabric8.kubernetes.api.model.Quantity;
44	import io.fabric8.kubernetes.api.model.Volume;
45	import io.fabric8.kubernetes.client.KubernetesClient;
46
47	@SuppressWarnings("serial")
48	public class JobPVCWorkspaceVolume extends WorkspaceVolume implements DynamicPVC {
49	private static final Logger LOGGER = Logger.getLogger(JobPVCWorkspaceVolume.class.getName());	×
50
51	private final String claimName;
52	private final String storageClassName;
53	private final String requestsSize;
54	private final String accessModes;
55
56	@DataBoundConstructor
57	public JobPVCWorkspaceVolume(@NonNull String claimName,
58	String storageClassName,
59	@NonNull String requestsSize,
60	String accessModes) {	×
61	this.claimName = claimName;	×
62	this.storageClassName = storageClassName;	×
63	this.requestsSize = requestsSize;	×
64	this.accessModes = accessModes;	×
65	}	×
66
67	public String getClaimName() {
68	return claimName;	×
69	}
70
71	@Override
72	@CheckForNull
73	public String getAccessModes() {
74	return accessModes;	×
75	}
76
77	@Override
78	@CheckForNull
79	public String getRequestsSize() {
80	return requestsSize;	×
81	}
82
83	@Override
84	@CheckForNull
85	public String getStorageClassName() {
86	return storageClassName;	×
87	}
88
89	@Override
90	public Volume buildVolume(String volumeName, String podName) {
91	return buildPVC(volumeName, podName);	×
92	}
93
94	@Override
95	public String getPvcName(String podName) {
96	return PVCUtil.normalize(getClaimName());	×
97	}
98
99	@Override
100	public PersistentVolumeClaim createVolume(KubernetesClient client, ObjectMeta podMetaData) {
101	String namespace = podMetaData.getNamespace();	×
102	String podId = podMetaData.getName();	×
103	String pvcName = getPvcName(podId);	×
104	LOGGER.log(Level.FINE, "Adding workspace volume {0} from pod: {1}/{2}", new Object[] { pvcName, namespace, podId });	×
105
106	List<PersistentVolumeClaim> pvcs = client.persistentVolumeClaims().list().getItems();	×
107	PersistentVolumeClaim pvc = pvcs.stream().filter(p -> Objects.equals(p.getMetadata().getName(), pvcName)).findFirst().orElse(null);	×
108
109	if (pvc != null) {	×
110	// check if size has been changed
111	Quantity actualStorage = PVCUtil.getRequestSize(pvc);	×
112	Quantity requestStorage = Quantity.parse(getRequestsSizeOrDefault());	×
113	if (!actualStorage.equals(requestStorage)) {	×
114	LOGGER.log(INFO, "PVC request is different than actual storage, from {0} to {1}. Request new one", new Object[] { actualStorage, requestStorage });	×
115
116	client.persistentVolumeClaims().resource(pvc).delete();	×
117	LOGGER.log(INFO, "Removed PVC: {0}/{1}", new Object[] { pvc.getMetadata().getNamespace(), pvc.getFullResourceName() });	×
118	pvc = null;	×
119	}
120	}
121
122	if (pvc == null) {	×
123	pvc = new PersistentVolumeClaimBuilder() //	×
124	.withNewMetadata() //	×
125	.withName(pvcName) //	×
126	.withLabels(DEFAULT_POD_LABELS) //	×
127	.endMetadata() //	×
128	.withNewSpec() //	×
129	.withAccessModes(getAccessModesOrDefault()) //	×
130	.withNewResources() //	×
131	.withRequests(getResourceMap()) //	×
132	.endResources() //	×
133	.withStorageClassName(getStorageClassNameOrDefault()) //	×
134	.endSpec() //	×
135	.build();	×
136	pvc = client.persistentVolumeClaims() //	×
137	.inNamespace(podMetaData.getNamespace()) //	×
138	.resource(pvc).create();	×
139	LOGGER.log(INFO, "Created PVC: {0}/{1}", new Object[] { namespace, pvcName });	×
140	}
141	return pvc;	×
142	}
143
144	@Override
145	public boolean equals(Object o) {
146	if (this == o) {	×
147	return true;	×
148	}
149	if (o == null \|\| getClass() != o.getClass()) {	×
150	return false;	×
151	}
152	JobPVCWorkspaceVolume that = (JobPVCWorkspaceVolume) o;	×
153	return Objects.equals(storageClassName, that.storageClassName) &&	×
154	Objects.equals(requestsSize, that.requestsSize) &&	×
155	Objects.equals(accessModes, that.accessModes);	×
156	}
157
158	@Override
159	public int hashCode() {
160	return Objects.hash(storageClassName, requestsSize, accessModes);	×
161	}
162
163	@Extension
164	@Symbol("jobPVC")
165	public static class DescriptorImpl extends Descriptor<WorkspaceVolume> {	1✔
166
167	private static final ListBoxModel ACCESS_MODES_BOX = new ListBoxModel() //	1✔
168	.add("ReadWriteOnce") //	1✔
169	.add("ReadOnlyMany") //	1✔
170	.add("ReadWriteMany");	1✔
171
172	@Override
173	public String getDisplayName() {
174	return "Per Job Persistent Volume Claim Workspace Volume";	1✔
175	}
176
177	@RequirePOST
178	@Restricted(DoNotUse.class) // stapler only
179	public ListBoxModel doFillAccessModesItems() {
180	return ACCESS_MODES_BOX;	×
181	}
182	}
183
184	}

nfalco79 / k8s-provisioning-plugin / #122

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous