6310285782

Committed 26 Sep 2023 08:47AM UTC coverage: 36.367% (-0.5%) from 36.866%

Build # 6310285782

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 and JEE to 9

Run Details

1675 of 1675 new or added lines in 266 files covered. (100.0%)

8368 of 23010 relevant lines covered (36.37%)

0.36 hits per line

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

5.6

/SpiNNaker-allocserv/src/main/java/uk/ac/manchester/spinnaker/alloc/admin/AdminImpl.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.admin;

import static jakarta.ws.rs.core.MediaType.APPLICATION_JSON;
import static jakarta.ws.rs.core.Response.created;
import static jakarta.ws.rs.core.Response.noContent;
import static jakarta.ws.rs.core.Response.Status.BAD_REQUEST;
import static jakarta.ws.rs.core.Response.Status.NOT_FOUND;
import static jakarta.ws.rs.core.Response.Status.NOT_MODIFIED;
import static java.util.stream.Collectors.toList;
import static org.slf4j.LoggerFactory.getLogger;
import static uk.ac.manchester.spinnaker.alloc.admin.AdminAPI.Paths.BASE_PATH;

import java.lang.reflect.Method;
import java.net.URI;
import java.util.Map;

import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jmx.export.annotation.ManagedOperation;
import org.springframework.jmx.export.annotation.ManagedResource;
import org.springframework.stereotype.Service;

import io.swagger.v3.oas.annotations.Hidden;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.WebApplicationException;
import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.core.SecurityContext;
import jakarta.ws.rs.core.UriInfo;
import uk.ac.manchester.spinnaker.alloc.admin.MachineDefinitionLoader.Machine;
import uk.ac.manchester.spinnaker.alloc.model.GroupRecord;
import uk.ac.manchester.spinnaker.alloc.model.MemberRecord;
import uk.ac.manchester.spinnaker.alloc.model.UserRecord;
import uk.ac.manchester.spinnaker.alloc.web.RequestFailedException;
import uk.ac.manchester.spinnaker.machine.board.PhysicalCoords;
import uk.ac.manchester.spinnaker.machine.board.TriadCoords;

/**
 * Implements the service administration interface.
 *
 * @author Donal Fellows
 */
@Service("admin")
@Path(BASE_PATH)
@Hidden
@ManagedResource("Spalloc:type=Admin,name=admin")
public class AdminImpl implements AdminAPI {
        private static final Logger log = getLogger(AdminImpl.class);

        @Autowired
        private MachineDefinitionLoader loader;

        @Autowired
        private MachineStateControl machineController;

        @Autowired
        private UserControl userManager;

        @Override
        public void importMachinesByContent(
                        MachineDefinitionLoader.Configuration definitions) {
                log.warn("CALLED importMachinesByContent({})", definitions.machines()
                                .stream().map(Machine::getName).collect(toList()));
                loader.loadMachineDefinitions(definitions);
        }

        private static final Method DESCRIBE_GROUP;

        private static final Method DESCRIBE_USER;

        private static final Method DESCRIBE_MEMBER;

        static {
                try {
                        DESCRIBE_GROUP = AdminAPI.class.getMethod("describeGroup",
                                        int.class, UriInfo.class);
                        DESCRIBE_USER = AdminAPI.class.getMethod("describeUser", int.class,
                                        UriInfo.class);
                        DESCRIBE_MEMBER = AdminAPI.class.getMethod("describeMember",
                                        int.class, int.class, UriInfo.class);
                } catch (NoSuchMethodException | SecurityException e) {
                        throw new RuntimeException("failed to discover method signatures",
                                        e);
                }
        }

        private static WebApplicationException noBoard() {
                return new WebApplicationException("no such board", NOT_FOUND);
        }

        private static WebApplicationException noUser() {
                return new WebApplicationException("no such user", NOT_FOUND);
        }

        private static WebApplicationException noGroup() {
                return new WebApplicationException("no such group", NOT_FOUND);
        }

        private static WebApplicationException noMember() {
                return new WebApplicationException("no such membership", NOT_FOUND);
        }

