wavefront-cli 8.4.1 → 8.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d96bb27765c031f9998dfa45406581de1852f0fbdc0abff4bcea45b679963299
-  data.tar.gz: d40011ef4d521dd738fb594095366ee7e506bc35c9bad83e2ad421eeedab16bb
+  metadata.gz: 363b1be94331165aacf1538c797d07bdbefda71e801335bb4e35df97cb0bd950
+  data.tar.gz: 5563b27f93c679dde5947c220d80c37816ba6faf8844d08111cbf7dcc65a76c1
 SHA512:
-  metadata.gz: f4777538a7b6f116f56c24382b9f3ea54ca78d5306009a3876857ff963f481561ff28e5c925cf0e62152e686caaa3c54e3abe90f48f16cb6e7cd6f87ede9f857
-  data.tar.gz: 1bfab61e86f92ff9284207627615f07a701092afb6bd6f839471833db3610fb60c8e013c56b57a50329c67650e1a778c6581adb61804f4365675cb1838cb7c4f
+  metadata.gz: ce61f68ba09a6ba395143fa92abeadcdb0de127f8991fe61b979ae49379d026973c5d47a09d6d4f0b306006a15f95a717cac02160af0b727f2858ba66a9fddae
+  data.tar.gz: 111d9d52a0e0c3955164e1872198531b9e2bd61184dc430050029efdf8d19f9cd845885a7f1d5d5685d03dbf7de0845453d95f888e13eb0195b83fd25437116d

data/HISTORY.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 8.5.0 (2021-01-12)
+* Allow attachment of roles and ingestion policies when creating service
+  accounts.
+* Improved introspection of service accounts.
+* Refactor `event` command. This improves test coverage, fixes handling
+  event names with numeric suffix, and fixes searching.
+
 ## 8.4.1 (2021-01-04)
 * Bugfix docopt error on `event` command.
 

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

@@ -10,15 +10,14 @@ class WavefrontCommandEvent < WavefrontCommandBase
   end
 
   def _commands
