@Test public void testGetQueueItems() throws IOException, Exception{ ListView view1 = listView("view1"); view1.filterQueue = true; ListView view2 = listView("view2"); view2.filterQueue = true; FreeStyleProject inView1 = j.createFreeStyleProject("in-view1"); inView1.setAssignedLabel(j.jenkins.getLabelAtom("without-any-slave")); view1.add(inView1); MatrixProject inView2 = j.createMatrixProject("in-view2"); inView2.setAssignedLabel(j.jenkins.getLabelAtom("without-any-slave")); view2.add(inView2); FreeStyleProject notInView = j.createFreeStyleProject("not-in-view"); notInView.setAssignedLabel(j.jenkins.getLabelAtom("without-any-slave")); FreeStyleProject inBothViews = j.createFreeStyleProject("in-both-views"); inBothViews.setAssignedLabel(j.jenkins.getLabelAtom("without-any-slave")); view1.add(inBothViews); view2.add(inBothViews); Queue.getInstance().schedule(notInView, 0); Queue.getInstance().schedule(inView1, 0); Queue.getInstance().schedule(inView2, 0); Queue.getInstance().schedule(inBothViews, 0); Thread.sleep(1000); assertContainsItems(view1, inView1, inBothViews); assertNotContainsItems(view1, notInView, inView2); assertContainsItems(view2, inView2, inBothViews); assertNotContainsItems(view2, notInView, inView1); }
@Override public boolean cancel(boolean mayInterruptIfRunning) { Queue q = Hudson.getInstance().getQueue(); synchronized (q) { if (executor != null) { if (mayInterruptIfRunning) executor.interrupt(); return mayInterruptIfRunning; } return q.cancel(task); } }
@Override public boolean cancel(boolean mayInterruptIfRunning) { Queue q = Jenkins.getInstance().getQueue(); synchronized (q) { synchronized (this) { if (!executors.isEmpty()) { if (mayInterruptIfRunning) for (Executor e : executors) e.interrupt(); return mayInterruptIfRunning; } return q.cancel(task); } } }
private void assertNotContainsItems(View view, Task... items) { for (Task job: items) { assertFalse( "Queued items for " + view.getDisplayName() + " should not contain " + job.getDisplayName(), view.getQueueItems().contains(Queue.getInstance().getItem(job)) ); } }
/** * Called when a new {@link Computer} object is introduced (such as when Hudson started, or when a * new slave is added.) * * <p>The default implementation of this method delegates to {@link #check(Computer)}, but this * allows {@link RetentionStrategy} to distinguish the first time invocation from the rest. * * @since 1.275 */ public void start(final T c) { Queue.withLock( new Runnable() { @Override public void run() { check(c); } }); }
/** * Updates an existing node on disk. If the node instance is not in the list of nodes, then this * will be a no-op, even if there is another instance with the same {@link Node#getNodeName()}. * * @param node the node to be updated. * @return {@code true}, if the node was updated. {@code false}, if the node was not in the list * of nodes. * @throws IOException if the node could not be persisted. */ public boolean updateNode(final @Nonnull Node node) throws IOException { if (node == nodes.get(node.getNodeName())) { Queue.withLock( new Runnable() { @Override public void run() { jenkins.trimLabels(); } }); persistNode(node); return true; } return false; }
/** * Adds a node. If a node of the same name already exists then that node will be replaced. * * @param node the new node. * @throws IOException if the list of nodes could not be persisted. */ public void addNode(final @Nonnull Node node) throws IOException { if (node != nodes.get(node.getNodeName())) { // TODO we should not need to lock the queue for adding nodes but until we have a way to // update the // computer list for just the new node Queue.withLock( new Runnable() { @Override public void run() { nodes.put(node.getNodeName(), node); jenkins.updateComputerList(); jenkins.trimLabels(); } }); persistNode(node); } }
/** * Sets the list of nodes. * * @param nodes the new list of nodes. * @throws IOException if the new list of nodes could not be persisted. */ public void setNodes(final @Nonnull Collection<? extends Node> nodes) throws IOException { Queue.withLock( new Runnable() { @Override public void run() { Set<String> toRemove = new HashSet<String>(Nodes.this.nodes.keySet()); for (Node n : nodes) { final String name = n.getNodeName(); toRemove.remove(name); Nodes.this.nodes.put(name, n); } Nodes.this .nodes .keySet() .removeAll(toRemove); // directory clean up will be handled by save jenkins.updateComputerList(); jenkins.trimLabels(); } }); save(); }
/** * Removes a node. If the node instance is not in the list of nodes, then this will be a no-op, * even if there is another instance with the same {@link Node#getNodeName()}. * * @param node the node instance to remove. * @throws IOException if the list of nodes could not be persisted. */ public void removeNode(final @Nonnull Node node) throws IOException { if (node == nodes.get(node.getNodeName())) { Queue.withLock( new Runnable() { @Override public void run() { Computer c = node.toComputer(); if (c != null) { c.recordTermination(); c.disconnect(OfflineCause.create(hudson.model.Messages._Hudson_NodeBeingRemoved())); } if (node == nodes.remove(node.getNodeName())) { jenkins.updateComputerList(); jenkins.trimLabels(); } } }); // no need for a full save() so we just do the minimum Util.deleteRecursive(new File(getNodesDir(), node.getNodeName())); } }
/** Checks the persistence of queue. */ public void testPersistence() throws Exception { Queue q = hudson.getQueue(); // prevent execution to push stuff into the queue hudson.setNumExecutors(0); hudson.setNodes(hudson.getNodes()); FreeStyleProject testProject = createFreeStyleProject("test"); testProject.scheduleBuild(new UserCause()); q.save(); System.out.println(FileUtils.readFileToString(new File(hudson.getRootDir(), "queue.xml"))); assertEquals(1, q.getItems().length); q.clear(); assertEquals(0, q.getItems().length); // load the contents back q.load(); assertEquals(1, q.getItems().length); // did it bind back to the same object? assertSame(q.getItems()[0].task, testProject); }
/** * Loads the nodes from disk. * * @throws IOException if the nodes could not be deserialized. */ public void load() throws IOException { final File nodesDir = getNodesDir(); final File[] subdirs = nodesDir.listFiles( new FileFilter() { public boolean accept(File child) { return child.isDirectory(); } }); final Map<String, Node> newNodes = new TreeMap<String, Node>(); if (subdirs != null) { for (File subdir : subdirs) { try { XmlFile xmlFile = new XmlFile(Jenkins.XSTREAM, new File(subdir, "config.xml")); if (xmlFile.exists()) { Node node = (Node) xmlFile.read(); newNodes.put(node.getNodeName(), node); } } catch (IOException e) { Logger.getLogger(Nodes.class.getName()).log(Level.WARNING, "could not load " + subdir, e); } } } Queue.withLock( new Runnable() { @Override public void run() { for (Iterator<Map.Entry<String, Node>> i = nodes.entrySet().iterator(); i.hasNext(); ) { if (!(i.next().getValue() instanceof EphemeralNode)) { i.remove(); } } nodes.putAll(newNodes); jenkins.updateComputerList(); jenkins.trimLabels(); } }); }
/** Can {@link Queue} successfully recover removal? */ public void testPersistence2() throws Exception { Queue q = hudson.getQueue(); // prevent execution to push stuff into the queue hudson.setNumExecutors(0); hudson.setNodes(hudson.getNodes()); FreeStyleProject testProject = createFreeStyleProject("test"); testProject.scheduleBuild(new UserCause()); q.save(); System.out.println(FileUtils.readFileToString(new File(hudson.getRootDir(), "queue.xml"))); assertEquals(1, q.getItems().length); q.clear(); assertEquals(0, q.getItems().length); // delete the project before loading the queue back testProject.delete(); q.load(); assertEquals(0, q.getItems().length); }
@Override @GuardedBy("hudson.model.Queue.lock") public long check(final SlaveComputer c) { if (c.isOffline() && c.isLaunchSupported()) { final HashMap<Computer, Integer> availableComputers = new HashMap<Computer, Integer>(); for (Computer o : Jenkins.getInstance().getComputers()) { if ((o.isOnline() || o.isConnecting()) && o.isPartiallyIdle() && o.isAcceptingTasks()) { final int idleExecutors = o.countIdle(); if (idleExecutors > 0) availableComputers.put(o, idleExecutors); } } boolean needComputer = false; long demandMilliseconds = 0; for (Queue.BuildableItem item : Queue.getInstance().getBuildableItems()) { // can any of the currently idle executors take this task? // assume the answer is no until we can find such an executor boolean needExecutor = true; for (Computer o : Collections.unmodifiableSet(availableComputers.keySet())) { Node otherNode = o.getNode(); if (otherNode != null && otherNode.canTake(item) == null) { needExecutor = false; final int availableExecutors = availableComputers.remove(o); if (availableExecutors > 1) { availableComputers.put(o, availableExecutors - 1); } else { availableComputers.remove(o); } break; } } // this 'item' cannot be built by any of the existing idle nodes, but it can be built by // 'c' Node checkedNode = c.getNode(); if (needExecutor && checkedNode != null && checkedNode.canTake(item) == null) { demandMilliseconds = System.currentTimeMillis() - item.buildableStartMilliseconds; needComputer = demandMilliseconds > inDemandDelay * 1000 * 60 /*MINS->MILLIS*/; break; } } if (needComputer) { // we've been in demand for long enough logger.log( Level.INFO, "Launching computer {0} as it has been in demand for {1}", new Object[] {c.getName(), Util.getTimeSpanString(demandMilliseconds)}); c.connect(false); } } else if (c.isIdle()) { final long idleMilliseconds = System.currentTimeMillis() - c.getIdleStartMilliseconds(); if (idleMilliseconds > idleDelay * 1000 * 60 /*MINS->MILLIS*/) { // we've been idle for long enough logger.log( Level.INFO, "Disconnecting computer {0} as it has been idle for {1}", new Object[] {c.getName(), Util.getTimeSpanString(idleMilliseconds)}); c.disconnect(new OfflineCause.IdleOfflineCause()); } else { // no point revisiting until we can be confident we will be idle return TimeUnit.MILLISECONDS.toMinutes( TimeUnit.MINUTES.toMillis(idleDelay) - idleMilliseconds); } } return 1; }
protected void doRun() { Queue q = queue.get(); if (q != null) q.maintain(); else cancel(); }