        @Override
        public boolean getBoardStateXYZ(String name, int x, int y, int z) {
                log.info("CALLED boardState({}:XYZ=({},{},{}))", name, x, y, z);
                var board = machineController.findTriad(name, new TriadCoords(x, y, z))
                                .orElseThrow(AdminImpl::noBoard);
                return board.getState();
        }

        @Override
        @ManagedOperation
        public boolean setBoardStateXYZ(String name, int x, int y, int z,
                        boolean enabled) {
                log.warn("CALLED boardState({}:XYZ=({},{},{})) := {}", name, x, y, z,
                                enabled);
                var board = machineController.findTriad(name, new TriadCoords(x, y, z))
                                .orElseThrow(AdminImpl::noBoard);
                board.setState(enabled);
                return board.getState();
        }

        @Override
        public boolean getBoardStateCFB(String name, int c, int f, int b) {
                log.info("CALLED boardState({}:CFB=({},{},{}))", name, c, f, b);
                var board = machineController
                                .findPhysical(name, new PhysicalCoords(c, f, b))
                                .orElseThrow(AdminImpl::noBoard);
                return board.getState();
        }

        @Override
        @ManagedOperation
        public boolean setBoardStateCFB(String name, int c, int f, int b,
                        boolean enabled) {
                log.warn("CALLED boardState({}:CFB=({},{},{})) := {}", name, c, f, b,
                                enabled);
                var board = machineController
                                .findPhysical(name, new PhysicalCoords(c, f, b))
                                .orElseThrow(AdminImpl::noBoard);
                board.setState(enabled);
                return board.getState();
        }

        @Override
        public boolean getBoardStateAddress(String name, String address) {
                log.info("CALLED boardState({}:IP=({}))", name, address);
                var board = machineController.findIP(name, address)
                                .orElseThrow(AdminImpl::noBoard);
                return board.getState();
        }

        @Override
        @ManagedOperation
        public boolean setBoardStateAddress(String name, String address,
                        boolean enabled) {
                log.warn("CALLED boardState({}:IP=({})) := {}", name, address, enabled);
                var board = machineController.findIP(name, address)
                                .orElseThrow(AdminImpl::noBoard);
                board.setState(enabled);
                return board.getState();
        }

        @Override
        public Map<String, URI> listUsers(UriInfo ui) {
                log.info("CALLED listUsers()");
                var ub = ui.getBaseUriBuilder().path(DESCRIBE_USER);
                return userManager.listUsers(user -> ub.build(user.getUserId()));
        }

        @Override
        public Response createUser(UserRecord providedUser, UriInfo ui) {
                log.warn("CALLED createUser({})", providedUser.getUserName());
                providedUser.initCreationDefaults();
                var realUser = userManager.createUser(providedUser)
                                .orElseThrow(() -> new RequestFailedException(NOT_MODIFIED,
                                                "user already exists"));
                var ub = ui.getBaseUriBuilder().path(DESCRIBE_USER);
                int id = realUser.getUserId();
                return created(ub.build(id)).type(APPLICATION_JSON)
                                .entity(realUser.sanitise()).build();
        }

