<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (1.8.0_292) on Tue Jun 15 06:12:40 GMT 2021 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>YarnClient (Apache Hadoop YARN Client 3.3.1 API)</title>
<meta name="date" content="2021-06-15">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">
<script type="text/javascript" src="../../../../../../script.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="YarnClient (Apache Hadoop YARN Client 3.3.1 API)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":6,"i1":6,"i2":9,"i3":6,"i4":6,"i5":6,"i6":6,"i7":6,"i8":6,"i9":6,"i10":6,"i11":6,"i12":10,"i13":6,"i14":6,"i15":6,"i16":6,"i17":6,"i18":6,"i19":6,"i20":6,"i21":6,"i22":6,"i23":6,"i24":6,"i25":6,"i26":6,"i27":6,"i28":6,"i29":6,"i30":6,"i31":6,"i32":6,"i33":6,"i34":6,"i35":6,"i36":6,"i37":6,"i38":6,"i39":6,"i40":6,"i41":6,"i42":6,"i43":6,"i44":6,"i45":10,"i46":6};
var tabs = {65535:["t0","All Methods"],1:["t1","Static Methods"],2:["t2","Instance Methods"],4:["t3","Abstract Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/YarnClient.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../../org/apache/hadoop/yarn/client/api/SharedCacheClient.html" title="class in org.apache.hadoop.yarn.client.api"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClientApplication.html" title="class in org.apache.hadoop.yarn.client.api"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../index.html?org/apache/hadoop/yarn/client/api/YarnClient.html" target="_top">Frames</a></li>
<li><a href="YarnClient.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.apache.hadoop.yarn.client.api</div>
<h2 title="Class YarnClient" class="title">Class YarnClient</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.apache.hadoop.service.AbstractService</li>
<li>
<ul class="inheritance">
<li>org.apache.hadoop.yarn.client.api.YarnClient</li>
</ul>
</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd><a href="https://docs.oracle.com/javase/8/docs/api/java/io/Closeable.html?is-external=true" title="class or interface in java.io">Closeable</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/AutoCloseable.html?is-external=true" title="class or interface in java.lang">AutoCloseable</a>, org.apache.hadoop.service.Service</dd>
</dl>
<dl>
<dt>Direct Known Subclasses:</dt>
<dd><a href="../../../../../../org/apache/hadoop/yarn/client/api/impl/YarnClientImpl.html" title="class in org.apache.hadoop.yarn.client.api.impl">YarnClientImpl</a></dd>
</dl>
<hr>
<br>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Stable
public abstract class <span class="typeNameLabel">YarnClient</span>
extends org.apache.hadoop.service.AbstractService</pre>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== NESTED CLASS SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="nested.class.summary">
<!--   -->
</a>
<h3>Nested Class Summary</h3>
<ul class="blockList">
<li class="blockList"><a name="nested.classes.inherited.from.class.org.apache.hadoop.service.Service">
<!--   -->
</a>
<h3>Nested classes/interfaces inherited from interface&nbsp;org.apache.hadoop.service.Service</h3>
<code>org.apache.hadoop.service.Service.STATE</code></li>
</ul>
</li>
</ul>
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier</th>
<th class="colLast" scope="col">Constructor and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected </code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#YarnClient-java.lang.String-">YarnClient</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</code>&nbsp;</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t1" class="tableTab"><span><a href="javascript:show(1);">Static Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t2" class="tableTab"><span><a href="javascript:show(2);">Instance Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t3" class="tableTab"><span><a href="javascript:show(4);">Abstract Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>abstract <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClientApplication.html" title="class in org.apache.hadoop.yarn.client.api">YarnClientApplication</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#createApplication--">createApplication</a></span>()</code>
<div class="block">
 Obtain a <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClientApplication.html" title="class in org.apache.hadoop.yarn.client.api"><code>YarnClientApplication</code></a> for a new application,
 which in turn contains the <code>ApplicationSubmissionContext</code> and
 <code>GetNewApplicationResponse</code>
 objects.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.protocolrecords.GetNewReservationResponse</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#createReservation--">createReservation</a></span>()</code>
<div class="block">
 Obtain a <code>GetNewReservationResponse</code> for a new reservation,
 which contains the <code>ReservationId</code> object.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>static <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html" title="class in org.apache.hadoop.yarn.client.api">YarnClient</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#createYarnClient--">createYarnClient</a></span>()</code>
<div class="block">Create a new instance of YarnClient.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.protocolrecords.ReservationDeleteResponse</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#deleteReservation-org.apache.hadoop.yarn.api.protocolrecords.ReservationDeleteRequest-">deleteReservation</a></span>(org.apache.hadoop.yarn.api.protocolrecords.ReservationDeleteRequest&nbsp;request)</code>
<div class="block">
 The interface used by clients to remove an existing Reservation.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>abstract void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#failApplicationAttempt-org.apache.hadoop.yarn.api.records.ApplicationAttemptId-">failApplicationAttempt</a></span>(org.apache.hadoop.yarn.api.records.ApplicationAttemptId&nbsp;applicationAttemptId)</code>
<div class="block">
 Fail an application attempt identified by given ID.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.QueueInfo&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getAllQueues--">getAllQueues</a></span>()</code>
<div class="block">
 Get information (<code>QueueInfo</code>) about all queues, recursively if there
 is a hierarchy</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>abstract org.apache.hadoop.security.token.Token&lt;org.apache.hadoop.yarn.security.AMRMTokenIdentifier&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getAMRMToken-org.apache.hadoop.yarn.api.records.ApplicationId-">getAMRMToken</a></span>(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;appId)</code>
<div class="block">Get the AMRM token of the application.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.records.ApplicationAttemptReport</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationAttemptReport-org.apache.hadoop.yarn.api.records.ApplicationAttemptId-">getApplicationAttemptReport</a></span>(org.apache.hadoop.yarn.api.records.ApplicationAttemptId&nbsp;applicationAttemptId)</code>
<div class="block">
 Get a report of the given ApplicationAttempt.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationAttemptReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationAttempts-org.apache.hadoop.yarn.api.records.ApplicationId-">getApplicationAttempts</a></span>(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;applicationId)</code>
<div class="block">
 Get a report of all (ApplicationAttempts) of Application in the cluster.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.records.ApplicationReport</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationReport-org.apache.hadoop.yarn.api.records.ApplicationId-">getApplicationReport</a></span>(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;appId)</code>
<div class="block">
 Get a report of the given Application.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplications--">getApplications</a></span>()</code>
<div class="block">
 Get a report (ApplicationReport) of all Applications in the cluster.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplications-java.util.EnumSet-">getApplications</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;org.apache.hadoop.yarn.api.records.YarnApplicationState&gt;&nbsp;applicationStates)</code>
<div class="block">
 Get a report (ApplicationReport) of Applications matching the given
 application states in the cluster.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplications-org.apache.hadoop.yarn.api.protocolrecords.GetApplicationsRequest-">getApplications</a></span>(org.apache.hadoop.yarn.api.protocolrecords.GetApplicationsRequest&nbsp;request)</code>
<div class="block">
 Get a list of ApplicationReports that match the given
 <code>GetApplicationsRequest</code>.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplications-java.util.Set-">getApplications</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTypes)</code>
<div class="block">
 Get a report (ApplicationReport) of Applications
 matching the given application types in the cluster.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplications-java.util.Set-java.util.EnumSet-">getApplications</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTypes,
               <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;org.apache.hadoop.yarn.api.records.YarnApplicationState&gt;&nbsp;applicationStates)</code>
<div class="block">
 Get a report (ApplicationReport) of Applications matching the given
 application types and application states in the cluster.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplications-java.util.Set-java.util.EnumSet-java.util.Set-">getApplications</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTypes,
               <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;org.apache.hadoop.yarn.api.records.YarnApplicationState&gt;&nbsp;applicationStates,
               <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTags)</code>
