More spalloc rest calls

SpiNNaker-allocserv/pom.xml

@@ -165,30 +165,6 @@ limitations under the License.
 					</execution>
 				</executions>
 			</plugin>
-			<plugin>
-				<groupId>uk.co.automatictester</groupId>
-				<artifactId>truststore-maven-plugin</artifactId>
-				<executions>
-					<execution>
-						<id>generate-truststore</id>
-						<goals>
-							<goal>generate-truststore</goal>
-						</goals>
-						<phase>generate-resources</phase>
-						<configuration>
-							<truststoreFile>${truststore.file}</truststoreFile>
-							<truststorePassword>${truststore.pass}</truststorePassword>
-							<servers>
-								<server>${ebrains.wellknown.server}:443</server>
-								<!-- Skip things that are down -->
-								<!--
-								<server>${ebrains.wellknown.server.dev}:443</server>
-								-->
-							</servers>
-						</configuration>
-					</execution>
-				</executions>
-			</plugin>
 		</plugins>
 
 		<pluginManagement>
@@ -563,6 +539,40 @@ limitations under the License.
 				</plugins>
 			</build>
 		</profile>
+		<profile>
+			<id>generate-truststore</id>
+			<activation>
+				<activeByDefault>true</activeByDefault>
+			</activation>
+			<build>
+				<plugins>
+					<plugin>
+						<groupId>uk.co.automatictester</groupId>
+						<artifactId>truststore-maven-plugin</artifactId>
+						<executions>
+							<execution>
+								<id>generate-truststore</id>
+								<goals>
+									<goal>generate-truststore</goal>
+								</goals>
+								<phase>generate-resources</phase>
+								<configuration>
+									<truststoreFile>${truststore.file}</truststoreFile>
+									<truststorePassword>${truststore.pass}</truststorePassword>
+									<servers>
+										<server>${ebrains.wellknown.server}:443</server>
+										<!-- Skip things that are down -->
+										<!--
+										<server>${ebrains.wellknown.server.dev}:443</server>
+										-->
+									</servers>
+								</configuration>
+							</execution>
+						</executions>
+					</plugin>
+				</plugins>
+			</build>
+		</profile>
 		<profile>
 			<id>windows-specific-bits</id>
 			<activation>

SpiNNaker-allocserv/src/main/java/uk/ac/manchester/spinnaker/alloc/allocator/AllocatorTask.java

@@ -125,7 +125,7 @@ public class AllocatorTask extends DatabaseAwareBean
 	private HistoricalDataProperties historyProps;
 
 	@Autowired
-	private ProxyRememberer rememberer;
+	private JobObjectRememberer rememberer;
 
 	@Autowired
 	private TaskScheduler scheduler;
@@ -984,7 +984,7 @@ private Collection<BMPAndMachine> destroyJob(Connection conn, int id,
 			return bmps;
 		} finally {
 			quotaManager.finishJob(id);
-			rememberer.killProxies(id);
+			rememberer.closeJob(id);
 		}
 	}
 
@@ -1245,7 +1245,7 @@ private Collection<BMPAndMachine> setAllocation(AllocSQL sql, int jobId,
 		log.info("allocated {} boards to {}; issuing power up commands",
 				boardsToAllocate.size(), jobId);
 		// Any proxies that existed are now defunct; user must make anew
-		rememberer.killProxies(jobId);
+		rememberer.closeJob(jobId);
 		return setPower(sql, jobId, ON, READY);
 	}
 

SpiNNaker-allocserv/src/main/java/uk/ac/manchester/spinnaker/alloc/allocator/JobObjectRememberer.java

