wavefront-cli 4.2.1 → 4.3.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 module WavefrontDisplay

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require_relative 'printer/sparkline'
 
@@ -6,21 +8,26 @@ module WavefrontDisplay
   # Format human-readable output for queries.
   #
   class Query < Base
-    # rubocop:disable Metrics/AbcSize
     def do_default
-      d_obj = { name:       data.name,
-                query:      data.query,
-                timeseries: mk_timeseries(data),
-                events:     mk_events(data) }
+      @data = default_data_object
+      long_output
+    rescue StandardError
+      raise(WavefrontCli::Exception::InvalidQuery,
+            data[:errorMessage].split("\n").first)
+    end
 
-      if data.key?(:warnings) && !options[:nowarn]
-        d_obj[:warnings] = data[:warnings]
-      end
+    def default_data_object
+      { name: data.name,
+        query: data.query,
+        timeseries: mk_timeseries(data),
+        events: mk_events(data) }.tap do |d|
+          d[:warnings] = data[:warnings] if show_warnings?
+        end
+    end
 
-      @data = d_obj
-      long_output
+    def show_warnings?
+      data.key?(:warnings) && !options[:nowarn]
     end
-    # rubocop:enable Metrics/AbcSize
 
     # Prioritizing keys does not make sense in this context
     #
@@ -43,6 +50,7 @@ module WavefrontDisplay
 
     def mk_events(data)
       return [] unless data.key?(:events)
+
       data[:events].map { |s| humanize_event(s) }
     end
 
@@ -75,25 +83,28 @@ module WavefrontDisplay
       data
     end
 
-    # rubocop:disable Metrics/MethodLength
+    # Prepare a padded line with the timestamp and value. If it's the
+    # @return [String]
+    #
     def humanize_series(data)
       last_date = nil
 
-      data.map! do |row|
-        if row.is_a?(Hash)
-          ht = human_time(row[:timestamp])
-          val = row[:value]
-        else
-          ht = human_time(row[0])
-          val = row[1]
-        end
-
+      data.map do |row|
+        ht, val = row_time_and_val(row)
         date, time = ht.split
-        ds = date == last_date ? '' : date
+        date_string = date == last_date ? '' : date
         last_date = date
-        format('%-12s %s    %s', ds, time, val)
+        format('%-12<series>s %<time>s    %<value>s',
+               series: date_string, time: time, value: val)
+      end
+    end
+
+    def row_time_and_val(row)
+      if row.is_a?(Hash)
+        [human_time(row[:timestamp]), row[:value]]
+      else
+        [human_time(row[0]), row[1]]
       end
-      # rubocop:enable Metrics/MethodLength
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 module WavefrontDisplay

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module WavefrontDisplay
+  #
+  # Format human-readable output for service account commands.
+  #
+  class ServiceAccount < Base
+    def do_describe
+      long_output
+    end
+
+    def do_list_brief
+      multicolumn(:identifier, :description)
+    end
+
+    def do_activate
+      puts format("Activated service account '#{options[:'<id>']}'.")
+    end
+
+    def do_deactivate
+      puts format("Deactivated service account '#{options[:'<id>']}'.")
+    end
+
+    def do_groups
+      if data[:userGroups].empty?
+        puts 'Account does not belong to any groups.'
+      else
+        data[:userGroups].each { |u| puts format('%<id>s (%<name>s)', u) }
+      end
+    end
+
+    alias do_join do_groups
+    alias do_leave do_groups
+
+    def do_privileges
+      if data[:groups].empty?
+        puts 'Account does not have any Wavefront privileges.'
+      else
+        puts data[:groups]
+      end
+    end
+
+    alias do_grant do_privileges
+    alias do_revoke do_privileges
+
+    def do_apitoken_list
+      if data.empty?
+        puts 'Account does not have any tokens.'
+      else
+        multicolumn(:tokenID, :tokenName)
+      end
+    end
+
+    def search_identifier_key
+      :identifier
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 module WavefrontDisplay

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 module WavefrontDisplay
@@ -12,19 +14,31 @@ module WavefrontDisplay
 
     def do_list_brief
       massage_data
+      terse_data
       multicolumn(:id, :description)
     end
 
+    def do_search_brief
+      return multicolumn(:id) unless data.empty?
+
+      puts 'No matches.'
+    end
+
+    private
+
+    def terse_data
+      @data.map! do |e|
+        { id: e[:id], description: e[:description] || '<no description>' }
+      end
+    end
+
     def massage_data
       return if options[:all]
