wavefront-cli 8.2.0 → 8.5.0

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)
+      id =~ /^\d{13}:.+/ ? 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 id =~ /^\d{13}:.+:\d+/
+        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/proxy.rb

@@ -32,6 +32,10 @@ module WavefrontCli
       version_info(raw).sort_by { |p| Gem::Version.new(p[:version]) }.reverse
     end
 
+    def do_shutdown
+      wf.shutdown(options[:'<id>'])
+    end
+
     def version_info(raw)
       raw.response.items.map do |i|
         { id: i.id, version: i.version, name: i.name }

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/version.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-WF_CLI_VERSION = '8.2.0'
+WF_CLI_VERSION = '8.5.0'

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/wavefront-cli/controller_spec.rb

@@ -22,6 +22,18 @@ class WavefrontCliHelpTest < MiniTest::Test
     assert_match(/^  \w+ --help$/, e.message)
   end
 
+  def test_commands_no_args
+    SupportedCommands.new.all.each do |cmd|
+      _test_command_no_args(cmd)
+    end
+  end
+
+  def _test_command_no_args(cmd)
+    capture_io { WavefrontCliController.new([cmd]) }
+  rescue SystemExit => e
+    assert e.message.end_with?("wf #{cmd} --help")
+  end
+
   def test_version
     capture_io { WavefrontCliController.new(%w[--version]) }
   rescue SystemExit => e

data/spec/wavefront-cli/event_spec.rb

@@ -3,6 +3,7 @@
 
 require 'tmpdir'
 require_relative '../support/command_base'
+require_relative '../test_mixins/tag'
 require_relative '../../lib/wavefront-cli/event'
 require 'wavefront-sdk/support/mixins'
 
@@ -15,12 +16,11 @@ class EventEndToEndTest < EndToEndTest
   attr_reader :test_state_dir
 
   include Wavefront::Mixins
-  include WavefrontCliTest::Describe
-  include WavefrontCliTest::Delete
-  # Ones above work, ones below don't
+  # include WavefrontCliTest::Describe
+  # include WavefrontCliTest::Delete
   # include WavefrontCliTest::Search
-  # include WavefrontCliTest::Set
-  # include WavefrontCliTest::Tags
+  # #include WavefrontCliTest::Set
+  # include WavefrontCliTest::Tag
 
   def before_setup
     @test_state_dir = Pathname.new(Dir.mktmpdir)
@@ -31,11 +31,6 @@ class EventEndToEndTest < EndToEndTest
     FileUtils.rm_r(test_state_dir)
   end
 
-  def cmd_instance
-    cmd_class.new(event_state_dir: TEST_EVENT_DIR)
-    puts cmd_class
-  end
-
   def test_list_no_options
     str = '/api/v2/event\?' \
           'earliestStartTimeEpochMillis=\d{13}+&' \
@@ -65,6 +60,22 @@ class EventEndToEndTest < EndToEndTest
     end
   end
 
+  def test_show_with_no_local_events
+    assert_exits_with('No locally recorded events.', 'show')
+  end
+
+  def test_show
+    setup_test_state_dir
+
+    out, err = capture_io do
+      assert_raises(SystemExit) { wf.new("event show -c #{CF}".split) }
+    end
+
+    assert_empty(err)
+    assert_equal("1568133440530:ev3:0\n1568133440520:ev2:0\n" \
+                 "1568133440515:ev1:1\n1568133440510:ev1:0\n", out)
+  end
+
   def test_create
     mock_id = "#{start_time}:#{event_name}:1"
     state_file = state_dir + mock_id
@@ -100,8 +111,8 @@ class EventEndToEndTest < EndToEndTest
     refute state_file.exist?
 
     out, err = capture_io do
