6233274834

Committed 19 Sep 2023 08:46AM UTC coverage: 36.409% (-0.6%) from 36.982%

Build # 6233274834

Build Type

Pull #658

github

Committed by

dkfellows

Commit Message

Merge branch 'master' into java-17

Pull Request Pull Request #658: Update Java version to 17

Run Details

1656 of 1656 new or added lines in 260 files covered. (100.0%)

8373 of 22997 relevant lines covered (36.41%)

0.36 hits per line

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

16.67

/SpiNNaker-allocserv/src/main/java/uk/ac/manchester/spinnaker/alloc/web/CreateJobRequest.java

/*
 * Copyright (c) 2021 The University of Manchester
 *
 * 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
 *
 *     https://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 uk.ac.manchester.spinnaker.alloc.web;

import static java.util.Objects.nonNull;

import java.time.Duration;
import java.util.List;

import javax.validation.Valid;
import javax.validation.constraints.AssertFalse;
import javax.validation.constraints.AssertTrue;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import javax.validation.constraints.Positive;
import javax.validation.constraints.PositiveOrZero;

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.errorprone.annotations.Keep;

import uk.ac.manchester.spinnaker.machine.board.ValidBoardNumber;
import uk.ac.manchester.spinnaker.machine.board.ValidCabinetNumber;
import uk.ac.manchester.spinnaker.machine.board.ValidFrameNumber;
import uk.ac.manchester.spinnaker.machine.board.ValidTriadHeight;
import uk.ac.manchester.spinnaker.machine.board.ValidTriadWidth;
import uk.ac.manchester.spinnaker.machine.board.ValidTriadX;
import uk.ac.manchester.spinnaker.machine.board.ValidTriadY;
import uk.ac.manchester.spinnaker.machine.board.ValidTriadZ;
import uk.ac.manchester.spinnaker.utils.validation.IPAddress;

/**
 * A request to create a job.
 *
 * @author Donal Fellows
 * @param owner
 *            Who owns the job. Ignored when the job is submitted by a
 *            non-admin.
 * @param group
 *            What group will the job be accounted against; the owner
 *            <em>must</em> be a member of the group. If {@code null}, the
 *            single group that the owner is a member of will be used (with it
 *            being an error for that to not exist or not be unique). Only one
 *            of group, {@link #nmpiCollab} or {@link #nmpiJobId} must be
 *            non-{@code null}, but all can be {@code null}.
 * @param nmpiCollab
 *            Which NMPI Collab the job will be accounted against; the owner
 *            <em>must</em> be a member of the Collab. A session will be created
 *            in the Collab and this will be accounted against. Only one of
 *            {@link #group}, nmpiCollab or {@link #nmpiJobId} must be
 *            non-{@code null}, but all can be {@code null}.
 * @param nmpiJobId
 *            Which NMPI Job the job will be accounted against; the owner
 *            <em>must</em> be able to update the NMPI Job. Only the quota of
 *            the NMPI Job will be updated at the end of the job, as will the
 *            local quota of the Collab of the NMPI Job. Only one of
 *            {@link #group}, {@link #nmpiCollab} or nmpiJobId must be
 *            non-{@code null}, but all can be {@code null}.
 * @param keepaliveInterval
 *            How long after a keepalive message will the job be auto-deleted?
 *            <em>Required.</em> Must be between 30 and 300 seconds.
 * @param numBoards
 *            The number of boards to allocate. May be {@code null} to either
 *            use the default (1) or to let one of the other selectors
 *            ({@link #dimensions}, {@link #board}) make the choice.
 * @param dimensions
 *            The dimensions of rectangle of triads of boards to allocate. May
 *            be {@code null} to let one of the other selectors
 *            ({@link #numBoards}, {@link #board}) make the choice.
 * @param board
 *            The specific board to allocate. May be {@code null} to let one of
 *            the other selectors ({@link #numBoards}, {@link #dimensions}) make
 *            the choice.
 * @param machineName
 *            Which machine to allocate on. This and {@link #tags} are mutually
 *            exclusive, but at least one must be given.
 * @param tags
 *            The tags to select which machine to allocate on. This and
 *            {@link #machineName} are mutually exclusive, but at least one must
 *            be given.
 * @param maxDeadBoards
 *            The maximum number of dead boards allowed in a rectangular
 *            allocation. Note that the allocation engine might increase this if
 *            it decides to overallocate. Defaults to {@code 0}.
 */
