wavefront-cli 6.1.0 → 7.1.0

data/lib/wavefront-cli/exception_handler.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module WavefrontCli
+  #
+  # Handle fatal errors.
+  #
+  module ExceptionMixins
+    # 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
+        abort 'Fatal error. Unsupported command. Please open a Github issue.'
+      when WavefrontCli::Exception::InvalidInput
+        abort "Invalid input. #{exception.message}"
+      when Interrupt
+        abort "\nOperation aborted at user request."
+      when WavefrontCli::Exception::ConfigFileNotFound
+        abort "Configuration file #{exception}' not found."
+      when WavefrontCli::Exception::CredentialError
+        handle_missing_credentials(exception)
+      when WavefrontCli::Exception::MandatoryValue
+        abort 'A value must be supplied.'
+      when Wavefront::Exception::NetworkTimeout
+        abort 'Connection timed out.'
+      when Wavefront::Exception::InvalidPermission
+        abort "'#{exception}' is not a valid Wavefront permission."
+      when Wavefront::Exception::InvalidUserGroupId
+        abort "'#{exception}' is not a valid user group ID."
+      when Wavefront::Exception::InvalidAccountId
+        abort "'#{exception}' is not a valid system or user account ID."
+      when Wavefront::Exception::InvalidRoleId
+        abort "'#{exception}' is not a valid role ID."
+      when Wavefront::Exception::InvalidApiTokenId
+        abort "'#{exception}' is not a valid API token ID."
+      when Wavefront::Exception::InvalidIngestionPolicyId
+        abort "'#{exception}' is not a valid ingestion policy ID."
+      when WavefrontCli::Exception::InvalidValue
+        abort "Invalid value for #{exception}."
+      when WavefrontCli::Exception::ProfileExists
+        abort "Profile '#{exception}' already exists."
+      when WavefrontCli::Exception::ProfileNotFound
+        abort "Profile '#{exception}' not found."
+      when WavefrontCli::Exception::FileNotFound
+        abort 'File not found.'
+      when WavefrontCli::Exception::InsufficientData
+        abort "Insufficient data. #{exception.message}"
+      when WavefrontCli::Exception::InvalidQuery
+        abort "Invalid query. API message: '#{exception.message}'."
+      when WavefrontCli::Exception::SystemError
+        abort "Host system error. #{exception.message}"
+      when WavefrontCli::Exception::UnparseableInput
+        abort "Cannot parse input. #{exception.message}"
+      when WavefrontCli::Exception::UnparseableSearchPattern
+        abort 'Searches require a key, a value, and a match operator.'
+      when WavefrontCli::Exception::UnsupportedFileFormat
+        abort 'Unsupported file format.'
+      when WavefrontCli::Exception::UnsupportedOperation
+        abort "Unsupported operation.\n#{exception.message}"
+      when WavefrontCli::Exception::UnsupportedOutput
+        abort exception.message
+      when WavefrontCli::Exception::UnsupportedNoop
+        abort 'Multiple API call operations cannot be performed as no-ops.'
+      when WavefrontCli::Exception::UserGroupNotFound
+        abort "Cannot find user group '#{exception.message}'."
+      when Wavefront::Exception::UnsupportedWriter
+        abort "Unsupported writer '#{exception.message}'."
+      when WavefrontCli::Exception::UserError
+        abort "User error: #{exception.message}."
+      when WavefrontCli::Exception::ImpossibleSearch
+        abort 'Search on non-existent key. Please use a top-level field.'
+      when Wavefront::Exception::InvalidSamplingValue
+        abort 'Sampling rates must be between 0 and 0.05.'
+      else
+        warn "general error: #{exception}"
+        backtrace_message(exception)
+        abort
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/PerceivedComplexity
+    # rubocop:enable Metrics/CyclomaticComplexity
+  end
+end

data/lib/wavefront-cli/output/hcl/base.rb

@@ -92,7 +92,7 @@ module WavefrontHclOutput
     def quote_value(val)
       case val.class.to_s.to_sym
       when :String
-        format('"%<value>s"', value: val.gsub(/\"/, '\"'))
+        format('"%<value>s"', value: val.gsub(/"/, '\"'))
       else
         val
       end

data/lib/wavefront-cli/query.rb

@@ -51,20 +51,26 @@ module WavefrontCli
 
     # @return [Hash] options for the SDK query method
     #
-    # rubocop:disable Metrics/AbcSize
     def q_opts
+      basic_q_opts.tap do |o|
+        o[:n] = options[:name]
+        o[:p] = options[:points]
+        o[:view] = 'HISTOGRAM' if options[:histogramview]
+        o[:cached] = false if options[:nocache]
+      end.compact
+    end
+
+    # Every query gets these options. They're modified by q_opts
+    #
+    def basic_q_opts
       { autoEvents: options[:events],
         i: options[:inclusive],
         summarization: options[:summarize] || 'mean',
         listMode: true,
-        strict: true,
+        strict: !options[:nostrict],
         includeObsoleteMetrics: options[:obsolete],
-        sorted: true }.tap do |o|
-          o[:n] = options[:name] if options[:name]
-          o[:p] = options[:points] if options[:points]
-        end
+        sorted: true }
     end
-    # rubocop:enable Metrics/AbcSize
 
     # @return [Integer] start of query window. If one has been
     #   given, that; if not, ten minutes ago

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/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 = '6.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>'],
@@ -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/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