MuranoCLI 2.2.4 → 3.0.0

data/lib/MrMurano/commands/tsdb.rb

@@ -1,13 +1,23 @@
+# Last Modified: 2017.08.16 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
 require 'date'
+require 'MrMurano/ReCommander'
 require 'MrMurano/Solution-ServiceConfig'
 require 'MrMurano/SubCmdGroupContext'
 
 module MrMurano
   module ServiceConfigs
     class Tsdb < ServiceConfig
-      def initialize
+      def initialize(sid=nil)
+        # FIXME/2017-07-03: What soln types have TSDBs?
+        @solntype = 'application.id'
         super
-        @serviceName = 'tsdb'
+        @service_name = 'tsdb'
       end
 
       def write(data)
@@ -18,6 +28,8 @@ module MrMurano
         call(:query, :post, query)
       end
 
+      # FIXME/2017-08-16: Convert to snake_case. Or is this method name magical?
+      # rubocop:disable Style/MethodName: Use snake_case for method names.
       def listTags
         call(:listTags)
       end
@@ -26,34 +38,54 @@ module MrMurano
         call(:listMetrics)
       end
 
-
       def str_to_timestamp(str)
-        if str =~ /^\d+(u|ms|s)?$/ then
+        if str =~ /^\d+(u|ms|s)?$/
           str
         else
           dt = DateTime.parse(str)
-          (dt.to_time.to_f * 1000000).to_i
+          (dt.to_time.to_f * 1_000_000).to_i
         end
       end
     end
   end
 end
 
+command :tsdb do |c|
+  c.syntax = %(murano tsdb)
+  c.summary = %(Show list of TSDB commands)
+  c.description = %(
+The tsdb sub-commands let you interact directly with the TSDB instance in a
+solution. This allows for easier debugging, being able to quickly try out
+different queries or write test data.
+  ).strip
+  c.project_not_required = true
+
+  c.action do |_args, _options|
+    ::Commander::UI.enable_paging
+    say MrMurano::SubCmdGroupHelp.new(c).get_help
+  end
+end
+
 command 'tsdb write' do |c|
-  c.syntax = %{murano tsdb write [options] <metric=value>|@<tag=value> … }
-  c.summary = %{write data}
-  c.description = %{Write data
+  c.syntax = %(murano tsdb write [--options] <metric=value>|@<tag=value> … )
+  c.summary = %(Write data to the TSDB)
+  c.description = %(
+Write data to the time series database (TSDB).
 
 TIMESTAMP is microseconds since unix epoch, or can be suffixed with units.
 Units are u (microseconds), ms (milliseconds), s (seconds)
 
 Also, many date-time formats can be parsed and will be converted to microseconds
-  }
-  c.option '--when TIMESTAMP', %{When this data happened. (defaults to now)}
+  ).strip
+
+  c.option '--when TIMESTAMP', %(When this data happened (default: now))
   # TODO: add option to take data from STDIN.
-  c.example 'murano tsdb write hum=45 lux=12765 @sn=44', %{Write two metrics (hum and lux) with a tag (sn)}
+
+  c.example 'murano tsdb write hum=45 lux=12765 @sn=44', %(Write two metrics (hum and lux) with a tag (sn))
 
   c.action do |args, options|
+    # SKIP: c.verify_arg_count!(args)
+
     sol = MrMurano::ServiceConfigs::Tsdb.new
 
     # we have hash of tags, hash of metrics, optional timestamp.
@@ -61,32 +93,31 @@ Also, many date-time formats can be parsed and will be converted to microseconds
     tags = {}
     args.each do |item|
       key, value = item.split('=', 2)
-      if key[0] == '@' then
-        tags[key[1..-1]] = value.to_s  #tags are always strings.
+      if key[0] == '@'
+        tags[key[1..-1]] = value.to_s # tags are always strings.
       else
         value = value.to_i if value == value.to_i.to_s
         metrics[key] = value
       end
     end
 
-    data = {:tags=>tags, :metrics=>metrics}
-    if not options.when.nil? and options.when != 'now' then
+    data = { tags: tags, metrics: metrics }
+    if !options.when.nil? && options.when != 'now'
       data[:ts] = sol.str_to_timestamp(options.when)
     end
 
     ret = sol.write(data)
