wavefront-cli 0.0.5 → 1.0.0

data/lib/wavefront-cli/display/printer/long.rb

@@ -0,0 +1,186 @@
+require_relative './base'
+require_relative '../../string'
+
+module WavefrontDisplayPrinter
+  #
+  # Print the long indented descriptions of things
+  #
+  class Long < Base
+    attr_reader :indent, :indent_str, :indent_step, :kw, :hide_blank
+
+    def initialize(data, fields = nil, modified_data = nil)
+      @out = []
+      @indent = 0
+      @indent_step = 2
+      @hide_blank = true
+      _two_columns(modified_data || data, nil, fields)
+    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 |item|
+        preen_fields(item, fields)
+        kw = key_width(item) unless kw
+        @kw = kw unless @kw
+        mk_indent(indent)
+        item.each { |k, v| parse_line(k, v) }
+        add_line(nil) if indent.zero?
+      end
+
+      @indent -= indent_step if indent > 0
+      @kw += 2
+      mk_indent(indent)
+    end
+
+    # Drop any fields not required.
+    #
+    # @param item [Hash, Map] the raw data
+    # @param fields [Array[Symbol]] the fields we wish to keep
+    # @return [Hash, Map]
+    #
+    def preen_fields(item, fields = nil)
+      return item unless fields
+      item.keep_if { |k, _v| fields.include?(k.to_sym) }
+    end
+
+    # Remove HTML and stuff
+    #
+    # @param [String] raw value
+    # @return [String] value with all HTML stripped out
+    #
+    def preen_value(value)
+      return value unless value.is_a?(String) && value =~ /<.*>/
+      value.gsub(%r{<\/?[^>]*>}, '').delete("\n")
+    end
+
+    # Return true if this line is blank and we don't want to print
+    # blank lines
+    #
+    # @param value [Object] thing to check
+    # @return [Boolean]
+    #
+    def blank?(value)
+      value.respond_to?(:empty?) && value.empty? && hide_blank
+    end
+
+    # Parse a line and add it to the output or pass it on to another
+    # method which knows how to add it to the output.
+    #
+    # @param key [String] a key
+    # @param value [Object] the value: could be anything
+    # @return [Nil]
+    #
+    def parse_line(key, value)
+      return if blank?(value)
+
+      value = preen_value(value)
+
+      if value.is_a?(Hash)
+        add_hash(key, value)
+      elsif value.is_a?(Array)
+        add_array(key, value)
+      else
+        add_line(key, value)
+      end
+    end
+
+    # Add a key-value pair to the output when value is an array. It
+    # will put the key and the first value element on the first
+    # line, with subsequent value elements aligned at the same
+    # offset, but with no key. If any value element is a hash, it is
+    # handled by a separate method. For instance:
+    #
+    # key    value1
+    #        value2
+    #        value3
+    #
+    # @param key [String] the key
+    # @param value_arr [Array] an array of values
+    # @return [Nil]
+    #
+    def add_array(key, value_arr)
+      value_arr.each_with_index do |element, index|
+        if element.is_a?(Hash)
+          add_hash(key, element, value_arr.size, index)
+        else
+          add_line(index.zero? ? key : nil, element)
+        end
+      end
+    end
+
+    # Add a hash to the output. It will put the key on a line on its
+    # own, followed by other keys indented. All values are aligned
+    # to the same point.  If this hash is a member of an array, we
+    # are able to print a horizontal rule at the end of it. We don't
+    # do this if it is the final member of the array.
+    #
+    # For instance:
+    #
+    #  key
+    #    subkey1    value1
+    #    subkey2    value2
+    #
+    # @param key [String] the key
+    # @param value [Hash] hash of values to display
+    # @param size [Integer] the size of the parent array, if there
+    #   is one
+    # @param index [Integer] the index of this element in parent
+    #   array, if there is one.
+    # @return [Nil]
+    #
+    def add_hash(key, value, arr_size = 0, arr_index = 0)
+      add_line(key) if arr_index.zero?
+      @indent += indent_step
+      @kw -= 2
+      _two_columns([value], kw - indent_step)
+      add_rule(kw) if arr_index + 1 < arr_size
+    end
+
+    # Add a horizontal rule, from the start of the second column to
+    # just shy of the end of the terminal
+    #
+    def add_rule(kw)
+      add_line(nil, '-' * (TW - kw - 4))
+    end
+
+    # Make the string which is prepended to each line.  Stepping is
+    # controlled by @indent_step.
+    #
+    # @param indent [Integer] how many characters to indent by.
+    #
+    def mk_indent(indent)
+      @indent_str = ' ' * indent
+    end
+
+    # Print a single line of output, handling the necessary
+    # indentation and tabulation.
+    #
+    # @param key [String] what to print in the first (key) column.
+    #   Make this an empty string to print
+    # @param val [String, Numeric] what to print in the second column
+    # @param tw [Integer] terminal width
+    #
+    def mk_line(key, value = '', tw = TW)
+      return indent_str + ' ' * kw + value if !key || key.empty?
+
+      indent_str + format("%-#{kw}s%s", key, value)
+                   .fold(tw, kw + indent_str.size, '').rstrip
+    end
+
+    # Add a line, prepped by #mk_line() to the out array.
+    #
+    def add_line(*args)
+      @out.<< mk_line(*args)
+    end
+  end
+end