-    ["list #{CMN} [-l] [-O fields] [-s start] [-e end] " \
-     '[-L limit] [-o cursor]',
+    ["list #{CMN} [-l] [-O fields] [-s start] [-e end] [-L limit] [-o cursor]",
      "describe #{CMN} <id>",
      "create #{CMN} [-d description] [-s start] [-i | -e end] " \
      '[-S severity] [-T type] [-H host...] [-g tag...] [-N] <event>',
      "close #{CMN} [<id>]",
      "delete #{CMN} <id>",
      "set #{CMN} <key=value> <id>",
-     "search #{CMN} [-o offset] [-L limit] [-l] [-O fields] <condition>...",
+     "search #{CMN} [-al] [-o cursor] [-L limit] [-O fields] <condition>...",
      "wrap #{CMN} [-C command] [-d description] [-S severity] [-T type] " \
      '[-H host...] [-g tag...] <event>',
      tag_commands,
@@ -28,6 +27,7 @@ class WavefrontCommandEvent < WavefrontCommandBase
   def _options
     [common_options,
      "-l, --long                list #{things} in detail",
+     "-a, --all                 list all #{things}",
      "-o, --cursor=EVENT        start listing from given #{thing}",
      '-O, --fields=F1,F2,...    only show given fields',
      "-L, --limit=COUNT         number of #{things} to list",

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

@@ -20,14 +20,15 @@ class WavefrontCommandServiceaccount < WavefrontCommandBase
   def _commands
     ["list #{CMN} [-l] [-O fields]",
      "describe #{CMN} <id>",
-     "create #{CMN} [-I] [-d description] [-p permission...] [-g group...] " \
-     '[-k usertoken...] <id>',
+     "create #{CMN} [-I] [-d description] [-p policy] [-r role...] " \
+     '[-g group...] [-k usertoken...] <id>',
      "activate #{CMN} <id>",
      "delete #{CMN} <account>...",
      "deactivate #{CMN} <id>",
      "dump #{CMN}",
      "groups #{CMN} <id>",
-     "permissions #{CMN} <id>",
+     "roles #{CMN} <id>",
+     "ingestionpolicy #{CMN} <id>",
      "join #{CMN} <id> <group>...",
      "leave #{CMN} <id> <group>...",
      "grant #{CMN} <permission> to <id>",
@@ -52,7 +53,8 @@ class WavefrontCommandServiceaccount < WavefrontCommandBase
      "-U, --upsert             import new or update existing #{thing}",
      "-I, --inactive           create an inactive #{thing}",
      "-d, --desc=STRING        description of #{thing}",
-     "-p, --permission=STRING  give #{thing} this permission",
+     "-r, --role=STRING        give #{thing} this role",
+     "-p, --policy=STRING      give #{thing} this ingestion policy",
      "-g, --group=STRING       add #{thing} to this user group",
      '-N, --name=STRING        name of token',
      '-k, --usertoken=STRING   API token']

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

@@ -35,14 +35,22 @@ module WavefrontDisplay
       end
     end
 
+    def do_roles
+      if data[:roles].empty?
+        puts 'Account does not have any roles attached.'
+      else
+        data[:roles].each { |r| puts format('%<id>s (%<name>s)', r) }
+      end
+    end
+
     alias do_join do_groups
     alias do_leave do_groups
 
-    def do_permissions
-      if data[:groups].empty?
-        puts 'Account does not have any Wavefront permissions.'
+    def do_ingestionpolicy
+      if data[:ingestionPolicy].empty?
+        puts 'Account does not have an ingestion policy attached.'
       else
-        puts data[:groups]
+        puts format('%<id>s (%<name>s)', data[:ingestionPolicy])
       end
     end
 

data/lib/wavefront-cli/event.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require 'fileutils'
-require 'open3'
-require 'etc'
 require 'wavefront-sdk/support/mixins'
 require_relative 'base'
+require_relative 'event_store'
 require_relative 'command_mixins/tag'
 
 module WavefrontCli
@@ -12,14 +10,13 @@ module WavefrontCli
   # CLI coverage for the v2 'event' API.
   #
   class Event < Base
-    attr_reader :state_dir
+    attr_reader :state
 
     include Wavefront::Mixins
     include WavefrontCli::Mixin::Tag
 
-    def post_initialize(_options)
-      @state_dir = event_state_dir + (Etc.getlogin || 'notty')
-      create_dir(state_dir)
+    def post_initialize(options)
+      @state = WavefrontCli::EventStore.new(options)
     end
 
     def do_list
@@ -32,38 +29,14 @@ module WavefrontCli
       t_start = parse_time(opts[:start], true)
       body = create_body(opts, t_start)
       resp = wf.create(body)
-      create_state_file(resp.response[:id]) if state_file_needed?(opts)
-      resp
-    end
-
-    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 an API call straight away.
-    #
-    def do_close(id = nil)
-      id ||= options[:'<id>']
-      ev = local_event(id)
-      ev_file = event_file(id)
-
-      abort "No locally stored event matches '#{id}'." unless ev
-
-      res = wf.close(ev)
-      ev_file.unlink if ev_file&.exist? && res.status.code == 200
-      res
-    end
+      return if opts[:noop]
 
-    def event_file(id)
-      id =~ /^\d{13}:.+/ ? state_dir + id : nil
+      state.create!(resp.response[:id])
+      resp
     end
 
     def do_show
-      events = local_event_list
+      events = state.list
 
       if events.size.zero?
         puts 'No open events.'
@@ -78,21 +51,54 @@ module WavefrontCli
       create_opts = options
       create_opts[:desc] ||= create_opts[:command]
       event_id = do_create(create_opts).response.id
-      exit_code = run_wrapped_cmd(options[:command])
+      exit_code = state.run_wrapped_cmd(options[:command])
       do_close(event_id)
       puts "Command exited #{exit_code}."
       exit exit_code
     end
 
-    # We can override the temp directory with the WF_EVENT_STATE_DIR. This is
-    # primarily for testing.
+    # 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 an API call
+    # straight away.
     #
-    def event_state_dir
-      if ENV['WF_EVENT_STATE_DIR']
-        Pathname.new(ENV['WF_EVENT_STATE_DIR'])
-      else
-        EVENT_STATE_DIR
-      end
+    def do_close(id = nil)
+      id ||= options[:'<id>']
+      ev = state.event(id)
+      ev_file = state.event_file(id)
+
+      abort "No locally stored event matches '#{id}'." unless ev
+
+      res = wf.close(ev)
+      ev_file.unlink if ev_file&.exist? && res.status.code == 200
+      res
+    end
+
+    # We have to override the normal validation methods because an event can
+    # be referred to by only a part of its name. This happens when the user
+    # refers to events on the local stack.
+    #
+    def validate_input
+      validate_id if options[:'<id>'] && !options[:close]
+      validate_tags if options[:'<tag>']
+      validate_tags(:evtag) if options[:evtag]
+      send(:extra_validation) if respond_to?(:extra_validation)
+    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
 
     # return [Hash] body for #create() method
@@ -123,128 +129,5 @@ module WavefrontCli
         r[:type] = opts[:type] if opts[:type]
       end
     end
-
-    # @return a local event from the stack directory
-    #
-    def local_event(id)
-      if !id
-        pop_event
-      elsif id =~ /^\d{13}:.+/
-        id
-      else
-        pop_event(id)
-      end
-    end
-
-    def local_event_list
-      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.')
-    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.
-    #
-    def create_state_file(id)
-      fname = state_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
-
-    def validate_input
-      validate_id if options[:'<id>'] && !options[:close]
-      validate_tags if options[:'<tag>']
-      validate_tags(:evtag) if options[:evtag]
-      send(:extra_validation) if respond_to?(:extra_validation)
-    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.
-    # Chances are you'll only ever have one in-play at once.
-    #
-    # @param name [String] name of event
-    # @eturn an array of [timestamp, event_name]
-    #
-    def pop_event(name = nil)
-      return false unless state_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
-
-    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

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/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.4.1'
+WF_CLI_VERSION = '8.5.0'

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

data/spec/wavefront-cli/event_store_spec.rb

@@ -0,0 +1,186 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pathname'
+require 'spy'
+require 'minitest/autorun'
+require_relative '../../lib/wavefront-cli/event_store'
+
+TEST_EVENT_STORE_DIR = Pathname.new(Dir.mktmpdir)
+
+# Tests for event store class. This is tested well via the interface of the
+# events CLI class.
+#
+class Test < MiniTest::Test
+  attr_reader :wf
+
+  include WavefrontCli::Constants
+
+  def before_setup
+    FileUtils.mkdir_p(TEST_EVENT_STORE_DIR)
+  end
+
+  def setup
+    @wf = WavefrontCli::EventStore.new({}, TEST_EVENT_STORE_DIR)
+  end
+
+  def teardown
+    FileUtils.rm_r(TEST_EVENT_STORE_DIR)
+  end
+
+  def test_state_file_needed?
+    wf1 = WavefrontCli::EventStore.new({}, TEST_EVENT_STORE_DIR)
+    assert wf1.state_file_needed?
+
+    wf2 = WavefrontCli::EventStore.new({ nostate: true }, TEST_EVENT_STORE_DIR)
+    refute wf2.state_file_needed?
+
+    wf3 = WavefrontCli::EventStore.new({ instant: true }, TEST_EVENT_STORE_DIR)
+    refute wf3.state_file_needed?
+
+    wf4 = WavefrontCli::EventStore.new({ start: Time.now - 20, end: Time.now },
+                                       TEST_EVENT_STORE_DIR)
+    refute wf4.state_file_needed?
+  end
+
+  def test_event_file
+    x = wf.event_file(id)
+    assert_instance_of(Pathname, x)
+    assert_equal(wf.dir, x.dirname)
+    assert_equal(id, x.basename.to_s)
+
+    assert_nil(wf.event_file('not_a_valid_id'))
+  end
+
+  def test_create_dir_ok
+    dir = TEST_EVENT_STORE_DIR + 'testdir'
+    refute dir.exist?
+    wf.create_dir(dir)
+    assert dir.exist?
+    dir.unlink
+  end
+
+  def test_list
+    setup_test_state_dir
+
+    x = wf.list
+    assert(x.all? { |e| e.is_a?(Pathname) })
+    assert_equal(4, x.size)
+
+    empty_test_state_dir
+  end
+
+  def test_list_empty_stack
+    out, err = capture_io { assert_raises(SystemExit) { wf.list } }
+    assert_empty(out)
+    assert_equal("No locally recorded events.\n", err)
+  end
+
+  def test_pop_event
+    setup_test_state_dir
+
+    assert (wf.dir + '1568133440530:ev3:0').exist?
+    assert_equal('1568133440530:ev3:0', wf.pop_event!)
+    refute (wf.dir + '1568133440530:ev3:0').exist?
+
+    empty_test_state_dir
+  end
+
+  def test_pop_event_named
+    setup_test_state_dir
+
+    assert (wf.dir + '1568133440515:ev1:1').exist?
+    assert_equal('1568133440515:ev1:1', wf.pop_event!('ev1'))
+    refute (wf.dir + '1568133440515:ev1:1').exist?
+
+    empty_test_state_dir
+  end
+
+  def test_event_specific
+    setup_test_state_dir
+
+    assert (wf.dir + '1568133440515:ev1:1').exist?
+    assert_equal('1568133440515:ev1:1', wf.event('1568133440515:ev1:1'))
+    assert (wf.dir + '1568133440515:ev1:1').exist?
+
+    empty_test_state_dir
+  end
+
+  def test_pop_event_empty_stack
+    out, err = capture_io { assert_raises(SystemExit) { wf.pop_event! } }
+    assert_empty(out)
+    assert_equal("No locally recorded events.\n", err)
+  end
+
+  def test_event_state_dir
+    ENV['WF_EVENT_STATE_DIR'] = nil
+    assert_equal(EVENT_STATE_DIR, wf.event_state_dir)
+
+    ENV['WF_EVENT_STATE_DIR'] = '/tmp/tester'
+    assert_equal(Pathname.new('/tmp/tester'), wf.event_state_dir)
+    ENV['WF_EVENT_STATE_DIR'] = nil
+
+    assert_equal(Pathname.new('/tmp/mydir'), wf.event_state_dir('/tmp/mydir'))
+  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_event_file_data
+    wf = WavefrontCli::EventStore.new({ desc: 'test event' },
+                                      TEST_EVENT_STORE_DIR)
+    x = wf.event_file_data
+    assert_instance_of(String, x)
+    y = JSON.parse(x, symbolize_names: true)
+    assert_equal('test event', y[:description])
+    assert_equal(%i[hosts description severity tags], y.keys)
+    assert_nil(y[:tags])
+  end
+
+  def test_create
+    refute (wf.dir + id).exist?
+    out, err = capture_io { wf.create!(id) }
+    assert_match(/Event state recorded at .*1481553823153:testev:0./, out)
+    assert_empty(err)
+    assert (wf.dir + id).exist?
+  end
+
+  def test_create_with_nostate
+    wf1 = WavefrontCli::EventStore.new(nostate: true)
+    assert_nil wf1.create!(id)
+  end
+
+  private
+
+  def id
+    '1481553823153:testev:0'
+  end
+
+  def dummy_event_files
+    %w[1568133440510:ev1:0
+       1568133440515:ev1:1
+       1568133440520:ev2:0
+       1568133440530:ev3:0]
+  end
+
+  def setup_test_state_dir
+    dummy_event_files.each do |f|
+      File.open(wf.dir + f, 'w') { |fh| fh.puts('dummy_data') }
+    end
+  end
+
+  def empty_test_state_dir
+    dummy_event_files.each do |f|
+      file = wf.dir + f
+      FileUtils.rm(file) if file.exist?
+    end
+  end
+end

data/spec/wavefront-cli/serviceaccount_spec.rb

@@ -41,20 +41,36 @@ class ServiceAccountEndToEndTest < EndToEndTest
     assert_abort_on_missing_creds("groups #{id}")
   end
 
-  def test_permissions
+  def test_roles
     quietly do
-      assert_cmd_gets("permissions #{id}", "/api/v2/#{api_path}/#{id}")
+      assert_cmd_gets("roles #{id}", "/api/v2/#{api_path}/#{id}")
     end
 
-    assert_invalid_id("permissions #{invalid_id}")
-    assert_usage('permissions')
+    assert_invalid_id("roles #{invalid_id}")
+    assert_usage('roles')
 
     assert_noop(
-      "permissions #{id}",
+      "roles #{id}",
       "uri: GET https://default.wavefront.com/api/v2/#{api_path}/#{id}"
     )
 
-    assert_abort_on_missing_creds("permissions #{id}")
+    assert_abort_on_missing_creds("roles #{id}")
+  end
+
+  def test_ingestionpolicy
+    quietly do
+      assert_cmd_gets("ingestionpolicy #{id}", "/api/v2/#{api_path}/#{id}")
+    end
+
+    assert_invalid_id("ingestionpolicy #{invalid_id}")
+    assert_usage('ingestionpolicy')
+
+    assert_noop(
+      "ingestionpolicy #{id}",
+      "uri: GET https://default.wavefront.com/api/v2/#{api_path}/#{id}"
+    )
+
+    assert_abort_on_missing_creds("ingestionpolicy #{id}")
   end
 
   def test_activate
@@ -85,7 +101,7 @@ class ServiceAccountEndToEndTest < EndToEndTest
                        '/api/v2/account/serviceaccount',
                        identifier: id,
                        active: true,
-                       groups: [],
+                       roles: [],
                        tokens: [],
                        userGroups: [])
     end
@@ -95,8 +111,8 @@ class ServiceAccountEndToEndTest < EndToEndTest
       'uri: POST https://default.wavefront.com/api/v2/account/serviceaccount',
       'body: ' + { identifier: id,
                    active: true,
-                   groups: [],
                    tokens: [],
+                   roles: [],
                    userGroups: [] }.to_json
     )
 
@@ -111,43 +127,56 @@ class ServiceAccountEndToEndTest < EndToEndTest
                        identifier: id,
                        description: 'words',
                        active: false,
-                       groups: [],
+                       roles: [],
                        tokens: [],
                        userGroups: [])
     end
   end
 