+
       drop_cluster_sources
       drop_hidden_sources
     end
 
-    def do_search_brief
-      multicolumn(:id)
-    end
-
     # Filter out any sources with 'hidden=true'
     #
     def drop_hidden_sources

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 module WavefrontDisplay
@@ -10,33 +12,77 @@ module WavefrontDisplay
     end
 
     def do_groups
-      if data.userGroups.empty?
+      groups = data.first.userGroups
+
+      if groups.empty?
         puts 'User does not belong to any groups.'
       else
-        data.userGroups.each { |u| puts format('%s (%s)', u[:id], u[:name]) }
+        groups.each { |u| puts format('%<id>s (%<name>s)', u) }
       end
     end
 
+    def do_privileges
+      puts(if data.first[:groups].empty?
+             'User does not have any Wavefront privileges.'
+           else
+             data.first[:groups]
+           end)
+    end
+
     def do_create
-      puts format("Created user '%s'.\nPermission groups\n%s\n" \
-                  "User groups\n%s",
-                  data.response[:identifier],
-                  groups_as_string(data.response.groups),
-                  user_groups_as_string(data.response.userGroups))
+      info = data[0]
+      puts format("Created user '%<user>s'.\nPermission groups\n" \
+                  "%<perm_groups>s\nUser groups\n%<user_groups>s",
+                  user: info[:identifier],
+                  perm_groups: groups_as_string(info[:groups]),
+                  user_groups: user_groups_as_string(info[:userGroups]))
     end
 
     def groups_as_string(groups)
       return '  <none>' if groups.empty?
-      data.response.groups.map { |g| format('  %s', g) }.join("\n  ")
+
+      data.response.groups.map do |g|
+        format('  %<group>s', group: g)
+      end.join("\n  ")
     end
 
     def user_groups_as_string(groups)
       return '  <none>' if groups.empty?
-      groups.map { |g| format('  %s (%s)', g[:name], g[:id]) }.join("\n")
+
+      groups.map { |g| format('  %<name>s (%<id>s)', g) }.join("\n")
     end
 
     def do_delete
-      puts format('Deleted %s', options[:'<user>'].join(', '))
+      puts format('Deleted %<quoted_user>s.',
+                  quoted_user: quoted(options[:'<user>']))
+    end
+
+    def do_invite
+      puts format("Sent invitation to '%<id>s'.", id: options[:'<id>'])
+    end
+
+    def do_grant
+      puts format("Granted '%<priv>s' to '%<id>s'.",
+                  priv: options[:'<privilege>'],
+                  id: options[:'<id>'])
+    end
+
+    def do_revoke
+      puts format("Revoked '%<priv>s' from '%<id>s'.",
+                  priv: options[:'<privilege>'],
+                  id: options[:'<id>'])
+    end
+
+    def do_join
+      puts format("Added '%<id>s' to %<quoted_group>s.",
+                  id: options[:'<id>'],
+                  quoted_group: quoted(options[:'<group>']))
+    end
+
+    def do_leave
+      puts format("Removed '%<id>s' from %<quoted_group>s.",
+                  id: options[:'<id>'],
+                  quoted_group: quoted(options[:'<group>']))
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 module WavefrontDisplay
@@ -10,43 +12,47 @@ module WavefrontDisplay
     end
 
     def do_delete
-      puts "Deleted user group '#{options[:'<id>']}."
+      puts "Deleted user group '#{options[:'<id>']}'."
     end
 
     def do_add_user
-      puts format('Added %s to %s.', options[:'<user>'].join(', '),
-                  options[:'<id>']).fold(TW, 0)
+      puts format("Added %<quoted_user>s to '%<group_id>s'.",
+                  quoted_user: quoted(options[:'<user>']),
+                  group_id: options[:'<id>']).fold(TW, 0)
     end
 
     def do_remove_user
-      puts format("Removed '%s' from %s.", options[:'<user>'].join(', '),
-                  options[:'<id>']).fold(TW, 0)
+      puts format("Removed %<quoted_user>s from '%<group_id>s'.",
+                  quoted_user: quoted(options[:'<user>']),
+                  group_id: options[:'<id>']).fold(TW, 0)
     end
 
     def do_grant
-      puts format("Granted '%s' permission to %s.",
-                  options[:'<permission>'], options[:'<id>'])
+      puts format("Granted '%<perm>s' permission to '%<group_id>s'.",
+                  perm: options[:'<permission>'],
+                  group_id: options[:'<id>'])
     end
 
     def do_revoke
