public void putSlave(SingularitySlave slave) { if (!active) { LOG.warn("putSlave {}, but not active", slave); } slaves.put(slave.getId(), slave); }
@JsonIgnore @Override public String getName() { return String.format("%s (%s)", getHost(), getId()); }
public Set<String> getSlaveIdsToTrackUsageFor() { List<SingularitySlave> slaves = getSlavesToTrackUsageFor(); Set<String> slaveIds = new HashSet<>(slaves.size()); for (SingularitySlave slave : slaves) { slaveIds.add(slave.getId()); } return slaveIds; }
@JsonIgnore public SingularitySlave withResources(MesosResourcesObject resources) { return new SingularitySlave(getId(), getFirstSeenAt(), getCurrentState(), host, rackId, attributes, Optional.of(resources)); }
@Override public SingularitySlave changeState(SingularityMachineStateHistoryUpdate newState) { return new SingularitySlave(getId(), getFirstSeenAt(), newState, host, rackId, attributes, resources); }
@DELETE @Path("/dead") public void clearAllDeadSlaves(@Auth SingularityUser user) { authorizationHelper.checkAdminAuthorization(user); manager.getObjectsFiltered(MachineState.DEAD).forEach((s) -> manager.deleteObject(s.getId())); } }
public List<SingularityTask> getTasksOnSlave(Collection<SingularityTaskId> activeTaskIds, SingularitySlave slave) { final List<SingularityTask> tasks = Lists.newArrayList(); final String sanitizedHost = JavaUtils.getReplaceHyphensWithUnderscores(slave.getHost()); for (SingularityTaskId activeTaskId : activeTaskIds) { if (activeTaskId.getSanitizedHost().equals(sanitizedHost)) { Optional<SingularityTask> maybeTask = getTask(activeTaskId); if (maybeTask.isPresent() && slave.getId().equals(maybeTask.get().getAgentId().getValue())) { tasks.add(maybeTask.get()); } } } return tasks; }
private void checkDeadSlaves() { final long start = System.currentTimeMillis(); final List<SingularitySlave> deadSlaves = slaveManager.getObjectsFiltered(MachineState.DEAD); if (deadSlaves.isEmpty()) { LOG.trace("No dead slaves"); return; } int deleted = 0; final long maxDuration = TimeUnit.HOURS.toMillis(configuration.getDeleteDeadSlavesAfterHours()); for (SingularitySlave deadSlave : slaveManager.getObjectsFiltered(MachineState.DEAD)) { final long duration = System.currentTimeMillis() - deadSlave.getCurrentState().getTimestamp(); if (duration > maxDuration) { SingularityDeleteResult result = slaveManager.deleteObject(deadSlave.getId()); deleted++; LOG.info("Removing dead slave {} ({}) after {} (max {})", deadSlave.getId(), result, JavaUtils.durationFromMillis(duration), JavaUtils.durationFromMillis(maxDuration)); } } LOG.debug("Checked {} dead slaves, deleted {} in {}", deadSlaves.size(), deleted, JavaUtils.duration(start)); }
@Test public void testSystemChangeClearsExpiringChangeIfInvalid() { SingularitySlave slave = getSingleSlave(); slaveResource.freezeSlave(singularityUser, slave.getId(), null); slaveResource.activateSlave(singularityUser, slave.getId(), new SingularityMachineChangeRequest(Optional.of(1L), Optional.absent(), Optional.absent(), Optional.of(MachineState.FROZEN), Optional.absent())); Assert.assertTrue(slaveManager.getExpiringObject(slave.getId()).isPresent()); slaveResource.decommissionSlave(singularityUser, slave.getId(), null); Assert.assertFalse(slaveManager.getExpiringObject(slave.getId()).isPresent()); }
@Test(expected = WebApplicationException.class) public void testInvalidTransitionToDecommissioned() { SingularitySlave slave = getSingleSlave(); slaveResource.decommissionSlave(singularityUser, slave.getId(), new SingularityMachineChangeRequest(Optional.of(1L), Optional.absent(), Optional.absent(), Optional.of(MachineState.DECOMMISSIONED), Optional.absent())); }
@Test(expected = WebApplicationException.class) public void testCannotUseStateReservedForSystem() { SingularitySlave slave = getSingleSlave(); slaveResource.freezeSlave(singularityUser, slave.getId(), new SingularityMachineChangeRequest(Optional.of(1L), Optional.absent(), Optional.absent(), Optional.of(MachineState.DEAD), Optional.absent())); }
@Test(expected = WebApplicationException.class) public void testBadExpiringStateTransition() { SingularitySlave slave = getSingleSlave(); slaveResource.decommissionSlave(singularityUser, slave.getId(), new SingularityMachineChangeRequest(Optional.of(1L), Optional.absent(), Optional.absent(), Optional.of(MachineState.FROZEN), Optional.absent())); }
@Test public void testExpiringMachineState() { MesosMasterStateObject state = getMasterState(1); singularitySlaveAndRackManager.loadSlavesAndRacksFromMaster(state, true); SingularitySlave slave = slaveManager.getObjects().get(0); slaveResource.freezeSlave(singularityUser, slave.getId(), new SingularityMachineChangeRequest(Optional.of(1L), Optional.absent(), Optional.absent(), Optional.of(MachineState.ACTIVE), Optional.absent())); Assert.assertEquals(MachineState.FROZEN, slaveManager.getObjects().get(0).getCurrentState().getState()); expiringUserActionPoller.runActionOnPoll(); Assert.assertEquals(MachineState.ACTIVE, slaveManager.getObjects().get(0).getCurrentState().getState()); }
!slave.getResources().get().getMemoryMegaBytes().isPresent() || !slave.getResources().get().getNumCpus().isPresent()) { LOG.debug("Could not find slave or resources for slave {}", slave.getId()); } else { memoryMbTotal = Optional.of(slave.getResources().get().getMemoryMegaBytes().get().longValue()); List<Long> slaveTimestamps = usageManager.getSlaveUsageTimestamps(slave.getId()); if (slaveTimestamps.size() + 1 > configuration.getNumUsageToKeep()) { usageManager.deleteSpecificSlaveUsage(slave.getId(), slaveTimestamps.get(0)); usageManager.saveSpecificSlaveUsageAndSetCurrent(slave.getId(), slaveUsage); } catch (Throwable t) { String message = String.format("Could not get slave usage for host %s", slave.getHost());
@Test public void testValidTransitionToDecommissioned() { initRequest(); initFirstDeploy(); requestResource.postRequest(request.toBuilder().setInstances(Optional.of(2)).build(), singularityUser); scheduler.drainPendingQueue(); resourceOffers(1); SingularitySlave slave = slaveManager.getObjects().get(0); slaveResource.decommissionSlave(singularityUser, slave.getId(), new SingularityMachineChangeRequest(Optional.of(1L), Optional.absent(), Optional.absent(), Optional.of(MachineState.DECOMMISSIONED), Optional.of(true))); Assert.assertEquals(MachineState.STARTING_DECOMMISSION, slaveManager.getObjects().get(0).getCurrentState().getState()); scheduler.checkForDecomissions(); scheduler.drainPendingQueue(); Assert.assertEquals(TaskCleanupType.DECOMISSIONING, taskManager.getCleanupTasks().get(0).getCleanupType()); expiringUserActionPoller.runActionOnPoll(); Assert.assertEquals(MachineState.DECOMMISSIONED, slaveManager.getObjects().get(0).getCurrentState().getState()); Assert.assertEquals(TaskCleanupType.DECOMMISSION_TIMEOUT, taskManager.getCleanupTasks().get(0).getCleanupType()); }
public void putSlave(SingularitySlave slave) { if (!active) { LOG.warn("putSlave {}, but not active", slave); } slaves.put(slave.getId(), slave); }
@Test public void testReconcileSlaves() { // Load 3 slaves on startup MesosMasterStateObject state = getMasterState(3); singularitySlaveAndRackManager.loadSlavesAndRacksFromMaster(state, true); MesosMasterStateObject newState = getMasterState(2); // 2 slaves, third has died singularitySlaveAndRackManager.loadSlavesAndRacksFromMaster(newState, false); List<SingularitySlave> slaves = slaveManager.getObjects(); Assert.assertEquals(3, slaves.size()); for (SingularitySlave slave : slaves) { if (slave.getId().equals("2")) { Assert.assertEquals(MachineState.DEAD, slave.getCurrentState().getState()); } else { Assert.assertEquals(MachineState.ACTIVE, slave.getCurrentState().getState()); } } }
@Test(expected = WebApplicationException.class) public void testBadExpiringStateTransition() { SingularitySlave slave = getSingleSlave(); slaveResource.decommissionSlave(singularityUser, slave.getId(), new SingularityMachineChangeRequest(Optional.of(1L), Optional.absent(), Optional.absent(), Optional.of(MachineState.FROZEN), Optional.absent())); }
@Test(expected = WebApplicationException.class) public void testInvalidTransitionToDecommissioned() { SingularitySlave slave = getSingleSlave(); slaveResource.decommissionSlave(singularityUser, slave.getId(), new SingularityMachineChangeRequest(Optional.of(1L), Optional.absent(), Optional.absent(), Optional.of(MachineState.DECOMMISSIONED), Optional.absent())); }
@Test(expected = WebApplicationException.class) public void testCannotUseStateReservedForSystem() { SingularitySlave slave = getSingleSlave(); slaveResource.freezeSlave(singularityUser, slave.getId(), new SingularityMachineChangeRequest(Optional.of(1L), Optional.absent(), Optional.absent(), Optional.of(MachineState.DEAD), Optional.absent())); }