<!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:13:18 GMT 2021 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>FederationInterceptorREST (Apache Hadoop YARN Router 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="FederationInterceptorREST (Apache Hadoop YARN Router 3.3.1 API)";
        }
    }
    catch(err) {
    }
//-->
var methods = {"i0":10,"i1":10,"i2":10,"i3":10,"i4":10,"i5":10,"i6":10,"i7":10,"i8":10,"i9":10,"i10":10,"i11":10,"i12":10,"i13":10,"i14":10,"i15":10,"i16":10,"i17":10,"i18":10,"i19":10,"i20":10,"i21":10,"i22":10,"i23":10,"i24":10,"i25":10,"i26":10,"i27":10,"i28":10,"i29":10,"i30":10,"i31":10,"i32":10,"i33":10,"i34":10,"i35":10,"i36":10,"i37":10,"i38":10,"i39":10,"i40":10,"i41":10,"i42":10,"i43":10,"i44":10,"i45":10,"i46":10,"i47":10,"i48":10,"i49":10,"i50":10,"i51":10};
var tabs = {65535:["t0","All Methods"],2:["t2","Instance 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/FederationInterceptorREST.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/server/router/webapp/DefaultRequestInterceptorREST.html" title="class in org.apache.hadoop.yarn.server.router.webapp"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/HTTPMethods.html" title="enum in org.apache.hadoop.yarn.server.router.webapp"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html" target="_top">Frames</a></li>
<li><a href="FederationInterceptorREST.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.server.router.webapp</div>
<h2 title="Class FederationInterceptorREST" class="title">Class FederationInterceptorREST</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><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html" title="class in org.apache.hadoop.yarn.server.router.webapp">org.apache.hadoop.yarn.server.router.webapp.AbstractRESTRequestInterceptor</a></li>
<li>
<ul class="inheritance">
<li>org.apache.hadoop.yarn.server.router.webapp.FederationInterceptorREST</li>
</ul>
</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<dl>
<dt>All Implemented Interfaces:</dt>
<dd>org.apache.hadoop.conf.Configurable, org.apache.hadoop.yarn.server.resourcemanager.webapp.RMWebServiceProtocol, <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp">RESTRequestInterceptor</a></dd>
</dl>
<hr>
<br>
<pre>public class <span class="typeNameLabel">FederationInterceptorREST</span>
extends <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html" title="class in org.apache.hadoop.yarn.server.router.webapp">AbstractRESTRequestInterceptor</a></pre>
<div class="block">Extends the <code>AbstractRESTRequestInterceptor</code> class and provides an
 implementation for federation of YARN RM and scaling an application across
 multiple YARN SubClusters. All the federation specific implementation is
 encapsulated in this class. This is always the last intercepter in the chain.</div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== 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="colOne" scope="col">Constructor and Description</th>
</tr>
<tr class="altColor">
<td class="colOne"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#FederationInterceptorREST--">FederationInterceptorREST</a></span>()</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="t2" class="tableTab"><span><a href="javascript:show(2);">Instance 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>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#addToClusterNodeLabels-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeLabelsInfo-javax.servlet.http.HttpServletRequest-">addToClusterNodeLabels</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeLabelsInfo&nbsp;newNodeLabels,
                      javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#cancelDelegationToken-javax.servlet.http.HttpServletRequest-">cancelDelegationToken</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.RMQueueAclInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#checkUserAccessToQueue-java.lang.String-java.lang.String-java.lang.String-javax.servlet.http.HttpServletRequest-">checkUserAccessToQueue</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;queue,
                      <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;username,
                      <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;queueAclType,
                      javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#createNewApplication-javax.servlet.http.HttpServletRequest-">createNewApplication</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>
<div class="block">YARN Router forwards every getNewApplication requests to any RM.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#createNewReservation-javax.servlet.http.HttpServletRequest-">createNewReservation</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#deleteReservation-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationDeleteRequestInfo-javax.servlet.http.HttpServletRequest-">deleteReservation</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationDeleteRequestInfo&nbsp;resContext,
                 javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code><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></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#dumpSchedulerLogs-java.lang.String-javax.servlet.http.HttpServletRequest-">dumpSchedulerLogs</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;time,
                 javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ClusterInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#get--">get</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ActivitiesInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getActivities-javax.servlet.http.HttpServletRequest-java.lang.String-java.lang.String-">getActivities</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
             <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;nodeId,
             <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;groupBy)</code>&nbsp;</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getApp-javax.servlet.http.HttpServletRequest-java.lang.String-java.util.Set-">getApp</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
      <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;appId,
      <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;unselectedFields)</code>
