wavefront-cli 0.0.2

data/lib/wavefront-cli/commands/source.rb

@@ -0,0 +1,27 @@
+require_relative './base'
+
+# Define the source command.
+#
+class WavefrontCommandSource < WavefrontCommandBase
+  def description
+    'view and manage source tags and descriptions'
+  end
+
+  def _commands
+    ["list #{CMN} [-l] [-f format] [-o offset] [-L limit] [-a]",
+     "describe #{CMN} [-f format] <id>",
+     "description set  #{CMN} <id> <description>",
+     "description clear  #{CMN} <id>",
+     "clear  #{CMN} <id>",
+     tag_commands]
+  end
+
+  def _options
+    [common_options,
+     '-l, --long                 list sources in detail',
+     '-o, --offset=n             start list from nth source',
+     '-L, --limit=COUNT          number of sources to list',
+     '-a, --all                  list all sources, including cluster',
+     '-f, --format=STRING        output format']
+  end
+end

data/lib/wavefront-cli/commands/user.rb

@@ -0,0 +1,24 @@
+require_relative './base'
+
+# Define the user command.
+#
+class WavefrontCommandUser < WavefrontCommandBase
+  def description
+    'view and manage Wavefront users'
+  end
+
+  def _commands
+    ["list #{CMN} [-l]",
+     "describe #{CMN} [-f format] <id>",
+     "delete #{CMN} <id>",
+     "import #{CMN} <file>",
+     "grant #{CMN} <privilege> to <id>",
+     "revoke #{CMN} <privilege> from <id>"]
+  end
+
+  def _options
+    [common_options,
+     '-l, --long                list users in detail',
+     '-f, --format=STRING       output format']
+  end
+end

data/lib/wavefront-cli/commands/webhook.rb

@@ -0,0 +1,25 @@
+require_relative './base'
+
+# Define the webhook command.
+#
+class WavefrontCommandWebhook < WavefrontCommandBase
+  def description
+    'view and manage webhooks'
+  end
+
+  def _commands
+    ["list #{CMN} [-l] [-f format] [-o offset] [-L limit]",
+     "describe #{CMN} [-f format] <id>",
+     "delete #{CMN} <id>",
+     "import #{CMN} <file>",
+     "update #{CMN} <key=value> <id>"]
+  end
+
+  def _options
+    [common_options,
+     '-l, --long                list webhooks in detail',
+     '-o, --offset=n            start list from nth webhook',
+     '-L, --limit=COUNT         number of webhooks to list',
+     '-f, --format=STRING       output format']
+  end
+end

data/lib/wavefront-cli/commands/window.rb

@@ -0,0 +1,33 @@
+require_relative './base'
+
+# Define the maintenance window command.
+#
+class WavefrontCommandWindow < WavefrontCommandBase
+  def description
+    'view and manage maintenance windows'
+  end
+
+  def sdk_file
+    'maintenancewindow'
+  end
+
+  def sdk_class
+    'MaintenanceWindow'
+  end
+
+  def _commands
+    ["list #{CMN} [-l] [-f format] [-o offset] [-L limit]",
+     "describe #{CMN} [-f format] <id>",
+     "delete #{CMN} <id>",
+     "import #{CMN} <file>",
+     "update #{CMN} <key=value> <id>"]
+  end
+
+  def _options
+    [common_options,
+     '-l, --long           list maintenance windows in detail',
+     '-o, --offset=n       start from nth maintenance window',
+     '-L, --limit=COUNT    number of maintenance windows to list',
+     '-f, --format=STRING  output format']
+  end
+end

data/lib/wavefront-cli/commands/write.rb