<div class="block">
 Get a report (ApplicationReport) of Applications matching the given
 application types, application states and application tags in the cluster.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplications-java.util.Set-java.util.Set-java.util.Set-java.util.EnumSet-">getApplications</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;queues,
               <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;users,
               <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTypes,
               <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;org.apache.hadoop.yarn.api.records.YarnApplicationState&gt;&nbsp;applicationStates)</code>
<div class="block">
 Get a report (ApplicationReport) of Applications matching the given users,
 queues, application types and application states in the cluster.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;org.apache.hadoop.yarn.api.records.NodeAttributeKey,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.NodeToAttributeValue&gt;&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getAttributesToNodes-java.util.Set-">getAttributesToNodes</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeAttributeKey&gt;&nbsp;attributes)</code>
<div class="block">
 The interface used by client to get mapping of AttributeKey to associated
 NodeToAttributeValue list for specified node attributeKeys in the cluster.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.QueueInfo&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getChildQueueInfos-java.lang.String-">getChildQueueInfos</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;parent)</code>
<div class="block">
 Get information (<code>QueueInfo</code>) about all the immediate children queues
 of the given queue</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeAttributeInfo&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getClusterAttributes--">getClusterAttributes</a></span>()</code>
<div class="block">
 The interface used by client to get node attributes in the cluster.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.NodeLabel&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getClusterNodeLabels--">getClusterNodeLabels</a></span>()</code>
<div class="block">
 The interface used by client to get node labels in the cluster</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.records.ContainerReport</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getContainerReport-org.apache.hadoop.yarn.api.records.ContainerId-">getContainerReport</a></span>(org.apache.hadoop.yarn.api.records.ContainerId&nbsp;containerId)</code>
<div class="block">
 Get a report of the given Container.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ContainerReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getContainers-org.apache.hadoop.yarn.api.records.ApplicationAttemptId-">getContainers</a></span>(org.apache.hadoop.yarn.api.records.ApplicationAttemptId&nbsp;applicationAttemptId)</code>
<div class="block">
 Get a report of all (Containers) of ApplicationAttempt in the cluster.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeId&gt;&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getLabelsToNodes--">getLabelsToNodes</a></span>()</code>
<div class="block">
 The interface used by client to get labels to nodes mapping
 in existing cluster</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeId&gt;&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getLabelsToNodes-java.util.Set-">getLabelsToNodes</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;labels)</code>
<div class="block">
 The interface used by client to get labels to nodes mapping
 for specified labels in existing cluster</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.NodeReport&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getNodeReports-org.apache.hadoop.yarn.api.records.NodeState...-">getNodeReports</a></span>(org.apache.hadoop.yarn.api.records.NodeState...&nbsp;states)</code>
<div class="block">
 Get a report of nodes (<code>NodeReport</code>) in the cluster.</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeAttribute&gt;&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getNodeToAttributes-java.util.Set-">getNodeToAttributes</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;hostNames)</code>
<div class="block">
 The interface used by client to get all node to attribute mapping in
 existing cluster.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;org.apache.hadoop.yarn.api.records.NodeId,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getNodeToLabels--">getNodeToLabels</a></span>()</code>
<div class="block">
 The interface used by client to get node to labels mappings in existing cluster</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.QueueUserACLInfo&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getQueueAclsInfo--">getQueueAclsInfo</a></span>()</code>
<div class="block">
 Get information about <em>acls</em> for <em>current user</em> on all the
 existing queues.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.records.QueueInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getQueueInfo-java.lang.String-">getQueueInfo</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;queueName)</code>
<div class="block">
 Get information (<code>QueueInfo</code>) about a given <em>queue</em>.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.records.Resource</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getResourceProfile-java.lang.String-">getResourceProfile</a></span>(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;profile)</code>
<div class="block">
 Get the details of a specific resource profile from the RM.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,org.apache.hadoop.yarn.api.records.Resource&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getResourceProfiles--">getResourceProfiles</a></span>()</code>
<div class="block">
 Get the resource profiles available in the RM.</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ResourceTypeInfo&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getResourceTypeInfo--">getResourceTypeInfo</a></span>()</code>
<div class="block">
 Get available resource types supported by RM.</div>
</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.records.Token</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getRMDelegationToken-org.apache.hadoop.io.Text-">getRMDelegationToken</a></span>(org.apache.hadoop.io.Text&nbsp;renewer)</code>
<div class="block">
 Get a delegation token so as to be able to talk to YARN using those tokens.</div>
