Merge branch 'trunk' into branch-alerts-dev

ambari-admin/src/main/resources/ui/admin-web/app/scripts/controllers/mainCtrl.js

@@ -18,7 +18,7 @@
 'use strict';
 
 angular.module('ambariAdminConsole')
-.controller('MainCtrl',['$scope', 'Auth', 'uiAlert', '$modal', function($scope, Auth, uiAlert, $modal) {
+.controller('MainCtrl',['$scope', 'Auth', 'uiAlert', '$modal', 'Cluster', function($scope, Auth, uiAlert, $modal, Cluster) {
   $scope.signOut = function() {
     Auth.signout().then(function() {
      window.location.pathname = ''; // Change location hard, because Angular works only with relative urls
@@ -39,4 +39,15 @@ angular.module('ambariAdminConsole')
   };
 
   $scope.currentUser = Auth.getCurrentUser();
+
+  $scope.cluster = null;
+  $scope.isLoaded = null;
+
+  Cluster.getStatus().then(function(cluster) {
+    $scope.cluster = cluster;
+    $scope.isLoaded = true;
+  }).catch(function(data) {
+      uiAlert.danger(data.status, data.message);
+  });
+
 }]);

ambari-admin/src/main/resources/ui/admin-web/app/styles/main.css

@@ -211,12 +211,49 @@
 }
 .mainpage .panel-body{
   padding: 20px;
-  height: 560px;
+  height: 620px;
 }
 .mainpage h1{
   font-size: 24px;
   margin-top: 10px;
 }
+.mainpage .panel-body #main-operations-boxes {
+  padding: 10px;
+}
+.mainpage .panel-body #main-operations-boxes .thumbnail{
+  display: block;
+  height: 230px;
+  padding: 8px;
+  background-color: #eeeeee;
+  margin-bottom: 20px;
+  margin-left: 20px;
+  margin-right: 10px;
+  border: none;
+  border-radius: 0px;
+}
+.mainpage .panel-body #main-operations-boxes .thumbnail .title,
+.mainpage .panel-body #main-operations-boxes .thumbnail .description,
+.mainpage .panel-body #main-operations-boxes .thumbnail .buttons {
+  text-align: center;
+  line-height: 1.5;
+}
+.mainpage .panel-body #main-operations-boxes .thumbnail .buttons .btn{
+  width: 200px;
+  margin: 5px;
+}
+.mainpage .panel-body #main-operations-boxes .thumbnail .buttons .btn.userslist-button,
+.mainpage .panel-body #main-operations-boxes .thumbnail .buttons .btn.groupslist-button {
+  width: 100px;
+}
+.mainpage .panel-body #main-operations-boxes .thumbnail .glyphicon {
+  font-size: 50px;
+  text-align: center;
+  display: block;
+  line-height: 1.5;
+}
+.mainpage .panel-body #main-operations-boxes .col-sm-5 {
+  width: 43.5%;
+}
 
 .views-list-table .panel{
   border-radius: 0;
@@ -488,6 +525,9 @@
   .container{
     width: 1170px;
   }
+  .mainpage .panel-body #main-operations-boxes .col-sm-5 {
+    width: 44%;
+  }
 }
 
 ul.nav li > a{

ambari-admin/src/main/resources/ui/admin-web/app/views/main.html

@@ -18,7 +18,44 @@
 <div class="panel panel-default mainpage">
   <div class="panel-body">
     <h1>Welcome to Apache Ambari</h1>
-    <p>Use the controls to the left to provision a cluster, manage who can access the cluster, and customize views for Ambari users.</p>
+    <div ng-if="isLoaded" id="main-operations-boxes" class="row thumbnails">
+      <p ng-hide="cluster">Provision a cluster, manage who can access the cluster, and customize views for Ambari users.</p>
+      <p ng-show="cluster">Monitor your cluster resources, manage who can access the cluster, and customize views for Ambari users.</p>
+        <!--Clusters-->
+      <div ng-show="cluster" class="col-sm-11 thumbnail">
+        <h4 class="title">Operate Your Cluster</h4>
+        <div class="description">Manage the configuration of your cluster and monitor the health of your services</div>
+        <div class="glyphicon glyphicon-cloud"></div>
+        <div class="buttons">
+          <span ng-class="{active: isActive('clusters.manageAccess')}"><a href="#/clusters/{{cluster.Clusters.cluster_name}}/manageAccess" class="btn btn-primary permission-button">Manage Permissions</a></span>
+          <span><a href="/#/main/dashboard" class="btn btn-primary go-dashboard-button" target="{{cluster.Clusters.cluster_name}}">Go to Dashboard</a></span>
+        </div>
+      </div>
+      <div ng-hide="cluster" class="col-sm-11 thumbnail">
+        <h4 class="title">Create a Cluster</h4>
+        <div class="description">Use the Install Wizard to select services and configure your cluster</div>
+        <div class="glyphicon glyphicon-cloud"></div>
+        <div class="buttons"> <a href="/#/installer/step0" class="btn btn-primary create-cluster-button">Install Cluster</a></div>
+      </div>
+
+        <!--Manage Users and groups-->
+      <div class="col-sm-5 thumbnail">
+        <h4 class="title">Manage Users + Groups</h4>
+        <div class="description">Manage the users and groups that can access Ambari</div>
+        <div class="glyphicon glyphicon-user"></div>
+        <div class="buttons">
+          <span ng-class="{active: isActive('users.list')}"><link-to route="users.list" class="btn btn-primary userslist-button">Users</link-to></span>
+          <span ng-class="{active: isActive('groups.list')}"><link-to route="groups.list" class="btn btn-primary groupslist-button">Groups</link-to></span>
+        </div>
+      </div>
+
+        <!--Deploy Views-->
+      <div class="col-sm-5 thumbnail">
+        <h4 class="title">Deploy Views</h4>
+        <div class="description">Create view instances and grant permissions</div>
+        <div class="glyphicon glyphicon-th"></div>
+        <div ng-class="{active: isActive('views.list')}" class="buttons"><link-to route="views.list" class="btn btn-primary viewslist-button">Views</link-to></div>
+        </div>
+      </div>
   </div>
-    
 </div>

ambari-common/src/main/python/ambari_jinja2/ext/jinja.el

@@ -1,213 +0,0 @@
-;;; jinja.el --- Jinja mode highlighting
-;;
-;; Author: Georg Brandl
-;; Copyright: (c) 2009 by the Jinja Team
-;; Last modified: 2008-05-22 23:04 by gbr
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Commentary:
-;;
-;; Mostly ripped off django-mode by Lennart Borgman.
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;; This program is free software; you can redistribute it and/or
-;; modify it under the terms of the GNU General Public License as
-;; published by the Free Software Foundation; either version 2, or
-;; (at your option) any later version.
-;;
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with this program; see the file COPYING.  If not, write to
-;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth
-;; Floor, Boston, MA 02110-1301, USA.
-;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
-;;; Code:
-
-(defconst jinja-font-lock-keywords
-  (list
-;   (cons (rx "{% comment %}" (submatch (0+ anything))
-;             "{% endcomment %}") (list 1 font-lock-comment-face))
-   '("{# ?\\(.*?\\) ?#}" . (1 font-lock-comment-face))
-   '("{%-?\\|-?%}\\|{{\\|}}" . font-lock-preprocessor-face)
-   '("{#\\|#}" . font-lock-comment-delimiter-face)
-   ;; first word in a block is a command
-   '("{%-?[ \t\n]*\\([a-zA-Z_]+\\)" . (1 font-lock-keyword-face))
-   ;; variables
-   '("\\({{ ?\\)\\([^|]*?\\)\\(|.*?\\)? ?}}" . (1 font-lock-variable-name-face))
-   ;; keywords and builtins
-   (cons (rx word-start
-             (or "in" "as" "recursive" "not" "and" "or" "if" "else"
-                 "import" "with" "without" "context")
-             word-end)
-         font-lock-keyword-face)
-   (cons (rx word-start
-             (or "true" "false" "none" "loop" "self" "super")
-             word-end)
-         font-lock-builtin-face)
-   ;; tests
-   '("\\(is\\)[ \t]*\\(not\\)[ \t]*\\([a-zA-Z_]+\\)"
-     (1 font-lock-keyword-face) (2 font-lock-keyword-face)
-     (3 font-lock-function-name-face))
-   ;; builtin filters
-   (cons (rx
-          "|" (* space)
-          (submatch
-           (or "abs" "batch" "capitalize" "capture" "center" "count" "default"
-               "dformat" "dictsort" "e" "escape" "filesizeformat" "first"
-               "float" "format" "getattribute" "getitem" "groupby" "indent"
-               "int" "join" "jsonencode" "last" "length" "lower" "markdown"
-               "pprint" "random" "replace" "reverse" "round" "rst" "slice"
-               "sort" "string" "striptags" "sum" "textile" "title" "trim"
-               "truncate" "upper" "urlencode" "urlize" "wordcount" "wordwrap"
-               "xmlattr")))
-         (list 1 font-lock-builtin-face))
-   )
-   "Minimal highlighting expressions for Jinja mode")
-
-(define-derived-mode jinja-mode nil "Jinja"
-  "Simple Jinja mode for use with `mumamo-mode'.
-This mode only provides syntax highlighting."
-  ;;(set (make-local-variable 'comment-start) "{#")
-  ;;(set (make-local-variable 'comment-end)   "#}")
-  (setq font-lock-defaults '(jinja-font-lock-keywords)))
-
-;; mumamo stuff
-
-(when (require 'mumamo nil t)
-
-  (defun mumamo-chunk-jinja3(pos min max)
-    "Find {# ... #}.  Return range and `jinja-mode'.
-See `mumamo-find-possible-chunk' for POS, MIN and MAX."
-    (mumamo-find-possible-chunk pos min max
-                                'mumamo-search-bw-exc-start-jinja3
-                                'mumamo-search-bw-exc-end-jinja3
-                                'mumamo-search-fw-exc-start-jinja3
-                                'mumamo-search-fw-exc-end-jinja3))
-
-  (defun mumamo-chunk-ambari_jinja2(pos min max)
-    "Find {{ ... }}.  Return range and `jinja-mode'.
-See `mumamo-find-possible-chunk' for POS, MIN and MAX."
-    (mumamo-find-possible-chunk pos min max
-                                'mumamo-search-bw-exc-start-ambari_jinja2
-                                'mumamo-search-bw-exc-end-ambari_jinja2
-                                'mumamo-search-fw-exc-start-ambari_jinja2
-                                'mumamo-search-fw-exc-end-ambari_jinja2))
-
-  (defun mumamo-chunk-jinja (pos min max)
-    "Find {% ... %}.  Return range and `jinja-mode'.
-See `mumamo-find-possible-chunk' for POS, MIN and MAX."
-    (mumamo-find-possible-chunk pos min max
-                                'mumamo-search-bw-exc-start-jinja
-                                'mumamo-search-bw-exc-end-jinja
-                                'mumamo-search-fw-exc-start-jinja
-                                'mumamo-search-fw-exc-end-jinja))
-
-  (defun mumamo-search-bw-exc-start-jinja (pos min)
-    "Helper for `mumamo-chunk-jinja'.
-POS is where to start search and MIN is where to stop."
-    (let ((exc-start (mumamo-chunk-start-bw-str-inc pos min "{%")))
-      (and exc-start
-           (<= exc-start pos)
-           (cons exc-start 'jinja-mode))))
-
-  (defun mumamo-search-bw-exc-start-ambari_jinja2(pos min)
-    "Helper for `mumamo-chunk-ambari_jinja2'.
-POS is where to start search and MIN is where to stop."
-    (let ((exc-start (mumamo-chunk-start-bw-str-inc pos min "{{")))
-      (and exc-start
-           (<= exc-start pos)
-           (cons exc-start 'jinja-mode))))
-
-  (defun mumamo-search-bw-exc-start-jinja3(pos min)
-    "Helper for `mumamo-chunk-jinja3'.
-POS is where to start search and MIN is where to stop."
-    (let ((exc-start (mumamo-chunk-start-bw-str-inc pos min "{#")))
-      (and exc-start
-           (<= exc-start pos)
-           (cons exc-start 'jinja-mode))))
-
-  (defun mumamo-search-bw-exc-end-jinja (pos min)
-    "Helper for `mumamo-chunk-jinja'.
-POS is where to start search and MIN is where to stop."
-    (mumamo-chunk-end-bw-str-inc pos min "%}"))
-
-  (defun mumamo-search-bw-exc-end-ambari_jinja2(pos min)
-    "Helper for `mumamo-chunk-ambari_jinja2'.
-POS is where to start search and MIN is where to stop."
-    (mumamo-chunk-end-bw-str-inc pos min "}}"))
-
-  (defun mumamo-search-bw-exc-end-jinja3(pos min)
-    "Helper for `mumamo-chunk-jinja3'.
-POS is where to start search and MIN is where to stop."
-    (mumamo-chunk-end-bw-str-inc pos min "#}"))
-
-  (defun mumamo-search-fw-exc-start-jinja (pos max)
-    "Helper for `mumamo-chunk-jinja'.
-POS is where to start search and MAX is where to stop."
-    (mumamo-chunk-start-fw-str-inc pos max "{%"))
-
-  (defun mumamo-search-fw-exc-start-ambari_jinja2(pos max)
-    "Helper for `mumamo-chunk-ambari_jinja2'.
-POS is where to start search and MAX is where to stop."
-    (mumamo-chunk-start-fw-str-inc pos max "{{"))
-
-  (defun mumamo-search-fw-exc-start-jinja3(pos max)
-    "Helper for `mumamo-chunk-jinja3'.
-POS is where to start search and MAX is where to stop."
-    (mumamo-chunk-start-fw-str-inc pos max "{#"))
-
-  (defun mumamo-search-fw-exc-end-jinja (pos max)
-    "Helper for `mumamo-chunk-jinja'.
-POS is where to start search and MAX is where to stop."
-    (mumamo-chunk-end-fw-str-inc pos max "%}"))
-
-  (defun mumamo-search-fw-exc-end-ambari_jinja2(pos max)
-    "Helper for `mumamo-chunk-ambari_jinja2'.
-POS is where to start search and MAX is where to stop."
-    (mumamo-chunk-end-fw-str-inc pos max "}}"))
-
-  (defun mumamo-search-fw-exc-end-jinja3(pos max)
-    "Helper for `mumamo-chunk-jinja3'.
-POS is where to start search and MAX is where to stop."
-    (mumamo-chunk-end-fw-str-inc pos max "#}"))
-
-;;;###autoload
-  (define-mumamo-multi-major-mode jinja-html-mumamo
-    "Turn on multiple major modes for Jinja with main mode `html-mode'.
-This also covers inlined style and javascript."
-    ("Jinja HTML Family" html-mode
-     (mumamo-chunk-jinja
-      mumamo-chunk-ambari_jinja2
-      mumamo-chunk-jinja3
-      mumamo-chunk-inlined-style
-      mumamo-chunk-inlined-script
-      mumamo-chunk-style=
-      mumamo-chunk-onjs=
-      )))
-
-;;;###autoload
-  (define-mumamo-multi-major-mode jinja-nxhtml-mumamo
-    "Turn on multiple major modes for Jinja with main mode `nxhtml-mode'.
-This also covers inlined style and javascript."
-    ("Jinja nXhtml Family" nxhtml-mode
-     (mumamo-chunk-jinja
-      mumamo-chunk-ambari_jinja2
-      mumamo-chunk-jinja3
-      mumamo-chunk-inlined-style
-      mumamo-chunk-inlined-script
-      mumamo-chunk-style=
-      mumamo-chunk-onjs=
-      )))
-  )
-
-(provide 'jinja)
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;; jinja.el ends here

ambari-server/src/main/java/org/apache/ambari/server/actionmanager/ActionScheduler.java

@@ -217,15 +217,27 @@ class ActionScheduler implements Runnable {
       }
       int i_stage = 0;
       
-      
       stages = filterParallelPerHostStages(stages);
-      
+
+      boolean exclusiveRequestIsGoing = false;
+      // This loop greatly depends on the fact that order of stages in
+      // a list does not change between invocations
       for (Stage s : stages) {
         // Check if we can process this stage in parallel with another stages
         i_stage ++;
-
         long requestId = s.getRequestId();
         LOG.debug("==> STAGE_i = " + i_stage + "(requestId=" + requestId + ",StageId=" + s.getStageId() + ")");
+        Request request = db.getRequest(requestId);
+
+        if (request.isExclusive()) {
+          if (runningRequestIds.size() > 0 ) {
+            // As a result, we will wait until any previous stages are finished
+            LOG.debug("Stage requires exclusive execution, but other requests are already executing. Stopping for now");
+            break;
+          }
+          exclusiveRequestIsGoing = true;
+        }
+
         if (runningRequestIds.contains(requestId)) {
           // We don't want to process different stages from the same request in parallel
           LOG.debug("==> We don't want to process different stages from the same request in parallel" );
@@ -238,8 +250,6 @@ class ActionScheduler implements Runnable {
           }
         }
 
-        
-
         // Commands that will be scheduled in current scheduler wakeup
         List<ExecutionCommand> commandsToSchedule = new ArrayList<ExecutionCommand>();
         Map<String, RoleStats> roleStats = processInProgressStage(s, commandsToSchedule);
@@ -344,6 +354,12 @@ class ActionScheduler implements Runnable {
         if (! configuration.getParallelStageExecution()) { // If disabled
           return;
         }
+
+        if (exclusiveRequestIsGoing) {
+          // As a result, we will prevent any further stages from being executed
+          LOG.debug("Stage requires exclusive execution, skipping all executing any further stages");
+          break;
+        }
       }
 
       requestsInProgress.retainAll(runningRequestIds);

ambari-server/src/main/java/org/apache/ambari/server/actionmanager/Request.java

@@ -37,7 +37,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import com.google.gson.Gson;
-import com.google.inject.Injector;
 import com.google.inject.assistedinject.Assisted;
 import com.google.inject.assistedinject.AssistedInject;
 
@@ -53,6 +52,15 @@ public class Request {
   private long createTime;
   private long startTime;
   private long endTime;
+
+  /**
+   * If true, this request can not be executed in parallel with any another
+   * requests. That is useful when updating MM state, performing
+   * decommission etc.
+   * Defaults to false.
+   */
+   private boolean exclusive;
+
   /**
    * As of now, this field is not used. Request status is
    * calculated at RequestResourceProvider on the fly.
@@ -75,6 +83,7 @@ public class Request {
     this.createTime = System.currentTimeMillis();
     this.startTime = -1;
     this.endTime = -1;
+    this.exclusive = false;
 
     if (-1L != this.clusterId) {
       try {
@@ -111,6 +120,7 @@ public class Request {
       this.startTime = -1;
       this.endTime = -1;
       this.requestType = RequestType.INTERNAL_REQUEST;
+      this.exclusive = false;
     } else {
       String message = "Attempted to construct request from empty stage collection";
       LOG.error(message);
@@ -132,6 +142,7 @@ public class Request {
       this.inputs = gson.toJson(actionRequest.getParameters());
       this.requestType = actionRequest.isCommand() ? RequestType.COMMAND : RequestType.ACTION;
       this.commandName = actionRequest.isCommand() ? actionRequest.getCommandName() : actionRequest.getActionName();
+      this.exclusive = actionRequest.isExclusive();
     }
   }
 
@@ -159,6 +170,7 @@ public class Request {
     this.createTime = entity.getCreateTime();
     this.startTime = entity.getStartTime();
     this.endTime = entity.getEndTime();
+    this.exclusive = entity.isExclusive();
     this.requestContext = entity.getRequestContext();
     this.inputs = entity.getInputs();
 
@@ -229,6 +241,7 @@ public class Request {
     requestEntity.setCreateTime(createTime);
     requestEntity.setStartTime(startTime);
     requestEntity.setEndTime(endTime);
+    requestEntity.setExclusive(exclusive);
     requestEntity.setRequestContext(requestContext);
     requestEntity.setInputs(inputs);
     requestEntity.setRequestType(requestType);
@@ -384,4 +397,12 @@ public class Request {
   public void setStatus(HostRoleStatus status) {
     this.status = status;
   }
+
+  public boolean isExclusive() {
+    return exclusive;
+  }
+
+  public void setExclusive(boolean isExclusive) {
+    this.exclusive = isExclusive;
+  }
 }

ambari-server/src/main/java/org/apache/ambari/server/api/util/StackExtensionHelper.java

@@ -145,7 +145,9 @@ public class StackExtensionHelper {
     ServiceInfo mergedServiceInfo = new ServiceInfo();
     mergedServiceInfo.setSchemaVersion(childService.getSchemaVersion());
     mergedServiceInfo.setName(childService.getName());
-    mergedServiceInfo.setComment(childService.getComment());
+    mergedServiceInfo.setComment(childService.getComment() != null ?
+        childService.getComment() :
+        parentService.getComment());
     mergedServiceInfo.setVersion(childService.getVersion());
     mergedServiceInfo.setDisplayName(
         childService.getDisplayName() != null ?
@@ -218,12 +220,16 @@ public class StackExtensionHelper {
     mergedServiceInfo.setCustomCommands(mergedCustomCommands);
     
     // metrics
-    if (null == childService.getMetricsFile() && null != parentService.getMetricsFile())
+    if (null != childService.getMetricsFile())
+      mergedServiceInfo.setMetricsFile(childService.getMetricsFile());
+    else if (null != parentService.getMetricsFile())
       mergedServiceInfo.setMetricsFile(parentService.getMetricsFile());
     
     // alerts
-    if (null == childService.getAlertsFile() && null != parentService.getAlertsFile())
-      mergedServiceInfo.setAlertsFile(parentService.getAlertsFile());    
+    if (null != childService.getAlertsFile())
+      mergedServiceInfo.setAlertsFile(childService.getAlertsFile());
+    else if (null != parentService.getAlertsFile())
+      mergedServiceInfo.setAlertsFile(parentService.getAlertsFile());
 
     populateComponents(mergedServiceInfo, parentService, childService);
 
@@ -423,12 +429,24 @@ public class StackExtensionHelper {
     // Map services with unique names
     Map<String, ServiceInfo> serviceInfoMap = new HashMap<String,
       ServiceInfo>();
+    List<ServiceInfo> serviceInfoList = null;
     // Iterate with oldest parent first - all stacks are populated
+    StackInfo parentStack = null;
     while(lt.hasPrevious()) {
-      StackInfo parentStack = lt.previous();
-      List<ServiceInfo> serviceInfoList = parentStack.getServices();
+      if (parentStack == null) {
+        parentStack = lt.previous();
+        serviceInfoList = parentStack.getServices();
+        for (ServiceInfo service : serviceInfoList){
+          if (!service.isDeleted()) {
+            serviceInfoMap.put(service.getName(), service);
+          }
+        }
+        continue;
+      }
+      StackInfo currentStackInfo = lt.previous();
+      serviceInfoList = currentStackInfo.getServices();
       
-      mergeStacks(parentStack, stackInfo);
+      mergeStacks(parentStack, currentStackInfo);
       
       for (ServiceInfo service : serviceInfoList) {
         ServiceInfo existingService = serviceInfoMap.get(service.getName());
@@ -437,7 +455,7 @@ public class StackExtensionHelper {
           continue;
         }
 
-        if (existingService == null) {
+        if (existingService == null && !service.isDeleted()) {
           serviceInfoMap.put(service.getName(), service);
         } else {
           // Redefined service - merge with parent
@@ -465,6 +483,7 @@ public class StackExtensionHelper {
         }
         
       }
+      parentStack = currentStackInfo;
     }
     return new ArrayList<ServiceInfo>(serviceInfoMap.values());
   }

ambari-server/src/main/java/org/apache/ambari/server/controller/ExecuteActionRequest.java

@@ -35,13 +35,15 @@ public class ExecuteActionRequest {
   private RequestOperationLevel operationLevel = null;
   private String actionName;
   private Map<String, String> parameters;
+  private boolean exclusive;
 
   public ExecuteActionRequest(String clusterName, String commandName,
                               String actionName,
                               List<RequestResourceFilter> resourceFilters,
                               RequestOperationLevel operationLevel,
-                              Map<String, String> parameters) {
-    this(clusterName, commandName, parameters);
+                              Map<String, String> parameters,
+                              boolean exclusive) {
+    this(clusterName, commandName, parameters, exclusive);
     this.actionName = actionName;
     if (resourceFilters != null) {
       this.resourceFilters.addAll(resourceFilters);
@@ -53,7 +55,9 @@ public class ExecuteActionRequest {
    * Create an ExecuteActionRequest to execute a command.
    * No filters.
    */
-  public ExecuteActionRequest(String clusterName, String commandName, Map<String, String> parameters) {
+  public ExecuteActionRequest(String clusterName, String commandName,
+                              Map<String, String> parameters,
+                              boolean exclusive) {
     this.clusterName = clusterName;
     this.commandName = commandName;
     this.actionName = null;
@@ -62,6 +66,7 @@ public class ExecuteActionRequest {
       this.parameters.putAll(parameters);
     }
     this.resourceFilters = new ArrayList<RequestResourceFilter>();
+    this.exclusive = exclusive;
   }
 
   public String getClusterName() {
@@ -88,6 +93,14 @@ public class ExecuteActionRequest {
     return parameters;
   }
 
+  public boolean isExclusive() {
+    return exclusive;
+  }
+
+  public void setExclusive(boolean isExclusive) {
+    this.exclusive = isExclusive;
+  }
+
   public Boolean isCommand() {
     return actionName == null || actionName.isEmpty();
   }
@@ -100,6 +113,7 @@ public class ExecuteActionRequest {
         append(", command :" + commandName).
         append(", inputs :" + parameters.toString()).
         append(", resourceFilters: " + resourceFilters).
+        append(", exclusive: " + exclusive).
         append(", clusterName :" + clusterName).toString();
   }
 }

ambari-server/src/main/java/org/apache/ambari/server/controller/MaintenanceStateHelper.java

@@ -279,7 +279,7 @@ public class MaintenanceStateHelper {
     ExecuteActionRequest actionRequest = new ExecuteActionRequest(
       clusterName, null, NAGIOS_ACTION_NAME,
       Collections.singletonList(resourceFilter),
-      level, params);
+      level, params, true);
 
     // createAction() may throw an exception if Nagios is in MS or
     // if Nagios is absent in cluster. This exception is usually ignored at

ambari-server/src/main/java/org/apache/ambari/server/controller/internal/ConfigGroupResourceProvider.java

@@ -211,6 +211,20 @@ public class ConfigGroupResourceProvider extends
     return getRequestStatus(null);
   }
 
+  @Override
+  public Set<String> checkPropertyIds(Set<String> propertyIds) {
+    //allow providing service_config_version_note, but we should not return it for config group
+    Set<String> unsupportedPropertyIds = super.checkPropertyIds(propertyIds);
+    for (Iterator<String> iterator = unsupportedPropertyIds.iterator(); iterator.hasNext(); ) {
+      String next = iterator.next();
+      next = PropertyHelper.getPropertyName(next);
+      if (next.equals("service_config_version_note") || next.equals("/service_config_version_note")) {
+        iterator.remove();
+      }
+    }
+    return unsupportedPropertyIds;
+  }
+
   /**
    * Create configuration group resources based on set of config group requests.
    *
@@ -477,7 +491,8 @@ public class ConfigGroupResourceProvider extends
       configGroup.persist();
       cluster.addConfigGroup(configGroup);
       if (serviceName != null) {
-        cluster.createServiceConfigVersion(serviceName, getManagementController().getAuthName(), null, configGroup);
+        cluster.createServiceConfigVersion(serviceName, getManagementController().getAuthName(),
+          request.getServiceConfigVersionNote(), configGroup);
       } else {
         LOG.warn("Could not determine service name for config group {}, service config version not created",
             configGroup.getId());
@@ -569,7 +584,8 @@ public class ConfigGroupResourceProvider extends
 
       configGroup.persist();
       if (serviceName != null) {
-        cluster.createServiceConfigVersion(serviceName, getManagementController().getAuthName(), null, configGroup);
+        cluster.createServiceConfigVersion(serviceName, getManagementController().getAuthName(),
+          request.getServiceConfigVersionNote(), configGroup);
       } else {
         LOG.warn("Could not determine service name for config group {}, service config version not created",
             configGroup.getId());

ambari-server/src/main/java/org/apache/ambari/server/controller/internal/RequestResourceProvider.java

@@ -70,6 +70,7 @@ public class RequestResourceProvider extends AbstractControllerResourceProvider
   protected static final String REQUEST_CREATE_TIME_ID = "Requests/create_time";
   protected static final String REQUEST_START_TIME_ID = "Requests/start_time";
   protected static final String REQUEST_END_TIME_ID = "Requests/end_time";
+  protected static final String REQUEST_EXCLUSIVE_ID = "Requests/exclusive";
   protected static final String REQUEST_TASK_CNT_ID = "Requests/task_count";
   protected static final String REQUEST_FAILED_TASK_CNT_ID = "Requests/failed_task_count";
   protected static final String REQUEST_ABORTED_TASK_CNT_ID = "Requests/aborted_task_count";
@@ -83,6 +84,7 @@ public class RequestResourceProvider extends AbstractControllerResourceProvider
   protected static final String HOSTS_ID = "hosts";
   protected static final String ACTION_ID = "action";
   protected static final String INPUTS_ID = "parameters";
+  protected static final String EXLUSIVE_ID = "exclusive";
   private static Set<String> pkPropertyIds =
       new HashSet<String>(Arrays.asList(new String[]{
           REQUEST_ID_PROPERTY_ID}));
@@ -317,13 +319,19 @@ public class RequestResourceProvider extends AbstractControllerResourceProvider
         params.put(key.substring(keyPrefix.length()), requestInfoProperties.get(key));
       }
     }
+
+    boolean exclusive = false;
+    if (requestInfoProperties.containsKey(EXLUSIVE_ID)) {
+      exclusive = Boolean.valueOf(requestInfoProperties.get(EXLUSIVE_ID).trim());
+    }
+
     return new ExecuteActionRequest(
       (String) propertyMap.get(REQUEST_CLUSTER_NAME_PROPERTY_ID),
       commandName,
       actionName,
       resourceFilterList,
       operationLevel,
-      params);
+      params, exclusive);
   }
 
   // Get all of the request resources for the given properties
@@ -422,6 +430,8 @@ public class RequestResourceProvider extends AbstractControllerResourceProvider
     setResourceProperty(resource, REQUEST_CREATE_TIME_ID, request.getCreateTime(), requestedPropertyIds);
     setResourceProperty(resource, REQUEST_START_TIME_ID, request.getStartTime(), requestedPropertyIds);
     setResourceProperty(resource, REQUEST_END_TIME_ID, request.getEndTime(), requestedPropertyIds);
+    setResourceProperty(resource, REQUEST_EXCLUSIVE_ID, request.isExclusive(), requestedPropertyIds);
+
     if (request.getRequestScheduleId() != null) {
       setResourceProperty(resource, REQUEST_SOURCE_SCHEDULE_ID, request.getRequestScheduleId(), requestedPropertyIds);
     } else {

ambari-server/src/main/java/org/apache/ambari/server/orm/entities/RequestEntity.java

@@ -84,6 +84,10 @@ public class RequestEntity {
   @Column(name = "end_time", nullable = false)
   private Long endTime = -1L;
 
+  @Basic
+  @Column(name = "exclusive_execution", insertable = true, updatable = true, nullable = false)
+  private Integer exclusive = 0;
+
   @OneToMany(mappedBy = "request")
   private Collection<StageEntity> stages;
 
@@ -145,6 +149,14 @@ public class RequestEntity {
     this.endTime = endTime;
   }
 
+  public Boolean isExclusive() {
+    return exclusive == 0 ? false : true;
+  }
+
+  public void setExclusive(Boolean exclusive) {
+    this.exclusive = (exclusive == false ? 0 : 1);
+  }
+
   public String getInputs() {
     return inputs != null ? new String(inputs) : null;
   }

ambari-server/src/main/java/org/apache/ambari/server/upgrade/UpgradeCatalog170.java

@@ -286,6 +286,10 @@ public class UpgradeCatalog170 extends AbstractUpgradeCatalog {
 
     addAlertingFrameworkDDL();
 
+    // Exclusive requests changes
+    dbAccessor.addColumn("request", new DBColumnInfo(
+            "exclusive_execution", Integer.class, 1, 0, false));
+
     //service config versions changes
 
     //remove old artifacts (for versions <=1.4.1) which depend on tables changed

ambari-server/src/main/java/org/apache/ambari/server/view/ViewRegistry.java

@@ -28,7 +28,6 @@ import org.apache.ambari.server.api.resources.ViewExternalSubResourceDefinition;
 import org.apache.ambari.server.api.services.ViewExternalSubResourceService;
 import org.apache.ambari.server.api.services.ViewSubResourceService;
 import org.apache.ambari.server.configuration.Configuration;
-import org.apache.ambari.server.controller.ControllerModule;
 import org.apache.ambari.server.controller.spi.Resource;
 import org.apache.ambari.server.orm.dao.MemberDAO;
 import org.apache.ambari.server.orm.dao.PrivilegeDAO;
@@ -101,6 +100,7 @@ public class ViewRegistry {
    * Constants
    */
   private static final String EXTRACTED_ARCHIVES_DIR = "work";
+  private static final String EXTRACT_COMMAND = "extract";
 
   /**
    * Thread pool
@@ -219,15 +219,31 @@ public class ViewRegistry {
    * Registry main method.
    *
    * @param args  the command line arguments
-   *
-   * @throws Exception if the registry command can not be completed
    */
-  public static void main(String[] args) throws Exception {
+  public static void main(String[] args) {
+
+    if (args.length >= 2) {
+      String archivePath = args[1];
+
+      try {
+        Injector injector = Guice.createInjector();
 
-    Injector injector = Guice.createInjector(new ControllerModule());
-    initInstance(injector.getInstance(ViewRegistry.class));
+        ViewExtractor      extractor      = injector.getInstance(ViewExtractor.class);
+        ViewArchiveUtility archiveUtility = injector.getInstance(ViewArchiveUtility.class);
+        Configuration      configuration  = injector.getInstance(Configuration.class);
 
-    singleton.readViewArchives(true, false);
+        if (args[0].equals(EXTRACT_COMMAND)) {
+          if (extractViewArchive(archivePath, extractor, archiveUtility, configuration, true)) {
+            System.exit(0);
+          }
+        }
+      } catch (Exception e) {
+        String msg = "Caught exception extracting view archive " + archivePath + ".";
+        LOG.error(msg, e);
+        System.exit(2);
+      }
+    }
+    System.exit(1);
   }
 
   /**
@@ -1229,6 +1245,43 @@ public class ViewRegistry {
     }
   }
 
+  // extract the view archive for the given path.
+  protected static boolean extractViewArchive(String archivePath,
+                                            ViewExtractor extractor,
+                                            ViewArchiveUtility archiveUtility,
+                                            Configuration configuration,
+                                            boolean systemOnly ) throws Exception {
+
+    File viewDir = configuration.getViewsDir();
+
+    String extractedArchivesPath = viewDir.getAbsolutePath() +
+        File.separator + EXTRACTED_ARCHIVES_DIR;
+
+    if (extractor.ensureExtractedArchiveDirectory(extractedArchivesPath)) {
+
+      File archiveFile = archiveUtility.getFile(archivePath);
+
+      ViewConfig viewConfig = archiveUtility.getViewConfigFromArchive(archiveFile);
+
+      String commonName = viewConfig.getName();
+      String version    = viewConfig.getVersion();
+      String viewName   = ViewEntity.getViewName(commonName, version);
+
+      String extractedArchiveDirPath = extractedArchivesPath + File.separator + viewName;
+      File   extractedArchiveDirFile = archiveUtility.getFile(extractedArchiveDirPath);
+
+      if (!extractedArchiveDirFile.exists()) {
+        ViewEntity viewDefinition = new ViewEntity(viewConfig, configuration, extractedArchiveDirPath);
+
+        if (!systemOnly || viewDefinition.isSystem()) {
+          extractor.extractViewArchive(viewDefinition, archiveFile, extractedArchiveDirFile);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   // set the status of the given view.
   private void setViewStatus(ViewEntity viewDefinition, ViewEntity.ViewStatus status, String statusDetail) {
     viewDefinition.setStatus(status);

ambari-server/src/main/python/ambari-server.py

@@ -189,7 +189,7 @@ STACK_UPGRADE_HELPER_CMD = "{0}" + os.sep + "bin" + os.sep + "java -cp {1}" +\
 
 VIEW_EXTRACT_CMD = "{0}" + os.sep + "bin" + os.sep + "java -cp {1}" +\
                           os.pathsep + "{2} " +\
-                          "org.apache.ambari.server.view.ViewRegistry " +\
+                          "org.apache.ambari.server.view.ViewRegistry extract {3} " +\
                           "> " + SERVER_OUT_FILE + " 2>&1"
 
 
@@ -283,6 +283,9 @@ JDBC_HOSTNAME_PROPERTY = "server.jdbc.hostname"
 JDBC_PORT_PROPERTY = "server.jdbc.port"
 JDBC_POSTGRES_SCHEMA_PROPERTY = "server.jdbc.postgres.schema"   # Only for postgres, defaults to same value as DB name
 
+VIEWS_DIR_PROPERTY = "views.dir"
+DEFAULT_VIEWS_DIR = "/var/lib/ambari-server/resources/views"
+
 JDBC_USER_NAME_PROPERTY = "server.jdbc.user.name"
 JDBC_PASSWORD_PROPERTY = "server.jdbc.user.passwd"
 JDBC_PASSWORD_FILENAME = "password.dat"
@@ -1225,6 +1228,7 @@ def prompt_db_properties(args):
 
 # extract the system views
 def extract_views():
+
   jdk_path = find_jdk()
   if jdk_path is None:
     print_error_msg("No JDK found, please run the \"setup\" "
@@ -1232,12 +1236,36 @@ def extract_views():
                     "JDK manually to " + JDK_INSTALL_DIR)
     return 1
 
-  command = VIEW_EXTRACT_CMD.format(jdk_path, get_conf_dir(),
-    get_ambari_classpath())
-  (retcode, stdout, stderr) = run_os_command(command)
-  print_info_msg("Return code from view extraction: " +
-                 str(retcode))
-  return retcode
+  properties = get_ambari_properties()
+  if properties == -1:
+    print_error_msg("Error getting ambari properties")
+    return -1
+
+  if not VIEWS_DIR_PROPERTY in properties.keys():
+    vdir = DEFAULT_VIEWS_DIR
+  else:
+    vdir = properties.get_property(VIEWS_DIR_PROPERTY)
+
+  files = [f for f in os.listdir(vdir) if os.path.isfile(os.path.join(vdir,f))]
+  for f in files:
+
+    command = VIEW_EXTRACT_CMD.format(jdk_path, get_conf_dir(),
+      get_ambari_classpath(), os.path.join(vdir,f))
+
+    retcode, stdout, stderr = run_os_command(command)
+    if retcode == 0:
+      sys.stdout.write(f + "\n")
+    elif retcode == 2:
+      sys.stdout.write("Error extracting " + f + "\n")
+    else:
+      sys.stdout.write(".")
+      sys.stdout.flush()
+
+    print_info_msg("Return code from extraction of view archive " + f + ": " +
+                   str(retcode))
+
+  sys.stdout.write("\n")
+  return 0
 
 # Store set of properties for remote database connection
 def store_remote_properties(args):

ambari-server/src/main/resources/Ambari-DDL-MySQL-CREATE.sql

@@ -46,7 +46,7 @@ CREATE TABLE execution_command (task_id BIGINT NOT NULL, command LONGBLOB, PRIMA
 CREATE TABLE host_role_command (task_id BIGINT NOT NULL, attempt_count SMALLINT NOT NULL, event LONGTEXT NOT NULL, exitcode INTEGER NOT NULL, host_name VARCHAR(255) NOT NULL, last_attempt_time BIGINT NOT NULL, request_id BIGINT NOT NULL, role VARCHAR(255), role_command VARCHAR(255), stage_id BIGINT NOT NULL, start_time BIGINT NOT NULL, end_time BIGINT, status VARCHAR(255), std_error LONGBLOB, std_out LONGBLOB, output_log VARCHAR(255) NULL, error_log VARCHAR(255) NULL, structured_out LONGBLOB, command_detail VARCHAR(255), custom_command_name VARCHAR(255), PRIMARY KEY (task_id));
 CREATE TABLE role_success_criteria (role VARCHAR(255) NOT NULL, request_id BIGINT NOT NULL, stage_id BIGINT NOT NULL, success_factor DOUBLE NOT NULL, PRIMARY KEY (role, request_id, stage_id));
 CREATE TABLE stage (stage_id BIGINT NOT NULL, request_id BIGINT NOT NULL, cluster_id BIGINT, log_info VARCHAR(255) NOT NULL, request_context VARCHAR(255), cluster_host_info LONGBLOB, command_params LONGBLOB, host_params LONGBLOB, PRIMARY KEY (stage_id, request_id));
-CREATE TABLE request (request_id BIGINT NOT NULL, cluster_id BIGINT, request_schedule_id BIGINT, command_name VARCHAR(255), create_time BIGINT NOT NULL, end_time BIGINT NOT NULL, inputs LONGBLOB, request_context VARCHAR(255), request_type VARCHAR(255), start_time BIGINT NOT NULL, status VARCHAR(255), PRIMARY KEY (request_id));
+CREATE TABLE request (request_id BIGINT NOT NULL, cluster_id BIGINT, request_schedule_id BIGINT, command_name VARCHAR(255), create_time BIGINT NOT NULL, end_time BIGINT NOT NULL, exclusive_execution TINYINT(1) NOT NULL DEFAULT 0, inputs LONGBLOB, request_context VARCHAR(255), request_type VARCHAR(255), start_time BIGINT NOT NULL, status VARCHAR(255), PRIMARY KEY (request_id));
 CREATE TABLE requestresourcefilter (filter_id BIGINT NOT NULL, request_id BIGINT NOT NULL, service_name VARCHAR(255), component_name VARCHAR(255), hosts LONGBLOB, PRIMARY KEY (filter_id));
 CREATE TABLE requestoperationlevel (operation_level_id BIGINT NOT NULL, request_id BIGINT NOT NULL, level_name VARCHAR(255), cluster_name VARCHAR(255), service_name VARCHAR(255), host_component_name VARCHAR(255), host_name VARCHAR(255), PRIMARY KEY (operation_level_id));
 CREATE TABLE key_value_store (`key` VARCHAR(255), `value` LONGTEXT, PRIMARY KEY (`key`));

ambari-server/src/main/resources/Ambari-DDL-Oracle-CREATE.sql

@@ -37,7 +37,7 @@ CREATE TABLE execution_command (task_id NUMBER(19) NOT NULL, command BLOB NULL,
 CREATE TABLE host_role_command (task_id NUMBER(19) NOT NULL, attempt_count NUMBER(5) NOT NULL, event CLOB NULL, exitcode NUMBER(10) NOT NULL, host_name VARCHAR2(255) NOT NULL, last_attempt_time NUMBER(19) NOT NULL, request_id NUMBER(19) NOT NULL, role VARCHAR2(255) NULL, role_command VARCHAR2(255) NULL, stage_id NUMBER(19) NOT NULL, start_time NUMBER(19) NOT NULL, end_time NUMBER(19), status VARCHAR2(255) NULL, std_error BLOB NULL, std_out BLOB NULL, output_log VARCHAR2(255) NULL, error_log VARCHAR2(255) NULL, structured_out BLOB NULL,  command_detail VARCHAR2(255) NULL, custom_command_name VARCHAR2(255) NULL, PRIMARY KEY (task_id));
 CREATE TABLE role_success_criteria (role VARCHAR2(255) NOT NULL, request_id NUMBER(19) NOT NULL, stage_id NUMBER(19) NOT NULL, success_factor NUMBER(19,4) NOT NULL, PRIMARY KEY (role, request_id, stage_id));
 CREATE TABLE stage (stage_id NUMBER(19) NOT NULL, request_id NUMBER(19) NOT NULL, cluster_id NUMBER(19) NULL, log_info VARCHAR2(255) NULL, request_context VARCHAR2(255) NULL, cluster_host_info BLOB NOT NULL, command_params BLOB, host_params BLOB, PRIMARY KEY (stage_id, request_id));
-CREATE TABLE request (request_id NUMBER(19) NOT NULL, cluster_id NUMBER(19), request_schedule_id NUMBER(19), command_name VARCHAR(255), create_time NUMBER(19) NOT NULL, end_time NUMBER(19) NOT NULL, inputs BLOB, request_context VARCHAR(255), request_type VARCHAR(255), start_time NUMBER(19) NOT NULL, status VARCHAR(255), PRIMARY KEY (request_id));
+CREATE TABLE request (request_id NUMBER(19) NOT NULL, cluster_id NUMBER(19), request_schedule_id NUMBER(19), command_name VARCHAR(255), create_time NUMBER(19) NOT NULL, end_time NUMBER(19) NOT NULL, exclusive_execution NUMBER(1) DEFAULT 0 NOT NULL, inputs BLOB, request_context VARCHAR(255), request_type VARCHAR(255), start_time NUMBER(19) NOT NULL, status VARCHAR(255), PRIMARY KEY (request_id));
 CREATE TABLE requestresourcefilter (filter_id NUMBER(19) NOT NULL, request_id NUMBER(19) NOT NULL, service_name VARCHAR2(255), component_name VARCHAR2(255), hosts BLOB, PRIMARY KEY (filter_id));
 CREATE TABLE requestoperationlevel (operation_level_id NUMBER(19) NOT NULL, request_id NUMBER(19) NOT NULL, level_name VARCHAR2(255), cluster_name VARCHAR2(255), service_name VARCHAR2(255), host_component_name VARCHAR2(255), host_name VARCHAR2(255), PRIMARY KEY (operation_level_id));
 CREATE TABLE key_value_store ("key" VARCHAR2(255) NOT NULL, "value" CLOB NULL, PRIMARY KEY ("key"));

ambari-server/src/main/resources/Ambari-DDL-Postgres-CREATE.sql

@@ -59,7 +59,7 @@ CREATE TABLE role_success_criteria (role VARCHAR(255) NOT NULL, request_id BIGIN
 
 CREATE TABLE stage (stage_id BIGINT NOT NULL, request_id BIGINT NOT NULL, cluster_id BIGINT NOT NULL, log_info VARCHAR(255) NOT NULL, request_context VARCHAR(255), cluster_host_info BYTEA NOT NULL, command_params BYTEA, host_params BYTEA, PRIMARY KEY (stage_id, request_id));
 
-CREATE TABLE request (request_id BIGINT NOT NULL, cluster_id BIGINT, command_name VARCHAR(255), create_time BIGINT NOT NULL, end_time BIGINT NOT NULL, inputs BYTEA, request_context VARCHAR(255), request_type VARCHAR(255), request_schedule_id BIGINT, start_time BIGINT NOT NULL, status VARCHAR(255), PRIMARY KEY (request_id));
+CREATE TABLE request (request_id BIGINT NOT NULL, cluster_id BIGINT, command_name VARCHAR(255), create_time BIGINT NOT NULL, end_time BIGINT NOT NULL, exclusive_execution SMALLINT NOT NULL DEFAULT 0, inputs BYTEA, request_context VARCHAR(255), request_type VARCHAR(255), request_schedule_id BIGINT, start_time BIGINT NOT NULL, status VARCHAR(255), PRIMARY KEY (request_id));
 
 CREATE TABLE requestresourcefilter (filter_id BIGINT NOT NULL, request_id BIGINT NOT NULL, service_name VARCHAR(255), component_name VARCHAR(255), hosts BYTEA, PRIMARY KEY (filter_id));
 

ambari-server/src/main/resources/Ambari-DDL-Postgres-EMBEDDED-CREATE.sql

@@ -91,7 +91,7 @@ GRANT ALL PRIVILEGES ON TABLE ambari.role_success_criteria TO :username;
 CREATE TABLE ambari.stage (stage_id BIGINT NOT NULL, request_id BIGINT NOT NULL, cluster_id BIGINT NOT NULL, log_info VARCHAR(255) NOT NULL, request_context VARCHAR(255), cluster_host_info BYTEA NOT NULL, command_params BYTEA, host_params BYTEA, PRIMARY KEY (stage_id, request_id));
 GRANT ALL PRIVILEGES ON TABLE ambari.stage TO :username;
 
-CREATE TABLE ambari.request (request_id BIGINT NOT NULL, cluster_id BIGINT, command_name VARCHAR(255), create_time BIGINT NOT NULL, end_time BIGINT NOT NULL, inputs BYTEA, request_context VARCHAR(255), request_type VARCHAR(255), request_schedule_id BIGINT, start_time BIGINT NOT NULL, status VARCHAR(255), PRIMARY KEY (request_id));
+CREATE TABLE ambari.request (request_id BIGINT NOT NULL, cluster_id BIGINT, command_name VARCHAR(255), create_time BIGINT NOT NULL, end_time BIGINT NOT NULL, exclusive_execution SMALLINT NOT NULL DEFAULT 0, inputs BYTEA, request_context VARCHAR(255), request_type VARCHAR(255), request_schedule_id BIGINT, start_time BIGINT NOT NULL, status VARCHAR(255), PRIMARY KEY (request_id));
 GRANT ALL PRIVILEGES ON TABLE ambari.request TO :username;
 
 CREATE TABLE ambari.requestresourcefilter (filter_id BIGINT NOT NULL, request_id BIGINT NOT NULL, service_name VARCHAR(255), component_name VARCHAR(255), hosts BYTEA, PRIMARY KEY (filter_id));

ambari-server/src/main/resources/properties.json

@@ -130,6 +130,7 @@
         "Requests/create_time",
         "Requests/start_time",
         "Requests/end_time",
+        "Requests/exclusive",
         "Requests/task_count",
         "Requests/failed_task_count",
         "Requests/aborted_task_count",

ambari-server/src/main/resources/stacks/HDP/1.3.2/services/HDFS/package/scripts/service_check.py

@@ -32,7 +32,7 @@ class HdfsServiceCheck(Script):
     safemode_command = "dfsadmin -safemode get | grep OFF"
 
     create_dir_cmd = format("fs -mkdir {dir} ; hadoop fs -chmod 777 {dir}")
-    test_dir_exists = format("hadoop fs -test -e {dir}")
+    test_dir_exists = format("su - {smoke_user} -c 'hadoop fs -test -e {dir}'")
     cleanup_cmd = format("fs -rm {tmp_file}")
     #cleanup put below to handle retries; if retrying there wil be a stale file
     #that needs cleanup; exit code is fn of second command

ambari-server/src/main/resources/stacks/HDP/1.3.2/services/HIVE/configuration/hive-site.xml

@@ -257,4 +257,23 @@ limitations under the License.
     </description>
   </property>
 
+  <property>
+    <name>hive.server2.support.dynamic.service.discovery</name>
+    <value>false</value>
+    <description>Whether HiveServer2 supports dynamic service discovery for its
+      clients. To support this, each instance of HiveServer2 currently uses
+      ZooKeeper to register itself, when it is brought up. JDBC/ODBC clients
+      should use the ZooKeeper ensemble: hive.zookeeper.quorum in their
+      connection string.
+    </description>
+  </property>
+
+  <property>
+    <name>hive.server2.zookeeper.namespace</name>
+    <value>hiveserver2</value>
+    <description>The parent node in ZooKeeper used by HiveServer2 when
+      supporting dynamic service discovery.
+    </description>
+  </property>
+
 </configuration>

ambari-server/src/main/resources/stacks/HDP/2.0.6/services/HDFS/package/scripts/service_check.py

@@ -33,7 +33,7 @@ class HdfsServiceCheck(Script):
 
     create_dir_cmd = format("fs -mkdir {dir}")
     chmod_command = format("fs -chmod 777 {dir}")
-    test_dir_exists = format("hadoop --config {hadoop_conf_dir} fs -test -e {dir}")
+    test_dir_exists = format("su - {smoke_user} -c 'hadoop --config {hadoop_conf_dir} fs -test -e {dir}'")
     cleanup_cmd = format("fs -rm {tmp_file}")
     #cleanup put below to handle retries; if retrying there wil be a stale file
     #that needs cleanup; exit code is fn of second command

ambari-server/src/main/resources/stacks/HDP/2.0.6/services/HIVE/configuration/hive-site.xml

@@ -309,4 +309,23 @@ limitations under the License.
     </description>
   </property>
 
+  <property>
+    <name>hive.server2.support.dynamic.service.discovery</name>
+    <value>false</value>
+    <description>Whether HiveServer2 supports dynamic service discovery for its
+      clients. To support this, each instance of HiveServer2 currently uses
+      ZooKeeper to register itself, when it is brought up. JDBC/ODBC clients
+      should use the ZooKeeper ensemble: hive.zookeeper.quorum in their
+      connection string.
+    </description>
+  </property>
+
+  <property>
+    <name>hive.server2.zookeeper.namespace</name>
+    <value>hiveserver2</value>
+    <description>The parent node in ZooKeeper used by HiveServer2 when
+      supporting dynamic service discovery.
+    </description>
+  </property>
+
 </configuration>

ambari-server/src/main/resources/stacks/HDP/2.0/role_command_order.json

@@ -23,7 +23,7 @@
     "OOZIE_SERVICE_CHECK-SERVICE_CHECK": ["OOZIE_SERVER-START", "MAPREDUCE2_SERVICE_CHECK-SERVICE_CHECK"],
     "WEBHCAT_SERVICE_CHECK-SERVICE_CHECK": ["WEBHCAT_SERVER-START"],
     "HBASE_SERVICE_CHECK-SERVICE_CHECK": ["HBASE_MASTER-START", "HBASE_REGIONSERVER-START"],
-    "HIVE_SERVICE_CHECK-SERVICE_CHECK": ["HIVE_SERVER-START", "HIVE_METASTORE-START"],
+    "HIVE_SERVICE_CHECK-SERVICE_CHECK": ["HIVE_SERVER-START", "HIVE_METASTORE-START", "WEBHCAT_SERVER-START"],
     "HCAT_SERVICE_CHECK-SERVICE_CHECK": ["HIVE_SERVER-START"],
     "PIG_SERVICE_CHECK-SERVICE_CHECK": ["RESOURCEMANAGER-START", "NODEMANAGER-START"],
     "SQOOP_SERVICE_CHECK-SERVICE_CHECK": ["RESOURCEMANAGER-START", "NODEMANAGER-START"],

ambari-server/src/main/resources/stacks/HDP/2.0/services/HBASE/metainfo.xml

@@ -20,9 +20,6 @@
   <services>
     <service>
       <name>HBASE</name>
-      <comment>Non-relational distributed database and centralized service for configuration management &amp;
-        synchronization
-      </comment>
       <version>0.96.0.2.0</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.0/services/HDFS/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>HDFS</name>
-      <comment>Apache Hadoop Distributed File System</comment>
       <version>2.1.0.2.0</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.0/services/HIVE/metainfo.xml

@@ -20,12 +20,6 @@
   <services>
     <service>
       <name>HIVE</name>
-      <comment>Data warehouse system for ad-hoc queries &amp; analysis of large datasets and table &amp; storage management service</comment>
-      <version>0.12.0.2.0</version>
-    </service>
-    <service>
-      <name>HCATALOG</name>
-      <comment>This is comment for HCATALOG service</comment>
       <version>0.12.0.2.0</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.0/services/OOZIE/metainfo.xml

@@ -20,9 +20,6 @@
   <services>
     <service>
       <name>OOZIE</name>
-      <comment>System for workflow coordination and execution of Apache Hadoop jobs.
-        This also includes the installation of the optional Oozie Web Console which relies on and will install the &lt;a target="_blank" href="http://www.sencha.com/legal/open-source-faq/"&gt;ExtJS&lt;/a&gt; Library.
-      </comment>
       <version>4.0.0.2.0</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.0/services/PIG/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>PIG</name>
-      <comment>Scripting platform for analyzing large datasets</comment>
       <version>0.12.0.2.0</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.0/services/SQOOP/metainfo.xml

@@ -20,9 +20,6 @@
   <services>
     <service>
       <name>SQOOP</name>
-      <comment>Tool for transferring bulk data between Apache Hadoop and
-        structured data stores such as relational databases
-      </comment>
       <version>1.4.4.2.0</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.0/services/WEBHCAT/metainfo.xml

@@ -1,27 +0,0 @@
-<?xml version="1.0"?>
-<!--
-   Licensed to the Apache Software Foundation (ASF) under one or more
-   contributor license agreements.  See the NOTICE file distributed with
-   this work for additional information regarding copyright ownership.
-   The ASF licenses this file to You under the Apache License, Version 2.0
-   (the "License"); you may not use this file except in compliance with
-   the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
--->
-<metainfo>
-  <schemaVersion>2.0</schemaVersion>
-  <services>
-    <service>
-      <name>WEBHCAT</name>
-      <comment>This is comment for WEBHCAT service</comment>
-      <version>0.12.0.2.0</version>
-    </service>
-  </services>
-</metainfo>

ambari-server/src/main/resources/stacks/HDP/2.0/services/YARN/metainfo.xml

@@ -21,12 +21,10 @@
   <services>
     <service>
       <name>YARN</name>
-      <comment>Apache Hadoop NextGen MapReduce (YARN)</comment>
       <version>2.1.0.2.0</version>
     </service>
     <service>
       <name>MAPREDUCE2</name>
-      <comment>Apache Hadoop NextGen MapReduce (YARN)</comment>
       <version>2.1.0.2.0</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.0/services/ZOOKEEPER/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>ZOOKEEPER</name>
-      <comment>Centralized service which provides highly reliable distributed coordination</comment>
       <version>3.4.5.2.0</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.1.GlusterFS/services/GLUSTERFS/configuration/hadoop-env.xml

@@ -81,11 +81,13 @@
     <value>hdfs</value>
     <description>User to run HDFS as</description>
   </property>
+  <!--
   <property>
     <name>user_group</name>
     <value>hadoop</value>
     <description>Proxy user group.</description>
   </property>
+  -->
     <!-- hadoop-env.sh -->
   <property>
     <name>content</name>

ambari-server/src/main/resources/stacks/HDP/2.1.GlusterFS/services/HIVE/configuration/hive-site.xml

@@ -480,4 +480,23 @@ limitations under the License.
     </description>
   </property>
 
+  <property>
+    <name>hive.server2.support.dynamic.service.discovery</name>
+    <value>false</value>
+    <description>Whether HiveServer2 supports dynamic service discovery for its
+      clients. To support this, each instance of HiveServer2 currently uses
+      ZooKeeper to register itself, when it is brought up. JDBC/ODBC clients
+      should use the ZooKeeper ensemble: hive.zookeeper.quorum in their
+      connection string.
+    </description>
+  </property>
+
+  <property>
+    <name>hive.server2.zookeeper.namespace</name>
+    <value>hiveserver2</value>
+    <description>The parent node in ZooKeeper used by HiveServer2 when
+      supporting dynamic service discovery.
+    </description>
+  </property>
+
 </configuration>

ambari-server/src/main/resources/stacks/HDP/2.1.GlusterFS/services/YARN/configuration/core-site.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0"?>
-<?xml-stylesheet type="text/xsl" href="configuration.xsl"?>
-<!--
-   Licensed to the Apache Software Foundation (ASF) under one or more
-   contributor license agreements.  See the NOTICE file distributed with
-   this work for additional information regarding copyright ownership.
-   The ASF licenses this file to You under the Apache License, Version 2.0
-   (the "License"); you may not use this file except in compliance with
-   the License.  You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
--->
-<configuration supports_final="true">
-</configuration>

ambari-server/src/main/resources/stacks/HDP/2.1/services/FLUME/metainfo.xml

@@ -19,8 +19,7 @@
   <schemaVersion>2.0</schemaVersion>
   <services>
     <service>
-      <name>FLUME</name>
-      <comment>Data management and processing platform</comment>
+      <name>FLUME</name>>
       <version>1.4.0.2.1</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.1/services/HBASE/metainfo.xml

@@ -20,9 +20,6 @@
   <services>
     <service>
       <name>HBASE</name>
-      <comment>Non-relational distributed database and centralized service for configuration management &amp;
-        synchronization
-      </comment>
       <version>0.98.0.2.1</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.1/services/HDFS/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>HDFS</name>
-      <comment>Apache Hadoop Distributed File System</comment>
       <version>2.4.0.2.1</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.1/services/HIVE/configuration/hive-site.xml

@@ -514,4 +514,23 @@ limitations under the License.
       </description>
   </property>
 
+  <property>
+    <name>hive.server2.support.dynamic.service.discovery</name>
+    <value>false</value>
+    <description>Whether HiveServer2 supports dynamic service discovery for its
+      clients. To support this, each instance of HiveServer2 currently uses
+      ZooKeeper to register itself, when it is brought up. JDBC/ODBC clients
+      should use the ZooKeeper ensemble: hive.zookeeper.quorum in their
+      connection string.
+    </description>
+  </property>
+
+  <property>
+    <name>hive.server2.zookeeper.namespace</name>
+    <value>hiveserver2</value>
+    <description>The parent node in ZooKeeper used by HiveServer2 when
+      supporting dynamic service discovery.
+    </description>
+  </property>
+
 </configuration>

ambari-server/src/main/resources/stacks/HDP/2.1/services/HIVE/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>HIVE</name>
-      <comment>Data warehouse system for ad-hoc queries &amp; analysis of large datasets and table &amp; storage management service</comment>
       <version>0.13.0.2.1</version>
 
       <components>

ambari-server/src/main/resources/stacks/HDP/2.1/services/NAGIOS/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>NAGIOS</name>
-      <comment>Nagios Monitoring and Alerting system</comment>
       <version>3.5.0</version>
       <components>
         <component>

ambari-server/src/main/resources/stacks/HDP/2.1/services/OOZIE/metainfo.xml

@@ -20,8 +20,6 @@
   <services>
     <service>
       <name>OOZIE</name>
-      <comment>System for workflow coordination and execution of Apache Hadoop jobs.  This also includes the installation of the optional Oozie Web Console which relies on and will install the &lt;a target="_blank" href="http://www.sencha.com/legal/open-source-faq/"&gt;ExtJS&lt;/a&gt; Library.
-      </comment>
       <version>4.0.0.2.1</version>
 
       <osSpecifics>

ambari-server/src/main/resources/stacks/HDP/2.1/services/PIG/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>PIG</name>
-      <comment>Scripting platform for analyzing large datasets</comment>
       <version>0.12.1.2.1</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.1/services/SQOOP/metainfo.xml

@@ -20,9 +20,6 @@
   <services>
     <service>
       <name>SQOOP</name>
-      <comment>Tool for transferring bulk data between Apache Hadoop and
-        structured data stores such as relational databases
-      </comment>
       <version>1.4.4.2.1</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.1/services/YARN/metainfo.xml

@@ -22,7 +22,6 @@
     <service>
       <name>YARN</name>
       <displayName>YARN</displayName>
-      <comment>Apache Hadoop NextGen MapReduce (YARN)</comment>
       <version>2.4.0.2.1</version>
       <components>
 

ambari-server/src/main/resources/stacks/HDP/2.1/services/ZOOKEEPER/metainfo.xml

@@ -20,8 +20,6 @@
   <services>
     <service>
       <name>ZOOKEEPER</name>
-      <comment>Centralized service which provides highly reliable distributed
-        coordination.</comment>
       <version>3.4.5.2.1</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.2.1/repos/repoinfo.xml

@@ -42,7 +42,7 @@
   </os>
   <os type="suse11">
     <repo>
-      <baseurl>http://dev.hortonworks.com.s3.amazonaws.com/HDP/sles11sp1/2.x/updates/2.2.0.0</baseurl>
+      <baseurl>http://dev.hortonworks.com.s3.amazonaws.com/HDP/suse11sp3/2.x/updates/2.2.0.0</baseurl>
       <repoid>HDP-2.2.1</repoid>
       <reponame>HDP</reponame>
     </repo>

ambari-server/src/main/resources/stacks/HDP/2.2.1/services/HDFS/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>HDFS</name>
-      <comment>Apache Hadoop Distributed File System</comment>
       <version>2.6.0.2.2</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.2.1/services/HIVE/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>HIVE</name>
-      <comment>Data warehouse system for ad-hoc queries &amp; analysis of large datasets and table &amp; storage management service</comment>
       <version>0.14.0.2.2</version>
     </service>
   </services>

ambari-server/src/main/resources/stacks/HDP/2.2/services/FALCON/metainfo.xml

@@ -21,7 +21,6 @@
     <service>
       <name>FALCON</name>
       <displayName>Falcon</displayName>
-      <comment>Data management and processing platform</comment>
       <version>0.6.0.2.2.9.9</version>
       <osSpecifics>
         <osSpecific>

ambari-server/src/main/resources/stacks/HDP/2.2/services/FLUME/metainfo.xml

@@ -21,7 +21,6 @@
     <service>
       <name>FLUME</name>
       <displayName>Flume</displayName>
-      <comment>Data management and processing platform</comment>
       <version>1.5.0.1.2.9.9.9</version>
 
       <osSpecifics>

ambari-server/src/main/resources/stacks/HDP/2.2/services/HBASE/metainfo.xml

@@ -21,9 +21,6 @@
     <service>
       <name>HBASE</name>
       <displayName>HBase</displayName>
-      <comment>Non-relational distributed database and centralized service for configuration management &amp;
-        synchronization
-      </comment>
       <version>0.98.4.2.9.9.9</version>
 
       <osSpecifics>

ambari-server/src/main/resources/stacks/HDP/2.2/services/HDFS/metainfo.xml

@@ -21,7 +21,6 @@
     <service>
       <name>HDFS</name>
       <displayName>HDFS</displayName>
-      <comment>Apache Hadoop Distributed File System</comment>
       <version>2.6.0.2.9.9.9</version>
 
       <osSpecifics>

ambari-server/src/main/resources/stacks/HDP/2.2/services/HIVE/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>HIVE</name>
-      <comment>Data warehouse system for ad-hoc queries &amp; analysis of large datasets and table &amp; storage management service</comment>
       <version>0.14.0.2.9.9.9</version>
       <osSpecifics>
         <osSpecific>

ambari-server/src/main/resources/stacks/HDP/2.2/services/OOZIE/metainfo.xml

@@ -20,8 +20,6 @@
   <services>
     <service>
       <name>OOZIE</name>
-      <comment>System for workflow coordination and execution of Apache Hadoop jobs.  This also includes the installation of the optional Oozie Web Console which relies on and will install the &lt;a target="_blank" href="http://www.sencha.com/legal/open-source-faq/"&gt;ExtJS&lt;/a&gt; Library.
-      </comment>
       <version>4.1.0.2.2.9.9</version>
       <osSpecifics>
         <osSpecific>

ambari-server/src/main/resources/stacks/HDP/2.2/services/PIG/metainfo.xml

@@ -21,7 +21,6 @@
     <service>
       <name>PIG</name>
       <displayName>Pig</displayName>
-      <comment>Scripting platform for analyzing large datasets</comment>
       <version>0.14.0.2.9.9.9</version>
       <osSpecifics>
         <osSpecific>

ambari-server/src/main/resources/stacks/HDP/2.2/services/SQOOP/metainfo.xml

@@ -20,9 +20,6 @@
   <services>
     <service>
       <name>SQOOP</name>
-      <comment>Tool for transferring bulk data between Apache Hadoop and
-        structured data stores such as relational databases
-      </comment>
       <version>1.4.5.2.9.9.9</version>
       <osSpecifics>
         <osSpecific>

ambari-server/src/main/resources/stacks/HDP/2.2/services/STORM/metainfo.xml

@@ -22,7 +22,6 @@
     <service>
       <name>STORM</name>
       <displayName>Storm</displayName>
-      <comment>Apache Hadoop Stream processing framework</comment>
       <version>0.9.3.2.9.9.9</version>
       <osSpecifics>
         <osSpecific>

ambari-server/src/main/resources/stacks/HDP/2.2/services/TEZ/metainfo.xml

@@ -21,7 +21,6 @@
     <service>
       <name>TEZ</name>
       <displayName>Tez</displayName>
-      <comment>Tez is the next generation Hadoop Query Processing framework written on top of YARN.</comment>
       <version>0.6.0.2.9.9.9</version>
 
       <osSpecifics>

ambari-server/src/main/resources/stacks/HDP/2.2/services/WEBHCAT/metainfo.xml

@@ -20,7 +20,6 @@
   <services>
     <service>
       <name>WEBHCAT</name>
-      <comment>This is comment for WEBHCAT service</comment>
       <version>0.14.0.2.9.9.9</version>
       <osSpecifics>
         <osSpecific>

ambari-server/src/main/resources/stacks/HDP/2.2/services/YARN/metainfo.xml

@@ -22,7 +22,6 @@
     <service>
       <name>YARN</name>
       <displayName>YARN</displayName>
-      <comment>Apache Hadoop NextGen MapReduce (YARN)</comment>
       <version>2.6.0.2.9.9.9</version>
       <components>
         <components>
@@ -51,7 +50,6 @@
     <service>
       <name>MAPREDUCE2</name>
       <displayName>MapReduce2</displayName>
-      <comment>Apache Hadoop NextGen MapReduce (YARN)</comment>
       <version>2.6.0.2.9.9.9</version>
       <osSpecifics>
         <osSpecific>

ambari-server/src/main/resources/stacks/HDP/2.2/services/ZOOKEEPER/metainfo.xml

@@ -21,7 +21,6 @@
     <service>
       <name>ZOOKEEPER</name>
       <displayName>ZooKeeper</displayName>
-      <comment>Centralized service which provides highly reliable distributed coordination</comment>
       <version>3.4.5.2.9.9.9</version>
 
       <osSpecifics>

ambari-server/src/test/java/org/apache/ambari/server/actionmanager/TestActionDBAccessorImpl.java

@@ -445,7 +445,7 @@ public class TestActionDBAccessorImpl {
     List<RequestResourceFilter> resourceFilters = new
       ArrayList<RequestResourceFilter>() {{ add(resourceFilter); }};
     ExecuteActionRequest executeActionRequest = new ExecuteActionRequest
-      ("cluster1", null, actionName, resourceFilters, null, null);
+      ("cluster1", null, actionName, resourceFilters, null, null, false);
     Request request = new Request(stages, clusters);
     db.persistActions(request);
   }

ambari-server/src/test/java/org/apache/ambari/server/actionmanager/TestActionScheduler.java

@@ -132,6 +132,10 @@ public class TestActionScheduler {
     stages.add(s);
     when(db.getStagesInProgress()).thenReturn(stages);
 
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     //Keep large number of attempts so that the task is not expired finally
     //Small action timeout to test rescheduling
     ActionScheduler scheduler = new ActionScheduler(100, 100, db, aq, fsm,
@@ -278,6 +282,11 @@ public class TestActionScheduler {
     stages.add(s);
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
+
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
     doAnswer(new Answer() {
       @Override
@@ -361,6 +370,10 @@ public class TestActionScheduler {
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
 
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
 
     doAnswer(new Answer() {
@@ -488,6 +501,11 @@ public class TestActionScheduler {
     stages.add(s);
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
+
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
     doAnswer(new Answer() {
       @Override
@@ -548,6 +566,11 @@ public class TestActionScheduler {
     stages.add(s);
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
+
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
     doAnswer(new Answer() {
       @Override
@@ -652,6 +675,11 @@ public class TestActionScheduler {
                     RoleCommand.START, Service.Type.GANGLIA, 5, 5, 4));
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
+
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
 
     Properties properties = new Properties();
@@ -731,6 +759,11 @@ public class TestActionScheduler {
                     RoleCommand.START, Service.Type.GANGLIA, 5, 5, 4));
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
+
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
 
     Properties properties = new Properties();
@@ -800,6 +833,11 @@ public class TestActionScheduler {
     
     
     ActionDBAccessor db = mock(ActionDBAccessor.class);
+
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
     
     Properties properties = new Properties();
@@ -859,6 +897,10 @@ public class TestActionScheduler {
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
 
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
     doAnswer(new Answer() {
       @Override
@@ -988,7 +1030,6 @@ public class TestActionScheduler {
     when(host.getState()).thenReturn(HostState.HEALTHY);
     when(host.getHostName()).thenReturn(host1);
 
-
     final List<Stage> stages = new ArrayList<Stage>();
 
     long now = System.currentTimeMillis();
@@ -1037,6 +1078,10 @@ public class TestActionScheduler {
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
 
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
     doAnswer(new Answer() {
       @Override
@@ -1210,6 +1255,10 @@ public class TestActionScheduler {
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
 
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
     doAnswer(new Answer() {
       @Override
@@ -1432,8 +1481,12 @@ public class TestActionScheduler {
     when(host.getState()).thenReturn(HostState.HEALTHY);
     when(host.getHostName()).thenReturn(hostname);
 
-
     ActionDBAccessor db = mock(ActionDBAccessorImpl.class);
+
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     Stage s1 = StageUtils.getATestStage(requestId1, stageId, hostname, CLUSTER_HOST_INFO,
       "{\"host_param\":\"param_value\"}", "{\"stage_param\":\"param_value\"}");
     Stage s2 = StageUtils.getATestStage(requestId2, stageId, hostname, CLUSTER_HOST_INFO_UPDATED,
@@ -1517,6 +1570,10 @@ public class TestActionScheduler {
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
 
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
 
     ActionScheduler scheduler = new ActionScheduler(100, 50000, db, aq, fsm, 3,
@@ -1595,6 +1652,11 @@ public class TestActionScheduler {
     stages.add(s);
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
+
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
     doAnswer(new Answer() {
       @Override
@@ -1665,6 +1727,10 @@ public class TestActionScheduler {
 
     ActionDBAccessor db = mock(ActionDBAccessor.class);
 
+    Request request = mock(Request.class);
+    when(request.isExclusive()).thenReturn(false);
+    when(db.getRequest(anyLong())).thenReturn(request);
+
     when(db.getStagesInProgress()).thenReturn(stages);
 
     List<HostRoleCommand> requestTasks = new ArrayList<HostRoleCommand>();
@@ -1747,11 +1813,6 @@ public class TestActionScheduler {
 
     scheduler.doWork();
 
-
-
-    //List<CommandReport> reports = new ArrayList<CommandReport>();
-    //reports.add(getCommandReport(HostRoleStatus.FAILED, Role.NAMENODE, Service.Type.HDFS, "1-1", 1));
-    //am.processTaskResponse(hostname, reports, stages.get(0).getOrderedHostRoleCommands());
     String reason = "Some reason";
 
     scheduler.scheduleCancellingRequest(requestId, reason);
@@ -1766,4 +1827,193 @@ public class TestActionScheduler {
     Assert.assertEquals(cancelCommand.getReason(), reason);
   }
 
+
+  @Test
+  public void testExclusiveRequests() throws Exception {
+    ActionQueue aq = new ActionQueue();
+    Clusters fsm = mock(Clusters.class);
+    Cluster oneClusterMock = mock(Cluster.class);
+    Service serviceObj = mock(Service.class);
+    ServiceComponent scomp = mock(ServiceComponent.class);
+    ServiceComponentHost sch = mock(ServiceComponentHost.class);
+    UnitOfWork unitOfWork = mock(UnitOfWork.class);
+    RequestFactory requestFactory = mock(RequestFactory.class);
+    when(fsm.getCluster(anyString())).thenReturn(oneClusterMock);
+    when(oneClusterMock.getService(anyString())).thenReturn(serviceObj);
+    when(serviceObj.getServiceComponent(anyString())).thenReturn(scomp);
+    when(scomp.getServiceComponentHost(anyString())).thenReturn(sch);
+    when(serviceObj.getCluster()).thenReturn(oneClusterMock);
+
+    HashMap<String, ServiceComponentHost> hosts =
+            new HashMap<String, ServiceComponentHost>();
+    String hostname1 = "hostname1";
+    String hostname2 = "hostname2";
+    String hostname3 = "hostname3";
+
+    hosts.put(hostname1, sch);
+    hosts.put(hostname2, sch);
+    hosts.put(hostname3, sch);
+    when(scomp.getServiceComponentHosts()).thenReturn(hosts);
+
+    long requestId1 = 1;
+    long requestId2 = 2;
+    long requestId3 = 3;
+
+    final List<Stage> stagesInProgress = new ArrayList<Stage>();
+    int namenodeCmdTaskId = 1;
+    stagesInProgress.add(
+            getStageWithSingleTask(
+                    hostname1, "cluster1", Role.NAMENODE, RoleCommand.START,
+                    Service.Type.HDFS, namenodeCmdTaskId, 1, (int) requestId1));
+    stagesInProgress.add(
+            getStageWithSingleTask(
+                    hostname1, "cluster1", Role.DATANODE, RoleCommand.START,
+                    Service.Type.HDFS, 2, 2, (int) requestId1));
+    stagesInProgress.add(
+            getStageWithSingleTask(
+                    hostname2, "cluster1", Role.DATANODE, RoleCommand.STOP, //Exclusive
+                    Service.Type.HDFS, 3, 3, (int) requestId2));
+
+    stagesInProgress.add(
+            getStageWithSingleTask(
+                    hostname3, "cluster1", Role.DATANODE, RoleCommand.START,
+                    Service.Type.HDFS, 4, 4, (int) requestId3));
+
+
+    Host host1 = mock(Host.class);
+    when(fsm.getHost(anyString())).thenReturn(host1);
+    when(host1.getState()).thenReturn(HostState.HEALTHY);
+    when(host1.getHostName()).thenReturn(hostname);
+
+    Host host2 = mock(Host.class);
+    when(fsm.getHost(anyString())).thenReturn(host2);
+    when(host2.getState()).thenReturn(HostState.HEALTHY);
+    when(host2.getHostName()).thenReturn(hostname);
+
+    Host host3 = mock(Host.class);
+    when(fsm.getHost(anyString())).thenReturn(host3);
+    when(host3.getState()).thenReturn(HostState.HEALTHY);
+    when(host3.getHostName()).thenReturn(hostname);
+
+    ActionDBAccessor db = mock(ActionDBAccessor.class);
+
+    when(db.getStagesInProgress()).thenReturn(stagesInProgress);
+
+    List<HostRoleCommand> requestTasks = new ArrayList<HostRoleCommand>();
+    for (Stage stage : stagesInProgress) {
+      requestTasks.addAll(stage.getOrderedHostRoleCommands());
+    }
+    when(db.getRequestTasks(anyLong())).thenReturn(requestTasks);
+    when(db.getAllStages(anyLong())).thenReturn(stagesInProgress);
+    doAnswer(new Answer() {
+      @Override
+      public Object answer(InvocationOnMock invocation) throws Throwable {
+        List<CommandReport> reports = (List<CommandReport>) invocation.getArguments()[0];
+        for (CommandReport report : reports) {
+          String actionId = report.getActionId();
+          long[] requestStageIds = StageUtils.getRequestStage(actionId);
+          Long requestId = requestStageIds[0];
+          Long stageId = requestStageIds[1];
+          String role = report.getRole();
+          Long id = report.getTaskId();
+          for (Stage stage : stagesInProgress) {
+            if (requestId.equals(stage.getRequestId()) && stageId.equals(stage.getStageId())) {
+              for (HostRoleCommand hostRoleCommand : stage.getOrderedHostRoleCommands()) {
+                if (hostRoleCommand.getTaskId() == id) {
+                  hostRoleCommand.setStatus(HostRoleStatus.valueOf(report.getStatus()));
+                }
+              }
+            }
+          }
+
+        }
+
+        return null;
+      }
+    }).when(db).updateHostRoleStates(anyCollectionOf(CommandReport.class));
+
+    when(db.getTask(anyLong())).thenAnswer(new Answer<Object>() {
+      @Override
+      public Object answer(InvocationOnMock invocation) throws Throwable {
+        Long taskId = (Long) invocation.getArguments()[0];
+        for (Stage stage : stagesInProgress) {
+          for (HostRoleCommand command : stage.getOrderedHostRoleCommands()) {
+            if (taskId.equals(command.getTaskId())) {
+              return command;
+            }
+          }
+        }
+        return null;
+      }
+    });
+
+    final Map<Long, Boolean> startedRequests = new HashMap<Long, Boolean>();
+    doAnswer(new Answer() {
+      @Override
+      public Object answer(InvocationOnMock invocation) throws Throwable {
+        startedRequests.put((Long)invocation.getArguments()[0], true);
+        return null;
+      }
+    }).when(db).startRequest(anyLong());
+
+    Request request1 = mock(Request.class);
+    when(request1.isExclusive()).thenReturn(false);
+    Request request2 = mock(Request.class);
+    when(request2.isExclusive()).thenReturn(true);
+    Request request3 = mock(Request.class);
+    when(request3.isExclusive()).thenReturn(false);
+
+    when(db.getRequest(requestId1)).thenReturn(request1);
+    when(db.getRequest(requestId2)).thenReturn(request2);
+    when(db.getRequest(requestId3)).thenReturn(request3);
+
+    Properties properties = new Properties();
+    Configuration conf = new Configuration(properties);
+    ServerActionManagerImpl serverActionManager = new ServerActionManagerImpl(fsm);
+
+    ActionScheduler scheduler =new ActionScheduler(100, 50, db, aq, fsm, 3,
+            new HostsMap((String) null), serverActionManager, unitOfWork, conf);
+
+    ActionManager am = new ActionManager(
+            2, 2, aq, fsm, db, new HostsMap((String) null),
+            serverActionManager, unitOfWork, requestFactory, conf);
+
+    // Execution of request 1
+
+    scheduler.doWork();
+
+    Assert.assertTrue(startedRequests.containsKey(requestId1));
+    Assert.assertFalse(startedRequests.containsKey(requestId2));
+    Assert.assertFalse(startedRequests.containsKey(requestId3));
+
+    stagesInProgress.remove(0);
+
+    scheduler.doWork();
+
+    Assert.assertTrue(startedRequests.containsKey(requestId1));
+    Assert.assertFalse(startedRequests.containsKey(requestId2));
+    Assert.assertFalse(startedRequests.containsKey(requestId3));
+
+    // Execution of request 2
+
+    stagesInProgress.remove(0);
+
+    scheduler.doWork();
+
+    Assert.assertTrue(startedRequests.containsKey(requestId1));
+    Assert.assertTrue(startedRequests.containsKey(requestId2));
+    Assert.assertFalse(startedRequests.containsKey(requestId3));
+
+    // Execution of request 3
+
+    stagesInProgress.remove(0);
+
+    scheduler.doWork();
+
+    Assert.assertTrue(startedRequests.containsKey(requestId1));
+    Assert.assertTrue(startedRequests.containsKey(requestId2));
+    Assert.assertTrue(startedRequests.containsKey(requestId3));
+
+  }
+
 }

ambari-server/src/test/java/org/apache/ambari/server/api/util/StackExtensionHelperTest.java

@@ -648,6 +648,26 @@ public class StackExtensionHelperTest {
     assertEquals(0, merged.getConfigTypes().size());
   }
 
+  @Test
+  public void testServiceInheritance() throws Exception {
+    File stackRoot = new File(stackRootStr);
+    StackInfo stackInfo = new StackInfo();
+    stackInfo.setName("HDP");
+    stackInfo.setVersion("2.0.6");
+    StackExtensionHelper helper = new StackExtensionHelper(injector, stackRoot);
+    helper.populateServicesForStack(stackInfo);
+    helper.fillInfo();
+    List<ServiceInfo> allServices = helper.getAllApplicableServices(stackInfo);
+    for (ServiceInfo serviceInfo : allServices) {
+      if (serviceInfo.getName().equals("HDFS")){
+        assertEquals("HDFS", serviceInfo.getName());
+        assertNotNull(serviceInfo.getMetricsFile()); 
+      } 
+    }
+    
+  }
+  
+  
   @Test
   public void testMergeComponentInfo() throws Exception {
     File stackRoot = new File(stackRootStr);

ambari-server/src/test/java/org/apache/ambari/server/controller/AmbariCustomCommandExecutionHelperTest.java

@@ -115,7 +115,7 @@ public class AmbariCustomCommandExecutionHelperTest {
             {
               put("forceRefreshConfigTags" , "capacity-scheduler");
             }
-          });
+          }, false);
       actionRequest.getResourceFilters().add(new RequestResourceFilter("YARN", "RESOURCEMANAGER",Collections.singletonList("c6401")));
       
       controller.createAction(actionRequest, requestProperties);

ambari-server/src/test/java/org/apache/ambari/server/controller/AmbariManagementControllerTest.java

@@ -2469,7 +2469,7 @@ public class AmbariManagementControllerTest {
     resourceFilters.add(resourceFilter);
 
     ExecuteActionRequest request = new ExecuteActionRequest(clusterName,
-      "DECOMMISSION", null, resourceFilters, level, params);
+      "DECOMMISSION", null, resourceFilters, level, params, false);
 
     Map<String, String> requestProperties = new HashMap<String, String>();
     requestProperties.put(REQUEST_CONTEXT_PROPERTY, "Called from a test");
@@ -2509,7 +2509,7 @@ public class AmbariManagementControllerTest {
     ArrayList<RequestResourceFilter> filters = new ArrayList<RequestResourceFilter>();
     filters.add(resourceFilter);
     request = new ExecuteActionRequest(clusterName, "DECOMMISSION", null,
-            filters, level, params);
+            filters, level, params, false);
 
     response = controller.createAction(request, requestProperties);
 
@@ -2533,7 +2533,7 @@ public class AmbariManagementControllerTest {
       put("included_hosts", "h2");
     }};
     request = new ExecuteActionRequest(clusterName, "DECOMMISSION", null,
-      resourceFilters, level, params);
+      resourceFilters, level, params, false);
 
     response = controller.createAction(request,
         requestProperties);
@@ -3924,7 +3924,7 @@ public class AmbariManagementControllerTest {
     List<RequestResourceFilter> resourceFilters = new ArrayList<RequestResourceFilter>();
     resourceFilters.add(resourceFilter);
 
-    ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params);
+    ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params, false);
     RequestStatusResponse response = controller.createAction(actionRequest, requestProperties);
     assertEquals(1, response.getTasks().size());
     ShortTaskStatus taskStatus = response.getTasks().get(0);
@@ -3952,7 +3952,7 @@ public class AmbariManagementControllerTest {
     resourceFilters.clear();
     resourceFilter = new RequestResourceFilter("", "", null);
     resourceFilters.add(resourceFilter);
-    actionRequest = new ExecuteActionRequest("c1", null, "a2", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a2", resourceFilters, null, params, false);
     response = controller.createAction(actionRequest, requestProperties);
     assertEquals(2, response.getTasks().size());
 
@@ -3982,7 +3982,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("", "", hosts);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params, false);
     response = controller.createAction(actionRequest, requestProperties);
     assertEquals(1, response.getTasks().size());
     taskStatus = response.getTasks().get(0);
@@ -4056,7 +4056,7 @@ public class AmbariManagementControllerTest {
       "HDFS_CLIENT",
       new ArrayList<String>() {{ add("h1"); }});
     ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1",
-      "RESTART", params);
+      "RESTART", params, false);
     actionRequest.getResourceFilters().add(resourceFilter);
 
     Map<String, String> requestProperties = new HashMap<String, String>();
@@ -4153,7 +4153,7 @@ public class AmbariManagementControllerTest {
       "NAGIOS_SERVER",
       new ArrayList<String>() {{ add("h1"); }});
     ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1",
-      "RESTART", params);
+      "RESTART", params, false);
     actionRequest.getResourceFilters().add(resourceFilter);
 
     Map<String, String> requestProperties = new HashMap<String, String>();
@@ -4246,7 +4246,7 @@ public class AmbariManagementControllerTest {
 
     RequestResourceFilter resourceFilter = new RequestResourceFilter("HDFS", null, null);
 
-    ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1", "NON_EXISTENT_CHECK", params);
+    ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1", "NON_EXISTENT_CHECK", params, false);
     actionRequest.getResourceFilters().add(resourceFilter);
 
     Map<String, String> requestProperties = new HashMap<String, String>();
@@ -4257,7 +4257,7 @@ public class AmbariManagementControllerTest {
     //actionRequest = new ExecuteActionRequest("c1", "NON_EXISTENT_SERVICE_CHECK", "HDFS", params);
     //expectActionCreationErrorWithMessage(actionRequest, requestProperties, "Unsupported action");
 
-    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION_DATANODE", params);
+    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION_DATANODE", params, false);
     actionRequest.getResourceFilters().add(resourceFilter);
 
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
@@ -4270,7 +4270,7 @@ public class AmbariManagementControllerTest {
     List<RequestResourceFilter> resourceFilters = new ArrayList<RequestResourceFilter>();
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params, false);
 
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Unsupported action DECOMMISSION for Service: HDFS and Component: HDFS_CLIENT");
@@ -4278,7 +4278,7 @@ public class AmbariManagementControllerTest {
     resourceFilters.clear();
     resourceFilter = new RequestResourceFilter("HDFS", null, null);
     resourceFilters.add(resourceFilter);
-    actionRequest = new ExecuteActionRequest("c1", null, "DECOMMISSION_DATANODE", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "DECOMMISSION_DATANODE", resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action DECOMMISSION_DATANODE does not exist");
 
@@ -4286,7 +4286,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("YARN", "RESOURCEMANAGER", null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Service not found, clusterName=c1, serviceName=YARN");
 
@@ -4299,7 +4299,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("HDFS", "NAMENODE", null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2);
+    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Same host cannot be specified for inclusion as well as exclusion. Hosts: [h1]");
 
@@ -4312,7 +4312,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("HDFS", "NAMENODE", null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2);
+    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Component HDFS_CLIENT is not supported for decommissioning.");
 
@@ -4322,7 +4322,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("HDFS", "NAMENODE", hosts);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2);
+    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Decommission command cannot be issued with target host(s) specified.");
 
@@ -4334,7 +4334,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("HDFS", "NAMENODE", null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2);
+    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Component DATANODE on host h1 cannot be decommissioned as its not in STARTED state");
 
@@ -4342,7 +4342,7 @@ public class AmbariManagementControllerTest {
       put("excluded_hosts", "h1 ");
       put("mark_draining_only", "true");
     }};
-    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2);
+    actionRequest = new ExecuteActionRequest("c1", "DECOMMISSION", null, resourceFilters, null, params2, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "mark_draining_only is not a valid parameter for NAMENODE");
 
@@ -4362,16 +4362,16 @@ public class AmbariManagementControllerTest {
         "a4", ActionType.SYSTEM, "", "HIVE", "", "Does file exist",
         TargetHostType.ANY, Short.valueOf("100")));
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a1", null, null, null);
+    actionRequest = new ExecuteActionRequest("c1", null, "a1", null, null, null, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action a1 requires input 'test' that is not provided");
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a1", null, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a1", null, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action a1 requires input 'dirName' that is not provided");
 
     params.put("dirName", "dirName");
-    actionRequest = new ExecuteActionRequest("c1", null, "a1", null, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a1", null, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action a1 requires explicit target host(s)");
 
@@ -4379,7 +4379,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("HIVE", null, null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a2", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a2", resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action a2 targets service HIVE that does not match with expected HDFS");
 
@@ -4387,7 +4387,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("HDFS", "HDFS_CLIENT", null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a2", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a2", resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action a2 targets component HDFS_CLIENT that does not match with expected DATANODE");
 
@@ -4395,7 +4395,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("HDFS2", "HDFS_CLIENT", null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action a1 targets service HDFS2 that does not exist");
 
@@ -4403,7 +4403,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("HDFS", "HDFS_CLIENT2", null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action a1 targets component HDFS_CLIENT2 that does not exist");
 
@@ -4411,7 +4411,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("", "HDFS_CLIENT2", null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action a1 targets component HDFS_CLIENT2 without specifying the target service");
 
@@ -4420,7 +4420,7 @@ public class AmbariManagementControllerTest {
     resourceFilters.add(resourceFilter);
 
     // targets a service that is not a member of the stack (e.g. MR not in HDP-2)
-    actionRequest = new ExecuteActionRequest("c1", null, "a3", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a3", resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Action a3 targets service MAPREDUCE that does not exist");
 
@@ -4430,7 +4430,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("", "", hosts);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a2", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a2", resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Request specifies host h6 but its not a valid host based on the target service=HDFS and component=DATANODE");
 
@@ -4438,7 +4438,7 @@ public class AmbariManagementControllerTest {
     resourceFilter = new RequestResourceFilter("HIVE", "", null);
     resourceFilters.add(resourceFilter);
 
-    actionRequest = new ExecuteActionRequest("c1", null, "a4", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a4", resourceFilters, null, params, false);
     expectActionCreationErrorWithMessage(actionRequest, requestProperties,
         "Suitable hosts not found, component=, service=HIVE, cluster=c1, actionName=a4");
 
@@ -4500,7 +4500,7 @@ public class AmbariManagementControllerTest {
     Map<String, String> params = new HashMap<String, String>() {{
       put("test", "test");
     }};
-    ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1", Role.HDFS_SERVICE_CHECK.name(), params);
+    ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1", Role.HDFS_SERVICE_CHECK.name(), params, false);
     RequestResourceFilter resourceFilter = new RequestResourceFilter("HDFS", null, null);
     actionRequest.getResourceFilters().add(resourceFilter);
 
@@ -4544,7 +4544,7 @@ public class AmbariManagementControllerTest {
     assertEquals(2, hostRoleCommand.getExecutionCommandWrapper().getExecutionCommand().getConfigurations().size());
     assertEquals(requestProperties.get(REQUEST_CONTEXT_PROPERTY), stage.getRequestContext());
 
-    actionRequest = new ExecuteActionRequest("c1", Role.MAPREDUCE_SERVICE_CHECK.name(), null);
+    actionRequest = new ExecuteActionRequest("c1", Role.MAPREDUCE_SERVICE_CHECK.name(), null, false);
     resourceFilter = new RequestResourceFilter("MAPREDUCE", null, null);
     actionRequest.getResourceFilters().add(resourceFilter);
 
@@ -5774,7 +5774,7 @@ public class AmbariManagementControllerTest {
     Assert.assertEquals("Expect only one service check.", 1, commandCount);
 
     RequestResourceFilter resourceFilter = new RequestResourceFilter("HDFS", null, null);
-    ExecuteActionRequest actionRequest = new ExecuteActionRequest("foo1", Role.HDFS_SERVICE_CHECK.name(), null);
+    ExecuteActionRequest actionRequest = new ExecuteActionRequest("foo1", Role.HDFS_SERVICE_CHECK.name(), null, false);
     actionRequest.getResourceFilters().add(resourceFilter);
     Map<String, String> requestProperties = new HashMap<String, String>();
 
@@ -6130,7 +6130,7 @@ public class AmbariManagementControllerTest {
     ArrayList<RequestResourceFilter> filters = new ArrayList<RequestResourceFilter>();
     filters.add(resourceFilter);
     ExecuteActionRequest request = new ExecuteActionRequest(clusterName,
-            "DECOMMISSION", null, filters, level, params);
+            "DECOMMISSION", null, filters, level, params, false);
 
     Map<String, String> requestProperties = new HashMap<String, String>();
     requestProperties.put(REQUEST_CONTEXT_PROPERTY, "Called from a test");
@@ -6162,7 +6162,7 @@ public class AmbariManagementControllerTest {
     filters.add(resourceFilter);
 
     request = new ExecuteActionRequest(clusterName, "DECOMMISSION",
-            null, filters, level, params);
+            null, filters, level, params, false);
 
     response = controller.createAction(request,
         requestProperties);
@@ -6204,7 +6204,7 @@ public class AmbariManagementControllerTest {
     filters = new ArrayList<RequestResourceFilter>();
     filters.add(resourceFilter);
     request = new ExecuteActionRequest(clusterName, "DECOMMISSION", null,
-            filters, level, params);
+            filters, level, params, false);
 
     response = controller.createAction(request,
         requestProperties);
@@ -6304,7 +6304,7 @@ public class AmbariManagementControllerTest {
     resourceFilters.add(resourceFilter1);
     resourceFilters.add(resourceFilter2);
 
-    ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params);
+    ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params, false);
     RequestStatusResponse response = null;
     try {
       response = controller.createAction(actionRequest, requestProperties);
@@ -6314,7 +6314,7 @@ public class AmbariManagementControllerTest {
         "allows one resource filter to be specified"));
     }
     resourceFilters.remove(resourceFilter1);
-    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params);
+    actionRequest = new ExecuteActionRequest("c1", null, "a1", resourceFilters, null, params, false);
     response = controller.createAction(actionRequest, requestProperties);
 
     assertEquals(1, response.getTasks().size());
@@ -6402,7 +6402,7 @@ public class AmbariManagementControllerTest {
     resourceFilters.add(resourceFilter);
 
     ExecuteActionRequest request = new ExecuteActionRequest("c1",
-      "RESTART", null, resourceFilters, null, params);
+      "RESTART", null, resourceFilters, null, params, false);
 
     RequestStatusResponse response = controller.createAction(request, requestProperties);
     Assert.assertEquals(3, response.getTasks().size());
@@ -6433,7 +6433,7 @@ public class AmbariManagementControllerTest {
       new ArrayList<String>() {{ add("h1"); }});
     resourceFilters.add(resourceFilter);
     request = new ExecuteActionRequest("c1", Role.HDFS_SERVICE_CHECK.name(),
-      null, resourceFilters, null, null);
+      null, resourceFilters, null, null, false);
     response = controller.createAction(request, requestProperties);
 
     Assert.assertEquals(1, response.getTasks().size());
@@ -6911,7 +6911,7 @@ public class AmbariManagementControllerTest {
       put("excluded_hosts", " h1 ");
     }};
     RequestResourceFilter resourceFilter = new RequestResourceFilter("HDFS", "NAMENODE", null);
-    ExecuteActionRequest request = new ExecuteActionRequest(clusterName, "DECOMMISSION", params);
+    ExecuteActionRequest request = new ExecuteActionRequest(clusterName, "DECOMMISSION", params, false);
     request.getResourceFilters().add(resourceFilter);
 
     Map<String, String> requestProperties = new HashMap<String, String>();
@@ -8872,7 +8872,7 @@ public class AmbariManagementControllerTest {
       amc.createHostComponents(componentHostRequests);
 
       RequestResourceFilter resourceFilter = new RequestResourceFilter("HDFS", null, null);
-      ExecuteActionRequest ar = new ExecuteActionRequest(CLUSTER_NAME, Role.HDFS_SERVICE_CHECK.name(), null);
+      ExecuteActionRequest ar = new ExecuteActionRequest(CLUSTER_NAME, Role.HDFS_SERVICE_CHECK.name(), null, false);
       ar.getResourceFilters().add(resourceFilter);
       amc.createAction(ar, null);
 
@@ -10154,7 +10154,7 @@ public class AmbariManagementControllerTest {
     resourceFilters.add(resourceFilter);
 
     ExecuteActionRequest actionRequest = new ExecuteActionRequest(null, null,
-        "a1", resourceFilters, null, requestParams);
+        "a1", resourceFilters, null, requestParams, false);
     RequestStatusResponse response = controller.createAction(actionRequest, requestProperties);
     assertEquals(1, response.getTasks().size());
     ShortTaskStatus taskStatus = response.getTasks().get(0);
@@ -10186,7 +10186,7 @@ public class AmbariManagementControllerTest {
     resourceFilters.add(resourceFilter);
 
     actionRequest = new ExecuteActionRequest(null, null,
-        "a1", resourceFilters, null, requestParams);
+        "a1", resourceFilters, null, requestParams, false);
     response = controller.createAction(actionRequest, requestProperties);
     assertEquals(2, response.getTasks().size());
     boolean host1Found = false;

ambari-server/src/test/java/org/apache/ambari/server/controller/BackgroundCustomCommandExecutionTest.java

@@ -118,7 +118,7 @@ public class BackgroundCustomCommandExecutionTest {
       };
 
       ExecuteActionRequest actionRequest = new ExecuteActionRequest("c1",
-          "REBALANCEHDFS", new HashMap<String, String>());
+          "REBALANCEHDFS", new HashMap<String, String>(), false);
       actionRequest.getResourceFilters().add(new RequestResourceFilter("HDFS", "NAMENODE",Collections.singletonList("c6401")));
       
       controller.createAction(actionRequest, requestProperties);

ambari-server/src/test/java/org/apache/ambari/server/view/ViewRegistryTest.java

@@ -18,8 +18,10 @@
 
 package org.apache.ambari.server.view;
 
+import static org.easymock.EasyMock.capture;
 import static org.easymock.EasyMock.createMock;
 import static org.easymock.EasyMock.createNiceMock;
+import static org.easymock.EasyMock.eq;
 import static org.easymock.EasyMock.expect;
 import static org.easymock.EasyMock.replay;
 import static org.easymock.EasyMock.reset;
@@ -81,6 +83,7 @@ import org.apache.ambari.server.view.events.EventImplTest;
 import org.apache.ambari.view.ViewDefinition;
 import org.apache.ambari.view.events.Event;
 import org.apache.ambari.view.events.Listener;
+import org.easymock.Capture;
 import org.easymock.EasyMock;
 import org.junit.Assert;
 import org.junit.Before;
@@ -926,6 +929,93 @@ public class ViewRegistryTest {
     verify(securityHelper, viewEntity, configuration);
   }
 
+  @Test
+  public void testExtractViewArchive() throws Exception {
+
+    File viewDir = createNiceMock(File.class);
+    File extractedArchiveDir = createNiceMock(File.class);
+    File viewArchive = createNiceMock(File.class);
+    File archiveDir = createNiceMock(File.class);
+    File entryFile  = createNiceMock(File.class);
+    File classesDir = createNiceMock(File.class);
+    File libDir = createNiceMock(File.class);
+    File fileEntry = createNiceMock(File.class);
+
+    JarFile viewJarFile = createNiceMock(JarFile.class);
+    Enumeration<JarEntry> enumeration = createMock(Enumeration.class);
+    JarEntry jarEntry = createNiceMock(JarEntry.class);
+    InputStream is = createMock(InputStream.class);
+    FileOutputStream fos = createMock(FileOutputStream.class);
+    ViewExtractor viewExtractor = createMock(ViewExtractor.class);
+
+    ResourceTypeEntity resourceTypeEntity = new ResourceTypeEntity();
+    resourceTypeEntity.setId(10);
+    resourceTypeEntity.setName("MY_VIEW{1.0.0}");
+
+    ViewEntity viewDefinition = ViewEntityTest.getViewEntity();
+    viewDefinition.setResourceType(resourceTypeEntity);
+
+    Set<ViewInstanceEntity> viewInstanceEntities = ViewInstanceEntityTest.getViewInstanceEntities(viewDefinition);
+    viewDefinition.setInstances(viewInstanceEntities);
+
+    Map<File, ViewConfig> viewConfigs =
+        Collections.singletonMap(viewArchive, viewDefinition.getConfiguration());
+
+    long resourceId = 99L;
+    for (ViewInstanceEntity viewInstanceEntity : viewInstanceEntities) {
+      ResourceEntity resourceEntity = new ResourceEntity();
+      resourceEntity.setId(resourceId);
+      resourceEntity.setResourceType(resourceTypeEntity);
+      viewInstanceEntity.setResource(resourceEntity);
+    }
+
+    Map<String, File> files = new HashMap<String, File>();
+
+    files.put("/var/lib/ambari-server/resources/views/my_view-1.0.0.jar", viewArchive);
+    files.put("/var/lib/ambari-server/resources/views/work", extractedArchiveDir);
+    files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}", archiveDir);
+    files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/view.xml", entryFile);
+    files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/WEB-INF/classes", classesDir);
+    files.put("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}/WEB-INF/lib", libDir);
+
+    Map<File, FileOutputStream> outputStreams = new HashMap<File, FileOutputStream>();
+    outputStreams.put(entryFile, fos);
+
+    Map<File, JarFile> jarFiles = new HashMap<File, JarFile>();
+    jarFiles.put(viewArchive, viewJarFile);
+
+    // set expectations
+    expect(configuration.getViewsDir()).andReturn(viewDir);
+    expect(viewDir.getAbsolutePath()).andReturn("/var/lib/ambari-server/resources/views");
+
+    expect(configuration.getViewExtractionThreadPoolCoreSize()).andReturn(2).anyTimes();
+    expect(configuration.getViewExtractionThreadPoolMaxSize()).andReturn(3).anyTimes();
+    expect(configuration.getViewExtractionThreadPoolTimeout()).andReturn(10000L).anyTimes();
+
+    expect(viewArchive.getAbsolutePath()).andReturn("/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}").anyTimes();
+
+    expect(archiveDir.exists()).andReturn(false);
+    expect(archiveDir.getAbsolutePath()).andReturn(
+        "/var/lib/ambari-server/resources/views/work/MY_VIEW{1.0.0}").anyTimes();
+
+    Capture<ViewEntity> viewEntityCapture = new Capture<ViewEntity>();
+    expect(viewExtractor.ensureExtractedArchiveDirectory("/var/lib/ambari-server/resources/views/work")).andReturn(true);
+    expect(viewExtractor.extractViewArchive(capture(viewEntityCapture), eq(viewArchive), eq(archiveDir))).andReturn(null);
+
+    // replay mocks
+    replay(configuration, viewDir, extractedArchiveDir, viewArchive, archiveDir, entryFile, classesDir,
+        libDir, fileEntry, viewJarFile, enumeration, jarEntry, is, fos, viewExtractor, resourceDAO, viewDAO, viewInstanceDAO);
+
+    TestViewArchiveUtility archiveUtility = new TestViewArchiveUtility(viewConfigs, files, outputStreams, jarFiles);
+
+    Assert.assertTrue(ViewRegistry.extractViewArchive("/var/lib/ambari-server/resources/views/my_view-1.0.0.jar",
+        viewExtractor, archiveUtility, configuration, true));
+
+    // verify mocks
+    verify(configuration, viewDir, extractedArchiveDir, viewArchive, archiveDir, entryFile, classesDir,
+        libDir, fileEntry, viewJarFile, enumeration, jarEntry, is, fos, viewExtractor, resourceDAO, viewDAO, viewInstanceDAO);
+  }
+
   public static class TestViewArchiveUtility extends ViewArchiveUtility {
     private final Map<File, ViewConfig> viewConfigs;
     private final Map<String, File> files;

ambari-server/src/test/java/org/apache/ambari/server/view/configuration/ViewConfigTest.java

@@ -47,6 +47,7 @@ public class ViewConfigTest {
       "    <label>My View!</label>\n" +
       "    <description>Description</description>" +
       "    <version>1.0.0</version>\n" +
+      "    <system>true</system>\n" +
       "    <icon64>/this/is/the/icon/url/icon64.png</icon64>\n" +
       "    <icon>/this/is/the/icon/url/icon.png</icon>\n" +
       "    <masker-class>org.apache.ambari.server.view.DefaultMasker</masker-class>" +

ambari-server/src/test/python/stacks/1.3.2/HDFS/test_service_check.py

@@ -57,7 +57,7 @@ class TestServiceCheck(RMFTestCase):
         conf_dir = '/etc/hadoop/conf',
         bin_dir = '/usr/bin',
         logoutput = True,
-        not_if = 'hadoop --config /etc/hadoop/conf fs -test -e /tmp',
+        not_if = 'su - ambari-qa -c \'hadoop --config /etc/hadoop/conf fs -test -e /tmp\'',
         try_sleep = 3,
         tries = 5,
         user = 'ambari-qa',

ambari-server/src/test/python/stacks/2.0.6/HDFS/test_service_check.py

@@ -56,7 +56,7 @@ class TestServiceCheck(RMFTestCase):
     self.assertResourceCalled('ExecuteHadoop', 'fs -mkdir /tmp',
         conf_dir = '/etc/hadoop/conf',
         logoutput = True,
-        not_if = 'hadoop --config /etc/hadoop/conf fs -test -e /tmp',
+        not_if = 'su - ambari-qa -c \'hadoop --config /etc/hadoop/conf fs -test -e /tmp\'',
         try_sleep = 3,
         tries = 5,
         bin_dir = '/usr/bin',

ambari-server/src/test/resources/stacks/HDP/2.0.7/services/HDFS/metrics.json

@@ -1,7840 +0,0 @@
-{
-  "NAMENODE": {
-    "Component": [
-      {
-        "type": "ganglia",
-        "metrics": {
-          "metrics/dfs/FSNamesystem/TotalLoad": {
-            "metric": "dfs.FSNamesystem.TotalLoad",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/BlockCapacity": {
-            "metric": "dfs.FSNamesystem.BlockCapacity",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityTotal": {
-            "metric": "dfs.FSNamesystem.CapacityTotal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityUsed": {
-            "metric": "dfs.FSNamesystem.CapacityUsed",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityRemaining": {
-            "metric": "dfs.FSNamesystem.CapacityRemaining",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityNonDFSUsed": {
-            "metric": "dfs.FSNamesystem.CapacityUsedNonDFS",
-            "pointInTime": false,
-            "temporal": true
-          },           
-          "metrics/dfs/namenode/GetListingOps": {
-            "metric": "dfs.namenode.GetListingOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesAppended": {
-            "metric": "dfs.namenode.FilesAppended",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getProtocolVersion_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.getProtocolVersion_num_ops",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/fsync_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.FsyncAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginSuccessAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/load/load_one": {
-            "metric": "load_one",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/renewLease_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.RenewLeaseNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getFileInfo_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetFileInfoAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/complete_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.CompleteAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setPermission_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.SetPermissionNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityTotalGB": {
-            "metric": "dfs.FSNamesystem.CapacityTotalGB",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setOwner_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.SetOwnerNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getBlockLocations_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetBlockLocationsNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/process/proc_run": {
-            "metric": "proc_run",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityUsedGB": {
-            "metric": "dfs.FSNamesystem.CapacityUsedGB",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/AddBlockOps": {
-            "metric": "dfs.namenode.AddBlockOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/swap_total": {
-            "metric": "swap_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesDeleted": {
-            "metric": "dfs.namenode.FilesDeleted",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/Syncs_avg_time": {
-            "metric": "dfs.namenode.SyncsAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "jvm.JvmMetrics.ThreadsBlocked",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "rpc.rpc.RpcQueueTimeNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/process/proc_total": {
-            "metric": "proc_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/blockReport_avg_time": {
-            "metric": "dfs.namenode.BlockReportAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/disk/part_max_used": {
-            "metric": "part_max_used",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getFileInfo_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetFileInfoNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getEditLogSize_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetEditLogManifestAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginSuccessNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blockReceived_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.BlockReceivedAndDeletedAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_idle": {
-            "metric": "cpu_idle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/versionRequest_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.VersionRequestAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_aidle": {
-            "metric": "cpu_aidle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_free": {
-            "metric": "mem_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/versionRequest_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.VersionRequestNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/addBlock_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.AddBlockNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesCreated": {
-            "metric": "dfs.namenode.FilesCreated",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rename_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.RenameAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/bytes_in": {
-            "metric": "bytes_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setSafeMode_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.SetSafeModeNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/pkts_out": {
-            "metric": "pkts_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/mem_cached": {
-            "metric": "mem_cached",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/disk_total": {
-            "metric": "disk_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setPermission_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.SetPermissionAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesRenamed": {
-            "metric": "dfs.namenode.FilesRenamed",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/register_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.RegisterDatanodeAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setReplication_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.setReplication_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/JournalTransactionsBatchedInSync": {
-            "metric": "dfs.namenode.JournalTransactionsBatchedInSync",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginFailureNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/GetBlockLocations": {
-            "metric": "dfs.namenode.GetBlockLocations",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/fsync_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.FsyncNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_wio": {
-            "metric": "cpu_wio",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/create_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.CreateAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/PendingReplicationBlocks": {
-            "metric": "dfs.FSNamesystem.PendingReplicationBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_speed": {
-            "metric": "cpu_speed",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/delete_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.DeleteAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FileInfoOps": {
-            "metric": "dfs.namenode.FileInfoOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/sendHeartbeat_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.SendHeartbeatNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/DeleteFileOps": {
-            "metric": "dfs.namenode.DeleteFileOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "rpc.rpc.RpcProcessingTimeAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blockReport_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.BlockReportNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setSafeMode_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.SetSafeModeAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthenticationSuccesses",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/PendingDeletionBlocks": {
-            "metric": "dfs.FSNamesystem.PendingDeletionBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "rpc.rpc.RpcAuthenticationFailures",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/network/pkts_in": {
-            "metric": "pkts_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_total": {
-            "metric": "mem_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getEditLogSize_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetEditLogManifestNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemHeapCommittedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesInGetListingOps": {
-            "metric": "dfs.namenode.FilesInGetListingOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "jvm.JvmMetrics.ThreadsRunnable",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/complete_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.CompleteNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "jvm.JvmMetrics.ThreadsNew",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rollFsImage_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.rollFsImage_num_ops",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "rpc.rpc.RpcAuthorizationFailures",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/Syncs_num_ops": {
-            "metric": "dfs.namenode.SyncsNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "rpc.rpc.RpcQueueTimeAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blockReceived_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.BlockReceivedAndDeletedNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setReplication_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.setReplication_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rollEditLog_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.RollEditLogAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "rpc.rpc.SentBytes",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/FilesTotal": {
-            "metric": "dfs.FSNamesystem.FilesTotal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "jvm.JvmMetrics.LogWarn",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/ExcessBlocks": {
-            "metric": "dfs.FSNamesystem.ExcessBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "jvm.JvmMetrics.GcCount",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "rpc.rpc.ReceivedBytes",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_nice": {
-            "metric": "cpu_nice",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/blockReport_num_ops": {
-            "metric": "dfs.namenode.BlockReportNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/SafemodeTime": {
-            "metric": "dfs.namenode.SafemodeTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rollFsImage_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.rollFsImage_avg_time",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/mkdirs_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.MkdirsAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "rpc.rpc.NumOpenConnections",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemHeapUsedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/ScheduledReplicationBlocks": {
-            "metric": "dfs.FSNamesystem.ScheduledReplicationBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsWaiting",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/disk/disk_free": {
-            "metric": "disk_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/BlocksTotal": {
-            "metric": "dfs.FSNamesystem.BlocksTotal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/mem_buffers": {
-            "metric": "mem_buffers",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "jvm.JvmMetrics.GcTimeMillis",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getBlockLocations_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetBlockLocationsAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/Transactions_num_ops": {
-            "metric": "dfs.namenode.TransactionsNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/create_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.CreateNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "jvm.JvmMetrics.ThreadsTerminated",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/network/bytes_out": {
-            "metric": "bytes_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_user": {
-            "metric": "cpu_user",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/swap_free": {
-            "metric": "swap_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_five": {
-            "metric": "load_five",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_system": {
-            "metric": "cpu_system",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityRemainingGB": {
-            "metric": "dfs.FSNamesystem.CapacityRemainingGB",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/Transactions_avg_time": {
-            "metric": "dfs.namenode.TransactionsAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/boottime": {
-            "metric": "boottime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/MissingBlocks": {
-            "metric": "dfs.FSNamesystem.MissingBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "rpc.rpc.CallQueueLength",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/delete_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.DeleteNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CorruptBlocks": {
-            "metric": "dfs.FSNamesystem.CorruptBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rename_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.RenameNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blockReport_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.BlockReportAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/mkdirs_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.MkdirsNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_fifteen": {
-            "metric": "load_fifteen",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "jvm.JvmMetrics.LogInfo",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/fsImageLoadTime": {
-            "metric": "dfs.namenode.FsImageLoadTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getListing_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetListingNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blocksBeingWrittenReport_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.blocksBeingWrittenReport_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rollEditLog_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.RollEditLogNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/addBlock_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.AddBlockAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blocksBeingWrittenReport_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.blocksBeingWrittenReport_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setOwner_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.SetOwnerAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "rpc.rpc.RpcProcessingTimeNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/mem_shared": {
-            "metric": "mem_shared",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/UnderReplicatedBlocks": {
-            "metric": "dfs.FSNamesystem.UnderReplicatedBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/sendHeartbeat_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.SendHeartbeatAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/CreateFileOps": {
-            "metric": "dfs.namenode.CreateFileOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/logError": {
-            "metric": "jvm.JvmMetrics.LogError",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginFailureAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_num": {
-            "metric": "cpu_num",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getProtocolVersion_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.getProtocolVersion_avg_time",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/register_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.RegisterDatanodeNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthorizationSuccesses",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getListing_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetListingAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "jvm.JvmMetrics.LogFatal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/renewLease_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.RenewLeaseAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          }
-        }
-      },
-      {
-        "type": "jmx",
-        "metrics": {
-          "metrics/dfs/namenode/Used": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Used",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/TotalLoad": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.TotalLoad",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memMaxM":{
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemMaxM",
-            "pointInTime" : true,
-            "temporal" : false
-          },
-          "metrics/dfs/FSNamesystem/BlockCapacity": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.BlockCapacity",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/TotalFiles": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.TotalFiles",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/HostName": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.HostName",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/GetListingOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.GetListingOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/UpgradeFinalized": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.UpgradeFinalized",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getProtocolVersion_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getProtocolVersion_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/fsync_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.fsync_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=ugi.loginSuccess_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/Safemode": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Safemode",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/CorruptBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystemMetrics.CorruptBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/LiveNodes": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.LiveNodes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/renewLease_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.renewLease_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getFileInfo_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getFileInfo_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityRemaining": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityRemaining",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/PercentRemaining": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.PercentRemaining",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/complete_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.complete_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityTotalGB": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityTotalGB",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getBlockLocations_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getBlockLocations_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/AddBlockOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.AddBlockOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityUsedGB": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityUsedGB",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Syncs_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.Syncs_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsBlocked",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcQueueTime_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/PercentUsed": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.PercentUsed",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/DecomNodes": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.DecomNodes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/blockReport_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.blockReport_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/NonDfsUsedSpace": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.NonDfsUsedSpace",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/UpgradeFinalized": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.UpgradeFinalized",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getFileInfo_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getFileInfo_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getEditLogSize_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getEditLogSize_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=ugi.loginSuccess_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReceived_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.blockReceived_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Safemode": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Safemode",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/FilesCreated": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.FilesCreated",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/addBlock_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.addBlock_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/DecomNodes": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.DecomNodes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityUsed": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityUsed",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/NonHeapMemoryUsed": {
-            "metric": "java.lang:type=Memory.NonHeapMemoryUsage[used]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/DeadNodes": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.DeadNodes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/PercentUsed": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.PercentUsed",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Free": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Free",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Total": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Total",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/GetBlockLocations": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.GetBlockLocations",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=ugi.loginFailure_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/fsync_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.fsync_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/HeapMemoryMax": {
-            "metric": "java.lang:type=Memory.HeapMemoryUsage[max]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/create_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.create_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/PendingReplicationBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.PendingReplicationBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/UnderReplicatedBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystemMetrics.UnderReplicatedBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/FileInfoOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.FileInfoOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/MissingBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystemMetrics.MissingBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/sendHeartbeat_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.sendHeartbeat_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcProcessingTime_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReport_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.blockReport_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/CapacityRemaining": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystemState.CapacityRemaining",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.rpcAuthenticationSuccesses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/PendingDeletionBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.PendingDeletionBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.rpcAuthenticationFailures",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getEditLogSize_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getEditLogSize_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemHeapCommittedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/FilesInGetListingOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.FilesInGetListingOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsRunnable",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/BlocksTotal": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystemMetrics.BlocksTotal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityTotal": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityTotal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/complete_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.complete_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/LiveNodes": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.LiveNodes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsNew",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollFsImage_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.rollFsImage_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.rpcAuthorizationFailures",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Syncs_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.Syncs_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/StartTime": {
-            "metric": "java.lang:type=Runtime.StartTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcQueueTime_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReceived_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.blockReceived_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollEditLog_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.rollEditLog_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/DeadNodes": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.DeadNodes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.SentBytes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/HeapMemoryUsed": {
-            "metric": "java.lang:type=Memory.HeapMemoryUsage[used]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/FilesTotal": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.FilesTotal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Version": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Version",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.LogWarn",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/ExcessBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.ExcessBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.GcCount",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/PercentRemaining": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.PercentRemaining",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.ReceivedBytes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/blockReport_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.blockReport_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/NonHeapMemoryMax": {
-            "metric": "java.lang:type=Memory.NonHeapMemoryUsage[max]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollFsImage_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.rollFsImage_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.NumOpenConnections",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemHeapUsedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/ScheduledReplicationBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.ScheduledReplicationBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsWaiting",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/BlocksTotal": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.BlocksTotal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.GcTimeMillis",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getBlockLocations_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getBlockLocations_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Transactions_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.Transactions_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/create_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.create_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/CapacityTotal": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Total",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsTerminated",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityRemainingGB": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityRemainingGB",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Transactions_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.Transactions_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/MissingBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.MissingBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Threads": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Threads",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.callQueueLen",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CorruptBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CorruptBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReport_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.blockReport_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/TotalFiles": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.TotalFiles",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.LogInfo",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/NameDirStatuses": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.NameDirStatuses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getListing_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getListing_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollEditLog_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.rollEditLog_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/addBlock_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.addBlock_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcProcessingTime_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/CapacityUsed": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Used",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/UnderReplicatedBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.UnderReplicatedBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/sendHeartbeat_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.sendHeartbeat_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/CreateFileOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNode.CreateFileOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logError": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.LogError",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=ugi.loginFailure_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getProtocolVersion_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getProtocolVersion_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.rpcAuthorizationSuccesses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "ServiceComponentInfo/Version": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Version",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getListing_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.getListing_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.LogFatal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/NonDfsUsedSpace": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.NonDfsUsedSpace",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/renewLease_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.renewLease_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/TotalBlocks": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.TotalBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityNonDFSUsed": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityNonDFSUsed",
-            "pointInTime": true,
-            "temporal": false
-          }
-        }
-      }
-    ],
-    "HostComponent": [
-      {
-        "type": "ganglia",
-        "metrics": {
-          "metrics/dfs/FSNamesystem/TotalLoad": {
-            "metric": "dfs.FSNamesystem.TotalLoad",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/BlockCapacity": {
-            "metric": "dfs.FSNamesystem.BlockCapacity",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityTotal": {
-            "metric": "dfs.FSNamesystem.CapacityTotal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityUsed": {
-            "metric": "dfs.FSNamesystem.CapacityUsed",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityRemaining": {
-            "metric": "dfs.FSNamesystem.CapacityRemaining",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityNonDFSUsed": {
-            "metric": "dfs.FSNamesystem.CapacityUsedNonDFS",
-            "pointInTime": false,
-            "temporal": true
-          }, 
-          "metrics/dfs/namenode/GetListingOps": {
-            "metric": "dfs.namenode.GetListingOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesAppended": {
-            "metric": "dfs.namenode.FilesAppended",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getProtocolVersion_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.getProtocolVersion_num_ops",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/fsync_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.FsyncAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginSuccessAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/load/load_one": {
-            "metric": "load_one",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/renewLease_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.RenewLeaseNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getFileInfo_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetFileInfoAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/complete_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.CompleteAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setPermission_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.SetPermissionNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityTotalGB": {
-            "metric": "dfs.FSNamesystem.CapacityTotalGB",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setOwner_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.SetOwnerNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getBlockLocations_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetBlockLocationsNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/process/proc_run": {
-            "metric": "proc_run",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityUsedGB": {
-            "metric": "dfs.FSNamesystem.CapacityUsedGB",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/AddBlockOps": {
-            "metric": "dfs.namenode.AddBlockOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/swap_total": {
-            "metric": "swap_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesDeleted": {
-            "metric": "dfs.namenode.FilesDeleted",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/Syncs_avg_time": {
-            "metric": "dfs.namenode.SyncsAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "jvm.JvmMetrics.ThreadsBlocked",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "rpc.rpc.RpcQueueTimeNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/process/proc_total": {
-            "metric": "proc_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/blockReport_avg_time": {
-            "metric": "dfs.namenode.BlockReportAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/disk/part_max_used": {
-            "metric": "part_max_used",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getFileInfo_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetFileInfoNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getEditLogSize_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetEditLogManifestAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginSuccessNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blockReceived_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.BlockReceivedAndDeletedAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_idle": {
-            "metric": "cpu_idle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/versionRequest_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.VersionRequestAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_aidle": {
-            "metric": "cpu_aidle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_free": {
-            "metric": "mem_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/versionRequest_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.VersionRequestNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/addBlock_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.AddBlockNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesCreated": {
-            "metric": "dfs.namenode.FilesCreated",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rename_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.RenameAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/bytes_in": {
-            "metric": "bytes_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setSafeMode_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.SetSafeModeNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/pkts_out": {
-            "metric": "pkts_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/mem_cached": {
-            "metric": "mem_cached",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/disk_total": {
-            "metric": "disk_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setPermission_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.SetPermissionAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesRenamed": {
-            "metric": "dfs.namenode.FilesRenamed",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/register_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.RegisterDatanodeAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setReplication_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.setReplication_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/JournalTransactionsBatchedInSync": {
-            "metric": "dfs.namenode.JournalTransactionsBatchedInSync",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginFailureNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/GetBlockLocations": {
-            "metric": "dfs.namenode.GetBlockLocations",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/fsync_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.FsyncNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_wio": {
-            "metric": "cpu_wio",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/create_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.CreateAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/PendingReplicationBlocks": {
-            "metric": "dfs.FSNamesystem.PendingReplicationBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_speed": {
-            "metric": "cpu_speed",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/delete_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.DeleteAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FileInfoOps": {
-            "metric": "dfs.namenode.FileInfoOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/sendHeartbeat_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.SendHeartbeatNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/DeleteFileOps": {
-            "metric": "dfs.namenode.DeleteFileOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "rpc.rpc.RpcProcessingTimeAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blockReport_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.BlockReportNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setSafeMode_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.SetSafeModeAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthenticationSuccesses",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/PendingDeletionBlocks": {
-            "metric": "dfs.FSNamesystem.PendingDeletionBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "rpc.rpc.RpcAuthenticationFailures",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/network/pkts_in": {
-            "metric": "pkts_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_total": {
-            "metric": "mem_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getEditLogSize_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetEditLogManifestNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemHeapCommittedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/FilesInGetListingOps": {
-            "metric": "dfs.namenode.FilesInGetListingOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "jvm.JvmMetrics.ThreadsRunnable",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/complete_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.CompleteNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "jvm.JvmMetrics.ThreadsNew",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rollFsImage_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.rollFsImage_num_ops",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "rpc.rpc.RpcAuthorizationFailures",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/Syncs_num_ops": {
-            "metric": "dfs.namenode.SyncsNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "rpc.rpc.RpcQueueTimeAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blockReceived_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.BlockReceivedAndDeletedNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setReplication_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.setReplication_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rollEditLog_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.RollEditLogAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "rpc.rpc.SentBytes",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/FilesTotal": {
-            "metric": "dfs.FSNamesystem.FilesTotal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "jvm.JvmMetrics.LogWarn",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/ExcessBlocks": {
-            "metric": "dfs.FSNamesystem.ExcessBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "jvm.JvmMetrics.GcCount",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "rpc.rpc.ReceivedBytes",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_nice": {
-            "metric": "cpu_nice",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/blockReport_num_ops": {
-            "metric": "dfs.namenode.BlockReportNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/SafemodeTime": {
-            "metric": "dfs.namenode.SafemodeTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rollFsImage_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.rollFsImage_avg_time",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/mkdirs_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.MkdirsAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "rpc.rpc.NumOpenConnections",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemHeapUsedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/ScheduledReplicationBlocks": {
-            "metric": "dfs.FSNamesystem.ScheduledReplicationBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsWaiting",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/disk/disk_free": {
-            "metric": "disk_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/BlocksTotal": {
-            "metric": "dfs.FSNamesystem.BlocksTotal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/mem_buffers": {
-            "metric": "mem_buffers",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "jvm.JvmMetrics.GcTimeMillis",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getBlockLocations_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetBlockLocationsAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/Transactions_num_ops": {
-            "metric": "dfs.namenode.TransactionsNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/create_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.CreateNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "jvm.JvmMetrics.ThreadsTerminated",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/network/bytes_out": {
-            "metric": "bytes_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_user": {
-            "metric": "cpu_user",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/swap_free": {
-            "metric": "swap_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_five": {
-            "metric": "load_five",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_system": {
-            "metric": "cpu_system",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CapacityRemainingGB": {
-            "metric": "dfs.FSNamesystem.CapacityRemainingGB",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/Transactions_avg_time": {
-            "metric": "dfs.namenode.TransactionsAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/boottime": {
-            "metric": "boottime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/MissingBlocks": {
-            "metric": "dfs.FSNamesystem.MissingBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "rpc.rpc.CallQueueLength",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/delete_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.DeleteNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/CorruptBlocks": {
-            "metric": "dfs.FSNamesystem.CorruptBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rename_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.RenameNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blockReport_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.BlockReportAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/mkdirs_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.MkdirsNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_fifteen": {
-            "metric": "load_fifteen",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "jvm.JvmMetrics.LogInfo",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/fsImageLoadTime": {
-            "metric": "dfs.namenode.FsImageLoadTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getListing_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetListingNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blocksBeingWrittenReport_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.blocksBeingWrittenReport_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/rollEditLog_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.RollEditLogNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/addBlock_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.AddBlockAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/blocksBeingWrittenReport_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.blocksBeingWrittenReport_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/setOwner_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.SetOwnerAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "rpc.rpc.RpcProcessingTimeNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/mem_shared": {
-            "metric": "mem_shared",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/FSNamesystem/UnderReplicatedBlocks": {
-            "metric": "dfs.FSNamesystem.UnderReplicatedBlocks",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/sendHeartbeat_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.SendHeartbeatAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/namenode/CreateFileOps": {
-            "metric": "dfs.namenode.CreateFileOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/logError": {
-            "metric": "jvm.JvmMetrics.LogError",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginFailureAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_num": {
-            "metric": "cpu_num",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getProtocolVersion_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.getProtocolVersion_avg_time",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/register_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.RegisterDatanodeNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthorizationSuccesses",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getListing_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetListingAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "jvm.JvmMetrics.LogFatal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/renewLease_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.RenewLeaseAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          }
-        }
-      },
-      {
-        "type": "jmx",
-        "metrics": {
-          "metrics/dfs/namenode/Used": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Used",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/TotalLoad": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.TotalLoad",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memMaxM":{
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemMaxM",
-            "pointInTime" : true,
-            "temporal" : false
-          },
-          "metrics/dfs/FSNamesystem/BlockCapacity": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.BlockCapacity",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/TotalFiles": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.TotalFiles",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/GetListingOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.GetListingOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/HostName": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.tag.Hostname",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/runtime/StartTime": {
-            "metric": "java.lang:type=Runtime.StartTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/UpgradeFinalized": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.UpgradeFinalized",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getProtocolVersion_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.VersionRequestNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/fsync_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.FsyncAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=UgiMetrics.LoginSuccessAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/renewLease_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.renewLease_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityRemaining": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityRemaining",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getFileInfo_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.GetFileInfoAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/PercentRemaining": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.PercentRemaining",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/complete_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.CompleteAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityTotalGB": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityTotalGB",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getBlockLocations_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.GetBlockLocationsNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityUsedGB": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityUsedGB",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/AddBlockOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.AddBlockOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Syncs_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.SyncsAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsBlocked",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/PercentUsed": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.PercentUsed",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcQueueTimeNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/blockReport_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.BlockReportAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/HeapMemoryMax": {
-            "metric": "java.lang:type=Memory.HeapMemoryUsage[max]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/HeapMemoryUsed": {
-            "metric": "java.lang:type=Memory.HeapMemoryUsage[used]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getFileInfo_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.GetFileInfoNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getEditLogSize_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.GetEditLogManifestAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=UgiMetrics.LoginSuccessNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReceived_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.BlockReceivedAndDeletedAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/addBlock_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.AddBlockNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/FilesCreated": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.FilesCreated",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Safemode": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Safemode",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityUsed": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityUsed",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/DecomNodes": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.DecomNodes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Free": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Free",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Total": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Total",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/HAState": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.tag#HAState",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/GetBlockLocations": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.GetBlockLocations",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=UgiMetrics.LoginFailureNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/fsync_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.FsyncNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/NonHeapMemoryMax": {
-            "metric": "java.lang:type=Memory.NonHeapMemoryUsage[max]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/create_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.CreateAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/PendingReplicationBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.PendingReplicationBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/FileInfoOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.FileInfoOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/sendHeartbeat_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.SendHeartbeatNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcProcessingTimeAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReport_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.BlockReportNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcAuthenticationSuccesses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/PendingDeletionBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.PendingDeletionBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcAuthenticationFailures",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemHeapCommittedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getEditLogSize_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.GetEditLogManifestNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/NonHeapMemoryUsed": {
-            "metric": "java.lang:type=Memory.NonHeapMemoryUsage[used]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/FilesInGetListingOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.FilesInGetListingOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsRunnable",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityTotal": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityTotal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/LiveNodes": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.LiveNodes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/complete_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.CompleteNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsNew",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollFsImage_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.rollFsImage_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcAuthorizationFailures",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Syncs_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.SyncsNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcQueueTimeAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReceived_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.BlockReceivedAndDeletedNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollEditLog_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.RollEditLogAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/DeadNodes": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.DeadNodes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.SentBytes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/FilesTotal": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.FilesTotal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Version": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Version",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.LogWarn",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/ExcessBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.ExcessBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.GcCount",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.ReceivedBytes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/blockReport_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.BlockReportNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollFsImage_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.rollFsImage_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.NumOpenConnections",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.MemHeapUsedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/ScheduledReplicationBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.ScheduledReplicationBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsWaiting",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/BlocksTotal": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.BlocksTotal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.GcTimeMillis",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getBlockLocations_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.GetBlockLocationsAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Transactions_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.TransactionsNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/create_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.CreateNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.ThreadsTerminated",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityRemainingGB": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityRemainingGB",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Transactions_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.TransactionsAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/MissingBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.MissingBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/Threads": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.Threads",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.CallQueueLength",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CorruptBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CorruptBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReport_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.BlockReportAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.LogInfo",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/NameDirStatuses": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.NameDirStatuses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getListing_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.GetListingNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollEditLog_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.RollEditLogNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/addBlock_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.AddBlockAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcProcessingTimeNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/UnderReplicatedBlocks": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.UnderReplicatedBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/sendHeartbeat_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.SendHeartbeatAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/CreateFileOps": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeActivity.CreateFileOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logError": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.LogError",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=UgiMetrics.LoginFailureAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getProtocolVersion_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.VersionRequestAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "Hadoop:service=NameNode,name=RpcActivity.RpcAuthorizationSuccesses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getListing_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.GetListingAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "Hadoop:service=NameNode,name=JvmMetrics.LogFatal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/NonDfsUsedSpace": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.NonDfsUsedSpace",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/renewLease_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=RpcDetailedActivity.renewLease_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/JournalTransactionInfo": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.JournalTransactionInfo",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityNonDFSUsed": {
-            "metric": "Hadoop:service=NameNode,name=FSNamesystem.CapacityUsedNonDFS",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/namenode/TotalBlocks": {
-            "metric": "Hadoop:service=NameNode,name=NameNodeInfo.TotalBlocks",
-            "pointInTime": true,
-            "temporal": false
-          }
-        }
-      }
-    ]
-  },
-  "DATANODE": {
-    "Component": [
-      {
-        "type": "ganglia",
-        "metrics": {
-          "metrics/dfs/datanode/heartBeats_avg_time": {
-            "metric": "dfs.datanode.HeartbeatsAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/closeRegion_num_ops": {
-            "metric": "rpc.rpc.closeRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unassign_num_ops": {
-            "metric": "rpc.rpc.unassign_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/modifyTable_num_ops": {
-            "metric": "rpc.rpc.modifyTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getProtocolVersion_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.getProtocolVersion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/splitRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.splitRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginSuccessAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getZooKeeper/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getZooKeeper.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolVersion_avg_time": {
-            "metric": "rpc.rpc.getProtocolVersion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHServerInfo/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getHServerInfo.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_one": {
-            "metric": "load_one",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/writes_from_remote_client": {
-            "metric": "dfs.datanode.WritesFromRemoteClient",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClosestRowBefore_num_ops": {
-            "metric": "rpc.rpc.getClosestRowBefore_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClosestRowBefore/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getClosestRowBefore.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_replicated": {
-            "metric": "dfs.datanode.BlocksReplicated",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getTask_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.getTask_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/replicateLogEntries_num_ops": {
-            "metric": "rpc.rpc.replicateLogEntries_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/flushRegion_avg_time": {
-            "metric": "rpc.rpc.flushRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/lockRow_num_ops": {
-            "metric": "rpc.rpc.lockRow_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/swap_total": {
-            "metric": "swap_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/multi_avg_time": {
-            "metric": "rpc.rpc.multi_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.openRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stopMaster_num_ops": {
-            "metric": "rpc.rpc.stopMaster_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_get_local_pathinfo": {
-            "metric": "dfs.datanode.BlocksGetLocalPathInfo",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/balance_avg_time": {
-            "metric": "rpc.rpc.balance_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/process/proc_total": {
-            "metric": "proc_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/splitRegion_num_ops": {
-            "metric": "rpc.rpc.splitRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/part_max_used": {
-            "metric": "part_max_used",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getCatalogTracker_avg_time": {
-            "metric": "rpc.rpc.getCatalogTracker_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/readBlockOp_num_ops": {
-            "metric": "dfs.datanode.ReadBlockOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/writeBlockOp_num_ops": {
-            "metric": "dfs.datanode.WriteBlockOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/modifyColumn_avg_time": {
-            "metric": "rpc.rpc.modifyColumn_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/multi/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.multi.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/balance_num_ops": {
-            "metric": "rpc.rpc.balance_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getZooKeeper_num_ops": {
-            "metric": "rpc.rpc.getZooKeeper_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/shutdown_num_ops": {
-            "metric": "rpc.rpc.shutdown_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/flushRegion_num_ops": {
-            "metric": "rpc.rpc.flushRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginSuccessNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isAborted/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.isAborted.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_idle": {
-            "metric": "cpu_idle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rollHLogWriter/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.rollHLogWriter.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/removeFromOnlineRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.removeFromOnlineRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolSignature/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getProtocolSignature.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/get_num_ops": {
-            "metric": "rpc.rpc.get_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blockChecksumOp_num_ops": {
-            "metric": "dfs.datanode.BlockChecksumOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getServerName_avg_time": {
-            "metric": "rpc.rpc.getServerName_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stopMaster_avg_time": {
-            "metric": "rpc.rpc.stopMaster_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getOnlineRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getOnlineRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/bytes_in": {
-            "metric": "bytes_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/removeFromOnlineRegions_num_ops": {
-            "metric": "rpc.rpc.removeFromOnlineRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/abort_avg_time": {
-            "metric": "rpc.rpc.abort_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openScanner/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.openScanner.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/ping_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.ping_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getRegionInfo_avg_time": {
-            "metric": "rpc.rpc.getRegionInfo_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getCatalogTracker/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getCatalogTracker.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getBlockLocalPathInfo_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.getBlockLocalPathInfo_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/enableTable_num_ops": {
-            "metric": "rpc.rpc.enableTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/lockRow/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.lockRow.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/lockRow_avg_time": {
-            "metric": "rpc.rpc.lockRow_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/commitPending_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.commitPending_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkOOME_num_ops": {
-            "metric": "rpc.rpc.checkOOME_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addColumn_avg_time": {
-            "metric": "rpc.rpc.addColumn_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addToOnlineRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.addToOnlineRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/reportRSFatalError_num_ops": {
-            "metric": "rpc.rpc.reportRSFatalError_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginFailureNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_wio": {
-            "metric": "cpu_wio",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getConfiguration/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getConfiguration.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getZooKeeper/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getZooKeeper.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/reads_from_local_client": {
-            "metric": "dfs.datanode.ReadsFromLocalClient",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getServerName_num_ops": {
-            "metric": "rpc.rpc.getServerName_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getServerName/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getServerName.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blockReports_num_ops": {
-            "metric": "dfs.datanode.BlockReportsNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/reportRSFatalError_avg_time": {
-            "metric": "rpc.rpc.reportRSFatalError_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthenticationSuccesses",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/pkts_in": {
-            "metric": "pkts_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isStopped/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.isStopped.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/disableTable_avg_time": {
-            "metric": "rpc.rpc.disableTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_total": {
-            "metric": "mem_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rollHLogWriter/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.rollHLogWriter.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemHeapCommittedM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/abort/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.abort.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "jvm.JvmMetrics.ThreadsRunnable",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegion_avg_time": {
-            "metric": "rpc.rpc.openRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "jvm.JvmMetrics.ThreadsNew",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unlockRow/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.unlockRow.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClusterStatus_num_ops": {
-            "metric": "rpc.rpc.getClusterStatus_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHTableDescriptors_avg_time": {
-            "metric": "rpc.rpc.getHTableDescriptors_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "rpc.rpc.RpcAuthorizationFailures",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/deleteColumn_num_ops": {
-            "metric": "rpc.rpc.deleteColumn_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/regionServerReport_avg_time": {
-            "metric": "rpc.rpc.regionServerReport_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/delete/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.delete.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "rpc.rpc.RpcQueueTimeAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/increment_num_ops": {
-            "metric": "rpc.rpc.increment_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getMapCompletionEvents_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.getMapCompletionEvents_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stop/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.stop.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getAlterStatus_num_ops": {
-            "metric": "rpc.rpc.getAlterStatus_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/modifyColumn_num_ops": {
-            "metric": "rpc.rpc.modifyColumn_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/flushRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.flushRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/next_avg_time": {
-            "metric": "rpc.rpc.next_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/incrementColumnValue/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.incrementColumnValue.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/next/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.next.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkOOME_avg_time": {
-            "metric": "rpc.rpc.checkOOME_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcSlowResponse_avg_time": {
-            "metric": "rpc.rpc.RpcSlowResponse_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getConfiguration_avg_time": {
-            "metric": "rpc.rpc.getConfiguration_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getServerName/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getServerName.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "rpc.rpc.ReceivedBytes",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_nice": {
-            "metric": "cpu_nice",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/bulkLoadHFiles_num_ops": {
-            "metric": "rpc.rpc.bulkLoadHFiles_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/ping_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.ping_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unassign_avg_time": {
-            "metric": "rpc.rpc.unassign_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "rpc.rpc.NumOpenConnections",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "jvm.JvmMetrics.GcTimeMillis",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/delete/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.delete.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/canCommit_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.canCommit_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/multi/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.multi.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "jvm.JvmMetrics.ThreadsTerminated",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolVersion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getProtocolVersion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/bytes_out": {
-            "metric": "bytes_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndDelete/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.checkAndDelete.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/balanceSwitch_avg_time": {
-            "metric": "rpc.rpc.balanceSwitch_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_five": {
-            "metric": "load_five",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_read": {
-            "metric": "dfs.datanode.BlocksRead",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/boottime": {
-            "metric": "boottime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.openRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/lockRow/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.lockRow.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/compactRegion_avg_time": {
-            "metric": "rpc.rpc.compactRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegion_num_ops": {
-            "metric": "rpc.rpc.openRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "rpc.rpc.CallQueueLength",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_removed": {
-            "metric": "dfs.datanode.BlocksRemoved",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/compactRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.compactRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolSignature/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getProtocolSignature.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/execCoprocessor_num_ops": {
-            "metric": "rpc.rpc.execCoprocessor_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/canCommit_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.canCommit_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHServerInfo/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getHServerInfo.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/readBlockOp_avg_time": {
-            "metric": "dfs.datanode.ReadBlockOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getOnlineRegions_avg_time": {
-            "metric": "rpc.rpc.getOnlineRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getCatalogTracker/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getCatalogTracker.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/incrementColumnValue_avg_time": {
-            "metric": "rpc.rpc.incrementColumnValue_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/move_num_ops": {
-            "metric": "rpc.rpc.move_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "rpc.rpc.RpcProcessingTimeNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stop_num_ops": {
-            "metric": "rpc.rpc.stop_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/replicateLogEntries_avg_time": {
-            "metric": "rpc.rpc.replicateLogEntries_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/deleteTable_num_ops": {
-            "metric": "rpc.rpc.deleteTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blockChecksumOp_avg_time": {
-            "metric": "dfs.datanode.BlockChecksumOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/copyBlockOp_avg_time": {
-            "metric": "dfs.datanode.CopyBlockOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/get_avg_time": {
-            "metric": "rpc.rpc.get_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logError": {
-            "metric": "jvm.JvmMetrics.LogError",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/multi_num_ops": {
-            "metric": "rpc.rpc.multi_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/next/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.next.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/writeBlockOp_avg_time": {
-            "metric": "dfs.datanode.WriteBlockOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getBlockCacheColumnFamilySummaries_num_ops": {
-            "metric": "rpc.rpc.getBlockCacheColumnFamilySummaries_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getFromOnlineRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getFromOnlineRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addToOnlineRegions_avg_time": {
-            "metric": "rpc.rpc.addToOnlineRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getRegionInfo/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getRegionInfo.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/deleteColumn_avg_time": {
-            "metric": "rpc.rpc.deleteColumn_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/bulkLoadHFiles_avg_time": {
-            "metric": "rpc.rpc.bulkLoadHFiles_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isAborted/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.isAborted.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/exists_avg_time": {
-            "metric": "rpc.rpc.exists_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stop/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.stop.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addToOnlineRegions_num_ops": {
-            "metric": "rpc.rpc.addToOnlineRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/abort/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.abort.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/removeFromOnlineRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.removeFromOnlineRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getOnlineRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getOnlineRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/exists/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.exists.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/offline_avg_time": {
-            "metric": "rpc.rpc.offline_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/replicateLogEntries/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.replicateLogEntries.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unlockRow_avg_time": {
-            "metric": "rpc.rpc.unlockRow_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/delete_num_ops": {
-            "metric": "rpc.rpc.delete_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getCatalogTracker_num_ops": {
-            "metric": "rpc.rpc.getCatalogTracker_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/regionServerStartup_avg_time": {
-            "metric": "rpc.rpc.regionServerStartup_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkOOME/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.checkOOME.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/exists_num_ops": {
-            "metric": "rpc.rpc.exists_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndDelete_num_ops": {
-            "metric": "rpc.rpc.checkAndDelete_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndPut/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.checkAndPut.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/closeRegion_avg_time": {
-            "metric": "rpc.rpc.closeRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getBlockLocalPathInfo_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.getBlockLocalPathInfo_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/close/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.close.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolSignature_avg_time": {
-            "metric": "rpc.rpc.getProtocolSignature_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/assign_avg_time": {
-            "metric": "rpc.rpc.assign_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/createTable_num_ops": {
-            "metric": "rpc.rpc.createTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/execCoprocessor_avg_time": {
-            "metric": "rpc.rpc.execCoprocessor_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/process/proc_run": {
-            "metric": "proc_run",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/close_avg_time": {
-            "metric": "rpc.rpc.close_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getConfiguration_num_ops": {
-            "metric": "rpc.rpc.getConfiguration_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "jvm.JvmMetrics.ThreadsBlocked",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHServerInfo_num_ops": {
-            "metric": "rpc.rpc.getHServerInfo_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isStopped_avg_time": {
-            "metric": "rpc.rpc.isStopped_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "rpc.rpc.RpcQueueTimeNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stop_avg_time": {
-            "metric": "rpc.rpc.stop_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rollHLogWriter_avg_time": {
-            "metric": "rpc.rpc.rollHLogWriter_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/writes_from_local_client": {
-            "metric": "dfs.datanode.WritesFromLocalClient",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isStopped_num_ops": {
-            "metric": "rpc.rpc.isStopped_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addToOnlineRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.addToOnlineRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getMapCompletionEvents_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.getMapCompletionEvents_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/heartBeats_num_ops": {
-            "metric": "dfs.datanode.HeartbeatsNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/replaceBlockOp_num_ops": {
-            "metric": "dfs.datanode.ReplaceBlockOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isMasterRunning_avg_time": {
-            "metric": "rpc.rpc.isMasterRunning_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/incrementColumnValue_num_ops": {
-            "metric": "rpc.rpc.incrementColumnValue_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/copyBlockOp_num_ops": {
-            "metric": "dfs.datanode.CopyBlockOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/bulkLoadHFiles/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.bulkLoadHFiles.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_aidle": {
-            "metric": "cpu_aidle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_free": {
-            "metric": "mem_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/execCoprocessor/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.execCoprocessor.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/close/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.close.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/assign_num_ops": {
-            "metric": "rpc.rpc.assign_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/enableTable_avg_time": {
-            "metric": "rpc.rpc.enableTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/incrementColumnValue/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.incrementColumnValue.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndDelete/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.checkAndDelete.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/pkts_out": {
-            "metric": "pkts_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getFromOnlineRegions_num_ops": {
-            "metric": "rpc.rpc.getFromOnlineRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/close_num_ops": {
-            "metric": "rpc.rpc.close_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_cached": {
-            "metric": "mem_cached",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getConfiguration/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getConfiguration.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/disk_total": {
-            "metric": "disk_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/get/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.get.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/done_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.done_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openScanner_avg_time": {
-            "metric": "rpc.rpc.openScanner_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcSlowResponse_num_ops": {
-            "metric": "rpc.rpc.RpcSlowResponse_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getFromOnlineRegions_avg_time": {
-            "metric": "rpc.rpc.getFromOnlineRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/reads_from_remote_client": {
-            "metric": "dfs.datanode.ReadsFromRemoteClient",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/splitRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.splitRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClosestRowBefore/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getClosestRowBefore.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/flushRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.flushRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isAborted_avg_time": {
-            "metric": "rpc.rpc.isAborted_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/increment/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.increment.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getBlockCacheColumnFamilySummaries/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getBlockCacheColumnFamilySummaries.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/deleteTable_avg_time": {
-            "metric": "rpc.rpc.deleteTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/commitPending_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.commitPending_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/bytes_read": {
-            "metric": "dfs.datanode.BytesRead",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/put/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.put.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_verified": {
-            "metric": "dfs.datanode.BlocksVerified",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/delete_avg_time": {
-            "metric": "rpc.rpc.delete_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClosestRowBefore_avg_time": {
-            "metric": "rpc.rpc.getClosestRowBefore_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_speed": {
-            "metric": "cpu_speed",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/get/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.get.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/statusUpdate_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.statusUpdate_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/compactRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.compactRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.openRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "rpc.rpc.RpcProcessingTimeAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/put_num_ops": {
-            "metric": "rpc.rpc.put_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/move_avg_time": {
-            "metric": "rpc.rpc.move_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "rpc.rpc.RpcAuthenticationFailures",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openScanner/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.openScanner.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClusterStatus_avg_time": {
-            "metric": "rpc.rpc.getClusterStatus_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/bytes_written": {
-            "metric": "dfs.datanode.BytesWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unlockRow/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.unlockRow.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/removeFromOnlineRegions_avg_time": {
-            "metric": "rpc.rpc.removeFromOnlineRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/modifyTable_avg_time": {
-            "metric": "rpc.rpc.modifyTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/put/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.put.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndPut_avg_time": {
-            "metric": "rpc.rpc.checkAndPut_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blockReports_avg_time": {
-            "metric": "dfs.datanode.BlockReportsAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/replaceBlockOp_avg_time": {
-            "metric": "dfs.datanode.ReplaceBlockOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isStopped/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.isStopped.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/put_avg_time": {
-            "metric": "rpc.rpc.put_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/increment/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.increment.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.openRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "rpc.rpc.SentBytes",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/createTable_avg_time": {
-            "metric": "rpc.rpc.createTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getTask_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.getTask_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getRegionInfo/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getRegionInfo.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addColumn_num_ops": {
-            "metric": "rpc.rpc.addColumn_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHTableDescriptors_num_ops": {
-            "metric": "rpc.rpc.getHTableDescriptors_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getAlterStatus_avg_time": {
-            "metric": "rpc.rpc.getAlterStatus_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getRegionInfo_num_ops": {
-            "metric": "rpc.rpc.getRegionInfo_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/maxMemoryM": {
-            "metric": "jvm.metrics.maxMemoryM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "jvm.JvmMetrics.LogWarn",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/statusUpdate_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.statusUpdate_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/compactRegion_num_ops": {
-            "metric": "rpc.rpc.compactRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getFromOnlineRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getFromOnlineRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isAborted_num_ops": {
-            "metric": "rpc.rpc.isAborted_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "jvm.JvmMetrics.GcCount",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getOnlineRegions_num_ops": {
-            "metric": "rpc.rpc.getOnlineRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/done_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.done_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkOOME/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.checkOOME.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemHeapUsedM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolVersion_num_ops": {
-            "metric": "rpc.rpc.getProtocolVersion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/disk_free": {
-            "metric": "disk_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsWaiting",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unlockRow_num_ops": {
-            "metric": "rpc.rpc.unlockRow_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/replicateLogEntries/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.replicateLogEntries.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/disableTable_num_ops": {
-            "metric": "rpc.rpc.disableTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_buffers": {
-            "metric": "mem_buffers",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/shutdown_avg_time": {
-            "metric": "rpc.rpc.shutdown_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openScanner_num_ops": {
-            "metric": "rpc.rpc.openScanner_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/regionServerStartup_num_ops": {
-            "metric": "rpc.rpc.regionServerStartup_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/bulkLoadHFiles/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.bulkLoadHFiles.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_user": {
-            "metric": "cpu_user",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/swap_free": {
-            "metric": "swap_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_system": {
-            "metric": "cpu_system",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/exists/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.exists.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegions_avg_time": {
-            "metric": "rpc.rpc.openRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/regionServerReport_num_ops": {
-            "metric": "rpc.rpc.regionServerReport_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/next_num_ops": {
-            "metric": "rpc.rpc.next_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getBlockCacheColumnFamilySummaries_avg_time": {
-            "metric": "rpc.rpc.getBlockCacheColumnFamilySummaries_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/block_verification_failures": {
-            "metric": "dfs.datanode.BlockVerificationFailures",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/closeRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.closeRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndDelete_avg_time": {
-            "metric": "rpc.rpc.checkAndDelete_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_fifteen": {
-            "metric": "load_fifteen",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHServerInfo_avg_time": {
-            "metric": "rpc.rpc.getHServerInfo_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "jvm.JvmMetrics.LogInfo",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getBlockCacheColumnFamilySummaries/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getBlockCacheColumnFamilySummaries.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getZooKeeper_avg_time": {
-            "metric": "rpc.rpc.getZooKeeper_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/execCoprocessor/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.execCoprocessor.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_written": {
-            "metric": "dfs.datanode.BlocksWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/balanceSwitch_num_ops": {
-            "metric": "rpc.rpc.balanceSwitch_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isMasterRunning_num_ops": {
-            "metric": "rpc.rpc.isMasterRunning_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/offline_num_ops": {
-            "metric": "rpc.rpc.offline_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_shared": {
-            "metric": "mem_shared",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolSignature_num_ops": {
-            "metric": "rpc.rpc.getProtocolSignature_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/abort_num_ops": {
-            "metric": "rpc.rpc.abort_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolVersion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getProtocolVersion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginFailureAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_num": {
-            "metric": "cpu_num",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getProtocolVersion_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.getProtocolVersion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rollHLogWriter_num_ops": {
-            "metric": "rpc.rpc.rollHLogWriter_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthorizationSuccesses",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegions_num_ops": {
-            "metric": "rpc.rpc.openRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "jvm.JvmMetrics.LogFatal",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/splitRegion_avg_time": {
-            "metric": "rpc.rpc.splitRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/closeRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.closeRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndPut_num_ops": {
-            "metric": "rpc.rpc.checkAndPut_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndPut/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.checkAndPut.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/increment_avg_time": {
-            "metric": "rpc.rpc.increment_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          }
-        }
-      }
-    ],
-    "HostComponent": [
-      {
-        "type": "ganglia",
-        "metrics": {
-          "metrics/dfs/datanode/heartBeats_avg_time": {
-            "metric": "dfs.datanode.HeartbeatsAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/closeRegion_num_ops": {
-            "metric": "rpc.rpc.closeRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unassign_num_ops": {
-            "metric": "rpc.rpc.unassign_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/modifyTable_num_ops": {
-            "metric": "rpc.rpc.modifyTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/splitRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.splitRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginSuccessAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/getZooKeeper/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getZooKeeper.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolVersion_avg_time": {
-            "metric": "rpc.rpc.getProtocolVersion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHServerInfo/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getHServerInfo.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_one": {
-            "metric": "load_one",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/writes_from_remote_client": {
-            "metric": "dfs.datanode.WritesFromRemoteClient",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClosestRowBefore_num_ops": {
-            "metric": "rpc.rpc.getClosestRowBefore_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClosestRowBefore/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getClosestRowBefore.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_replicated": {
-            "metric": "dfs.datanode.BlocksReplicated",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/replicateLogEntries_num_ops": {
-            "metric": "rpc.rpc.replicateLogEntries_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/flushRegion_avg_time": {
-            "metric": "rpc.rpc.flushRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/lockRow_num_ops": {
-            "metric": "rpc.rpc.lockRow_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/swap_total": {
-            "metric": "swap_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/multi_avg_time": {
-            "metric": "rpc.rpc.multi_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.openRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stopMaster_num_ops": {
-            "metric": "rpc.rpc.stopMaster_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_get_local_pathinfo": {
-            "metric": "dfs.datanode.BlocksGetLocalPathInfo",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/process/proc_total": {
-            "metric": "proc_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/balance_avg_time": {
-            "metric": "rpc.rpc.balance_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/splitRegion_num_ops": {
-            "metric": "rpc.rpc.splitRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/part_max_used": {
-            "metric": "part_max_used",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getCatalogTracker_avg_time": {
-            "metric": "rpc.rpc.getCatalogTracker_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/readBlockOp_num_ops": {
-            "metric": "dfs.datanode.ReadBlockOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/writeBlockOp_num_ops": {
-            "metric": "dfs.datanode.WriteBlockOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/modifyColumn_avg_time": {
-            "metric": "rpc.rpc.modifyColumn_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/multi/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.multi.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/balance_num_ops": {
-            "metric": "rpc.rpc.balance_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getZooKeeper_num_ops": {
-            "metric": "rpc.rpc.getZooKeeper_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/shutdown_num_ops": {
-            "metric": "rpc.rpc.shutdown_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/flushRegion_num_ops": {
-            "metric": "rpc.rpc.flushRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginSuccessNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/isAborted/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.isAborted.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_idle": {
-            "metric": "cpu_idle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rollHLogWriter/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.rollHLogWriter.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/removeFromOnlineRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.removeFromOnlineRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolSignature/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getProtocolSignature.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/get_num_ops": {
-            "metric": "rpc.rpc.get_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blockChecksumOp_num_ops": {
-            "metric": "dfs.datanode.BlockChecksumOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getServerName_avg_time": {
-            "metric": "rpc.rpc.getServerName_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stopMaster_avg_time": {
-            "metric": "rpc.rpc.stopMaster_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getOnlineRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getOnlineRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/bytes_in": {
-            "metric": "bytes_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/removeFromOnlineRegions_num_ops": {
-            "metric": "rpc.rpc.removeFromOnlineRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/abort_avg_time": {
-            "metric": "rpc.rpc.abort_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openScanner/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.openScanner.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getRegionInfo_avg_time": {
-            "metric": "rpc.rpc.getRegionInfo_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getCatalogTracker/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getCatalogTracker.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/enableTable_num_ops": {
-            "metric": "rpc.rpc.enableTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/lockRow/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.lockRow.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/lockRow_avg_time": {
-            "metric": "rpc.rpc.lockRow_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkOOME_num_ops": {
-            "metric": "rpc.rpc.checkOOME_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addColumn_avg_time": {
-            "metric": "rpc.rpc.addColumn_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addToOnlineRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.addToOnlineRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/reportRSFatalError_num_ops": {
-            "metric": "rpc.rpc.reportRSFatalError_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginFailureNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_wio": {
-            "metric": "cpu_wio",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getConfiguration/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getConfiguration.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getZooKeeper/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getZooKeeper.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/reads_from_local_client": {
-            "metric": "dfs.datanode.ReadsFromLocalClient",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getServerName_num_ops": {
-            "metric": "rpc.rpc.getServerName_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getServerName/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getServerName.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blockReports_num_ops": {
-            "metric": "dfs.datanode.BlockReportsNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/reportRSFatalError_avg_time": {
-            "metric": "rpc.rpc.reportRSFatalError_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthenticationSuccesses",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/network/pkts_in": {
-            "metric": "pkts_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isStopped/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.isStopped.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/disableTable_avg_time": {
-            "metric": "rpc.rpc.disableTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_total": {
-            "metric": "mem_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rollHLogWriter/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.rollHLogWriter.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemHeapCommittedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/abort/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.abort.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "jvm.JvmMetrics.ThreadsRunnable",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/openRegion_avg_time": {
-            "metric": "rpc.rpc.openRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "jvm.JvmMetrics.ThreadsNew",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/unlockRow/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.unlockRow.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClusterStatus_num_ops": {
-            "metric": "rpc.rpc.getClusterStatus_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHTableDescriptors_avg_time": {
-            "metric": "rpc.rpc.getHTableDescriptors_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "rpc.rpc.RpcAuthorizationFailures",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/deleteColumn_num_ops": {
-            "metric": "rpc.rpc.deleteColumn_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/regionServerReport_avg_time": {
-            "metric": "rpc.rpc.regionServerReport_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/delete/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.delete.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "rpc.rpc.RpcQueueTimeAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/increment_num_ops": {
-            "metric": "rpc.rpc.increment_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stop/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.stop.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getAlterStatus_num_ops": {
-            "metric": "rpc.rpc.getAlterStatus_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/modifyColumn_num_ops": {
-            "metric": "rpc.rpc.modifyColumn_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/flushRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.flushRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/incrementColumnValue/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.incrementColumnValue.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/next_avg_time": {
-            "metric": "rpc.rpc.next_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/next/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.next.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkOOME_avg_time": {
-            "metric": "rpc.rpc.checkOOME_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcSlowResponse_avg_time": {
-            "metric": "rpc.rpc.RpcSlowResponse_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getConfiguration_avg_time": {
-            "metric": "rpc.rpc.getConfiguration_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getServerName/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getServerName.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "rpc.rpc.ReceivedBytes",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_nice": {
-            "metric": "cpu_nice",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/bulkLoadHFiles_num_ops": {
-            "metric": "rpc.rpc.bulkLoadHFiles_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unassign_avg_time": {
-            "metric": "rpc.rpc.unassign_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "rpc.rpc.NumOpenConnections",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "jvm.JvmMetrics.GcTimeMillis",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/delete/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.delete.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/multi/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.multi.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "jvm.JvmMetrics.ThreadsTerminated",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolVersion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getProtocolVersion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/bytes_out": {
-            "metric": "bytes_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndDelete/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.checkAndDelete.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/balanceSwitch_avg_time": {
-            "metric": "rpc.rpc.balanceSwitch_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_five": {
-            "metric": "load_five",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_read": {
-            "metric": "dfs.datanode.BlocksRead",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/boottime": {
-            "metric": "boottime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.openRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/lockRow/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.lockRow.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/compactRegion_avg_time": {
-            "metric": "rpc.rpc.compactRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegion_num_ops": {
-            "metric": "rpc.rpc.openRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "rpc.rpc.CallQueueLength",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_removed": {
-            "metric": "dfs.datanode.BlocksRemoved",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/compactRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.compactRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolSignature/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getProtocolSignature.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/execCoprocessor_num_ops": {
-            "metric": "rpc.rpc.execCoprocessor_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHServerInfo/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getHServerInfo.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/readBlockOp_avg_time": {
-            "metric": "dfs.datanode.ReadBlockOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getOnlineRegions_avg_time": {
-            "metric": "rpc.rpc.getOnlineRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getCatalogTracker/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getCatalogTracker.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/incrementColumnValue_avg_time": {
-            "metric": "rpc.rpc.incrementColumnValue_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/move_num_ops": {
-            "metric": "rpc.rpc.move_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "rpc.rpc.RpcProcessingTimeNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/stop_num_ops": {
-            "metric": "rpc.rpc.stop_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/replicateLogEntries_avg_time": {
-            "metric": "rpc.rpc.replicateLogEntries_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/deleteTable_num_ops": {
-            "metric": "rpc.rpc.deleteTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blockChecksumOp_avg_time": {
-            "metric": "dfs.datanode.BlockChecksumOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/copyBlockOp_avg_time": {
-            "metric": "dfs.datanode.CopyBlockOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/get_avg_time": {
-            "metric": "rpc.rpc.get_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logError": {
-            "metric": "jvm.JvmMetrics.LogError",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/multi_num_ops": {
-            "metric": "rpc.rpc.multi_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/next/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.next.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/writeBlockOp_avg_time": {
-            "metric": "dfs.datanode.WriteBlockOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getBlockCacheColumnFamilySummaries_num_ops": {
-            "metric": "rpc.rpc.getBlockCacheColumnFamilySummaries_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getFromOnlineRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getFromOnlineRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addToOnlineRegions_avg_time": {
-            "metric": "rpc.rpc.addToOnlineRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getRegionInfo/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getRegionInfo.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/deleteColumn_avg_time": {
-            "metric": "rpc.rpc.deleteColumn_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/bulkLoadHFiles_avg_time": {
-            "metric": "rpc.rpc.bulkLoadHFiles_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isAborted/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.isAborted.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/exists_avg_time": {
-            "metric": "rpc.rpc.exists_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/stop/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.stop.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addToOnlineRegions_num_ops": {
-            "metric": "rpc.rpc.addToOnlineRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/abort/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.abort.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/removeFromOnlineRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.removeFromOnlineRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getOnlineRegions/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getOnlineRegions.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/exists/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.exists.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/offline_avg_time": {
-            "metric": "rpc.rpc.offline_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/replicateLogEntries/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.replicateLogEntries.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unlockRow_avg_time": {
-            "metric": "rpc.rpc.unlockRow_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/delete_num_ops": {
-            "metric": "rpc.rpc.delete_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getCatalogTracker_num_ops": {
-            "metric": "rpc.rpc.getCatalogTracker_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/regionServerStartup_avg_time": {
-            "metric": "rpc.rpc.regionServerStartup_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkOOME/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.checkOOME.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/exists_num_ops": {
-            "metric": "rpc.rpc.exists_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndDelete_num_ops": {
-            "metric": "rpc.rpc.checkAndDelete_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndPut/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.checkAndPut.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/closeRegion_avg_time": {
-            "metric": "rpc.rpc.closeRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/close/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.close.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolSignature_avg_time": {
-            "metric": "rpc.rpc.getProtocolSignature_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/assign_avg_time": {
-            "metric": "rpc.rpc.assign_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/createTable_num_ops": {
-            "metric": "rpc.rpc.createTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/execCoprocessor_avg_time": {
-            "metric": "rpc.rpc.execCoprocessor_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/process/proc_run": {
-            "metric": "proc_run",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/close_avg_time": {
-            "metric": "rpc.rpc.close_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getConfiguration_num_ops": {
-            "metric": "rpc.rpc.getConfiguration_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "jvm.JvmMetrics.ThreadsBlocked",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/getHServerInfo_num_ops": {
-            "metric": "rpc.rpc.getHServerInfo_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isStopped_avg_time": {
-            "metric": "rpc.rpc.isStopped_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "rpc.rpc.RpcQueueTimeNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/stop_avg_time": {
-            "metric": "rpc.rpc.stop_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rollHLogWriter_avg_time": {
-            "metric": "rpc.rpc.rollHLogWriter_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isStopped_num_ops": {
-            "metric": "rpc.rpc.isStopped_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/writes_from_local_client": {
-            "metric": "dfs.datanode.WritesFromLocalClient",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addToOnlineRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.addToOnlineRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/heartBeats_num_ops": {
-            "metric": "dfs.datanode.HeartbeatsNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isMasterRunning_avg_time": {
-            "metric": "rpc.rpc.isMasterRunning_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/replaceBlockOp_num_ops": {
-            "metric": "dfs.datanode.ReplaceBlockOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/incrementColumnValue_num_ops": {
-            "metric": "rpc.rpc.incrementColumnValue_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/copyBlockOp_num_ops": {
-            "metric": "dfs.datanode.CopyBlockOpNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/bulkLoadHFiles/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.bulkLoadHFiles.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_aidle": {
-            "metric": "cpu_aidle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_free": {
-            "metric": "mem_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/execCoprocessor/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.execCoprocessor.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/close/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.close.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/assign_num_ops": {
-            "metric": "rpc.rpc.assign_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/enableTable_avg_time": {
-            "metric": "rpc.rpc.enableTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/incrementColumnValue/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.incrementColumnValue.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndDelete/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.checkAndDelete.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/pkts_out": {
-            "metric": "pkts_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getFromOnlineRegions_num_ops": {
-            "metric": "rpc.rpc.getFromOnlineRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/close_num_ops": {
-            "metric": "rpc.rpc.close_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_cached": {
-            "metric": "mem_cached",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getConfiguration/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getConfiguration.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/disk_total": {
-            "metric": "disk_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/get/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.get.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openScanner_avg_time": {
-            "metric": "rpc.rpc.openScanner_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcSlowResponse_num_ops": {
-            "metric": "rpc.rpc.RpcSlowResponse_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getFromOnlineRegions_avg_time": {
-            "metric": "rpc.rpc.getFromOnlineRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/reads_from_remote_client": {
-            "metric": "dfs.datanode.ReadsFromRemoteClient",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/splitRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.splitRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClosestRowBefore/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getClosestRowBefore.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/flushRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.flushRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isAborted_avg_time": {
-            "metric": "rpc.rpc.isAborted_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/increment/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.increment.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getBlockCacheColumnFamilySummaries/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getBlockCacheColumnFamilySummaries.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/deleteTable_avg_time": {
-            "metric": "rpc.rpc.deleteTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/bytes_read": {
-            "metric": "dfs.datanode.BytesRead",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/put/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.put.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_verified": {
-            "metric": "dfs.datanode.BlocksVerified",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/delete_avg_time": {
-            "metric": "rpc.rpc.delete_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClosestRowBefore_avg_time": {
-            "metric": "rpc.rpc.getClosestRowBefore_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_speed": {
-            "metric": "cpu_speed",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/get/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.get.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/compactRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.compactRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.openRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "rpc.rpc.RpcProcessingTimeAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/put_num_ops": {
-            "metric": "rpc.rpc.put_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/move_avg_time": {
-            "metric": "rpc.rpc.move_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "rpc.rpc.RpcAuthenticationFailures",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/openScanner/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.openScanner.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getClusterStatus_avg_time": {
-            "metric": "rpc.rpc.getClusterStatus_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/bytes_written": {
-            "metric": "dfs.datanode.BytesWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/unlockRow/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.unlockRow.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/removeFromOnlineRegions_avg_time": {
-            "metric": "rpc.rpc.removeFromOnlineRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/modifyTable_avg_time": {
-            "metric": "rpc.rpc.modifyTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/put/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.put.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndPut_avg_time": {
-            "metric": "rpc.rpc.checkAndPut_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blockReports_avg_time": {
-            "metric": "dfs.datanode.BlockReportsAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/replaceBlockOp_avg_time": {
-            "metric": "dfs.datanode.ReplaceBlockOpAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isStopped/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.isStopped.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/put_avg_time": {
-            "metric": "rpc.rpc.put_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/increment/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.increment.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.openRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "rpc.rpc.SentBytes",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/createTable_avg_time": {
-            "metric": "rpc.rpc.createTable_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getRegionInfo/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getRegionInfo.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/addColumn_num_ops": {
-            "metric": "rpc.rpc.addColumn_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHTableDescriptors_num_ops": {
-            "metric": "rpc.rpc.getHTableDescriptors_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getAlterStatus_avg_time": {
-            "metric": "rpc.rpc.getAlterStatus_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getRegionInfo_num_ops": {
-            "metric": "rpc.rpc.getRegionInfo_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/maxMemoryM": {
-            "metric": "jvm.metrics.maxMemoryM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "jvm.JvmMetrics.LogWarn",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/compactRegion_num_ops": {
-            "metric": "rpc.rpc.compactRegion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getFromOnlineRegions/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.getFromOnlineRegions.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/isAborted_num_ops": {
-            "metric": "rpc.rpc.isAborted_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "jvm.JvmMetrics.GcCount",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/getOnlineRegions_num_ops": {
-            "metric": "rpc.rpc.getOnlineRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkOOME/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.checkOOME.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemHeapUsedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolVersion_num_ops": {
-            "metric": "rpc.rpc.getProtocolVersion_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/disk_free": {
-            "metric": "disk_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsWaiting",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/unlockRow_num_ops": {
-            "metric": "rpc.rpc.unlockRow_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/replicateLogEntries/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.replicateLogEntries.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/disableTable_num_ops": {
-            "metric": "rpc.rpc.disableTable_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_buffers": {
-            "metric": "mem_buffers",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/shutdown_avg_time": {
-            "metric": "rpc.rpc.shutdown_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openScanner_num_ops": {
-            "metric": "rpc.rpc.openScanner_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/regionServerStartup_num_ops": {
-            "metric": "rpc.rpc.regionServerStartup_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/bulkLoadHFiles/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.bulkLoadHFiles.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_user": {
-            "metric": "cpu_user",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/swap_free": {
-            "metric": "swap_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_system": {
-            "metric": "cpu_system",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/exists/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.exists.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/openRegions_avg_time": {
-            "metric": "rpc.rpc.openRegions_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/regionServerReport_num_ops": {
-            "metric": "rpc.rpc.regionServerReport_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/next_num_ops": {
-            "metric": "rpc.rpc.next_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getBlockCacheColumnFamilySummaries_avg_time": {
-            "metric": "rpc.rpc.getBlockCacheColumnFamilySummaries_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/block_verification_failures": {
-            "metric": "dfs.datanode.BlockVerificationFailures",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/closeRegion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.closeRegion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndDelete_avg_time": {
-            "metric": "rpc.rpc.checkAndDelete_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_fifteen": {
-            "metric": "load_fifteen",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getHServerInfo_avg_time": {
-            "metric": "rpc.rpc.getHServerInfo_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "jvm.JvmMetrics.LogInfo",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/getBlockCacheColumnFamilySummaries/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getBlockCacheColumnFamilySummaries.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getZooKeeper_avg_time": {
-            "metric": "rpc.rpc.getZooKeeper_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/execCoprocessor/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.execCoprocessor.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/datanode/blocks_written": {
-            "metric": "dfs.datanode.BlocksWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/balanceSwitch_num_ops": {
-            "metric": "rpc.rpc.balanceSwitch_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/isMasterRunning_num_ops": {
-            "metric": "rpc.rpc.isMasterRunning_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/offline_num_ops": {
-            "metric": "rpc.rpc.offline_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_shared": {
-            "metric": "mem_shared",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolSignature_num_ops": {
-            "metric": "rpc.rpc.getProtocolSignature_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/abort_num_ops": {
-            "metric": "rpc.rpc.abort_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/getProtocolVersion/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.getProtocolVersion.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginFailureAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_num": {
-            "metric": "cpu_num",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rollHLogWriter_num_ops": {
-            "metric": "rpc.rpc.rollHLogWriter_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthorizationSuccesses",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/openRegions_num_ops": {
-            "metric": "rpc.rpc.openRegions_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "jvm.JvmMetrics.LogFatal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/splitRegion_avg_time": {
-            "metric": "rpc.rpc.splitRegion_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/closeRegion/aboveOneSec/_avg_time": {
-            "metric": "rpc.rpc.closeRegion.aboveOneSec._avg_time",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndPut_num_ops": {
-            "metric": "rpc.rpc.checkAndPut_num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/checkAndPut/aboveOneSec/_num_ops": {
-            "metric": "rpc.rpc.checkAndPut.aboveOneSec._num_ops",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/increment_avg_time": {
-            "metric": "rpc.rpc.increment_avg_time",
-            "pointInTime": true,
-            "temporal": true
-          }
-        }
-      },
-      {
-        "type": "jmx",
-        "metrics": {
-          "metrics/rpcdetailed/getEditLogSize_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getEditLogSize_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/TotalLoad": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.TotalLoad",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.MemHeapCommittedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/NonHeapMemoryUsed": {
-            "metric": "java.lang:type=Memory.NonHeapMemoryUsage[used]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/BlockCapacity": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.BlockCapacity",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.ThreadsRunnable",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/complete_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.complete_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.ThreadsNew",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollFsImage_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.rollFsImage_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.RpcAuthorizationFailures",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/RpcPort": {
-            "metric": "Hadoop:service=DataNode,name=DataNodeInfo.RpcPort",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getProtocolVersion_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getProtocolVersion_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.RpcQueueTimeAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/fsync_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.fsync_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=UgiMetrics.LoginSuccessAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReceived_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.blockReceived_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollEditLog_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.rollEditLog_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.SentBytes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/renewLease_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.renewLease_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getFileInfo_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getFileInfo_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/FilesTotal": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.FilesTotal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/VolumeInfo": {
-            "metric": "Hadoop:service=DataNode,name=DataNodeInfo.VolumeInfo",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/complete_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.complete_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.LogWarn",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityTotalGB": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.CapacityTotalGB",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/ExcessBlocks": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.ExcessBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getBlockLocations_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getBlockLocations_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/HttpPort": {
-            "metric": "Hadoop:service=DataNode,name=DataNodeInfo.HttpPort",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.GcCount",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityUsedGB": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.CapacityUsedGB",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.ReceivedBytes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/HostName": {
-            "metric": "Hadoop:service=DataNode,name=MetricsSystem,sub=Stats.tag.Hostname",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.ThreadsBlocked",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.RpcQueueTimeNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/HeapMemoryMax": {
-            "metric": "java.lang:type=Memory.HeapMemoryUsage[max]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/HeapMemoryUsed": {
-            "metric": "java.lang:type=Memory.HeapMemoryUsage[used]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollFsImage_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.rollFsImage_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.NumOpenConnections",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getFileInfo_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getFileInfo_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.MemHeapUsedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/ScheduledReplicationBlocks": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.ScheduledReplicationBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.ThreadsWaiting",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/BlocksTotal": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.BlocksTotal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=UgiMetrics.LoginSuccessNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getEditLogSize_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getEditLogSize_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getBlockLocations_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getBlockLocations_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.GcTimeMillis",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReceived_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.blockReceived_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/create_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.create_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.ThreadsTerminated",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/addBlock_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.addBlock_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CapacityRemainingGB": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.CapacityRemainingGB",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/MissingBlocks": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.MissingBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.CallQueueLength",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/CorruptBlocks": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.CorruptBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/Version": {
-            "metric": "Hadoop:service=DataNode,name=DataNodeInfo.Version",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReport_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.blockReport_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.LogInfo",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getListing_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getListing_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/rollEditLog_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.rollEditLog_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/addBlock_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.addBlock_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/NamenodeAddress": {
-            "metric": "Hadoop:service=DataNode,name=DataNodeInfo.NamenodeAddresses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.RpcProcessingTimeNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "Hadoop:service=NameNode,name=UgiMetrics.LoginFailureNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/fsync_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.fsync_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/UnderReplicatedBlocks": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.UnderReplicatedBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/NonHeapMemoryMax": {
-            "metric": "java.lang:type=Memory.NonHeapMemoryUsage[max]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/PendingReplicationBlocks": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.PendingReplicationBlocks",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/create_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.create_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/sendHeartbeat_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.sendHeartbeat_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logError": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.LogError",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "Hadoop:service=NameNode,name=UgiMetrics.LoginFailureAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getProtocolVersion_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getProtocolVersion_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.RpcAuthorizationSuccesses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getListing_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.getListing_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/sendHeartbeat_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.sendHeartbeat_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "Hadoop:service=DataNode,name=JvmMetrics.LogFatal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/renewLease_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.renewLease_avg_time",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.RpcProcessingTimeAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/blockReport_num_ops": {
-            "metric": "Hadoop:service=DataNode,name=RpcDetailedActivity.blockReport_num_ops",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.RpcAuthenticationSuccesses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "Hadoop:service=DataNode,name=RpcActivity.RpcAuthenticationFailures",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/FSNamesystem/PendingDeletionBlocks": {
-            "metric": "Hadoop:service=DataNode,name=DataNode.PendingDeletionBlocks",
-            "pointInTime": true,
-            "temporal": false
-          }
-        }
-      }
-    ]
-  },
-  "JOURNALNODE": {
-    "Component": [
-      {
-        "type": "ganglia",
-        "metrics": {
-          "metrics/dfs/journalNode/syncs300s75thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s75thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/lastWrittenTxId": {
-            "metric": "dfs.JournalNode.LastWrittenTxId",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s90thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s90thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/finalizeLogSegment_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.FinalizeLogSegmentNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginSuccessAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/startLogSegment_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.StartLogSegmentAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_one": {
-            "metric": "load_one",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/currentLagTxns": {
-            "metric": "dfs.JournalNode.CurrentLagTxns",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/bytesWritten": {
-            "metric": "dfs.JournalNode.BytesWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/process/proc_run": {
-            "metric": "proc_run",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/acceptRecovery_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.AcceptRecoveryNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/swap_total": {
-            "metric": "swap_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/txnsWritten": {
-            "metric": "dfs.JournalNode.TxnsWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "jvm.JvmMetrics.ThreadsBlocked",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "rpc.rpc.RpcQueueTimeNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/process/proc_total": {
-            "metric": "proc_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/part_max_used": {
-            "metric": "part_max_used",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/newEpoch_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.NewEpochNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s_num_ops": {
-            "metric": "dfs.JournalNode.Syncs3600sNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s99thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s99thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginSuccessNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s95thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s95thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_idle": {
-            "metric": "cpu_idle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s99thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s99thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_aidle": {
-            "metric": "cpu_aidle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_free": {
-            "metric": "mem_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s50thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s50thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/bytes_in": {
-            "metric": "bytes_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s_num_ops": {
-            "metric": "dfs.JournalNode.Syncs300sNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s90thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s90thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/pkts_out": {
-            "metric": "pkts_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_cached": {
-            "metric": "mem_cached",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/disk_total": {
-            "metric": "disk_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/lastPromisedEpoch": {
-            "metric": "dfs.JournalNode.LastPromisedEpoch",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/prepareRecovery_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.PrepareRecoveryAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/lastWriterEpoch": {
-            "metric": "dfs.JournalNode.LastWriterEpoch",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginFailureNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getEditLogManifest_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetEditLogManifestNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_wio": {
-            "metric": "cpu_wio",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/acceptRecovery_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.AcceptRecoveryAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_speed": {
-            "metric": "cpu_speed",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "rpc.rpc.RpcProcessingTimeAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthenticationSuccesses",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "rpc.rpc.RpcAuthenticationFailures",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/pkts_in": {
-            "metric": "pkts_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_total": {
-            "metric": "mem_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemHeapCommittedM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "jvm.JvmMetrics.ThreadsRunnable",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s75thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s75thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "jvm.JvmMetrics.ThreadsNew",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "rpc.rpc.RpcAuthorizationFailures",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s95thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s95thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "rpc.rpc.RpcQueueTimeAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s95thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s95thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getEditLogManifest_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetEditLogManifestAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "rpc.rpc.SentBytes",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "jvm.JvmMetrics.LogWarn",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "jvm.JvmMetrics.GcCount",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "rpc.rpc.ReceivedBytes",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_nice": {
-            "metric": "cpu_nice",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/batchesWritten": {
-            "metric": "dfs.JournalNode.BatchesWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "rpc.rpc.NumOpenConnections",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/batchesWrittenWhileLagging": {
-            "metric": "dfs.JournalNode.BatchesWrittenWhileLagging",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s99thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s99thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemHeapUsedM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/prepareRecovery_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.PrepareRecoveryNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsWaiting",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/disk_free": {
-            "metric": "disk_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/newEpoch_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.NewEpochAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_buffers": {
-            "metric": "mem_buffers",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s_num_ops": {
-            "metric": "dfs.JournalNode.Syncs60sNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "jvm.JvmMetrics.GcTimeMillis",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "jvm.JvmMetrics.ThreadsTerminated",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memMaxM": {
-            "metric": "jvm.JvmMetrics.MemMaxM",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/bytes_out": {
-            "metric": "bytes_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_user": {
-            "metric": "cpu_user",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/swap_free": {
-            "metric": "swap_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_five": {
-            "metric": "load_five",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_system": {
-            "metric": "cpu_system",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getJournalState_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetJournalStateAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/boottime": {
-            "metric": "boottime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s90thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s90thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "rpc.rpc.CallQueueLength",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/journal_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.JournalAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/finalizeLogSegment_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.FinalizeLogSegmentAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_fifteen": {
-            "metric": "load_fifteen",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/startLogSegment_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.StartLogSegmentNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s50thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s50thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "jvm.JvmMetrics.LogInfo",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getJournalState_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetJournalStateNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "rpc.rpc.RpcProcessingTimeNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_shared": {
-            "metric": "mem_shared",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s50thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s50thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logError": {
-            "metric": "jvm.JvmMetrics.LogError",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginFailureAvgTime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_num": {
-            "metric": "cpu_num",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/journal_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.JournalNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthorizationSuccesses",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "jvm.JvmMetrics.LogFatal",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s75thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s75thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          }
-        }
-      }
-    ],
-    "HostComponent": [
-      {
-        "type": "ganglia",
-        "metrics": {
-          "metrics/dfs/journalNode/syncs300s75thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s75thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/lastWrittenTxId": {
-            "metric": "dfs.JournalNode.LastWrittenTxId",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s90thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s90thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/finalizeLogSegment_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.FinalizeLogSegmentNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginSuccessAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/startLogSegment_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.StartLogSegmentAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/load/load_one": {
-            "metric": "load_one",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/currentLagTxns": {
-            "metric": "dfs.JournalNode.CurrentLagTxns",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/bytesWritten": {
-            "metric": "dfs.JournalNode.BytesWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/process/proc_run": {
-            "metric": "proc_run",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/acceptRecovery_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.AcceptRecoveryNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/swap_total": {
-            "metric": "swap_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/txnsWritten": {
-            "metric": "dfs.JournalNode.TxnsWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "jvm.JvmMetrics.ThreadsBlocked",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "rpc.rpc.RpcQueueTimeNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/process/proc_total": {
-            "metric": "proc_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/part_max_used": {
-            "metric": "part_max_used",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/newEpoch_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.NewEpochNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s_num_ops": {
-            "metric": "dfs.JournalNode.Syncs3600sNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s99thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s99thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginSuccessNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s95thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s95thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_idle": {
-            "metric": "cpu_idle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s99thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s99thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_aidle": {
-            "metric": "cpu_aidle",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_free": {
-            "metric": "mem_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s50thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s50thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/bytes_in": {
-            "metric": "bytes_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s_num_ops": {
-            "metric": "dfs.JournalNode.Syncs300sNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s90thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s90thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/network/pkts_out": {
-            "metric": "pkts_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/mem_cached": {
-            "metric": "mem_cached",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/disk/disk_total": {
-            "metric": "disk_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/lastPromisedEpoch": {
-            "metric": "dfs.JournalNode.LastPromisedEpoch",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/prepareRecovery_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.PrepareRecoveryAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/lastWriterEpoch": {
-            "metric": "dfs.JournalNode.LastWriterEpoch",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "ugi.UgiMetrics.LoginFailureNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getEditLogManifest_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetEditLogManifestNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_wio": {
-            "metric": "cpu_wio",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/acceptRecovery_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.AcceptRecoveryAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_speed": {
-            "metric": "cpu_speed",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "rpc.rpc.RpcProcessingTimeAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthenticationSuccesses",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "rpc.rpc.RpcAuthenticationFailures",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/network/pkts_in": {
-            "metric": "pkts_in",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/mem_total": {
-            "metric": "mem_total",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "jvm.JvmMetrics.MemHeapCommittedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "jvm.JvmMetrics.ThreadsRunnable",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s75thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s75thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "jvm.JvmMetrics.ThreadsNew",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "rpc.rpc.RpcAuthorizationFailures",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s95thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s95thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "rpc.rpc.RpcQueueTimeAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s95thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s95thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getEditLogManifest_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetEditLogManifestAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "rpc.rpc.SentBytes",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "jvm.JvmMetrics.LogWarn",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "jvm.JvmMetrics.GcCount",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "rpc.rpc.ReceivedBytes",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_nice": {
-            "metric": "cpu_nice",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/batchesWritten": {
-            "metric": "dfs.JournalNode.BatchesWritten",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "rpc.rpc.NumOpenConnections",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/batchesWrittenWhileLagging": {
-            "metric": "dfs.JournalNode.BatchesWrittenWhileLagging",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s99thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s99thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "jvm.JvmMetrics.MemHeapUsedM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/prepareRecovery_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.PrepareRecoveryNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "jvm.JvmMetrics.ThreadsWaiting",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/disk/disk_free": {
-            "metric": "disk_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/newEpoch_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.NewEpochAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/mem_buffers": {
-            "metric": "mem_buffers",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s_num_ops": {
-            "metric": "dfs.JournalNode.Syncs60sNumOps",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "jvm.JvmMetrics.GcTimeMillis",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "jvm.JvmMetrics.ThreadsTerminated",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/memMaxM": {
-            "metric": "jvm.JvmMetrics.MemMaxM",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/network/bytes_out": {
-            "metric": "bytes_out",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_user": {
-            "metric": "cpu_user",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/memory/swap_free": {
-            "metric": "swap_free",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/load/load_five": {
-            "metric": "load_five",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_system": {
-            "metric": "cpu_system",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getJournalState_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.GetJournalStateAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/boottime": {
-            "metric": "boottime",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs300s90thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs300s90thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "rpc.rpc.CallQueueLength",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/journal_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.JournalAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/finalizeLogSegment_avg_time": {
-            "metric": "rpcdetailed.rpcdetailed.FinalizeLogSegmentAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/load/load_fifteen": {
-            "metric": "load_fifteen",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/startLogSegment_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.StartLogSegmentNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs60s50thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs60s50thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "jvm.JvmMetrics.LogInfo",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/getJournalState_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.GetJournalStateNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "rpc.rpc.RpcProcessingTimeNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/memory/mem_shared": {
-            "metric": "mem_shared",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s50thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s50thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/jvm/logError": {
-            "metric": "jvm.JvmMetrics.LogError",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "ugi.UgiMetrics.LoginFailureAvgTime",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/cpu/cpu_num": {
-            "metric": "cpu_num",
-            "pointInTime": true,
-            "temporal": true
-          },
-          "metrics/rpcdetailed/journal_num_ops": {
-            "metric": "rpcdetailed.rpcdetailed.JournalNumOps",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "rpc.rpc.RpcAuthorizationSuccesses",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "jvm.JvmMetrics.LogFatal",
-            "pointInTime": false,
-            "temporal": true
-          },
-          "metrics/dfs/journalNode/syncs3600s75thPercentileLatencyMicros": {
-            "metric": "dfs.JournalNode.Syncs3600s75thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": true
-          }
-        }
-      },
-      {
-        "type": "jmx",
-        "metrics": {
-          "metrics/jvm/memHeapCommittedM": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.MemHeapCommittedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/NonHeapMemoryUsed": {
-            "metric": "java.lang:type=Memory.NonHeapMemoryUsage[used]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsRunnable": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.ThreadsRunnable",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs300s95thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs300s95thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsNew": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.ThreadsNew",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/finalizeLogSegment_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.FinalizeLogSegmentNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthorizationFailures": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.RpcAuthorizationFailures",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginSuccess_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=UgiMetrics.LoginSuccessAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcQueueTime_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.RpcQueueTimeAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/startLogSegment_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.StartLogSegmentAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/lastWriterEpoch": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).LastWriterEpoch",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getEditLogManifest_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.GetEditLogManifestAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/SentBytes": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.SentBytes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memNonHeapUsedM": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.MemNonHeapUsedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs60s_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs60sNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logWarn": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.LogWarn",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs3600s50thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs3600s50thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsTimedWaiting": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.ThreadsTimedWaiting",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/gcCount": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.GcCount",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs3600s95thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs3600s95thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/acceptRecovery_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.AcceptRecoveryNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/ReceivedBytes": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.ReceivedBytes",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs3600s99thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs3600s99thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsBlocked": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.ThreadsBlocked",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/lastWrittenTxId": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).LastWrittenTxId",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcQueueTime_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.RpcQueueTimeNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/HeapMemoryMax": {
-            "metric": "java.lang:type=Memory.HeapMemoryUsage[max]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/HeapMemoryUsed": {
-            "metric": "java.lang:type=Memory.HeapMemoryUsage[used]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/newEpoch_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.NewEpochNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs60s75thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs60s75thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/NumOpenConnections": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.NumOpenConnections",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memHeapUsedM": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.MemHeapUsedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/prepareRecovery_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.PrepareRecoveryNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/batchesWrittenWhileLagging": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).BatchesWrittenWhileLagging",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsWaiting": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.ThreadsWaiting",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/newEpoch_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.NewEpochAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginSuccess_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=UgiMetrics.LoginSuccessNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/gcTimeMillis": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.GcTimeMillis",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs300s75thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs300s75thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/threadsTerminated": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.ThreadsTerminated",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memMaxM": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.MemMaxM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs300s_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs300sNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs300s50thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs300s50thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getJournalState_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.GetJournalStateAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/lastPromisedEpoch": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).LastPromisedEpoch",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/startTime": {
-            "metric": "java.lang:type=Runtime.StartTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs60s95thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs60s95thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/journalsStatus": {
-            "metric": "Hadoop:service=JournalNode,name=JournalNodeInfo.JournalsStatus",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/memNonHeapCommittedM": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.MemNonHeapCommittedM",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs60s50thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs60s50thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/callQueueLen": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.CallQueueLength",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/journal_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.JournalAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs3600s75thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs3600s75thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/finalizeLogSegment_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.FinalizeLogSegmentAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs3600s90thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs3600s90thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/batchesWritten": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).BatchesWritten",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/startLogSegment_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.StartLogSegmentNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs60s90thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs60s90thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs3600s_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs3600sNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/prepareRecovery_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.PrepareRecoveryAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logInfo": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.LogInfo",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getJournalState_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.GetJournalStateNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/currentLagTxns": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).CurrentLagTxns",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcProcessingTime_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.RpcProcessingTimeNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginFailure_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=UgiMetrics.LoginFailureNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/getEditLogManifest_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.GetEditLogManifestNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs300s99thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs300s99thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/NonHeapMemoryMax": {
-            "metric": "java.lang:type=Memory.NonHeapMemoryUsage[max]",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs300s90thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs300s90thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/acceptRecovery_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.AcceptRecoveryAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logError": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.LogError",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/ugi/loginFailure_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=UgiMetrics.LoginFailureAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/syncs60s99thPercentileLatencyMicros": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).Syncs60s99thPercentileLatencyMicros",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpcdetailed/journal_num_ops": {
-            "metric": "Hadoop:service=JournalNode,name=RpcDetailedActivity.JournalNumOps",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthorizationSuccesses": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.RpcAuthorizationSuccesses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/txnsWritten": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).TxnsWritten",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/jvm/logFatal": {
-            "metric": "Hadoop:service=JournalNode,name=JvmMetrics.LogFatal",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/RpcProcessingTime_avg_time": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.RpcProcessingTimeAvgTime",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthenticationSuccesses": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.RpcAuthenticationSuccesses",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/rpc/rpcAuthenticationFailures": {
-            "metric": "Hadoop:service=JournalNode,name=RpcActivity.RpcAuthenticationFailures",
-            "pointInTime": true,
-            "temporal": false
-          },
-          "metrics/dfs/journalnode/cluster/$1.replaceAll(\"^-\",\"\")/bytesWritten": {
-            "metric": "Hadoop:service=JournalNode,name=Journal(-.+).BytesWritten",
-            "pointInTime": true,
-            "temporal": false
-          }
-        }
-      }
-    ]
-  }
-}

ambari-web/app/controllers/installer.js

@@ -745,6 +745,21 @@ App.InstallerController = App.WizardController.extend({
     App.router.get('applicationController').postUserPref(persists, true);
   },
 
+  /**
+   * Save cluster provisioning state to the server
+   * @param state cluster provisioning state
+   * @param callback is called after request completes
+   */
+  setClusterProvisioningState: function (state, callback) {
+    App.ajax.send({
+      name: 'cluster.save_provisioning_state',
+      sender: this,
+      data: {
+        state: state
+      }
+    }).complete(callback());
+  },
+
   setStepsEnable: function () {
     for (var i = 0; i <= this.totalSteps; i++) {
       var step = this.get('isStepDisabled').findProperty('step', i);

ambari-web/app/controllers/main/service/info/configs.js

@@ -185,7 +185,7 @@ App.MainServiceInfoConfigsController = Em.Controller.extend(App.ServerValidatorM
    * @return {Boolean}
    */
   isVersionDefault: function(version) {
-    return version && version.get('groupId') == -1;
+    return (App.ServiceConfigVersion.find(this.get('content.serviceName') + "_" + version).get('groupId') == -1);
   },
 
   /**
@@ -248,7 +248,7 @@ App.MainServiceInfoConfigsController = Em.Controller.extend(App.ServerValidatorM
     }
     var hash = {};
     this.get('stepConfigs')[0].configs.forEach(function (config) {
-      hash[config.get('name')] = {value: config.get('value'), overrides: []};
+      hash[config.get('name')] = {value: config.get('value'), overrides: [], isFinal: config.get('isFinal')};
       if (!config.get('overrides')) return;
       if (!config.get('overrides.length')) return;
 
@@ -324,12 +324,11 @@ App.MainServiceInfoConfigsController = Em.Controller.extend(App.ServerValidatorM
     var self = this;
     this.set('versionLoaded', false);
     version = version || this.get('currentDefaultVersion');
-    var versionRecord = App.ServiceConfigVersion.find(this.get('content.serviceName') + "_" + version);
     //version of non-default group require properties from current version of default group to correctly display page
-    var versions = (this.isVersionDefault(versionRecord)) ? [version] : [this.get('currentDefaultVersion'), version];
+    var versions = (this.isVersionDefault(version)) ? [version] : [this.get('currentDefaultVersion'), version];
 
     //if version from default group selected then switch to default group
-    if (self.get('dataIsLoaded') && this.isVersionDefault(versionRecord)) {
+    if (self.get('dataIsLoaded') && this.isVersionDefault(version)) {
       this.set('selectedConfigGroup', this.get('configGroups').findProperty('isDefault'));
     }
 
@@ -569,10 +568,16 @@ App.MainServiceInfoConfigsController = Em.Controller.extend(App.ServerValidatorM
   loadCompareVersionConfigs: function (allConfigs) {
     var dfd = $.Deferred();
     var self = this;
-    var compareServiceVersion = this.get('compareServiceVersion');
+    var compareServiceVersions = [];
 
-    if (compareServiceVersion) {
-      this.getCompareVersionConfigs(compareServiceVersion).done(function (json) {
+    if (this.get('compareServiceVersion')) {
+      if (!this.isVersionDefault(this.get('compareServiceVersion').get('version'))) {
+        compareServiceVersions = [this.get('compareServiceVersion').get('version'), this.get('selectedVersion')];
+      } else {
+        compareServiceVersions = [this.get('compareServiceVersion').get('version')];
+      }
+
+      this.getCompareVersionConfigs(compareServiceVersions).done(function (json) {
         self.initCompareConfig(allConfigs, json);
         self.set('compareServiceVersion', null);
         self.set('isCompareMode', true);
@@ -597,76 +602,173 @@ App.MainServiceInfoConfigsController = Em.Controller.extend(App.ServerValidatorM
   initCompareConfig: function(allConfigs, json) {
     var serviceVersionMap = {};
     var configNamesMap = {};
-    var serviceName = json.items[0].service_name;
-    var compareServiceVersion = this.get('compareServiceVersion');
+    var serviceName = this.get('content.serviceName');
+    var compareVersionNumber = this.get('compareServiceVersion').get('version');
+    //indicate whether compared versions are from non-default group
+    var compareNonDefaultVersions = (json.items.length > 1);
 
+    serviceVersionMap[compareVersionNumber] = {};
+    if (compareNonDefaultVersions) {
+      serviceVersionMap[this.get('selectedVersion')] = {};
+    }
     allConfigs.mapProperty('name').forEach(function(name) {
       configNamesMap[name] = true;
     });
 
-    json.items[0].configurations.forEach(function (configuration) {
-      if (serviceName == 'YARN' && configuration.type == 'capacity-scheduler') {
-        // put all properties in a single textarea for capacity-scheduler
-        var value = '';
-        for (var prop in configuration.properties) {
-          value += prop + '=' + configuration.properties[prop] + '\n';
-        }
-        serviceVersionMap[configuration.type + '-' + configuration.type] = {
-          name: configuration.type,
-          value: value,
-          type: configuration.type,
-          tag: configuration.tag,
-          version: configuration.version
-        };
-      } else {
-        for (var prop in configuration.properties) {
-          serviceVersionMap[prop + '-' + configuration.type] = {
-            name: prop,
-            value: configuration.properties[prop],
+    json.items.forEach(function (item) {
+      item.configurations.forEach(function (configuration) {
+        if (serviceName == 'YARN' && configuration.type == 'capacity-scheduler') {
+          // put all properties in a single textarea for capacity-scheduler
+          var value = '';
+          for (var prop in configuration.properties) {
+            value += prop + '=' + configuration.properties[prop] + '\n';
+          }
+          serviceVersionMap[item.service_config_version][configuration.type + '-' + configuration.type] = {
+            name: configuration.type,
+            value: value,
             type: configuration.type,
             tag: configuration.tag,
-            version: configuration.version
+            version: configuration.version,
+            service_config_version: item.service_config_version
           };
-          if (Em.isNone(configNamesMap[prop])) {
-            allConfigs.push(this.getMockConfig(prop, serviceName, App.config.getOriginalFileName(configuration.type)));
+        } else {
+          for (var prop in configuration.properties) {
+            serviceVersionMap[item.service_config_version][prop + '-' + configuration.type] = {
+              name: prop,
+              value: configuration.properties[prop],
+              type: configuration.type,
+              tag: configuration.tag,
+              version: configuration.version,
+              service_config_version: item.service_config_version
+            };
+            if (Em.isNone(configNamesMap[prop])) {
+              allConfigs.push(this.getMockConfig(prop, serviceName, App.config.getOriginalFileName(configuration.type)));
+            }
           }
         }
-      }
-      if (configuration.properties_attributes && configuration.properties_attributes.final) {
-        for (var final in configuration.properties_attributes.final) {
-          serviceVersionMap[final + '-' + configuration.type].isFinal = (configuration.properties_attributes.final[final] === 'true');
+        if (configuration.properties_attributes && configuration.properties_attributes.final) {
+          for (var final in configuration.properties_attributes.final) {
+            serviceVersionMap[item.service_config_version][final + '-' + configuration.type].isFinal = (configuration.properties_attributes.final[final] === 'true');
+          }
         }
-      }
+      }, this);
     }, this);
 
-    allConfigs.forEach(function (serviceConfig) {
-      // map the property in the compare version to compare with current serviceConfig
-      var compareConfig = serviceVersionMap[serviceConfig.name + '-' + App.config.getConfigTagFromFileName(serviceConfig.filename)];
-      var compareObject = $.extend(true, {isComparison: true}, serviceConfig);
-      compareObject.serviceVersion = compareServiceVersion;
-      compareObject.isEditable = false;
-
-      if (compareConfig) {
-        if (serviceConfig.isMock) {
-          compareObject.displayType = 'string';
-          compareObject.isMock = false;
-        }
-        serviceConfig.compareConfig = App.ServiceConfigProperty.create(compareObject);
-        this.setSupportsFinal(serviceConfig.compareConfig);
-        serviceConfig.compareConfig.set('isFinal', compareConfig.isFinal);
-        serviceConfig.compareConfig.set('value', App.config.formatOverrideValue(serviceConfig, compareConfig.value));
-        serviceConfig.isComparison = true;
-        serviceConfig.hasCompareDiffs = (serviceConfig.value !== serviceConfig.compareConfig.get('value'))||
-          (serviceConfig.isFinal !== (serviceConfig.compareConfig.get('isFinal') == true));
-      } else if (serviceConfig.isUserProperty) {
-        compareObject.isMock = true;
-        compareObject.displayType = 'label';
-        serviceConfig.compareConfig = App.ServiceConfigProperty.create(compareObject);
-        serviceConfig.compareConfig.set('value', 'Undefined');
-        serviceConfig.isComparison = true;
-        serviceConfig.hasCompareDiffs = true;
+    if (compareNonDefaultVersions) {
+      allConfigs.forEach(function (serviceConfig) {
+        this.setCompareConfigs(serviceConfig, serviceVersionMap, compareVersionNumber, this.get('selectedVersion'));
+      }, this);
+    } else {
+      allConfigs.forEach(function (serviceConfig) {
+        this.setCompareDefaultGroupConfig(serviceConfig, serviceVersionMap[this.get('compareServiceVersion').get('version')]);
+      }, this);
+    }
+  },
+
+
+  /**
+   * set compare properties to service config of non-default group
+   * @param serviceConfig
+   * @param serviceVersionMap
+   * @param compareVersion
+   * @param selectedVersion
+   */
+  setCompareConfigs: function (serviceConfig, serviceVersionMap, compareVersion, selectedVersion) {
+    var compareConfig = serviceVersionMap[compareVersion][serviceConfig.name + '-' + App.config.getConfigTagFromFileName(serviceConfig.filename)];
+    var selectedConfig = serviceVersionMap[selectedVersion][serviceConfig.name + '-' + App.config.getConfigTagFromFileName(serviceConfig.filename)];
+
+    serviceConfig.compareConfigs = [];
+    serviceConfig.isComparison = true;
+
+    if (compareConfig && selectedConfig) {
+      serviceConfig.compareConfigs.push(this.getComparisonConfig(serviceConfig, compareConfig));
+      serviceConfig.compareConfigs.push(this.getComparisonConfig(serviceConfig, selectedConfig));
+      serviceConfig.hasCompareDiffs = this.hasCompareDiffs(serviceConfig.compareConfigs[0], serviceConfig.compareConfigs[1]);
+    } else if (compareConfig && !selectedConfig) {
+      serviceConfig.compareConfigs.push(this.getComparisonConfig(serviceConfig, compareConfig));
+      serviceConfig.compareConfigs.push(this.getMockComparisonConfig(selectedConfig, selectedVersion));
+      serviceConfig.hasCompareDiffs = true;
+    } else if (!compareConfig && selectedConfig) {
+      serviceConfig.compareConfigs.push(this.getMockComparisonConfig(selectedConfig, compareVersion));
+      serviceConfig.compareConfigs.push(this.getComparisonConfig(serviceConfig, selectedConfig));
+      serviceConfig.hasCompareDiffs = true;
+    }
+  },
+
+  /**
+   * init attributes and wrap mock compare config into App.ServiceConfigProperty
+   * @param serviceConfig
+   * @param compareConfig
+   * @return {object}
+   */
+  getMockComparisonConfig: function (serviceConfig, compareServiceVersion) {
+    var compareObject = $.extend(true, {isComparison: true},  serviceConfig);
+    compareObject.isEditable = false;
+
+    compareObject.serviceVersion = App.ServiceConfigVersion.find(this.get('content.serviceName') + "_" + compareServiceVersion);
+    compareObject.isMock = true;
+    compareObject.displayType = 'label';
+    compareObject = App.ServiceConfigProperty.create(compareObject);
+    compareObject.set('value', 'Undefined');
+    return compareObject;
+  },
+
+  /**
+   * init attributes and wrap compare config into App.ServiceConfigProperty
+   * @param serviceConfig
+   * @param compareConfig
+   * @return {object}
+   */
+  getComparisonConfig: function (serviceConfig, compareConfig) {
+    var compareObject = $.extend(true, {isComparison: true},  serviceConfig);
+    compareObject.isEditable = false;
+
+    if (compareConfig) {
+      if (serviceConfig.isMock) {
+        compareObject.displayType = 'string';
+        compareObject.isMock = false;
       }
-    }, this);
+      compareObject.serviceVersion = App.ServiceConfigVersion.find(this.get('content.serviceName') + "_" + compareConfig.service_config_version);
+      compareObject = App.ServiceConfigProperty.create(compareObject);
+      compareObject.set('isFinal', compareConfig.isFinal);
+      compareObject.set('value', App.config.formatOverrideValue(serviceConfig, compareConfig.value));
+      this.setSupportsFinal(compareObject);
+    }
+    return compareObject;
+  },
+
+  /**
+   * set compare properties to service config of default group
+   * @param serviceConfig
+   * @param serviceVersionMap
+   */
+  setCompareDefaultGroupConfig: function (serviceConfig, serviceVersionMap) {
+    // map the property in the compare version to compare with current serviceConfig
+    var compareConfig = serviceVersionMap[serviceConfig.name + '-' + App.config.getConfigTagFromFileName(serviceConfig.filename)];
+    var compareObject = {};
+
+    serviceConfig.compareConfigs = [];
+    serviceConfig.isComparison = true;
+
+    if (compareConfig) {
+      compareObject = this.getComparisonConfig(serviceConfig, compareConfig);
+      serviceConfig.hasCompareDiffs = serviceConfig.isMock || this.hasCompareDiffs(serviceConfig, compareObject);
+      serviceConfig.compareConfigs.push(compareObject);
+    } else if (serviceConfig.isUserProperty) {
+      serviceConfig.compareConfigs.push(this.getMockComparisonConfig(serviceConfig, this.get('compareServiceVersion').get('version')));
+      serviceConfig.hasCompareDiffs = true;
+    }
+  },
+
+  /**
+   * check value and final attribute of original and compare config for differencies
+   * @param originalConfig
+   * @param compareConfig
+   * @return {Boolean}
+   */
+  hasCompareDiffs: function (originalConfig, compareConfig) {
+    return (originalConfig.value !== compareConfig.value) ||
+    (originalConfig.isFinal !== (compareConfig.isFinal == true));
   },
 
   /**
@@ -701,18 +803,18 @@ App.MainServiceInfoConfigsController = Em.Controller.extend(App.ServerValidatorM
 
   /**
    * get configs of chosen version from server to compare
-   * @param compareServiceVersion
+   * @param compareServiceVersions
    * @return {$.ajax}
    */
-  getCompareVersionConfigs: function (compareServiceVersion) {
+  getCompareVersionConfigs: function (compareServiceVersions) {
     this.set('versionLoaded', false);
 
     return App.ajax.send({
-      name: 'service.serviceConfigVersion.get',
+      name: 'service.serviceConfigVersions.get.multiple',
       sender: this,
       data: {
         serviceName: this.get('content.serviceName'),
-        serviceConfigVersion: compareServiceVersion.get('version')
+        serviceConfigVersions: compareServiceVersions
       }
     });
   },
@@ -1041,6 +1143,7 @@ App.MainServiceInfoConfigsController = Em.Controller.extend(App.ServerValidatorM
    */
   setEditability: function (serviceConfigProperty, defaultGroupSelected) {
     serviceConfigProperty.set('isEditable', false);
+    if (serviceConfigProperty.get('isComparison')) return;
     if (App.get('isAdmin') && defaultGroupSelected && !this.get('isHostsConfigsPage') && !serviceConfigProperty.get('group')) {
       serviceConfigProperty.set('isEditable', serviceConfigProperty.get('isReconfigurable'));
     } else if (serviceConfigProperty.get('group') && this.get('selectedConfigGroup.name') === serviceConfigProperty.get('group.name')) {
@@ -1282,6 +1385,7 @@ App.MainServiceInfoConfigsController = Em.Controller.extend(App.ServerValidatorM
           "tag": selectedConfigGroup.get('service.id'),
           "description": selectedConfigGroup.get('description'),
           "hosts": groupHosts,
+          "service_config_version_note": this.get('serviceConfigVersionNote'),
           "desired_configs": this.buildGroupDesiredConfigs(overridenConfigs)
         }
       }, true);

ambari-web/app/controllers/main/service/item.js

@@ -157,20 +157,34 @@ App.MainServiceItemController = Em.Controller.extend({
 
     return App.showConfirmationFeedBackPopup(function(query, runMmOperation) {
       self.set('isPending', true);
-      self.startStopPopupPrimary(serviceHealth, query, runMmOperation);
+      self.startStopWithMmode(serviceHealth, query, runMmOperation);
     }, bodyMessage);
   },
 
-  startStopPopupPrimary: function (serviceHealth, query, runMmOperation) {
-    var requestInfo = "";
-    var turnOnMM = "ON";
-    if (serviceHealth == "STARTED") {
-      turnOnMM = "OFF";
-      requestInfo = App.BackgroundOperationsController.CommandContexts.START_SERVICE.format(this.get('content.serviceName'));
+
+  startStopWithMmode: function(serviceHealth, query, runMmOperation) {
+    var self = this;
+    if (runMmOperation) {
+      if (serviceHealth == "STARTED") {
+        this.startStopPopupPrimary(serviceHealth, query).complete(function() {
+          batchUtils.turnOnOffPassiveRequest("OFF", Em.I18n.t('passiveState.turnOff'), self.get('content.serviceName').toUpperCase());
+        });
+      } else {
+        batchUtils.turnOnOffPassiveRequest("ON", Em.I18n.t('passiveState.turnOn'), this.get('content.serviceName').toUpperCase()).complete(function() {
+          self.startStopPopupPrimary(serviceHealth, query);
+        })
+      }
     } else {
-      requestInfo = App.BackgroundOperationsController.CommandContexts.STOP_SERVICE.format(this.get('content.serviceName'));
+      this.startStopPopupPrimary(serviceHealth, query);
     }
 
+  },
+
+  startStopPopupPrimary: function (serviceHealth, query) {
+    var requestInfo = (serviceHealth == "STARTED")
+        ? App.BackgroundOperationsController.CommandContexts.START_SERVICE.format(this.get('content.serviceName'))
+        : App.BackgroundOperationsController.CommandContexts.STOP_SERVICE.format(this.get('content.serviceName'));
+
     var data = {
       'context': requestInfo,
       'serviceName': this.get('content.serviceName').toUpperCase(),
@@ -179,10 +193,8 @@ App.MainServiceItemController = Em.Controller.extend({
       },
       'query': query
     };
-    if (runMmOperation) {
-      data.ServiceInfo.maintenance_state = turnOnMM;
-    }
-    App.ajax.send({
+
+    return App.ajax.send({
       'name': 'common.service.update',
       'sender': this,
       'success': 'startStopPopupSuccessCallback',

ambari-web/app/data/HDP2/site_properties.js

@@ -525,6 +525,15 @@ module.exports =
       "category": "Advanced hive-site",
       "serviceName": "HIVE"
     },
+    {
+      "id": "site property",
+      "name": "hive.server2.support.dynamic.service.discovery",
+      "displayName": "hive.server2.support.dynamic.service.discovery",
+      "defaultValue": false,
+      "displayType": "checkbox",
+      "category": "Advanced hive-site",
+      "serviceName": "HIVE"
+    },
   /**********************************************tez-site*****************************************/
     {
       "id": "site property",

ambari-web/app/data/site_properties.js

@@ -517,6 +517,15 @@ module.exports =
       "category": "Advanced hive-site",
       "serviceName": "HIVE"
     },
+    {
+      "id": "site property",
+      "name": "hive.server2.support.dynamic.service.discovery",
+      "displayName": "hive.server2.support.dynamic.service.discovery",
+      "defaultValue": false,
+      "displayType": "checkbox",
+      "category": "Advanced hive-site",
+      "serviceName": "HIVE"
+    },
   /**********************************************hbase-site***************************************/
     {
       "id": "site property",

ambari-web/app/messages.js

@@ -1459,6 +1459,7 @@ Em.I18n.translations = {
   'services.service.config_groups.switchGroupTextFull':'Switch to \'{0}\' host config group',
   'services.service.config_groups.switchGroupTextShort':'Switch to \'{0}\'',
   'services.reassign.closePopup':'Move {0} wizard is in progress. You must allow the wizard to complete for Ambari to be in usable state. If you choose to quit, you must follow manual instructions to complete or revert move {0} wizard as documented in the Ambari User Guide. Are you sure you want to exit the wizard?',
+  'services.reassign.error.fewHosts':'You must have at least 2 hosts in your cluster to run Move Wizard.',
 
   'services.reassign.step1.header':'Get Started',
   'services.reassign.step1.message1': 'This wizard will walk you through moving {0}.<br/>',

ambari-web/app/models/cluster_states.js

@@ -108,7 +108,6 @@ App.clusterStatus = Em.Object.create(App.UserPref, {
    * @method updateFromServer
    */
   updateFromServer: function (overrideLocaldb) {
-    // if overrideLocaldb is undefined, set it to true
     this.set('additionalData', {
       user: App.db.getUser(),
       login: App.db.getLoginName(),

ambari-web/app/models/service_config.js

@@ -180,6 +180,7 @@ App.ServiceConfigProperty = Ember.Object.extend({
   group: null, // Contain group related to this property. Set only when isOriginalSCP is false.
   isUserProperty: null, // This property was added by user. Hence they get removal actions etc.
   isOverridable: true,
+  compareConfigs: [],
   isComparison: false,
   hasCompareDiffs: false,
   showLabel: true,

ambari-web/app/router.js

@@ -29,6 +29,12 @@ App.Router = Em.Router.extend({
   enableLogging: true,
   isFwdNavigation: true,
   backBtnForHigherStep: false,
+
+  /**
+   * Is true, if cluster.provisioning_state is equal to 'INSTALLED'
+   * @type {Boolean}
+   */
+  clusterInstallCompleted: false,
   /**
    * user prefered path to route
    */
@@ -119,6 +125,9 @@ App.Router = Em.Router.extend({
 
   onAuthenticationSuccess: function (data) {
     this.set('loggedIn', true);
+    if (data.items.length) {
+      this.set('clusterInstallCompleted', data.items[0].Clusters.provisioning_state === 'INSTALLED');
+    }
   },
 
   onAuthenticationError: function (data) {
@@ -265,7 +274,7 @@ App.Router = Em.Router.extend({
       App.usersMapper.map({"items": [loginData]});
       router.setUserLoggedIn(params.loginName);
       var permissionList = privileges.items.mapProperty('PrivilegeInfo.permission_name');
-      var isAdmin = permissionList.indexOf('AMBARI.ADMIN') > -1;
+      var isAdmin = permissionList.contains('AMBARI.ADMIN');
       var transitionToApp = false;
       if (isAdmin) {
         App.set('isAdmin', true);
@@ -277,14 +286,15 @@ App.Router = Em.Router.extend({
         }
       } else {
         if (clustersData.items.length) {
+          this.set('clusterInstallCompleted', clustersData.items[0].Clusters.provisioning_state === 'INSTALLED');
           //TODO: Iterate over clusters
           var clusterName = clustersData.items[0].Clusters.cluster_name;
           var clusterPermissions = privileges.items.filterProperty('PrivilegeInfo.cluster_name', clusterName).mapProperty('PrivilegeInfo.permission_name');
-          if (clusterPermissions.indexOf('CLUSTER.OPERATE') > -1) {
+          if (clusterPermissions.contains('CLUSTER.OPERATE')) {
             App.set('isAdmin', true);
             App.set('isOperator', true);
             transitionToApp = true;
-          } else if (clusterPermissions.indexOf('CLUSTER.READ') > -1) {
+          } else if (clusterPermissions.contains('CLUSTER.READ')) {
             transitionToApp = true;
           }
         }
@@ -317,40 +327,42 @@ App.Router = Em.Router.extend({
       } else {
         callback('main.dashboard.index');
       }
-    }
-    App.clusterStatus.updateFromServer(false).complete(function () {
-      var clusterStatusOnServer = App.clusterStatus.get('value');
-      // if wizardControllerName == "installerController", then it means someone closed the browser or the browser was crashed when we were last in Installer wizard
-      var route = 'installer';
-      if (!App.get('isAdmin') || clusterStatusOnServer && (clusterStatusOnServer.clusterState === 'DEFAULT' || clusterStatusOnServer.clusterState === 'CLUSTER_STARTED_5')) {
-        route = 'main.dashboard.index';
-      } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('addHostController.name')) {
-        // if wizardControllerName == "addHostController", then it means someone closed the browser or the browser was crashed when we were last in Add Hosts wizard
-        route = 'main.hostAdd';
-      } else if (clusterStatusOnServer && (clusterStatusOnServer.wizardControllerName === App.router.get('addSecurityController.name') || clusterStatusOnServer.wizardControllerName === App.router.get('mainAdminSecurityDisableController.name'))) {
-        // if wizardControllerName == "addSecurityController", then it means someone closed the browser or the browser was crashed when we were last in Add Security wizard
-        route = 'main.admin.adminSecurity';
-      } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('addServiceController.name')) {
-        // if wizardControllerName == "addHostController", then it means someone closed the browser or the browser was crashed when we were last in Add Hosts wizard
-        route = 'main.serviceAdd';
-      } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('stackUpgradeController.name')) {
-        // if wizardControllerName == "stackUpgradeController", then it means someone closed the browser or the browser was crashed when we were last in Stack Upgrade wizard
-        route = 'main.stackUpgrade';
-      } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('reassignMasterController.name')) {
-        // if wizardControllerName == "reassignMasterController", then it means someone closed the browser or the browser was crashed when we were last in Reassign Master wizard
-        route = 'main.reassign';
-      } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('highAvailabilityWizardController.name')) {
-        // if wizardControllerName == "highAvailabilityWizardController", then it means someone closed the browser or the browser was crashed when we were last in NameNode High Availability wizard
-        route = 'main.services.enableHighAvailability';
-      } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('rMHighAvailabilityWizardController.name')) {
-        // if wizardControllerName == "highAvailabilityWizardController", then it means someone closed the browser or the browser was crashed when we were last in NameNode High Availability wizard
-        route = 'main.services.enableRMHighAvailability';
-      } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('rollbackHighAvailabilityWizardController.name')) {
-        // if wizardControllerName == "highAvailabilityRollbackController", then it means someone closed the browser or the browser was crashed when we were last in NameNode High Availability Rollback wizard
-        route = 'main.services.rollbackHighAvailability';
+    } else {
+      if (this.get('clusterInstallCompleted')) {
+        App.clusterStatus.updateFromServer(false).complete(function () {
+          var clusterStatusOnServer = App.clusterStatus.get('value');
+          var route = 'main.dashboard.index';
+          if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('addHostController.name')) {
+            // if wizardControllerName == "addHostController", then it means someone closed the browser or the browser was crashed when we were last in Add Hosts wizard
+            route = 'main.hostAdd';
+          } else if (clusterStatusOnServer && (clusterStatusOnServer.wizardControllerName === App.router.get('addSecurityController.name') || clusterStatusOnServer.wizardControllerName === App.router.get('mainAdminSecurityDisableController.name'))) {
+            // if wizardControllerName == "addSecurityController", then it means someone closed the browser or the browser was crashed when we were last in Add Security wizard
+            route = 'main.admin.adminSecurity';
+          } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('addServiceController.name')) {
+            // if wizardControllerName == "addHostController", then it means someone closed the browser or the browser was crashed when we were last in Add Hosts wizard
+            route = 'main.serviceAdd';
+          } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('stackUpgradeController.name')) {
+            // if wizardControllerName == "stackUpgradeController", then it means someone closed the browser or the browser was crashed when we were last in Stack Upgrade wizard
+            route = 'main.stackUpgrade';
+          } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('reassignMasterController.name')) {
+            // if wizardControllerName == "reassignMasterController", then it means someone closed the browser or the browser was crashed when we were last in Reassign Master wizard
+            route = 'main.reassign';
+          } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('highAvailabilityWizardController.name')) {
+            // if wizardControllerName == "highAvailabilityWizardController", then it means someone closed the browser or the browser was crashed when we were last in NameNode High Availability wizard
+            route = 'main.services.enableHighAvailability';
+          } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('rMHighAvailabilityWizardController.name')) {
+            // if wizardControllerName == "highAvailabilityWizardController", then it means someone closed the browser or the browser was crashed when we were last in NameNode High Availability wizard
+            route = 'main.services.enableRMHighAvailability';
+          } else if (clusterStatusOnServer && clusterStatusOnServer.wizardControllerName === App.router.get('rollbackHighAvailabilityWizardController.name')) {
+            // if wizardControllerName == "highAvailabilityRollbackController", then it means someone closed the browser or the browser was crashed when we were last in NameNode High Availability Rollback wizard
+            route = 'main.services.rollbackHighAvailability';
+          }
+          callback(route);
+        });
+      } else {
+        callback('installer');
       }
-      callback(route);
-    });
+    }
   },
 
   logOff: function (context) {

ambari-web/app/routes/installer.js

@@ -79,7 +79,7 @@ module.exports = Em.Route.extend({
             });
           } else {
             Em.run.next(function () {
-              App.router.transitionTo('main.services');
+              App.router.transitionTo('main.views.index');
             });
           }
 
@@ -436,11 +436,11 @@ module.exports = Em.Route.extend({
     complete: function (router, context) {
       var controller = router.get('installerController');
       controller.finish();
-
-      // We need to do recovery based on whether we are in Add Host or Installer wizard
-      controller.saveClusterState('DEFAULT');
-
-      router.transitionTo('main.dashboard.index');
+      controller.setClusterProvisioningState('INSTALLED', function () {
+        // We need to do recovery based on whether we are in Add Host or Installer wizard
+        controller.saveClusterState('DEFAULT');
+        router.transitionTo('main.dashboard.index');
+      });
     }
   }),
 

ambari-web/app/routes/reassign_master_routes.js

@@ -34,56 +34,62 @@ module.exports = App.WizardRoute.extend({
 
   enter: function (router) {
     console.log('in /service/reassign:enter');
-    var context = this;
-    Em.run.next(function () {
-      var reassignMasterController = router.get('reassignMasterController');
-      App.router.get('updateController').set('isWorking', false);
-      var popup = App.ModalPopup.show({
-        classNames: ['full-width-modal'],
-        header: Em.I18n.t('services.reassign.header'),
-        bodyClass: App.ReassignMasterView.extend({
-          controller: reassignMasterController
-        }),
-        primary: Em.I18n.t('form.cancel'),
-        showFooter: false,
-        secondary: null,
+    if (App.router.get('mainHostController.hostsCountMap.TOTAL') > 1) {
+      var context = this;
+      Em.run.next(function () {
+        var reassignMasterController = router.get('reassignMasterController');
+        App.router.get('updateController').set('isWorking', false);
+        var popup = App.ModalPopup.show({
+          classNames: ['full-width-modal'],
+          header: Em.I18n.t('services.reassign.header'),
+          bodyClass: App.ReassignMasterView.extend({
+            controller: reassignMasterController
+          }),
+          primary: Em.I18n.t('form.cancel'),
+          showFooter: false,
+          secondary: null,
 
-        onPrimary: function () {
-          this.hide();
-          App.router.get('updateController').set('isWorking', true);
-          App.router.transitionTo('main.services.index');
-        },
-        onClose: function () {
-          var reassignMasterController = router.get('reassignMasterController');
-          var currStep = reassignMasterController.get('currentStep');
+          onPrimary: function () {
+            this.hide();
+            App.router.get('updateController').set('isWorking', true);
+            App.router.transitionTo('main.services.index');
+          },
+          onClose: function () {
+            var reassignMasterController = router.get('reassignMasterController');
+            var currStep = reassignMasterController.get('currentStep');
 
-          if (parseInt(currStep) > 3) {
-            var self = this;
-            App.showConfirmationPopup(function(){
-              router.get('reassignMasterWizardStep' + currStep + 'Controller').removeObserver('tasks.@each.status', this, 'onTaskStatusChange');
-              context.leaveWizard(router,self);
-            }, Em.I18n.t('services.reassign.closePopup').format(reassignMasterController.get('content.reassign.display_name')));
-          } else {
-            context.leaveWizard(router,this);
+            if (parseInt(currStep) > 3) {
+              var self = this;
+              App.showConfirmationPopup(function () {
+                router.get('reassignMasterWizardStep' + currStep + 'Controller').removeObserver('tasks.@each.status', this, 'onTaskStatusChange');
+                context.leaveWizard(router, self);
+              }, Em.I18n.t('services.reassign.closePopup').format(reassignMasterController.get('content.reassign.display_name')));
+            } else {
+              context.leaveWizard(router, this);
+            }
+          },
+          didInsertElement: function () {
+            this.fitHeight();
+          }
+        });
+        reassignMasterController.set('popup', popup);
+        reassignMasterController.loadSecurityEnabled();
+        reassignMasterController.loadComponentToReassign();
+        var currentClusterStatus = App.clusterStatus.get('value');
+        if (currentClusterStatus) {
+          switch (currentClusterStatus.clusterState) {
+            case 'REASSIGN_MASTER_INSTALLING' :
+              reassignMasterController.setCurrentStep(currentClusterStatus.localdb.ReassignMaster.currentStep);
+              break;
           }
-        },
-        didInsertElement: function () {
-          this.fitHeight();
         }
+        router.transitionTo('step' + reassignMasterController.get('currentStep'));
       });
-      reassignMasterController.set('popup', popup);
-      reassignMasterController.loadSecurityEnabled();
-      reassignMasterController.loadComponentToReassign();
-      var currentClusterStatus = App.clusterStatus.get('value');
-      if (currentClusterStatus) {
-        switch (currentClusterStatus.clusterState) {
-          case 'REASSIGN_MASTER_INSTALLING' :
-            reassignMasterController.setCurrentStep(currentClusterStatus.localdb.ReassignMaster.currentStep);
-            break;
-        }
-      }
-      router.transitionTo('step' + reassignMasterController.get('currentStep'));
-    });
+    } else {
+      App.showAlertPopup(Em.I18n.t('common.error'), Em.I18n.t('services.reassign.error.fewHosts'), function () {
+        router.transitionTo('main.services.index');
+      })
+    }
   },
 
   step1: Em.Route.extend({

ambari-web/app/templates/common/configs/compare_property.hbs

@@ -16,17 +16,19 @@
 * limitations under the License.
 }}
 
-<div {{bindAttr class=":control-group :overrideField"}}>
-  {{view view.serviceConfigProperty.compareConfig.viewClass serviceConfigBinding="view.serviceConfigProperty.compareConfig"}}
-  {{#unless view.serviceConfigProperty.compareConfig.isMock}}
-    <span class="label label-info">{{view.serviceConfigProperty.compareConfig.serviceVersion.versionText}}</span>
-    {{#if view.serviceConfigProperty.compareConfig.serviceVersion.isCurrent}}
-        <span class="label label-success">{{t common.current}}</span>
-    {{/if}}
-    {{#if view.serviceConfigProperty.compareConfig.supportsFinal}}
-        <a disabled="disabled" {{bindAttr class=":btn :btn-small :btn-final view.serviceConfigProperty.compareConfig.isFinal:active view.serviceConfigProperty.compareConfig.hideFinalIcon:hidden" }}>
-            <i class="icon-lock"></i>
-        </a>
-    {{/if}}
-  {{/unless}}
-</div>
+{{#each compareConfig in view.serviceConfigProperty.compareConfigs}}
+    <div {{bindAttr class=":control-group :overrideField"}}>
+      {{view compareConfig.viewClass serviceConfigBinding="compareConfig"}}
+      {{#unless compareConfig.isMock}}
+          <span class="label label-info">{{compareConfig.serviceVersion.versionText}}</span>
+        {{#if compareConfig.serviceVersion.isCurrent}}
+            <span class="label label-success">{{t common.current}}</span>
+        {{/if}}
+        {{#if compareConfig.supportsFinal}}
+            <a disabled="disabled" {{bindAttr class=":btn :btn-small :btn-final compareConfig.isFinal:active compareConfig.hideFinalIcon:hidden" }}>
+                <i class="icon-lock"></i>
+            </a>
+        {{/if}}
+      {{/unless}}
+    </div>
+{{/each}}

ambari-web/app/templates/common/configs/service_config_category.hbs

@@ -49,9 +49,13 @@
             <div {{bindAttr class="errorMessage:error: warnMessage:warning: :control-group"}}>
               {{view viewClass serviceConfigBinding="this" categoryConfigsAllBinding="view.categoryConfigsAll" }}
               {{#if this.isComparison}}
+                {{#if controller.selectedConfigGroup.isDefault}}
                   <span class="label label-info">{{t dashboard.configHistory.table.version.prefix}}{{controller.selectedVersion}}</span>
-                {{#if controller.isCurrentSelected}}
+                  {{#if controller.isCurrentSelected}}
                     <span class="label label-success">{{t common.current}}</span>
+                  {{/if}}
+                {{else}}
+                  <span class="label label-info">{{t common.default}}&nbsp;{{t services.service.config.configHistory.configGroup}}</span>
                 {{/if}}
               {{/if}}
               {{#if supportsFinal}}

ambari-web/app/utils/ajax/ajax.js

@@ -911,6 +911,19 @@ var urls = {
       };
     }
   },
+  'cluster.save_provisioning_state': {
+    'real': '/clusters/{clusterName}',
+    'type': 'PUT',
+    'format': function (data) {
+      return {
+        data: JSON.stringify({
+          "Clusters": {
+            "provisioning_state": data.state
+          }
+        })
+      };
+    }
+  },
   'admin.high_availability.polling': {
     'real': '/clusters/{clusterName}/requests/{requestId}?fields=tasks/*,Requests/*',
     'mock': ''
@@ -1368,7 +1381,7 @@ var urls = {
     mock: '/data/users/privileges_{userName}.json'
   },
   'router.login.clusters': {
-    'real': '/clusters',
+    'real': '/clusters?fields=Clusters/provisioning_state',
     'mock': '/data/clusters/info.json'
   },
   'router.logoff': {
@@ -1376,7 +1389,7 @@ var urls = {
     'mock': ''
   },
   'router.authentication': {
-    'real': '/clusters',
+    'real': '/clusters?fields=Clusters/provisioning_state',
     'mock': '/data/clusters/info.json',
     'format': function() {
       return {

ambari-web/app/utils/batch_scheduled_requests.js

@@ -68,6 +68,8 @@ module.exports = {
    * Facade-function for restarting host components of specific service
    * @param {String} serviceName for which service hostComponents should be restarted
    * @param {bool} staleConfigsOnly restart only hostComponents with <code>staleConfig</code> true
+   * @param {Object} query
+   * @param {bool} runMmOperation
    */
   restartAllServiceHostComponents: function(serviceName, staleConfigsOnly, query, runMmOperation) {
     var self = this;
@@ -77,7 +79,7 @@ module.exports = {
       this.turnOnOffPassiveRequest('ON', Em.I18n.t('passiveState.turnOnFor').format(serviceName), serviceName);
     }
     this.getComponentsFromServer({
-      services: services,
+      services: [serviceName],
       staleConfigs: staleConfigsOnly ? staleConfigsOnly : null,
       passiveState: 'OFF',
       displayParams: ['host_components/HostRoles/component_name']
@@ -266,7 +268,7 @@ module.exports = {
   },
 
   turnOnOffPassiveRequest: function(state, message, serviceName, callback) {
-    App.ajax.send({
+    return App.ajax.send({
       'name': 'common.service.passive',
       'sender': {
         'successCallback': callback || defaultSuccessCallback,

contrib/views/slider/pom.xml

@@ -551,7 +551,7 @@
 			</resource>
 			<resource>
 				<targetPath>WEB-INF/lib</targetPath>
-				<filtering>true</filtering>
+				<filtering>false</filtering>
 				<directory>lib</directory>
 				<includes>
 					<include>slider-agent.tar.gz</include>

contrib/views/slider/src/main/java/org/apache/ambari/view/slider/SliderAppTypesResourceProvider.java

@@ -75,8 +75,10 @@ public class SliderAppTypesResourceProvider implements
 		Set<SliderAppType> appSet = new HashSet<SliderAppType>();
 			List<SliderAppType> sliderAppTypes = sliderController.getSliderAppTypes(request
 			    .getPropertyIds());
-			for (SliderAppType app : sliderAppTypes)
-				appSet.add(app);
+            if (sliderAppTypes != null) {
+              for (SliderAppType app : sliderAppTypes)
+                appSet.add(app);
+            }
 		return appSet;
 	}
 

contrib/views/slider/src/main/java/org/apache/ambari/view/slider/SliderAppsViewController.java

@@ -20,6 +20,7 @@ package org.apache.ambari.view.slider;
 
 import java.io.IOException;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import org.apache.hadoop.yarn.exceptions.YarnException;
@@ -90,4 +91,7 @@ public interface SliderAppsViewController {
 
   public void thawApp(String appId) throws YarnException, IOException,
       InterruptedException;
+
+  public void flexApp(String appId, Map<String, Integer> componentsMap)
+      throws YarnException, IOException, InterruptedException;
 }

contrib/views/slider/src/main/java/org/apache/ambari/view/slider/SliderAppsViewControllerImpl.java

@@ -26,6 +26,7 @@ import java.io.InputStream;
 import java.lang.reflect.Field;
 import java.security.PrivilegedExceptionAction;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -42,7 +43,6 @@ import org.apache.commons.io.IOUtils;
 import org.apache.commons.io.filefilter.RegexFileFilter;
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.fs.FileSystem;
-import org.apache.hadoop.fs.Path;
 import org.apache.hadoop.hdfs.HdfsConfiguration;
 import org.apache.hadoop.security.UserGroupInformation;
 import org.apache.hadoop.yarn.api.records.ApplicationId;
@@ -56,6 +56,7 @@ import org.apache.slider.api.ClusterDescription;
 import org.apache.slider.client.SliderClient;
 import org.apache.slider.common.SliderKeys;
 import org.apache.slider.common.params.ActionCreateArgs;
+import org.apache.slider.common.params.ActionFlexArgs;
 import org.apache.slider.common.params.ActionFreezeArgs;
 import org.apache.slider.common.params.ActionInstallPackageArgs;
 import org.apache.slider.common.params.ActionThawArgs;
@@ -248,10 +249,12 @@ public class SliderAppsViewControllerImpl implements SliderAppsViewController {
                 List<SliderAppType> appTypes = getSliderAppTypes(null);
                 if (appTypes != null && appTypes.size() > 0) {
                   for (SliderAppType appType : appTypes) {
-                    logger.info("TYPE: " + appType.getTypeName() + "   "
-                        + app.getType());
-                    logger.info("VERSION: " + appType.getTypeVersion() + "   "
-                        + app.getAppVersion());
+                    if (logger.isDebugEnabled()) {
+                      logger.debug("TYPE: " + appType.getTypeName() + "   "
+                          + app.getType());
+                      logger.debug("VERSION: " + appType.getTypeVersion() + "   "
+                          + app.getAppVersion());
+                    }
                     if ((appType.getTypeName() != null && appType.getTypeName()
                         .equalsIgnoreCase(app.getType()))
                         && (appType.getTypeVersion() != null && appType
@@ -447,9 +450,20 @@ public class SliderAppsViewControllerImpl implements SliderAppsViewController {
     return yarnConfig;
   }
 
+  private boolean areViewParametersSet() {
+    String hdfsPath = viewContext.getProperties().get(PROPERTY_HDFS_ADDRESS);
+    String rmAddress = viewContext.getProperties().get(PROPERTY_YARN_RM_ADDRESS);
+    String rmSchedulerAddress = viewContext.getProperties().get(PROPERTY_YARN_RM_SCHEDULER_ADDRESS);
+    String zkQuorum = viewContext.getProperties().get(PROPERTY_ZK_QUOROM);
+    return hdfsPath!=null && rmAddress!=null && rmSchedulerAddress!=null && zkQuorum!=null;
+  }
+
   @Override
   public List<SliderApp> getSliderApps(final Set<String> properties)
       throws YarnException, IOException, InterruptedException {
+    if (!areViewParametersSet()) {
+      return Collections.emptyList();
+    }
     return invokeSliderClientRunnable(new SliderClientContextRunnable<List<SliderApp>>() {
       @Override
       public List<SliderApp> run(SliderClient sliderClient)
@@ -514,6 +528,9 @@ public class SliderAppsViewControllerImpl implements SliderAppsViewController {
   @Override
   public List<SliderAppType> getSliderAppTypes(Set<String> properties) {
     if (appTypes == null) {
+      if (!areViewParametersSet()) {
+        return Collections.emptyList();
+      }
       appTypes = loadAppTypes();
     }
     return appTypes;
@@ -572,6 +589,8 @@ public class SliderAppsViewControllerImpl implements SliderAppsViewController {
                 appTypeComponent.setName(component.getName());
                 appTypeComponent.setYarnMemory(1024);
                 appTypeComponent.setYarnCpuCores(1);
+                // Updated below if present in resources.json
+                appTypeComponent.setInstanceCount(1);
                 // appTypeComponent.setPriority(component.);
                 if (component.getMinInstanceCount() != null) {
                   appTypeComponent.setInstanceCount(Integer.parseInt(component
@@ -637,7 +656,8 @@ public class SliderAppsViewControllerImpl implements SliderAppsViewController {
   public String createSliderApp(JsonObject json) throws IOException,
       YarnException, InterruptedException {
     if (json.has("name") && json.has("typeConfigs")
-        && json.has("typeComponents")) {
+        && json.has("typeComponents") && json.has("typeName")) {
+      final String appType = json.get("typeName").getAsString();
       final String appName = json.get("name").getAsString();
       JsonObject configs = json.get("typeConfigs").getAsJsonObject();
       JsonArray componentsArray = json.get("typeComponents").getAsJsonArray();
@@ -672,16 +692,15 @@ public class SliderAppsViewControllerImpl implements SliderAppsViewController {
       saveAppConfigs(configs, componentsArray, appConfigJsonFile);
       saveAppResources(componentsArray, resourcesJsonFile);
 
-      String hdfsLocation = viewContext.getProperties().get(PROPERTY_HDFS_ADDRESS);
       final ActionCreateArgs createArgs = new ActionCreateArgs();
       createArgs.template = appConfigJsonFile;
       createArgs.resources = resourcesJsonFile;
-      createArgs.image = new Path(hdfsLocation
-          + "/user/yarn/agent/slider-agent.tar.gz");
       
       final ActionInstallPackageArgs installArgs = new ActionInstallPackageArgs();
-      installArgs.name = appName;
-      installArgs.packageURI = getAppsFolderPath() + "/" + configs.get("application.def").getAsString();
+      SliderAppType sliderAppType = getSliderAppType(appType, null);
+      String localAppPackageFileName = sliderAppType.getTypePackageFileName();
+      installArgs.name = appType;
+      installArgs.packageURI = getAppsFolderPath() + "/" + localAppPackageFileName;
       installArgs.replacePkg = true;
 
       return invokeSliderClientRunnable(new SliderClientContextRunnable<String>() {
@@ -803,4 +822,33 @@ public class SliderAppsViewControllerImpl implements SliderAppsViewController {
     });
     logger.info("Thawed Slider App [" + appId + "] with response: " + applicationId.toString());
   }
+
+  @Override
+  public void flexApp(final String appId, final Map<String, Integer> componentsMap)
+      throws YarnException, IOException, InterruptedException {
+    ApplicationId applicationId = invokeSliderClientRunnable(new SliderClientContextRunnable<ApplicationId>() {
+      @Override
+      public ApplicationId run(SliderClient sliderClient) throws YarnException,
+          IOException, InterruptedException {
+        Set<String> properties = new HashSet<String>();
+        properties.add("id");
+        properties.add("name");
+        final SliderApp sliderApp = getSliderApp(appId, properties);
+        if (sliderApp == null) {
+          throw new ApplicationNotFoundException(appId);
+        }
+        ActionFlexArgs flexArgs = new ActionFlexArgs();
+        flexArgs.parameters.add(sliderApp.getName());
+        for (Entry<String, Integer> e : componentsMap.entrySet()) {
+          flexArgs.componentDelegate.componentTuples.add(e.getKey());
+          flexArgs.componentDelegate.componentTuples.add(e.getValue()
+              .toString());
+        }
+        sliderClient.actionFlex(sliderApp.getName(), flexArgs);
+        return sliderClient.applicationId;
+      }
+    });
+    logger.info("Flexed Slider App [" + appId + "] with response: " + applicationId);
+  }
+
 }

contrib/views/slider/src/main/java/org/apache/ambari/view/slider/rest/SliderAppsResource.java

@@ -21,6 +21,9 @@ package org.apache.ambari.view.slider.rest;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
 
 import javax.ws.rs.Consumes;
 import javax.ws.rs.DELETE;
@@ -88,11 +91,25 @@ public class SliderAppsResource {
         JsonObject requestJson = requestContent.getAsJsonObject();
         if (requestJson.has("state")) {
           String newState = requestJson.get("state").getAsString();
-          if ("FROZEN".equals(newState))
+          if ("FROZEN".equals(newState)) {
             sliderAppsViewController.freezeApp(appId);
-          else if ("RUNNING".equals(newState))
+            return Response.ok().build();
+          } else if ("RUNNING".equals(newState)) {
             sliderAppsViewController.thawApp(appId);
+            return Response.ok().build();
+          }
         } else if (requestJson.has("components")) {
+          Map<String, Integer> componentsMap = new HashMap<String, Integer>();
+          JsonObject componentsJson = requestJson.get("components")
+              .getAsJsonObject();
+          for (Entry<String, JsonElement> e : componentsJson.entrySet()) {
+            String componentName = e.getKey();
+            int instanceCount = e.getValue().getAsJsonObject()
+                .get("instanceCount").getAsInt();
+            componentsMap.put(componentName, instanceCount);
+          }
+          sliderAppsViewController.flexApp(appId, componentsMap);
+          return Response.ok().build();
         }
       }
       String sliderApp = sliderAppsViewController

contrib/views/slider/src/main/java/org/apache/ambari/view/slider/rest/client/Metric.java

@@ -20,6 +20,7 @@ package org.apache.ambari.view.slider.rest.client;
 
 import org.apache.log4j.Logger;
 import org.codehaus.jackson.annotate.JsonIgnore;
+import org.codehaus.jackson.annotate.JsonIgnoreProperties;
 
 import javax.xml.xpath.XPath;
 import javax.xml.xpath.XPathExpression;
@@ -29,6 +30,7 @@ import javax.xml.xpath.XPathFactory;
 import java.util.ArrayList;
 import java.util.List;
 
+@JsonIgnoreProperties({"keyName", "matchers", "xPathExpression", "xPathExpressionComputed"})
 public class Metric {
   private static final Logger logger = Logger
       .getLogger(Metric.class);
@@ -37,9 +39,13 @@ public class Metric {
   private String metric;
   private boolean pointInTime;
   private boolean temporal;
+  @JsonIgnore
   private String keyName = null;
+  @JsonIgnore
   private List<List<String>> matchers = null;
+  @JsonIgnore
   private XPathExpression xPathExpression = null;
+  @JsonIgnore
   private boolean xPathExpressionComputed = false;
 
   private Metric() {
@@ -93,6 +99,7 @@ public class Metric {
     return xPathExpression;
   }
 
+  @JsonIgnore
   public String getJmxBeanKeyName() {
     if (keyName == null) {
       int firstIndex = metric.indexOf(SEPARATOR);
@@ -109,6 +116,7 @@ public class Metric {
    *
    * @return
    */
+  @JsonIgnore
   public List<List<String>> getMatchers() {
     if (matchers == null) {
       List<List<String>> tmpMatchers = new ArrayList<List<String>>();
@@ -146,5 +154,4 @@ public class Metric {
       }
     }
   }
-
 }

contrib/views/slider/src/main/resources/ui/app/controllers/slider_app_controller.js

@@ -46,7 +46,7 @@ App.SliderAppController = Ember.ObjectController.extend({
       actions.push({
         title: 'Flex',
         action: 'flex',
-        confirm: true
+        confirm: false
       });
     }
     if ('FROZEN' === status) {
@@ -319,12 +319,17 @@ App.SliderAppController = Ember.ObjectController.extend({
     openModal: function(option) {
       this.set('currentAction', option.action);
       if (option.confirm) {
-        Bootstrap.ModalManager.confirm(
-          this,
+        Bootstrap.ModalManager.open(
+          "confirm-modal",
           Ember.I18n.t('common.confirmation'),
-          Ember.I18n.t('question.sure'),
-          Ember.I18n.t('yes'),
-          Ember.I18n.t('no')
+          Ember.View.extend({
+            template: Ember.Handlebars.compile('{{t question.sure}}')
+          }),
+          [
+            Ember.Object.create({title: Em.I18n.t('common.cancel'), clicked:"modalCanceled", dismiss: 'modal'}),
+            Ember.Object.create({title: Em.I18n.t('ok'), clicked:"modalConfirmed", type:'success'})
+          ],
+          this
         );
       }
       else {

contrib/views/slider/src/main/resources/ui/app/controllers/slider_controller.js

@@ -29,29 +29,36 @@
  * If Slider-properties exists:
  *  - Load cluster name
  *  - Load hostNames
+ * After whole data has been loaded set <code>App.sliderConfigs</code> and enable/disable Slider
  * @type {Ember.Controller}
  */
-App.SliderController = Ember.Controller.extend({
+App.SliderController = Ember.Controller.extend(App.RunPeriodically, {
 
   /**
-   *  Load resources on controller initialization
-   * @method initResources
+   * Map for Slider-errors
+   * If some config is empty, service isn't installed
+   * @type {object}
    */
-  initResources: function () {
-    this.getParametersFromViewProperties();
+  serviceConfigMap: {
+    HDFS: 'hdfsAddress',
+    YARN: 'yarnResourceManager',
+    ZOOKEEPER: 'zookeeperQuorum'
   },
 
   /**
    * List of Slider-properties mapped from Ambari-configs
+   * Key-names used in Slider-Title-Popup, so don't change it pls
    * @type {Em.Object}
    */
   initialValuesToLoad: Em.Object.create({
     ambariAddress: null,
     clusterName: null,
     hdfsAddress: null,
-    yarnRMAddress: null,
-    yarnRMSchedulerAddress: null,
-    zookeeperQuorum: null
+    yarnResourceManager: null,
+    yarnResourceManagerScheduler: null,
+    zookeeperQuorum: null,
+    gangliaServer: null,
+    gangliaClusters: null
   }),
 
   /**
@@ -60,6 +67,14 @@ App.SliderController = Ember.Controller.extend({
    */
   zookeeperHosts: [],
 
+  /**
+   *  Load resources on controller initialization
+   * @method initResources
+   */
+  initResources: function () {
+    this.getParametersFromViewProperties();
+  },
+
   /**
    * Get Slider properties from View-parameters (set in the Ambari Admin View)
    * If parameters can't be found, use Ambari-configs to populate Slider properties
@@ -71,20 +86,46 @@ App.SliderController = Ember.Controller.extend({
       name: 'slider.getViewParams',
       sender: this,
       success: 'getParametersFromViewPropertiesSuccessCallback',
-      error: 'getClusterName'
+      error: 'getParametersFromViewPropertiesErrorCallback'
     });
   },
 
   /**
    * Check if Slider-properties exist
+   * If exist - set Slider properties using view-configs
    * If not - get Ambari configs to populate Slider properties
    * @param {object} data
    * @method getParametersFromViewPropertiesSuccessCallback
    */
   getParametersFromViewPropertiesSuccessCallback: function(data) {
     var properties = Em.get(data, 'ViewInstanceInfo.properties'),
-      loadConfigs = Em.isNone(properties);
-      this.getClusterName(loadConfigs);
+      initialValuesToLoad = this.get('initialValuesToLoad');
+    if (properties == null || properties['hdfs.address'] == null
+        || properties['yarn.resourcemanager.address'] == null
+        || properties['yarn.resourcemanager.scheduler.address'] == null
+        || properties['zookeeper.quorum'] == null) {
+      this.getClusterName();
+    } else {
+      initialValuesToLoad.setProperties({
+        ambariAddress: location.protocol + "//" + document.location.host,
+        hdfsAddress: properties['hdfs.address'],
+        yarnResourceManager: properties['yarn.resourcemanager.address'],
+        yarnResourceManagerScheduler: properties['yarn.resourcemanager.scheduler.address'],
+        zookeeperQuorum: properties['zookeeper.quorum'],
+        gangliaServer: properties['ganglia.server.hostname'],
+        gangliaClusters: properties['ganglia.custom.clusters']
+      });
+      App.set('gangliaHost', properties['ganglia.server.hostname']);
+      this.finishSliderConfiguration();
+    }
+  },
+
+  /**
+   * Error-callback for Slider-parameters request
+   * @method getParametersFromViewPropertiesErrorCallback
+   */
+  getParametersFromViewPropertiesErrorCallback: function() {
+    this.getClusterName();
   },
 
   /**
@@ -92,14 +133,12 @@ App.SliderController = Ember.Controller.extend({
    * @returns {$.ajax}
    * @method getClusterName
    */
-  getClusterName: function (loadConfigs) {
-    if (Em.isNone(loadConfigs)) loadConfigs = true;
+  getClusterName: function () {
     return App.ajax.send({
       name: 'cluster_name',
       sender: this,
       data: {
-        urlPrefix: '/api/v1/',
-        loadConfigs: loadConfigs
+        urlPrefix: '/api/v1/'
       },
       success: 'getClusterNameSuccessCallback'
     });
@@ -115,13 +154,10 @@ App.SliderController = Ember.Controller.extend({
   getClusterNameSuccessCallback: function (data, opt, params) {
     var clusterName = Em.get(data.items[0], 'Clusters.cluster_name');
     App.set('clusterName', clusterName);
-    App.ApplicationStatusMapper.loop('load');
     this.loadComponentHost({componentName: "GANGLIA_SERVER", callback: "loadGangliaHostSuccessCallback"});
     this.loadComponentHost({componentName: "NAGIOS_SERVER", callback: "loadNagiosHostSuccessCallback"});
     this.loadComponentHost({componentName: "ZOOKEEPER_SERVER", callback: "setZookeeperQuorum"});
-    if(params.loadConfigs) {
-      this.loadConfigsTags();
-    }
+    this.loadConfigsTags();
   },
 
   /**
@@ -182,8 +218,8 @@ App.SliderController = Ember.Controller.extend({
     initialValuesToLoad.set('ambariAddress', location.protocol + "//" + document.location.host);
     initialValuesToLoad.set('clusterName', App.get('clusterName'));
     initialValuesToLoad.set('hdfsAddress', hdfs.properties['fs.defaultFS']);
-    initialValuesToLoad.set('yarnRMAddress', yarn.properties['yarn.resourcemanager.address']);
-    initialValuesToLoad.set('yarnRMSchedulerAddress', yarn.properties['yarn.resourcemanager.scheduler.address']);
+    initialValuesToLoad.set('yarnResourceManager', yarn.properties['yarn.resourcemanager.address']);
+    initialValuesToLoad.set('yarnResourceManagerScheduler', yarn.properties['yarn.resourcemanager.scheduler.address']);
     initialValuesToLoad.set('zookeeperQuorum', zookeeper.properties.clientPort);
     this.setZookeeperQuorum();
   },
@@ -238,14 +274,39 @@ App.SliderController = Ember.Controller.extend({
           ViewInstanceInfo: {
             properties: {
               'hdfs.address': initialValues.get('hdfsAddress'),
-              'yarn.resourcemanager.address': initialValues.get('yarnRMAddress'),
-              'yarn.resourcemanager.scheduler.address': initialValues.get('yarnRMSchedulerAddress'),
+              'yarn.resourcemanager.address': initialValues.get('yarnResourceManager'),
+              'yarn.resourcemanager.scheduler.address': initialValues.get('yarnResourceManagerScheduler'),
               'zookeeper.quorum': initialValues.get('zookeeperQuorum')
             }
           }
         }
+      },
+      success: 'finishSliderConfiguration'
+    });
+  },
+
+  /**
+   * After all Slider-configs are loaded, application should check self status
+   * @method finishSliderConfiguration
+   */
+  finishSliderConfiguration: function() {
+    //check if all services exist
+    var serviceConfigMap = this.get('serviceConfigMap'),
+      initialValuesToLoad = this.get('initialValuesToLoad'),
+      services = Em.keys(serviceConfigMap),
+      errors = [];
+    services.forEach(function(serviceName) {
+      var configName = Em.get(serviceConfigMap, serviceName);
+      if (Em.isEmpty(initialValuesToLoad[configName])) {
+        errors.push(Em.I18n.t('error.no' + serviceName));
       }
     });
+    App.setProperties({
+      viewErrors: errors,
+      viewEnabled: errors.length === 0,
+      sliderConfigs: initialValuesToLoad,
+      mapperTime: new Date().getTime()
+    });
   },
 
   /**

contrib/views/slider/src/main/resources/ui/app/helpers/ajax.js

@@ -32,7 +32,11 @@ var urls = {
 
   'slider.getViewParams': {
     real: '',
-    mock: '/data/resource/slider-properties.json'
+    mock: '/data/resource/slider-properties.json',
+    headers: {
+      Accept: "text/plain; charset=utf-8",
+      "Content-Type": "text/plain; charset=utf-8"
+    }
   },
 
   'mapper.applicationTypes': {

contrib/views/slider/src/main/resources/ui/app/initialize.js

@@ -59,12 +59,6 @@ App.initializer({
        */
       version: viewVersion,
 
-      /**
-       * Version of SLIDER_1 resource
-       * @type {string}
-       */
-      resourcesVersion: '',
-
       /**
        * @type {string}
        */
@@ -102,16 +96,35 @@ App.initializer({
        * Host with Ganglia Server
        * @type {string|null}
        */
-      gangliaHost: null
+      gangliaHost: null,
+
+      /**
+       * List of Ganglia clusters
+       * @type {array|null}
+       */
+      gangliaClusters: null,
+
+      /**
+       * View-configs set from ambari-admin
+       * Loaded in <code>App.SliderController</code>
+       * @type {null|object}
+       */
+      sliderConfigs: null,
+
+      /**
+       * Last time when mapper ran
+       * @type {null|number}
+       */
+      mapperTime: null
 
     });
-    application.SliderController.proto().initResources();
+    application.SliderController.proto().loop('initResources');
     application.ApplicationTypeMapper.loop('load');
     application.SliderAppsMapper.loop('load');
   }
 });
 
-// Load all modules in order automagically. Ember likes things to work this
+// Load all modules in order automatically. Ember likes things to work this
 // way so everything is in the App.* namespace.
 var folderOrder = [
     'initializers', 'mixins', 'routes', 'models', 'mappers',