<div class="block">The YARN Router will forward to the respective YARN RM in which the AM is
 running.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppActivitiesInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getAppActivities-javax.servlet.http.HttpServletRequest-java.lang.String-java.lang.String-java.util.Set-java.util.Set-java.lang.String-java.lang.String-java.util.Set-boolean-">getAppActivities</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                <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;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;time,
                <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;requestPriorities,
                <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;allocationRequestIds,
                <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;groupBy,
                <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;limit,
                <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;actions,
                boolean&nbsp;summarize)</code>&nbsp;</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.webapp.dao.AppAttemptInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getAppAttempt-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-">getAppAttempt</a></span>(javax.servlet.http.HttpServletRequest&nbsp;req,
             javax.servlet.http.HttpServletResponse&nbsp;res,
             <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;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;appAttemptId)</code>&nbsp;</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppAttemptsInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getAppAttempts-javax.servlet.http.HttpServletRequest-java.lang.String-">getAppAttempts</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
              <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;appId)</code>&nbsp;</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppPriority</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getAppPriority-javax.servlet.http.HttpServletRequest-java.lang.String-">getAppPriority</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
              <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;appId)</code>&nbsp;</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppQueue</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getAppQueue-javax.servlet.http.HttpServletRequest-java.lang.String-">getAppQueue</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
           <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;appId)</code>&nbsp;</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppsInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getApps-javax.servlet.http.HttpServletRequest-java.lang.String-java.util.Set-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.util.Set-java.util.Set-java.lang.String-java.util.Set-">getApps</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
       <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;stateQuery,
       <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;statesQuery,
       <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;finalStatusQuery,
       <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;userQuery,
       <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;queueQuery,
       <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;count,
       <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;startedBegin,
       <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;startedEnd,
       <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;finishBegin,
       <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;finishEnd,
       <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/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,
       <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,
       <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;unselectedFields)</code>
<div class="block">The YARN Router will forward the request to all the YARN RMs in parallel,
 after that it will group all the ApplicationReports by the ApplicationId.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppState</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getAppState-javax.servlet.http.HttpServletRequest-java.lang.String-">getAppState</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
           <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;appId)</code>
<div class="block">The YARN Router will forward to the respective YARN RM in which the AM is
 running.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ApplicationStatisticsInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getAppStatistics-javax.servlet.http.HttpServletRequest-java.util.Set-java.util.Set-">getAppStatistics</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                <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;stateQueries,
                <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;typeQueries)</code>&nbsp;</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppTimeoutInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getAppTimeout-javax.servlet.http.HttpServletRequest-java.lang.String-java.lang.String-">getAppTimeout</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
             <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;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;type)</code>&nbsp;</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppTimeoutsInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getAppTimeouts-javax.servlet.http.HttpServletRequest-java.lang.String-">getAppTimeouts</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
              <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;appId)</code>&nbsp;</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ClusterInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getClusterInfo--">getClusterInfo</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ClusterMetricsInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getClusterMetricsInfo--">getClusterMetricsInfo</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeLabelsInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getClusterNodeLabels-javax.servlet.http.HttpServletRequest-">getClusterNodeLabels</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ClusterUserInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getClusterUserInfo-javax.servlet.http.HttpServletRequest-">getClusterUserInfo</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.webapp.dao.ContainerInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getContainer-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-">getContainer</a></span>(javax.servlet.http.HttpServletRequest&nbsp;req,
            javax.servlet.http.HttpServletResponse&nbsp;res,
            <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;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;appAttemptId,
            <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;containerId)</code>&nbsp;</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.webapp.dao.ContainersInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getContainers-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-">getContainers</a></span>(javax.servlet.http.HttpServletRequest&nbsp;req,
             javax.servlet.http.HttpServletResponse&nbsp;res,
             <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;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;appAttemptId)</code>&nbsp;</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code>protected <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/DefaultRequestInterceptorREST.html" title="class in org.apache.hadoop.yarn.server.router.webapp">DefaultRequestInterceptorREST</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getInterceptorForSubCluster-org.apache.hadoop.yarn.server.federation.store.records.SubClusterId-">getInterceptorForSubCluster</a></span>(org.apache.hadoop.yarn.server.federation.store.records.SubClusterId&nbsp;subClusterId)</code>&nbsp;</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeLabelsInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getLabelsOnNode-javax.servlet.http.HttpServletRequest-java.lang.String-">getLabelsOnNode</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
               <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;nodeId)</code>&nbsp;</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.LabelsToNodesInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.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>&nbsp;</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getNode-java.lang.String-">getNode</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;nodeId)</code>
<div class="block">The YARN Router will forward to the request to all the SubClusters to find
 where the node is running.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodesInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getNodes-java.lang.String-">getNodes</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;states)</code>
<div class="block">The YARN Router will forward the request to all the YARN RMs in parallel,
 after that it will remove all the duplicated NodeInfo by using the NodeId.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeToLabelsInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getNodeToLabels-javax.servlet.http.HttpServletRequest-">getNodeToLabels</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code>protected <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/DefaultRequestInterceptorREST.html" title="class in org.apache.hadoop.yarn.server.router.webapp">DefaultRequestInterceptorREST</a></code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getOrCreateInterceptorForSubCluster-org.apache.hadoop.yarn.server.federation.store.records.SubClusterId-java.lang.String-">getOrCreateInterceptorForSubCluster</a></span>(org.apache.hadoop.yarn.server.federation.store.records.SubClusterId&nbsp;subClusterId,
                                   <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;webAppAddress)</code>&nbsp;</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.SchedulerTypeInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#getSchedulerInfo--">getSchedulerInfo</a></span>()</code>&nbsp;</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#init-java.lang.String-">init</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;user)</code>
