sensu-cli 0.2.1 → 0.2.2

data/lib/sensu-cli/api.rb

@@ -13,20 +13,21 @@ module SensuCli
         http.use_ssl = true
         http.verify_mode = OpenSSL::SSL::VERIFY_NONE
       end
+      proxy_header = { 'api-proxy' => 'true' }
       case opts[:method]
       when 'Get'
-        req =  Net::HTTP::Get.new(opts[:path])
+        req =  Net::HTTP::Get.new(opts[:path], initheader = proxy_header)
       when 'Delete'
-        req =  Net::HTTP::Delete.new(opts[:path])
+        req =  Net::HTTP::Delete.new(opts[:path], initheader = proxy_header)
       when 'Post'
-        req =  Net::HTTP::Post.new(opts[:path],initheader = {'Content-Type' => 'application/json'})
+        req =  Net::HTTP::Post.new(opts[:path], initheader = proxy_header.merge!({ 'Content-Type' => 'application/json' }))
         req.body = opts[:payload]
       end
       req.basic_auth(opts[:user], opts[:password]) if opts[:user] && opts[:password]
       begin
         http.request(req)
       rescue Timeout::Error
-        puts "HTTP request has timed out.".color(:red)
+        puts 'HTTP request has timed out.'.color(:red)
         exit
       rescue StandardError => e
         puts "An HTTP error occurred.  Check your settings. #{e}".color(:red)
@@ -34,25 +35,25 @@ module SensuCli
       end
     end
 
-    def response(code,body,command=nil)
+    def response(code, body, command = nil)
       case code
       when '200'
         JSON.parse(body)
       when '201'
-        puts "The stash has been created." if command == "stashes" || command == "silence"
+        puts 'The stash has been created.' if command == 'stashes' || command == 'silence'
       when '202'
-        puts "The item was submitted for processing."
+        puts 'The item was submitted for processing.'
       when '204'
-        puts "Sensu is healthy" if command == 'health'
-        puts "The item was successfully deleted." if command == 'aggregates' || command == 'stashes'
+        puts 'Sensu is healthy' if command == 'health'
+        puts 'The item was successfully deleted.' if command == 'aggregates' || command == 'stashes'
       when '400'
-        puts "The payload is malformed.".color(:red)
+        puts 'The payload is malformed.'.color(:red)
       when '401'
-        puts "The request requires user authentication.".color(:red)
+        puts 'The request requires user authentication.'.color(:red)
       when '404'
-        puts "The item did not exist.".color(:cyan)
+        puts 'The item did not exist.'.color(:cyan)
       else
-        (command == 'health') ? (puts "Sensu is not healthy.".color(:red)) : (puts "There was an error while trying to complete your request. Response code: #{code}".color(:red))
+        (command == 'health') ? (puts 'Sensu is not healthy.'.color(:red)) : (puts "There was an error while trying to complete your request. Response code: #{code}".color(:red))
       end
     end
 

data/lib/sensu-cli/base.rb

@@ -4,7 +4,7 @@ module SensuCli
     def setup
       clis = Cli.new
       cli = clis.global
-      @format = cli[:fields][:format] || "long"
+      @format = cli[:fields][:format] || 'long'
       settings
       api_path(cli)
       make_call
@@ -13,21 +13,21 @@ module SensuCli
     def settings
       directory = "#{Dir.home}/.sensu"
       file = "#{directory}/settings.rb"
-      alt = "/etc/sensu/sensu-cli/settings.rb"
+      alt = '/etc/sensu/sensu-cli/settings.rb'
       settings = Settings.new
       if settings.is_file?(file)
         SensuCli::Config.from_file(file)
       elsif settings.is_file?(alt)
         SensuCli::Config.from_file(alt)
       else
-        settings.create(directory,file)
+        settings.create(directory, file)
       end
     end
 
     def api_path(cli)
       p = PathCreator.new
-      p.respond_to?(cli[:command]) ? path = p.send(cli[:command], cli) : (puts "Something Bad Happened";exit)
-      @api = {:path => path[:path], :method => cli[:method], :command => cli[:command], :payload => (path[:payload] || false)}
+      p.respond_to?(cli[:command]) ? path = p.send(cli[:command], cli) : (puts 'Something Bad Happened'; exit)
+      @api = { :path => path[:path], :method => cli[:method], :command => cli[:command], :payload => (path[:payload] || false) }
     end
 
     def make_call
