wavefront-cli 5.1.0 → 7.1.0

data/lib/wavefront-cli/role.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+
+module WavefrontCli
+  #
+  # CLI coverage for the v2 'role' API.
+  #
+  class Role < WavefrontCli::Base
+    alias do_permissions do_describe
+
+    def do_create
+      wf.create({ name: options[:'<name>'],
+                  description: options[:description],
+                  permissions: options[:permission] }.compact)
+    end
+
+    def do_accounts
+      things_with_role(:account, options[:'<id>'])
+    end
+
+    def do_groups
+      things_with_role(:usergroup, options[:'<id>'])
+    end
+
+    def do_give_to
+      wf.add_assignees(options[:'<id>'], options[:'<member>'])
+    end
+
+    def do_take_from
+      wf.remove_assignees(options[:'<id>'], options[:'<member>'])
+    end
+
+    def do_grant
+      wf.grant(options[:'<permission>'], Array(options[:'<id>']))
+    end
+
+    def do_revoke
+      wf.revoke(options[:'<permission>'], Array(options[:'<id>']))
+    end
+
+    private
+
+    # Search for objects of the given type with the given role
+    #
+    def things_with_role(thing, role)
+      require 'wavefront-sdk/search'
+      wfs = Wavefront::Search.new(mk_creds, mk_opts)
+      wfs.search(thing,
+                 conds_to_query(["roles~#{role}"]),
+                 limit: :all, sort_field: :id)
+    end
+  end
+end

data/lib/wavefront-cli/serviceaccount.rb

@@ -173,20 +173,14 @@ module WavefrontCli
 
     def validate_groups
       options[:group].each { |g| wf_usergroup_id?(g) }
-    rescue Wavefront::Exception::InvalidUserGroupId => e
-      raise e, 'Invalid usergroup ID'
     end
 
     def validate_tokens
       options[:usertoken].each { |t| wf_apitoken_id?(t) }
-    rescue Wavefront::Exception::InvalidApiTokenId => e
-      raise e, 'Invalid API token'
     end
 
     def validate_perms
       options[:permission].each { |p| wf_permission?(p) }
-    rescue Wavefront::Exception::InvalidPermission => e
-      raise e, 'Invalid permission'
     end
 
     def descriptive_name

data/lib/wavefront-cli/spy.rb

@@ -42,14 +42,6 @@ module WavefrontCli
 
     private
 
-    def require_sdk_class
-      require 'wavefront-sdk/unstable/spy'
-    end
-
-    def _sdk_class
-      'Wavefront::Unstable::Spy'
-    end
-
     def rate
       return 0.01 unless options[:rate]
 

data/lib/wavefront-cli/subcommands/import.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/load_file'
+
+module WavefrontCli
+  module Subcommand
+    #
+    # Stuff to import an object
+    #
+    class Import
+      attr_reader :wf, :options
+
+      def initialize(calling_class, options)
+        @calling_class = calling_class
+        @wf = calling_class.wf
+        @options = options
+        @message = 'IMPORTED'
+      end
+
+      def run!
+        errs = 0
+
+        [raw_input].flatten.each do |obj|
+          resp = import_object(obj)
+          next if options[:noop]
+
+          errs += 1 unless resp.ok?
+          puts import_message(obj, resp)
+        end
+
+        exit errs
+      end
+
+      private
+
+      def raw_input
+        WavefrontCli::Helper::LoadFile.new(options[:'<file>']).load
+      end
+
+      def import_message(obj, resp)
+        format('%-15<id>s %-10<status>s %<message>s',
+               id: obj[:id] || obj[:url],
+               status: resp.ok? ? @message : 'FAILED',
+               message: resp.status.message)
+      end
+
+      def import_object(raw)
+        raw = preprocess_rawfile(raw) if respond_to?(:preprocess_rawfile)
+        prepped = @calling_class.import_to_create(raw)
+
+        if options[:upsert]
+          import_upsert(raw, prepped)
+        elsif options[:update]
+          @message = 'UPDATED'
+          import_update(raw)
+        else
+          wf.create(prepped)
+        end
+      end
+
+      def import_upsert(raw, prepped)
+        update_call = import_update(raw)
+
+        if update_call.ok?
+          @message = 'UPDATED'
+          return update_call
+        end
+
+        puts 'update failed, inserting' if options[:verbose] || options[:debug]
+        wf.create(prepped)
+      end
+
+      def import_update(raw)
+        wf.update(raw[:id], raw, false)
+      end
+    end
+  end
+end