-  def test_create_account_in_usergroups
+  def test_create_account_with_usergroups
     quietly do
       assert_cmd_posts("create -g #{usergroups[0]} -g #{usergroups[1]} #{id}",
                        '/api/v2/account/serviceaccount',
                        identifier: id,
                        active: true,
-                       groups: [],
                        tokens: [],
+                       roles: [],
                        userGroups: usergroups)
     end
   end
 
+  def test_create_account_with_roles
+    quietly do
+      assert_cmd_posts("create -r #{roles[0]} -r #{roles[1]} #{id}",
+                       '/api/v2/account/serviceaccount',
+                       identifier: id,
+                       active: true,
+                       tokens: [],
+                       roles: roles,
+                       userGroups: [])
+    end
+  end
+
   def test_create_account_with_tokens
     quietly do
       assert_cmd_posts("create -k #{tokens[0]} -k #{tokens[1]} #{id}",
                        '/api/v2/account/serviceaccount',
                        identifier: id,
                        active: true,
-                       groups: [],
                        tokens: tokens,
+                       roles: [],
                        userGroups: [])
     end
   end
 
-  def test_create_account_with_permissions
+  def test_create_account_with_ingestion_policy
     quietly do
-      assert_cmd_posts("create -p #{permissions[0]} -p #{permissions[1]} #{id}",
+      assert_cmd_posts("create -p #{ingestion_policy} #{id}",
                        '/api/v2/account/serviceaccount',
                        identifier: id,
                        active: true,
-                       groups: permissions,
+                       ingestionPolicyId: ingestion_policy,
+                       roles: [],
                        tokens: [],
                        userGroups: [])
     end
@@ -158,8 +187,8 @@ class ServiceAccountEndToEndTest < EndToEndTest
                       "create -g abcdefg #{id}")
   end
 