@@ -46,7 +46,7 @@ module SensuCli
       msg = api.response(res.code, res.body, @api[:command])
       if res.code != '200'
         exit
-      elsif @format == "single"
+      elsif @format == 'single'
         Pretty.table(msg)
       else
         Pretty.print(msg)

data/lib/sensu-cli/cli.rb

@@ -10,10 +10,10 @@ module SensuCli
     EVENT_COMMANDS  = %w(list show delete)
     STASH_COMMANDS  = %w(list show delete create)
     AGG_COMMANDS    = %w(list show delete)
-    SIL_COMMANDS    = ""
-    RES_COMMANDS    = ""
-    INFO_COMMANDS   = ""
-    HEALTH_COMMANDS = ""
+    SIL_COMMANDS    = ''
+    RES_COMMANDS    = ''
+    INFO_COMMANDS   = ''
+    HEALTH_COMMANDS = ''
 
     CLIENT_BANNER = <<-EOS.gsub(/^ {10}/, '')
           ** Client Commands **
@@ -49,7 +49,6 @@ module SensuCli
           sensu-cli stash delete STASHPATH
           sensu-cli stash create PATH\n\r
         EOS
-        #apost '/stashes'
     AGG_BANNER = <<-EOS.gsub(/^ {10}/, '')
           ** Aggregate Commands **
           sensu-cli aggregate list (OPTIONS)
@@ -110,7 +109,7 @@ module SensuCli
     end
 
     def deep_merge(hash_one, hash_two)
-      hash_one.merge(hash_two) {|key, hash_one_item, hash_two_item| deep_merge(hash_one_item, hash_two_item)}
+      hash_one.merge(hash_two) { |key, hash_one_item, hash_two_item| deep_merge(hash_one_item, hash_two_item) }
     end
 
     def parser(cli)
@@ -120,7 +119,7 @@ module SensuCli
       end
     end
 
-    def explode_if_empty(opts,command)
+    def explode_if_empty(opts, command)
       explode(opts) if ARGV.empty? && command != 'list'
     end
 
@@ -129,172 +128,172 @@ module SensuCli
     end
 
     def client
-      opts = parser("CLIENT")
+      opts = parser('CLIENT')
       command = next_argv
-      explode_if_empty(opts,command)
+      explode_if_empty(opts, command)
       case command
       when 'list'
         p = Trollop::options do
-          opt :limit, "The number if clients to return", :short => "l", :type => :string
-          opt :offset, "The number of clients to offset before returning", :short => "o", :type => :string
-          opt :format, "Available formats; single (single line formatting)", :short => "f", :type => :string
+          opt :limit, 'The number if clients to return', :short => 'l', :type => :string
+          opt :offset, 'The number of clients to offset before returning', :short => 'o', :type => :string
+          opt :format, 'Available formats; single (single line formatting)', :short => 'f', :type => :string
         end
-        Trollop::die :format, "Available optional formats: single".color(:red) if p[:format] && p[:format] != "single"
-        Trollop::die :offset, "Offset depends on the limit option --limit ( -l )".color(:red) if p[:offset] && !p[:limit]
-        cli = {:command => 'clients', :method => 'Get', :fields => p}
+        Trollop::die :format, 'Available optional formats: single'.color(:red) if p[:format] && p[:format] != 'single'
+        Trollop::die :offset, 'Offset depends on the limit option --limit ( -l )'.color(:red) if p[:offset] && !p[:limit]
+        { :command => 'clients', :method => 'Get', :fields => p }
       when 'delete'
         p = Trollop::options
-        item = next_argv #the ARGV.shift needs to happen after Trollop::options to catch --help
-        deep_merge({:command => 'clients', :method => 'Delete', :fields => {:name => item}},{:fields => p})
+        item = next_argv # the ARGV.shift needs to happen after Trollop::options to catch --help
+        deep_merge({ :command => 'clients', :method => 'Delete', :fields => { :name => item } }, { :fields => p })
       when 'show'
         p = Trollop::options
         item = next_argv
-        deep_merge({:command => 'clients', :method => 'Get', :fields => {:name => item}},{:fields => p})
+        deep_merge({ :command => 'clients', :method => 'Get', :fields => { :name => item } }, { :fields => p })
       when 'history'
         p = Trollop::options
         item = next_argv