-      puts format("Revoked '%s' permission from %s.",
-                  options[:'<permission>'], options[:'<id>'])
+      puts format("Revoked '%<perm>s' permission from '%<group_id>s'.",
+                  perm: options[:'<permission>'],
+                  group_id: options[:'<id>'])
     end
 
     def do_users
-      if data.users.empty?
-        puts 'No users in group.'
-      else
-        data.users.each { |u| puts u }
-      end
+      puts(if !data.include?(:users) || data[:users].empty?
+             "No users in group '#{options[:'<id>']}'."
+           else
+             data[:users]
+           end)
     end
 
     def do_permissions
-      if data.permissions.empty?
-        puts 'Group has no permissions.'
-      else
-        data.permissions.each { |u| puts u }
-      end
+      puts(if !data.include?(:permissions) || data[:permissions].empty?
+             "Group '#{options[:'<id>']}' has no permissions."
+           else
+             data[:permissions]
+           end)
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 module WavefrontDisplay

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 module WavefrontDisplay
@@ -23,8 +25,10 @@ module WavefrontDisplay
     end
 
     def report
-      %w[sent rejected unsent].each do |k|
-        puts format('  %12s %d', k.to_s, data[k])
+      %w[sent rejected unsent].each do |status|
+        puts format('  %12<status>s %<count>d',
+                    status: status,
+                    count: data[status])
       end
     end
   end

data/lib/wavefront-cli/event.rb

@@ -1,71 +1,54 @@
+# frozen_string_literal: true
+
 require 'fileutils'
 require 'open3'
 require 'wavefront-sdk/support/mixins'
 require_relative 'base'
 require_relative 'command_mixins/tag'
 
-EVENT_STATE_DIR = Pathname.new('/var/tmp/wavefront')
-
 module WavefrontCli
   #
   # CLI coverage for the v2 'event' API.
   #
   class Event < Base
     attr_reader :state_dir
+
     include Wavefront::Mixins
     include WavefrontCli::Mixin::Tag
 
     def post_initialize(_options)
-      @state_dir = EVENT_STATE_DIR + (Etc.getlogin || 'notty')
-      create_state_dir
+      @state_dir = event_state_dir + (Etc.getlogin || 'notty')
+      create_dir(state_dir)
     end
 
     def do_list
-      wf.list(options[:start]  || Time.now - 600,
-              options[:end]    || Time.now,
-              options[:limit]  || 100,
-              options[:cursor] || nil)
-    end
-
-    def do_set
-      k, v = options[:'<key=value>'].split('=')
-      wf.update(options[:'<id>'], k => v)
+      wf.list(*list_args)
     end
 
-    # You can override the options generated by docopt. This is how
-    # #wrap() works.
-    #
-    # rubocop:disable Metrics/AbcSize
     def do_create(opts = nil)
       opts ||= options
-
       opts[:start] = Time.now unless opts[:start]
-
       t_start = parse_time(opts[:start], true)
-
       body = create_body(opts, t_start)
-
       resp = wf.create(body)
-
-      unless opts[:nostate] || opts[:end] || opts[:instant]
-        create_state_file(resp.response[:id], opts[:host])
-      end
-
+      create_state_file(resp.response[:id]) if state_file_needed?(opts)
       resp
     end
-    # rubocop:enable Metrics/AbcSize
+
+    def state_file_needed?(opts)
+      !(opts[:nostate] || opts[:end] || opts[:instant])
+    end
 
     # The user doesn't have to give us an event ID.  If no event
     # name is given, we'll pop the last event off the stack. If an
     # event name is given and it doesn't look like a full WF event
     # 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.
+    # like a real event, we'll make an API call straight away.
     #
-    # rubocop:disable Metrics/AbcSize
     def do_close(id = nil)
       id ||= options[:'<id>']
-      ev_file = id =~ /^\d{13}:.+/ ? state_dir + id : nil
       ev = local_event(id)
+      ev_file = event_file(id)
 
       abort "No locally stored event matches '#{id}'." unless ev
 
@@ -73,7 +56,10 @@ module WavefrontCli
       ev_file.unlink if ev_file&.exist? && res.status.code == 200
       res
     end
-    # rubocop:enable Metrics/AbcSize
+
+    def event_file(id)
+      id =~ /^\d{13}:.+/ ? state_dir + id : nil
+    end
 
     def do_show
       events = local_event_list