public record CreateJobRequest(@JsonProperty String owner,
                @JsonProperty String group,
                @JsonProperty("nmpi-collab") String nmpiCollab,
                @Positive(message = "negative NMPI job IDs are unsupported") //
                @JsonProperty("nmpi-job-id") Integer nmpiJobId,
                @JsonProperty("keepalive-interval")
                @NotNull(message = "keepalive-interval is "
                                + "required") Duration keepaliveInterval,
                @JsonProperty("num-boards") @Positive(message = "number of boards "
                                + "must be at least 1 if given") Integer numBoards,
                @JsonProperty @Valid Dimensions dimensions,
                @JsonProperty @Valid SpecificBoard board,
                @JsonProperty("machine-name") String machineName,
                @JsonProperty List<@NotBlank(//
                                message = "tags must not be blank") String> tags,
                @JsonProperty("max-dead-boards") @PositiveOrZero(message = //
                                "max-dead-boards may not be negative") Integer maxDeadBoards) {
        // Extended validation

        @Keep
        @JsonIgnore
        @AssertTrue(message = "either machine-name or tags must be supplied")
        private boolean isMachineNameAndTagsMutuallyExclusive() {
                return nonNull(machineName) != nonNull(tags);
        }

        @Keep
        @JsonIgnore
        @AssertFalse(message = "machine-name, if given, must be non-blank")
        private boolean isMachineNameInsane() {
                return nonNull(machineName) && machineName.isBlank();
        }

        @Keep
        @JsonIgnore
        @AssertFalse(message = "group, if given, must be non-blank")
        private boolean isGroupInsane() {
                return nonNull(group) && group.isBlank();
        }

        @Keep
        @JsonIgnore
        @AssertFalse(message = "nmpi-collab, if given, must be non-blank")
        private boolean isCollabInsane() {
                return nonNull(nmpiCollab) && nmpiCollab.isBlank();
        }

        @Keep
        @JsonIgnore
        @AssertTrue(
                        message = "either specify num-boards or dimensions and/or board")
        private boolean isOverLocated() {
                int count = 0;
                if (nonNull(numBoards)) {
                        count++;
                }
                if (nonNull(dimensions) || nonNull(board)) {
                        count++;
                }
                return count <= 1;
        }

        @Keep
        @JsonIgnore
        @AssertTrue(message = "only at most one of group, nmpi-collab and "
                        + "nmpi-job-id can be given")
        private boolean isGroupLocatableInAtMostOneWayOnly() {
                int count = 0;
                if (nonNull(group)) {
                        count++;
                }
                if (nonNull(nmpiCollab)) {
                        count++;
                }
                if (nonNull(nmpiJobId)) {
                        count++;
                }
                return count <= 1;
        }

        private static final Duration MIN_KEEPALIVE = Duration.parse("PT30S");

        private static final Duration MAX_KEEPALIVE = Duration.parse("PT300S");

        @Keep
        @JsonIgnore
        @AssertTrue(message = "keepalive-interval must be 30 to 300 seconds")
        private boolean isKeepaliveIntervalInRange() {
                /*
                 * Really ought to be validated against config, but we've not got the
                 * config at this point.
                 */
                return keepaliveInterval == null
                                || (keepaliveInterval.compareTo(MAX_KEEPALIVE) <= 0
                                        && keepaliveInterval.compareTo(MIN_KEEPALIVE) >= 0);
        }

        /**
         * Describes a request for an allocation of given dimensions.
         *
         * @param width
         *            The width of the rectangle of boards to allocate, in triads.
         * @param height
         *            The height of the rectangle of boards to allocate, in triads.
         */
        public record Dimensions(@ValidTriadWidth int width,
                        @ValidTriadHeight int height) {
        }

        /**
         * Describes a request for a specific board.
         *
         * @param x
         *            The X triad coordinate of the board.
         * @param y
         *            The Y triad coordinate of the board.
         * @param z
         *            The Z triad coordinate of the board.
         * @param cabinet
         *            The physical cabinet number of the board.
         * @param frame
         *            The physical frame number of the board.
         * @param board
         *            The physical board number of the board.
         * @param address
         *            The IP address of the board.
         */
        public record SpecificBoard(@ValidTriadX Integer x, @ValidTriadY Integer y,
                        @ValidTriadZ Integer z, @ValidCabinetNumber Integer cabinet,
                        @ValidFrameNumber Integer frame, @ValidBoardNumber Integer board,
                        @IPAddress(nullOK = true, message = "address must be "
                                        + "an IP address") String address) {
                @JsonIgnore
                private boolean isTriadValid() {
                        return nonNull(x) && nonNull(y) && nonNull(z);
                }

                @JsonIgnore
                private boolean isPhysicalValid() {
                        return nonNull(cabinet) && nonNull(frame) && nonNull(board);
                }

                @JsonIgnore
                private boolean isIPValid() {
                        return nonNull(address);
                }

                /**
                 * Does this represent a valid way of identifying a board?
                 *
                 * @return Yes if at least one way of giving coordinates is valid.
                 */
                @Keep
                @JsonIgnore
                @AssertTrue(message = "at least one way of identifying a board "
                                + "must be given")
                private boolean isSpecificBoardValid() {
                        return isTriadValid() || isPhysicalValid() || isIPValid();
                }
        }
}