-        deep_merge({:command => 'clients', :method => 'Get', :fields => {:name => item, :history => true}},{:fields => p})
+        deep_merge({ :command => 'clients', :method => 'Get', :fields => { :name => item, :history => true } }, { :fields => p })
       else
         explode(opts)
       end
     end
 
     def info
-      parser("INFO")
+      parser('INFO')
       p = Trollop::options
-      cli = {:command => 'info', :method => 'Get', :fields => p}
+      { :command => 'info', :method => 'Get', :fields => p }
     end
 
     def health
-      opts = parser("HEALTH")
+      opts = parser('HEALTH')
       p = Trollop::options do
-        opt :consumers, "The minimum number of consumers", :short => "c", :type => :string, :required => true
-        opt :messages, "The maximum number of messages", :short => "m", :type => :string, :required => true
+        opt :consumers, 'The minimum number of consumers', :short => 'c', :type => :string, :required => true
+        opt :messages, 'The maximum number of messages', :short => 'm', :type => :string, :required => true
       end
-      cli = {:command => 'health', :method => 'Get', :fields => p}
+      { :command => 'health', :method => 'Get', :fields => p }
     end
 
     def check
-      opts = parser("CHECK")
+      opts = parser('CHECK')
       command = next_argv
-      explode_if_empty(opts,command)
+      explode_if_empty(opts, command)
       p = Trollop::options
       item = next_argv
       case command
       when 'list'
-        cli = {:command => 'checks', :method => 'Get', :fields => p}
+        { :command => 'checks', :method => 'Get', :fields => p }
       when 'show'
-        deep_merge({:command => 'checks', :method => 'Get', :fields => {:name => item}},{:fields => p})
+        deep_merge({ :command => 'checks', :method => 'Get', :fields => { :name => item } }, { :fields => p })
       when 'request'
-        ARGV.empty? ? explode(opts) : subscribers = next_argv.split(",")
-        deep_merge({:command => 'checks', :method => 'Post', :fields => {:check => item, :subscribers => subscribers}},{:fields => p})
+        ARGV.empty? ? explode(opts) : subscribers = next_argv.split(',')
+        deep_merge({ :command => 'checks', :method => 'Post', :fields => { :check => item, :subscribers => subscribers } }, { :fields => p })
       else
         explode(opts)
       end
     end
 
     def event
-      opts = parser("EVENT")
+      opts = parser('EVENT')
       command = next_argv
-      explode_if_empty(opts,command)
+      explode_if_empty(opts, command)
       case command
       when 'list'
         p = Trollop::options do
-          opt :format, "Available formats; single (single line formatting)", :short => "f", :type => :string
+          opt :format, 'Available formats; single (single line formatting)', :short => 'f', :type => :string
         end
-        Trollop::die :format, "Available optional formats: single".color(:red) if p[:format] && p[:format] != "single"
-        cli = {:command => 'events', :method => 'Get', :fields => p}
+        Trollop::die :format, 'Available optional formats: single'.color(:red) if p[:format] && p[:format] != 'single'
+        { :command => 'events', :method => 'Get', :fields => p }
       when 'show'
         p = Trollop::options do
-          opt :check, "Returns the check associated with the client", :short => "k", :type => :string
+          opt :check, 'Returns the check associated with the client', :short => 'k', :type => :string
         end
         item = next_argv
-        deep_merge({:command => 'events', :method => 'Get', :fields => {:client => item}},{:fields => p})
+        deep_merge({ :command => 'events', :method => 'Get', :fields => { :client => item } }, { :fields => p })
       when 'delete'
         p = Trollop::options
         item = next_argv
         check = next_argv
         explode(opts) if check == nil
-        deep_merge({:command => 'events', :method => 'Delete', :fields => {:client => item, :check => check}},{:fields => p})
+        deep_merge({ :command => 'events', :method => 'Delete', :fields => { :client => item, :check => check } }, { :fields => p })
       else
         explode(opts)
       end
     end
 
     def stash
-      opts = parser("STASH")
+      opts = parser('STASH')
       command = next_argv
-      explode_if_empty(opts,command)
+      explode_if_empty(opts, command)
       case command
       when 'list'
         p = Trollop::options do
-          opt :limit, "The number of stashes to return", :short => "l", :type => :string
-          opt :offset, "The number of stashes to offset before returning", :short => "o", :type => :string
+          opt :limit, 'The number of stashes to return', :short => 'l', :type => :string
+          opt :offset, 'The number of stashes to offset before returning', :short => 'o', :type => :string
         end
