wavefront-cli 8.3.0 → 8.5.1

data/lib/wavefront-cli/event_store.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'etc'
+require 'fileutils'
+require 'open3'
+require 'json'
+require_relative 'constants'
+require_relative 'exception'
+
+module WavefrontCli
+  #
+  # Encapsulation of everything needed to manage the locally stored state of
+  # events opened by the CLI. This is our own addition, entirely separate from
+  # Wavefront's API.
+  #
+  # When the user creates an open-ended event (i.e. one that does not have and
+  # end time, and is not instantaneous) a state file is created in a local
+  # directory. (*)
+  #
+  # That directory is defined by the EVENT_STATE_DIR constant, but may be
+  # overriden with an option in the constructor. The tests do this.
+  #
+  # (*) The user may specifically request that no state file be created with
+  # the --nostate flag.
+  #
+  class EventStore
+    include WavefrontCli::Constants
+
+    attr_reader :dir, :options
+
+    # @param state_dir [Pathname] override the default dir for testing
+    #
+    def initialize(options, state_dir = nil)
+      @options = options
+      @dir = event_state_dir(state_dir) + (Etc.getlogin || 'notty')
+      create_dir(dir)
+    end
+
+    def state_file_needed?
+      !(options[:nostate] || options[:end] || options[:instant])
+    end
+
+    def event_file(id)
+      /^\d{13}:.+/.match?(id) ? dir + id : nil
+    end
+
+    # We can override the temp directory with the WF_EVENT_STATE_DIR env var.
+    # This is primarily for testing, though someone may find a valid use for
+    # it.
+    #
+    def event_state_dir(state_dir = nil)
+      if ENV['WF_EVENT_STATE_DIR']
+        Pathname.new(ENV['WF_EVENT_STATE_DIR'])
+      elsif state_dir.nil?
+        EVENT_STATE_DIR
+      else
+        Pathname.new(state_dir)
+      end
+    end
+
+    # @param id [String,Nil] if this is falsey, returns the event on the top
+    #   of the state stack, removing its state file. If it's an exact event
+    #   ID, simply pass that ID back, NOT removing the state file. This is
+    #   okay: the state file is cleaned up by WavefrontCli::Event when an
+    #   event is closed.  If it's a name but not an ID, return the ID of the
+    #   most recent event with the given name.
+    # @return [String] the name of the most recent suitable event from the
+    #   local stack directory.
+    #
+    def event(id)
+      if !id
+        pop_event!
+      elsif /^\d{13}:.+:\d+/.match?(id)
+        id
+      else
+        pop_event!(id)
+      end
+    end
+
+    # List events on the local stack
+    #
+    def list
+      events = 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.')
+    end
+
+    # 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
+    #
+    def run_wrapped_cmd(cmd)
+      separator = '-' * (TW - 4)
+
+      puts "Command output follows, on STDERR:\n#{separator}"
+      ret = nil
+
+      Open3.popen2e(cmd) do |_in, out, thr|
+        # rubocop:disable Lint/AssignmentInCondition
+        while l = out.gets do warn l end
+        # rubocop:enable Lint/AssignmentInCondition
+        ret = thr.value.exitstatus
+      end
+
+      puts separator
+      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.
+    # @return [Nil]
+    #
+    def create!(id)
+      return unless state_file_needed?
+
+      fname = dir + id
+      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
+
+    # 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?
+    rescue StandardError
+      raise(WavefrontCli::Exception::SystemError,
+            "Cannot create writable system directory at '#{state_dir}'.")
+    end
+
+    # Get the last event this script created. If you supply a name, you get
+    # the last event with that name. If not, you get the last event. Note the
+    # '!': this method (potentially) has side effects.
+    # @param name [String] name of event. This is the middle part of the real
+    #   event name: the only part supplied by the user.
+    # @return [Array[timestamp, event_name]]
+    #
+    def pop_event!(name = nil)
+      return false unless dir.exist?
+
+      list = local_events_with_name(name)
+      return false if list.empty?
+
+      ev_file = list.max
+      File.unlink(ev_file)
+      ev_file.basename.to_s
+    end
+
+    # Event names are of the form `1609860826095:name:0`
+    # @param name [String] the user-specified (middle) portion of an event ID
+    # @return [Array[String]] list of matching events
+    #
+    def local_events_with_name(name = nil)
+      return list unless name
+
+      list.select { |f| f.basename.to_s.split(':')[1] == name }
+    end
+  end
+end

data/lib/wavefront-cli/exception.rb

@@ -7,26 +7,47 @@ module WavefrontCli
   #
   class Exception
     class CredentialError < RuntimeError; end