1	/*
2	* Copyright (c) 2021 The University of Manchester
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package uk.ac.manchester.spinnaker.alloc.web;
17
18	import static java.util.Objects.nonNull;
19
20	import java.time.Duration;
21	import java.util.List;
22
23	import javax.validation.Valid;
24	import javax.validation.constraints.AssertFalse;
25	import javax.validation.constraints.AssertTrue;
26	import javax.validation.constraints.NotBlank;
27	import javax.validation.constraints.NotNull;
28	import javax.validation.constraints.Positive;
29	import javax.validation.constraints.PositiveOrZero;
30
31	import com.fasterxml.jackson.annotation.JsonIgnore;
32	import com.fasterxml.jackson.annotation.JsonProperty;
33	import com.google.errorprone.annotations.Keep;
34
35	import uk.ac.manchester.spinnaker.machine.board.ValidBoardNumber;
36	import uk.ac.manchester.spinnaker.machine.board.ValidCabinetNumber;
37	import uk.ac.manchester.spinnaker.machine.board.ValidFrameNumber;
38	import uk.ac.manchester.spinnaker.machine.board.ValidTriadHeight;
39	import uk.ac.manchester.spinnaker.machine.board.ValidTriadWidth;
40	import uk.ac.manchester.spinnaker.machine.board.ValidTriadX;
41	import uk.ac.manchester.spinnaker.machine.board.ValidTriadY;
42	import uk.ac.manchester.spinnaker.machine.board.ValidTriadZ;
43	import uk.ac.manchester.spinnaker.utils.validation.IPAddress;
44
45	/**
46	* A request to create a job.
47	*
48	* @author Donal Fellows
49	* @param owner
50	* Who owns the job. Ignored when the job is submitted by a
51	* non-admin.
52	* @param group
53	* What group will the job be accounted against; the owner
54	* <em>must</em> be a member of the group. If {@code null}, the
55	* single group that the owner is a member of will be used (with it
56	* being an error for that to not exist or not be unique). Only one
57	* of group, {@link #nmpiCollab} or {@link #nmpiJobId} must be
58	* non-{@code null}, but all can be {@code null}.
59	* @param nmpiCollab
60	* Which NMPI Collab the job will be accounted against; the owner
61	* <em>must</em> be a member of the Collab. A session will be created
62	* in the Collab and this will be accounted against. Only one of
63	* {@link #group}, nmpiCollab or {@link #nmpiJobId} must be
64	* non-{@code null}, but all can be {@code null}.
65	* @param nmpiJobId
66	* Which NMPI Job the job will be accounted against; the owner
67	* <em>must</em> be able to update the NMPI Job. Only the quota of
68	* the NMPI Job will be updated at the end of the job, as will the
69	* local quota of the Collab of the NMPI Job. Only one of
70	* {@link #group}, {@link #nmpiCollab} or nmpiJobId must be
71	* non-{@code null}, but all can be {@code null}.
72	* @param keepaliveInterval
73	* How long after a keepalive message will the job be auto-deleted?
74	* <em>Required.</em> Must be between 30 and 300 seconds.
75	* @param numBoards
76	* The number of boards to allocate. May be {@code null} to either
77	* use the default (1) or to let one of the other selectors
78	* ({@link #dimensions}, {@link #board}) make the choice.
79	* @param dimensions
80	* The dimensions of rectangle of triads of boards to allocate. May
81	* be {@code null} to let one of the other selectors
82	* ({@link #numBoards}, {@link #board}) make the choice.
83	* @param board
84	* The specific board to allocate. May be {@code null} to let one of
85	* the other selectors ({@link #numBoards}, {@link #dimensions}) make
86	* the choice.
87	* @param machineName
88	* Which machine to allocate on. This and {@link #tags} are mutually
89	* exclusive, but at least one must be given.
90	* @param tags
91	* The tags to select which machine to allocate on. This and
92	* {@link #machineName} are mutually exclusive, but at least one must
93	* be given.
94	* @param maxDeadBoards
95	* The maximum number of dead boards allowed in a rectangular
96	* allocation. Note that the allocation engine might increase this if
97	* it decides to overallocate. Defaults to {@code 0}.
98	*/
99	public record CreateJobRequest(@JsonProperty String owner,	1✔
100	@JsonProperty String group,
101	@JsonProperty("nmpi-collab") String nmpiCollab,
102	@Positive(message = "negative NMPI job IDs are unsupported") //
103	@JsonProperty("nmpi-job-id") Integer nmpiJobId,
104	@JsonProperty("keepalive-interval")
105	@NotNull(message = "keepalive-interval is "
106	+ "required") Duration keepaliveInterval,
107	@JsonProperty("num-boards") @Positive(message = "number of boards "
108	+ "must be at least 1 if given") Integer numBoards,
109	@JsonProperty @Valid Dimensions dimensions,
110	@JsonProperty @Valid SpecificBoard board,
111	@JsonProperty("machine-name") String machineName,
112	@JsonProperty List<@NotBlank(//
113	message = "tags must not be blank") String> tags,
114	@JsonProperty("max-dead-boards") @PositiveOrZero(message = //
115	"max-dead-boards may not be negative") Integer maxDeadBoards) {
116	// Extended validation
117
118	@Keep
119	@JsonIgnore
120	@AssertTrue(message = "either machine-name or tags must be supplied")
121	private boolean isMachineNameAndTagsMutuallyExclusive() {
122	return nonNull(machineName) != nonNull(tags);	×
123	}
124
125	@Keep
126	@JsonIgnore
127	@AssertFalse(message = "machine-name, if given, must be non-blank")
128	private boolean isMachineNameInsane() {
129	return nonNull(machineName) && machineName.isBlank();	×
130	}
131
132	@Keep
133	@JsonIgnore
134	@AssertFalse(message = "group, if given, must be non-blank")
135	private boolean isGroupInsane() {
136	return nonNull(group) && group.isBlank();	×
137	}
138
139	@Keep
140	@JsonIgnore
141	@AssertFalse(message = "nmpi-collab, if given, must be non-blank")
142	private boolean isCollabInsane() {
143	return nonNull(nmpiCollab) && nmpiCollab.isBlank();	×
144	}
145
146	@Keep
147	@JsonIgnore
148	@AssertTrue(
149	message = "either specify num-boards or dimensions and/or board")
150	private boolean isOverLocated() {
151	int count = 0;	×
152	if (nonNull(numBoards)) {	×
153	count++;	×
154	}
155	if (nonNull(dimensions) \|\| nonNull(board)) {	×
156	count++;	×
157	}
158	return count <= 1;	×
159	}
160
161	@Keep
162	@JsonIgnore
163	@AssertTrue(message = "only at most one of group, nmpi-collab and "
164	+ "nmpi-job-id can be given")
165	private boolean isGroupLocatableInAtMostOneWayOnly() {
166	int count = 0;	×
167	if (nonNull(group)) {	×
168	count++;	×
169	}
170	if (nonNull(nmpiCollab)) {	×
171	count++;	×
172	}
173	if (nonNull(nmpiJobId)) {	×
174	count++;	×
175	}
176	return count <= 1;	×
177	}
178
179	private static final Duration MIN_KEEPALIVE = Duration.parse("PT30S");	1✔
180
181	private static final Duration MAX_KEEPALIVE = Duration.parse("PT300S");	1✔
182
183	@Keep
184	@JsonIgnore
185	@AssertTrue(message = "keepalive-interval must be 30 to 300 seconds")
186	private boolean isKeepaliveIntervalInRange() {
187	/*
188	* Really ought to be validated against config, but we've not got the
189	* config at this point.
190	*/
191	return keepaliveInterval == null	×
192	\|\| (keepaliveInterval.compareTo(MAX_KEEPALIVE) <= 0	×
193	&& keepaliveInterval.compareTo(MIN_KEEPALIVE) >= 0);	×
194	}
195
196	/**
197	* Describes a request for an allocation of given dimensions.
198	*
199	* @param width
200	* The width of the rectangle of boards to allocate, in triads.
201	* @param height
202	* The height of the rectangle of boards to allocate, in triads.
203	*/
204	public record Dimensions(@ValidTriadWidth int width,	1✔
205	@ValidTriadHeight int height) {
206	}
207
208	/**
209	* Describes a request for a specific board.
210	*
211	* @param x
212	* The X triad coordinate of the board.
213	* @param y
214	* The Y triad coordinate of the board.
215	* @param z
216	* The Z triad coordinate of the board.
217	* @param cabinet
218	* The physical cabinet number of the board.
219	* @param frame
220	* The physical frame number of the board.
221	* @param board
222	* The physical board number of the board.
223	* @param address
224	* The IP address of the board.
225	*/
226	public record SpecificBoard(@ValidTriadX Integer x, @ValidTriadY Integer y,	1✔
227	@ValidTriadZ Integer z, @ValidCabinetNumber Integer cabinet,
228	@ValidFrameNumber Integer frame, @ValidBoardNumber Integer board,
229	@IPAddress(nullOK = true, message = "address must be "
230	+ "an IP address") String address) {
231	@JsonIgnore
232	private boolean isTriadValid() {
233	return nonNull(x) && nonNull(y) && nonNull(z);	×
234	}
235
236	@JsonIgnore
237	private boolean isPhysicalValid() {
238	return nonNull(cabinet) && nonNull(frame) && nonNull(board);	×
239	}
240
241	@JsonIgnore
242	private boolean isIPValid() {
243	return nonNull(address);	×
244	}
245
246	/**
247	* Does this represent a valid way of identifying a board?
248	*
249	* @return Yes if at least one way of giving coordinates is valid.
250	*/
251	@Keep
252	@JsonIgnore
253	@AssertTrue(message = "at least one way of identifying a board "
254	+ "must be given")
255	private boolean isSpecificBoardValid() {
256	return isTriadValid() \|\| isPhysicalValid() \|\| isIPValid();	×
257	}
258	}
259	}

SpiNNakerManchester / JavaSpiNNaker / 6233274834

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