Example usage for org.apache.hadoop.yarn.api.records Container getPriority

List of usage examples for org.apache.hadoop.yarn.api.records Container getPriority

Introduction

In this page you can find the example usage for org.apache.hadoop.yarn.api.records Container getPriority.

Prototype

@Public
@Stable
public abstract Priority getPriority();

Source Link

Document

Get the Priority at which the Container was allocated.

Usage

From source file:com.cloudera.llama.am.yarn.YarnRMConnector.java

License:Apache License

@Override
public void onContainersAllocated(List<Container> containers) {
    List<RMEvent> changes = new ArrayList<RMEvent>();
    // no need to use a ugi.doAs() as this is called from within Yarn client
    List<Container> unclaimedContainers = new ArrayList<Container>();
    for (Container container : containers) {
        List<? extends Collection<LlamaContainerRequest>> matchingContainerReqs = amRmClientAsync
                .getMatchingRequests(container.getPriority(), getNodeName(container.getNodeId()),
                        container.getResource());

        if (!matchingContainerReqs.isEmpty()) {
            LlamaContainerRequest req = null;
            Iterator<? extends Collection<LlamaContainerRequest>> it1 = matchingContainerReqs.iterator();
            while (req == null && it1.hasNext()) {
                Iterator<LlamaContainerRequest> it2 = it1.next().iterator();
                while (req == null && it2.hasNext()) {
                    req = it2.next();//w  w  w .j  ava 2  s  .c  o  m
                    LOG.trace("Matching container '{}' resource '{}'", container, req.getResourceAsk());
                }
            }
            if (req == null) {
                LOG.error("There was a match for container '{}', " + "LlamaContainerRequest cannot be NULL",
                        container);
            } else {
                handleContainerMatchingRequest(container, req, changes);
                /*Remove the granted request from anyLocationResourceIdToRequestMap if it is there*/
                anyLocationResourceIdToRequestMap.remove(req.getResourceAsk().getResourceId());
            }
        } else {
            LOG.debug("No strong request match for {}. Adding to the list of unclaimed containers.", container);
            unclaimedContainers.add(container);
        }
    }
    /*Matching YARN resources against requests relaxing locality*/
    for (Container container : unclaimedContainers) {
        /*Looking for requests with 'DONT_CARE' or 'PREFERRED' locality which match with the resources we've got*/
        boolean containerIsClaimed = false;
        Iterator<Map.Entry<UUID, LlamaContainerRequest>> iterator = anyLocationResourceIdToRequestMap.entrySet()
                .iterator();
        while (iterator.hasNext()) {
            Map.Entry<UUID, LlamaContainerRequest> entry = iterator.next();
            LlamaContainerRequest request = entry.getValue();
            /*Matching by the capacity only*/
            if (request.getResourceAsk().getCpuVCoresAsk() == container.getResource().getVirtualCores()
                    && request.getResourceAsk().getMemoryMbsAsk() == container.getResource().getMemory()) {
                handleContainerMatchingRequest(container, request, changes);
                iterator.remove();
                containerIsClaimed = true;
                break;
            }
        }
        if (!containerIsClaimed) {
            LOG.error("No matching request for {}. Releasing the container.", container);
            containerToResourceMap.remove(container.getId());
            amRmClientAsync.releaseAssignedContainer(container.getId());
        }
    }
    llamaCallback.onEvent(changes);
}

From source file:com.datatorrent.stram.StreamingAppMasterService.java

License:Apache License

/**
 * Main run function for the application master
 *
 * @throws YarnException//www  .  j av a2s  .c om
 */
@SuppressWarnings("SleepWhileInLoop")
private void execute() throws YarnException, IOException {
    LOG.info("Starting ApplicationMaster");
    final Credentials credentials = UserGroupInformation.getCurrentUser().getCredentials();
    LOG.info("number of tokens: {}", credentials.getAllTokens().size());
    Iterator<Token<?>> iter = credentials.getAllTokens().iterator();
    while (iter.hasNext()) {
        Token<?> token = iter.next();
        LOG.debug("token: {}", token);
    }
    final Configuration conf = getConfig();
    long tokenLifeTime = (long) (dag.getValue(LogicalPlan.TOKEN_REFRESH_ANTICIPATORY_FACTOR) * Math
            .min(dag.getValue(LogicalPlan.HDFS_TOKEN_LIFE_TIME), dag.getValue(LogicalPlan.RM_TOKEN_LIFE_TIME)));
    long expiryTime = System.currentTimeMillis() + tokenLifeTime;
    LOG.debug(" expiry token time {}", tokenLifeTime);
    String hdfsKeyTabFile = dag.getValue(LogicalPlan.KEY_TAB_FILE);

    // Register self with ResourceManager
    RegisterApplicationMasterResponse response = amRmClient.registerApplicationMaster(appMasterHostname, 0,
            appMasterTrackingUrl);

    // Dump out information about cluster capability as seen by the resource manager
    int maxMem = response.getMaximumResourceCapability().getMemory();
    int maxVcores = response.getMaximumResourceCapability().getVirtualCores();
    LOG.info("Max mem {}m and vcores {} capabililty of resources in this cluster ", maxMem, maxVcores);

    // for locality relaxation fall back
    Map<StreamingContainerAgent.ContainerStartRequest, MutablePair<Integer, ContainerRequest>> requestedResources = Maps
            .newHashMap();

    // Setup heartbeat emitter
    // TODO poll RM every now and then with an empty request to let RM know that we are alive
    // The heartbeat interval after which an AM is timed out by the RM is defined by a config setting:
    // RM_AM_EXPIRY_INTERVAL_MS with default defined by DEFAULT_RM_AM_EXPIRY_INTERVAL_MS
    // The allocate calls to the RM count as heartbeat so, for now, this additional heartbeat emitter
    // is not required.

    int loopCounter = -1;
    List<ContainerId> releasedContainers = new ArrayList<ContainerId>();
    int numTotalContainers = 0;
    // keep track of already requested containers to not request them again while waiting for allocation
    int numRequestedContainers = 0;
    int numReleasedContainers = 0;
    int nextRequestPriority = 0;
    ResourceRequestHandler resourceRequestor = new ResourceRequestHandler();

    YarnClient clientRMService = YarnClient.createYarnClient();

    try {
        // YARN-435
        // we need getClusterNodes to populate the initial node list,
        // subsequent updates come through the heartbeat response
        clientRMService.init(conf);
        clientRMService.start();

        ApplicationReport ar = StramClientUtils.getStartedAppInstanceByName(clientRMService,
                dag.getAttributes().get(DAG.APPLICATION_NAME),
                UserGroupInformation.getLoginUser().getUserName(), dag.getAttributes().get(DAG.APPLICATION_ID));
        if (ar != null) {
            appDone = true;
            dnmgr.shutdownDiagnosticsMessage = String.format(
                    "Application master failed due to application %s with duplicate application name \"%s\" by the same user \"%s\" is already started.",
                    ar.getApplicationId().toString(), ar.getName(), ar.getUser());
            LOG.info("Forced shutdown due to {}", dnmgr.shutdownDiagnosticsMessage);
            finishApplication(FinalApplicationStatus.FAILED, numTotalContainers);
            return;
        }
        resourceRequestor.updateNodeReports(clientRMService.getNodeReports());
    } catch (Exception e) {
        throw new RuntimeException("Failed to retrieve cluster nodes report.", e);
    } finally {
        clientRMService.stop();
    }

    // check for previously allocated containers
    // as of 2.2, containers won't survive AM restart, but this will change in the future - YARN-1490
    checkContainerStatus();
    FinalApplicationStatus finalStatus = FinalApplicationStatus.SUCCEEDED;
    final InetSocketAddress rmAddress = conf.getSocketAddr(YarnConfiguration.RM_ADDRESS,
            YarnConfiguration.DEFAULT_RM_ADDRESS, YarnConfiguration.DEFAULT_RM_PORT);

    while (!appDone) {
        loopCounter++;

        if (UserGroupInformation.isSecurityEnabled() && System.currentTimeMillis() >= expiryTime
                && hdfsKeyTabFile != null) {
            String applicationId = appAttemptID.getApplicationId().toString();
            expiryTime = StramUserLogin.refreshTokens(tokenLifeTime, "." + File.separator + "tmp",
                    applicationId, conf, hdfsKeyTabFile, credentials, rmAddress, true);
        }

        Runnable r;
        while ((r = this.pendingTasks.poll()) != null) {
            r.run();
        }

        // log current state
        /*
         * LOG.info("Current application state: loop=" + loopCounter + ", appDone=" + appDone + ", total=" +
         * numTotalContainers + ", requested=" + numRequestedContainers + ", completed=" + numCompletedContainers +
         * ", failed=" + numFailedContainers + ", currentAllocated=" + this.allAllocatedContainers.size());
         */
        // Sleep before each loop when asking RM for containers
        // to avoid flooding RM with spurious requests when it
        // need not have any available containers
        try {
            sleep(1000);
        } catch (InterruptedException e) {
            LOG.info("Sleep interrupted " + e.getMessage());
        }

        // Setup request to be sent to RM to allocate containers
        List<ContainerRequest> containerRequests = new ArrayList<ContainerRequest>();
        List<ContainerRequest> removedContainerRequests = new ArrayList<ContainerRequest>();

        // request containers for pending deploy requests
        if (!dnmgr.containerStartRequests.isEmpty()) {
            StreamingContainerAgent.ContainerStartRequest csr;
            while ((csr = dnmgr.containerStartRequests.poll()) != null) {
                if (csr.container.getRequiredMemoryMB() > maxMem) {
                    LOG.warn("Container memory {}m above max threshold of cluster. Using max value {}m.",
                            csr.container.getRequiredMemoryMB(), maxMem);
                    csr.container.setRequiredMemoryMB(maxMem);
                }
                if (csr.container.getRequiredVCores() > maxVcores) {
                    LOG.warn("Container vcores {} above max threshold of cluster. Using max value {}.",
                            csr.container.getRequiredVCores(), maxVcores);
                    csr.container.setRequiredVCores(maxVcores);
                }
                csr.container.setResourceRequestPriority(nextRequestPriority++);
                ContainerRequest cr = resourceRequestor.createContainerRequest(csr, true);
                MutablePair<Integer, ContainerRequest> pair = new MutablePair<Integer, ContainerRequest>(
                        loopCounter, cr);
                requestedResources.put(csr, pair);
                containerRequests.add(cr);
            }
        }

        if (!requestedResources.isEmpty()) {
            //resourceRequestor.clearNodeMapping();
            for (Map.Entry<StreamingContainerAgent.ContainerStartRequest, MutablePair<Integer, ContainerRequest>> entry : requestedResources
                    .entrySet()) {
                if ((loopCounter - entry.getValue().getKey()) > NUMBER_MISSED_HEARTBEATS) {
                    StreamingContainerAgent.ContainerStartRequest csr = entry.getKey();
                    removedContainerRequests.add(entry.getValue().getRight());
                    ContainerRequest cr = resourceRequestor.createContainerRequest(csr, false);
                    entry.getValue().setLeft(loopCounter);
                    entry.getValue().setRight(cr);
                    containerRequests.add(cr);
                }
            }
        }

        numTotalContainers += containerRequests.size();
        numRequestedContainers += containerRequests.size();
        AllocateResponse amResp = sendContainerAskToRM(containerRequests, removedContainerRequests,
                releasedContainers);
        if (amResp.getAMCommand() != null) {
            LOG.info(" statement executed:{}", amResp.getAMCommand());
            switch (amResp.getAMCommand()) {
            case AM_RESYNC:
            case AM_SHUTDOWN:
                throw new YarnRuntimeException("Received the " + amResp.getAMCommand() + " command from RM");
            default:
                throw new YarnRuntimeException("Received the " + amResp.getAMCommand() + " command from RM");

            }
        }
        releasedContainers.clear();

        // Retrieve list of allocated containers from the response
        List<Container> newAllocatedContainers = amResp.getAllocatedContainers();
        // LOG.info("Got response from RM for container ask, allocatedCnt=" + newAllocatedContainers.size());
        numRequestedContainers -= newAllocatedContainers.size();
        long timestamp = System.currentTimeMillis();
        for (Container allocatedContainer : newAllocatedContainers) {

            LOG.info("Got new container." + ", containerId=" + allocatedContainer.getId() + ", containerNode="
                    + allocatedContainer.getNodeId() + ", containerNodeURI="
                    + allocatedContainer.getNodeHttpAddress() + ", containerResourceMemory"
                    + allocatedContainer.getResource().getMemory() + ", priority"
                    + allocatedContainer.getPriority());
            // + ", containerToken" + allocatedContainer.getContainerToken().getIdentifier().toString());

            boolean alreadyAllocated = true;
            StreamingContainerAgent.ContainerStartRequest csr = null;
            for (Map.Entry<StreamingContainerAgent.ContainerStartRequest, MutablePair<Integer, ContainerRequest>> entry : requestedResources
                    .entrySet()) {
                if (entry.getKey().container.getResourceRequestPriority() == allocatedContainer.getPriority()
                        .getPriority()) {
                    alreadyAllocated = false;
                    csr = entry.getKey();
                    break;
                }
            }

            if (alreadyAllocated) {
                LOG.info("Releasing {} as resource with priority {} was already assigned",
                        allocatedContainer.getId(), allocatedContainer.getPriority());
                releasedContainers.add(allocatedContainer.getId());
                numReleasedContainers++;
                numRequestedContainers++;
                continue;
            }
            if (csr != null) {
                requestedResources.remove(csr);
            }

            // allocate resource to container
            ContainerResource resource = new ContainerResource(allocatedContainer.getPriority().getPriority(),
                    allocatedContainer.getId().toString(), allocatedContainer.getNodeId().toString(),
                    allocatedContainer.getResource().getMemory(),
                    allocatedContainer.getResource().getVirtualCores(),
                    allocatedContainer.getNodeHttpAddress());
            StreamingContainerAgent sca = dnmgr.assignContainer(resource, null);

            if (sca == null) {
                // allocated container no longer needed, add release request
                LOG.warn("Container {} allocated but nothing to deploy, going to release this container.",
                        allocatedContainer.getId());
                releasedContainers.add(allocatedContainer.getId());
            } else {
                AllocatedContainer allocatedContainerHolder = new AllocatedContainer(allocatedContainer);
                this.allocatedContainers.put(allocatedContainer.getId().toString(), allocatedContainerHolder);
                ByteBuffer tokens = null;
                if (UserGroupInformation.isSecurityEnabled()) {
                    UserGroupInformation ugi = UserGroupInformation.getLoginUser();
                    Token<StramDelegationTokenIdentifier> delegationToken = allocateDelegationToken(
                            ugi.getUserName(), heartbeatListener.getAddress());
                    allocatedContainerHolder.delegationToken = delegationToken;
                    //ByteBuffer tokens = LaunchContainerRunnable.getTokens(delegationTokenManager, heartbeatListener.getAddress());
                    tokens = LaunchContainerRunnable.getTokens(ugi, delegationToken);
                }
                LaunchContainerRunnable launchContainer = new LaunchContainerRunnable(allocatedContainer,
                        nmClient, sca, tokens);
                // Thread launchThread = new Thread(runnableLaunchContainer);
                // launchThreads.add(launchThread);
                // launchThread.start();
                launchContainer.run(); // communication with NMs is now async

                // record container start event
                StramEvent ev = new StramEvent.StartContainerEvent(allocatedContainer.getId().toString(),
                        allocatedContainer.getNodeId().toString());
                ev.setTimestamp(timestamp);
                dnmgr.recordEventAsync(ev);
            }
        }

        // track node updates for future locality constraint allocations
        // TODO: it seems 2.0.4-alpha doesn't give us any updates
        resourceRequestor.updateNodeReports(amResp.getUpdatedNodes());

        // Check the completed containers
        List<ContainerStatus> completedContainers = amResp.getCompletedContainersStatuses();
        // LOG.debug("Got response from RM for container ask, completedCnt=" + completedContainers.size());
        for (ContainerStatus containerStatus : completedContainers) {
            LOG.info("Completed containerId=" + containerStatus.getContainerId() + ", state="
                    + containerStatus.getState() + ", exitStatus=" + containerStatus.getExitStatus()
                    + ", diagnostics=" + containerStatus.getDiagnostics());

            // non complete containers should not be here
            assert (containerStatus.getState() == ContainerState.COMPLETE);

            AllocatedContainer allocatedContainer = allocatedContainers
                    .remove(containerStatus.getContainerId().toString());
            if (allocatedContainer != null && allocatedContainer.delegationToken != null) {
                UserGroupInformation ugi = UserGroupInformation.getLoginUser();
                delegationTokenManager.cancelToken(allocatedContainer.delegationToken, ugi.getUserName());
            }
            int exitStatus = containerStatus.getExitStatus();
            if (0 != exitStatus) {
                if (allocatedContainer != null) {
                    numFailedContainers.incrementAndGet();
                }
                //          if (exitStatus == 1) {
                //            // non-recoverable StreamingContainer failure
                //            appDone = true;
                //            finalStatus = FinalApplicationStatus.FAILED;
                //            dnmgr.shutdownDiagnosticsMessage = "Unrecoverable failure " + containerStatus.getContainerId();
                //            LOG.info("Exiting due to: {}", dnmgr.shutdownDiagnosticsMessage);
                //          }
                //          else {
                // Recoverable failure or process killed (externally or via stop request by AM)
                // also occurs when a container was released by the application but never assigned/launched
                LOG.debug("Container {} failed or killed.", containerStatus.getContainerId());
                dnmgr.scheduleContainerRestart(containerStatus.getContainerId().toString());
                //          }
            } else {
                // container completed successfully
                numCompletedContainers.incrementAndGet();
                LOG.info("Container completed successfully." + ", containerId="
                        + containerStatus.getContainerId());
            }

            String containerIdStr = containerStatus.getContainerId().toString();
            dnmgr.removeContainerAgent(containerIdStr);

            // record container stop event
            StramEvent ev = new StramEvent.StopContainerEvent(containerIdStr, containerStatus.getExitStatus());
            ev.setReason(containerStatus.getDiagnostics());
            dnmgr.recordEventAsync(ev);
        }

        if (dnmgr.forcedShutdown) {
            LOG.info("Forced shutdown due to {}", dnmgr.shutdownDiagnosticsMessage);
            finalStatus = FinalApplicationStatus.FAILED;
            appDone = true;
        } else if (allocatedContainers.isEmpty() && numRequestedContainers == 0
                && dnmgr.containerStartRequests.isEmpty()) {
            LOG.debug("Exiting as no more containers are allocated or requested");
            finalStatus = FinalApplicationStatus.SUCCEEDED;
            appDone = true;
        }

        LOG.debug("Current application state: loop=" + loopCounter + ", appDone=" + appDone + ", total="
                + numTotalContainers + ", requested=" + numRequestedContainers + ", released="
                + numReleasedContainers + ", completed=" + numCompletedContainers + ", failed="
                + numFailedContainers + ", currentAllocated=" + allocatedContainers.size());

        // monitor child containers
        dnmgr.monitorHeartbeat();
    }

    finishApplication(finalStatus, numTotalContainers);
}