-    if ret != {} then
-      sol.error ret
-    end
+    sol.error ret if ret != {}
   end
 end
 
 command 'tsdb query' do |c|
-  c.syntax = %{murano tsdb query [options] <metric>|@<tag=value> …}
-  c.summary = %{query data}
-  c.description =%{Query data from the TSDB.
+  c.syntax = %(murano tsdb query [--options] <metric>|@<tag=value> …)
+  c.summary = %(Query data from the TSDB)
+  c.description = %(
+Query data from the time series database (TSDB).
 
-FUNCS is a comma seperated list of the aggregate functions.
+FUNCS is a comma separated list of the aggregate functions.
 Currently: avg, min, max, count, sum.  For string metrics, only count.
 
 FILL is null, none, any integer, previous
@@ -99,20 +130,21 @@ TIMESTAMP is microseconds since unix epoch, or can be suffixed with units.
 Units are u (microseconds), ms (milliseconds), s (seconds)
 
 Also, many date-time formats can be parsed and will be converted to microseconds
-  }
-  c.option '--start_time TIMESTAMP', %{Start time range}
-  c.option '--end_time TIMESTAMP', %{End time range; defaults to now}
-  c.option '--relative_start DURATION', %{Start time relative from now}
-  c.option '--relative_end DURATION', %{End time relative from now}
-  c.option '--sampling_size DURATION', %{The size of time slots used for downsampling}
-  c.option '--limit NUM', Integer, %{Limit number of data points returned}
-  c.option '--epoch UNIT', ['u','ms','s'], %{Set size of returned timestamps}
-  c.option '--mode MODE', ['merge','split'], %{Merge or split each returned metric}
-  c.option '--fill FILL', %{Value to fill for time slots with no data points exist in merge mode}
-  c.option '--order_by ORDER', ['desc','asc'], %{Return results in ascending or descending time order}
-  c.option '--aggregate FUNCS', %{Aggregation functions to apply}
-
-  c.option '-o', '--output FILE', %{Download to file instead of STDOUT}
+  ).strip
+
+  c.option '--start_time TIMESTAMP', %(Start time range)
+  c.option '--end_time TIMESTAMP', %(End time range; defaults to now)
+  c.option '--relative_start DURATION', %(Start time relative from now)
+  c.option '--relative_end DURATION', %(End time relative from now)
+  c.option '--sampling_size DURATION', %(The size of time slots used for downsampling)
+  c.option '--limit NUM', Integer, %(Limit number of data points returned)
+  c.option '--epoch UNIT', %w[u ms s], %(Set size of returned timestamps)
+  c.option '--mode MODE', %w[merge split], %(Merge or split each returned metric)
+  c.option '--fill FILL', %(Value to fill for time slots with no data points exist in merge mode)
+  c.option '--order_by ORDER', %w[desc asc], %(Return results in ascending or descending time order)
+  c.option '--aggregate FUNCS', %(Aggregation functions to apply)
+
+  c.option '-o', '--output FILE', %(Download to file instead of STDOUT)
 
   c.example 'murano tsdb query hum', 'Get all hum metric entries'
   c.example 'murano tsdb query hum @sn=45', 'Get all hum metric entries for tag sn=45'
@@ -123,17 +155,18 @@ Also, many date-time formats can be parsed and will be converted to microseconds
   c.example 'murano tsdb query hum --sampling_size 30m', 'Get one hum entry from each 30 minute chunk of time'
   c.example 'murano tsdb query hum --sampling_size 30m --aggregate avg', 'Get average hum entry from each 30 minute chunk of time'
 
-
   c.action do |args, options|
+    # SKIP: c.verify_arg_count!(args)
+
     sol = MrMurano::ServiceConfigs::Tsdb.new
 
     query = {}
     tags = {}
     metrics = []
     args.each do |arg|
-      if arg =~ /=/ then
+      if arg =~ /=/
         # a tag.
-        k,v = arg.split('=', 2)
+        k, v = arg.split('=', 2)
         k = k[1..-1] if k[0] == '@'
         tags[k] = v
       else