-        Trollop::die :offset, "Offset depends on the limit option --limit ( -l )".color(:red) if p[:offset] && !p[:limit]
-        cli = {:command => 'stashes', :method => 'Get', :fields => p}
+        Trollop::die :offset, 'Offset depends on the limit option --limit ( -l )'.color(:red) if p[:offset] && !p[:limit]
+        { :command => 'stashes', :method => 'Get', :fields => p }
       when 'show'
         p = Trollop::options
         item = next_argv
-        deep_merge({:command => 'stashes', :method => 'Get', :fields => {:path => item}},{:fields => p})
+        deep_merge({ :command => 'stashes', :method => 'Get', :fields => { :path => item } }, { :fields => p })
       when 'delete'
         p = Trollop::options
         item = next_argv
-        deep_merge({:command => 'stashes', :method => 'Delete', :fields => {:path => item}},{:fields => p})
+        deep_merge({ :command => 'stashes', :method => 'Delete', :fields => { :path => item } }, { :fields => p })
       when 'create'
         p = Trollop::options
         item = next_argv
-        deep_merge({:command => 'stashes', :method => 'Post', :fields => {:create => true, :create_path => item}},{:fields => p})
+        deep_merge({ :command => 'stashes', :method => 'Post', :fields => { :create => true, :create_path => item } }, { :fields => p })
       else
         explode(opts)
       end
     end
 
     def aggregate
-      opts = parser("AGG")
+      opts = parser('AGG')
       command = next_argv
-      explode_if_empty(opts,command)
+      explode_if_empty(opts, command)
       case command
       when 'list'
         p = Trollop::options
-        cli = {:command => 'aggregates', :method => 'Get', :fields => p}
+        { :command => 'aggregates', :method => 'Get', :fields => p }
       when 'show'
         p = Trollop::options do
-          opt :id, "The id of the check issued.", :short=>"i", :type => :integer
-          opt :limit, "The number of aggregates to return", :short => "l", :type => :string
-          opt :offset, "The number of aggregates to offset before returning", :short => "o", :type => :string
-          #opt :results, "Include the check results", :short => "r", :type => :boolean
+          opt :id, 'The id of the check issued.', :short => 'i', :type => :integer
+          opt :limit, 'The number of aggregates to return', :short => 'l', :type => :string
+          opt :offset, 'The number of aggregates to offset before returning', :short => 'o', :type => :string
+          # opt :results, 'Include the check results', :short => 'r', :type => :boolean
         end
-        Trollop::die :offset, "Offset depends on the limit option --limit ( -l )".color(:red) if p[:offset] && !p[:limit]
+        Trollop::die :offset, 'Offset depends on the limit option --limit ( -l )'.color(:red) if p[:offset] && !p[:limit]
         item = next_argv
-        deep_merge({:command => 'aggregates', :method => 'Get', :fields => {:check => item}},{:fields => p})
+        deep_merge({ :command => 'aggregates', :method => 'Get', :fields => { :check => item } }, { :fields => p })
       when 'delete'
         p = Trollop::options
         item = next_argv
-        deep_merge({:command => 'aggregates', :method => 'Delete', :fields => {:check => item}},{:fields => p})
+        deep_merge({ :command => 'aggregates', :method => 'Delete', :fields => { :check => item } }, { :fields => p })
       else
         explode(opts)
       end
     end
 
     def silence
-      opts = parser("SIL")
+      opts = parser('SIL')
       p = Trollop::options do
-        opt :check, "The check to silence (requires --client)", :short => 'k', :type => :string
-        opt :reason, "The reason this check/node is being silenced", :short => 'r', :type => :string
-        opt :expires, "The number of minutes the silenced event is valid (must use with check-stashes plugin)", :short => 'e', :type => :integer
+        opt :check, 'The check to silence (requires --client)', :short => 'k', :type => :string
+        opt :reason, 'The reason this check/node is being silenced', :short => 'r', :type => :string
+        opt :expires, 'The number of minutes the silenced event is valid (must use with check-stashes plugin)', :short => 'e', :type => :integer
       end
       command = next_argv
       explode(opts) if command == nil
-      deep_merge({:command => 'silence', :method => 'Post', :fields => {:client => command}},{:fields => p})
+      deep_merge({ :command => 'silence', :method => 'Post', :fields => { :client => command } }, { :fields => p })
     end
 
     def resolve