@@ -93,41 +79,47 @@ module WavefrontCli
       event_id = do_create(create_opts).response.id
       exit_code = run_wrapped_cmd(options[:command])
       do_close(event_id)
-      puts "Command exited #{exit_code}"
+      puts "Command exited #{exit_code}."
       exit exit_code
     end
 
-    private
+    # We can override the temp directory with the WF_EVENT_STATE_DIR. This is
+    # primarily for testing.
+    #
+    def event_state_dir
+      if ENV['WF_EVENT_STATE_DIR']
+        Pathname.new(ENV['WF_EVENT_STATE_DIR'])
+      else
+        EVENT_STATE_DIR
+      end
+    end
 
     # return [Hash] body for #create() method
     #
-    # rubocop:disable Metrics/AbcSize
-    # rubocop:disable Metrics/CyclomaticComplexity
-    # rubocop:disable Metrics/PerceivedComplexity
     # rubocop:disable Metrics/MethodLength
     def create_body(opts, t_start)
-      body = { name:        opts[:'<event>'],
-               startTime:   t_start,
-               annotations: {} }
-
-      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]
-      body[:tags] = opts[:evtag] if opts[:evtag]
-
-      if opts[:instant]
-        body[:endTime] = t_start + 1
-      elsif opts[:end]
-        body[:endTime] = parse_time(opts[:end], true)
-      end
-
-      body
+      { name: opts[:'<event>'],
+        startTime: t_start,
+        annotations: annotations(opts) }.tap do |r|
+          r[:hosts] = opts[:host] if opts[:host]
+          r[:tags] = opts[:evtag] if opts[:evtag]
+
+          if opts[:instant]
+            r[:endTime] = t_start + 1
+          elsif opts[:end]
+            r[:endTime] = parse_time(opts[:end], true)
+          end
+        end
     end
     # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/PerceivedComplexity
-    # rubocop:enable Metrics/AbcSize
+
+    def annotations(opts)
+      {}.tap do |r|
+        r[:details] = opts[:desc] if opts[:desc]
+        r[:severity] = opts[:severity] if opts[:severity]
+        r[:type] = opts[:type] if opts[:type]
+      end
+    end
 
     # @return a local event from the stack directory
     #
@@ -142,7 +134,10 @@ module WavefrontCli
     end
 
     def local_event_list
-      state_dir.children
+      events = state_dir.children
+      abort 'No locally recorded events.' if events.empty?
+
+      events
     rescue Errno::ENOENT
       raise(WavefrontCli::Exception::SystemError,
             'There is no event state directory on this host.')
@@ -160,7 +155,7 @@ module WavefrontCli
 
       Open3.popen2e(cmd) do |_in, out, thr|
         # rubocop:disable Lint/AssignmentInCondition
-        while l = out.gets do STDERR.puts(l) end
+        while l = out.gets do warn l end
         # rubocop:enable Lint/AssignmentInCondition
         ret = thr.value.exitstatus
       end
@@ -173,15 +168,27 @@ module WavefrontCli
     # 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 = [])
+    def create_state_file(id)
       fname = state_dir + id
-      File.open(fname, 'w') { hosts.to_s }
+      File.open(fname, 'w') { |fh| fh.puts(event_file_data) }
       puts "Event state recorded at #{fname}."
     rescue StandardError
       puts 'NOTICE: event was created but state file was not.'
     end
 
-    def create_state_dir
+    # Record event data in the state file. We don't currently use it, but it
+    # might be useful to someone someday.
+    #
+    # @return [String]
+    #
+    def event_file_data
+      { hosts: options[:host],
+        description: options[:desc],
+        severity: options[:severity],
+        tags: options[:evtag] }.to_json
+    end
+
+    def create_dir(state_dir)
       FileUtils.mkdir_p(state_dir)
       raise unless state_dir.exist? && state_dir.directory? &&
                    state_dir.writable?
@@ -217,10 +224,24 @@ module WavefrontCli
 
     def local_events_with_name(name = nil)
       list = local_event_list
-
       return list unless name
 
       list.select { |f| f.basename.to_s.split(':').last == name }
     end
+
+    def list_args
+      [window_start,
+       window_end,
+       options[:limit] || 100,
+       options[:cursor] || nil]
+    end
+
+    def window_start
+      parse_time((options[:start] || Time.now - 600), true)
+    end
+
+    def window_end
+      parse_time((options[:end] || Time.now), true)
+    end
   end
 end