@@ -145,24 +178,24 @@ Also, many date-time formats can be parsed and will be converted to microseconds
 
     # A query without any metrics is invalid.  So if the user didn't provide any,
     # look up all of them (well, frist however many) and use that list.
-    if query[:metrics].nil? or query[:metrics].empty? then
+    if query[:metrics].to_s.empty?
       ret = sol.listMetrics
       query[:metrics] = ret[:metrics]
     end
 
-    unless options.start_time.nil? then
+    unless options.start_time.nil?
       query[:start_time] = sol.str_to_timestamp(options.start_time)
     end
-    unless options.end_time.nil? then
+    unless options.end_time.nil?
       query[:end_time] = sol.str_to_timestamp(options.end_time)
     end
 
-    unless options.relative_start.nil? then
+    unless options.relative_start.nil?
       o = options.relative_start
       o = "-#{o}" unless o[0] == '-'
       query[:relative_start] = o
     end
-    unless options.relative_end.nil? then
+    unless options.relative_end.nil?
       o = options.relative_end
       o = "-#{o}" unless o[0] == '-'
       query[:relative_end] = o
@@ -175,79 +208,86 @@ Also, many date-time formats can be parsed and will be converted to microseconds
     query[:order_by] = options.order_by unless options.order_by.nil?
 
     query[:fill] = options.fill unless options.fill.nil?
-    unless options.aggregate.nil? then
+    unless options.aggregate.nil?
       query[:aggregate] = options.aggregate.split(',')
     end
 
-    io=nil
-    if options.output then
-      io = File.open(options.output, 'w')
-    end
+    io = File.open(options.output, 'w') if options.output
     sol.outf sol.query(query) do |dd, ios|
       # If aggregated, then we need to break up the columns. since each is now a
       # hash of the aggregated functions
-      unless options.aggregate.nil? then
+      unless options.aggregate.nil?
         dd[:values].map! do |row|
           row.map do |value|
-            if value.kind_of? Hash then
-              query[:aggregate].map{|qa| value[qa.to_sym]}
+            if value.is_a? Hash
+              query[:aggregate].map { |qa| value[qa.to_sym] }
             else
               value
             end
           end.flatten
         end
         dd[:columns].map! do |col|
-          if col == 'time' then
+          if col == 'time'
             col
           else
-            query[:aggregate].map{|qa| "#{col}.#{qa.to_s}"}
+            query[:aggregate].map { |qa| "#{col}.#{qa}" }
           end
         end.flatten!
       end
-      sol.tabularize({
-        :headers=>dd[:columns],
-        :rows=>dd[:values]
-      }, ios)
+      sol.tabularize(
+        {
+          headers: dd[:columns],
+          rows: dd[:values],
+        },
+        ios
+      )
     end
     io.close unless io.nil?
   end
 end
 
 command 'tsdb list tags' do |c|
-  c.syntax = %{murano tsdb list tags [options]}
-  c.summary = %{List tags}
-  c.option '--values', %{Also return the known tag values}
+  c.syntax = %(murano tsdb list tags [--options])
+  c.summary = %(List tags)
+  c.description = %(
+List tags.
+  ).strip
+
+  c.option '--values', %(Include the known tag values)
 
   c.action do |args, options|
-    options.default :values=>false
+    c.verify_arg_count!(args)
+    options.default(values: false)
 
     sol = MrMurano::ServiceConfigs::Tsdb.new
     ret = sol.listTags
     # TODO: handle looping if :next != nil
 
-    if options.values then
+    if options.values
       sol.outf(ret[:tags]) do |dd, ios|
-        data={}
+        data = {}
         data[:headers] = dd.keys
-        data[:rows] = dd.keys.map{|k| dd[k]}
-        len = data[:rows].map{|i| i.length}.max
-        data[:rows].each{|r| r.fill(nil, r.length, len - r.length)}
+        data[:rows] = dd.keys.map { |k| dd[k] }
+        len = data[:rows].map(&:length).max
+        data[:rows].each { |r| r.fill(nil, r.length, len - r.length) }
         data[:rows] = data[:rows].transpose
         sol.tabularize(data, ios)
       end
     else
       sol.outf ret[:tags].keys
     end
