<!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:11:52 GMT 2021 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>TimelineReaderWebServices (Apache Hadoop YARN Timeline Service 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="TimelineReaderWebServices (Apache Hadoop YARN Timeline Service 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};
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/TimelineReaderWebServices.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/timelineservice/reader/TimelineReaderUtils.html" title="class in org.apache.hadoop.yarn.server.timelineservice.reader"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServicesUtils.html" title="class in org.apache.hadoop.yarn.server.timelineservice.reader"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html" target="_top">Frames</a></li>
<li><a href="TimelineReaderWebServices.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.timelineservice.reader</div>
<h2 title="Class TimelineReaderWebServices" class="title">Class TimelineReaderWebServices</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.apache.hadoop.yarn.server.timelineservice.reader.TimelineReaderWebServices</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>@InterfaceAudience.Private
 @InterfaceStability.Unstable
public class <span class="typeNameLabel">TimelineReaderWebServices</span>
extends <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></pre>
<div class="block">REST end point for Timeline Reader.</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/timelineservice/reader/TimelineReaderWebServices.html#TimelineReaderWebServices--">TimelineReaderWebServices</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>org.apache.hadoop.yarn.api.records.timeline.TimelineAbout</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#about-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-">about</a></span>(javax.servlet.http.HttpServletRequest&nbsp;req,
     javax.servlet.http.HttpServletResponse&nbsp;res)</code>
<div class="block">Return the description of the timeline reader web services.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getApp-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getApp</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;uId,
      <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;confsToRetrieve,
      <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;metricsToRetrieve,
      <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;fields,
      <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;metricsLimit,
      <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;metricsTimeStart,
      <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;metricsTimeEnd)</code>
<div class="block">Return a single app for given UID which is a delimited string containing
 clusterid, userid, flow name, flowrun id and app id.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getApp-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-">getApp</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;flowName,
      <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;flowRunId,
      <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;userId,
      <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;confsToRetrieve,
      <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;metricsToRetrieve,
      <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;fields,
      <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;metricsLimit,
      <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;metricsTimeStart,
      <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;metricsTimeEnd)</code>
<div class="block">Return a single app for given app id.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getApp-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-">getApp</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;clusterId,
      <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;flowName,
      <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;flowRunId,
      <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;userId,
      <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;confsToRetrieve,
      <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;metricsToRetrieve,
      <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;fields,
      <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;metricsLimit,
      <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;metricsTimeStart,
      <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;metricsTimeEnd)</code>
<div class="block">Return a single app for given cluster id and app id.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getAppAttempt-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-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,
             <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;userId,
             <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;flowName,
             <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;flowRunId,
             <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;confsToRetrieve,
             <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;metricsToRetrieve,
             <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;fields,
             <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;metricsLimit,
             <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;metricsTimeStart,
             <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;metricsTimeEnd,
             <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;entityIdPrefix)</code>
<div class="block">Return a single application-attempt entity for the given attempt Id.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getAppAttempt-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-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;clusterId,
             <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;userId,
             <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;flowName,
             <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;flowRunId,
             <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;confsToRetrieve,
             <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;metricsToRetrieve,
             <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;fields,
             <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;metricsLimit,
             <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;metricsTimeStart,
             <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;metricsTimeEnd,
             <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;entityIdPrefix)</code>
<div class="block">Return a single application attempt entity of the given entity Id.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getAppAttempts-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-">getAppAttempts</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;userId,
              <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;flowName,
              <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;flowRunId,
              <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
              <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;createdTimeEnd,
              <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;relatesTo,
              <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;isRelatedTo,
              <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;infofilters,
              <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;conffilters,
              <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;metricfilters,
              <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;eventfilters,
              <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;confsToRetrieve,
              <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;metricsToRetrieve,
              <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;fields,
              <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;metricsLimit,
              <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;metricsTimeStart,
              <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;metricsTimeEnd,
              <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;fromId)</code>
<div class="block">Return a set of application-attempt entities for a given applicationId.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getAppAttempts-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-java.lang.String-">getAppAttempts</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;clusterId,
              <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;userId,
              <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;flowName,
              <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;flowRunId,
              <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
              <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;createdTimeEnd,
              <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;relatesTo,
              <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;isRelatedTo,
              <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;infofilters,
              <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;conffilters,
              <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;metricfilters,
              <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;eventfilters,
              <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;confsToRetrieve,
              <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;metricsToRetrieve,
              <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;fields,
              <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;metricsLimit,
              <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;metricsTimeStart,
              <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;metricsTimeEnd,
              <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;fromId)</code>
<div class="block">Return a set of application-attempt entities for a given applicationId.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getContainer-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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;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;userId,
            <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;flowName,
            <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;flowRunId,
            <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;confsToRetrieve,
            <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;metricsToRetrieve,
            <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;fields,
            <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;metricsLimit,
            <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;metricsTimeStart,
            <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;metricsTimeEnd,
            <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;entityIdPrefix)</code>
<div class="block">Return a single container entity for the given container Id.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getContainer-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-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;clusterId,
            <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;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;userId,
            <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;flowName,
            <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;flowRunId,
            <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;confsToRetrieve,
            <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;metricsToRetrieve,
            <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;fields,
            <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;metricsLimit,
            <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;metricsTimeStart,
            <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;metricsTimeEnd,
            <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;entityIdPrefix)</code>
<div class="block">Return a single container entity for the given container Id.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getContainers-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-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,
             <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;userId,
             <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;flowName,
             <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;flowRunId,
             <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
             <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;createdTimeEnd,
             <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;relatesTo,
             <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;isRelatedTo,
             <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;infofilters,
             <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;conffilters,
             <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;metricfilters,
             <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;eventfilters,
             <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;confsToRetrieve,
             <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;metricsToRetrieve,
             <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;fields,
             <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;metricsLimit,
             <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;metricsTimeStart,
             <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;metricsTimeEnd,
             <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;fromId)</code>
<div class="block">Return a set of container entities belonging to given application attempt
 id.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getContainers-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-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;clusterId,
             <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;userId,
             <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;flowName,
             <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;flowRunId,
             <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
             <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;createdTimeEnd,
             <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;relatesTo,
             <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;isRelatedTo,
             <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;infofilters,
             <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;conffilters,
             <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;metricfilters,
             <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;eventfilters,
             <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;confsToRetrieve,
             <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;metricsToRetrieve,
             <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;fields,
             <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;metricsLimit,
             <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;metricsTimeStart,
             <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;metricsTimeEnd,
             <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;fromId)</code>
<div class="block">Return a set of container entities belonging to given application attempt
 id.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-">getEntities</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;uId,
           <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;entityType,
           <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
           <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;createdTimeEnd,
           <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;relatesTo,
           <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;isRelatedTo,
           <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;infofilters,
           <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;conffilters,
           <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;metricfilters,
           <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;eventfilters,
           <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;confsToRetrieve,
           <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;metricsToRetrieve,
           <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;fields,
           <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;metricsLimit,
           <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;metricsTimeStart,
           <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;metricsTimeEnd,
           <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;fromId)</code>
<div class="block">Return a single entity for a given entity type and UID which is a delimited
 string containing clusterid, userid, flow name, flowrun id and app id.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-java.lang.String-">getEntities</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;entityType,
           <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;userId,
           <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;flowName,
           <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;flowRunId,
           <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
           <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;createdTimeEnd,
           <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;relatesTo,
           <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;isRelatedTo,
           <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;infofilters,
           <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;conffilters,
           <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;metricfilters,
           <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;eventfilters,
           <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;confsToRetrieve,
           <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;metricsToRetrieve,
           <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;fields,
           <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;metricsLimit,
           <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;metricsTimeStart,
           <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;metricsTimeEnd,
           <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;fromId)</code>
<div class="block">Return a set of entities that match the given parameters.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getEntities</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;clusterId,
           <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;entityType,
           <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;userId,
           <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;flowName,
           <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;flowRunId,
           <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
           <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;createdTimeEnd,
           <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;relatesTo,
           <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;isRelatedTo,
           <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;infofilters,
           <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;conffilters,
           <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;metricfilters,
           <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;eventfilters,
           <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;confsToRetrieve,
           <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;metricsToRetrieve,
           <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;fields,
           <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;metricsLimit,
           <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;metricsTimeStart,
           <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;metricsTimeEnd,
           <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;fromId)</code>
<div class="block">Return a set of entities that match the given parameters.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getEntity-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getEntity</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;uId,
         <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;confsToRetrieve,
         <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;metricsToRetrieve,
         <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;fields,
         <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;metricsLimit,
         <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;metricsTimeStart,
         <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;metricsTimeEnd)</code>
<div class="block">Return a single entity for given UID which is a delimited string containing
 clusterid, userid, flow name, flowrun id, app id, entity type and entityid.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getEntity-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getEntity</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;entityType,
         <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;entityId,
         <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;userId,
         <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;flowName,
         <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;flowRunId,
         <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;confsToRetrieve,
         <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;metricsToRetrieve,
         <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;fields,
         <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;metricsLimit,
         <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;metricsTimeStart,
         <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;metricsTimeEnd,
         <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;entityIdPrefix)</code>
<div class="block">Return a single entity of the given entity type and Id.</div>
</td>
</tr>
<tr id="i17" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getEntity-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getEntity</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;clusterId,
         <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;entityType,
         <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;entityId,
         <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;userId,
         <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;flowName,
         <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;flowRunId,
         <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;confsToRetrieve,
         <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;metricsToRetrieve,
         <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;fields,
         <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;metricsLimit,
         <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;metricsTimeStart,
         <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;metricsTimeEnd,
         <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;entityIdPrefix)</code>
<div class="block">Return a single entity of the given entity type and Id.</div>
</td>
</tr>
<tr id="i18" class="altColor">
<td class="colFirst"><code><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;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getEntityTypes-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getEntityTypes</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;flowName,
              <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;flowRunId,
              <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;userId)</code>
<div class="block">Returns a set of available entity types for a given app id.</div>
</td>
</tr>
<tr id="i19" class="rowColor">
<td class="colFirst"><code><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;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getEntityTypes-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getEntityTypes</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;clusterId,
              <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;flowName,
              <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;flowRunId,
              <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;userId)</code>
<div class="block">Returns a set of available entity types for a given app id.</div>
</td>
</tr>
<tr id="i20" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-">getFlowApps</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;userId,
           <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;flowName,
           <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
           <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;createdTimeEnd,
           <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;relatesTo,
           <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;isRelatedTo,
           <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;infofilters,
           <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;conffilters,
           <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;metricfilters,
           <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;eventfilters,
           <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;confsToRetrieve,
           <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;metricsToRetrieve,
           <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;fields,
           <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;metricsLimit,
           <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;metricsTimeStart,
           <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;metricsTimeEnd,
           <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;fromId)</code>
<div class="block">Return a list of apps for given user and flow name.</div>
</td>
</tr>
<tr id="i21" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-">getFlowApps</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;clusterId,
           <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;userId,
           <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;flowName,
           <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
           <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;createdTimeEnd,
           <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;relatesTo,
           <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;isRelatedTo,
           <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;infofilters,
           <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;conffilters,
           <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;metricfilters,
           <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;eventfilters,
           <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;confsToRetrieve,
           <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;metricsToRetrieve,
           <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;fields,
           <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;metricsLimit,
           <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;metricsTimeStart,
           <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;metricsTimeEnd,
           <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;fromId)</code>