-      opts = parser("RES")
+      opts = parser('RES')
       command = next_argv
       p = Trollop::options
       ARGV.empty? ? explode(opts) : check = next_argv
-      deep_merge({:command => 'resolve', :method => 'Post', :fields => {:client => command, :check => check}},{:fields => p})
+      deep_merge({ :command => 'resolve', :method => 'Post', :fields => { :client => command, :check => check } }, { :fields => p })
     end
 
   end

data/lib/sensu-cli/editor.rb

@@ -5,7 +5,7 @@ module SensuCli
   class Editor
 
     def create_stash(create_path)
-      file = temp_file({:path => create_path, :content => {:timestamp => Time.now.to_i }})
+      file = temp_file({ :path => create_path, :content => { :timestamp => Time.now.to_i } })
       edit(file)
     end
 
@@ -15,7 +15,7 @@ module SensuCli
       begin
         JSON.parse(File.read(file))
       rescue JSON::ParserError
-        puts "The stash you created has Invalid JSON."
+        puts 'The stash you created has Invalid JSON.'
         exit
       end
     end

data/lib/sensu-cli/path.rb

@@ -2,15 +2,15 @@ module SensuCli
   class PathCreator
 
     def clients(cli)
-      path = "/clients"
+      path = '/clients'
       path << "/#{cli[:fields][:name]}" if cli[:fields][:name]
-      path << "/history" if cli[:fields][:history]
+      path << '/history' if cli[:fields][:history]
       path << pagination(cli)
       respond(path)
     end
 
     def info(cli)
-      path = "/info"
+      path = '/info'
       respond(path)
     end
 
@@ -24,53 +24,53 @@ module SensuCli
         e = Editor.new
         payload = e.create_stash(cli[:fields][:create_path]).to_json
       end
-      path = "/stashes"
+      path = '/stashes'
       path << "/#{cli[:fields][:path]}" if cli[:fields][:path]
       path << pagination(cli)
-      respond(path,payload)
+      respond(path, payload)
     end
 
     def checks(cli)
       if cli[:fields][:name]
         path = "/check/#{cli[:fields][:name]}"
       elsif cli[:fields][:subscribers]
-        payload = {:check => cli[:fields][:check],:subscribers => cli[:fields][:subscribers]}.to_json
-        path = "/check/request"
+        payload = { :check => cli[:fields][:check], :subscribers => cli[:fields][:subscribers] }.to_json
+        path = '/check/request'
       else
-        path = "/checks"
+        path = '/checks'
       end
-      respond(path,payload)
+      respond(path, payload)
     end
 
     def events(cli)
-      path = "/events"
+      path = '/events'
       path << "/#{cli[:fields][:client]}" if cli[:fields][:client]
       path << "/#{cli[:fields][:check]}" if cli[:fields][:check]
       respond(path)
     end
 
     def resolve(cli)
-      payload = {:client => cli[:fields][:client], :check => cli[:fields][:check]}.to_json
-      path = "/event/resolve"
-      respond(path,payload)
+      payload = { :client => cli[:fields][:client], :check => cli[:fields][:check] }.to_json
+      path = '/event/resolve'
+      respond(path, payload)
     end
 
     def silence(cli)
-      payload = {:timestamp => Time.now.to_i}
-      payload.merge!({:reason => cli[:fields][:reason]}) if cli[:fields][:reason]
+      payload = { :timestamp => Time.now.to_i }
+      payload.merge!({ :reason => cli[:fields][:reason] }) if cli[:fields][:reason]
       if cli[:fields][:expires]
         expires = Time.now.to_i + (cli[:fields][:expires] * 60)
-        payload.merge!({:expires => expires})
+        payload.merge!({ :expires => expires })
       end
       payload = payload.to_json
-      path = "/stashes/silence"
+      path = '/stashes/silence'
       path << "/#{cli[:fields][:client]}" if cli[:fields][:client]
       path << "/#{cli[:fields][:check]}" if cli[:fields][:check]
-      respond(path,payload)
+      respond(path, payload)
     end
 
     def aggregates(cli)
-      path = "/aggregates"
+      path = '/aggregates'
       path << "/#{cli[:fields][:check]}" if cli[:fields][:check]
       path << "/#{cli[:fields][:id]}" if cli[:fields][:id]
       path << pagination(cli)