-      assert_cmd_posts('create -d reason -H host1 -H host2 -g ' \
-                       "mytag #{event_name}",
+      assert_cmd_posts('create -d reason -H host1 -H host2 -g mytag ' \
+                       "#{event_name}",
                        '/api/v2/event',
                        { name: event_name,
                          startTime: a_ms_timestamp,
@@ -148,15 +159,6 @@ class EventEndToEndTest < EndToEndTest
     assert_match(/\ntags          tag1\n              tag2\n/, out)
   end
 
-  def test_close_named_event
-    quietly do
-      assert_cmd_posts('close 1568133440520:ev2:0',
-                       '/api/v2/event/1568133440520:ev2:0/close')
-    end
-
-    assert_abort_on_missing_creds("close #{id}")
-  end
-
   def test_close_with_no_local_events
     quietly { assert_cmd_posts("close #{id}", "/api/v2/event/#{id}/close") }
     assert_exits_with('No locally recorded events.', 'close')
@@ -212,26 +214,47 @@ class EventEndToEndTest < EndToEndTest
     end
   end
 
-  def test_show
-    setup_test_state_dir
+  def test_window_start
+    wfse = WavefrontCli::Event.new(start: wall_time[0], end: wall_time[1])
+    assert_kind_of(Numeric, wfse.window_start)
+    assert_equal(epoch_ms_time[0], wfse.window_start)
+  end
 
-    out, err = capture_io do
-      assert_raises(SystemExit) { wf.new("event show -c #{CF}".split) }
-    end
+  def test_window_end
+    wfse = WavefrontCli::Event.new(start: wall_time[0], end: wall_time[1])
+    assert_kind_of(Numeric, wfse.window_end)
+    assert_equal(epoch_ms_time[1], wfse.window_end)
+  end
 
-    assert_empty(err)
-    assert_equal("1568133440530:ev3:0\n1568133440520:ev2:0\n" \
-                 "1568133440515:ev1:1\n1568133440510:ev1:0\n", out)
+  def test_list_args_defaults
+    wfe = WavefrontCli::Event.new({})
+    x = wfe.list_args
+    assert_instance_of(Array, x)
+    assert_equal(4, x.size)
+    assert_in_delta(((Time.now - 600).to_i * 1000), x[0], 1000)
+    assert_in_delta((Time.now.to_i * 1000), x[1], 1000)
+    assert_equal(100, x[2])
+    assert_nil(x[3])
+  end
+
+  def test_list_args_options
+    wfse = WavefrontCli::Event.new(limit: 55,
+                                   start: wall_time[0],
+                                   cursor: id,
+                                   end: wall_time[1])
+    x = wfse.list_args
+    assert_instance_of(Array, x)
+    assert_equal(4, x.size)
+    assert_equal(epoch_ms_time[0], x[0])
+    assert_equal(epoch_ms_time[1], x[1])
+    assert_equal(55, x[2])
+    assert_equal(id, x[3])
   end
 
   private
 
   def id
-    '1481553823153:testev'
-  end
-
-  def event_name
-    'test_event'
+    '1481553823153:testev:0'
   end
 
   def invalid_id
@@ -242,18 +265,24 @@ class EventEndToEndTest < EndToEndTest
     'event'
   end
 
+  def event_name
+    'test_event'
+  end
+
   def start_time
     1_481_553_823_153
   end
 
-  def import_fields
-    %i[method title creatorId triggers template]
+  def epoch_ms_time
+    wall_time.map { |t| (t.to_i * 1000) }
   end
 
   def state_dir
     test_state_dir + (Etc.getlogin || 'notty')
   end
 
+  # Puts some test events in the state directory
+  #
   def setup_test_state_dir
     FileUtils.mkdir_p(state_dir)
 
@@ -285,79 +314,10 @@ class EventEndToEndTest < EndToEndTest
                  "https://#{perm[:endpoint]}/api/v2/event/#{mock_id}/close")
       .with(body: 'null')
   end
-end
-
-# Unit tests for class methods
-#
-class EventMethodTests < Minitest::Test
-  attr_reader :wf, :wfse
-
-  def setup
-    @wf = WavefrontCli::Event.new({})
-    @wfse = WavefrontCli::Event.new(start: wall_time[0],
-                                    end: wall_time[1],
-                                    limit: 55,
-                                    cursor: '1481553823153:testev')
-  end
-
-  def test_create_dir_ok
-    base = Pathname.new(Dir.mktmpdir)
-    dir = base + 'testdir'
-    refute dir.exist?
-    wf.create_dir(dir)
-    assert dir.exist?
-    dir.unlink
-    base.unlink
-  end
-
-  def test_create_dir_fail
-    spy = Spy.on(FileUtils, :mkdir_p).and_return(false)
-
-    assert_raises(WavefrontCli::Exception::SystemError) do
-      wf.create_dir(Pathname.new('/any/old/directory'))
-    end
-
-    assert spy.has_been_called?
-    spy.unhook
-  end
-
-  def test_list_args_defaults
-    x = wf.list_args
-    assert_instance_of(Array, x)
-    assert_equal(4, x.size)
-    assert_in_delta(((Time.now - 600).to_i * 1000), x[0], 1000)
-    assert_in_delta((Time.now.to_i * 1000), x[1], 1000)
-    assert_equal(100, x[2])
-    assert_nil(x[3])
-  end
-
-  def test_list_args_options
-    x = wfse.list_args
-    assert_instance_of(Array, x)
-    assert_equal(4, x.size)
-    assert_equal(epoch_ms_time[0], x[0])
-    assert_equal(epoch_ms_time[1], x[1])
-    assert_equal(55, x[2])
-    assert_equal('1481553823153:testev', x[3])
-  end
-
-  def test_window_start
-    assert_kind_of(Numeric, wf.window_start)
-    assert_equal(epoch_ms_time[0], wfse.window_start)
-  end
-
-  def test_window_end
-    assert_kind_of(Numeric, wf.window_end)
-    assert_equal(epoch_ms_time[1], wfse.window_end)
-  end
 
-  private
-
-  def wall_time
-    [Time.at(1_568_112_000), Time.at(1_568_112_999)]
-  end
-
-  def epoch_ms_time
-    wall_time.map { |t| (t.to_i * 1000) }
+  # Event searching uses a cursor, not an offset
+  #
+  def cannot_handle_offsets
+    true
   end
 end