/** * Returns the queue item if the owner is scheduled for execution in the queue, in REVERSE ORDER */ public List<Item> getQueuedItems() { LinkedList<Item> list = new LinkedList<Item>(); for (Item item : Jenkins.getInstance().getQueue().getItems()) { if (item.task == owner) { list.addFirst(item); } } return list; }
/** @deprecated Use {@link #doCancelItem} instead. */ @Deprecated @RequirePOST public HttpResponse doCancelQueue() throws IOException, ServletException { if(hasCancelPermission()){ Jenkins.getInstance().getQueue().cancel(this); } return HttpResponses.forwardToPreviousPage(); }
/** * Returns the first queue item if the owner is scheduled for execution in the queue. */ public Item getQueuedItem() { return Jenkins.getInstance().getQueue().getItem(owner); }
/** * Called from {@code queue.jelly} and {@code entries.jelly}. */ @RequirePOST public HttpResponse doCancelItem(@QueryParameter long id) throws IOException, ServletException { Item item = getItem(id); if (item != null) { if(item.hasCancelPermission()){ cancel(item); } } // else too late, ignore (JENKINS-14813) return HttpResponses.forwardToPreviousPage(); }
/** * Persists the queue contents to the disk. */ public void save() { if(BulkChange.contains(this)) return; if (Jenkins.getInstanceOrNull() == null) { return; } XmlFile queueFile = new XmlFile(XSTREAM, getXMLQueueFile()); lock.lock(); try { // write out the queue state we want to save State state = new State(); state.counter = WaitingItem.COUNTER.longValue(); // write out the tasks on the queue for (Item item: getItems()) { if(item.task instanceof TransientTask) continue; state.items.add(item); } try { queueFile.write(state); } catch (IOException e) { LOGGER.log(Level.WARNING, "Failed to write out the queue file " + getXMLQueueFile(), e); } } finally { lock.unlock(); } SaveableListener.fireOnChange(this, queueFile); }
pendings.clear(); File queueFile = getQueueFile(); if (queueFile.exists()) { try (BufferedReader in = Files.newBufferedReader(Util.fileToPath(queueFile), Charset.defaultCharset())) { String line; while ((line = in.readLine()) != null) { AbstractProject j = Jenkins.getInstance().getItemByFullName(line, AbstractProject.class); if (j != null) j.scheduleBuild(); queueFile = getXMLQueueFile(); if (queueFile.exists()) { Object unmarshaledObj = new XmlFile(XSTREAM, queueFile).read(); if (o instanceof Task) { schedule((Task)o, 0); } else if (o instanceof Item) { Item item = (Item)o; LOGGER.log(Level.WARNING, "Failed to load the queue file " + getXMLQueueFile(), e); } finally { updateSnapshot(); } } finally { lock.unlock();
/** * Tests {@link EventListener#gerritEvent(com.sonymobile.tools.gerrit.gerritevents.dto.GerritEvent)} * with a normal scenario, but with silentMode on. */ @Test public void testGerritEventSilentMode() { AbstractProject project = mockProject(); Queue queue = mockConfig(project); PowerMockito.mockStatic(ToGerritRunListener.class); ToGerritRunListener listener = PowerMockito.mock(ToGerritRunListener.class); PowerMockito.when(ToGerritRunListener.getInstance()).thenReturn(listener); GerritProject gP = mock(GerritProject.class); doReturn(true).when(gP).isInteresting(any(String.class), any(String.class), any(String.class)); when(gP.getFilePaths()).thenReturn(null); GerritTrigger trigger = Setup.createDefaultTrigger(null); Setup.setTrigger(trigger, project); trigger.setGerritProjects(Collections.nCopies(1, gP)); Whitebox.setInternalState(trigger, "job", project); PatchsetCreated event = Setup.createPatchsetCreated(); trigger.createListener().gerritEvent(event); verify(listener, never()).onTriggered(same(project), same(event)); verify(queue).schedule2(same(project), anyInt(), hasCauseActionContainingCause(null)); }
/** * Tests GerritTrigger.retriggerThisBuild when the trigger is configured for silentMode. */ @Test public void testRetriggerThisBuildSilent() { AbstractProject project = mockProject(); Queue queue = mockConfig(project); PowerMockito.mockStatic(ToGerritRunListener.class); ToGerritRunListener listener = PowerMockito.mock(ToGerritRunListener.class); PowerMockito.when(ToGerritRunListener.getInstance()).thenReturn(listener); AbstractBuild build = mock(AbstractBuild.class); when(build.getNumber()).thenReturn(1); when(build.getProject()).thenReturn(project); when(build.getParent()).thenReturn(project); PatchsetCreated event = Setup.createPatchsetCreated(); when(listener.isBuilding(project, event)).thenReturn(false); GerritTrigger trigger = Setup.createDefaultTrigger(project); Setup.setTrigger(trigger, project); trigger.setGerritProjects(Collections.<GerritProject>emptyList()); TriggerContext context = new TriggerContext(build, event, Collections.<TriggeredItemEntity>emptyList()); trigger.retriggerThisBuild(context); verify(listener, never()).onRetriggered(isA(Job.class), isA(PatchsetCreated.class), anyListOf(Run.class)); verify(queue).schedule2(same(project), eq(0), hasCauseActionContainingUserCause()); }
/** * Tests the schedule method of GerritTrigger. * It verifies that {@link AbstractProject#scheduleBuild2(int, hudson.model.Cause, hudson.model.Action...)} * gets called with an negative buildScheduleDelay 10000. */ @Test public void testScheduleWithMaximumBuildScheduleDelay() { Queue queue = mockJenkinsQueue(); AbstractProject project = mockProject(); mockPluginConfig(10000); PatchsetCreated event = Setup.createPatchsetCreated(); final GerritCause gerritCause = spy(new GerritCause(event, true)); GerritTrigger trigger = Setup.createDefaultTrigger(project); Setup.setTrigger(trigger, project); doReturn("http://mock.url").when(gerritCause).getUrl(); trigger.schedule(gerritCause, event); verify(queue).schedule2(same(project), eq(10000), hasCauseActionContainingCause(gerritCause)); }
gerritSlaves.add(new GerritSlave("slave1", "host1", 0)); gerritSlaves.add(new GerritSlave("slave2", "host2", 1)); // slave timeout is 1 second when(gerritTriggerMock.gerritSlavesToWaitFor("someGerritServer")).thenReturn(gerritSlaves); ReplicationFailedAction replicationFailedAction = item.getAction(ReplicationFailedAction.class); assertNotNull("Item should be tagged with replicationFailedAction", replicationFailedAction); assertTrue(replicationFailedAction.getReason().contains("slave2")); verify(queueMock, times(0)).maintain();
AbstractProject project = PowerMockito.mock(AbstractProject.class); when(project.getFullName()).thenReturn("MockedProject"); when(project.isBuildable()).thenReturn(false); Queue queue = mockConfig(project); PowerMockito.mockStatic(ToGerritRunListener.class); ToGerritRunListener listener = PowerMockito.mock(ToGerritRunListener.class); PowerMockito.when(ToGerritRunListener.getInstance()).thenReturn(listener); eventListener.gerritEvent(event); verifyZeroInteractions(listener); verify(project).addTrigger(same(trigger)); verify(project).getTriggers(); verify(project).isBuildable(); verify(queue, never()).schedule2(same(project), anyInt(), any(List.class)); verify(eventListener, never()).schedule( any(GerritTrigger.class),
/** * Mocks {@link Jenkins#getQueue()} and sets it up to return {@link ScheduleResult#created(Queue.WaitingItem)} on * any calls to {@link Queue#schedule2(Queue.Task, int, List)}. * * @param jenkins the jenkins mock. * @return the mocked queue. */ private static Queue mockQueue(Jenkins jenkins) { Queue queue = PowerMockito.mock(Queue.class); when(jenkins.getQueue()).thenReturn(queue); when(queue.schedule2(any(Queue.Task.class), anyInt(), anyList())).thenAnswer(new Answer<ScheduleResult>() { @Override public ScheduleResult answer(InvocationOnMock invocation) throws Throwable { Object[] arguments = invocation.getArguments(); Queue.WaitingItem i = new Queue.WaitingItem( new GregorianCalendar(), (Queue.Task)arguments[0], (List<Action>)arguments[2]); return ScheduleResult.created(i); } }); return queue; } }
/** * Test that it should not block item when the elapsed time between the event reception time stamp and the * dispatcher get called is greater than the cache expiration time. * * Lets say that the cache expires after 6 hours, a build enter the queue and gets blocked by another * QueueTaskDispatcher for 7 hours and this dispatcher gets called after, we assume that we received the * replication event. We cannot cache the events forever otherwise will end up with serious memory issue. */ @Test public void shouldNotBlockItemWhenElapsedTimeIsGreaterThenCacheExpirationTime() { PatchsetCreated patchsetCreated = Setup.createPatchsetCreated("someGerritServer", "someProject", "refs/heads/master"); patchsetCreated.setReceivedOn(System.currentTimeMillis() - TimeUnit.MINUTES.toMillis(ReplicationCache.DEFAULT_EXPIRATION_IN_MINUTES)); Item item = createItem(patchsetCreated, new String[] {"slaveA", "slaveB"}); assertNull("Item should not be blocked", dispatcher.canRun(item)); verify(queueMock, times(0)).maintain(); }
@Override public String getStatus() { // Yet another copy of the same logic; perhaps this should be factored into some method returning a union of Queue.Item and PlaceholderExecutable? for (Queue.Item item : Queue.getInstance().getItems()) { if (item.task instanceof PlaceholderTask && ((PlaceholderTask) item.task).context.equals(getContext())) { return "waiting for " + item.task.getFullDisplayName() + " to be scheduled; blocked: " + item.getWhy(); } } Jenkins j = Jenkins.getInstance(); if (j != null) { COMPUTERS: for (Computer c : j.getComputers()) { for (Executor e : c.getExecutors()) { Queue.Executable exec = e.getCurrentExecutable(); if (exec instanceof PlaceholderTask.PlaceholderExecutable && ((PlaceholderTask.PlaceholderExecutable) exec).getParent().context.equals(getContext())) { return "running on " + c.getName(); } } } } return "node block appears to be neither running nor scheduled"; }
@Override public void stop(Throwable cause) throws Exception { for (Queue.Item item : Queue.getInstance().getItems()) { // if we are still in the queue waiting to be scheduled, just retract that if (item.task instanceof PlaceholderTask && ((PlaceholderTask) item.task).context.equals(getContext())) { Queue.getInstance().cancel(item); break; } } Jenkins j = Jenkins.getInstance(); if (j != null) { // if we are already running, kill the ongoing activities, which releases PlaceholderExecutable from its sleep loop // Similar to Executor.of, but distinct since we do not have the Executable yet: COMPUTERS: for (Computer c : j.getComputers()) { for (Executor e : c.getExecutors()) { Queue.Executable exec = e.getCurrentExecutable(); if (exec instanceof PlaceholderTask.PlaceholderExecutable && ((PlaceholderTask.PlaceholderExecutable) exec).getParent().context.equals(getContext())) { PlaceholderTask.finish(((PlaceholderTask.PlaceholderExecutable) exec).getParent().cookie); break COMPUTERS; } } } } // Whether or not either of the above worked (and they would not if for example our item were canceled), make sure we die. super.stop(cause); }
@CheckForNull Queue.Item scheduleBuild2(int quietPeriod, List<Action> actions) { if (!asJob().isBuildable()) return null; List<Action> queueActions = new ArrayList<Action>(actions); if (isParameterized() && Util.filter(queueActions, ParametersAction.class).isEmpty()) { queueActions.add(new ParametersAction(getDefaultParametersValues())); } return Jenkins.getInstance().getQueue().schedule2(asJob(), quietPeriod, queueActions).getItem(); }
Queue queue = Queue.getInstance(); if (this instanceof Queue.Task) { queue.cancel((Queue.Task) this); for (Queue.Item i : queue.getItems()) { Item item = Tasks.getItemOf(i.task); while (item != null) { if (item == this) { queue.cancel(i); break; for (Computer c : Jenkins.getInstance().getComputers()) { for (Executor e : c.getAllExecutors()) { final WorkUnit workUnit = e.getCurrentWorkUnit(); final Executable executable = workUnit != null ? workUnit.getExecutable() : null; final SubTask subtask = executable != null ? getParentOf(executable) : null; while (item != null) { if (item == this) { buildsInProgress.put(e, e.getCurrentExecutable()); e.interrupt(Result.ABORTED); break; Jenkins.getInstance().rebuildDependencyGraphAsync();
@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); } } }
WaitingItem item = Jenkins.getInstance().getQueue().schedule( getJob(), delay.getTimeInSeconds(), new ParametersAction(values), new CauseAction(new Cause.UserIdCause())); if (item!=null) {
private void cancelPreviousJobsInQueueThatMatch(@Nonnull StashCause stashCause) { logger.fine("Looking for queued jobs that match PR ID: " + stashCause.getPullRequestId()); Queue queue = Jenkins.getInstance().getQueue(); for (Queue.Item item : queue.getItems()) { if (hasCauseFromTheSamePullRequest(item.getCauses(), stashCause)) { logger.info("Canceling item in queue: " + item); queue.cancel(item); } } }