</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code>abstract <a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.QueueInfo&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getRootQueueInfos--">getRootQueueInfos</a></span>()</code>
<div class="block">
 Get information (<code>QueueInfo</code>) about top level queues.</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.records.YarnClusterMetrics</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getYarnClusterMetrics--">getYarnClusterMetrics</a></span>()</code>
<div class="block">
 Get metrics (<code>YarnClusterMetrics</code>) about the cluster.</div>
</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code>abstract void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#killApplication-org.apache.hadoop.yarn.api.records.ApplicationId-">killApplication</a></span>(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;applicationId)</code>
<div class="block">
 Kill an application identified by given ID.</div>
</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code>abstract void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#killApplication-org.apache.hadoop.yarn.api.records.ApplicationId-java.lang.String-">killApplication</a></span>(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;applicationId,
               <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;diagnostics)</code>
<div class="block">
 Kill an application identified by given ID.</div>
</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.protocolrecords.ReservationListResponse</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#listReservations-org.apache.hadoop.yarn.api.protocolrecords.ReservationListRequest-">listReservations</a></span>(org.apache.hadoop.yarn.api.protocolrecords.ReservationListRequest&nbsp;request)</code>
<div class="block">
 The interface used by clients to get the list of reservations in a plan.</div>
</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code>abstract void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#moveApplicationAcrossQueues-org.apache.hadoop.yarn.api.records.ApplicationId-java.lang.String-">moveApplicationAcrossQueues</a></span>(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;appId,
                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;queue)</code>
<div class="block">
 Attempts to move the given application to the given queue.</div>
</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code>abstract void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#shellToContainer-org.apache.hadoop.yarn.api.records.ContainerId-org.apache.hadoop.yarn.api.records.ShellContainerCommand-">shellToContainer</a></span>(org.apache.hadoop.yarn.api.records.ContainerId&nbsp;containerId,
                org.apache.hadoop.yarn.api.records.ShellContainerCommand&nbsp;command)</code>
<div class="block">
 The interface used by client to get a shell to a container.</div>
</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code>abstract void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#signalToContainer-org.apache.hadoop.yarn.api.records.ContainerId-org.apache.hadoop.yarn.api.records.SignalContainerCommand-">signalToContainer</a></span>(org.apache.hadoop.yarn.api.records.ContainerId&nbsp;containerId,
                 org.apache.hadoop.yarn.api.records.SignalContainerCommand&nbsp;command)</code>
<div class="block">
 Signal a container identified by given ID.</div>
</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.records.ApplicationId</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#submitApplication-org.apache.hadoop.yarn.api.records.ApplicationSubmissionContext-">submitApplication</a></span>(org.apache.hadoop.yarn.api.records.ApplicationSubmissionContext&nbsp;appContext)</code>
<div class="block">
 Submit a new application to <code>YARN.</code> It is a blocking call - it
 will not return <code>ApplicationId</code> until the submitted application is
 submitted successfully and accepted by the ResourceManager.</div>
</td>
</tr>
<tr id="i43" class="rowColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.protocolrecords.ReservationSubmissionResponse</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#submitReservation-org.apache.hadoop.yarn.api.protocolrecords.ReservationSubmissionRequest-">submitReservation</a></span>(org.apache.hadoop.yarn.api.protocolrecords.ReservationSubmissionRequest&nbsp;request)</code>
<div class="block">
 The interface used by clients to submit a new reservation to the
 <code>ResourceManager</code>.</div>
</td>
</tr>
<tr id="i44" class="altColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.records.Priority</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#updateApplicationPriority-org.apache.hadoop.yarn.api.records.ApplicationId-org.apache.hadoop.yarn.api.records.Priority-">updateApplicationPriority</a></span>(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;applicationId,
                         org.apache.hadoop.yarn.api.records.Priority&nbsp;priority)</code>
<div class="block">
 The interface used by client to set priority of an application</div>
</td>
</tr>
<tr id="i45" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.protocolrecords.UpdateApplicationTimeoutsResponse</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#updateApplicationTimeouts-org.apache.hadoop.yarn.api.protocolrecords.UpdateApplicationTimeoutsRequest-">updateApplicationTimeouts</a></span>(org.apache.hadoop.yarn.api.protocolrecords.UpdateApplicationTimeoutsRequest&nbsp;request)</code>&nbsp;</td>
</tr>
<tr id="i46" class="altColor">
<td class="colFirst"><code>abstract org.apache.hadoop.yarn.api.protocolrecords.ReservationUpdateResponse</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#updateReservation-org.apache.hadoop.yarn.api.protocolrecords.ReservationUpdateRequest-">updateReservation</a></span>(org.apache.hadoop.yarn.api.protocolrecords.ReservationUpdateRequest&nbsp;request)</code>
<div class="block">
 The interface used by clients to update an existing Reservation.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.org.apache.hadoop.service.AbstractService">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;org.apache.hadoop.service.AbstractService</h3>