@@ -0,0 +1,35 @@
+require_relative './base'
+
+# Define the write command.
+#
+class WavefrontCommandWrite < WavefrontCommandBase
+  def description
+    'send data to a Wavefront proxy'
+  end
+
+  def _commands
+    ['point [-DnV] [-c file] [-P profile] [-E proxy] [-t time] ' \
+      '[-p port] [-H host] [-n] [-T tag...] <metric> <value>',
+     'file [-DnV] [-c file] [-P profile] [-E proxy] [-H host] ' \
+     '[-p port] [-n] [-F format] [-m metric] [-T tag...] <file>']
+  end
+
+  def _options
+    ['-E, --proxy=URI            proxy endpoint',
+     '-t, --time=TIME            time of data point (omit to use ' \
+     'current time)',
+     '-H, --host=STRING          source host', \
+     '-p, --port=INT             Wavefront proxy port',
+     '-T, --tag=TAG              point tag in key=value form',
+     '-F, --infileformat=STRING  format of input file or stdin',
+     '-m, --metric=STRING        the metric path to which contents of ' \
+     'a file will be assigned. If the file contains a metric name, ' \
+     'the two will be concatenated']
+  end
+
+  def postscript
+    %(Files are whitespace separated, and fields can be defined
+       with the -F option.  Use 't' for timestamp; 'm' for metric
+       name; 'v' for value and 'T' for tags. Put 'T' last.)
+  end
+end

data/lib/wavefront-cli/constants.rb

@@ -0,0 +1,17 @@
+module WavefrontCli
+
+  # Universal truths
+  #
+  module Constants
+    HUMAN_TIME_FORMAT = '%F %T'.freeze
+    HUMAN_TIME_FORMAT_MS = '%F %T.%3N'.freeze
+
+    # The CLI will use these options if they are not supplied on the
+    # command line or in a config file.
+    #
+    DEFAULT_OPTS = {
+      endpoint: 'metrics.wavefront.com',
+      format:   :human,
+    }.freeze
+  end
+end

data/lib/wavefront-cli/controller.rb

@@ -0,0 +1,134 @@
+require 'pathname'
+require 'pp'
+require 'docopt'
+require_relative './version'
+require_relative './opt_handler'
+require_relative './exception'
+
+$LOAD_PATH.<< Pathname.new(__FILE__).dirname.realpath.parent.parent
+              .parent + 'lib'
+$LOAD_PATH.<< Pathname.new(__FILE__).dirname.realpath.parent.parent
+              .parent + 'wavefront-sdk' + 'lib'
+
+CMD_DIR = Pathname.new(__FILE__).dirname + 'commands'
+
+# Dynamically generate a CLI interface from files which describe
+# each subcomand.
+#
+class WavefrontCliController
+  attr_reader :args, :usage, :opts, :cmds, :tw
+
+  def initialize(args)
+    @args = args
+    @cmds = load_commands
+    @usage = docopt_hash
+    cmd, opts = parse_args
+    @opts = parse_opts(opts)
+    pp @opts if @opts[:debug]
+    hook = load_sdk(cmd, @opts)
+    run_command(hook)
+  end
+
+  # What you see when you do 'wavefront --help'
+  #
+  def default_help
+    s = "Wavefront CLI\n\nUsage:\n  #{CMD} command [options]\n" \
+        "  #{CMD} --version\n  #{CMD} --help\n\nCommands:\n"
+
+    cmds.sort.each { |k, v| s.<< format("  %-15s %s\n", k, v.description) }
+    s.<< "\nUse '#{CMD} <command> --help' for further information.\n"
+  end
+
+  # Make a hash of command descriptions for docopt.
+  #
+  def docopt_hash
+    cmds.each_with_object(default: default_help) do |(k, v), ret|
+      ret[k.to_sym] = v.docopt
+    end
+  end
+
+  # Parse the input. The first Docopt.docopt handles the default
+  # options, the second works on the command.
+  #
+  def parse_args
+    Docopt.docopt(usage[:default], version: WF_CLI_VERSION, argv: args)
+  rescue Docopt::Exit => e
+    cmd = args.empty? ? nil : args.first.to_sym
+
+    abort e.message unless usage.keys.include?(cmd)
+
+    begin
+      [cmd, sanitize_keys(Docopt.docopt(usage[cmd], argv: args))]
+    rescue Docopt::Exit => e
+      abort e.message
+    end
+  end
+
+  def parse_opts(o)
+    WavefrontCli::OptHandler.new(conf_file, o).opts
+  end
+
+  # Get the SDK class we need to run the command we've been given.
+  #
+  def load_sdk(cmd, opts)
+    require_relative File.join('.', cmds[cmd].sdk_file)
+    Object.const_get('WavefrontCli').const_get(cmds[cmd].sdk_class).new(opts)
+  rescue WavefrontCli::Exception::UnhandledCommand
+    abort 'Fatal error. Unsupported command.'
+  rescue => e
+    p e
+  end
+
+  def run_command(hook)
+    hook.validate_opts
+    hook.run
+  rescue => e
+    $stderr.puts "general error: #{e}"
+    $stderr.puts "re-run with '-D' for stack trace." unless opts[:debug]
+    $stderr.puts "Backtrace:\n\t#{e.backtrace.join("\n\t")}" if opts[:debug]
+    abort
+  end
+
+  # Each command is defined in its own file. Dynamically load all
+  # those commands.
+  #
+  def load_commands
+    CMD_DIR.children.each_with_object({}) do |f, ret|
+      k = import_command(f)
+      ret[k.word.to_sym] = k if k
+    end
+  end
+
+  # Load a command description from a file. Each is in its own class
+  #
+  # @param f [Pathname] path of file to load
+  # return [Class] new class object defining command.
+  #
+  def import_command(f)
+    return if f.extname != '.rb' || f.basename.to_s == 'base.rb'
+    k_name = f.basename.to_s[0..-4]
+    require(CMD_DIR + k_name)
+    Object.const_get("WavefrontCommand#{k_name.capitalize}").new
+  end
+
+  # The default config file path.
+  #
+  # @return [Pathname] where we excpect to find a config file
+  #
+  def conf_file
+    if ENV['HOME']
+      Pathname.new(ENV['HOME']) + '.wavefront'
+    else
+      Pathname.new('/etc/wavefront/client.conf')
+    end
+  end
+
+  # Symbolize, and remove dashes from option keys
+  #
+  # @param h [Hash] options hash
+  # return [Hash] h with modified keys
+  #
+  def sanitize_keys(h)
+    h.each_with_object({}) { |(k, v), r| r[k.delete('-').to_sym] = v }
+  end
+end