<div class="block">Return a list of apps for a given user, cluster id and flow name.</div>
</td>
</tr>
<tr id="i22" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowRun-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-">getFlowRun</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;uId,
          <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;metricsToRetrieve)</code>
<div class="block">Return a single flow run for given UID which is a delimited string
 containing clusterid, userid, flow name and flowrun id.</div>
</td>
</tr>
<tr id="i23" class="rowColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowRun-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getFlowRun</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;userId,
          <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;flowName,
          <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;flowRunId,
          <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;metricsToRetrieve)</code>
<div class="block">Return a single flow run for the given user, flow name and run id.</div>
</td>
</tr>
<tr id="i24" class="altColor">
<td class="colFirst"><code>org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowRun-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getFlowRun</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;clusterId,
          <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;userId,
          <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;flowName,
          <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;flowRunId,
          <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;metricsToRetrieve)</code>
<div class="block">Return a single flow run for the given user, cluster, flow name and run id.</div>
</td>
</tr>
<tr id="i25" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowRunApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getFlowRunApps</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;uId,
              <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
              <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;createdTimeEnd,
              <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;relatesTo,
              <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;isRelatedTo,
              <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;infofilters,
              <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;conffilters,
              <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;metricfilters,
              <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;eventfilters,
              <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;confsToRetrieve,
              <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;metricsToRetrieve,
              <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;fields,
              <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;metricsLimit,
              <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;metricsTimeStart,
              <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;metricsTimeEnd,
              <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;fromId)</code>
<div class="block">Return a list of apps for given UID which is a delimited string containing
 clusterid, userid, flow name and flowrun id.</div>
</td>
</tr>
<tr id="i26" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowRunApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-">getFlowRunApps</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;userId,
              <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;flowName,
              <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;flowRunId,
              <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
              <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;createdTimeEnd,
              <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;relatesTo,
              <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;isRelatedTo,
              <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;infofilters,
              <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;conffilters,
              <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;metricfilters,
              <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;eventfilters,
              <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;confsToRetrieve,
              <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;metricsToRetrieve,
              <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;fields,
              <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;metricsLimit,
              <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;metricsTimeStart,
              <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;metricsTimeEnd,
              <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;fromId)</code>
<div class="block">Return a list of apps for given user, flow name and flow run id.</div>
</td>
</tr>
<tr id="i27" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowRunApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-">getFlowRunApps</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;clusterId,
              <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;userId,
              <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;flowName,
              <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;flowRunId,
              <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
              <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;createdTimeEnd,
              <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;relatesTo,
              <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;isRelatedTo,
              <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;infofilters,
              <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;conffilters,
              <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;metricfilters,
              <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;eventfilters,
              <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;confsToRetrieve,
              <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;metricsToRetrieve,
              <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;fields,
              <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;metricsLimit,
              <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;metricsTimeStart,
              <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;metricsTimeEnd,
              <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;fromId)</code>
<div class="block">Return a list of apps for a given user, cluster id, flow name and flow run
 id.</div>
</td>
</tr>
<tr id="i28" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowRuns-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getFlowRuns</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;uId,
           <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
           <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;createdTimeEnd,
           <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;metricsToRetrieve,
           <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;fields,
           <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;fromId)</code>
<div class="block">Return a list of flow runs for given UID which is a delimited string
 containing clusterid, userid and flow name.</div>
</td>
</tr>
<tr id="i29" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowRuns-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getFlowRuns</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;userId,
           <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;flowName,
           <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
           <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;createdTimeEnd,
           <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;metricsToRetrieve,
           <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;fields,
           <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;fromId)</code>
<div class="block">Return a set of flows runs for the given user and flow name.</div>
</td>
</tr>
<tr id="i30" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlowRuns-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-">getFlowRuns</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;clusterId,
           <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;userId,
           <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;flowName,
           <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
           <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;createdTimeEnd,
           <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;metricsToRetrieve,
           <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;fields,
           <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;fromId)</code>
<div class="block">Return a set of flows runs for the given cluster, user and flow name.</div>
</td>
</tr>
<tr id="i31" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlows-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-">getFlows</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;limit,
        <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;dateRange,
        <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;fromId)</code>
<div class="block">Return a list of active flows.</div>
</td>
</tr>
<tr id="i32" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getFlows-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">getFlows</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;clusterId,
        <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;dateRange,
        <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;fromId)</code>
<div class="block">Return a list of active flows for a given cluster id.</div>
</td>
</tr>
<tr id="i33" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getSubAppEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-">getSubAppEntities</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;userId,
                 <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;entityType,
                 <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;entityId,
                 <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;confsToRetrieve,
                 <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;metricsToRetrieve,
                 <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;fields,
                 <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;metricsLimit,
                 <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;metricsTimeStart,
                 <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;metricsTimeEnd,
                 <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;entityIdPrefix)</code>&nbsp;</td>
</tr>
<tr id="i34" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getSubAppEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-">getSubAppEntities</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;clusterId,
                 <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;userId,
                 <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;entityType,
                 <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;entityId,
                 <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;confsToRetrieve,
                 <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;metricsToRetrieve,
                 <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;fields,
                 <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;metricsLimit,
                 <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;metricsTimeStart,
                 <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;metricsTimeEnd,
                 <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;entityIdPrefix)</code>&nbsp;</td>
</tr>
<tr id="i35" class="rowColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getSubAppEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-">getSubAppEntities</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;userId,
                 <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;entityType,
                 <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                 <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;createdTimeEnd,
                 <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;relatesTo,
                 <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;isRelatedTo,
                 <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;infofilters,
                 <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;conffilters,
                 <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;metricfilters,
                 <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;eventfilters,
                 <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;confsToRetrieve,
                 <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;metricsToRetrieve,
                 <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;fields,
                 <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;metricsLimit,
                 <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;metricsTimeStart,
                 <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;metricsTimeEnd,
                 <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;fromId)</code>&nbsp;</td>
</tr>
<tr id="i36" class="altColor">
<td class="colFirst"><code><a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;</code></td>
<td class="colLast"><code><span class="memberNameLink"><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html#getSubAppEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-">getSubAppEntities</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;clusterId,
                 <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;userId,
                 <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;entityType,
                 <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                 <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;createdTimeEnd,
                 <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;relatesTo,
                 <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;isRelatedTo,
                 <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;infofilters,
                 <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;conffilters,
                 <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;metricfilters,
                 <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;eventfilters,
                 <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;confsToRetrieve,
                 <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;metricsToRetrieve,
                 <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;fields,
                 <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;metricsLimit,
                 <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;metricsTimeStart,
                 <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;metricsTimeEnd,
                 <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;fromId)</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/timelineservice/reader/TimelineReaderWebServices.html#health-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-">health</a></span>(javax.servlet.http.HttpServletRequest&nbsp;req,
      javax.servlet.http.HttpServletResponse&nbsp;res)</code>
<div class="block">Health check REST end point.</div>
</td>
</tr>
</table>
<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="TimelineReaderWebServices--">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>TimelineReaderWebServices</h4>
<pre>public&nbsp;TimelineReaderWebServices()</pre>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="about-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>about</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timeline.TimelineAbout&nbsp;about(@Context
                                                                       javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                       @Context
                                                                       javax.servlet.http.HttpServletResponse&nbsp;res)</pre>
<div class="block">Return the description of the timeline reader web services.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>information about the cluster including timeline version.</dd>
</dl>
</li>
</ul>
<a name="health-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>health</h4>
<pre>public&nbsp;javax.ws.rs.core.Response&nbsp;health(@Context
                                        javax.servlet.http.HttpServletRequest&nbsp;req,
                                        @Context
                                        javax.servlet.http.HttpServletResponse&nbsp;res)</pre>
<div class="block">Health check REST end point.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>A <code>Response</code> object with HTTP status 200 OK if the service
         is running.
         Otherwise, a <code>Response</code> object with HTTP status 500 is
         returned.</dd>
</dl>
</li>
</ul>
<a name="getEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getEntities</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getEntities(@Context
                                                                                          javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                          @Context
                                                                                          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;uId,
                                                                                          <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;entityType,
                                                                                          <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                          <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;createdTimeEnd,
                                                                                          <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;relatesTo,
                                                                                          <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;isRelatedTo,
                                                                                          <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;infofilters,
                                                                                          <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;conffilters,
                                                                                          <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;metricfilters,
                                                                                          <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;eventfilters,
                                                                                          <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;confsToRetrieve,
                                                                                          <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;metricsToRetrieve,
                                                                                          <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;fields,
                                                                                          <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;metricsLimit,
                                                                                          <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;metricsTimeStart,
                                                                                          <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;metricsTimeEnd,
                                                                                          <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;fromId)</pre>
<div class="block">Return a single entity for a given entity type and UID which is a delimited
 string containing clusterid, userid, flow name, flowrun id and app id.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>uId</code> - a delimited string containing clusterid, userid, flow name,
     flowrun id and app id which are extracted from UID and then used to
     query backend(Mandatory path param).</dd>
<dd><code>entityType</code> - Type of entities(Mandatory path param).</dd>
<dd><code>limit</code> - If specified, defines the number of entities to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched entities should not be
     created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched entities should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched entities should relate to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched entities should be related to
     given entities associated with a entity type. relatesto is a comma
     separated list in the format [entitytype]:[entityid1]:[entityid2]...
     (Optional query param).</dd>
<dd><code>infofilters</code> - If specified, matched entities should have exact matches
     to the given info represented as key-value pairs. This is represented
     as infofilters=info1:value1,info2:value2... (Optional query param).</dd>
<dd><code>conffilters</code> - If specified, matched entities should have exact matches
     to the given configs represented as key-value pairs. This is
     represented as conffilters=conf1:value1,conf2:value2... (Optional query
     param).</dd>