data/lib/wavefront-cli/display/printer/terse.rb

@@ -0,0 +1,55 @@
+require_relative './base'
+
+module WavefrontDisplayPrinter
+
+  # Print things which are per-row. The terse listings, primarily
+  #
+  class Terse < Base
+    attr_reader :data, :keys, :fmt_string
+
+    def initialize(data, *keys)
+      # require 'json'
+      # File.open('/tmp/1', 'w') { |f| f.puts data.to_json }
+      @data = data
+      @keys = keys
+      @fmt_string = format_string.rstrip
+      @out = prep_output
+    end
+
+    # @return [String] a Ruby format string for each line
+    #
+    def format_string
+      lk = longest_keys
+      keys.each_with_object('') { |k, out| out.<< "%-#{lk[k]}s  " }
+    end
+
+    # Find the length of the longest value for each member of @keys,
+    # in @data.
+    #
+    # @return [Hash] with the same keys as :keys and Integer values
+    #
+    def longest_keys
+      keys.each_with_object(Hash[*keys.map { |k| [k, 0] }.flatten]) \
+      do |k, aggr|
+        data.each do |obj|
+          val = obj[k]
+          val = val.join(', ') if val.is_a?(Array)
+          aggr[k] = val.size if val.size > aggr[k]
+        end
+      end
+    end
+
+    # Print multiple column output. 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 prep_output
+      data.each_with_object([]) do |o, aggr|
+        args = keys.map { |k| o[k].is_a?(Array) ? o[k].join(', ') : o[k] }
+        aggr.<< format(fmt_string, *args).rstrip
+      end
+    end
+  end
+end

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

@@ -6,7 +6,6 @@ module WavefrontDisplay
   #
   class Query < Base
     def do_default
-
       ts = if data.key?(:timeseries)
              data[:timeseries].each do |s|
                s[:data] = humanize_series(s[:data])
@@ -62,7 +61,7 @@ module WavefrontDisplay
         date, time = ht.split
         ds = date == last_date ? '' : date
         last_date = date
-        format('%12s %s    %s', ds, time, val)
+        format('%-12s %s    %s', ds, time, val)
       end
     end
   end

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

@@ -11,7 +11,7 @@ module WavefrontDisplay
     end
 
     def do_list_brief
-      terse_output(:id, :entityType)
+      multicolumn(:id, :entityType)
     end
   end
 end

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

@@ -12,13 +12,17 @@ module WavefrontDisplay
 
     def do_list_brief
       drop_cluster_sources
-      terse_output(:id, :description)
+      multicolumn(:id, :description)
     end
 
-    # Filter out the Wavefront cluster sources
+    def do_search_brief
+      multicolumn(:id)
+    end
+
+    # Filter out the Wavefront cluster sources. Don't sort them, or
+    # using offset and cursor becomes confusing.
     #
     def drop_cluster_sources
-      data.sort_by! { |k, _v| k }
       return if options[:all]
       data.delete_if { |k| k.id =~ /prod-[\da-f]{2}-/ }
     end

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

@@ -6,13 +6,12 @@ module WavefrontDisplay
   #
   class Webhook < Base
     def do_list
-      long_output([:id, :description, :createdEpochMillis,
-                   :updatedEpochMillis, :updaterId, :creatorId,
-                   :title])
+      long_output([:id, :title, :description, :createdEpochMillis,
+                   :updatedEpochMillis, :updaterId, :creatorId])
     end
 
     def do_list_brief