From source file:io.amient.yarn1.YarnContainerContext.java

License:Open Source License

public boolean isSatisfiedBy(Container container) {
    return container.getResource().getMemory() >= capability.getMemory()
            && container.getResource().getVirtualCores() >= capability.getVirtualCores()
            && container.getPriority().getPriority() >= priority.getPriority();
}

From source file:io.hops.util.DBUtility.java

License:Apache License

public static void removeContainersToDecrease(
        final Collection<org.apache.hadoop.yarn.api.records.Container> containers) throws IOException {
    long start = System.currentTimeMillis();
    AsyncLightWeightRequestHandler removeContainerToDecrease = new AsyncLightWeightRequestHandler(
            YARNOperationType.TEST) {//from   ww w . j a v  a2  s . c  o  m
        @Override
        public Object performTask() throws StorageException {
            connector.beginTransaction();
            connector.writeLock();
            ContainerToDecreaseDataAccess ctsDA = (ContainerToDecreaseDataAccess) RMStorageFactory
                    .getDataAccess(ContainerToDecreaseDataAccess.class);
            List<io.hops.metadata.yarn.entity.Container> containersToDecrease = new ArrayList<io.hops.metadata.yarn.entity.Container>();
            for (org.apache.hadoop.yarn.api.records.Container container : containers) {
                containersToDecrease.add(new io.hops.metadata.yarn.entity.Container(
                        container.getId().toString(), container.getNodeId().toString(),
                        container.getNodeHttpAddress(), container.getPriority().getPriority(),
                        container.getResource().getMemorySize(), container.getResource().getVirtualCores(),
                        container.getResource().getGPUs(), container.getVersion()));
            }
            ctsDA.removeAll(containersToDecrease);
            connector.commit();
            return null;
        }
    };

    removeContainerToDecrease.handle();
    long duration = System.currentTimeMillis() - start;
    if (duration > 10) {
        LOG.error("too long " + duration);
    }
}

From source file:io.hops.util.DBUtility.java

License:Apache License

public static void addContainersToDecrease(final List<org.apache.hadoop.yarn.api.records.Container> containers)
        throws IOException {
    long start = System.currentTimeMillis();
    AsyncLightWeightRequestHandler addContainerToDecrease = new AsyncLightWeightRequestHandler(
            YARNOperationType.TEST) {//  w w w.  ja  v  a  2 s  .  com
        @Override
        public Object performTask() throws StorageException {
            connector.beginTransaction();
            connector.writeLock();
            ContainerToDecreaseDataAccess ctsDA = (ContainerToDecreaseDataAccess) RMStorageFactory
                    .getDataAccess(ContainerToDecreaseDataAccess.class);
            List<io.hops.metadata.yarn.entity.Container> containersToDecrease = new ArrayList<io.hops.metadata.yarn.entity.Container>();
            for (org.apache.hadoop.yarn.api.records.Container container : containers) {
                containersToDecrease.add(new io.hops.metadata.yarn.entity.Container(
                        container.getId().toString(), container.getNodeId().toString(),
                        container.getNodeHttpAddress(), container.getPriority().getPriority(),
                        container.getResource().getMemorySize(), container.getResource().getVirtualCores(),
                        container.getResource().getGPUs(), container.getVersion()));
            }
            ctsDA.addAll(containersToDecrease);
            connector.commit();
            return null;
        }
    };

    addContainerToDecrease.handle();
    long duration = System.currentTimeMillis() - start;
    if (duration > 10) {
        LOG.error("too long " + duration);
    }
}