<dd><code>metricfilters</code> - If specified, matched entities should contain the
     given metrics. This is represented as
     metricfilters=metricid1, metricid2... (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched entities should contain the given
     events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
     <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type, id and created time is returned
     (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the entities
     would not contain metric values before this timestamp(Optional query
     param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the entities would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of entities from the
     given fromId. The set of entities retrieved is inclusive of specified
     fromId. fromId should be taken from the value associated with FROM_ID
     info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing
     a set of <cite>TimelineEntity</cite> instances of the given entity type
     is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request or UID is incorrect,
     HTTP 400(Bad Request) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getEntities</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getEntities(@Context
                                                                                          javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                          @Context
                                                                                          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;entityType,
                                                                                          <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;userId,
                                                                                          <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;flowName,
                                                                                          <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;flowRunId,
                                                                                          <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                          <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;createdTimeEnd,
                                                                                          <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;relatesTo,
                                                                                          <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;isRelatedTo,
                                                                                          <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;infofilters,
                                                                                          <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;conffilters,
                                                                                          <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;metricfilters,
                                                                                          <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;eventfilters,
                                                                                          <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;confsToRetrieve,
                                                                                          <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;metricsToRetrieve,
                                                                                          <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;fields,
                                                                                          <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;metricsLimit,
                                                                                          <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;metricsTimeStart,
                                                                                          <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;metricsTimeEnd,
                                                                                          <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;fromId)</pre>
<div class="block">Return a set of entities that match the given parameters. Cluster ID is not
 provided by client so default cluster ID has to be taken. If userid, flow
 name and flowrun id which are optional query parameters are not specified,
 they will be queried based on app id and default cluster id from the flow
 context information stored in underlying storage implementation. If number
 of matching entities are more than the limit, most recent entities till the
 limit is reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>appId</code> - Application id to which the entities to be queried belong to(
     Mandatory path param).</dd>
<dd><code>entityType</code> - Type of entities(Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entities(Optional query
     param)</dd>
<dd><code>flowName</code> - Flow name which should match for the entities(Optional
     query param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entities(Optional query
     param).</dd>
<dd><code>limit</code> - If specified, defines the number of entities to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched entities should not be
     created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched entities should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched entities should relate to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched entities should be related to
     given entities associated with a entity type. relatesto is a comma
     separated list in the format [entitytype]:[entityid1]:[entityid2]...
     (Optional query param).</dd>
<dd><code>infofilters</code> - If specified, matched entities should have exact matches
     to the given info represented as key-value pairs. This is represented
     as infofilters=info1:value1,info2:value2... (Optional query param).</dd>
<dd><code>conffilters</code> - If specified, matched entities should have exact matches
     to the given configs represented as key-value pairs. This is
     represented as conffilters=conf1:value1,conf2:value2... (Optional query
     param).</dd>
<dd><code>metricfilters</code> - If specified, matched entities should contain the
     given metrics. This is represented as
     metricfilters=metricid1, metricid2... (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched entities should contain the given
     events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
     <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type, id, created time is returned
     (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the entities
     would not contain metric values before this timestamp(Optional query
     param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the entities would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of entities from the
     given fromId. The set of entities retrieved is inclusive of specified
     fromId. fromId should be taken from the value associated with FROM_ID
     info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing
     a set of <cite>TimelineEntity</cite> instances of the given entity type
     is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow context information cannot be retrieved, HTTP 404(Not Found)
     is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getEntities</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getEntities(@Context
                                                                                          javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                          @Context
                                                                                          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;clusterId,
                                                                                          <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;entityType,
                                                                                          <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;userId,
                                                                                          <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;flowName,
                                                                                          <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;flowRunId,
                                                                                          <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                          <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;createdTimeEnd,
                                                                                          <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;relatesTo,
                                                                                          <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;isRelatedTo,
                                                                                          <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;infofilters,
                                                                                          <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;conffilters,
                                                                                          <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;metricfilters,
                                                                                          <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;eventfilters,
                                                                                          <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;confsToRetrieve,
                                                                                          <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;metricsToRetrieve,
                                                                                          <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;fields,
                                                                                          <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;metricsLimit,
                                                                                          <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;metricsTimeStart,
                                                                                          <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;metricsTimeEnd,
                                                                                          <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;fromId)</pre>
<div class="block">Return a set of entities that match the given parameters. If userid, flow
 name and flowrun id which are optional query parameters are not specified,
 they will be queried based on app id and cluster id from the flow context
 information stored in underlying storage implementation. If number of
 matching entities are more than the limit, most recent entities till the
 limit is reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the entities to be queried belong to(
     Mandatory path param).</dd>
<dd><code>appId</code> - Application id to which the entities to be queried belong to(
     Mandatory path param).</dd>
<dd><code>entityType</code> - Type of entities(Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entities(Optional query
     param)</dd>
<dd><code>flowName</code> - Flow name which should match for the entities(Optional
     query param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entities(Optional query
     param).</dd>
<dd><code>limit</code> - If specified, defines the number of entities to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched entities should not be
     created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched entities should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched entities should relate to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched entities should be related to
     given entities associated with a entity type. relatesto is a comma
     separated list in the format [entitytype]:[entityid1]:[entityid2]...
     (Optional query param).</dd>
<dd><code>infofilters</code> - If specified, matched entities should have exact matches
     to the given info represented as key-value pairs. This is represented
     as infofilters=info1:value1,info2:value2... (Optional query param).</dd>
<dd><code>conffilters</code> - If specified, matched entities should have exact matches
     to the given configs represented as key-value pairs. This is
     represented as conffilters=conf1:value1,conf2:value2... (Optional query
     param).</dd>
<dd><code>metricfilters</code> - If specified, matched entities should contain the
     given metrics. This is represented as
     metricfilters=metricid1, metricid2... (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched entities should contain the given
     events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
     <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type, id, created time is returned
     (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the entities
     would not contain metric values before this timestamp(Optional query
     param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the entities would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of entities from the
     given fromId. The set of entities retrieved is inclusive of specified
     fromId. fromId should be taken from the value associated with FROM_ID
     info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing
     a set of <cite>TimelineEntity</cite> instances of the given entity type
     is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow context information cannot be retrieved, HTTP 404(Not Found)
     is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getEntity-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getEntity</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getEntity(@Context
                                                                                   javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                   @Context
                                                                                   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;uId,
                                                                                   <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;confsToRetrieve,
                                                                                   <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;metricsToRetrieve,
                                                                                   <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;fields,
                                                                                   <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;metricsLimit,
                                                                                   <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;metricsTimeStart,
                                                                                   <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;metricsTimeEnd)</pre>
<div class="block">Return a single entity for given UID which is a delimited string containing
 clusterid, userid, flow name, flowrun id, app id, entity type and entityid.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>uId</code> - a delimited string containing clusterid, userid, flow name,
     flowrun id, app id, entity type and entity id which are extracted from
     UID and then used to query backend(Mandatory path param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
     <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type, id, created time is returned
     (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the entity would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the entity would
     not contain metric values after this timestamp(Optional query param).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     <cite>TimelineEntity</cite> instance is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request or UID is incorrect,
     HTTP 400(Bad Request) is returned.<br>
     If entity for the given entity id cannot be found, HTTP 404(Not Found)
     is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getEntity-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getEntity</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getEntity(@Context
                                                                                   javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                   @Context
                                                                                   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;entityType,
                                                                                   <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;entityId,
                                                                                   <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;userId,
                                                                                   <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;flowName,
                                                                                   <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;flowRunId,
                                                                                   <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;confsToRetrieve,
                                                                                   <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;metricsToRetrieve,
                                                                                   <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;fields,
                                                                                   <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;metricsLimit,
                                                                                   <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;metricsTimeStart,
                                                                                   <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;metricsTimeEnd,
                                                                                   <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;entityIdPrefix)</pre>
<div class="block">Return a single entity of the given entity type and Id. Cluster ID is not
 provided by client so default cluster ID has to be taken. If userid, flow
 name and flowrun id which are optional query parameters are not specified,
 they will be queried based on app id and default cluster id from the flow
 context information stored in underlying storage implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>appId</code> - Application id to which the entity to be queried belongs to(
     Mandatory path param).</dd>
<dd><code>entityType</code> - Type of entity(Mandatory path param).</dd>
<dd><code>entityId</code> - Id of the entity to be fetched(Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entity(Optional query
     param).</dd>
<dd><code>flowName</code> - Flow name which should match for the entity(Optional query
     param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entity(Optional query
     param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
     <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type, id, created time is returned
     (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the entity would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the entity would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>entityIdPrefix</code> - Defines the id prefix for the entity to be fetched.
     If specified, then entity retrieval will be faster.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     <cite>TimelineEntity</cite> instance is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow context information cannot be retrieved or entity for the given
     entity id cannot be found, HTTP 404(Not Found) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getEntity-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getEntity</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getEntity(@Context
                                                                                   javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                   @Context
                                                                                   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;clusterId,
                                                                                   <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;entityType,
                                                                                   <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;entityId,
                                                                                   <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;userId,
                                                                                   <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;flowName,
                                                                                   <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;flowRunId,
                                                                                   <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;confsToRetrieve,
                                                                                   <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;metricsToRetrieve,
                                                                                   <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;fields,
                                                                                   <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;metricsLimit,
                                                                                   <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;metricsTimeStart,
                                                                                   <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;metricsTimeEnd,
                                                                                   <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;entityIdPrefix)</pre>
<div class="block">Return a single entity of the given entity type and Id. If userid, flowname
 and flowrun id which are optional query parameters are not specified, they
 will be queried based on app id and cluster id from the flow context
 information stored in underlying storage implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the entity to be queried belongs to(
     Mandatory path param).</dd>
<dd><code>appId</code> - Application id to which the entity to be queried belongs to(
     Mandatory path param).</dd>
<dd><code>entityType</code> - Type of entity(Mandatory path param).</dd>
<dd><code>entityId</code> - Id of the entity to be fetched(Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entity(Optional query
     param).</dd>
<dd><code>flowName</code> - Flow name which should match for the entity(Optional query
     param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entity(Optional query
     param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
     <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type, id and created time is returned
     (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the entity would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the entity would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>entityIdPrefix</code> - Defines the id prefix for the entity to be fetched.
     If specified, then entity retrieval will be faster.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     <cite>TimelineEntity</cite> instance is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow context information cannot be retrieved or entity for the given
     entity id cannot be found, HTTP 404(Not Found) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowRun-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowRun</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getFlowRun(@Context
                                                                                    javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                    @Context
                                                                                    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;uId,
                                                                                    <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;metricsToRetrieve)</pre>
<div class="block">Return a single flow run for given UID which is a delimited string
 containing clusterid, userid, flow name and flowrun id.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>uId</code> - a delimited string containing clusterid, userid, flow name and
     flowrun id which are extracted from UID and then used to query backend
     (Mandatory path param).</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     <cite>FlowRunEntity</cite> instance is returned. By default, all
     metrics for the flow run will be returned.<br>
     On failures,<br>
     If any problem occurs in parsing request or UID is incorrect,
     HTTP 400(Bad Request) is returned.<br>
     If flow run for the given flow run id cannot be found, HTTP 404
     (Not Found) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowRun-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowRun</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getFlowRun(@Context
                                                                                    javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                    @Context
                                                                                    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;userId,
                                                                                    <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;flowName,
                                                                                    <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;flowRunId,
                                                                                    <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;metricsToRetrieve)</pre>
<div class="block">Return a single flow run for the given user, flow name and run id.
 Cluster ID is not provided by client so default cluster ID has to be taken.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>userId</code> - User id representing the user who ran the flow run(Mandatory
     path param).</dd>
<dd><code>flowName</code> - Flow name to which the flow run to be queried belongs to(
     Mandatory path param).</dd>
<dd><code>flowRunId</code> - Id of the flow run to be queried(Mandatory path param).</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     <cite>FlowRunEntity</cite> instance is returned. By default, all
     metrics for the flow run will be returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow run for the given flow run id cannot be found, HTTP 404
     (Not Found) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowRun-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowRun</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getFlowRun(@Context
                                                                                    javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                    @Context
                                                                                    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;clusterId,
                                                                                    <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;userId,
                                                                                    <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;flowName,
                                                                                    <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;flowRunId,
                                                                                    <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;metricsToRetrieve)</pre>
<div class="block">Return a single flow run for the given user, cluster, flow name and run id.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the flow run to be queried belong to(
     Mandatory path param).</dd>
<dd><code>userId</code> - User id representing the user who ran the flow run(Mandatory
     path param).</dd>
<dd><code>flowName</code> - Flow name to which the flow run to be queried belongs to(
     Mandatory path param).</dd>
<dd><code>flowRunId</code> - Id of the flow run to be queried(Mandatory path param).</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     <cite>FlowRunEntity</cite> instance is returned. By default, all
     metrics for the flow run will be returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow run for the given flow run id cannot be found, HTTP 404
     (Not Found) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowRuns-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowRuns</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlowRuns(@Context
                                                                                          javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                          @Context
                                                                                          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;uId,
                                                                                          <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                          <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;createdTimeEnd,
                                                                                          <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;metricsToRetrieve,
                                                                                          <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;fields,
                                                                                          <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;fromId)</pre>
<div class="block">Return a list of flow runs for given UID which is a delimited string
 containing clusterid, userid and flow name.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>uId</code> - a delimited string containing clusterid, userid, and flow name
     which are extracted from UID and then used to query backend(Mandatory
     path param).</dd>
<dd><code>limit</code> - If specified, defines the number of flow runs to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched flow runs should not be
     created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched flow runs should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields to retrieve, see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All
     fields will be retrieved if fields=ALL. Amongst all the fields, only
     METRICS makes sense for flow runs hence only ALL or METRICS are
     supported as fields for fetching flow runs. Other fields will lead to
     HTTP 400 (Bad Request) response. (Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of flow run entities
     from the given fromId. The set of entities retrieved is inclusive of
     specified fromId. fromId should be taken from the value associated
     with FROM_ID info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     set of <cite>FlowRunEntity</cite> instances for the given flow are
     returned.<br>
     On failures,<br>
     If any problem occurs in parsing request or UID is incorrect,
     HTTP 400(Bad Request) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowRuns-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowRuns</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlowRuns(@Context
                                                                                          javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                          @Context
                                                                                          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;userId,
                                                                                          <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;flowName,
                                                                                          <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                          <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;createdTimeEnd,
                                                                                          <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;metricsToRetrieve,
                                                                                          <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;fields,
                                                                                          <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;fromId)</pre>
<div class="block">Return a set of flows runs for the given user and flow name.
 Cluster ID is not provided by client so default cluster ID has to be taken.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>userId</code> - User id representing the user who ran the flow runs(
     Mandatory path param)</dd>
<dd><code>flowName</code> - Flow name to which the flow runs to be queried belongs to(
     Mandatory path param).</dd>
<dd><code>limit</code> - If specified, defines the number of flow runs to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched flow runs should not be
     created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched flow runs should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields to retrieve, see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All
     fields will be retrieved if fields=ALL. Amongst all the fields, only
     METRICS makes sense for flow runs hence only ALL or METRICS are
     supported as fields for fetching flow runs. Other fields will lead to
     HTTP 400 (Bad Request) response. (Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of flow run entities
     from the given fromId. The set of entities retrieved is inclusive of
     specified fromId. fromId should be taken from the value associated
     with FROM_ID info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     set of <cite>FlowRunEntity</cite> instances for the given flow are
     returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowRuns-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowRuns</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlowRuns(@Context
                                                                                          javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                          @Context
                                                                                          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;clusterId,
                                                                                          <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;userId,
                                                                                          <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;flowName,
                                                                                          <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                          <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;createdTimeEnd,
                                                                                          <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;metricsToRetrieve,
                                                                                          <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;fields,
                                                                                          <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;fromId)</pre>
<div class="block">Return a set of flows runs for the given cluster, user and flow name.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the flow runs to be queried belong to(
     Mandatory path param).</dd>
<dd><code>userId</code> - User id representing the user who ran the flow runs(
     Mandatory path param)</dd>
<dd><code>flowName</code> - Flow name to which the flow runs to be queried belongs to(
     Mandatory path param).</dd>
<dd><code>limit</code> - If specified, defines the number of flow runs to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched flow runs should not be
     created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched flow runs should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields to retrieve, see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All
     fields will be retrieved if fields=ALL. Amongst all the fields, only
     METRICS makes sense for flow runs hence only ALL or METRICS are
     supported as fields for fetching flow runs. Other fields will lead to
     HTTP 400 (Bad Request) response. (Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of flow run entities
     from the given fromId. The set of entities retrieved is inclusive of
     specified fromId. fromId should be taken from the value associated
     with FROM_ID info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     set of <cite>FlowRunEntity</cite> instances for the given flow are
     returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlows-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>getFlows</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlows(@Context
                                                                                       javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                       @Context
                                                                                       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;limit,
                                                                                       <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;dateRange,
                                                                                       <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;fromId)</pre>
<div class="block">Return a list of active flows. Cluster ID is not provided by client so
 default cluster ID has to be taken.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>limit</code> - If specified, defines the number of flows to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>dateRange</code> - If specified is given as "[startdate]-[enddate]"(i.e.
     start and end date separated by "-") or single date. Dates are
     interpreted in yyyyMMdd format and are assumed to be in GMT(Optional
     query param).
     If a single date is specified, all flows active on that date are
     returned. If both startdate and enddate is given, all flows active
     between start and end date will be returned. If only startdate is
     given, flows active on and after startdate are returned. If only
     enddate is given, flows active on and before enddate are returned.
     For example :
     "daterange=20150711" returns flows active on 20150711.
     "daterange=20150711-20150714" returns flows active between these
     2 dates.
     "daterange=20150711-" returns flows active on and after 20150711.
     "daterange=-20150711" returns flows active on and before 20150711.</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of flows from the given
     fromId. The set of flows retrieved is inclusive of specified fromId.
     fromId should be taken from the value associated with FROM_ID info key
     in flow entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     set of <cite>FlowActivityEntity</cite> instances are returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.<br></dd>
</dl>
</li>
</ul>
<a name="getFlows-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlows</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlows(@Context
                                                                                       javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                       @Context
                                                                                       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;clusterId,
                                                                                       <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;dateRange,
                                                                                       <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;fromId)</pre>
<div class="block">Return a list of active flows for a given cluster id.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the flows to be queried belong to(
     Mandatory path param).</dd>
<dd><code>limit</code> - If specified, defines the number of flows to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>dateRange</code> - If specified is given as "[startdate]-[enddate]"(i.e.
     start and end date separated by "-") or single date. Dates are
     interpreted in yyyyMMdd format and are assumed to be in GMT(Optional
     query param).
     If a single date is specified, all flows active on that date are
     returned. If both startdate and enddate is given, all flows active
     between start and end date will be returned. If only startdate is
     given, flows active on and after startdate are returned. If only
     enddate is given, flows active on and before enddate are returned.
     For example :
     "daterange=20150711" returns flows active on 20150711.
     "daterange=20150711-20150714" returns flows active between these
     2 dates.
     "daterange=20150711-" returns flows active on and after 20150711.
     "daterange=-20150711" returns flows active on and before 20150711.</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of flows from the given
     fromId. The set of flows retrieved is inclusive of specified fromId.
     fromId should be taken from the value associated with FROM_ID info key
     in flow entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     set of <cite>FlowActivityEntity</cite> instances are returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getApp-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApp</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getApp(@Context
                                                                                javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                @Context
                                                                                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;uId,
                                                                                <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;confsToRetrieve,
                                                                                <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;metricsToRetrieve,
                                                                                <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;fields,
                                                                                <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;metricsLimit,
                                                                                <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;metricsTimeStart,
                                                                                <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;metricsTimeEnd)</pre>
<div class="block">Return a single app for given UID which is a delimited string containing
 clusterid, userid, flow name, flowrun id and app id.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>uId</code> - a delimited string containing clusterid, userid, flow name, flow
     run id and app id which are extracted from UID and then used to query
     backend(Mandatory path param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the app entity object to retrieve,
     see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type(equivalent to YARN_APPLICATION),
     app id and app created time is returned(Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the apps would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the apps would
     not contain metric values after this timestamp(Optional query param).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     <cite>TimelineEntity</cite> instance is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request or UID is incorrect,
     HTTP 400(Bad Request) is returned.<br>
     If app for the given app id cannot be found, HTTP 404(Not Found) is
     returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getApp-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApp</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getApp(@Context
                                                                                javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                @Context
                                                                                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;flowName,
                                                                                <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;flowRunId,
                                                                                <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;userId,
                                                                                <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;confsToRetrieve,
                                                                                <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;metricsToRetrieve,
                                                                                <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;fields,
                                                                                <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;metricsLimit,
                                                                                <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;metricsTimeStart,
                                                                                <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;metricsTimeEnd)</pre>
<div class="block">Return a single app for given app id. Cluster ID is not provided by client
 client so default cluster ID has to be taken. If userid, flow name and flow
 run id which are optional query parameters are not specified, they will be
 queried based on app id and cluster id from the flow context information
 stored in underlying storage implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>appId</code> - Application id to be queried(Mandatory path param).</dd>
<dd><code>flowName</code> - Flow name which should match for the app(Optional query
     param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the app(Optional query
     param).</dd>
<dd><code>userId</code> - User id which should match for the app(Optional query param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the app entity object to retrieve,
     see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type(equivalent to YARN_APPLICATION),
     app id and app created time is returned(Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the app would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the app would
     not contain metric values after this timestamp(Optional query param).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     <cite>TimelineEntity</cite> instance is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow context information cannot be retrieved or app for the given
     app id cannot be found, HTTP 404(Not Found) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getApp-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getApp</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getApp(@Context
                                                                                javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                @Context
                                                                                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;clusterId,
                                                                                <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;flowName,
                                                                                <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;flowRunId,
                                                                                <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;userId,
                                                                                <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;confsToRetrieve,
                                                                                <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;metricsToRetrieve,
                                                                                <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;fields,
                                                                                <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;metricsLimit,
                                                                                <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;metricsTimeStart,
                                                                                <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;metricsTimeEnd)</pre>
<div class="block">Return a single app for given cluster id and app id. If userid, flow name
 and flowrun id which are optional query parameters are not specified, they
 will be queried based on app id and cluster id from the flow context
 information stored in underlying storage implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the app to be queried belong to(
     Mandatory path param).</dd>
<dd><code>appId</code> - Application id to be queried(Mandatory path param).</dd>
<dd><code>flowName</code> - Flow name which should match for the app(Optional query
     param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the app(Optional query
     param).</dd>
<dd><code>userId</code> - User id which should match for the app(Optional query param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the app entity object to retrieve,
     see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type(equivalent to YARN_APPLICATION),
     app id and app created time is returned(Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the app would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the app would
     not contain metric values after this timestamp(Optional query param).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     <cite>TimelineEntity</cite> instance is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow context information cannot be retrieved or app for the given
     app id cannot be found, HTTP 404(Not Found) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowRunApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowRunApps</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlowRunApps(@Context
                                                                                             javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                             @Context
                                                                                             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;uId,
                                                                                             <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                             <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;createdTimeEnd,
                                                                                             <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;relatesTo,
                                                                                             <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;isRelatedTo,
                                                                                             <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;infofilters,
                                                                                             <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;conffilters,
                                                                                             <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;metricfilters,
                                                                                             <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;eventfilters,
                                                                                             <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;confsToRetrieve,
                                                                                             <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;metricsToRetrieve,
                                                                                             <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;fields,
                                                                                             <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;metricsLimit,
                                                                                             <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;metricsTimeStart,
                                                                                             <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;metricsTimeEnd,
                                                                                             <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;fromId)</pre>
<div class="block">Return a list of apps for given UID which is a delimited string containing
 clusterid, userid, flow name and flowrun id. If number of matching apps are
 more than the limit, most recent apps till the limit is reached, will be
 returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>uId</code> - a delimited string containing clusterid, userid, flow name and
     flowrun id which are extracted from UID and then used to query backend.
     (Mandatory path param).</dd>
<dd><code>limit</code> - If specified, defines the number of apps to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched apps should not be created
     before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched apps should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched apps should relate to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched apps should be related to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>infofilters</code> - If specified, matched apps should have exact matches
     to the given info represented as key-value pairs. This is represented
     as infofilters=info1:value1,info2:value2... (Optional query param).</dd>
<dd><code>conffilters</code> - If specified, matched apps should have exact matches
     to the given configs represented as key-value pairs. This is
     represented as conffilters=conf1:value1,conf2:value2... (Optional query
     param).</dd>
<dd><code>metricfilters</code> - If specified, matched apps should contain the given
     metrics. This is represented as metricfilters=metricid1, metricid2...
     (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched apps should contain the given
     events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the app entity object to retrieve,
     see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type(equivalent to YARN_APPLICATION),
     app id and app created time is returned(Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the apps would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the apps would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of applications
     from the given fromId. The set of applications retrieved is inclusive
     of specified fromId. fromId should be taken from the value associated
     with FROM_ID info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing
     a set of <cite>TimelineEntity</cite> instances representing apps is
     returned.<br>
     On failures,<br>
     If any problem occurs in parsing request or UID is incorrect,
     HTTP 400(Bad Request) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowRunApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowRunApps</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlowRunApps(@Context
                                                                                             javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                             @Context
                                                                                             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;userId,
                                                                                             <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;flowName,
                                                                                             <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;flowRunId,
                                                                                             <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                             <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;createdTimeEnd,
                                                                                             <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;relatesTo,
                                                                                             <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;isRelatedTo,
                                                                                             <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;infofilters,
                                                                                             <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;conffilters,
                                                                                             <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;metricfilters,
                                                                                             <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;eventfilters,
                                                                                             <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;confsToRetrieve,
                                                                                             <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;metricsToRetrieve,
                                                                                             <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;fields,
                                                                                             <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;metricsLimit,
                                                                                             <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;metricsTimeStart,
                                                                                             <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;metricsTimeEnd,
                                                                                             <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;fromId)</pre>
<div class="block">Return a list of apps for given user, flow name and flow run id. Cluster ID
 is not provided by client so default cluster ID has to be taken. If number
 of matching apps are more than the limit, most recent apps till the limit
 is reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>userId</code> - User id which should match for the apps(Mandatory path param)</dd>
<dd><code>flowName</code> - Flow name which should match for the apps(Mandatory path
     param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the apps(Mandatory path
     param).</dd>
<dd><code>limit</code> - If specified, defines the number of apps to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched apps should not be created
     before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched apps should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched apps should relate to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched apps should be related to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>infofilters</code> - If specified, matched apps should have exact matches
     to the given info represented as key-value pairs. This is represented
     as infofilters=info1:value1,info2:value2... (Optional query param).</dd>
<dd><code>conffilters</code> - If specified, matched apps should have exact matches
     to the given configs represented as key-value pairs. This is
     represented as conffilters=conf1:value1,conf2:value2... (Optional query
     param).</dd>
<dd><code>metricfilters</code> - If specified, matched apps should contain the given
     metrics. This is represented as metricfilters=metricid1, metricid2...
     (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched apps should contain the given
     events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the app entity object to retrieve,
     see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type(equivalent to YARN_APPLICATION),
     app id and app created time is returned(Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the apps would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the apps would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of applications
     from the given fromId. The set of applications retrieved is inclusive
     of specified fromId. fromId should be taken from the value associated
     with FROM_ID info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing
     a set of <cite>TimelineEntity</cite> instances representing apps is
     returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowRunApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowRunApps</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlowRunApps(@Context
                                                                                             javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                             @Context
                                                                                             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;clusterId,
                                                                                             <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;userId,
                                                                                             <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;flowName,
                                                                                             <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;flowRunId,
                                                                                             <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                             <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;createdTimeEnd,
                                                                                             <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;relatesTo,
                                                                                             <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;isRelatedTo,
                                                                                             <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;infofilters,
                                                                                             <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;conffilters,
                                                                                             <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;metricfilters,
                                                                                             <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;eventfilters,
                                                                                             <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;confsToRetrieve,
                                                                                             <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;metricsToRetrieve,
                                                                                             <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;fields,
                                                                                             <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;metricsLimit,
                                                                                             <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;metricsTimeStart,
                                                                                             <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;metricsTimeEnd,
                                                                                             <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;fromId)</pre>
<div class="block">Return a list of apps for a given user, cluster id, flow name and flow run
 id. If number of matching apps are more than the limit, most recent apps
 till the limit is reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the apps to be queried belong to
     (Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the apps(Mandatory path param)</dd>
<dd><code>flowName</code> - Flow name which should match for the apps(Mandatory path
     param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the apps(Mandatory path
     param).</dd>
<dd><code>limit</code> - If specified, defines the number of apps to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched apps should not be created
     before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched apps should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched apps should relate to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched apps should be related to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>infofilters</code> - If specified, matched apps should have exact matches
     to the given info represented as key-value pairs. This is represented
     as infofilters=info1:value1,info2:value2... (Optional query param).</dd>
<dd><code>conffilters</code> - If specified, matched apps should have exact matches
     to the given configs represented as key-value pairs. This is
     represented as conffilters=conf1:value1,conf2:value2... (Optional query
     param).</dd>
<dd><code>metricfilters</code> - If specified, matched apps should contain the given
     metrics. This is represented as metricfilters=metricid1, metricid2...
     (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched apps should contain the given
     events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the app entity object to retrieve,
     see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type(equivalent to YARN_APPLICATION),
     app id and app created time is returned(Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the apps would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the apps would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of applications
     from the given fromId. The set of applications retrieved is inclusive
     of specified fromId. fromId should be taken from the value associated
     with FROM_ID info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing
     a set of <cite>TimelineEntity</cite> instances representing apps is
     returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowApps</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlowApps(@Context
                                                                                          javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                          @Context
                                                                                          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;userId,
                                                                                          <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;flowName,
                                                                                          <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                          <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;createdTimeEnd,
                                                                                          <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;relatesTo,
                                                                                          <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;isRelatedTo,
                                                                                          <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;infofilters,
                                                                                          <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;conffilters,
                                                                                          <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;metricfilters,
                                                                                          <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;eventfilters,
                                                                                          <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;confsToRetrieve,
                                                                                          <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;metricsToRetrieve,
                                                                                          <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;fields,
                                                                                          <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;metricsLimit,
                                                                                          <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;metricsTimeStart,
                                                                                          <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;metricsTimeEnd,
                                                                                          <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;fromId)</pre>
<div class="block">Return a list of apps for given user and flow name. Cluster ID is not
 provided by client so default cluster ID has to be taken. If number of
 matching apps are more than the limit, most recent apps till the limit is
 reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>userId</code> - User id which should match for the apps(Mandatory path param)</dd>
<dd><code>flowName</code> - Flow name which should match for the apps(Mandatory path
     param).</dd>
<dd><code>limit</code> - If specified, defines the number of apps to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched apps should not be created
     before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched apps should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched apps should relate to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched apps should be related to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>infofilters</code> - If specified, matched apps should have exact matches
     to the given info represented as key-value pairs. This is represented
     as infofilters=info1:value1,info2:value2... (Optional query param).</dd>
<dd><code>conffilters</code> - If specified, matched apps should have exact matches
     to the given configs represented as key-value pairs. This is
     represented as conffilters=conf1:value1,conf2:value2... (Optional query
     param).</dd>
<dd><code>metricfilters</code> - If specified, matched apps should contain the given
     metrics. This is represented as metricfilters=metricid1, metricid2...
     (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched apps should contain the given
     events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the app entity object to retrieve,
     see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type(equivalent to YARN_APPLICATION),
     app id and app created time is returned(Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the apps would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the apps would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of applications
     from the given fromId. The set of applications retrieved is inclusive
     of specified fromId. fromId should be taken from the value associated
     with FROM_ID info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing
     a set of <cite>TimelineEntity</cite> instances representing apps is
     returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getFlowApps-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getFlowApps</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getFlowApps(@Context
                                                                                          javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                          @Context
                                                                                          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;clusterId,
                                                                                          <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;userId,
                                                                                          <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;flowName,
                                                                                          <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                          <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;createdTimeEnd,
                                                                                          <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;relatesTo,
                                                                                          <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;isRelatedTo,
                                                                                          <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;infofilters,
                                                                                          <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;conffilters,
                                                                                          <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;metricfilters,
                                                                                          <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;eventfilters,
                                                                                          <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;confsToRetrieve,
                                                                                          <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;metricsToRetrieve,
                                                                                          <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;fields,
                                                                                          <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;metricsLimit,
                                                                                          <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;metricsTimeStart,
                                                                                          <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;metricsTimeEnd,
                                                                                          <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;fromId)</pre>
<div class="block">Return a list of apps for a given user, cluster id and flow name. If number
 of matching apps are more than the limit, most recent apps till the limit
 is reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the apps to be queried belong to
     (Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the apps(Mandatory path param)</dd>
<dd><code>flowName</code> - Flow name which should match for the apps(Mandatory path
     param).</dd>
<dd><code>limit</code> - If specified, defines the number of apps to return. The
     maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If it
     is not specified or has a value less than 0, then limit will be
     considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched apps should not be created
     before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched apps should not be created
     after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched apps should relate to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched apps should be related to given
     entities associated with a entity type. relatesto is a comma separated
     list in the format [entitytype]:[entityid1]:[entityid2]... (Optional
     query param).</dd>
<dd><code>infofilters</code> - If specified, matched apps should have exact matches
     to the given info represented as key-value pairs. This is represented
     as infofilters=info1:value1,info2:value2... (Optional query param).</dd>
<dd><code>conffilters</code> - If specified, matched apps should have exact matches
     to the given configs represented as key-value pairs. This is
     represented as conffilters=conf1:value1,conf2:value2... (Optional query
     param).</dd>
<dd><code>metricfilters</code> - If specified, matched apps should contain the given
     metrics. This is represented as metricfilters=metricid1, metricid2...
     (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched apps should contain the given
     events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
     retrieve and send back in response. These configs will be retrieved
     irrespective of whether configs are specified in fields to retrieve or
     not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
     and send back in response. These metrics will be retrieved
     irrespective of whether metrics are specified in fields to retrieve or
     not.</dd>
<dd><code>fields</code> - Specifies which fields of the app entity object to retrieve,
     see <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
     specified, 3 fields i.e. entity type(equivalent to YARN_APPLICATION),
     app id and app created time is returned(Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
     Considered only if fields contains METRICS/ALL or metricsToRetrieve is
     specified. Ignored otherwise. The maximum possible value for
     metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>. If it is not specified
     or has a value less than 1, and metrics have to be retrieved, then
     metricsLimit will be considered as 1 i.e. latest single value of
     metric(s) will be returned. (Optional query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the apps would
     not contain metric values before this timestamp(Optional query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the apps would
     not contain metric values after this timestamp(Optional query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of applications
     from the given fromId. The set of applications retrieved is inclusive
     of specified fromId. fromId should be taken from the value associated
     with FROM_ID info key in entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing
     a set of <cite>TimelineEntity</cite> instances representing apps is
     returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getAppAttempts-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppAttempts</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getAppAttempts(@Context
                                                                                             javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                             @Context
                                                                                             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;userId,
                                                                                             <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;flowName,
                                                                                             <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;flowRunId,
                                                                                             <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                             <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;createdTimeEnd,
                                                                                             <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;relatesTo,
                                                                                             <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;isRelatedTo,
                                                                                             <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;infofilters,
                                                                                             <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;conffilters,
                                                                                             <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;metricfilters,
                                                                                             <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;eventfilters,
                                                                                             <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;confsToRetrieve,
                                                                                             <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;metricsToRetrieve,
                                                                                             <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;fields,
                                                                                             <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;metricsLimit,
                                                                                             <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;metricsTimeStart,
                                                                                             <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;metricsTimeEnd,
                                                                                             <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;fromId)</pre>
<div class="block">Return a set of application-attempt entities for a given applicationId.
 Cluster ID is not provided by client so default cluster ID has to be taken.
 If userid, flow name and flowrun id which are optional query parameters are
 not specified, they will be queried based on app id and default cluster id
 from the flow context information stored in underlying storage
 implementation. If number of matching entities are more than the limit,
 most recent entities till the limit is reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>appId</code> - Application id to which the entities to be queried belong to(
          Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entities(Optional query
          param)</dd>
<dd><code>flowName</code> - Flow name which should match for the entities(Optional
          query param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entities(Optional query
          param).</dd>
<dd><code>limit</code> - If specified, defines the number of entities to return. The
          maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If
          it is not specified or has a value less than 0, then limit will be
          considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched entities should not be
          created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched entities should not be created
          after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched entities should relate to given
          entities associated with a entity type. relatesto is a comma
          separated list in the format
          [entitytype]:[entityid1]:[entityid2]... (Optional query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched entities should be related to
          given entities associated with a entity type. relatesto is a comma
          separated list in the format
          [entitytype]:[entityid1]:[entityid2]... (Optional query param).</dd>
<dd><code>infofilters</code> - If specified, matched entities should have exact matches
          to the given info represented as key-value pairs. This is
          represented as infofilters=info1:value1,info2:value2... (Optional
          query param).</dd>
<dd><code>conffilters</code> - If specified, matched entities should have exact matches
          to the given configs represented as key-value pairs. This is
          represented as conffilters=conf1:value1,conf2:value2... (Optional
          query param).</dd>
<dd><code>metricfilters</code> - If specified, matched entities should contain the
          given metrics. This is represented as metricfilters=metricid1,
          metricid2... (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched entities should contain the given
          events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
          retrieve and send back in response. These configs will be
          retrieved irrespective of whether configs are specified in fields
          to retrieve or not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
          and send back in response. These metrics will be retrieved
          irrespective of whether metrics are specified in fields to
          retrieve or not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
          <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
          specified, 3 fields i.e. entity type, id, created time is returned
          (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
          Considered only if fields contains METRICS/ALL or
          metricsToRetrieve is specified. Ignored otherwise. The maximum
          possible value for metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>.
          If it is not specified or has a value less than 1, and metrics
          have to be retrieved, then metricsLimit will be considered as 1
          i.e. latest single value of metric(s) will be returned. (Optional
          query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the app attempts
          would not contain metric values before this timestamp(Optional
          query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the app attempts
          would not contain metric values after this timestamp(Optional
          query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of application-attempt
         entities from the given fromId. The set of application-attempt
         entities retrieved is inclusive of specified fromId. fromId should
         be taken from the value associated with FROM_ID info key in
         entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
         set of <cite>TimelineEntity</cite> instances of the app-attempt
         entity type is returned.<br>
         On failures,<br>
         If any problem occurs in parsing request, HTTP 400(Bad Request) is
         returned.<br>
         If flow context information cannot be retrieved, HTTP 404(Not
         Found) is returned.<br>
         For all other errors while retrieving data, HTTP 500(Internal
         Server Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getAppAttempts-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppAttempts</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getAppAttempts(@Context
                                                                                             javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                             @Context
                                                                                             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;clusterId,
                                                                                             <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;userId,
                                                                                             <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;flowName,
                                                                                             <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;flowRunId,
                                                                                             <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                             <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;createdTimeEnd,
                                                                                             <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;relatesTo,
                                                                                             <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;isRelatedTo,
                                                                                             <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;infofilters,
                                                                                             <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;conffilters,
                                                                                             <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;metricfilters,
                                                                                             <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;eventfilters,
                                                                                             <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;confsToRetrieve,
                                                                                             <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;metricsToRetrieve,
                                                                                             <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;fields,
                                                                                             <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;metricsLimit,
                                                                                             <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;metricsTimeStart,
                                                                                             <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;metricsTimeEnd,
                                                                                             <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;fromId)</pre>
<div class="block">Return a set of application-attempt entities for a given applicationId. If
 userid, flow name and flowrun id which are optional query parameters are
 not specified, they will be queried based on app id and cluster id from the
 flow context information stored in underlying storage implementation. If
 number of matching entities are more than the limit, most recent entities
 till the limit is reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the entities to be queried belong to(
          Mandatory path param).</dd>
<dd><code>appId</code> - Application id to which the entities to be queried belong to(
          Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entities(Optional query
          param)</dd>
<dd><code>flowName</code> - Flow name which should match for the entities(Optional
          query param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entities(Optional query
          param).</dd>
<dd><code>limit</code> - If specified, defines the number of entities to return. The
          maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If
          it is not specified or has a value less than 0, then limit will be
          considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched entities should not be
          created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched entities should not be created
          after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched entities should relate to given
          entities associated with a entity type. relatesto is a comma
          separated list in the format
          [entitytype]:[entityid1]:[entityid2]... (Optional query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched entities should be related to
          given entities associated with a entity type. relatesto is a comma
          separated list in the format
          [entitytype]:[entityid1]:[entityid2]... (Optional query param).</dd>
<dd><code>infofilters</code> - If specified, matched entities should have exact matches
          to the given info represented as key-value pairs. This is
          represented as infofilters=info1:value1,info2:value2... (Optional
          query param).</dd>
<dd><code>conffilters</code> - If specified, matched entities should have exact matches
          to the given configs represented as key-value pairs. This is
          represented as conffilters=conf1:value1,conf2:value2... (Optional
          query param).</dd>
<dd><code>metricfilters</code> - If specified, matched entities should contain the
          given metrics. This is represented as metricfilters=metricid1,
          metricid2... (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched entities should contain the given
          events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
          retrieve and send back in response. These configs will be
          retrieved irrespective of whether configs are specified in fields
          to retrieve or not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
          and send back in response. These metrics will be retrieved
          irrespective of whether metrics are specified in fields to
          retrieve or not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
          <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
          specified, 3 fields i.e. entity type, id, created time is returned
          (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
          Considered only if fields contains METRICS/ALL or
          metricsToRetrieve is specified. Ignored otherwise. The maximum
          possible value for metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>.
          If it is not specified or has a value less than 1, and metrics
          have to be retrieved, then metricsLimit will be considered as 1
          i.e. latest single value of metric(s) will be returned. (Optional
          query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the app attempts
          would not contain metric values before this timestamp(Optional
          query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the app attempts
          would not contain metric values after this timestamp(Optional
          query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of application-attempt
         entities from the given fromId. The set of application-attempt
         entities retrieved is inclusive of specified fromId. fromId should
         be taken from the value associated with FROM_ID info key in
         entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
         set of <cite>TimelineEntity</cite> instances of the app-attempts
         entity type is returned.<br>
         On failures,<br>
         If any problem occurs in parsing request, HTTP 400(Bad Request) is
         returned.<br>
         If flow context information cannot be retrieved, HTTP 404(Not
         Found) is returned.<br>
         For all other errors while retrieving data, HTTP 500(Internal
         Server Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getAppAttempt-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppAttempt</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getAppAttempt(@Context
                                                                                       javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                       @Context
                                                                                       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;userId,
                                                                                       <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;flowName,
                                                                                       <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;flowRunId,
                                                                                       <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;confsToRetrieve,
                                                                                       <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;metricsToRetrieve,
                                                                                       <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;fields,
                                                                                       <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;metricsLimit,
                                                                                       <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;metricsTimeStart,
                                                                                       <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;metricsTimeEnd,
                                                                                       <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;entityIdPrefix)</pre>
<div class="block">Return a single application-attempt entity for the given attempt Id.
 Cluster ID is not provided by client so default cluster ID has to be taken.
 If userid, flow name and flowrun id which are optional query parameters are
 not specified, they will be queried based on app id and default cluster id
 from the flow context information stored in underlying storage
 implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>appId</code> - Application id to which the entity to be queried belongs to(
          Mandatory path param).</dd>
<dd><code>appAttemptId</code> - Application Attempt Id to which the containers belong
          to( Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entity(Optional query
          param).</dd>
<dd><code>flowName</code> - Flow name which should match for the entity(Optional query
          param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entity(Optional query
          param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
          retrieve and send back in response. These configs will be
          retrieved irrespective of whether configs are specified in fields
          to retrieve or not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
          and send back in response. These metrics will be retrieved
          irrespective of whether metrics are specified in fields to
          retrieve or not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
          <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
          specified, 3 fields i.e. entity type, id, created time is returned
          (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
          Considered only if fields contains METRICS/ALL or
          metricsToRetrieve is specified. Ignored otherwise. The maximum
          possible value for metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>.
          If it is not specified or has a value less than 1, and metrics
          have to be retrieved, then metricsLimit will be considered as 1
          i.e. latest single value of metric(s) will be returned. (Optional
          query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the app attempt
          would not contain metric values before this timestamp(Optional
          query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the app attempt
          would not contain metric values after this timestamp(Optional
          query param).</dd>
<dd><code>entityIdPrefix</code> - Defines the id prefix for the entity to be fetched.
          If specified, then entity retrieval will be faster.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
         <cite>TimelineEntity</cite> instance is returned.<br>
         On failures,<br>
         If any problem occurs in parsing request, HTTP 400(Bad Request) is
         returned.<br>
         If flow context information cannot be retrieved or entity for the
         given entity id cannot be found, HTTP 404(Not Found) is
         returned.<br>
         For all other errors while retrieving data, HTTP 500(Internal
         Server Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getAppAttempt-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getAppAttempt</h4>
<pre>public&nbsp;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&nbsp;getAppAttempt(@Context
                                                                                       javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                       @Context
                                                                                       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;clusterId,
                                                                                       <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;userId,
                                                                                       <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;flowName,
                                                                                       <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;flowRunId,
                                                                                       <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;confsToRetrieve,
                                                                                       <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;metricsToRetrieve,
                                                                                       <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;fields,
                                                                                       <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;metricsLimit,
                                                                                       <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;metricsTimeStart,
                                                                                       <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;metricsTimeEnd,
                                                                                       <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;entityIdPrefix)</pre>
<div class="block">Return a single application attempt entity of the given entity Id. If
 userid, flowname and flowrun id which are optional query parameters are not
 specified, they will be queried based on app id and cluster id from the
 flow context information stored in underlying storage implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the entity to be queried belongs to(
          Mandatory path param).</dd>
<dd><code>appId</code> - Application id to which the entity to be queried belongs to(
          Mandatory path param).</dd>
<dd><code>appAttemptId</code> - Application Attempt Id to which the containers belong
          to( Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entity(Optional query
          param).</dd>
<dd><code>flowName</code> - Flow name which should match for the entity(Optional query
          param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entity(Optional query
          param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
          retrieve and send back in response. These configs will be
          retrieved irrespective of whether configs are specified in fields
          to retrieve or not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
          and send back in response. These metrics will be retrieved
          irrespective of whether metrics are specified in fields to
          retrieve or not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
          <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
          specified, 3 fields i.e. entity type, id and created time is
          returned (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
          Considered only if fields contains METRICS/ALL or
          metricsToRetrieve is specified. Ignored otherwise. The maximum
          possible value for metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>.
          If it is not specified or has a value less than 1, and metrics
          have to be retrieved, then metricsLimit will be considered as 1
          i.e. latest single value of metric(s) will be returned. (Optional
          query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the app attempt
          would not contain metric values before this timestamp(Optional
          query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the app attempt
          would not contain metric values after this timestamp(Optional
          query param).</dd>
<dd><code>entityIdPrefix</code> - Defines the id prefix for the entity to be fetched.
          If specified, then entity retrieval will be faster.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
         <cite>TimelineEntity</cite> instance is returned.<br>
         On failures,<br>
         If any problem occurs in parsing request, HTTP 400(Bad Request) is
         returned.<br>
         If flow context information cannot be retrieved or entity for the
         given entity id cannot be found, HTTP 404(Not Found) is
         returned.<br>
         For all other errors while retrieving data, HTTP 500(Internal
         Server Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getContainers-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getContainers</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getContainers(@Context
                                                                                            javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                            @Context
                                                                                            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;userId,
                                                                                            <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;flowName,
                                                                                            <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;flowRunId,
                                                                                            <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                            <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;createdTimeEnd,
                                                                                            <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;relatesTo,
                                                                                            <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;isRelatedTo,
                                                                                            <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;infofilters,
                                                                                            <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;conffilters,
                                                                                            <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;metricfilters,
                                                                                            <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;eventfilters,
                                                                                            <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;confsToRetrieve,
                                                                                            <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;metricsToRetrieve,
                                                                                            <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;fields,
                                                                                            <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;metricsLimit,
                                                                                            <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;metricsTimeStart,
                                                                                            <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;metricsTimeEnd,
                                                                                            <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;fromId)</pre>
<div class="block">Return a set of container entities belonging to given application attempt
 id. Cluster ID is not provided by client so default cluster ID has to be
 taken. If userid, flow name and flowrun id which are optional query
 parameters are not specified, they will be queried based on app id and
 default cluster id from the flow context information stored in underlying
 storage implementation. If number of matching entities are more than the
 limit, most recent entities till the limit is reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>appId</code> - Application id to which the entities to be queried belong to(
          Mandatory path param).</dd>
<dd><code>appattemptId</code> - Application Attempt Id to which the containers belong
          to( Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entities(Optional query
          param)</dd>
<dd><code>flowName</code> - Flow name which should match for the entities(Optional
          query param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entities(Optional query
          param).</dd>
<dd><code>limit</code> - If specified, defines the number of entities to return. The
          maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If
          it is not specified or has a value less than 0, then limit will be
          considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched entities should not be
          created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched entities should not be created
          after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched entities should relate to given
          entities associated with a entity type. relatesto is a comma
          separated list in the format
          [entitytype]:[entityid1]:[entityid2]... (Optional query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched entities should be related to
          given entities associated with a entity type. relatesto is a comma
          separated list in the format
          [entitytype]:[entityid1]:[entityid2]... (Optional query param).</dd>
<dd><code>infofilters</code> - If specified, matched entities should have exact matches
          to the given info represented as key-value pairs. This is
          represented as infofilters=info1:value1,info2:value2... (Optional
          query param).</dd>
<dd><code>conffilters</code> - If specified, matched entities should have exact matches
          to the given configs represented as key-value pairs. This is
          represented as conffilters=conf1:value1,conf2:value2... (Optional
          query param).</dd>
<dd><code>metricfilters</code> - If specified, matched entities should contain the
          given metrics. This is represented as metricfilters=metricid1,
          metricid2... (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched entities should contain the given
          events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
          retrieve and send back in response. These configs will be
          retrieved irrespective of whether configs are specified in fields
          to retrieve or not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
          and send back in response. These metrics will be retrieved
          irrespective of whether metrics are specified in fields to
          retrieve or not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
          <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
          specified, 3 fields i.e. entity type, id, created time is returned
          (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
          Considered only if fields contains METRICS/ALL or
          metricsToRetrieve is specified. Ignored otherwise. The maximum
          possible value for metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>.
          If it is not specified or has a value less than 1, and metrics
          have to be retrieved, then metricsLimit will be considered as 1
          i.e. latest single value of metric(s) will be returned. (Optional
          query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the containers
          would not contain metric values before this timestamp(Optional
          query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the containers
          would not contain metric values after this timestamp(Optional
          query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of container
         entities from the given fromId. The set of container
         entities retrieved is inclusive of specified fromId. fromId should
         be taken from the value associated with FROM_ID info key in
         entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
         set of <cite>TimelineEntity</cite> instances of the containers
         belongs to given application attempt id.<br>
         On failures,<br>
         If any problem occurs in parsing request, HTTP 400(Bad Request) is
         returned.<br>
         If flow context information cannot be retrieved, HTTP 404(Not
         Found) is returned.<br>
         For all other errors while retrieving data, HTTP 500(Internal
         Server Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getContainers-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getContainers</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getContainers(@Context
                                                                                            javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                            @Context
                                                                                            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;clusterId,
                                                                                            <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;userId,
                                                                                            <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;flowName,
                                                                                            <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;flowRunId,
                                                                                            <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                            <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;createdTimeEnd,
                                                                                            <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;relatesTo,
                                                                                            <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;isRelatedTo,
                                                                                            <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;infofilters,
                                                                                            <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;conffilters,
                                                                                            <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;metricfilters,
                                                                                            <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;eventfilters,
                                                                                            <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;confsToRetrieve,
                                                                                            <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;metricsToRetrieve,
                                                                                            <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;fields,
                                                                                            <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;metricsLimit,
                                                                                            <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;metricsTimeStart,
                                                                                            <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;metricsTimeEnd,
                                                                                            <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;fromId)</pre>
<div class="block">Return a set of container entities belonging to given application attempt
 id. If userid, flow name and flowrun id which are optional query parameters
 are not specified, they will be queried based on app id and cluster id from
 the flow context information stored in underlying storage implementation.
 If number of matching entities are more than the limit, most recent
 entities till the limit is reached, will be returned.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the entities to be queried belong to(
          Mandatory path param).</dd>
<dd><code>appId</code> - Application id to which the entities to be queried belong to(
          Mandatory path param).</dd>
<dd><code>appattemptId</code> - Application Attempt Id to which the containers belong
          to( Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entities(Optional query
          param)</dd>
<dd><code>flowName</code> - Flow name which should match for the entities(Optional
          query param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entities(Optional query
          param).</dd>
<dd><code>limit</code> - If specified, defines the number of entities to return. The
          maximum possible value for limit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Long.MAX_VALUE</code></a>. If
          it is not specified or has a value less than 0, then limit will be
          considered as 100. (Optional query param).</dd>
<dd><code>createdTimeStart</code> - If specified, matched entities should not be
          created before this timestamp(Optional query param).</dd>
<dd><code>createdTimeEnd</code> - If specified, matched entities should not be created
          after this timestamp(Optional query param).</dd>
<dd><code>relatesTo</code> - If specified, matched entities should relate to given
          entities associated with a entity type. relatesto is a comma
          separated list in the format
          [entitytype]:[entityid1]:[entityid2]... (Optional query param).</dd>
<dd><code>isRelatedTo</code> - If specified, matched entities should be related to
          given entities associated with a entity type. relatesto is a comma
          separated list in the format
          [entitytype]:[entityid1]:[entityid2]... (Optional query param).</dd>
<dd><code>infofilters</code> - If specified, matched entities should have exact matches
          to the given info represented as key-value pairs. This is
          represented as infofilters=info1:value1,info2:value2... (Optional
          query param).</dd>
<dd><code>conffilters</code> - If specified, matched entities should have exact matches
          to the given configs represented as key-value pairs. This is
          represented as conffilters=conf1:value1,conf2:value2... (Optional
          query param).</dd>
<dd><code>metricfilters</code> - If specified, matched entities should contain the
          given metrics. This is represented as metricfilters=metricid1,
          metricid2... (Optional query param).</dd>
<dd><code>eventfilters</code> - If specified, matched entities should contain the given
          events. This is represented as eventfilters=eventid1, eventid2...</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
          retrieve and send back in response. These configs will be
          retrieved irrespective of whether configs are specified in fields
          to retrieve or not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
          and send back in response. These metrics will be retrieved
          irrespective of whether metrics are specified in fields to
          retrieve or not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
          <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
          specified, 3 fields i.e. entity type, id, created time is returned
          (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
          Considered only if fields contains METRICS/ALL or
          metricsToRetrieve is specified. Ignored otherwise. The maximum
          possible value for metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>.
          If it is not specified or has a value less than 1, and metrics
          have to be retrieved, then metricsLimit will be considered as 1
          i.e. latest single value of metric(s) will be returned. (Optional
          query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the containers
          would not contain metric values before this timestamp(Optional
          query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the containers
          would not contain metric values after this timestamp(Optional
          query param).</dd>
<dd><code>fromId</code> - If specified, retrieve the next set of container
         entities from the given fromId. The set of container
         entities retrieved is inclusive of specified fromId. fromId should
         be taken from the value associated with FROM_ID info key in
         entity response which was sent earlier.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
         set of <cite>TimelineEntity</cite> instances of the containers
         belongs to given application attempt id.<br>
         On failures,<br>
         If any problem occurs in parsing request, HTTP 400(Bad Request) is
         returned.<br>
         If flow context information cannot be retrieved, HTTP 404(Not
         Found) is returned.<br>
         For all other errors while retrieving data, HTTP 500(Internal
         Server Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getContainer-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.api.records.timelineservice.TimelineEntity&nbsp;getContainer(@Context
                                                                                      javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                      @Context
                                                                                      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;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;userId,
                                                                                      <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;flowName,
                                                                                      <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;flowRunId,
                                                                                      <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;confsToRetrieve,
                                                                                      <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;metricsToRetrieve,
                                                                                      <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;fields,
                                                                                      <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;metricsLimit,
                                                                                      <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;metricsTimeStart,
                                                                                      <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;metricsTimeEnd,
                                                                                      <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;entityIdPrefix)</pre>
<div class="block">Return a single container entity for the given container Id. Cluster ID is
 not provided by client so default cluster ID has to be taken. If userid,
 flow name and flowrun id which are optional query parameters are not
 specified, they will be queried based on app id and default cluster id from
 the flow context information stored in underlying storage implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>appId</code> - Application id to which the entity to be queried belongs to(
          Mandatory path param).</dd>
<dd><code>containerId</code> - Container Id to which the entity to be queried belongs
          to( Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entity(Optional query
          param).</dd>
<dd><code>flowName</code> - Flow name which should match for the entity(Optional query
          param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entity(Optional query
          param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
          retrieve and send back in response. These configs will be
          retrieved irrespective of whether configs are specified in fields
          to retrieve or not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
          and send back in response. These metrics will be retrieved
          irrespective of whether metrics are specified in fields to
          retrieve or not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
          <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
          specified, 3 fields i.e. entity type, id, created time is returned
          (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
          Considered only if fields contains METRICS/ALL or
          metricsToRetrieve is specified. Ignored otherwise. The maximum
          possible value for metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>.
          If it is not specified or has a value less than 1, and metrics
          have to be retrieved, then metricsLimit will be considered as 1
          i.e. latest single value of metric(s) will be returned. (Optional
          query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the container
          would not contain metric values before this timestamp(Optional
          query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the container
          would not contain metric values after this timestamp(Optional
          query param).</dd>
<dd><code>entityIdPrefix</code> - Defines the id prefix for the entity to be fetched.
          If specified, then entity retrieval will be faster.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing
         <cite>TimelineEntity</cite> instance is returned.<br>
         On failures,<br>
         If any problem occurs in parsing request, HTTP 400(Bad Request) is
         returned.<br>
         If flow context information cannot be retrieved or entity for the
         given entity id cannot be found, HTTP 404(Not Found) is
         returned.<br>
         For all other errors while retrieving data, HTTP 500(Internal
         Server Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getContainer-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-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.api.records.timelineservice.TimelineEntity&nbsp;getContainer(@Context
                                                                                      javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                      @Context
                                                                                      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;clusterId,
                                                                                      <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;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;userId,
                                                                                      <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;flowName,
                                                                                      <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;flowRunId,
                                                                                      <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;confsToRetrieve,
                                                                                      <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;metricsToRetrieve,
                                                                                      <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;fields,
                                                                                      <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;metricsLimit,
                                                                                      <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;metricsTimeStart,
                                                                                      <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;metricsTimeEnd,
                                                                                      <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;entityIdPrefix)</pre>
<div class="block">Return a single container entity for the given container Id. If userid,
 flowname and flowrun id which are optional query parameters are not
 specified, they will be queried based on app id and cluster id from the
 flow context information stored in underlying storage implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the entity to be queried belongs to(
          Mandatory path param).</dd>
<dd><code>appId</code> - Application id to which the entity to be queried belongs to(
          Mandatory path param).</dd>
<dd><code>containerId</code> - Container Id to which the entity to be queried belongs
          to( Mandatory path param).</dd>
<dd><code>userId</code> - User id which should match for the entity(Optional query
          param).</dd>
<dd><code>flowName</code> - Flow name which should match for the entity(Optional query
          param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the entity(Optional query
          param).</dd>
<dd><code>confsToRetrieve</code> - If specified, defines which configurations to
          retrieve and send back in response. These configs will be
          retrieved irrespective of whether configs are specified in fields
          to retrieve or not.</dd>
<dd><code>metricsToRetrieve</code> - If specified, defines which metrics to retrieve
          and send back in response. These metrics will be retrieved
          irrespective of whether metrics are specified in fields to
          retrieve or not.</dd>
<dd><code>fields</code> - Specifies which fields of the entity object to retrieve, see
          <a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/storage/TimelineReader.Field.html" title="enum in org.apache.hadoop.yarn.server.timelineservice.storage"><code>TimelineReader.Field</code></a>. All fields will be retrieved if fields=ALL. If not
          specified, 3 fields i.e. entity type, id and created time is
          returned (Optional query param).</dd>
<dd><code>metricsLimit</code> - If specified, defines the number of metrics to return.
          Considered only if fields contains METRICS/ALL or
          metricsToRetrieve is specified. Ignored otherwise. The maximum
          possible value for metricsLimit can be <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true#MAX_VALUE" title="class or interface in java.lang"><code>Integer.MAX_VALUE</code></a>.
          If it is not specified or has a value less than 1, and metrics
          have to be retrieved, then metricsLimit will be considered as 1
          i.e. latest single value of metric(s) will be returned. (Optional
          query param).</dd>
<dd><code>metricsTimeStart</code> - If specified, returned metrics for the container
          would not contain metric values before this timestamp(Optional
          query param).</dd>
<dd><code>metricsTimeEnd</code> - If specified, returned metrics for the container
          would not contain metric values after this timestamp(Optional
          query param).</dd>
<dd><code>entityIdPrefix</code> - Defines the id prefix for the entity to be fetched.
          If specified, then entity retrieval will be faster.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
         <cite>TimelineEntity</cite> instance is returned.<br>
         On failures,<br>
         If any problem occurs in parsing request, HTTP 400(Bad Request) is
         returned.<br>
         If flow context information cannot be retrieved or entity for the
         given entity id cannot be found, HTTP 404(Not Found) is
         returned.<br>
         For all other errors while retrieving data, HTTP 500(Internal
         Server Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getEntityTypes-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getEntityTypes</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<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;getEntityTypes(@Context
                                  javax.servlet.http.HttpServletRequest&nbsp;req,
                                  @Context
                                  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;flowName,
                                  <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;flowRunId,
                                  <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;userId)</pre>
<div class="block">Returns a set of available entity types for a given app id. Cluster ID is
 not provided by client so default cluster ID has to be taken. If userid,
 flow name and flow run id which are optional query parameters are not
 specified, they will be queried based on app id and cluster id from the
 flow context information stored in underlying storage implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>appId</code> - Application id to be queried(Mandatory path param).</dd>
<dd><code>flowName</code> - Flow name which should match for the app(Optional query
     param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the app(Optional query
     param).</dd>
<dd><code>userId</code> - User id which should match for the app(Optional query param).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     list contains all timeline entity types is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow context information cannot be retrieved or app for the given
     app id cannot be found, HTTP 404(Not Found) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getEntityTypes-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-java.lang.String-java.lang.String-java.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getEntityTypes</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;<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;getEntityTypes(@Context
                                  javax.servlet.http.HttpServletRequest&nbsp;req,
                                  @Context
                                  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;clusterId,
                                  <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;flowName,
                                  <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;flowRunId,
                                  <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;userId)</pre>
<div class="block">Returns a set of available entity types for a given app id. If userid,
 flow name and flow run id which are optional query parameters are not
 specified, they will be queried based on app id and cluster id from the
 flow context information stored in underlying storage implementation.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>req</code> - Servlet request.</dd>
<dd><code>res</code> - Servlet response.</dd>
<dd><code>clusterId</code> - Cluster id to which the app to be queried belong to(
     Mandatory path param).</dd>
<dd><code>appId</code> - Application id to be queried(Mandatory path param).</dd>
<dd><code>flowName</code> - Flow name which should match for the app(Optional query
     param).</dd>
<dd><code>flowRunId</code> - Run id which should match for the app(Optional query
     param).</dd>
<dd><code>userId</code> - User id which should match for the app(Optional query param).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>If successful, a HTTP 200(OK) response having a JSON representing a
     list contains all timeline entity types is returned.<br>
     On failures,<br>
     If any problem occurs in parsing request, HTTP 400(Bad Request) is
     returned.<br>
     If flow context information cannot be retrieved or app for the given
     app id cannot be found, HTTP 404(Not Found) is returned.<br>
     For all other errors while retrieving data, HTTP 500(Internal Server
     Error) is returned.</dd>
</dl>
</li>
</ul>
<a name="getSubAppEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSubAppEntities</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getSubAppEntities(@Context
                                                                                                javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                                @Context
                                                                                                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;userId,
                                                                                                <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;entityType,
                                                                                                <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                                <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;createdTimeEnd,
                                                                                                <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;relatesTo,
                                                                                                <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;isRelatedTo,
                                                                                                <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;infofilters,
                                                                                                <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;conffilters,
                                                                                                <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;metricfilters,
                                                                                                <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;eventfilters,
                                                                                                <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;confsToRetrieve,
                                                                                                <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;metricsToRetrieve,
                                                                                                <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;fields,
                                                                                                <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;metricsLimit,
                                                                                                <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;metricsTimeStart,
                                                                                                <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;metricsTimeEnd,
                                                                                                <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;fromId)</pre>
</li>
</ul>
<a name="getSubAppEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-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.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSubAppEntities</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getSubAppEntities(@Context
                                                                                                javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                                @Context
                                                                                                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;clusterId,
                                                                                                <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;userId,
                                                                                                <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;entityType,
                                                                                                <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/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;createdTimeStart,
                                                                                                <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;createdTimeEnd,
                                                                                                <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;relatesTo,
                                                                                                <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;isRelatedTo,
                                                                                                <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;infofilters,
                                                                                                <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;conffilters,
                                                                                                <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;metricfilters,
                                                                                                <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;eventfilters,
                                                                                                <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;confsToRetrieve,
                                                                                                <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;metricsToRetrieve,
                                                                                                <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;fields,
                                                                                                <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;metricsLimit,
                                                                                                <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;metricsTimeStart,
                                                                                                <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;metricsTimeEnd,
                                                                                                <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;fromId)</pre>
</li>
</ul>
<a name="getSubAppEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getSubAppEntities</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getSubAppEntities(@Context
                                                                                                javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                                @Context
                                                                                                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;userId,
                                                                                                <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;entityType,
                                                                                                <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;entityId,
                                                                                                <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;confsToRetrieve,
                                                                                                <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;metricsToRetrieve,
                                                                                                <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;fields,
                                                                                                <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;metricsLimit,
                                                                                                <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;metricsTimeStart,
                                                                                                <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;metricsTimeEnd,
                                                                                                <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;entityIdPrefix)</pre>
</li>
</ul>
<a name="getSubAppEntities-javax.servlet.http.HttpServletRequest-javax.servlet.http.HttpServletResponse-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.lang.String-java.lang.String-java.lang.String-">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>getSubAppEntities</h4>
<pre>public&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/util/Set.html?is-external=true" title="class or interface in java.util">Set</a>&lt;org.apache.hadoop.yarn.api.records.timelineservice.TimelineEntity&gt;&nbsp;getSubAppEntities(@Context
                                                                                                javax.servlet.http.HttpServletRequest&nbsp;req,
                                                                                                @Context
                                                                                                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;clusterId,
                                                                                                <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;userId,
                                                                                                <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;entityType,
                                                                                                <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;entityId,
                                                                                                <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;confsToRetrieve,
                                                                                                <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;metricsToRetrieve,
                                                                                                <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;fields,
                                                                                                <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;metricsLimit,
                                                                                                <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;metricsTimeStart,
                                                                                                <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;metricsTimeEnd,
                                                                                                <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;entityIdPrefix)</pre>
</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/TimelineReaderWebServices.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/timelineservice/reader/TimelineReaderUtils.html" title="class in org.apache.hadoop.yarn.server.timelineservice.reader"><span class="typeNameLink">Prev&nbsp;Class</span></a></li>
<li><a href="../../../../../../../org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServicesUtils.html" title="class in org.apache.hadoop.yarn.server.timelineservice.reader"><span class="typeNameLink">Next&nbsp;Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../../../../index.html?org/apache/hadoop/yarn/server/timelineservice/reader/TimelineReaderWebServices.html" target="_top">Frames</a></li>
<li><a href="TimelineReaderWebServices.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>