+
     class MandatoryValue < RuntimeError; end
+
     class ConfigFileNotFound < IOError; end
+
     class FileNotFound < IOError; end
+
     class ImpossibleSearch < RuntimeError; end
+
     class InsufficientData < RuntimeError; end
+
     class InvalidInput < RuntimeError; end
+
     class InvalidQuery < RuntimeError; end
+
     class InvalidValue < RuntimeError; end
+
     class ProfileExists < RuntimeError; end
+
     class ProfileNotFound < RuntimeError; end
+
     class SystemError < RuntimeError; end
+
     class UnhandledCommand < RuntimeError; end
+
     class UnparseableInput < RuntimeError; end
+
     class UnparseableResponse < RuntimeError; end
+
     class UnparseableSearchPattern < RuntimeError; end
+
     class UnsupportedFileFormat < RuntimeError; end
+
     class UnsupportedNoop < RuntimeError; end
+
     class UnsupportedOperation < RuntimeError; end
+
     class UnsupportedOutput < RuntimeError; end
+
     class UserGroupNotFound < RuntimeError; end
+
     class UserError < RuntimeError; end
   end
 end

data/lib/wavefront-cli/exception_handler.rb

@@ -8,6 +8,7 @@ module WavefrontCli
     # rubocop:disable Metrics/MethodLength
     # rubocop:disable Metrics/AbcSize
     # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/PerceivedComplexity
     def exception_handler(exception)
       case exception
       when WavefrontCli::Exception::UnhandledCommand
@@ -26,6 +27,8 @@ module WavefrontCli
         abort 'Connection timed out.'
       when Wavefront::Exception::InvalidPermission
         abort "'#{exception}' is not a valid Wavefront permission."
+      when Wavefront::Exception::InvalidTimestamp
+        abort "'#{exception}' is not a parseable time."
       when Wavefront::Exception::InvalidUserGroupId
         abort "'#{exception}' is not a valid user group ID."
       when Wavefront::Exception::InvalidAccountId
@@ -80,6 +83,7 @@ module WavefrontCli
         abort
       end
     end
+    # rubocop:enable Metrics/PerceivedComplexity
     # rubocop:enable Metrics/MethodLength
     # rubocop:enable Metrics/AbcSize
     # rubocop:enable Metrics/CyclomaticComplexity

data/lib/wavefront-cli/opt_handler.rb

@@ -29,7 +29,7 @@ module WavefrontCli
 
     def initialize(cli_opts = {})
       cred_opts = setup_cred_opts(cli_opts)
-      cli_opts.reject! { |_k, v| v.nil? }
+      cli_opts.compact!
       @opts = DEFAULT_OPTS.merge(load_profile(cred_opts)).merge(cli_opts)
     rescue WavefrontCli::Exception::ConfigFileNotFound => e
       abort "Configuration file '#{e}' not found."

data/lib/wavefront-cli/query.rb

@@ -126,7 +126,7 @@ module WavefrontCli
       end
     end
 
-    def handle_errcode_404(_status)
+    def handle_errcode404(_status)
       'Perhaps metric does not exist for given host.'
     end
   end

data/lib/wavefront-cli/serviceaccount.rb

@@ -23,7 +23,8 @@ module WavefrontCli
     end
 
     alias do_groups do_describe
-    alias do_permissions do_describe
+    alias do_ingestionpolicy do_describe
+    alias do_roles do_describe
 
     def do_create
       wf_user_id?(options[:'<id>'])
@@ -95,7 +96,7 @@ module WavefrontCli
     def extra_validation
       validate_groups
       validate_tokens
-      validate_perms
+      validate_ingestion_policy
     end
 
     def validator_exception
@@ -157,15 +158,18 @@ module WavefrontCli
       !options[:inactive]
     end
 
+    # rubocop:disable Metrics/AbcSize
     def user_body
       { identifier: options[:'<id>'],
         active: active_account?,
-        groups: options[:permission],
+        ingestionPolicyId: options[:policy],
         tokens: options[:usertoken],
-        userGroups: options[:group] }.tap do |b|
+        roles: options[:role],
+        userGroups: options[:group] }.compact.tap do |b|
           b[:description] = options[:desc] if options[:desc]
         end
     end
+    # rubocop:enable Metrics/AbcSize
 
     def item_dump_call
       wf.list.response
@@ -175,12 +179,18 @@ module WavefrontCli
       options[:group].each { |g| wf_usergroup_id?(g) }
     end
 
+    def validate_roles
+      options[:role].each { |r| wf_role_id?(r) }
+    end
+
     def validate_tokens
       options[:usertoken].each { |t| wf_apitoken_id?(t) }
     end
 