From source file:org.apache.drill.yarn.appMaster.ClusterControllerImpl.java

License:Apache License

@Override
public synchronized void containersAllocated(List<Container> containers) {
    EventContext context = new EventContext(this);
    for (Container container : containers) {
        if (allocatedContainers.contains(container.getId())) {
            continue;
        }//from  w  w w .  j  a  v  a  2s. co m

        // We should never get a container on a node in the blacklist we
        // sent to YARN. If we do, something is wrong. Log the error and
        // reject the container. Else, bad things happen further along as
        // the tracking mechanisms assume one task per node.

        String host = container.getNodeId().getHost();
        if (nodeInventory.isInUse(host)) {
            LOG.error("Host is in use, but YARN allocated a container: " + DoYUtil.labelContainer(container)
                    + " - container rejected.");
            yarn.releaseContainer(container);
            continue;
        }

        // The container is fine.

        allocatedContainers.add(container.getId());
        int priority = container.getPriority().getPriority();
        int offset = priority - PRIORITY_OFFSET;
        if (offset < 0 || offset > prioritizedGroups.size()) {
            LOG.error("Container allocated with unknown priority " + DoYUtil.labelContainer(container));
            continue;
        }
        context.setGroup(prioritizedGroups.get(offset));
        context.group.containerAllocated(context, container);
    }
}