data/lib/wavefront-cli/dashboard.rb

@@ -0,0 +1,27 @@
+require_relative './base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'dashboard' API.
+  #
+  class Dashboard < WavefrontCli::Base
+    def do_describe
+      wf.describe(options[:'<id>'], options[:version])
+    end
+
+    def do_delete
+      print (if wf.describe(options[:'<id>']).status.code == 200
+              'Soft'
+            else
+              'Permanently'
+            end)
+
+      puts " deleting dashboard '#{options[:'<id>']}'."
+      wf.delete(options[:'<id>'])
+    end
+
+    def do_history
+      wf.history(options[:'<id>'])
+    end
+  end
+end

data/lib/wavefront-cli/display/alert.rb

@@ -0,0 +1,44 @@
+require_relative './base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for alerts.
+  #
+  class Alert < Base
+    def do_list
+      long_output [:id, :minutes, :target, :status, :tags, :hostsUsed,
+                   :condition, :displayExpression, :severity,
+                   :additionalInformation]
+    end
+
+    def do_list_brief
+      multicolumn(:id, :status, :name)
+    end
+
+    def do_describe
+      readable_time(:created, :lastProcessedMillis,
+                    :lastNotificationMillis, :createdEpochMillis,
+                    :updatedEpochMillis, :updated)
+      drop_fields(:conditionQBEnabled, :displayExpressionQBEnabled,
+                  :displayExpressionQBSerialization)
+      long_output
+    end
+
+    def do_snooze
+      print "Snoozed alert '#{options[:'<id>']}' "
+
+      puts options[:time] ? "for #{options[:time]} seconds." :
+                            'indefinitely.'
+    end
+
+    def do_unsnooze
+      puts "Unsnoozed alert '#{options[:'<id>']}'."
+    end
+
+    def do_summary
+      kw = data.keys.map(&:size).max + 2
+      data.delete_if { |_k, v| v.zero? } unless options[:all]
+      data.sort.each { |k, v| puts format("%-#{kw}s%s", k, v) }
+    end
+  end
+end

data/lib/wavefront-cli/display/base.rb