-  def test_create_invalid_permission
-    assert_exits_with("'123456' is not a valid Wavefront permission.",
+  def test_create_invalid_ingestion_policy
+    assert_exits_with("'123456' is not a valid ingestion policy ID.",
                       "create -p 123456 #{id}")
   end
 
@@ -358,8 +387,9 @@ class ServiceAccountEndToEndTest < EndToEndTest
     'service account'
   end
 
-  def permissions
-    %w[alerts_management events_management]
+  def roles
+    %w[07fc5cdd-0979-489e-8f70-325f39d15e55
+       0a42adf6-e738-4c5d-9e53-fd10bd979a31]
   end
 
   def tokens
@@ -372,6 +402,10 @@ class ServiceAccountEndToEndTest < EndToEndTest
        abcdef12-1234-abcd-1234-abcdef012345]
   end
 
+  def ingestion_policy
+    'test-policy-1607616352537'
+  end
+
   def import_fields
     %i[identifier description active tokens groups userGroups]
   end

data/wavefront-cli.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |gem|
 
   gem.add_runtime_dependency 'docopt', '~> 0.6.0'
   gem.add_runtime_dependency 'inifile', '~> 3.0'
-  gem.add_runtime_dependency 'wavefront-sdk', '~> 5.4', '>= 5.4.1'
+  gem.add_runtime_dependency 'wavefront-sdk', '~> 5.4', '>= 5.4.2'
 
   gem.add_development_dependency 'minitest', '~> 5.14'
   gem.add_development_dependency 'rake', '~> 13.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wavefront-cli
 version: !ruby/object:Gem::Version