From source file:org.apache.drill.yarn.core.DoYUtil.java

License:Apache License

public static String labelContainer(Container container) {
    StringBuilder buf = new StringBuilder().append("[id: ").append(container.getId()).append(", host: ")
            .append(container.getNodeId().getHost()).append(", priority: ").append(container.getPriority())
            .append("]");
    return buf.toString();
}

From source file:org.apache.drill.yarn.core.DoYUtil.java

License:Apache License

/**
 * Utility method to display YARN container information in a useful way for
 * log messages.//  w  ww .  jav a2 s. com
 *
 * @param container
 * @return
 */

public static String describeContainer(Container container) {
    StringBuilder buf = new StringBuilder().append("[id: ").append(container.getId()).append(", host: ")
            .append(container.getNodeId().getHost()).append(", priority: ").append(container.getPriority())
            .append(", memory: ").append(container.getResource().getMemory()).append(" MB, vcores: ")
            .append(container.getResource().getVirtualCores()).append("]");
    return buf.toString();
}

From source file:org.apache.flink.yarn.YarnResourceManager.java

License:Apache License

@Override
public void onContainersAllocated(List<Container> containers) {
    for (Container container : containers) {
        numPendingContainerRequests = Math.max(0, numPendingContainerRequests - 1);
        LOG.info("Received new container: {} - Remaining pending container requests: {}", container.getId(),
                numPendingContainerRequests);
        try {// w w  w .  j av a  2s .c o  m
            /** Context information used to start a TaskExecutor Java process */
            ContainerLaunchContext taskExecutorLaunchContext = createTaskExecutorLaunchContext(
                    container.getResource(), container.getId().toString(), container.getNodeId().getHost());
            nodeManagerClient.startContainer(container, taskExecutorLaunchContext);
        } catch (Throwable t) {
            // failed to launch the container, will release the failed one and ask for a new one
            LOG.error("Could not start TaskManager in container {},", container, t);
            resourceManagerClient.releaseAssignedContainer(container.getId());
            requestYarnContainer(container.getResource(), container.getPriority());
        }
    }
    if (numPendingContainerRequests <= 0) {
        resourceManagerClient.setHeartbeatInterval(yarnHeartbeatIntervalMillis);
    }
}

From source file:org.apache.flink.yarn.YarnResourceManagerTest.java

License:Apache License

private static Container mockContainer(String host, int port, int containerId) {
    Container mockContainer = mock(Container.class);

    NodeId mockNodeId = NodeId.newInstance(host, port);
    ContainerId mockContainerId = ContainerId.newInstance(
            ApplicationAttemptId.newInstance(ApplicationId.newInstance(System.currentTimeMillis(), 1), 1),
            containerId);/*from  w w w  . j  a  v a2s.  c o m*/

    when(mockContainer.getId()).thenReturn(mockContainerId);
    when(mockContainer.getNodeId()).thenReturn(mockNodeId);
    when(mockContainer.getResource()).thenReturn(Resource.newInstance(200, 1));
    when(mockContainer.getPriority()).thenReturn(Priority.UNDEFINED);

    return mockContainer;
}