@@ -0,0 +1,304 @@
+require_relative '../constants'
+
+module WavefrontDisplay
+  #
+  # Print human-friendly output. If a command requires a dedicated
+  # handler to format its output, define a method with the same name
+  # as that which fetches the data, in a WavefrontDisplay class,
+  # extending this one.
+  #
+  # We provide long_output() and terse_output() methods to solve
+  # standard formatting problems. To use them, define a do_() method
+  # but rather than printing the output, have it call the method.
+  #
+  class Base
+    include WavefrontCli::Constants
+
+    attr_reader :data, :options, :indent, :kw, :indent_str, :indent_step,
+                :hide_blank
+
+    # Display classes can provide a do_method_code() method, which
+    # handles <code> errors when running do_method()
+    #
+    def run_error(method)
+      return unless respond_to?(method)
+      send(method)
+      exit 1
+    end
+
+    def initialize(data, options = {})
+      @data = data
+      @options = options
+      @indent = 0
+      @indent_step = options[:indent_step] || 2
+      @hide_blank = options[:hide_blank] || true
+    end
+
+    def run(method)
+      if method == 'do_list'
+        if options[:long]
+          do_list
+        else
+          do_list_brief
+        end
+
+        return
+      end
+
+      if respond_to?("#{method}_brief")
+        send("#{method}_brief")
+      elsif respond_to?(method)
+        send(method)
+      else
+        long_output
+      end
+    end
+
+    def long_output(fields = nil, modified_data = nil)
+      _two_columns(modified_data || data, nil, fields)
+    end
+
+    # Extract two fields from a hash and print a list of them as
+    # pairs.
+    #
+    # @param col1 [String] the field to use in the first column
+    # @param col2 [String] the field to use in the second column
+    # @return [Nil]
+    #
+    def terse_output(col1 = :id, col2 = :name, modified_data = nil)
+      d = modified_data || data
+      want = d.each_with_object({}) { |r, a| a[r[col1]] = r[col2] }
+      @indent_str = ''
+      @kw = key_width(want)
+
+      want.each do |k, v|
+        v = v.join(', ') if v.is_a?(Array)
+        print_line(k, v)
+      end
+    end
+
+    # Print multiple column output. Currently this method does no
+    # word wrapping.
+    #
+    # @param keys [Symbol] the keys you want in the output. They
+    #   will be printed in the order given.
+    #
+    def multicolumn(*keys)
+      len = Hash[*keys.map {|k| [k, 0]}.flatten]
+
+      keys.each do |k|
+        data.each do |obj|
+          val = obj[k]
+          val = val.join(', ') if val.is_a?(Array)
+          len[k] = val.size if val.size > len[k]
+        end
+      end
+
+      fmt = keys.each_with_object('') { |k, out| out.<< "%-#{len[k]}s  " }
+
+      data.each do |obj|
+        args = keys.map do |k|
+          obj[k].is_a?(Array) ? obj[k].join(', ') : obj[k]
+        end
+
+        puts format(fmt, *args)
+      end
+    end
+
+    def set_indent(indent)
+      @indent_str = ' ' * indent
+    end
+
+    # A recursive function which displays a key-value hash in two
+    # columns. The key column width is automatically calculated.
+    # Multiple-value 'v's are printed one per line. Hashes are nested.
+    #
+    # @param data [Array] and array of objects to display. Each object
+    #   should be a hash.
+    # @param indent [Integer] how many characters to indent the current
+    #   data.
+    # @kw [Integer] the width of the first (key) column.
+    # @returns [Nil]
+    #
+    def _two_columns(data, kw = nil, fields = nil)
+      [data].flatten.each do |row|
+        row.keep_if { |k, _v| fields.include?(k) } unless fields.nil?
+        kw = key_width(row) unless kw
+        @kw = kw unless @kw
+        set_indent(indent)
+
+        row.each do |k, v|
+          next if v.respond_to?(:empty?) && v.empty? && hide_blank
+
+          if v.is_a?(String) && v.match(/<.*>/)
+            v = v.gsub(%r{<\/?[^>]*>}, '').delete("\n")
+          end
+
+          if v.is_a?(Hash)
+            print_line(k)
+            @indent += indent_step
+            @kw -= 2
+            _two_columns([v], kw - indent_step)
+          elsif v.is_a?(Array)
+            print_array(k, v)
+          else
+            print_line(k, v)
+          end
+        end
+        puts if indent.zero?
+      end
+
+      @indent -= indent_step if indent > 0
+      @kw += 2
+      set_indent(indent)
+    end
+
+    def print_array(k, v)
+      v.each_with_index do |w, i|
+        if w.is_a?(Hash)
+          print_line(k) if i.zero?
+          @indent += indent_step
+          @kw -= 2
+          _two_columns([w], kw - indent_step)
+          print_line('', '---') unless i == v.size - 1
+        else
+          if i.zero?
+            print_line(k, v.shift)
+          else
+            print_line('', w)
+          end
+        end
+      end
+    end
+
+    # Print a single line of output
+    # @param key [String] what to print in the first (key) column
+    # @param val [String, Numeric] what to print in the second column
+    # @param indent [Integer] number of leading spaces on line
+    #
+    def print_line(key, value = '')
+      if key.empty?
+        puts ' ' * kw + value
+      else
+        puts indent_str + format("%-#{kw}s%s", key, value).fold(TW, kw)
+      end
+    end
+
+    # Give it a key-value hash, and it will return the size of the first
+    # column to use when formatting that data.
+    #
+    # @param hash [Hash] the data for which you need a column width
+    # @param pad [Integer] the number of spaces you want between columns
+    # @return [Integer] length of longest key + pad
+    #
+    def key_width(hash, pad = 2)
+      return 0 if hash.keys.empty?
+      hash.keys.map(&:size).max + pad
+    end
+
+    def indent_wrap(line, cols = 78, offset = 22)
+      #
+      # hanging indent long lines to fit in an 80-column terminal
+      #
+      return unless line
+      line.gsub(/(.{1,#{cols - offset}})(\s+|\Z)/, "\\1\n#{' ' *
+              offset}").rstrip
+    end
+
+    def friendly_name
+      self.class.name.split('::').last.gsub(/([a-z])([A-Z])/, '\\1 \\2')
+          .downcase
+    end
+
+    def do_list
+      long_output
+    end
+
+    def do_list_brief
+      terse_output
+    end
+
+    def do_import
+      puts "Imported #{friendly_name}."
+      long_output
+    end
+
+    def do_delete
+      puts "Deleted #{friendly_name} '#{options[:'<id>']}'."
+    end
+
+    def do_undelete
+      puts "Undeleted #{friendly_name} '#{options[:'<id>']}'."
+    end
+
+    def do_tag_add
+      puts "Tagged #{friendly_name} '#{options[:'<id>']}'."
+    end
+
+    def do_tag_delete
+      puts "Deleted tag from #{friendly_name} '#{options[:'<id>']}'."
+    end
+
+    def do_tag_clear
+      puts "Cleared tags on #{friendly_name} '#{options[:'<id>']}'."
+    end
+
+    def do_tag_set
+      puts "Set tags on #{friendly_name} '#{options[:'<id>']}'."
+    end
+
+    def do_tags
+      if data.empty?
+        puts "No tags set on #{friendly_name} '#{options[:'<id>']}'."
+      else
+        data.sort.each { |t| puts t }
+      end
+    end
+
+    # Modify, in-place, the data structure to remove fields which
+    # we deem not of interest to the user.
+    #
+    # @param keys [Symbol] keys you do not wish to be shown.
+    #
+    def drop_fields(*keys)
+      data.delete_if { |k, _v| keys.include?(k.to_sym) }
+    end
+
+    # Modify, in-place, the data structure to make times
+    # human-readable. Automatically handles second and millisecond
+    # epoch times.
+    #
+    def readable_time(*keys)
+      keys.each do |k|
+        next unless data.key?(k)
+        data[k] = human_time(data[k])
+      end
+    end
+
+    def human_time(t)
+      str = t.to_s
+
+      if str.length == 13
+        fmt = '%Q'
+        out_fmt = HUMAN_TIME_FORMAT_MS
+      else
+        fmt = '%s'
+        out_fmt = HUMAN_TIME_FORMAT
+      end
+
+      DateTime.strptime(str, fmt).strftime(out_fmt)
+    end
+
+  end
+end
+
+# Extensions to the String class to help with formatting.
+#
+class String
+
+  # Fold long command lines and suitably indent
+  #
+  def fold(width = TW, indent = 10)
+    scan(/\S.{0,#{width - 2}}\S(?=\s|$)|\S+/).join("\n" + ' ' * indent)
+  end
+end