-
-
   end
 end
 
 command 'tsdb list metrics' do |c|
-  c.syntax = %{murano tsdb list metrics}
-  c.summary = %{List metrics}
-
-  c.action do |args, options|
+  c.syntax = %(murano tsdb list metrics)
+  c.summary = %(List metrics)
+  c.description = %(
+List metrics.
+  ).strip
+
+  c.action do |args, _options|
+    c.verify_arg_count!(args)
     sol = MrMurano::ServiceConfigs::Tsdb.new
     ret = sol.listMetrics
     # TODO: handle looping if :next != nil
@@ -255,17 +295,3 @@ command 'tsdb list metrics' do |c|
   end
 end
 
-command :tsdb do |c|
-  c.syntax = %{murano tsdb}
-  c.summary = %{About TSDB}
-  c.description = %{The tsdb sub-commands let you interact directly with the TSDB instance in a
-solution.  This allows for easier debugging, being able to quickly try out
-different queries or write test data.}
-
-  c.action do |args, options|
-    ::Commander::UI.enable_paging
-    say MrMurano::SubCmdGroupHelp.new(c).get_help
-  end
-end
-
-#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/commands/usage.rb

@@ -1,23 +1,65 @@
+# Last Modified: 2017.08.16 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
+require 'MrMurano/ReCommander'
 require 'MrMurano/Solution'
 
 command :usage do |c|
-  c.syntax = %{murano usage}
-  c.summary = %{Get usage info for project}
-  c.description = %{Get usage info for project}
-
-  c.action do |args,options|
-    sol = MrMurano::Solution.new
-    sol.outf(sol.usage) do |dd,ios|
-      headers = ['', :Quota, :Daily, :Monthly, :Total]
-      rows = []
-      dd.each_pair do |key,value|
-        quota = value[:quota] or {}
-        usage = value[:usage] or {}
-        rows << [key, quota[:daily], usage[:calls_daily], usage[:calls_monthly], usage[:calls_total]]
+  c.syntax = %(murano usage)
+  c.summary = %(Get usage info for solution(s))
+  c.description = %(
+Get usage info for solution(s).
+  ).strip
+
+  # Add flag: --type [application|product|all].
+  cmd_add_solntype_pickers(c)
+
+  c.option '--[no-]all', 'Show usage for all Solutions in Business, not just Project'
+  c.option(
+    '--[no-]header', %(Output solution descriptions (default: true))
+  )
+
+  c.action do |args, options|
+    c.verify_arg_count!(args)
+    options.default(all: false, header: true)
+    cmd_defaults_solntype_pickers(options)
+
+    solz = must_fetch_solutions!(options)
+
+    solsages = []
+    MrMurano::Verbose.whirly_start('Fetching usage...')
+    solz.each do |sol|
+      solsages += [[sol, sol.usage]]
+    end
+    MrMurano::Verbose.whirly_stop
+
+    solsages.each do |sol, usage|
+      sol.outf(usage) do |dd, ios|
+        ios.puts(sol.pretty_desc(add_type: true)) if options.header
+        headers = ['', :Quota, :Daily, :Monthly, :Total]
+        rows = []
+        dd.each_pair do |key, value|
+          quota = value[:quota] || {}
+          usage = value[:usage] || {}
+          rows << [
+            key,
+            quota[:daily],
+            usage[:calls_daily],
+            usage[:calls_monthly],
+            usage[:calls_total],
+          ]
+        end
+        sol.tabularize({ headers: headers, rows: rows }, ios)
       end
-      sol.tabularize({:headers=>headers,:rows=>rows}, ios)
     end
   end
 end
+alias_command 'usage application', 'usage', '--type', 'application'
+alias_command 'usage product', 'usage', '--type', 'product'
+alias_command 'application usage', 'usage', '--type', 'application'
+alias_command 'product usage', 'usage', '--type', 'product'
 
-#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/hash.rb

@@ -1,20 +1,110 @@
+# Last Modified: 2017.08.16 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
+require 'orderedhash'
 
-# from: http://www.any-where.de/blog/ruby-hash-convert-string-keys-to-symbols/
 class Hash
-  #take keys of hash and transform those to a symbols
+  # From:
+  #   http://www.any-where.de/blog/ruby-hash-convert-string-keys-to-symbols/
+  #
+  # Take keys of hash and transform those to symbols.
   def self.transform_keys_to_symbols(value)
-    return value.map{|v| Hash.transform_keys_to_symbols(v)} if value.is_a?(Array)
+    return value.map { |v| Hash.transform_keys_to_symbols(v) } if value.is_a?(Array)
     return value if not value.is_a?(Hash)
-    hash = value.inject({}){|memo,(k,v)| memo[k.to_sym] = Hash.transform_keys_to_symbols(v); memo}
-    return hash
+    value.inject({}) { |memo, (k,v)| memo[k.to_sym] = Hash.transform_keys_to_symbols(v); memo }
   end
-  #take keys of hash and transform those to strings
+
+  # From:
+  #   http://www.any-where.de/blog/ruby-hash-convert-string-keys-to-symbols/
+  #
+  # Take keys of hash and transform those to strings.
   def self.transform_keys_to_strings(value)
-    return value.map{|v| Hash.transform_keys_to_strings(v)} if value.is_a?(Array)
+    return value.map { |v| Hash.transform_keys_to_strings(v) } if value.is_a?(Array)
     return value if not value.is_a?(Hash)
-    hash = value.inject({}){|memo,(k,v)| memo[k.to_s] = Hash.transform_keys_to_strings(v); memo}
-    return hash
+    value.inject({}) { |memo, (k,v)| memo[k.to_s] = Hash.transform_keys_to_strings(v); memo }
+  end
+
+  # From Rails.
+  def deep_merge!(other_hash, &block)
+    other_hash.each_pair do |current_key, other_value|
+      this_value = self[current_key]
+      if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+        self[current_key] = this_value.deep_merge(other_value, &block)
+      elsif block_given? && key?(current_key)
+        self[current_key] = block.call(current_key, this_value, other_value)
+      else
+        self[current_key] = other_value
+      end
+    end
+    self
+  end
+end
+
+def ordered_hash(dict)
+  ohash = OrderedHash.new
+  dict.keys.sort.each do |key|
+    value = dict[key]
+    if value.is_a? Hash
+      ohash[key] = ordered_hash(value)
+    else
+      ohash[key] = value
+    end
+  end
+  ohash
+end
+
+##
+# Take a hash or something (a Commander::Command::Options) and return a hash
+#
+# @param hsh [Hash, Commander::Command::Options] Thing we want to be a Hash
+# @return [Hash] an actual Hash with default value of false
+def elevate_hash(hsh)
+  # Commander::Command::Options stripped all of the methods from parent
+  # objects. I have not nice thoughts about that.
+  begin
+    hsh = hsh.__hash__
+  # rubocop:disable Lint/HandleExceptions: Do not suppress exceptions.
+  rescue NoMethodError
+    # swallow this.
+  end
+  # build a hash where the default is 'false' instead of 'nil'
+  Hash.new(false).merge(Hash.transform_keys_to_symbols(hsh))
+  # 2017-08-16: Weird: [lb] seeing the Hash behave differently
+  #   after feeding through this function. Unknown keys would
+  #   return nil before, but after, return false.
+  #
+  #   (byeebug) options
+  #   {:delete=>false, :create=>true, :update=>false}
+  #   (byeebug) options[:fff]
+  #   false
+  #   (byeebug) options[:fff] = nil
+  #   nil
+  #   (byeebug) options[:fff]
+  #   nil
+  #   (byeebug) options[:fffd]
+  #   false
+  #   (byeebug) options
+  #   {:delete=>false, :create=>true, :update=>false, :fff=>nil}
+  #
+  #   Work around is to test with hash.key?
+end
+
+##
+# Array-ify the given item, if not already an array.
+#
+# NOTE/2017-08-15: This fcn. is not hash-related, but this file is the
+#   closest we've got to a generic utility method dumping ground.
+def ensure_array(item)
+  if item.nil?
+    []
+  elsif !item.is_a?(Array)
+    [item]
+  else
+    item
   end
 end
 
-#  vim: set ai et sw=2 ts=2 :