data/lib/wavefront-cli/usergroup.rb

@@ -12,27 +12,27 @@ module WavefrontCli
     end
 
     alias do_users do_describe
+    alias do_roles do_describe
     alias do_permissions do_describe
 
     def do_create
-      wf.create(name: options[:'<name>'],
-                permissions: options[:permission])
+      wf.create(name: options[:'<name>'], roleIDs: options[:roleid])
     end
 
-    def do_add_user
+    def do_add_to
       wf.add_users_to_group(options[:'<id>'], options[:'<user>'])
     end
 
-    def do_remove_user
+    def do_remove_from
       wf.remove_users_from_group(options[:'<id>'], options[:'<user>'])
     end
 
-    def do_grant
-      wf.grant(options[:'<permission>'], Array(options[:'<id>']))
+    def do_add_role
+      wf.add_roles_to_group(options[:'<id>'], options[:'<role>'])
     end
 
-    def do_revoke
-      wf.revoke(options[:'<permission>'], Array(options[:'<id>']))
+    def do_remove_role
+      wf.remove_roles_from_group(options[:'<id>'], options[:'<role>'])
     end
 
     def import_to_create(raw)

data/lib/wavefront-cli/version.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-WF_CLI_VERSION = '5.1.0'
+WF_CLI_VERSION = '7.1.0'

data/lib/wavefront-cli/write.rb

@@ -9,15 +9,16 @@ module WavefrontCli
   #
   class Write < Base
     attr_reader :fmt
