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

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 java.util.stream.Collectors.toList;
import static javax.ws.rs.core.MediaType.APPLICATION_JSON;
import static javax.ws.rs.core.Response.created;
import static javax.ws.rs.core.Response.noContent;
import static javax.ws.rs.core.Response.Status.BAD_REQUEST;
import static javax.ws.rs.core.Response.Status.NOT_FOUND;
import static javax.ws.rs.core.Response.Status.NOT_MODIFIED;
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 javax.ws.rs.Path;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.SecurityContext;
import javax.ws.rs.core.UriInfo;

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

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