        @Override
        public UserRecord describeUser(int id, UriInfo ui) {
                log.info("CALLED describeUser({})", id);
                var ub = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);
                return userManager.getUser(id, m -> ub.build(m.getGroupId()))
                                .orElseThrow(AdminImpl::noUser).sanitise();
        }

        @Override
        public UserRecord updateUser(int id, UserRecord providedUser, UriInfo ui,
                        SecurityContext security) {
                log.warn("CALLED updateUser({})", providedUser.getUserName());
                var adminUser = security.getUserPrincipal().getName();
                providedUser.setUserId(null);
                var ub = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);
                return userManager
                                .updateUser(id, providedUser, adminUser,
                                                m -> ub.build(m.getGroupId()))
                                .orElseThrow(AdminImpl::noUser).sanitise();
        }

        @Override
        public String deleteUser(int id, SecurityContext security) {
                log.warn("CALLED deleteUser({})", id);
                var adminUser = security.getUserPrincipal().getName();
                return "deleted user " + userManager.deleteUser(id, adminUser)
                                .orElseThrow(AdminImpl::noUser);
        }

        @Override
        public Map<String, URI> listGroups(UriInfo ui) {
                log.warn("CALLED listGroups()");
                var ub = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);
                return userManager.listGroups(g -> ub.build(g.getGroupId()));
        }

        @Override
        public Response createGroup(GroupRecord group, UriInfo ui) {
                log.warn("CALLED createGroup({})", group.getGroupName());
                var realGroup = userManager.createGroup(group, group.getType())
                                .orElseThrow(() -> new WebApplicationException(
                                                "group already exists", BAD_REQUEST));
                var ub = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);
                return created(ub.build(realGroup.getGroupId())).type(APPLICATION_JSON)
                                .entity(realGroup).build();
        }

        @Override
        public GroupRecord describeGroup(int groupId, UriInfo ui) {
                log.warn("CALLED describeGroup({})", groupId);
                var ub = ui.getBaseUriBuilder().path(DESCRIBE_MEMBER);
                return userManager.getGroup(groupId, m -> ub.build(groupId, m.getId()))
                                .orElseThrow(AdminImpl::noGroup);
        }

        @Override
        public GroupRecord updateGroup(int groupId, GroupRecord group, UriInfo ui) {
                log.warn("CALLED updateGroup({})", groupId);
                var ub = ui.getBaseUriBuilder().path(DESCRIBE_MEMBER);
                return userManager
                                .updateGroup(groupId, group,
                                                m -> ub.build(group.getGroupId(), m.getId()))
                                .orElseThrow(AdminImpl::noGroup);
        }

        @Override
        public String deleteGroup(int groupId) {
                log.warn("CALLED deleteGroup({})", groupId);
                return "deleted group " + userManager.deleteGroup(groupId)
                                .orElseThrow(AdminImpl::noGroup);
        }

        @Override
        public Response addMember(int groupId, MemberRecord request, UriInfo ui) {
                var userName = request.getUserName();
                log.warn("CALLED addMember({},{})", groupId, userName);
                var ub = ui.getBaseUriBuilder().path(DESCRIBE_MEMBER);
                var group = userManager.getGroup(groupId, null)
                                .orElseThrow(AdminImpl::noGroup);
                var user = userManager.getUser(userName, null)
                                .orElseThrow(AdminImpl::noUser);
                return userManager.addUserToGroup(user, group)
                                .map(member -> created(ub.build(member.getId()))
                                                .type(APPLICATION_JSON).entity(member))
                                .orElseThrow(() -> new WebApplicationException(
                                                "user already a member of group", BAD_REQUEST))
                                .build();
        }

        @Override
        public MemberRecord describeMember(int groupId, int memberId, UriInfo ui) {
                log.warn("CALLED describeMember({},{})", groupId, memberId);
                var ubGroup = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);
                var ubUser = ui.getBaseUriBuilder().path(DESCRIBE_USER);
                return userManager
                                .describeMembership(memberId,
                                                m -> ubGroup.build(m.getGroupId()),
                                                m -> ubUser.build(m.getUserId()))
                                .orElseThrow(AdminImpl::noMember);
        }

        @Override
        public Response removeMember(int groupId, int memberId) {
                log.warn("CALLED removeMember({groupId},{memberId})");
                var group = userManager.getGroup(groupId, null)
                                .orElseThrow(AdminImpl::noGroup);
                var member = userManager.describeMembership(memberId, null, null)
                                .orElseThrow(AdminImpl::noMember);
                if (!userManager.removeMembershipOfGroup(member, group)) {
                        throw new WebApplicationException("remove failed", BAD_REQUEST);
                }
                return noContent().build();
        }
}

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.admin;
17
18	import static jakarta.ws.rs.core.MediaType.APPLICATION_JSON;
19	import static jakarta.ws.rs.core.Response.created;
20	import static jakarta.ws.rs.core.Response.noContent;
21	import static jakarta.ws.rs.core.Response.Status.BAD_REQUEST;
22	import static jakarta.ws.rs.core.Response.Status.NOT_FOUND;
23	import static jakarta.ws.rs.core.Response.Status.NOT_MODIFIED;
24	import static java.util.stream.Collectors.toList;
25	import static org.slf4j.LoggerFactory.getLogger;
26	import static uk.ac.manchester.spinnaker.alloc.admin.AdminAPI.Paths.BASE_PATH;
27
28	import java.lang.reflect.Method;
29	import java.net.URI;
30	import java.util.Map;
31
32	import org.slf4j.Logger;
33	import org.springframework.beans.factory.annotation.Autowired;
34	import org.springframework.jmx.export.annotation.ManagedOperation;
35	import org.springframework.jmx.export.annotation.ManagedResource;
36	import org.springframework.stereotype.Service;
37
38	import io.swagger.v3.oas.annotations.Hidden;
39	import jakarta.ws.rs.Path;
40	import jakarta.ws.rs.WebApplicationException;
41	import jakarta.ws.rs.core.Response;
42	import jakarta.ws.rs.core.SecurityContext;
43	import jakarta.ws.rs.core.UriInfo;
44	import uk.ac.manchester.spinnaker.alloc.admin.MachineDefinitionLoader.Machine;
45	import uk.ac.manchester.spinnaker.alloc.model.GroupRecord;
46	import uk.ac.manchester.spinnaker.alloc.model.MemberRecord;
47	import uk.ac.manchester.spinnaker.alloc.model.UserRecord;
48	import uk.ac.manchester.spinnaker.alloc.web.RequestFailedException;
49	import uk.ac.manchester.spinnaker.machine.board.PhysicalCoords;
50	import uk.ac.manchester.spinnaker.machine.board.TriadCoords;
51
52	/**
53	* Implements the service administration interface.
54	*
55	* @author Donal Fellows
56	*/
57	@Service("admin")
58	@Path(BASE_PATH)
59	@Hidden
60	@ManagedResource("Spalloc:type=Admin,name=admin")
61	public class AdminImpl implements AdminAPI {	1✔
62	private static final Logger log = getLogger(AdminImpl.class);	1✔
63
64	@Autowired
65	private MachineDefinitionLoader loader;
66
67	@Autowired
68	private MachineStateControl machineController;
69
70	@Autowired
71	private UserControl userManager;
72
73	@Override
74	public void importMachinesByContent(
75	MachineDefinitionLoader.Configuration definitions) {
76	log.warn("CALLED importMachinesByContent({})", definitions.machines()	×
77	.stream().map(Machine::getName).collect(toList()));	×
78	loader.loadMachineDefinitions(definitions);	×
79	}	×
80
81	private static final Method DESCRIBE_GROUP;
82
83	private static final Method DESCRIBE_USER;
84
85	private static final Method DESCRIBE_MEMBER;
86
87	static {
88	try {
89	DESCRIBE_GROUP = AdminAPI.class.getMethod("describeGroup",	1✔
90	int.class, UriInfo.class);
91	DESCRIBE_USER = AdminAPI.class.getMethod("describeUser", int.class,	1✔
92	UriInfo.class);
93	DESCRIBE_MEMBER = AdminAPI.class.getMethod("describeMember",	1✔
94	int.class, int.class, UriInfo.class);
95	} catch (NoSuchMethodException \| SecurityException e) {	×
96	throw new RuntimeException("failed to discover method signatures",	×
97	e);
98	}	1✔
99	}	1✔
100
101	private static WebApplicationException noBoard() {
102	return new WebApplicationException("no such board", NOT_FOUND);	×
103	}
104
105	private static WebApplicationException noUser() {
106	return new WebApplicationException("no such user", NOT_FOUND);	×
107	}
108
109	private static WebApplicationException noGroup() {
110	return new WebApplicationException("no such group", NOT_FOUND);	×
111	}
112
113	private static WebApplicationException noMember() {
114	return new WebApplicationException("no such membership", NOT_FOUND);	×
115	}
116
117	@Override
118	public boolean getBoardStateXYZ(String name, int x, int y, int z) {
119	log.info("CALLED boardState({}:XYZ=({},{},{}))", name, x, y, z);	×
120	var board = machineController.findTriad(name, new TriadCoords(x, y, z))	×
121	.orElseThrow(AdminImpl::noBoard);	×
122	return board.getState();	×
123	}
124
125	@Override
126	@ManagedOperation
127	public boolean setBoardStateXYZ(String name, int x, int y, int z,
128	boolean enabled) {
129	log.warn("CALLED boardState({}:XYZ=({},{},{})) := {}", name, x, y, z,	×
130	enabled);	×
131	var board = machineController.findTriad(name, new TriadCoords(x, y, z))	×
132	.orElseThrow(AdminImpl::noBoard);	×
133	board.setState(enabled);	×
134	return board.getState();	×
135	}
136
137	@Override
138	public boolean getBoardStateCFB(String name, int c, int f, int b) {
139	log.info("CALLED boardState({}:CFB=({},{},{}))", name, c, f, b);	×
140	var board = machineController	×
141	.findPhysical(name, new PhysicalCoords(c, f, b))	×
142	.orElseThrow(AdminImpl::noBoard);	×
143	return board.getState();	×
144	}
145
146	@Override
147	@ManagedOperation
148	public boolean setBoardStateCFB(String name, int c, int f, int b,
149	boolean enabled) {
150	log.warn("CALLED boardState({}:CFB=({},{},{})) := {}", name, c, f, b,	×
151	enabled);	×
152	var board = machineController	×
153	.findPhysical(name, new PhysicalCoords(c, f, b))	×
154	.orElseThrow(AdminImpl::noBoard);	×
155	board.setState(enabled);	×
156	return board.getState();	×
157	}
158
159	@Override
160	public boolean getBoardStateAddress(String name, String address) {
161	log.info("CALLED boardState({}:IP=({}))", name, address);	×
162	var board = machineController.findIP(name, address)	×
163	.orElseThrow(AdminImpl::noBoard);	×
164	return board.getState();	×
165	}
166
167	@Override
168	@ManagedOperation
169	public boolean setBoardStateAddress(String name, String address,
170	boolean enabled) {
171	log.warn("CALLED boardState({}:IP=({})) := {}", name, address, enabled);	×
172	var board = machineController.findIP(name, address)	×
173	.orElseThrow(AdminImpl::noBoard);	×
174	board.setState(enabled);	×
175	return board.getState();	×
176	}
177
178	@Override
179	public Map<String, URI> listUsers(UriInfo ui) {
180	log.info("CALLED listUsers()");	×
181	var ub = ui.getBaseUriBuilder().path(DESCRIBE_USER);	×
182	return userManager.listUsers(user -> ub.build(user.getUserId()));	×
183	}
184
185	@Override
186	public Response createUser(UserRecord providedUser, UriInfo ui) {
187	log.warn("CALLED createUser({})", providedUser.getUserName());	×
188	providedUser.initCreationDefaults();	×
189	var realUser = userManager.createUser(providedUser)	×
190	.orElseThrow(() -> new RequestFailedException(NOT_MODIFIED,	×
191	"user already exists"));
192	var ub = ui.getBaseUriBuilder().path(DESCRIBE_USER);	×
193	int id = realUser.getUserId();	×
194	return created(ub.build(id)).type(APPLICATION_JSON)	×
195	.entity(realUser.sanitise()).build();	×
196	}
197
198	@Override
199	public UserRecord describeUser(int id, UriInfo ui) {
200	log.info("CALLED describeUser({})", id);	×
201	var ub = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);	×
202	return userManager.getUser(id, m -> ub.build(m.getGroupId()))	×
203	.orElseThrow(AdminImpl::noUser).sanitise();	×
204	}
205
206	@Override
207	public UserRecord updateUser(int id, UserRecord providedUser, UriInfo ui,
208	SecurityContext security) {
209	log.warn("CALLED updateUser({})", providedUser.getUserName());	×
210	var adminUser = security.getUserPrincipal().getName();	×
211	providedUser.setUserId(null);	×
212	var ub = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);	×
213	return userManager	×
214	.updateUser(id, providedUser, adminUser,	×
215	m -> ub.build(m.getGroupId()))	×
216	.orElseThrow(AdminImpl::noUser).sanitise();	×
217	}
218
219	@Override
220	public String deleteUser(int id, SecurityContext security) {
221	log.warn("CALLED deleteUser({})", id);	×
222	var adminUser = security.getUserPrincipal().getName();	×
223	return "deleted user " + userManager.deleteUser(id, adminUser)	×
224	.orElseThrow(AdminImpl::noUser);	×
225	}
226
227	@Override
228	public Map<String, URI> listGroups(UriInfo ui) {
229	log.warn("CALLED listGroups()");	×
230	var ub = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);	×
231	return userManager.listGroups(g -> ub.build(g.getGroupId()));	×
232	}
233
234	@Override
235	public Response createGroup(GroupRecord group, UriInfo ui) {
236	log.warn("CALLED createGroup({})", group.getGroupName());	×
237	var realGroup = userManager.createGroup(group, group.getType())	×
238	.orElseThrow(() -> new WebApplicationException(	×
239	"group already exists", BAD_REQUEST));
240	var ub = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);	×
241	return created(ub.build(realGroup.getGroupId())).type(APPLICATION_JSON)	×
242	.entity(realGroup).build();	×
243	}
244
245	@Override
246	public GroupRecord describeGroup(int groupId, UriInfo ui) {
247	log.warn("CALLED describeGroup({})", groupId);	×
248	var ub = ui.getBaseUriBuilder().path(DESCRIBE_MEMBER);	×
249	return userManager.getGroup(groupId, m -> ub.build(groupId, m.getId()))	×
250	.orElseThrow(AdminImpl::noGroup);	×
251	}
252
253	@Override
254	public GroupRecord updateGroup(int groupId, GroupRecord group, UriInfo ui) {
255	log.warn("CALLED updateGroup({})", groupId);	×
256	var ub = ui.getBaseUriBuilder().path(DESCRIBE_MEMBER);	×
257	return userManager	×
258	.updateGroup(groupId, group,	×
259	m -> ub.build(group.getGroupId(), m.getId()))	×
260	.orElseThrow(AdminImpl::noGroup);	×
261	}
262
263	@Override
264	public String deleteGroup(int groupId) {
265	log.warn("CALLED deleteGroup({})", groupId);	×
266	return "deleted group " + userManager.deleteGroup(groupId)	×
267	.orElseThrow(AdminImpl::noGroup);	×
268	}
269
270	@Override
271	public Response addMember(int groupId, MemberRecord request, UriInfo ui) {
272	var userName = request.getUserName();	×
273	log.warn("CALLED addMember({},{})", groupId, userName);	×
274	var ub = ui.getBaseUriBuilder().path(DESCRIBE_MEMBER);	×
275	var group = userManager.getGroup(groupId, null)	×
276	.orElseThrow(AdminImpl::noGroup);	×
277	var user = userManager.getUser(userName, null)	×
278	.orElseThrow(AdminImpl::noUser);	×
279	return userManager.addUserToGroup(user, group)	×
280	.map(member -> created(ub.build(member.getId()))	×
281	.type(APPLICATION_JSON).entity(member))	×
282	.orElseThrow(() -> new WebApplicationException(	×
283	"user already a member of group", BAD_REQUEST))
284	.build();	×
285	}
286
287	@Override
288	public MemberRecord describeMember(int groupId, int memberId, UriInfo ui) {
289	log.warn("CALLED describeMember({},{})", groupId, memberId);	×
290	var ubGroup = ui.getBaseUriBuilder().path(DESCRIBE_GROUP);	×
291	var ubUser = ui.getBaseUriBuilder().path(DESCRIBE_USER);	×
292	return userManager	×
293	.describeMembership(memberId,	×
294	m -> ubGroup.build(m.getGroupId()),	×
295	m -> ubUser.build(m.getUserId()))	×
296	.orElseThrow(AdminImpl::noMember);	×
297	}
298
299	@Override
300	public Response removeMember(int groupId, int memberId) {
301	log.warn("CALLED removeMember({groupId},{memberId})");	×
302	var group = userManager.getGroup(groupId, null)	×
303	.orElseThrow(AdminImpl::noGroup);	×
304	var member = userManager.describeMembership(memberId, null, null)	×
305	.orElseThrow(AdminImpl::noMember);	×
306	if (!userManager.removeMembershipOfGroup(member, group)) {	×
307	throw new WebApplicationException("remove failed", BAD_REQUEST);	×
308	}
309	return noContent().build();	×
310	}
311	}

SpiNNakerManchester / JavaSpiNNaker / 6310285782

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