<div class="block">Initializes the <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp"><code>RESTRequestInterceptor</code></a>.</div>
</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#listReservation-java.lang.String-java.lang.String-long-long-boolean-javax.servlet.http.HttpServletRequest-">listReservation</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;queue,
               <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;reservationId,
               long&nbsp;startTime,
               long&nbsp;endTime,
               boolean&nbsp;includeResourceAllocations,
               javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#postDelegationToken-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.DelegationToken-javax.servlet.http.HttpServletRequest-">postDelegationToken</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.DelegationToken&nbsp;tokenData,
                   javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i37" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#postDelegationTokenExpiration-javax.servlet.http.HttpServletRequest-">postDelegationTokenExpiration</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i38" class="altColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#removeFromCluserNodeLabels-java.util.Set-javax.servlet.http.HttpServletRequest-">removeFromCluserNodeLabels</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;oldNodeLabels,
                          javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i39" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#replaceLabelsOnNode-java.util.Set-javax.servlet.http.HttpServletRequest-java.lang.String-">replaceLabelsOnNode</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;newNodeLabelsName,
                   javax.servlet.http.HttpServletRequest&nbsp;hsr,
                   <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;nodeId)</code>&nbsp;</td>
</tr>
<tr id="i40" class="altColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#replaceLabelsOnNodes-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeToLabelsEntryList-javax.servlet.http.HttpServletRequest-">replaceLabelsOnNodes</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeToLabelsEntryList&nbsp;newNodeToLabels,
                    javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i41" class="rowColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#setNextInterceptor-org.apache.hadoop.yarn.server.router.webapp.RESTRequestInterceptor-">setNextInterceptor</a></span>(<a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp">RESTRequestInterceptor</a>&nbsp;next)</code>
<div class="block">Sets the <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp"><code>RESTRequestInterceptor</code></a> in the chain.</div>
</td>
</tr>
<tr id="i42" class="altColor">
<td class="colFirst"><code>void</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#shutdown--">shutdown</a></span>()</code>
<div class="block">Disposes the <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp"><code>RESTRequestInterceptor</code></a>.</div>
</td>
</tr>
<tr id="i43" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#signalToContainer-java.lang.String-java.lang.String-javax.servlet.http.HttpServletRequest-">signalToContainer</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;containerId,
                 <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;command,
                 javax.servlet.http.HttpServletRequest&nbsp;req)</code>&nbsp;</td>
</tr>
<tr id="i44" class="altColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#submitApplication-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ApplicationSubmissionContextInfo-javax.servlet.http.HttpServletRequest-">submitApplication</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ApplicationSubmissionContextInfo&nbsp;newApp,
                 javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>
<div class="block">Today, in YARN there are no checks of any applicationId submitted.</div>
</td>
</tr>
<tr id="i45" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#submitReservation-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationSubmissionRequestInfo-javax.servlet.http.HttpServletRequest-">submitReservation</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationSubmissionRequestInfo&nbsp;resContext,
                 javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
<tr id="i46" class="altColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#updateApplicationPriority-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppPriority-javax.servlet.http.HttpServletRequest-java.lang.String-">updateApplicationPriority</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppPriority&nbsp;targetPriority,
                         javax.servlet.http.HttpServletRequest&nbsp;hsr,
                         <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;appId)</code>&nbsp;</td>
</tr>
<tr id="i47" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#updateApplicationTimeout-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppTimeoutInfo-javax.servlet.http.HttpServletRequest-java.lang.String-">updateApplicationTimeout</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppTimeoutInfo&nbsp;appTimeout,
                        javax.servlet.http.HttpServletRequest&nbsp;hsr,
                        <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;appId)</code>&nbsp;</td>
</tr>
<tr id="i48" class="altColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#updateAppQueue-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppQueue-javax.servlet.http.HttpServletRequest-java.lang.String-">updateAppQueue</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppQueue&nbsp;targetQueue,
              javax.servlet.http.HttpServletRequest&nbsp;hsr,
              <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;appId)</code>&nbsp;</td>
</tr>
<tr id="i49" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#updateAppState-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppState-javax.servlet.http.HttpServletRequest-java.lang.String-">updateAppState</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppState&nbsp;targetState,
              javax.servlet.http.HttpServletRequest&nbsp;hsr,
              <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;appId)</code>
<div class="block">The YARN Router will forward to the respective YARN RM in which the AM is
 running.</div>
</td>
</tr>
<tr id="i50" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ResourceInfo</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#updateNodeResource-javax.servlet.http.HttpServletRequest-java.lang.String-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ResourceOptionInfo-">updateNodeResource</a></span>(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                  <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;nodeId,
                  org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ResourceOptionInfo&nbsp;resourceOption)</code>&nbsp;</td>
</tr>
<tr id="i51" class="rowColor">
<td class="colFirst"><code>javax.ws.rs.core.Response</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html#updateReservation-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationUpdateRequestInfo-javax.servlet.http.HttpServletRequest-">updateReservation</a></span>(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationUpdateRequestInfo&nbsp;resContext,
                 javax.servlet.http.HttpServletRequest&nbsp;hsr)</code>&nbsp;</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods.inherited.from.class.org.apache.hadoop.yarn.server.router.webapp.AbstractRESTRequestInterceptor">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;org.apache.hadoop.yarn.server.router.webapp.<a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html" title="class in org.apache.hadoop.yarn.server.router.webapp">AbstractRESTRequestInterceptor</a></h3>
<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html#getConf--">getConf</a>, <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html#getNextInterceptor--">getNextInterceptor</a>, <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html#setConf-org.apache.hadoop.conf.Configuration-">setConf</a></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#toString--" title="class or interface in java.lang">toString</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="FederationInterceptorREST--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>FederationInterceptorREST</h4>
<pre>public&nbsp;FederationInterceptorREST()</pre>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="init-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>init</h4>
<pre>public&nbsp;void&nbsp;init(<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;user)</pre>
<div class="block"><span class="descfrmTypeLabel">Description copied from class:&nbsp;<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html#init-java.lang.String-">AbstractRESTRequestInterceptor</a></code></span></div>
<div class="block">Initializes the <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp"><code>RESTRequestInterceptor</code></a>.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html#init-java.lang.String-">init</a></code>&nbsp;in interface&nbsp;<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp">RESTRequestInterceptor</a></code></dd>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html#init-java.lang.String-">init</a></code>&nbsp;in class&nbsp;<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html" title="class in org.apache.hadoop.yarn.server.router.webapp">AbstractRESTRequestInterceptor</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>user</code> - the name of the client</dd>
</dl>
</li>
</ul>
<a name="getInterceptorForSubCluster-org.apache.hadoop.yarn.server.federation.store.records.SubClusterId-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getInterceptorForSubCluster</h4>
<pre>protected&nbsp;<a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/DefaultRequestInterceptorREST.html" title="class in org.apache.hadoop.yarn.server.router.webapp">DefaultRequestInterceptorREST</a>&nbsp;getInterceptorForSubCluster(org.apache.hadoop.yarn.server.federation.store.records.SubClusterId&nbsp;subClusterId)</pre>
</li>
</ul>
<a name="getOrCreateInterceptorForSubCluster-org.apache.hadoop.yarn.server.federation.store.records.SubClusterId-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getOrCreateInterceptorForSubCluster</h4>
<pre>protected&nbsp;<a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/DefaultRequestInterceptorREST.html" title="class in org.apache.hadoop.yarn.server.router.webapp">DefaultRequestInterceptorREST</a>&nbsp;getOrCreateInterceptorForSubCluster(org.apache.hadoop.yarn.server.federation.store.records.SubClusterId&nbsp;subClusterId,
                                                                            <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;webAppAddress)</pre>
</li>
</ul>
<a name="createNewApplication-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createNewApplication</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;createNewApplication(javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                               throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                      <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>,
                                                      <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></pre>
<div class="block">YARN Router forwards every getNewApplication requests to any RM. During
 this operation there will be no communication with the State Store. The
 Router will forward the requests to any SubCluster. The Router will retry
 to submit the request on #numSubmitRetries different SubClusters. The
 SubClusters are randomly chosen from the active ones.
 <p>
 Possible failures and behaviors:
 <p>
 Client: identical behavior as <code>RMWebServices</code>.
 <p>
 Router: the Client will timeout and resubmit.
 <p>
 ResourceManager: the Router will timeout and contacts another RM.
 <p>
 StateStore: not in the execution.</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</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>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></code></dd>
</dl>
</li>
</ul>
<a name="submitApplication-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ApplicationSubmissionContextInfo-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>submitApplication</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;submitApplication(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ApplicationSubmissionContextInfo&nbsp;newApp,
                                                   javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                            throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                   <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>,
                                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></pre>
<div class="block">Today, in YARN there are no checks of any applicationId submitted.
 <p>
 Base scenarios:
 <p>
 The Client submits an application to the Router. The Router selects one
 SubCluster to forward the request. The Router inserts a tuple into
 StateStore with the selected SubCluster (e.g. SC1) and the appId. The
 State Store replies with the selected SubCluster (e.g. SC1). The Router
 submits the request to the selected SubCluster.
 <p>
 In case of State Store failure:
 <p>
 The client submits an application to the Router. The Router selects one
 SubCluster to forward the request. The Router inserts a tuple into State
 Store with the selected SubCluster (e.g. SC1) and the appId. Due to the
 State Store down the Router times out and it will retry depending on the
 FederationFacade settings. The Router replies to the client with an error
 message.
 <p>
 If State Store fails after inserting the tuple: identical behavior as
 <code>RMWebServices</code>.
 <p>
 In case of Router failure:
 <p>
 Scenario 1 – Crash before submission to the ResourceManager
 <p>
 The Client submits an application to the Router. The Router selects one
 SubCluster to forward the request. The Router inserts a tuple into State
 Store with the selected SubCluster (e.g. SC1) and the appId. The Router
 crashes. The Client timeouts and resubmits the application. The Router
 selects one SubCluster to forward the request. The Router inserts a tuple
 into State Store with the selected SubCluster (e.g. SC2) and the appId.
 Because the tuple is already inserted in the State Store, it returns the
 previous selected SubCluster (e.g. SC1). The Router submits the request
 to the selected SubCluster (e.g. SC1).
 <p>
 Scenario 2 – Crash after submission to the ResourceManager
 <p>
 The Client submits an application to the Router. The Router selects one
 SubCluster to forward the request. The Router inserts a tuple into State
 Store with the selected SubCluster (e.g. SC1) and the appId. The Router
 submits the request to the selected SubCluster. The Router crashes. The
 Client timeouts and resubmit the application. The Router selects one
 SubCluster to forward the request. The Router inserts a tuple into State
 Store with the selected SubCluster (e.g. SC2) and the appId. The State
 Store replies with the selected SubCluster (e.g. SC1). The Router submits
 the request to the selected SubCluster (e.g. SC1). When a client re-submits
 the same application to the same RM, it does not raise an exception and
 replies with operation successful message.
 <p>
 In case of Client failure: identical behavior as <code>RMWebServices</code>.
 <p>
 In case of ResourceManager failure:
 <p>
 The Client submits an application to the Router. The Router selects one
 SubCluster to forward the request. The Router inserts a tuple into State
 Store with the selected SubCluster (e.g. SC1) and the appId. The Router
 submits the request to the selected SubCluster. The entire SubCluster is
 down – all the RMs in HA or the master RM is not reachable. The Router
 times out. The Router selects a new SubCluster to forward the request.
 The Router update a tuple into State Store with the selected SubCluster
 (e.g. SC2) and the appId. The State Store replies with OK answer. The
 Router submits the request to the selected SubCluster (e.g. SC2).</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</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>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></code></dd>
</dl>
</li>
</ul>
<a name="getApp-javax.servlet.http.HttpServletRequest-java.lang.String-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApp</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppInfo&nbsp;getApp(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                               <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;appId,
                                                                               <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;unselectedFields)</pre>
<div class="block">The YARN Router will forward to the respective YARN RM in which the AM is
 running.
 <p>
 Possible failure:
 <p>
 Client: identical behavior as <code>RMWebServices</code>.
 <p>
 Router: the Client will timeout and resubmit the request.
 <p>
 ResourceManager: the Router will timeout and the call will fail.
 <p>
 State Store: the Router will timeout and it will retry depending on the
 FederationFacade settings - if the failure happened before the select
 operation.</div>
</li>
</ul>
<a name="updateAppState-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppState-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateAppState</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;updateAppState(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppState&nbsp;targetState,
                                                javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                <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;appId)
                                         throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                org.apache.hadoop.yarn.exceptions.YarnException,
                                                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a>,
                                                <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">The YARN Router will forward to the respective YARN RM in which the AM is
 running.
 <p>
 Possible failures and behaviors:
 <p>
 Client: identical behavior as <code>RMWebServices</code>.
 <p>
 Router: the Client will timeout and resubmit the request.
 <p>
 ResourceManager: the Router will timeout and the call will fail.
 <p>
 State Store: the Router will timeout and it will retry depending on the
 FederationFacade settings - if the failure happened before the select
 operation.</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</code></dd>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></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="getApps-javax.servlet.http.HttpServletRequest-java.lang.String-java.util.Set-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.util.Set-java.util.Set-java.lang.String-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApps</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppsInfo&nbsp;getApps(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                 <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;stateQuery,
                                                                                 <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;statesQuery,
                                                                                 <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;finalStatusQuery,
                                                                                 <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;userQuery,
                                                                                 <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;queueQuery,
                                                                                 <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;count,
                                                                                 <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;startedBegin,
                                                                                 <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;startedEnd,
                                                                                 <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;finishBegin,
                                                                                 <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;finishEnd,
                                                                                 <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/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,
                                                                                 <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,
                                                                                 <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;unselectedFields)</pre>
<div class="block">The YARN Router will forward the request to all the YARN RMs in parallel,
 after that it will group all the ApplicationReports by the ApplicationId.
 <p>
 Possible failure:
 <p>
 Client: identical behavior as <code>RMWebServices</code>.
 <p>
 Router: the Client will timeout and resubmit the request.
 <p>
 ResourceManager: the Router calls each YARN RM in parallel by using one
 thread for each YARN RM. In case a YARN RM fails, a single call will
 timeout. However the Router will merge the ApplicationReports it got, and
 provides a partial list to the client.
 <p>
 State Store: the Router will timeout and it will retry depending on the
 FederationFacade settings - if the failure happened before the select
 operation.</div>
</li>
</ul>
<a name="getNode-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getNode</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeInfo&nbsp;getNode(<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;nodeId)</pre>
<div class="block">The YARN Router will forward to the request to all the SubClusters to find
 where the node is running.
 <p>
 Possible failure:
 <p>
 Client: identical behavior as <code>RMWebServices</code>.
 <p>
 Router: the Client will timeout and resubmit the request.
 <p>
 ResourceManager: the Router will timeout and the call will fail.
 <p>
 State Store: the Router will timeout and it will retry depending on the
 FederationFacade settings - if the failure happened before the select
 operation.</div>
</li>
</ul>
<a name="getNodes-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getNodes</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodesInfo&nbsp;getNodes(<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;states)</pre>
<div class="block">The YARN Router will forward the request to all the YARN RMs in parallel,
 after that it will remove all the duplicated NodeInfo by using the NodeId.
 <p>
 Possible failure:
 <p>
 Client: identical behavior as <code>RMWebServices</code>.
 <p>
 Router: the Client will timeout and resubmit the request.
 <p>
 ResourceManager: the Router calls each YARN RM in parallel by using one
 thread for each YARN RM. In case a YARN RM fails, a single call will
 timeout. However the Router will use the NodesInfo it got, and provides a
 partial list to the client.
 <p>
 State Store: the Router will timeout and it will retry depending on the
 FederationFacade settings - if the failure happened before the select
 operation.</div>
</li>
</ul>
<a name="updateNodeResource-javax.servlet.http.HttpServletRequest-java.lang.String-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ResourceOptionInfo-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateNodeResource</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ResourceInfo&nbsp;updateNodeResource(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                                <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;nodeId,
                                                                                                org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ResourceOptionInfo&nbsp;resourceOption)</pre>
</li>
</ul>
<a name="getClusterMetricsInfo--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getClusterMetricsInfo</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ClusterMetricsInfo&nbsp;getClusterMetricsInfo()</pre>
</li>
</ul>
<a name="getAppState-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppState</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppState&nbsp;getAppState(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                     <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;appId)
                                                                              throws org.apache.hadoop.security.authorize.AuthorizationException</pre>
<div class="block">The YARN Router will forward to the respective YARN RM in which the AM is
 running.
 <p>
 Possible failure:
 <p>
 Client: identical behavior as <code>RMWebServices</code>.
 <p>
 Router: the Client will timeout and resubmit the request.
 <p>
 ResourceManager: the Router will timeout and the call will fail.
 <p>
 State Store: the Router will timeout and it will retry depending on the
 FederationFacade settings - if the failure happened before the select
 operation.</div>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</code></dd>
</dl>
</li>
</ul>
<a name="get--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>get</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ClusterInfo&nbsp;get()</pre>
</li>
</ul>
<a name="getClusterInfo--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getClusterInfo</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ClusterInfo&nbsp;getClusterInfo()</pre>
</li>
</ul>
<a name="getClusterUserInfo-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getClusterUserInfo</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ClusterUserInfo&nbsp;getClusterUserInfo(javax.servlet.http.HttpServletRequest&nbsp;hsr)</pre>
</li>
</ul>
<a name="getSchedulerInfo--">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSchedulerInfo</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.SchedulerTypeInfo&nbsp;getSchedulerInfo()</pre>
</li>
</ul>
<a name="dumpSchedulerLogs-java.lang.String-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>dumpSchedulerLogs</h4>
<pre>public&nbsp;<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;dumpSchedulerLogs(<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;time,
                                javax.servlet.http.HttpServletRequest&nbsp;hsr)
                         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>
<dl>
<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></dd>
</dl>
</li>
</ul>
<a name="getActivities-javax.servlet.http.HttpServletRequest-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getActivities</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ActivitiesInfo&nbsp;getActivities(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                             <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;nodeId,
                                                                                             <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;groupBy)</pre>
</li>
</ul>
<a name="getAppActivities-javax.servlet.http.HttpServletRequest-java.lang.String-java.lang.String-java.util.Set-java.util.Set-java.lang.String-java.lang.String-java.util.Set-boolean-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppActivities</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppActivitiesInfo&nbsp;getAppActivities(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                                   <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;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;time,
                                                                                                   <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;requestPriorities,
                                                                                                   <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;allocationRequestIds,
                                                                                                   <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;groupBy,
                                                                                                   <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;limit,
                                                                                                   <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;actions,
                                                                                                   boolean&nbsp;summarize)</pre>
</li>
</ul>
<a name="getAppStatistics-javax.servlet.http.HttpServletRequest-java.util.Set-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppStatistics</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ApplicationStatisticsInfo&nbsp;getAppStatistics(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                                           <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;stateQueries,
                                                                                                           <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;typeQueries)</pre>
</li>
</ul>
<a name="getNodeToLabels-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getNodeToLabels</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeToLabelsInfo&nbsp;getNodeToLabels(javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                                                                          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>
<dl>
<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></dd>
</dl>
</li>
</ul>
<a name="getLabelsToNodes-java.util.Set-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLabelsToNodes</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.LabelsToNodesInfo&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 <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><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="replaceLabelsOnNodes-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeToLabelsEntryList-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>replaceLabelsOnNodes</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;replaceLabelsOnNodes(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeToLabelsEntryList&nbsp;newNodeToLabels,
                                                      javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                               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>
<dl>
<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></dd>
</dl>
</li>
</ul>
<a name="replaceLabelsOnNode-java.util.Set-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>replaceLabelsOnNode</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;replaceLabelsOnNode(<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;newNodeLabelsName,
                                                     javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                     <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;nodeId)
                                              throws <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></code></dd>
</dl>
</li>
</ul>
<a name="getClusterNodeLabels-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getClusterNodeLabels</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeLabelsInfo&nbsp;getClusterNodeLabels(javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                                                                             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>
<dl>
<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></dd>
</dl>
</li>
</ul>
<a name="addToClusterNodeLabels-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeLabelsInfo-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addToClusterNodeLabels</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;addToClusterNodeLabels(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeLabelsInfo&nbsp;newNodeLabels,
                                                        javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                                 throws <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></code></dd>
</dl>
</li>
</ul>
<a name="removeFromCluserNodeLabels-java.util.Set-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>removeFromCluserNodeLabels</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;removeFromCluserNodeLabels(<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;oldNodeLabels,
                                                            javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                                     throws <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></code></dd>
</dl>
</li>
</ul>
<a name="getLabelsOnNode-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLabelsOnNode</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.NodeLabelsInfo&nbsp;getLabelsOnNode(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                               <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;nodeId)
                                                                                        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>
<dl>
<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></dd>
</dl>
</li>
</ul>
<a name="getAppPriority-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppPriority</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppPriority&nbsp;getAppPriority(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                           <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;appId)
                                                                                    throws org.apache.hadoop.security.authorize.AuthorizationException</pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</code></dd>
</dl>
</li>
</ul>
<a name="updateApplicationPriority-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppPriority-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateApplicationPriority</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;updateApplicationPriority(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppPriority&nbsp;targetPriority,
                                                           javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                           <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;appId)
                                                    throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                           org.apache.hadoop.yarn.exceptions.YarnException,
                                                           <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a>,
                                                           <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.security.authorize.AuthorizationException</code></dd>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></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="getAppQueue-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppQueue</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppQueue&nbsp;getAppQueue(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                     <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;appId)
                                                                              throws org.apache.hadoop.security.authorize.AuthorizationException</pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</code></dd>
</dl>
</li>
</ul>
<a name="updateAppQueue-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppQueue-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateAppQueue</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;updateAppQueue(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppQueue&nbsp;targetQueue,
                                                javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                <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;appId)
                                         throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                org.apache.hadoop.yarn.exceptions.YarnException,
                                                <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a>,
                                                <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.security.authorize.AuthorizationException</code></dd>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></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="postDelegationToken-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.DelegationToken-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>postDelegationToken</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;postDelegationToken(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.DelegationToken&nbsp;tokenData,
                                                     javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                              throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                     <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>,
                                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a>,
                                                     <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</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>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></code></dd>
</dl>
</li>
</ul>
<a name="postDelegationTokenExpiration-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>postDelegationTokenExpiration</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;postDelegationTokenExpiration(javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                                        throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                               <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>,
                                                               <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a>,
                                                               <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</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>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></code></dd>
</dl>
</li>
</ul>
<a name="cancelDelegationToken-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cancelDelegationToken</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;cancelDelegationToken(javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                                throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                       <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>,
                                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a>,
                                                       <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</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>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></code></dd>
</dl>
</li>
</ul>
<a name="createNewReservation-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>createNewReservation</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;createNewReservation(javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                               throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                      <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>,
                                                      <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</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>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></code></dd>
</dl>
</li>
</ul>
<a name="submitReservation-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationSubmissionRequestInfo-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>submitReservation</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;submitReservation(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationSubmissionRequestInfo&nbsp;resContext,
                                                   javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                            throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                   <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>,
                                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</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>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></code></dd>
</dl>
</li>
</ul>
<a name="updateReservation-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationUpdateRequestInfo-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateReservation</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;updateReservation(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationUpdateRequestInfo&nbsp;resContext,
                                                   javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                            throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                   <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>,
                                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</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>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></code></dd>
</dl>
</li>
</ul>
<a name="deleteReservation-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationDeleteRequestInfo-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>deleteReservation</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;deleteReservation(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.ReservationDeleteRequestInfo&nbsp;resContext,
                                                   javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                            throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                   <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>,
                                                   <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</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>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></code></dd>
</dl>
</li>
</ul>
<a name="listReservation-java.lang.String-java.lang.String-long-long-boolean-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>listReservation</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;listReservation(<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,
                                                 <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;reservationId,
                                                 long&nbsp;startTime,
                                                 long&nbsp;endTime,
                                                 boolean&nbsp;includeResourceAllocations,
                                                 javax.servlet.http.HttpServletRequest&nbsp;hsr)
                                          throws <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Exception.html?is-external=true" title="class or interface in java.lang">Exception</a></code></dd>
</dl>
</li>
</ul>
<a name="getAppTimeout-javax.servlet.http.HttpServletRequest-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppTimeout</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppTimeoutInfo&nbsp;getAppTimeout(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                             <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;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;type)
                                                                                      throws org.apache.hadoop.security.authorize.AuthorizationException</pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</code></dd>
</dl>
</li>
</ul>
<a name="getAppTimeouts-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppTimeouts</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppTimeoutsInfo&nbsp;getAppTimeouts(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                               <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;appId)
                                                                                        throws org.apache.hadoop.security.authorize.AuthorizationException</pre>
<dl>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code>org.apache.hadoop.security.authorize.AuthorizationException</code></dd>
</dl>
</li>
</ul>
<a name="updateApplicationTimeout-org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppTimeoutInfo-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>updateApplicationTimeout</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;updateApplicationTimeout(org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppTimeoutInfo&nbsp;appTimeout,
                                                          javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                          <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;appId)
                                                   throws org.apache.hadoop.security.authorize.AuthorizationException,
                                                          org.apache.hadoop.yarn.exceptions.YarnException,
                                                          <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a>,
                                                          <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.security.authorize.AuthorizationException</code></dd>
<dd><code>org.apache.hadoop.yarn.exceptions.YarnException</code></dd>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/InterruptedException.html?is-external=true" title="class or interface in java.lang">InterruptedException</a></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="getAppAttempts-javax.servlet.http.HttpServletRequest-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppAttempts</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.AppAttemptsInfo&nbsp;getAppAttempts(javax.servlet.http.HttpServletRequest&nbsp;hsr,
                                                                                               <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;appId)</pre>
</li>
</ul>
<a name="checkUserAccessToQueue-java.lang.String-java.lang.String-java.lang.String-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>checkUserAccessToQueue</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.resourcemanager.webapp.dao.RMQueueAclInfo&nbsp;checkUserAccessToQueue(<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,
                                                                                                      <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;username,
                                                                                                      <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;queueAclType,
                                                                                                      javax.servlet.http.HttpServletRequest&nbsp;hsr)</pre>
</li>
</ul>
<a name="getAppAttempt-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppAttempt</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.webapp.dao.AppAttemptInfo&nbsp;getAppAttempt(javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                             javax.servlet.http.HttpServletResponse&nbsp;res,
                                                                             <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;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;appAttemptId)</pre>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - the servlet request</dd>
<dd><code>res</code> - the servlet response</dd>
<dd><code>appId</code> - the application we want to get the appAttempt. It is a
          PathParam.</dd>
<dd><code>appAttemptId</code> - the AppAttempt we want to get the info. It is a
          PathParam.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>AppAttemptInfo of the specific AppAttempt</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>WebServices.getAppAttempt(HttpServletRequest, HttpServletResponse,
      String, String)</code></dd>
</dl>
</li>
</ul>
<a name="getContainers-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getContainers</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.webapp.dao.ContainersInfo&nbsp;getContainers(javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                             javax.servlet.http.HttpServletResponse&nbsp;res,
                                                                             <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;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;appAttemptId)</pre>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - the servlet request</dd>
<dd><code>res</code> - the servlet response</dd>
<dd><code>appId</code> - the application we want to get the containers info. It is a
          PathParam.</dd>
<dd><code>appAttemptId</code> - the AppAttempt we want to get the info. It is a
          PathParam.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>ContainersInfo of all the containers that belong to the specific
         AppAttempt</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>WebServices.getContainers(HttpServletRequest, HttpServletResponse,
      String, String)</code></dd>
</dl>
</li>
</ul>
<a name="getContainer-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getContainer</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.server.webapp.dao.ContainerInfo&nbsp;getContainer(javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                           javax.servlet.http.HttpServletResponse&nbsp;res,
                                                                           <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;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;appAttemptId,
                                                                           <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;containerId)</pre>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - the servlet request</dd>
<dd><code>res</code> - the servlet response</dd>
<dd><code>appId</code> - the application we want to get the containers info. It is a
          PathParam.</dd>
<dd><code>appAttemptId</code> - the AppAttempt we want to get the info. It is a
          PathParam.</dd>
<dd><code>containerId</code> - the container we want to get the info. It is a
          PathParam.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>ContainerInfo of the specific ContainerId</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><code>WebServices.getContainer(HttpServletRequest, HttpServletResponse,
      String, String, String)</code></dd>
</dl>
</li>
</ul>
<a name="setNextInterceptor-org.apache.hadoop.yarn.server.router.webapp.RESTRequestInterceptor-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>setNextInterceptor</h4>
<pre>public&nbsp;void&nbsp;setNextInterceptor(<a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp">RESTRequestInterceptor</a>&nbsp;next)</pre>
<div class="block"><span class="descfrmTypeLabel">Description copied from class:&nbsp;<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html#setNextInterceptor-org.apache.hadoop.yarn.server.router.webapp.RESTRequestInterceptor-">AbstractRESTRequestInterceptor</a></code></span></div>
<div class="block">Sets the <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp"><code>RESTRequestInterceptor</code></a> in the chain.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html#setNextInterceptor-org.apache.hadoop.yarn.server.router.webapp.RESTRequestInterceptor-">setNextInterceptor</a></code>&nbsp;in interface&nbsp;<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp">RESTRequestInterceptor</a></code></dd>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html#setNextInterceptor-org.apache.hadoop.yarn.server.router.webapp.RESTRequestInterceptor-">setNextInterceptor</a></code>&nbsp;in class&nbsp;<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html" title="class in org.apache.hadoop.yarn.server.router.webapp">AbstractRESTRequestInterceptor</a></code></dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>next</code> - the RESTRequestInterceptor to set in the pipeline</dd>
</dl>
</li>
</ul>
<a name="signalToContainer-java.lang.String-java.lang.String-javax.servlet.http.HttpServletRequest-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>signalToContainer</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;signalToContainer(<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;containerId,
                                                   <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;command,
                                                   javax.servlet.http.HttpServletRequest&nbsp;req)</pre>
</li>
</ul>
<a name="shutdown--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>shutdown</h4>
<pre>public&nbsp;void&nbsp;shutdown()</pre>
<div class="block"><span class="descfrmTypeLabel">Description copied from class:&nbsp;<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html#shutdown--">AbstractRESTRequestInterceptor</a></code></span></div>
<div class="block">Disposes the <a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp"><code>RESTRequestInterceptor</code></a>.</div>
<dl>
<dt><span class="overrideSpecifyLabel">Specified by:</span></dt>
<dd><code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html#shutdown--">shutdown</a></code>&nbsp;in interface&nbsp;<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/RESTRequestInterceptor.html" title="interface in org.apache.hadoop.yarn.server.router.webapp">RESTRequestInterceptor</a></code></dd>
<dt><span class="overrideSpecifyLabel">Overrides:</span></dt>
<dd><code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html#shutdown--">shutdown</a></code>&nbsp;in class&nbsp;<code><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/AbstractRESTRequestInterceptor.html" title="class in org.apache.hadoop.yarn.server.router.webapp">AbstractRESTRequestInterceptor</a></code></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/FederationInterceptorREST.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/server/router/webapp/DefaultRequestInterceptorREST.html" title="class in org.apache.hadoop.yarn.server.router.webapp"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../../../../org/apache/hadoop/yarn/server/router/webapp/HTTPMethods.html" title="enum in org.apache.hadoop.yarn.server.router.webapp"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/apache/hadoop/yarn/server/router/webapp/FederationInterceptorREST.html" target="_top">Frames</a></li>
<li><a href="FederationInterceptorREST.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>
