Mirror filters and sort preferences to url-params

appengine/swarming/elements/res/imp/botlist/bot-list-data.html

 <!--
   Copyright 2016 The LUCI Authors. All rights reserved.
   Use of this source code is governed under the Apache License, Version 2.0
   that can be found in the LICENSE file.
 
   This in an HTML Import-able file that contains the definition
   of the following elements:
 
     <bot-list-data>
 
   This makes calls authenticated with Oauth 2 to the swarming apis.  It parses
   that data into usable data structures.
 
   Usage:
 
     <bot-list-data></bot-list-data>
 
   Properties:
     // inputs
     auth_headers: Object, the OAuth2 header to include in the request.  This
         should come from swarming-app.
+    query_params: Object, The query params that will filter the query
+        server-side.  This can have dimensions:Array<String>, quarantined:String
+        and is_dead: String. For example:
+        {
+          "dimensions": ["pool:Skia", "device_type:Sprout"],
+          "quarantined": "FALSE",  // optional
+          "is_dead": "TRUE",       // optional
+        }
+        For a full list of dimensions in the fleet, see the API call:
+        https://[swarming_url]/_ah/api/swarming/v1/bots/dimensions
     // outputs
     bots: Array<Object>, all bots returned by the botlist.  This is an Object
         with at least the following structure:
       dimensions: Array<Object>: Has key:String and value:Array<String>
       task_id: String
       external_ip: String
       is_dead: Object: Is usually Boolean, but could be message string
       quarantined: Object: Is usually Boolean, but could be message string
       bot_id: String
       state: String, Stringified JSON that has many pieces of information, like
                 devices, disk space, temperature, etc.
     busy: Boolean, if any ajax requests are in flight.
+    dimensions: Array<String>, of all valid dimensions.
     fleet: Object, counts of all bots in the fleet.  Contains "alive", "busy",
         "idle", "dead", and "quarantined".
     primary_map: Object, a mapping of primary keys to secondary items.
         The primary keys are things that can be columns or sorted by.  The
         primary values (aka the secondary items) are things that can be filtered
         on. Primary consists of dimensions and state.  Secondary contains the
         values primary things can be.
     primary_arr: Array<String>, the display order of the primary keys.
         This is dimensions, then bot properties, then elements from bot.state.
 
   Methods:
     signIn(): Force a signin of the user using OAuth.  This happens
         automatically when auth_headers is set.
 
   Events:
     None.
 -->
 
 <link rel="import" href="/res/imp/bower_components/iron-ajax/iron-ajax.html">
 
 <link rel="import" href="bot-list-shared.html">
 
 <dom-module id="bot-list-data">
   <template>
     <iron-ajax id="botlist"
        url="/_ah/api/swarming/v1/bots/list"
        headers="[[auth_headers]]"