@@ -83,7 +83,7 @@ module SensuCli
       elsif cli[:fields].has_key?(:limit)
         page = "?limit=#{cli[:fields][:limit]}"
       else
-        page = ""
+        page = ''
       end
     end
 
@@ -91,8 +91,8 @@ module SensuCli
       puts "Path method: #{method_name} does not exist. "
     end
 
-    def respond(path,payload=false)
-      {:path => path, :payload => payload}
+    def respond(path, payload = false)
+      { :path => path, :payload => payload }
     end
 
   end

data/lib/sensu-cli/pretty.rb

@@ -6,14 +6,14 @@ module SensuCli
     def self.print(res)
       if !res.empty?
         if res.is_a?(Hash)
-          res.each do |key,value|
+          res.each do |key, value|
             puts "#{key}:  ".color(:cyan) + "#{value}".color(:green)
           end
         elsif res.is_a?(Array)
           res.each do |item|
-            puts "-------".color(:yellow)
+            puts '-------'.color(:yellow)
             if item.is_a?(Hash)
-              item.each do |key,value|
+              item.each do |key, value|
                 puts "#{key}:  ".color(:cyan) + "#{value}".color(:green)
               end
             else
@@ -22,7 +22,7 @@ module SensuCli
           end
         end
       else
-        puts "no values for this request".color(:cyan)
+        puts 'no values for this request'.color(:cyan)
       end
     end
 
@@ -32,36 +32,36 @@ module SensuCli
     end
 
     def self.clean(thing)
-      thing = thing.gsub("\n",'/\n') if thing.is_a?(String)
+      thing = thing.gsub("\n", '/\n') if thing.is_a?(String)
       thing
     end
 
     def self.table(res)
       if !res.empty?
         if res.is_a?(Array)
-          keys = res.map{|item| item.keys}.flatten.uniq.sort
+          keys = res.map { |item| item.keys }.flatten.uniq.sort
 
           # Remove fields with spaces (breaks awkage)
           keys.select! do |key|
-            res.none?{|item| item[key].to_s.include?(' ')}
+            res.none? { |item| item[key].to_s.include?(' ') }
           end
 
           # Find max value lengths
           value_lengths = {}
           keys.each do |key|
-            max_value_length = res.map{|item| item[key].to_s.length}.max
+            max_value_length = res.map { |item| item[key].to_s.length }.max
             value_lengths[key] = [max_value_length, key.length].max
           end
 
           # Print header
-          format = keys.map {|key| "%-#{value_lengths[key]}s"}.join(' ')
+          format = keys.map { |key| "%-#{value_lengths[key]}s" }.join(' ')
           puts sprintf(format, *keys)
 
           # Print value rows
           res.each do |item|
             if item.is_a?(Hash)
-              values = keys.map {|key| item[key]}
-              format = keys.map {|key| "%-#{value_lengths[key]}s"}.join(' ')
+              values = keys.map { |key| item[key] }
+              format = keys.map { |key| "%-#{value_lengths[key]}s" }.join(' ')
               puts sprintf(format, *values)
             else
               puts item.to_s.color(:cyan)
@@ -69,7 +69,7 @@ module SensuCli
           end
         end
       else
-        puts "no values for this request".color(:cyan)
+        puts 'no values for this request'.color(:cyan)
       end
     end
 

data/lib/sensu-cli/settings.rb

@@ -9,9 +9,9 @@ module SensuCli
       !File.readable?(file) ? false : true
     end
 
-    def create(directory,file)
+    def create(directory, file)
       FileUtils.mkdir_p(directory) if !File.directory?(directory)
-      FileUtils.cp(File.join(File.dirname(__FILE__),"../../settings.example.rb"), file)
+      FileUtils.cp(File.join(File.dirname(__FILE__), '../../settings.example.rb'), file)
       puts "We created the configuration file for you at #{file}.  You can also place this in /etc/sensu/sensu-cli. Edit the settings as needed.".color(:red)
       exit
     end

data/lib/sensu-cli/version.rb

@@ -1,3 +1,3 @@
 module SensuCli
-    VERSION = '0.2.1'
+    VERSION = '0.2.2'
 end

data/settings.example.rb

@@ -1,3 +1,3 @@
-host "127.0.0.1"
-port "4567"
+host '127.0.0.1'
+port '4567'
 ssl  false

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sensu-cli
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors: