public String getQueueName() { try { this.readLock.lock(); return queue.getQueueName(); } finally { this.readLock.unlock(); } }
/** * Get metrics reference from containing queue. */ public QueueMetrics getMetrics() { return queue.getMetrics(); }
@Override public QueueInfo getQueueInfo(String queueName, boolean includeChildQueues, boolean recursive) { return DEFAULT_QUEUE.getQueueInfo(false, false); }
synchronized public void move(Queue newQueue) { QueueMetrics oldMetrics = queue.getMetrics(); QueueMetrics newMetrics = newQueue.getMetrics(); for (Map<String, ResourceRequest> asks : requests.values()) { ResourceRequest request = asks.get(ResourceRequest.ANY); if (request != null) { oldMetrics.decrPendingResources(user, request.getNumContainers(), request.getCapability()); newMetrics.incrPendingResources(user, request.getNumContainers(), request.getCapability()); } } oldMetrics.moveAppFrom(this); newMetrics.moveAppTo(this); activeUsersManager.deactivateApplication(user, applicationId); activeUsersManager = newQueue.getActiveUsersManager(); activeUsersManager.activateApplication(user, applicationId); this.queue = newQueue; this.queueName = newQueue.getQueueName(); }
private Queue createQueue(String name, Queue parent, float capacity) { QueueMetrics metrics = QueueMetrics.forQueue(name, parent, false, conf); QueueInfo queueInfo = QueueInfo.newInstance(name, capacity, 1.0f, 0, null, null, QueueState.RUNNING, null, "", null, false, null, false); ActiveUsersManager activeUsersManager = new ActiveUsersManager(metrics); Queue queue = mock(Queue.class); when(queue.getMetrics()).thenReturn(metrics); when(queue.getAbstractUsersManager()).thenReturn(activeUsersManager); when(queue.getQueueInfo(false, false)).thenReturn(queueInfo); return queue; }
public void move(Queue newQueue) { try { writeLock.lock(); QueueMetrics oldMetrics = queue.getMetrics(); QueueMetrics newMetrics = newQueue.getMetrics(); String newQueueName = newQueue.getQueueName(); String user = getUser();
public void move(Queue newQueue) { try { this.writeLock.lock(); QueueMetrics oldMetrics = queue.getMetrics(); QueueMetrics newMetrics = newQueue.getMetrics(); for (AppPlacementAllocator ap : schedulerKeyToAppPlacementAllocator .values()) { ask.getCount()); queue.decPendingResource( ap.getPrimaryRequestedNodePartition(), delta); newQueue.incPendingResource( ap.getPrimaryRequestedNodePartition(), delta); newMetrics.moveAppTo(this); abstractUsersManager.deactivateApplication(user, applicationId); abstractUsersManager = newQueue.getAbstractUsersManager(); if (!schedulerKeys.isEmpty()) { abstractUsersManager.activateApplication(user, applicationId);
private Queue createQueue(String name, Queue parent) { QueueMetrics metrics = QueueMetrics.forQueue(name, parent, false, conf); ActiveUsersManager activeUsersManager = new ActiveUsersManager(metrics); Queue queue = mock(Queue.class); when(queue.getMetrics()).thenReturn(metrics); when(queue.getActiveUsersManager()).thenReturn(activeUsersManager); return queue; }
schedulerApp.getQueue().getQueueName()); queue.recoverContainer(getClusterResource(), schedulerAttempt, rmContainer);
@Override public synchronized boolean checkAccess(UserGroupInformation callerUGI, QueueACL acl, String queueName) { return DEFAULT_QUEUE.hasAccess(acl, callerUGI); }
public boolean unreserve(SchedulerRequestKey schedulerKey, FiCaSchedulerNode node, RMContainer rmContainer) { try { writeLock.lock(); // Done with the reservation? if (internalUnreserve(node, schedulerKey)) { node.unreserveResource(this); // Update reserved metrics queue.getMetrics().unreserveResource(node.getPartition(), getUser(), rmContainer.getReservedResource()); queue.decReservedResource(node.getPartition(), rmContainer.getReservedResource()); return true; } return false; } finally { writeLock.unlock(); } }
Queue oldQueue = createQueue("old", parentQueue); Queue newQueue = createQueue("new", parentQueue); QueueMetrics parentMetrics = parentQueue.getMetrics(); QueueMetrics oldMetrics = oldQueue.getMetrics(); QueueMetrics newMetrics = newQueue.getMetrics(); when(rmContext.getEpoch()).thenReturn(3L); SchedulerApplicationAttempt app = new SchedulerApplicationAttempt(appAttId, user, oldQueue, oldQueue.getAbstractUsersManager(), rmContext); oldMetrics.submitApp(user);
public void stop() { // clear pending resources metrics for the application try { this.writeLock.lock(); QueueMetrics metrics = queue.getMetrics(); for (AppPlacementAllocator ap : schedulerKeyToAppPlacementAllocator .values()) { PendingAsk ask = ap.getPendingAsk(ResourceRequest.ANY); if (ask.getCount() > 0) { metrics.decrPendingResources(ap.getPrimaryRequestedNodePartition(), user, ask.getCount(), ask.getPerAllocationResource()); // Update Queue queue.decPendingResource( ap.getPrimaryRequestedNodePartition(), Resources.multiply(ask.getPerAllocationResource(), ask.getCount())); } } metrics.finishAppAttempt(applicationId, pending, user); // Clear requests themselves clearRequests(); } finally { this.writeLock.unlock(); } }
@Override public List<QueueUserACLInfo> getQueueUserAclInfo() { return DEFAULT_QUEUE.getQueueUserAclInfo(null); }
@Test public void testAppPercentagesOnswitch() throws Exception { FifoScheduler scheduler = mock(FifoScheduler.class); when(scheduler.getClusterResource()).thenReturn(Resource.newInstance(0, 0)); when(scheduler.getResourceCalculator()) .thenReturn(new DefaultResourceCalculator()); ApplicationAttemptId appAttId = createAppAttemptId(0, 0); RMContext rmContext = mock(RMContext.class); when(rmContext.getEpoch()).thenReturn(3L); when(rmContext.getScheduler()).thenReturn(scheduler); final String user = "user1"; Queue queue = createQueue("test", null); SchedulerApplicationAttempt app = new SchedulerApplicationAttempt(appAttId, user, queue, queue.getAbstractUsersManager(), rmContext); // Resource request Resource requestedResource = Resource.newInstance(1536, 2); app.attemptResourceUsage.incUsed(requestedResource); assertEquals(0.0f, app.getResourceUsageReport().getQueueUsagePercentage(), 0.0f); assertEquals(0.0f, app.getResourceUsageReport().getClusterUsagePercentage(), 0.0f); }
queue.recoverContainer(clusterResource, schedulerAttempt, rmContainer);
@Test public void testSchedulingOpportunityOverflow() throws Exception { ApplicationAttemptId attemptId = createAppAttemptId(0, 0); Queue queue = createQueue("test", null); RMContext rmContext = mock(RMContext.class); when(rmContext.getEpoch()).thenReturn(3L); SchedulerApplicationAttempt app = new SchedulerApplicationAttempt( attemptId, "user", queue, queue.getActiveUsersManager(), rmContext); Priority priority = Priority.newInstance(1); assertEquals(0, app.getSchedulingOpportunities(priority)); app.addSchedulingOpportunity(priority); assertEquals(1, app.getSchedulingOpportunities(priority)); // verify the count is capped at MAX_VALUE and does not overflow app.setSchedulingOpportunities(priority, Integer.MAX_VALUE - 1); assertEquals(Integer.MAX_VALUE - 1, app.getSchedulingOpportunities(priority)); app.addSchedulingOpportunity(priority); assertEquals(Integer.MAX_VALUE, app.getSchedulingOpportunities(priority)); app.addSchedulingOpportunity(priority); assertEquals(Integer.MAX_VALUE, app.getSchedulingOpportunities(priority)); } }
synchronized public void move(Queue newQueue) { QueueMetrics oldMetrics = queue.getMetrics(); QueueMetrics newMetrics = newQueue.getMetrics(); for (Map<String, ResourceRequest> asks : requests.values()) { ResourceRequest request = asks.get(ResourceRequest.ANY); if (request != null) { oldMetrics.decrPendingResources(user, request.getNumContainers(), request.getCapability()); newMetrics.incrPendingResources(user, request.getNumContainers(), request.getCapability()); } } oldMetrics.moveAppFrom(this); newMetrics.moveAppTo(this); activeUsersManager.deactivateApplication(user, applicationId); activeUsersManager = newQueue.getActiveUsersManager(); activeUsersManager.activateApplication(user, applicationId); this.queue = newQueue; this.queueName = newQueue.getQueueName(); }
Queue oldQueue = createQueue("old", parentQueue); Queue newQueue = createQueue("new", parentQueue); QueueMetrics parentMetrics = parentQueue.getMetrics(); QueueMetrics oldMetrics = oldQueue.getMetrics(); QueueMetrics newMetrics = newQueue.getMetrics(); when(rmContext.getEpoch()).thenReturn(3L); SchedulerApplicationAttempt app = new SchedulerApplicationAttempt(appAttId, user, oldQueue, oldQueue.getActiveUsersManager(), rmContext); oldMetrics.submitApp(user);
@Override public synchronized boolean checkAccess(UserGroupInformation callerUGI, QueueACL acl, String queueName) { return DEFAULT_QUEUE.hasAccess(acl, callerUGI); }