-       params="[[_botlistParams(dimensions.*)]]"
+       params="[[query_params]]"
        handle-as="json"
        last-response="{{_list}}"
        loading="{{_busy1}}">
     </iron-ajax>
 
     <iron-ajax id="dimensions"
        url="/_ah/api/swarming/v1/bots/dimensions"
        headers="[[auth_headers]]"
        handle-as="json"
        last-response="{{_dimensions}}"
        loading="{{_busy2}}">
     </iron-ajax>
 
     <iron-ajax id="fleet"
        url="/_ah/api/swarming/v1/bots/count"
        headers="[[auth_headers]]"
        handle-as="json"
        last-response="{{_count}}"
        loading="{{_busy3}}">
     </iron-ajax>
   </template>
   <script>
   (function(){
+    var BLACKLIST_DIMENSIONS = ["quarantined", "error"];
 
     Polymer({
       is: 'bot-list-data',
 
       behaviors: [SwarmingBehaviors.BotListBehavior],
 
       properties: {
         // inputs
         auth_headers: {
           type: Object,
           observer: "signIn",
         },
-        dimensions: {
-          type: Array,
+        query_params: {
+          type: Object,
         },
 
         //outputs
         bots: {
           type: Array,
           computed: "_bots(_list)",
           notify: true,
         },
         busy: {
           type: Boolean,
           computed: "_or(_busy1,_busy2,_busy3)",
           notify: true,
         },
+        dimensions: {
+          type: Array,
+          computed: "_makeArray(_dimensions)",
+          notify: true,
+        },
         fleet: {
           type: Object,
           computed: "_fleet(_count)",
           notify: true,
         },
         primary_map: {
           type:Object,
           computed: "_primaryMap(_dimensions)",
           notify: true,
         },
         primary_arr: {
           type: Array,
-          // DIMENSIONS and BOT_PROPERTIES are inherited from BotListBehavior
-          computed: "_primaryArr(DIMENSIONS, BOT_PROPERTIES)",
+          //BOT_PROPERTIES is inherited from BotListBehavior
+          computed: "_primaryArr(dimensions, BOT_PROPERTIES)",
           notify: true,
         },
 
         // private
         _count: {
           type: Object,
         },
         _dimensions: {
           type: Object,
         },
         _list: {
           type: Object,
         },
       },
 
       signIn: function(){
+        // Auto on iron-ajax means to automatically re-make the request if
+        // the url or the query params change.  Auto does not trigger if the
+        // [auth] headers change, so we wait until the user is signed in
+        // before making any requests.
         this.$.botlist.auto = true;
         this.$.dimensions.auto = true;
         this.$.fleet.auto = true;
       },
 
-      _botlistParams: function() {
-        if (!this.dimensions) {
-          return {};
-        }
-        return {
-          dimensions: this.dimensions,
-        };
-      },
-
       _bots: function(){
         if (!this._list || !this._list.items) {
           return [];
         }
         // Do any preprocessing here
         this._list.items.forEach(function(bot){
           // Parse the state, which is a JSON string.  This contains a lot of
           // interesting information like details about the devices attached.
           bot.state = JSON.parse(bot.state);
           // get the disks in an easier to deal with format, sorted by size.
@@ skipping 14 matching lines @@
 
         });
         return this._list.items;
       },
 
       _fleet: function() {
         if (!this._count) {
           return {};
         }
         return {
-          alive: this._count.count || -1,
+          all: this._count.count || -1,
+          alive: (this._count.count - this._count.dead) || -1,
           busy: this._count.busy || -1,
-          idle: this._count.count && this._count.busy &&
-              this._count.count - this._count.busy,
+          idle: (this._count.count - this._count.busy) || -1,
           dead: this._count.dead || -1,
           quarantined: this._count.quarantined || -1,
         }
       },
 
+      _makeArray: function(dimObj) {
+        if (!dimObj || !dimObj.bots_dimensions) {
+          return [];
+        }
+        var dims = [];
+        dimObj.bots_dimensions.forEach(function(d){
+          if (BLACKLIST_DIMENSIONS.indexOf(d.key) === -1) {
+            dims.push(d.key);
+          }
+        });
+        dims.sort();
+        return dims;
+      },
+
       _primaryArr: function(dimensions, properties) {
         return dimensions.concat(properties);
       },
 
       _primaryMap: function(dimensions){
-        // map will keep track of dimensions that we have seen at least once.
-        // This will then basically get turned into an array to be used for
-        // filtering.
+        // pMap will have a list of columns to available values (primary key
+        // to secondary values). This includes bot dimensions, but also
+        // includes state like disk_space, quarantined, busy, etc.
         dimensions = dimensions.bots_dimensions;
 
         var pMap = {};
         dimensions.forEach(function(d){
           if (this.DIMENSIONS_WITH_ALIASES.indexOf(d.key) === -1) {
             // value is an array of all seen values for the dimension d.key
             pMap[d.key] = d.value;
           } else if (d.key === "gpu") {
             var gpus = [];
             d.value.forEach(function(g){
@@ skipping 24 matching lines @@
         // Add some options that might not show up.
         pMap["android_devices"].push("0");
         pMap["device_os"].push("none");
         pMap["device_type"].push("none");
 
         pMap["id"] = [];
 
         // Create custom filter options
         pMap["disk_space"] = [];
         pMap["task"] = ["busy", "idle"];
-        pMap["status"] = ["available", "dead", "quarantined"];
+        pMap["status"] = ["alive", "dead", "quarantined"];
 
         // No need to sort any of this, bot-filters sorts secondary items
         // automatically, especially when the user types a query.
         return pMap;
       },
 
     });
   })();
   </script>
 </dom-module>