-  version: 8.4.1
+  version: 8.5.0
 platform: ruby
 authors:
 - Robert Fisher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-04 00:00:00.000000000 Z
+date: 2021-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docopt
@@ -47,7 +47,7 @@ dependencies:
         version: '5.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.4.1
+        version: 5.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -57,7 +57,7 @@ dependencies:
         version: '5.4'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.4.1
+        version: 5.4.2
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -232,6 +232,7 @@ files:
 - lib/wavefront-cli/display/webhook.rb
 - lib/wavefront-cli/display/write.rb
 - lib/wavefront-cli/event.rb
+- lib/wavefront-cli/event_store.rb
 - lib/wavefront-cli/exception.rb
 - lib/wavefront-cli/exception_handler.rb
 - lib/wavefront-cli/externallink.rb
@@ -322,6 +323,7 @@ files:
 - spec/wavefront-cli/display/printer/long_spec.rb
 - spec/wavefront-cli/display/printer/terse_spec.rb
 - spec/wavefront-cli/event_spec.rb
+- spec/wavefront-cli/event_store_spec.rb
 - spec/wavefront-cli/externallink_spec.rb
 - spec/wavefront-cli/integration_spec.rb
 - spec/wavefront-cli/maintenancewindow_spec.rb
@@ -461,6 +463,7 @@ test_files:
 - spec/wavefront-cli/display/printer/long_spec.rb
 - spec/wavefront-cli/display/printer/terse_spec.rb
 - spec/wavefront-cli/event_spec.rb
+- spec/wavefront-cli/event_store_spec.rb
 - spec/wavefront-cli/externallink_spec.rb
 - spec/wavefront-cli/integration_spec.rb
 - spec/wavefront-cli/maintenancewindow_spec.rb