-      terse_output(:id, :title)
+      multicolumn(:id, :title)
     end
 
     def do_describe

data/lib/wavefront-cli/event.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require 'wavefront-sdk/mixins'
 require_relative './base'
+require 'open3'
 
 EVENT_STATE_DIR = Pathname.new('/var/tmp/wavefront')
 
@@ -26,7 +27,7 @@ module WavefrontCli
       options[:start] = Time.now - 600 unless options[:start]
       options[:end] = Time.now unless options[:end]
       wf.list(options[:start], options[:end], options[:limit] || 100,
-              options[:offset] || nil)
+              options[:cursor] || nil)
     end
 
     def do_update
@@ -34,32 +35,37 @@ module WavefrontCli
       wf.update(options[:'<id>'], k => v)
     end
 
-    def do_create
-      options[:start] = Time.now unless options[:start]
+    # You can override the options generated by docopt. This is how
+    # #wrap() works.
+    #
+    def do_create(opts = nil)
+      opts ||= options
+
+      opts[:start] = Time.now unless opts[:start]
 
-      t_start = parse_time(options[:start], true)
-      id = [t_start, options[:'<event>']].join(':')
+      t_start = parse_time(opts[:start], true)
+      id = [t_start, opts[:'<event>']].join(':')
 
-      body = { name:        options[:'<event>'],
+      body = { name:        opts[:'<event>'],
                startTime:   t_start,
                id:          id,
                annotations: {} }
 
-      body[:annotations][:details] = options[:desc] if options[:desc]
-      body[:annotations][:severity] = options[:severity] if options[:severity]
-      body[:annotations][:type] = options[:type] if options[:type]
-      body[:hosts] = options[:host] if options[:host]
+      body[:annotations][:details] = opts[:desc] if opts[:desc]
+      body[:annotations][:severity] = opts[:severity] if opts[:severity]
+      body[:annotations][:type] = opts[:type] if opts[:type]
+      body[:hosts] = opts[:host] if opts[:host]
 
-      if options[:instant]
+      if opts[:instant]
         body[:endTime] = t_start + 1
-      elsif options[:end]
-        body[:endTime] = parse_time(options[:end], true)
+      elsif opts[:end]
+        body[:endTime] = parse_time(opts[:end], true)
       end
 
       resp = wf.create(body)
 
-      unless options[:nostate] || options[:end] || options[:instant]
-        create_state_file(id, options[:host])
+      unless opts[:nostate] || opts[:end] || opts[:instant]
+        create_state_file(id, opts[:host])
       end
 
       resp
@@ -71,19 +77,20 @@ module WavefrontCli
     # name, we'll look for something on the stack.  If it does look
     # like a real event, we'll make and API call straight away.
     #
-    def do_close
+    def do_close(id = nil)
+      id ||= options[:'<id>']
       ev_file = nil
 
-      ev = if options[:'<id>'] == false
+      ev = if !id
              pop_event
-           elsif options[:'<id>'] =~ /^\d{13}:.+/
-             ev_file = state_dir + options[:'<id>']
-             options[:'<id>']
+           elsif id =~ /^\d{13}:.+/
+             ev_file = state_dir + id
+             id
            else
-             pop_event(options[:'<id>'])
+             pop_event(id)
            end
 
-      abort "No locally stored event matches '#{options[:'<id>']}'." unless ev
+      abort "No locally stored event matches '#{id}'." unless ev
 
       res = wf.close(ev)
       ev_file.unlink if ev_file && ev_file.exist? && res.status.code == 200
@@ -106,14 +113,46 @@ module WavefrontCli
       exit
     end
 
+    def do_wrap
+      create_opts = options
+      create_opts[:desc] ||= create_opts[:command]
+      event_id = do_create(create_opts).response.id
+      exit_code = run_wrapped_cmd(options[:command])
+      do_close(event_id)
+      puts "Command exited #{exit_code}"
+      exit exit_code
+    end
+
     private
 
+    # Run a command, stream stderr and stdout to the screen (they
+    # get combined -- could be an issue for someone somewhere) and
+    # return the command's exit code
+    #
+    # rubocop:disable Lint/AssignmentInCondition
+    #
+    def run_wrapped_cmd(cmd)
+      puts 'Command output follows, on STDERR:'
+      puts '-' * (TW - 4)
+      ret = nil
+
+      Open3.popen2e(cmd) do |_in, out, thr|
+        while l = out.gets
+          STDERR.puts l
+        end
+
+        ret = thr.value.exitstatus
+      end
+
+      puts '-' * (TW - 4)
+      ret
+    end
+
     # Write a state file. We put the hosts bound to the event into the
     # file. These aren't currently used by anything in the CLI, but they
     # might be useful to someone, somewhere, someday.
     #
     def create_state_file(id, hosts = [])
-      puts "statfile fir #{id}"
       fname = state_dir + id
 
       begin

data/lib/wavefront-cli/exception.rb

@@ -1,5 +1,5 @@
 module WavefrontCli
   class Exception
-    class UnhandledCommand < ::Exception; end
+    class UnhandledCommand < RuntimeError; end
   end
 end

data/lib/wavefront-cli/opt_handler.rb

@@ -37,13 +37,13 @@ module WavefrontCli
       @opts = DEFAULT_OPTS.merge(load_profile).merge(@cli_opts)
     end
 
+    # Load in configuration options from the (optionally) given
+    # section of an ini-style configuration file. If the file's not
+    # there, we don't consider that an error. Returns a hash of
+    # options which matches what Docopt gives us.
+    #
+    # rubocop:disable Metrics/AbcSize
     def load_profile
-      #
-      # Load in configuration options from the (optionally) given
-      # section of an ini-style configuration file. If the file's
-      # not there, we don't consider that an error. Returns a hash
-      # of options which matches what Docopt gives us.
-      #
       unless conf_file.exist?
         puts "config file '#{conf_file}' not found. Taking options " \
              'from command-line.'

data/lib/wavefront-cli/query.rb

@@ -19,11 +19,11 @@ module WavefrontCli
         sorted:                 true
       }
 