<code>close, getBlockers, getConfig, getFailureCause, getFailureState, getLifecycleHistory, getName, getServiceState, getStartTime, init, isInState, noteFailure, putBlocker, registerGlobalListener, registerServiceListener, removeBlocker, serviceInit, serviceStart, serviceStop, setConfig, start, stop, toString, unregisterGlobalListener, unregisterServiceListener, waitForServiceToStop</code></li>
</ul>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#clone--" title="class or interface in java.lang">clone</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals-java.lang.Object-" title="class or interface in java.lang">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#finalize--" title="class or interface in java.lang">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass--" title="class or interface in java.lang">getClass</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#hashCode--" title="class or interface in java.lang">hashCode</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify--" title="class or interface in java.lang">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll--" title="class or interface in java.lang">notifyAll</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait--" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait-long-int-" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor.detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a name="YarnClient-java.lang.String-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>YarnClient</h4>
<pre>@InterfaceAudience.Private
protected&nbsp;YarnClient(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;name)</pre>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="createYarnClient--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createYarnClient</h4>
<pre>@InterfaceAudience.Public
public static&nbsp;<a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html" title="class in org.apache.hadoop.yarn.client.api">YarnClient</a>&nbsp;createYarnClient()</pre>
<div class="block">Create a new instance of YarnClient.</div>
</li>
</ul>
<a name="createApplication--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createApplication</h4>
<pre>public abstract&nbsp;<a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClientApplication.html" title="class in org.apache.hadoop.yarn.client.api">YarnClientApplication</a>&nbsp;createApplication()
                                                 throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                        <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Obtain a <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClientApplication.html" title="class in org.apache.hadoop.yarn.client.api"><code>YarnClientApplication</code></a> for a new application,
 which in turn contains the <code>ApplicationSubmissionContext</code> and
 <code>GetNewApplicationResponse</code>
 objects.
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClientApplication.html" title="class in org.apache.hadoop.yarn.client.api"><code>YarnClientApplication</code></a> built for a new application</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="submitApplication-org.apache.hadoop.yarn.api.records.ApplicationSubmissionContext-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>submitApplication</h4>
<pre>public abstract&nbsp;org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;submitApplication(org.apache.hadoop.yarn.api.records.ApplicationSubmissionContext&nbsp;appContext)
                                                                            throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Submit a new application to <code>YARN.</code> It is a blocking call - it
 will not return <code>ApplicationId</code> until the submitted application is
 submitted successfully and accepted by the ResourceManager.
 </p>
 
 <p>
 Users should provide an <code>ApplicationId</code> as part of the parameter
 <code>ApplicationSubmissionContext</code> when submitting a new application,
 otherwise it will throw the <code>ApplicationIdNotProvidedException</code>.
 </p>

 <p>This internally calls <code>(SubmitApplicationRequest)</code>, and after that, it internally invokes
 <code>(GetApplicationReportRequest)</code> and waits till it can make sure that the
 application gets properly submitted. If RM fails over or RM restart
 happens before ResourceManager saves the application's state,
 <code>#getApplicationReport(GetApplicationReportRequest)</code> will throw
 the <code>ApplicationNotFoundException</code>. This API automatically resubmits
 the application with the same <code>ApplicationSubmissionContext</code> when it
 catches the <code>ApplicationNotFoundException</code></p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>appContext</code> - <code>ApplicationSubmissionContext</code> containing all the details
          needed to submit a new application</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><code>ApplicationId</code> of the accepted application</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#createApplication--"><code>createApplication()</code></a></dd>
</dl>
</li>
</ul>
<a name="failApplicationAttempt-org.apache.hadoop.yarn.api.records.ApplicationAttemptId-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>failApplicationAttempt</h4>
<pre>public abstract&nbsp;void&nbsp;failApplicationAttempt(org.apache.hadoop.yarn.api.records.ApplicationAttemptId&nbsp;applicationAttemptId)
                                     throws org.apache.hadoop.yarn.exceptions.YarnException,
                                            <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Fail an application attempt identified by given ID.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationAttemptId</code> - <code>ApplicationAttemptId</code> of the attempt to fail.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - in case of errors or if YARN rejects the request due to
           access-control restrictions.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getQueueAclsInfo--"><code>getQueueAclsInfo()</code></a></dd>
</dl>
</li>
</ul>
<a name="killApplication-org.apache.hadoop.yarn.api.records.ApplicationId-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>killApplication</h4>
<pre>public abstract&nbsp;void&nbsp;killApplication(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;applicationId)
                              throws org.apache.hadoop.yarn.exceptions.YarnException,
                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Kill an application identified by given ID.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationId</code> - <code>ApplicationId</code> of the application that needs to be killed</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - in case of errors or if YARN rejects the request due to
           access-control restrictions.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getQueueAclsInfo--"><code>getQueueAclsInfo()</code></a></dd>
</dl>
</li>
</ul>
<a name="killApplication-org.apache.hadoop.yarn.api.records.ApplicationId-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>killApplication</h4>
<pre>public abstract&nbsp;void&nbsp;killApplication(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;applicationId,
                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;diagnostics)
                              throws org.apache.hadoop.yarn.exceptions.YarnException,
                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Kill an application identified by given ID.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationId</code> - <code>ApplicationId</code> of the application that needs to
          be killed</dd>
<dd><code>diagnostics</code> - for killing an application.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - in case of errors or if YARN rejects the request due
           to access-control restrictions.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplicationReport-org.apache.hadoop.yarn.api.records.ApplicationId-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplicationReport</h4>
<pre>public abstract&nbsp;org.apache.hadoop.yarn.api.records.ApplicationReport&nbsp;getApplicationReport(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;appId)
                                                                                   throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                          <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report of the given Application.
 </p>
 
 <p>
 In secure mode, <code>YARN</code> verifies access to the application, queue
 etc. before accepting the request.
 </p>
 
 <p>
 If the user does not have <code>VIEW_APP</code> access then the following
 fields in the report will be set to stubbed values:
 <ul>
 <li>host - set to "N/A"</li>
 <li>RPC port - set to -1</li>
 <li>client token - set to "N/A"</li>
 <li>diagnostics - set to "N/A"</li>
 <li>tracking URL - set to "N/A"</li>
 <li>original tracking URL - set to "N/A"</li>
 <li>resource usage report - all values are -1</li>
 </ul></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>appId</code> - <code>ApplicationId</code> of the application that needs a report</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>application report</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getAMRMToken-org.apache.hadoop.yarn.api.records.ApplicationId-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAMRMToken</h4>