+
     include Wavefront::Mixins
     SPLIT_PATTERN = /\s(?=(?:[^"]|"[^"]*")*$)/.freeze
 
     # rubocop:disable Metrics/AbcSize
-    def do_point
+    def do_point(value = options[:'<value>'])
       tags = tags_to_hash(options[:tag])
 
       p = { path: options[:'<metric>'],
-            value: options[:'<value>'].delete('\\').to_f }
+            value: sane_value(value) }
 
       p[:tags] = tags unless tags.empty?
       p[:source] = options[:host] if options[:host]
@@ -36,6 +37,31 @@ module WavefrontCli
       send_point(make_distribution_point(tags_to_hash(options[:tag])))
     end
 
+    def do_noise
+      loop do
+        do_point(random_value(options[:min] || -10, options[:max] || 10))
+        sleep(sleep_time)
+      end
+    end
+
+    def random_value(min, max)
+      return min if min == max
+
+      rand(max.to_f - min.to_f) + min.to_f
+    end
+
+    def sane_value(value)
+      return value if value.is_a?(Numeric)
+
+      raise WavefrontCli::Exception::InvalidValue unless value.is_a?(String)
+
+      value.delete('\\').to_f
+    end
+
+    def sleep_time
+      options[:interval] ? options[:interval].to_f : 1
+    end
+
     # rubocop:disable Metrics/AbcSize
     def make_distribution_point(tags)
       { path: options[:'<metric>'],
@@ -121,7 +147,7 @@ module WavefrontCli
     def send_point(point)
       call_write(point)
     rescue Wavefront::Exception::InvalidEndpoint
-      abort format("Could not connect to proxy '%<proxy>s:%<port>s'.", options)
+      abort format("Could not connect to proxy '%<proxy>s:%<port>s'.", wf.creds)
     end
 
     # Read the input, from a file or from STDIN, and turn each line
@@ -270,7 +296,6 @@ module WavefrontCli
     # @raise WavefrontCli::Exception::UnparseableInput if the line
     #   doesn't look right
     #
-    # rubocop:disable Metrics/CyclomaticComplexity
     # rubocop:disable Metrics/MethodLength
     # rubocop:disable Metrics/AbcSize
     def process_line(line)
@@ -293,7 +318,6 @@ module WavefrontCli
     end
     # rubocop:enable Metrics/AbcSize
     # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/CyclomaticComplexity
 
     # We can get tags from the file, from the -T option, or both.
     # Merge them, making the -T win if there is a collision.

data/spec/.rubocop.yml

@@ -14,3 +14,37 @@ Style/HashTransformKeys:
     Enabled: true
 Style/HashTransformValues:
     Enabled: true
+
+# new compatabilities
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: true
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
+Lint/RaiseException:
+  Enabled: true
+Lint/StructNewOverride:
+  Enabled: true
+Style/ExponentialNotation:
+  Enabled: true
+Style/SlicingWithRange:
+  Enabled: true
+Lint/DeprecatedOpenSSLConstant:
+  Enabled: true
+Lint/MixedRegexpCaptureTypes:
+  Enabled: true
+Style/RedundantRegexpCharacterClass:
+  Enabled: true
+Style/RedundantRegexpEscape:
+  Enabled: true
+Style/AccessorGrouping:
+  Enabled: true
+Style/BisectedAttrAccessor:
+  Enabled: true
+Style/RedundantAssignment:
+  Enabled: true
+Style/RedundantFetchBlock:
+  Enabled: true
+
+# Is nothing sacred?
+Layout/LineLength:
+  Max: 80

data/spec/test_mixins/delete.rb

@@ -15,8 +15,7 @@ module WavefrontCliTest
 
       assert_noop(
         "delete #{id}",
-        'uri: DELETE https://default.wavefront.com/api/v2/' \
-        "#{api_path}/#{id}"
+        "uri: DELETE https://default.wavefront.com/api/v2/#{api_path}/#{id}"
       )
 
       assert_abort_on_missing_creds("delete #{id}")

data/spec/test_mixins/import.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../lib/wavefront-cli/helpers/load_file'
+
 module WavefrontCliTest
   #
   # Mixin to test standard 'import' commands
@@ -25,7 +27,7 @@ module WavefrontCliTest
       assert_abort_on_missing_creds("import #{import_file}")
     end
 
-    def test_import_update
+    def _test_import_update
       Spy.teardown
 
       out, err = capture_io do
@@ -38,15 +40,19 @@ module WavefrontCliTest
       end
 
       assert_empty(err)
-      assert_equal('1556812163465   IMPORTED', out.strip)
+      assert_equal('1556812163465   UPDATED', out.strip)
 
       assert_exits_with('File not found.', 'import /no/such/file')
       assert_usage('import -u')
       assert_abort_on_missing_creds("import -u #{import_file}")
     end
 
+    def load_file(file)
+      WavefrontCli::Helper::LoadFile.new(file).load
+    end
+
     def test_import_fields
-      x = cmd_instance.import_to_create(cmd_instance.load_file(import_file))
+      x = cmd_instance.import_to_create(load_file(import_file))
       assert_instance_of(Hash, x)
       import_fields.each { |f| assert_includes(x.keys, f) }
       blocked_import_fields.each { |f| refute_includes(x.keys, f) }

data/spec/wavefront-cli/account_spec.rb

@@ -0,0 +1,303 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../support/command_base'
+require_relative '../../lib/wavefront-cli/account'
+
+# Ensure 'account' commands produce the correct API calls.
+#
+class AccountEndToEndTest < EndToEndTest
+  include WavefrontCliTest::List
+  include WavefrontCliTest::Delete
+  include WavefrontCliTest::Describe
+  include WavefrontCliTest::Search
+
+  def test_role_add_to
+    quietly do
+      assert_cmd_posts("role add to #{id} #{roles.join(' ')}",
+                       "/api/v2/account/#{id}/addRoles",
+                       roles.to_json)
+    end
+
+    assert_invalid_id("role add to #{invalid_id} #{roles.first}")
+    assert_invalid_id("role add to #{id} #{invalid_role}")
+    assert_abort_on_missing_creds("role add to #{id} #{roles.last}")
+    assert_usage("role add to #{roles.first}")
+  end
+
+  def test_role_remove_from
+    quietly do
+      assert_cmd_posts("role remove from #{id} #{roles.join(' ')}",
+                       "/api/v2/account/#{id}/removeRoles",
+                       roles.to_json)
+    end
+
+    assert_invalid_id("role remove from #{invalid_id} #{roles.first}")
+    assert_abort_on_missing_creds("role remove from #{id} #{roles.last}")
+    assert_usage("role remove from #{roles.first}")
+  end
+
+  def test_add_group_to
+    assert_repeated_output("Added '#{id}' to '#{groups.first}'.") do
+      assert_cmd_posts("group add to #{id} #{groups.first}",
+                       "/api/v2/account/#{id}/addUserGroups",
+                       [groups.first].to_json)
+    end
+
+    assert_invalid_id("group add to #{id} #{invalid_group}")
+    assert_invalid_id("group add to #{invalid_id} #{groups.first}")
+    assert_abort_on_missing_creds("group add to #{id} #{groups.last}")
+    assert_usage("group add to #{groups.first}")
+  end
+
+  def test_remove_group_from
+    assert_repeated_output("Removed '#{id}' from '#{groups.first}', " \
+                           "'#{groups.last}'.") do
+      assert_cmd_posts("group remove from #{id} #{groups.join(' ')}",
+                       "/api/v2/account/#{id}/removeUserGroups",
+                       groups.to_json)
+    end
+
+    assert_invalid_id("group remove from #{id} #{invalid_group}")
+    assert_invalid_id("group remove from #{invalid_id} #{groups.first}")
+    assert_abort_on_missing_creds("group remove from #{id} #{groups.last}")
+    assert_usage("group remove from #{groups.first}")
+  end
+
+  def test_business_functions
+    quietly do
+      assert_cmd_gets("business functions #{id}",
+                      "/api/v2/account/#{id}/businessFunctions")
+    end
+
+    assert_noop("business functions #{id}",
+                'uri: GET https://default.wavefront.com/api/v2/account/' \
+                "#{id}/businessFunctions")
+    assert_invalid_id("business functions #{invalid_id}")
+    assert_abort_on_missing_creds("business functions #{id}")
+    assert_usage('business functions')
+  end
+
+  def test_grant_to
+    assert_repeated_output("Granted '#{permission}' to '#{id}'.") do
+      assert_cmd_posts("grant #{permission} to #{id}",
+                       "/api/v2/account/grant/#{permission}",
+                       [id].to_json)
+    end
+
+    assert_invalid_id("grant #{permission} to #{invalid_id}")
+    assert_abort_on_missing_creds("grant #{permission} to #{id}")
+    assert_usage("grant #{permission}")
+  end
+
+  def test_revoke_from
+    assert_repeated_output("Revoked '#{permission}' from '#{id}'.") do
+      assert_cmd_posts("revoke #{permission} from #{id}",
+                       "/api/v2/account/revoke/#{permission}",
+                       [id].to_json)
+    end
+
+    out, err = capture_io do
+      assert_raises(SystemExit) do
+        wf.new("account revoke #{invalid_permission} from #{id}".split)
+      end
+    end
+
+    assert_empty out
+    assert_equal("'made_up_permission' is not a valid Wavefront permission.",
+                 err.strip)
+
+    assert_invalid_id("revoke #{permission} from #{invalid_id}")
+    assert_abort_on_missing_creds("revoke #{permission} from #{id}")
+    assert_usage("revoke #{permission}")
+  end
+
+  def test_roles
+    assert_repeated_output("'#{id}' has no roles.") do
+      assert_cmd_gets("roles #{id}", "/api/v2/account/#{id}", [])
+    end
+
+    assert_abort_on_missing_creds("roles #{id}")
+    assert_invalid_id("roles #{invalid_id}")
+    assert_usage('roles')
+  end
+
+  def test_add_ingestionpolicy_to
+    assert_repeated_output("Added '#{policy}' to '#{id}'.") do
+      assert_cmd_posts("ingestionpolicy add to #{id} #{policy}",
+                       '/api/v2/account/addingestionpolicy',
+                       { ingestionPolicyId: policy,
+                         accounts: [id] }.to_json)
+    end
+
+    assert_invalid_id("ingestionpolicy add to #{invalid_id} #{policy}")
+    assert_invalid_id("ingestionpolicy add to #{id} #{invalid_policy}")
+    assert_abort_on_missing_creds("ingestionpolicy add to #{id} #{policy}")
+    assert_usage("ingestionpolicy add to #{policy}")
+  end
+
+  def test_remove_ingestionpolicy_remove
+    assert_repeated_output("Removed '#{policy}' from '#{id}'.") do
+      assert_cmd_posts("ingestionpolicy remove from #{id} #{policy}",
+                       '/api/v2/account/removeingestionpolicies',
+                       { ingestionPolicyId: policy,
+                         accounts: [id] }.to_json)
+    end
+
+    assert_invalid_id("ingestionpolicy remove from #{invalid_id} #{policy}")
+    assert_invalid_id("ingestionpolicy remove from #{id} #{invalid_policy}")
+    assert_abort_on_missing_creds("ingestionpolicy remove from #{id} #{policy}")
+    assert_usage("ingestionpolicy remove from #{policy}")
+  end
+
+  def test_ingestionpolicy
+    assert_repeated_output("'#{id}' has no ingestion policy.") do
+      assert_cmd_gets("ingestionpolicy #{id}", "/api/v2/account/#{id}", [])
+    end
+
+    assert_abort_on_missing_creds("ingestionpolicy #{id}")
+    assert_invalid_id("ingestionpolicy #{invalid_id}")
+    assert_usage('ingestionpolicy')
+  end
+
+  def test_groups
+    assert_repeated_output("'#{id}' does not belong to any groups.") do
+      assert_cmd_gets("groups #{id}", "/api/v2/account/#{id}", [])
+    end
+
+    assert_invalid_id("groups #{invalid_id}")
+    assert_abort_on_missing_creds("groups #{id}")
+    assert_usage('groups')
+  end
+
+  def test_permissions
+    assert_repeated_output("'#{id}' does not have any permissions " \
+                           'directly attached.') do
+      assert_cmd_gets("permissions #{id}", "/api/v2/account/#{id}", [])
+    end
+
+    assert_abort_on_missing_creds("permissions #{id}")
+    assert_invalid_id("permissions #{invalid_id}")
+    assert_usage('permissions')
+  end
+
+  def test_invite_with_group
+    expected_body = [{ emailAddress: id,
+                       userGroups: [groups.first],
+                       groups: [] }].to_json
+
+    assert_repeated_output("Sent invitation to '#{id}'.") do
+      assert_cmd_posts("invite user -g #{groups.first} #{id}",
+                       '/api/v2/account/user/invite',
+                       expected_body)
+    end
+
+    assert_noop("invite user -g #{groups.first} #{id}",
+                'uri: POST https://default.wavefront.com/api/v2/account/user' \
+                '/invite',
+                "body: #{expected_body}")
+    assert_invalid_id("invite user -g #{groups.first} #{invalid_id}")
+    assert_abort_on_missing_creds("invite user -g #{groups.first} #{id}")
+    assert_usage('invite user')
+  end
+
+  def test_invite_with_role_and_policy
+    expected_body = [{ emailAddress: id,
+                       roles: roles,
+                       ingestionPolicyId: policy,
+                       groups: [] }].to_json
+
+    assert_repeated_output("Sent invitation to '#{id}'.") do
+      assert_cmd_posts(
+        "invite user -r #{roles.join(' -r ')} -i #{policy} #{id}",
+        '/api/v2/account/user/invite',
+        expected_body
+      )
+    end
+
+    assert_noop("invite user -r #{roles.join(' -r ')} -i #{policy} #{id}",
+                'uri: POST https://default.wavefront.com/api/v2/account/user' \
+                '/invite',
+                "body: #{expected_body}")
+    assert_invalid_id("invite user -m #{permission} #{invalid_id}")
+    assert_abort_on_missing_creds("invite user -m #{permission} #{id}")
+    assert_usage('invite user')
+  end
+
+  def test_validate
+    cmd = "validate #{user_list.join(' ')}"
+
+    quietly do
+      assert_cmd_posts(cmd,
+                       '/api/v2/account/validateAccounts',
+                       user_list.to_json,
+                       IO.read(RES_DIR + 'responses' + 'user-validate.json'))
+    end
+
+    assert_noop(cmd,
+                'uri: POST https://default.wavefront.com/api/v2/account' \
+                '/validateAccounts',
+                "body: #{user_list.to_json}")
+    assert_abort_on_missing_creds(cmd)
+    assert_usage('validate')
+  end
+
+  private
+
+  def id
+    'someone@example.com'
+  end
+
+  def invalid_id
+    'bad' * 200
+  end
+
+  def cmd_word
+    'account'
+  end
+
+  def groups
+    %w[2659191e-aad4-4302-a94e-9667e1517127
+       abcdef12-1234-abcd-1234-abcdef012345]
+  end
+
+  def invalid_group
+    '__bad_group__'
+  end
+
+  def roles
+    %w[87654321-aad4-4302-a94e-9667e1517127
+       12345678-1234-abcd-1234-abcdef012345]
+  end
+
+  def invalid_role
+    '__bad_role__'
+  end
+
+  def list_response
+    { items: [{ identifier: 'user1@example.com' },
+              { identifier: 'user2@example.com' }] }.to_json
+  end
+
+  def permission
+    'alerts_management'
+  end
+
+  def invalid_permission
+    'made_up_permission'
+  end
+
+  def user_list
+    %w[someone@example.com
+       sa:testsysacct
+       no-such-thing]
+  end
+
+  def policy
+    'test-policy-1579802191234'
+  end
+
+  def invalid_policy
+    '__some_nonsense_or_other__'
+  end
+end