-      if options[:start]
-        options[:start] = parse_time(options[:start], true)
-      else
-        options[:start] = (Time.now - 600).to_i
-      end
+      options[:start] = if options[:start]
+                          parse_time(options[:start], true)
+                        else
+                          (Time.now - 600).to_i
+                        end
 
       if options[:end]
         options[:end] = parse_time(options[:end], true)
@@ -42,7 +42,6 @@ module WavefrontCli
                options[:start], options[:end] || nil, opts)
     end
 
-
     # Work out a sensible granularity based on the time window
     #
     def default_granularity(window)

data/lib/wavefront-cli/source.rb

@@ -5,6 +5,10 @@ module WavefrontCli
   # CLI coverage for the v2 'source' API.
   #
   class Source < WavefrontCli::Base
+    def do_list
+      wf.list(options[:limit], options[:cursor])
+    end
+
     def do_clear
       wf.delete(options[:'<id>'])
     end
@@ -14,7 +18,7 @@ module WavefrontCli
     end
 
     def do_description_clear
-      wf.update(options[:'<id>'], { description: ''}, false)
+      wf.update(options[:'<id>'], { description: '' }, false)
     end
   end
 end

data/lib/wavefront-cli/string.rb

@@ -0,0 +1,59 @@
+# Extensions to the String class to help with formatting.
+#
+class String
+  # Fold long command lines. We can't break on a space after an
+  # option or it confuses docopt.
+  #
+  # @param tw [Integer] terminal width
+  # @param indent [Integer] size of hanging indent, in chars
+  #
+  def cmd_fold(tw = TW, indent = 10)
+    #gsub(/\s(?=\w+\])/, '^').scan_line(tw - 8).join("\n" + ' ' * indent)
+    gsub(/(-\w) /, "\\1^").scan_line(tw - 12).join("\n" + ' ' * indent)
+      .tr('^', ' ')
+  end
+
+  # Wrapper around #fold()
+  #
+  # @param tw [Integer] width of terminal, in chars
+  # @param indent [Integer] hanging indent of following lines
+  # @return [String] folded and indented string
+  #
+  def opt_fold(tw = TW, indent = 10)
+    fold(tw, indent, '  ')
+  end
+
+  # Fold long lines with a hanging indent. Originally a special case
+  # for option folding, now addded the prefix parameter to make it
+  # more general.
+  #
+  # rubocop:disable Metrics/AbcSize
+  #
+  # @param tw [Integer] terminal width
+  # @param indent [Integer] size of hanging indent, in chars
+  # @param prefix [String] prepended to every line
+  # @return [String] the folded line
+  #
+  def fold(tw = TW, indent = 10, prefix = '')
+    chunks = self.scan_line(tw - 8)
+
+    line_1 = prefix + chunks.shift + "\n"
+
+    return line_1 if chunks.empty?
+
+    rest = chunks.join(' ').scan_line(tw - indent - 5).map do |l|
+      prefix + ' ' * indent + l
+    end
+
+    line_1 + rest.join("\n") + "\n"
+  end
+
+  # @param width [Integer] length of longest string (width of
+  #   terminal less some margin)
+  # @return [Array] original string chunked into an array width
+  #   elements whose length < width
+  #
+  def scan_line(width)
+    scan(/\S.{0,#{width}}\S(?=\s|$)|\S+/)
+  end
+end

data/lib/wavefront-cli/version.rb

@@ -1 +1 @@
-WF_CLI_VERSION = '0.0.5'.freeze
+WF_CLI_VERSION = '1.0.0'.freeze

data/lib/wavefront-cli/write.rb

@@ -5,6 +5,7 @@ module WavefrontCli
   #
   # Send points to a proxy.
   #
+  # rubocop:disable Metrics/ClassLength
   class Write < Base
     attr_reader :fmt
     include Wavefront::Mixins
@@ -13,6 +14,8 @@ module WavefrontCli
       { proxy: options[:proxy], port: options[:port] || 2878 }
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def do_point
       p = { path:  options[:'<metric>'],
             value: options[:'<value>'].to_f,
@@ -152,7 +155,7 @@ module WavefrontCli
     # Merge them, making the -T win if there is a collision.
     #
     def line_tags(chunks)
-      file_tags =  fmt.last == 'T' ? extract_tags(chunks) : {}
+      file_tags = fmt.last == 'T' ? extract_tags(chunks) : {}
       opt_tags = tags_to_hash(options[:tag])
       file_tags.merge(opt_tags)
     end

data/spec/spec_helper.rb

@@ -50,7 +50,7 @@ def cmd_to_call(word, args, call, sdk_class = nil)
   headers = { 'Accept':          /.*/,
               'Accept-Encoding': /.*/,
               'Authorization':  'Bearer 0123456789-ABCDEF',
-              'User-Agent':     /wavefront-sdk .*/,
+              'User-Agent':     "wavefront-cli-#{WF_CLI_VERSION}"
             }
 
   sdk_class ||= Object.const_get("WavefrontCli::#{word.capitalize}")

data/spec/wavefront-cli/alert_spec.rb

@@ -18,19 +18,30 @@ describe "#{word} command" do
 
   it 'deletes with a check on inTrash' do
     stub_request(:get,
-                 'https://other.wavefront.com/api/v2/alert/1481553823153').
-        with(headers: {'Accept': '*/*',
-                       'Accept-Encoding': 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
+                 'https://other.wavefront.com/api/v2/alert/1481553823153')
+      .with(headers: { 'Accept': '*/*',
+                       'Accept-Encoding':
+                         'gzip;q=1.0,deflate;q=0.6,identity;q=0.3',
                        'Authorization': 'Bearer 0123456789-ABCDEF',
-                       'User-Agent': /wavefront.*/}).
-          to_return(:status => 200, :body => "", :headers => {})
+                       'User-Agent': /wavefront.*/ })
+      .to_return(status: 200, body: '', headers: {})
     cmd_to_call(word, "delete #{id}",
                 method: :delete, path: "/api/v2/#{word}/#{id}")
   end
+
   cmd_to_call(word, "undelete #{id}",
               method: :post, path: "/api/v2/#{word}/#{id}/undelete")
   cmd_to_call(word, "snooze #{id}",
               method: :post, path: "/api/v2/#{word}/#{id}/snooze")
+  cmd_to_call(word, "search id=#{id}",
+              { method: :post, path: "/api/v2/search/#{word}",
+                body:   { limit: 10,
+                          offset: 0,
+                          query: [{key: 'id',
+                                   value: id,
+                                   matchingMethod: 'EXACT'}],
+                          sort: {field: 'id', ascending: true}},
+                headers: JSON_POST_HEADERS })
   cmd_to_call(word, "snooze -T 800 #{id}",
               method: :post,
               path:   "/api/v2/#{word}/#{id}/snooze?seconds=800")