<pre>public abstract&nbsp;org.apache.hadoop.security.token.Token&lt;org.apache.hadoop.yarn.security.AMRMTokenIdentifier&gt;&nbsp;getAMRMToken(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;appId)
                                                                                                                  throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                         <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block">Get the AMRM token of the application.
 <p>
 The AMRM token is required for AM to RM scheduling operations. For 
 managed Application Masters YARN takes care of injecting it. For unmanaged
 Applications Masters, the token must be obtained via this method and set
 in the <code>UserGroupInformation</code> of the
 current user.
 <p>
 The AMRM token will be returned only if all the following conditions are
 met:
 <ul>
   <li>the requester is the owner of the ApplicationMaster</li>
   <li>the application master is an unmanaged ApplicationMaster</li>
   <li>the application master is in ACCEPTED state</li>
 </ul>
 Else this method returns NULL.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>appId</code> - <code>ApplicationId</code> of the application to get the AMRM token</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the AMRM token if available</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplications--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplications</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;&nbsp;getApplications()
                                                                                    throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report (ApplicationReport) of all Applications in the cluster.
 </p>

 <p>
 If the user does not have <code>VIEW_APP</code> access for an application
 then the corresponding report will be filtered as described in
 <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationReport-org.apache.hadoop.yarn.api.records.ApplicationId-"><code>getApplicationReport(ApplicationId)</code></a>.
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of reports of all running applications</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplications-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplications</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;&nbsp;getApplications(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTypes)
                                                                                    throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report (ApplicationReport) of Applications
 matching the given application types in the cluster.
 </p>

 <p>
 If the user does not have <code>VIEW_APP</code> access for an application
 then the corresponding report will be filtered as described in
 <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationReport-org.apache.hadoop.yarn.api.records.ApplicationId-"><code>getApplicationReport(ApplicationId)</code></a>.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationTypes</code> - set of application types you are interested in</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of reports of applications</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplications-java.util.EnumSet-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplications</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;&nbsp;getApplications(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;org.apache.hadoop.yarn.api.records.YarnApplicationState&gt;&nbsp;applicationStates)
                                                                                    throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report (ApplicationReport) of Applications matching the given
 application states in the cluster.
 </p>

 <p>
 If the user does not have <code>VIEW_APP</code> access for an application
 then the corresponding report will be filtered as described in
 <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationReport-org.apache.hadoop.yarn.api.records.ApplicationId-"><code>getApplicationReport(ApplicationId)</code></a>.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationStates</code> - set of application states you are interested in</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of reports of applications</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplications-java.util.Set-java.util.EnumSet-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplications</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;&nbsp;getApplications(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTypes,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;org.apache.hadoop.yarn.api.records.YarnApplicationState&gt;&nbsp;applicationStates)
                                                                                    throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report (ApplicationReport) of Applications matching the given
 application types and application states in the cluster.
 </p>

 <p>
 If the user does not have <code>VIEW_APP</code> access for an application
 then the corresponding report will be filtered as described in
 <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationReport-org.apache.hadoop.yarn.api.records.ApplicationId-"><code>getApplicationReport(ApplicationId)</code></a>.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationTypes</code> - set of application types you are interested in</dd>
<dd><code>applicationStates</code> - set of application states you are interested in</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of reports of applications</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplications-java.util.Set-java.util.EnumSet-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplications</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;&nbsp;getApplications(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTypes,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;org.apache.hadoop.yarn.api.records.YarnApplicationState&gt;&nbsp;applicationStates,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTags)
                                                                                    throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report (ApplicationReport) of Applications matching the given
 application types, application states and application tags in the cluster.
 </p>

 <p>
 If the user does not have <code>VIEW_APP</code> access for an application
 then the corresponding report will be filtered as described in
 <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationReport-org.apache.hadoop.yarn.api.records.ApplicationId-"><code>getApplicationReport(ApplicationId)</code></a>.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationTypes</code> - set of application types you are interested in</dd>
<dd><code>applicationStates</code> - set of application states you are interested in</dd>
<dd><code>applicationTags</code> - set of application tags you are interested in</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of reports of applications</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplications-java.util.Set-java.util.Set-java.util.Set-java.util.EnumSet-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplications</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;&nbsp;getApplications(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;queues,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;users,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;applicationTypes,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/util/EnumSet.html?is-external=true" title="class or interface in java.util">EnumSet</a>&lt;org.apache.hadoop.yarn.api.records.YarnApplicationState&gt;&nbsp;applicationStates)
                                                                                    throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report (ApplicationReport) of Applications matching the given users,
 queues, application types and application states in the cluster. If any of
 the params is set to null, it is not used when filtering.
 </p>

 <p>
 If the user does not have <code>VIEW_APP</code> access for an application
 then the corresponding report will be filtered as described in
 <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationReport-org.apache.hadoop.yarn.api.records.ApplicationId-"><code>getApplicationReport(ApplicationId)</code></a>.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>queues</code> - set of queues you are interested in</dd>
<dd><code>users</code> - set of users you are interested in</dd>
<dd><code>applicationTypes</code> - set of application types you are interested in</dd>
<dd><code>applicationStates</code> - set of application states you are interested in</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of reports of applications</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplications-org.apache.hadoop.yarn.api.protocolrecords.GetApplicationsRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplications</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationReport&gt;&nbsp;getApplications(org.apache.hadoop.yarn.api.protocolrecords.GetApplicationsRequest&nbsp;request)
                                                                           throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                  <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a list of ApplicationReports that match the given
 <code>GetApplicationsRequest</code>.
</p>

 <p>
 If the user does not have <code>VIEW_APP</code> access for an application
 then the corresponding report will be filtered as described in
 <a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClient.html#getApplicationReport-org.apache.hadoop.yarn.api.records.ApplicationId-"><code>getApplicationReport(ApplicationId)</code></a>.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>request</code> - the request object to get the list of applications.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The list of ApplicationReports that match the request</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - Exception specific to YARN.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - Exception mostly related to connection errors.</dd>
</dl>
</li>
</ul>
<a name="getYarnClusterMetrics--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getYarnClusterMetrics</h4>
<pre>public abstract&nbsp;org.apache.hadoop.yarn.api.records.YarnClusterMetrics&nbsp;getYarnClusterMetrics()
                                                                                     throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                            <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get metrics (<code>YarnClusterMetrics</code>) about the cluster.
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>cluster metrics</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getNodeReports-org.apache.hadoop.yarn.api.records.NodeState...-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getNodeReports</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.NodeReport&gt;&nbsp;getNodeReports(org.apache.hadoop.yarn.api.records.NodeState...&nbsp;states)
                                                                            throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report of nodes (<code>NodeReport</code>) in the cluster.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>states</code> - The <code>NodeState</code>s to filter on. If no filter states are
          given, nodes in all states will be returned.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>A list of node reports</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getRMDelegationToken-org.apache.hadoop.io.Text-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getRMDelegationToken</h4>
<pre>public abstract&nbsp;org.apache.hadoop.yarn.api.records.Token&nbsp;getRMDelegationToken(org.apache.hadoop.io.Text&nbsp;renewer)
                                                                       throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a delegation token so as to be able to talk to YARN using those tokens.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>renewer</code> - Address of the renewer who can renew these tokens when needed by
          securely talking to YARN.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a delegation token (<code>Token</code>) that can be used to
         talk to YARN</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getQueueInfo-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getQueueInfo</h4>
<pre>public abstract&nbsp;org.apache.hadoop.yarn.api.records.QueueInfo&nbsp;getQueueInfo(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;queueName)
                                                                   throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                          <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get information (<code>QueueInfo</code>) about a given <em>queue</em>.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>queueName</code> - Name of the queue whose information is needed</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>queue information</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - in case of errors or if YARN rejects the request due to
           access-control restrictions.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getAllQueues--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAllQueues</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.QueueInfo&gt;&nbsp;getAllQueues()
                                                                         throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get information (<code>QueueInfo</code>) about all queues, recursively if there
 is a hierarchy
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of queue-information for all queues</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getRootQueueInfos--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getRootQueueInfos</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.QueueInfo&gt;&nbsp;getRootQueueInfos()
                                                                              throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get information (<code>QueueInfo</code>) about top level queues.
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of queue-information for all the top-level queues</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getChildQueueInfos-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getChildQueueInfos</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.QueueInfo&gt;&nbsp;getChildQueueInfos(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;parent)
                                                                               throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                      <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get information (<code>QueueInfo</code>) about all the immediate children queues
 of the given queue
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>parent</code> - Name of the queue whose child-queues' information is needed</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of queue-information for all queues who are direct children
         of the given parent queue.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getQueueAclsInfo--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getQueueAclsInfo</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.QueueUserACLInfo&gt;&nbsp;getQueueAclsInfo()
                                                                                    throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get information about <em>acls</em> for <em>current user</em> on all the
 existing queues.
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of queue acls (<code>QueueUserACLInfo</code>) for
         <em>current user</em></dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplicationAttemptReport-org.apache.hadoop.yarn.api.records.ApplicationAttemptId-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplicationAttemptReport</h4>
<pre>public abstract&nbsp;org.apache.hadoop.yarn.api.records.ApplicationAttemptReport&nbsp;getApplicationAttemptReport(org.apache.hadoop.yarn.api.records.ApplicationAttemptId&nbsp;applicationAttemptId)
                                                                                                 throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                        <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report of the given ApplicationAttempt.
 </p>
 
 <p>
 In secure mode, <code>YARN</code> verifies access to the application, queue
 etc. before accepting the request.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationAttemptId</code> - <code>ApplicationAttemptId</code> of the application attempt that needs
          a report</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>application attempt report</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code>org.apache.hadoop.yarn.exceptions.ApplicationAttemptNotFoundException</code> - if application attempt
         not found</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApplicationAttempts-org.apache.hadoop.yarn.api.records.ApplicationId-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApplicationAttempts</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ApplicationAttemptReport&gt;&nbsp;getApplicationAttempts(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;applicationId)
                                                                                                  throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                         <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report of all (ApplicationAttempts) of Application in the cluster.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationId</code> - application id of the app</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of reports for all application attempts for specified
         application.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getContainerReport-org.apache.hadoop.yarn.api.records.ContainerId-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getContainerReport</h4>
<pre>public abstract&nbsp;org.apache.hadoop.yarn.api.records.ContainerReport&nbsp;getContainerReport(org.apache.hadoop.yarn.api.records.ContainerId&nbsp;containerId)
                                                                               throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                      <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report of the given Container.
 </p>
 
 <p>
 In secure mode, <code>YARN</code> verifies access to the application, queue
 etc. before accepting the request.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>containerId</code> - <code>ContainerId</code> of the container that needs a report</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>container report</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code>org.apache.hadoop.yarn.exceptions.ContainerNotFoundException</code> - if container not found.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getContainers-org.apache.hadoop.yarn.api.records.ApplicationAttemptId-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getContainers</h4>
<pre>public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ContainerReport&gt;&nbsp;getContainers(org.apache.hadoop.yarn.api.records.ApplicationAttemptId&nbsp;applicationAttemptId)
                                                                                throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get a report of all (Containers) of ApplicationAttempt in the cluster.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationAttemptId</code> - application attempt id</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a list of reports of all containers for specified application
         attempts</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="moveApplicationAcrossQueues-org.apache.hadoop.yarn.api.records.ApplicationId-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>moveApplicationAcrossQueues</h4>
<pre>public abstract&nbsp;void&nbsp;moveApplicationAcrossQueues(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;appId,
                                                 <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;queue)
                                          throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                 <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Attempts to move the given application to the given queue.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>appId</code> - Application to move.</dd>
<dd><code>queue</code> - Queue to place it in to.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="createReservation--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createReservation</h4>
<pre>public abstract&nbsp;org.apache.hadoop.yarn.api.protocolrecords.GetNewReservationResponse&nbsp;createReservation()
                                                                                                throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Obtain a <code>GetNewReservationResponse</code> for a new reservation,
 which contains the <code>ReservationId</code> object.
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>The <code>GetNewReservationResponse</code> containing a new
         <code>ReservationId</code> object.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - if reservation cannot be created.</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if reservation cannot be created.</dd>
</dl>
</li>
</ul>
<a name="submitReservation-org.apache.hadoop.yarn.api.protocolrecords.ReservationSubmissionRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>submitReservation</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;org.apache.hadoop.yarn.api.protocolrecords.ReservationSubmissionResponse&nbsp;submitReservation(org.apache.hadoop.yarn.api.protocolrecords.ReservationSubmissionRequest&nbsp;request)
                                                                                                                                                            throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by clients to submit a new reservation to the
 <code>ResourceManager</code>.
 </p>
 
 <p>
 The client packages all details of its request in a
 <code>ReservationSubmissionRequest</code> object. This contains information
 about the amount of capacity, temporal constraints, and gang needs.
 Furthermore, the reservation might be composed of multiple stages, with
 ordering dependencies among them.
 </p>
 
 <p>
 In order to respond, a new admission control component in the
 <code>ResourceManager</code> performs an analysis of the resources that have
 been committed over the period of time the user is requesting, verify that
 the user requests can be fulfilled, and that it respect a sharing policy
 (e.g., <code>CapacityOverTimePolicy</code>). Once it has positively determined
 that the ReservationRequest is satisfiable the <code>ResourceManager</code>
 answers with a <code>ReservationSubmissionResponse</code> that includes a
 <code>ReservationId</code>. Upon failure to find a valid allocation the response
 is an exception with the message detailing the reason of failure.
 </p>
 
 <p>
 The semantics guarantees that the <code>ReservationId</code> returned,
 corresponds to a valid reservation existing in the time-range request by
 the user. The amount of capacity dedicated to such reservation can vary
 overtime, depending of the allocation that has been determined. But it is
 guaranteed to satisfy all the constraint expressed by the user in the
 <code>ReservationDefinition</code>
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>request</code> - request to submit a new Reservation</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>response contains the <code>ReservationId</code> on accepting the
         submission</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - if the reservation cannot be created successfully</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="updateReservation-org.apache.hadoop.yarn.api.protocolrecords.ReservationUpdateRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateReservation</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;org.apache.hadoop.yarn.api.protocolrecords.ReservationUpdateResponse&nbsp;updateReservation(org.apache.hadoop.yarn.api.protocolrecords.ReservationUpdateRequest&nbsp;request)
                                                                                                                                                        throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                               <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by clients to update an existing Reservation. This is
 referred to as a re-negotiation process, in which a user that has
 previously submitted a Reservation.
 </p>
 
 <p>
 The allocation is attempted by virtually substituting all previous
 allocations related to this Reservation with new ones, that satisfy the new
 <code>ReservationDefinition</code>. Upon success the previous allocation is
 atomically substituted by the new one, and on failure (i.e., if the system
 cannot find a valid allocation for the updated request), the previous
 allocation remains valid.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>request</code> - to update an existing Reservation (the
          <code>ReservationUpdateRequest</code> should refer to an existing valid
          <code>ReservationId</code>)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>response empty on successfully updating the existing reservation</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - if the request is invalid or reservation cannot be
           updated successfully</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="deleteReservation-org.apache.hadoop.yarn.api.protocolrecords.ReservationDeleteRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>deleteReservation</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;org.apache.hadoop.yarn.api.protocolrecords.ReservationDeleteResponse&nbsp;deleteReservation(org.apache.hadoop.yarn.api.protocolrecords.ReservationDeleteRequest&nbsp;request)
                                                                                                                                                        throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                               <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by clients to remove an existing Reservation.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>request</code> - to remove an existing Reservation (the
          <code>ReservationDeleteRequest</code> should refer to an existing valid
          <code>ReservationId</code>)</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>response empty on successfully deleting the existing reservation</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - if the request is invalid or reservation cannot be
           deleted successfully</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="listReservations-org.apache.hadoop.yarn.api.protocolrecords.ReservationListRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>listReservations</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;org.apache.hadoop.yarn.api.protocolrecords.ReservationListResponse&nbsp;listReservations(org.apache.hadoop.yarn.api.protocolrecords.ReservationListRequest&nbsp;request)
                                                                                                                                                     throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                            <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by clients to get the list of reservations in a plan.
 The reservationId will be used to search for reservations to list if it is
 provided. Otherwise, it will select active reservations within the
 startTime and endTime (inclusive).
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>request</code> - to list reservations in a plan. Contains fields to select
                String queue, ReservationId reservationId, long startTime,
                long endTime, and a bool includeReservationAllocations.

                queue: Required. Cannot be null or empty. Refers to the
                reservable queue in the scheduler that was selected when
                creating a reservation submission
                <code>ReservationSubmissionRequest</code>.

                reservationId: Optional. If provided, other fields will
                be ignored.

                startTime: Optional. If provided, only reservations that
                end after the startTime will be selected. This defaults
                to 0 if an invalid number is used.

                endTime: Optional. If provided, only reservations that
                start on or before endTime will be selected. This defaults
                to Long.MAX_VALUE if an invalid number is used.

                includeReservationAllocations: Optional. Flag that
                determines whether the entire reservation allocations are
                to be returned. Reservation allocations are subject to
                change in the event of re-planning as described by
                <code>ReservationDefinition</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>response that contains information about reservations that are
                being searched for.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - if the request is invalid</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if the request failed otherwise</dd>
</dl>
</li>
</ul>
<a name="getNodeToLabels--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getNodeToLabels</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;org.apache.hadoop.yarn.api.records.NodeId,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&gt;&nbsp;getNodeToLabels()
                                                                                                                                            throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by client to get node to labels mappings in existing cluster
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>node to labels mappings</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getLabelsToNodes--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLabelsToNodes</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeId&gt;&gt;&nbsp;getLabelsToNodes()
                                                                                                                                             throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by client to get labels to nodes mapping
 in existing cluster
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>node to labels mappings</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getLabelsToNodes-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLabelsToNodes</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeId&gt;&gt;&nbsp;getLabelsToNodes(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;labels)
                                                                                                                                             throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by client to get labels to nodes mapping
 for specified labels in existing cluster
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>labels</code> - labels for which labels to nodes mapping has to be retrieved</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>labels to nodes mappings for specific labels</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getClusterNodeLabels--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getClusterNodeLabels</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.NodeLabel&gt;&nbsp;getClusterNodeLabels()
                                                                                                                                         throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by client to get node labels in the cluster
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>cluster node labels collection</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - when there is a failure in
           <code>ApplicationClientProtocol</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - when there is a failure in
           <code>ApplicationClientProtocol</code></dd>
</dl>
</li>
</ul>
<a name="updateApplicationPriority-org.apache.hadoop.yarn.api.records.ApplicationId-org.apache.hadoop.yarn.api.records.Priority-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateApplicationPriority</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;org.apache.hadoop.yarn.api.records.Priority&nbsp;updateApplicationPriority(org.apache.hadoop.yarn.api.records.ApplicationId&nbsp;applicationId,
                                                                                                                                              org.apache.hadoop.yarn.api.records.Priority&nbsp;priority)
                                                                                                                                       throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by client to set priority of an application
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>applicationId</code> - </dd>
<dd><code>priority</code> - </dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>updated priority of an application.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="signalToContainer-org.apache.hadoop.yarn.api.records.ContainerId-org.apache.hadoop.yarn.api.records.SignalContainerCommand-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>signalToContainer</h4>
<pre>public abstract&nbsp;void&nbsp;signalToContainer(org.apache.hadoop.yarn.api.records.ContainerId&nbsp;containerId,
                                       org.apache.hadoop.yarn.api.records.SignalContainerCommand&nbsp;command)
                                throws org.apache.hadoop.yarn.exceptions.YarnException,
                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Signal a container identified by given ID.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>containerId</code> - <code>ContainerId</code> of the container that needs to be signaled</dd>
<dd><code>command</code> - the signal container command</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="updateApplicationTimeouts-org.apache.hadoop.yarn.api.protocolrecords.UpdateApplicationTimeoutsRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateApplicationTimeouts</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public&nbsp;org.apache.hadoop.yarn.api.protocolrecords.UpdateApplicationTimeoutsResponse&nbsp;updateApplicationTimeouts(org.apache.hadoop.yarn.api.protocolrecords.UpdateApplicationTimeoutsRequest&nbsp;request)
                                                                                                                                                               throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                                      <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getResourceProfiles--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getResourceProfiles</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,org.apache.hadoop.yarn.api.records.Resource&gt;&nbsp;getResourceProfiles()
                                                                                                                                             throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get the resource profiles available in the RM.
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a Map of the resource profile names to their capabilities</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YARNFeatureNotEnabledException</code> - if resource-profile is disabled</dd>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - if any error happens inside YARN</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - in case of other errors</dd>
</dl>
</li>
</ul>
<a name="getResourceProfile-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getResourceProfile</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;org.apache.hadoop.yarn.api.records.Resource&nbsp;getResourceProfile(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;profile)
                                                                                                                                throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get the details of a specific resource profile from the RM.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>profile</code> - the profile name</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>resource profile name with its capabilities</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YARNFeatureNotEnabledException</code> - if resource-profile is disabled</dd>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - if any error happens inside YARN</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - in case of other others</dd>
</dl>
</li>
</ul>
<a name="getResourceTypeInfo--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getResourceTypeInfo</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.ResourceTypeInfo&gt;&nbsp;getResourceTypeInfo()
                                                                                                                                               throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                      <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 Get available resource types supported by RM.
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>list of supported resource types with detailed information</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - if any issue happens inside YARN</dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - in case of other others</dd>
</dl>
</li>
</ul>
<a name="getClusterAttributes--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getClusterAttributes</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeAttributeInfo&gt;&nbsp;getClusterAttributes()
                                                                                                                                                throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by client to get node attributes in the cluster.
 </p></div>
<dl>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>cluster node attributes collection</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code> - when there is a failure in
                       <code>ApplicationClientProtocol</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - when there is a failure in
                       <code>ApplicationClientProtocol</code></dd>
</dl>
</li>
</ul>
<a name="getAttributesToNodes-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAttributesToNodes</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;org.apache.hadoop.yarn.api.records.NodeAttributeKey,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;org.apache.hadoop.yarn.api.records.NodeToAttributeValue&gt;&gt;&nbsp;getAttributesToNodes(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeAttributeKey&gt;&nbsp;attributes)
                                                                                                                                                                                                             throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                                                                                    <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by client to get mapping of AttributeKey to associated
 NodeToAttributeValue list for specified node attributeKeys in the cluster.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>attributes</code> - AttributeKeys for which associated NodeToAttributeValue
          mapping value has to be retrieved. If empty or null is set then
          will return mapping for all attributeKeys in the cluster</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>mapping of AttributeKey to List of associated
         NodeToAttributeValue's.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="getNodeToAttributes-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getNodeToAttributes</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html?is-external=true" title="class or interface in java.util">Map</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>,<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.NodeAttribute&gt;&gt;&nbsp;getNodeToAttributes(<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&gt;&nbsp;hostNames)
                                                                                                                                                       throws org.apache.hadoop.yarn.exceptions.YarnException,
                                                                                                                                                              <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by client to get all node to attribute mapping in
 existing cluster.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>hostNames</code> - HostNames for which host to attributes mapping has to
                  be retrived.If empty or null is set then will return
                  all nodes to attributes mapping in cluster.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>Node to attribute mappings</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code></dd>
</dl>
</li>
</ul>
<a name="shellToContainer-org.apache.hadoop.yarn.api.records.ContainerId-org.apache.hadoop.yarn.api.records.ShellContainerCommand-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>shellToContainer</h4>
<pre>@InterfaceAudience.Public
 @InterfaceStability.Unstable
public abstract&nbsp;void&nbsp;shellToContainer(org.apache.hadoop.yarn.api.records.ContainerId&nbsp;containerId,
                                                                                              org.apache.hadoop.yarn.api.records.ShellContainerCommand&nbsp;command)
                                                                                       throws <a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></pre>
<div class="block"><p>
 The interface used by client to get a shell to a container.
 </p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>containerId</code> - Container ID</dd>
<dd><code>command</code> - Shell type</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/io/IOException.html?is-external=true" title="class or interface in java.io">IOException</a></code> - if connection fails.</dd>
</dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a name="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/YarnClient.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../../../index-all.html">Index</a></li>
<li><a href="../../../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList">
<li><a href="../../../../../../org/apache/hadoop/yarn/client/api/SharedCacheClient.html" title="class in org.apache.hadoop.yarn.client.api"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../../../org/apache/hadoop/yarn/client/api/YarnClientApplication.html" title="class in org.apache.hadoop.yarn.client.api"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../index.html?org/apache/hadoop/yarn/client/api/YarnClient.html" target="_top">Frames</a></li>
<li><a href="YarnClient.html" target="_top">No&nbsp;Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../../../allclasses-noframe.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor.detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a name="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &#169; 2008&#x2013;2021 <a href="https://www.apache.org">Apache Software Foundation</a>. All rights reserved.</small></p>
</body>
</html>