-    def validate_perms
-      options[:permission].each { |p| wf_permission?(p) }
+    def validate_ingestion_policy
+      return true unless options[:policy]
+
+      wf_ingestionpolicy_id?(options[:policy])
     end
 
     def descriptive_name

data/lib/wavefront-cli/settings.rb

@@ -7,6 +7,8 @@ module WavefrontCli
   # CLI coverage for the v2 'settings' API.
   #
   class Settings < WavefrontCli::Base
+    JOBS = %w[invitePermissions defaultUserGroups].freeze
+
     def do_list_permissions
       wf.permissions
     end
@@ -24,10 +26,7 @@ module WavefrontCli
         k, v = o.split('=', 2)
         next unless v && !v.empty?
 
-        if %w[invitePermissions defaultUserGroups].include?(k)
-          v = v.include?(',') ? v.split(',') : [v]
-        end
-
+        v = v.include?(',') ? v.split(',') : [v] if JOBS.include?(k)
         a[k] = v
       end
 

data/lib/wavefront-cli/stdlib/string.rb

@@ -50,7 +50,7 @@ class String
   # undesirable line breaking. This puts it back
   #
   def restored
-    tr('^', ' ').chomp("\n")
+    tr('^', ' ').chomp
   end
 
   # Fold long value lines in two-column output. The returned string

data/lib/wavefront-cli/version.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-WF_CLI_VERSION = '8.3.0'
+WF_CLI_VERSION = '8.5.1'

data/lib/wavefront-cli/write.rb

@@ -375,7 +375,7 @@ module WavefrontCli
     end
 
     def format_string_is_all_valid_chars?(fmt)
-      return true if fmt =~ /^[dmstTv]+$/
+      return true if /^[dmstTv]+$/.match?(fmt)
 
       raise(WavefrontCli::Exception::UnparseableInput,
             'unsupported field in format string')

data/spec/.rubocop.yml

@@ -1,23 +1,8 @@
 ---
-AllCops:
-  NewCops: enable
+inherit_from:
+  - ../.rubocop.yml
 
 Metrics/MethodLength:
   Max: 30
-
 Metrics/AbcSize:
   Max: 45
-
-Metrics/ClassLength:
-  Max: 300
-
-# Is nothing sacred?
-Layout/LineLength:
-  Max: 80
-
-Style/IfUnlessModifier:
-  Enabled: false # because it wants to make lines >80 chars
-Style/StringConcatenation:
-  Enabled: false
-Style/OptionalBooleanParameter:
-  Enabled: false

data/spec/spec_helper.rb

@@ -22,7 +22,6 @@ unless defined?(CMD)
     'Content-Type': 'application/json', Accept: 'application/json'
   }.freeze
   BAD_TAG = '*BAD_TAG*'
-  TW = 80
   HOME_CONFIG = Pathname.new(ENV['HOME']) + '.wavefront'
 end
 

data/spec/support/minitest_assertions.rb

@@ -214,9 +214,9 @@ module Minitest
     private
 
     def mk_headers(token = nil)
-      { 'Accept': /.*/,
+      { Accept: /.*/,
         'Accept-Encoding': /.*/,
-        'Authorization': 'Bearer ' + (token || '0123456789-ABCDEF'),
+        Authorization: 'Bearer ' + (token || '0123456789-ABCDEF'),
         'User-Agent': "wavefront-cli-#{WF_CLI_VERSION}" }
     end
 

data/spec/wavefront-cli/commands/base_spec.rb

@@ -72,7 +72,7 @@ class WavefrontCommmandBaseTest < MiniTest::Test
       next if skip_cmd && c.match(skip_cmd)
 
       assert_match(/^  \w+/, c)
-      assert_includes(c, CMN) unless c =~ /--help$/
+      assert_includes(c, CMN) unless /--help$/.match?(c)
     end
   end
 
@@ -88,7 +88,7 @@ class WavefrontCommmandBaseTest < MiniTest::Test
       refute o.end_with?('.')
     end
 
-    assert_equal(1, wf.options.split("\n").select(&:empty?).size)
+    assert_equal(1, wf.options.split("\n").count(&:empty?))
   end
 
   def test_opt_row

data/spec/wavefront-cli/commands/config_spec.rb

@@ -28,7 +28,7 @@ class WavefrontCommmandConfigTest < WavefrontCommmandBaseTest
       refute o.end_with?('.')
     end
 
-    assert_equal(wf.options.split("\n").select(&:empty?).size, 0)
+    assert_equal(wf.options.split("\n").count(&:empty?), 0)
   end
 
   def test_commands