@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) 2025 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.allocator;
+
+import static java.util.Objects.nonNull;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.PreDestroy;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.stereotype.Component;
+
+import com.google.errorprone.annotations.concurrent.GuardedBy;
+
+import uk.ac.manchester.spinnaker.alloc.proxy.ProxyCore;
+import uk.ac.manchester.spinnaker.machine.ChipLocation;
+import uk.ac.manchester.spinnaker.protocols.FastDataIn;
+import uk.ac.manchester.spinnaker.protocols.download.Downloader;
+import uk.ac.manchester.spinnaker.transceiver.TransceiverInterface;
+
+/**
+ * Remembers job objects so that they can be closed when the state of a
+ * job invalidates them. This class takes care to be thread-safe. The
+ * information it holds is <em>not</em> persistent.
+ *
+ * @author Donal Fellows
+ */
+@Component
+class JobObjectRememberer {
+
+	private static final Log log = LogFactory.getLog(JobObjectRememberer.class);
+
+	@GuardedBy("this")
+	private final Map<Integer, List<ProxyCore>> proxies = new HashMap<>();
+
+	@GuardedBy("this")
+	private final Map<Integer, TransceiverInterface> transceivers =
+			new HashMap<>();
+
+	private final Map<Integer, Map<ChipLocation, FastDataIn>> fastDataCache =
+			new HashMap<>();
+
+	private final Map<Integer, Map<ChipLocation, Downloader>> downloaders =
+			new HashMap<>();
+
+	/**
+	 * Called when service is shutting down. Kill <em>everything!</em>
+	 */
+	@PreDestroy
+	private synchronized void closeAll() {
+		proxies.values().forEach(list -> list.forEach(ProxyCore::close));
+		proxies.clear(); // Just in case
+		transceivers.values().forEach(txrx -> {
+			try {
+				txrx.close();
+			} catch (IOException e) {
+				log.error("Error closing Transceiver", e);
+			}
+		});
+		transceivers.clear(); // Just in case
+		fastDataCache.values().forEach(map -> map.values().forEach(fdi -> {
+			try {
+				fdi.close();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}));
+		fastDataCache.clear(); // Just in case
+		downloaders.values().forEach(map -> map.values().forEach(dl -> {
+			try {
+				dl.close();
+			} catch (IOException e) {
+				// TODO Auto-generated catch block
+				e.printStackTrace();
+			}
+		}));
+	}
+
+	/**
+	 * Note down that a job has a websocket proxy active.
+	 *
+	 * @param jobId
+	 *            The job ID.
+	 * @param proxy
+	 *            The websocket proxy.
+	 */
+	synchronized void rememberProxyForJob(Integer jobId, ProxyCore proxy) {
+		proxies.computeIfAbsent(jobId, __ -> new ArrayList<>()).add(proxy);
+	}
+
+	/**
+	 * Stop remembering a job's particular websocket proxy.
+	 *
+	 * @param jobId
+	 *            The job ID.
+	 * @param proxy
+	 *            The websocket proxy.
+	 */
+	synchronized void removeProxyForJob(Integer jobId, ProxyCore proxy) {
+		var list = proxies.get(jobId);
+		if (nonNull(list)) {
+			list.remove(proxy);
+		}
+	}
+
+	/*
+	 * Get the transceiver for a job.
+	 *
+	 * @param jobId The job ID.
+	 *
+	 * @return The transceiver or null if none.
+	 */
+	synchronized TransceiverInterface getTransceiverForJob(int jobId) {
+		return transceivers.get(jobId);
+	}
+
+	/** Set the transceiver for a job.
+	 *
+	 * @param jobId The job ID.
+	 * @param txrx The transceiver.
+	 */
+	synchronized void rememberTransceiverForJob(Integer jobId,
+			TransceiverInterface txrx) {
+		transceivers.put(jobId, txrx);
+	}
+
+	/** Get the fast data in for a job.
+	 *
+	 * @param jobId The job ID.
+	 * @param chip  The ethernet chip to get the fast data in for.
+	 * @return The fast data in or null if none.
+	 */
+	synchronized FastDataIn getFastDataIn(Integer jobId, ChipLocation chip) {
+		return fastDataCache.getOrDefault(jobId, Map.of()).get(chip);
+	}
+
+	/**
+	 * Remember the fast data in for a job.
+	 *
+	 * @param jobId The job ID.
+	 * @param chip  The ethernet chip to remember the fast data in for.
+	 * @param fdi   The fast data in.
+	 */
+	synchronized void rememberFastDataIn(Integer jobId, ChipLocation chip,
+			FastDataIn fdi) {
+		fastDataCache.computeIfAbsent(jobId, __ -> new HashMap<>()).put(
+				chip, fdi);
+	}
+
+	/**
+	 * Get the downloader for a job.
+	 *
+	 * @param jobId The job ID.
+	 * @param chip  The ethernet chip to get the downloader for.
+	 * @return The downloader or null if none.
+	 */
+	synchronized Downloader getDownloader(Integer jobId, ChipLocation chip) {
+		return downloaders.getOrDefault(jobId, Map.of()).get(chip);
+	}
+
+	/**
+	 * Remember the downloader for a job.
+	 *
+	 * @param jobId      The job ID.
+	 * @param chip       The ethernet chip to remember the downloader for.
+	 * @param downloader The downloader.
+	 */
+	synchronized void rememberDownloader(Integer jobId, ChipLocation chip,
+			Downloader downloader) {
+		downloaders.computeIfAbsent(jobId, __ -> new HashMap<>()).put(
+				chip, downloader);
+	}
+
+	/**
+	 * Close all remembered objects for a job. This is called when the
+	 * state of a job changes significantly (i.e., when the set of boards that
+	 * may be communicated with changes).
+	 *
+	 * @param jobId
+	 *            The job ID.
+	 */
+	void closeJob(Integer jobId) {
+		synchronized (this) {
+			var proxyList = proxies.remove(jobId);
+			if (nonNull(proxyList)) {
+				proxyList.forEach(ProxyCore::close);
+			}
+			var txrx = transceivers.remove(jobId);
+			if (nonNull(txrx)) {
+				try {
+					txrx.close();
+				} catch (IOException e) {
+					log.error("Error closing Transceiver", e);
+				}
+			}
+			var fdc = fastDataCache.remove(jobId);
+			if (nonNull(fdc)) {
+				fdc.values().forEach(fdi -> {
+					try {
+						fdi.close();
+					} catch (IOException e) {
+						log.error("Error closing FastDataIn", e);
+					}
+				});
+			}
+			var dl = downloaders.remove(jobId);
+			if (nonNull(dl)) {
+				dl.values().forEach(downloader -> {
+					try {
+						downloader.close();
+					} catch (IOException e) {
+						log.error("Error closing Downloader", e);
+					}
+				});
+			}
+		}
+	}
+}