sensu-cli-compat 0.6.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: 93c6437ccfa0bfec4c2ef12ae2fc7f795da9ea2f
+  data.tar.gz: 8d1b4470a3bb9248737fb91dc76eb9abcd106b00
+SHA512: 
+  metadata.gz: ba28bd44a8487cf939f6f23892b6af8bb0186ee0cd790a6d230f5d30fcd6a3a15555961deb92c59ef9e67df9dde32fa617002c97d224bb635028c09458b8e9f0
+  data.tar.gz: a45e1623c30498a7114ab72194b87c6bb3ea826a439bb7a8607158e25593a1bb4cf72d8f6bc412218c1ca12a8355c83d0d0070b208b01ca4813028be4c057e4d

data/README.md

@@ -0,0 +1,127 @@
+sensu-cli
+=========
+```
+#
+# Welcome to the sensu-cli.
+#          ______
+#       .-'      '-.
+#     .'     __     '.
+#    /      /  \      \
+#    ------------------
+#            /\
+#           '--'
+#         SENSU-CLI
+#
+```
+A sensu-cli for interacting with the sensu api.
+
+What is Sensu? http://sensuapp.org/
+
+Features
+--------
+* API interaction with info, health, stashes, events, clients, aggregates and checks
+* Resolve Events
+* Silence clients and checks
+* Get Requests (get clients, stashes, events, etc.)
+* Delete Requests (delete clients, stashes, aggregates and events)
+
+
+Usage and Configuration
+-----------------------
+* gem install sensu-cli
+
+* There is one settings file for host, port, ssl, and HTTP timeout that lives in your user directory ~/.sensu/settings.rb.  You can alternatively place this in /etc/sensu/sensu-cli/settings.rb.
+
+````
+host  "127.0.0.1"
+port  "4567"
+ssl   false
+read_timeout 20
+open_timeout 20
+````
+This format was chosen so you can do some ENV magic via your profile and setting up an alias. For details see the [wiki](https://github.com/agent462/sensu-cli/wiki)
+
+* All Configuration Settings   
+`host` String - Required   
+`port` String/Integer - Required   
+`ssl`  Boolean - Optional - Defaults False   
+`read_timeout` Integer - Optional - Default 15 (seconds)   
+`open_timeout` Integer - Optional - Default 5 (seconds)   
+`pretty_colors` Boolean - Optional - Default True    
+`proxy_address` String - Optional    
+`proxy_port` Integer - Optional    
+`user` String - Optional   
+`password` String - Optional   
+
+Examples
+-----------
+````
+Available subcommands: (for details, sensu SUB-COMMAND --help)
+
+** Aggregate Commands **
+sensu-cli aggregate list (OPTIONS)
+sensu-cli aggregate show CHECK (OPTIONS)
+sensu-cli aggregate delete CHECK
+
+** Check Commands **
+sensu-cli check list
+sensu-cli check show CHECK
+sensu-cli check request CHECK SUB1,SUB2
+
+** Client Commands **
+sensu-cli client list (OPTIONS)
+sensu-cli client show NODE
+sensu-cli client delete NODE
+sensu-cli client history NODE
+
+** Event Commands **
+sensu-cli event list
+sensu-cli event show NODE (OPTIONS)
+sensu-cli event delete NODE CHECK
+
+** Health Commands **
+sensu-cli health (OPTIONS)
+
+** Info Commands **
+sensu-cli info
+
+** Silence Commands **
+sensu-cli silence NODE (OPTIONS)
+
+** Stash Commands **
+sensu-cli stash list (OPTIONS)
+sensu-cli stash show STASHPATH
+sensu-cli stash delete STASHPATH
+sensu-cli stash create PATH
+
+** Resolve Commands **
+sensu-cli resolve NODE CHECK
+
+  --version, -v:   Print version and exit
+     --help, -h:   Show this message
+````
+
+Contributions
+-------------
+Please provide a pull request.  I'm an ops guy, not a developer, so if you're submitting code cleanup, all I ask is that you explain the improvement so I can learn.
+
+
+License and Author
+==================
+I'm releasing this under the MIT or Apache 2.0 license.  You pick.
+
+Author:: Bryan Brandau <agent462@gmail.com>
+
+Copyright:: 2013, Bryan Brandau
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/bin/sensu

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib' unless $LOAD_PATH.include?(File.dirname(__FILE__) + '/../lib/')
+
+require 'sensu-cli'
+sensu = SensuCli::Base.new
+sensu.setup

data/bin/sensu-cli

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib' unless $LOAD_PATH.include?(File.dirname(__FILE__) + '/../lib/')
+
+require 'sensu-cli'
+sensu = SensuCli::Base.new
+sensu.setup

data/lib/sensu-cli.rb

@@ -0,0 +1,16 @@
+require 'sensu-cli/settings'
+require 'sensu-cli/cli'
+require 'sensu-cli/editor'
+require 'sensu-cli/pretty'
+require 'sensu-cli/path.rb'
+require 'sensu-cli/api.rb'
+require 'sensu-cli/base.rb'
+require 'sensu-cli/version.rb'
+require 'sensu-cli/filter.rb'
+
+module SensuCli
+  def self.die(code = 0, msg = nil)
+    at_exit { puts msg }
+    Kernel.exit(code)
+  end
+end

data/lib/sensu-cli/api.rb

@@ -0,0 +1,62 @@
+require 'net/https'
+require 'json'
+require 'rainbow/ext/string'
+
+module SensuCli
+  class Api
+    def request(opts)
+      http = Net::HTTP.new(opts[:host], opts[:port], opts[:proxy_address],
+                           opts[:proxy_port])
+      http.read_timeout = opts[:read_timeout]
+      http.open_timeout = opts[:open_timeout]
+      if opts[:ssl]
+        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], proxy_header)
+      when 'Delete'
+        req =  Net::HTTP::Delete.new(opts[:path], proxy_header)
+      when 'Post'
+        req =  Net::HTTP::Post.new(opts[:path], 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
+        SensuCli::die(1, 'HTTP request has timed out.'.color(:red))
+      rescue StandardError => e
+        SensuCli::die(1, "An HTTP error occurred.  Check your settings. #{e}".color(:red))
+      end
+    end
+
+    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'
+      when '202'
+        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'
+      when '400'
+        puts 'The payload is malformed.'.color(:red)
+      when '401'
+        puts 'The request requires user authentication.'.color(:red)
+      when '404'
+        puts 'The item did not exist.'.color(:cyan)
+      else
+        if command == 'health'
+          puts 'Sensu is not healthy.'.color(:red)
+        else
+          puts "There was an error while trying to complete your request. Response code: #{code}".color(:red)
+        end
+      end
+    end
+  end
+end

data/lib/sensu-cli/base.rb

@@ -0,0 +1,66 @@
+module SensuCli
+  class Base
+    def setup
+      @cli = Cli.new.global
+      settings
+      api_path(@cli)
+      make_call
+    end
+
+    def settings
+      directory = "#{Dir.home}/.sensu"
+      file = "#{directory}/settings.rb"
+      alt = '/etc/sensu/sensu-cli/settings.rb'
+      settings = Settings.new
+      if settings.file?(file)
+        SensuCli::Config.from_file(file)
+      elsif settings.file?(alt)
+        SensuCli::Config.from_file(alt)
+      else
+        settings.create(directory, file)
+      end
+      Rainbow.enabled = Config.pretty_colors == false ? false : true
+    end
+
+    def api_path(cli)
+      p = PathCreator.new
+      p.respond_to?(cli[:command]) ? path = p.send(cli[:command], cli) : SensuCli::die(1, 'Something Bad Happened')
+      @api = { :path => path[:path], :method => cli[:method], :command => cli[:command], :payload => (path[:payload] || false) }
+    end
+
+    def make_call
+      opts = {
+        :path => @api[:path],
+        :method => @api[:method],
+        :payload => @api[:payload],
+        :host => Config.host,
+        :port => Config.port,
+        :ssl => Config.ssl || false,
+        :user => Config.user || nil,
+        :read_timeout => Config.read_timeout || 15,
+        :open_timeout => Config.open_timeout || 5,
+        :password => Config.password || nil,
+        :proxy_address => Config.proxy_address || nil,
+        :proxy_port => Config.proxy_port || nil
+      }
+      api = Api.new
+      res = api.request(opts)
+      msg = api.response(res.code, res.body, @api[:command])
+      msg = Filter.new(@cli[:fields][:filter]).process(msg) if @cli[:fields][:filter]
+      endpoint = @api[:command]
+      if res.code != '200'
+        SensuCli::die(0)
+      elsif @cli[:fields][:format] == 'single'
+        Pretty.single(msg, endpoint)
+      elsif @cli[:fields][:format] == 'table'
+        fields = nil || @cli[:fields][:fields]
+        Pretty.table(msg, endpoint, fields)
+      elsif @cli[:fields][:format] == 'json'
+        Pretty.json(msg)
+      else
+        Pretty.print(msg, endpoint)
+      end
+      Pretty.count(msg) unless @cli[:fields][:format] == 'table' or @cli[:fields][:format] == 'json'
+    end
+  end
+end

data/lib/sensu-cli/cli.rb

@@ -0,0 +1,313 @@
+require 'trollop'
+require 'sensu-cli/version'
+require 'rainbow/ext/string'
+
+module SensuCli
+  class Cli # rubocop:disable ClassLength
+    SUB_COMMANDS    = %w(info client check event stash aggregate silence resolve health)
+    CLIENT_COMMANDS = %w(list show delete history)
+    CHECK_COMMANDS  = %w(list show request)
+    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 = ''
+
+    CLIENT_BANNER = <<-EOS.gsub(/^ {10}/, '')
+          ** Client Commands **
+          sensu-cli client list (OPTIONS)
+          sensu-cli client show NODE
+          sensu-cli client delete NODE
+          sensu-cli client history NODE\n\r
+        EOS
+    INFO_BANNER = <<-EOS.gsub(/^ {10}/, '')
+          ** Info Commands **
+          sensu-cli info\n\r
+        EOS
+    HEALTH_BANNER = <<-EOS.gsub(/^ {10}/, '')
+          ** Health Commands **
+          sensu-cli health (OPTIONS)\n\r
+        EOS
+    CHECK_BANNER = <<-EOS.gsub(/^ {10}/, '')
+          ** Check Commands **
+          sensu-cli check list
+          sensu-cli check show CHECK
+          sensu-cli check request CHECK SUB1,SUB2\n\r
+        EOS
+    EVENT_BANNER = <<-EOS.gsub(/^ {10}/, '')
+          ** Event Commands **
+          sensu-cli event list (OPTIONS)
+          sensu-cli event show NODE (OPTIONS)
+          sensu-cli event delete NODE CHECK\n\r
+        EOS
+    STASH_BANNER = <<-EOS.gsub(/^ {10}/, '')
+          ** Stash Commands **
+          sensu-cli stash list (OPTIONS)
+          sensu-cli stash show STASHPATH
+          sensu-cli stash delete STASHPATH
+          sensu-cli stash create PATH\n\r
+        EOS
+    AGG_BANNER = <<-EOS.gsub(/^ {10}/, '')
+          ** Aggregate Commands **
+          sensu-cli aggregate list (OPTIONS)
+          sensu-cli aggregate show CHECK (OPTIONS)
+          sensu-cli aggregate delete CHECK\n\r
+        EOS
+    SIL_BANNER = <<-EOS.gsub(/^ {10}/, '')
+          ** Silence Commands **
+          sensu-cli silence NODE (OPTIONS)\n\r
+        EOS
+    RES_BANNER = <<-EOS.gsub(/^ {10}/, '')
+          ** Resolve Commands **
+          sensu-cli resolve NODE CHECK\n\r
+        EOS
+
+    def global
+      global_opts = Trollop::Parser.new do
+        version "sensu-cli version: #{SensuCli::VERSION}"
+        banner <<-'EOS'.gsub(/^ {10}/, '')
+          #
+          # Welcome to the sensu-cli.
+          #          ______
+          #       .-'      '-.
+          #     .'     __     '.
+          #    /      /  \      \
+          #    ------------------
+          #            /\
+          #           '--'
+          #         SENSU-CLI
+          #
+        EOS
+        banner "\n\rAvailable subcommands: (for details, sensu-cli SUB-COMMAND --help)\n\r"
+        banner AGG_BANNER
+        banner CHECK_BANNER
+        banner CLIENT_BANNER
+        banner EVENT_BANNER
+        banner HEALTH_BANNER
+        banner INFO_BANNER
+        banner SIL_BANNER
+        banner STASH_BANNER
+        banner RES_BANNER
+        stop_on SUB_COMMANDS
+      end
+
+      Trollop::with_standard_exception_handling global_opts do
+        global_opts.parse ARGV
+        raise Trollop::HelpNeeded if ARGV.empty? # show help screen
+      end
+
+      cmd = next_argv
+      self.respond_to?(cmd) ? send(cmd) : explode(global_opts)
+    end
+
+    def explode(opts)
+      Trollop::with_standard_exception_handling opts do
+        raise Trollop::HelpNeeded # show help screen
+      end
+    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) }
+    end
+
+    def parser(cli)
+      Trollop::Parser.new do
+        banner Cli.const_get("#{cli}_BANNER")
+        stop_on Cli.const_get("#{cli}_COMMANDS")
+      end
+    end
+
+    def explode_if_empty(opts, command)
+      explode(opts) if ARGV.empty? && command != 'list'
+    end
+
+    def next_argv
+      ARGV.shift
+    end
+
+    def client # rubocop:disable MethodLength
+      opts = parser('CLIENT')
+      command = next_argv
+      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, table, json', :short => 'f', :type => :string
+          opt :fields, 'Fields for table ouput: -F name,address,subscriptions', :short => 'F', :type => :string
+          opt :filter, 'Field and value to filter on: name,graphite', :type => :string
+        end
+        Trollop::die :format, 'Available optional formats: single, table, json'.color(:red) if p[:format] != 'table' && p[:format] != 'single' && p[:format] != 'json' && p[:format]
+        Trollop::die :fields, 'Fields must be used in conjunction with --format table'.color(:red) if p[:format] != 'table' && p[:fields]
+        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 })
+      when 'show'
+        p = Trollop::options
+        item = next_argv
+        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 })
+      else
+        explode(opts)
+      end
+    end
+
+    def info
+      parser('INFO')
+      p = Trollop::options
+      { :command => 'info', :method => 'Get', :fields => p }
+    end
+
+    def health
+      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
+      end
+      { :command => 'health', :method => 'Get', :fields => p }
+    end
+
+    def check
+      opts = parser('CHECK')
+      command = next_argv
+      explode_if_empty(opts, command)
+      item = next_argv
+      case command
+      when 'list'
+        p = Trollop::options do
+          opt :filter, 'Field and value to filter on: command,procs', :type => :string
+        end
+        { :command => 'checks', :method => 'Get', :fields => p }
+      when 'show'
+        p = Trollop::options
+        deep_merge({ :command => 'checks', :method => 'Get', :fields => { :name => item } }, { :fields => p })
+      when 'request'
+        p = Trollop::options
+        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')
+      command = next_argv
+      explode_if_empty(opts, command)
+      case command
+      when 'list'
+        p = Trollop::options do
+          opt :filter, 'Field and value to filter on: client,graphite (use "name" as field for client or event name)', :type => :string
+          opt :format, 'Available formats; single, table, json', :short => 'f', :type => :string
+        end
+        Trollop::die :format, 'Available optional formats: single, table, json'.color(:red) if p[:format] != 'table' && p[:format] != 'single' && p[:format] != 'json' && p[:format]
+        { :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
+        end
+        item = next_argv
+        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 })
+      else
+        explode(opts)
+      end
+    end
+
+    def stash
+      opts = parser('STASH')
+      command = next_argv
+      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 :format, 'Available formats; single, table, json', :short => 'f', :type => :string
+          opt :filter, 'Field and value to filter on: path,graphite', :type => :string
+        end
+        Trollop::die :offset, 'Offset depends on the limit option --limit ( -l )'.color(:red) if p[:offset] && !p[:limit]
+        Trollop::die :format, 'Available optional formats: single, table, json'.color(:red) if p[:format] != 'table' && p[:format] != 'single' && p[:format] != 'json' && p[:format]
+        { :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 })
+      when 'delete'
+        p = Trollop::options
+        item = next_argv
+        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 })
+      else
+        explode(opts)
+      end
+    end
+
+    def aggregate
+      opts = parser('AGG')
+      command = next_argv
+      explode_if_empty(opts, command)
+      case command
+      when 'list'
+        p = Trollop::options do
+          opt :filter, 'Field and value to filter on: issued,1399505890', :type => :string
+        end
+        { :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
+        end
+        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 })
+      when 'delete'
+        p = Trollop::options
+        item = next_argv
+        deep_merge({ :command => 'aggregates', :method => 'Delete', :fields => { :check => item } }, { :fields => p })
+      else
+        explode(opts)
+      end
+    end
+
+    def silence
+      opts = parser('SIL')
+      p = Trollop::options do
+        opt :check, 'The check to silence', :short => 'k', :type => :string
+        opt :owner, 'The owner of the stash', :short => 'o', :type => :string
+        opt :reason, 'The reason this check/node is being silenced', :short => 'r', :type => :string
+        opt :expire, 'The number of seconds the silenced event is valid', :short => 'e', :type => :integer
+      end
+      command = next_argv
+      explode(opts) if command.nil?
+      deep_merge({ :command => 'silence', :method => 'Post', :fields => { :client => command } }, { :fields => p })
+    end
+
+    def resolve
+      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 })
+    end
+  end
+end

data/lib/sensu-cli/editor.rb

@@ -0,0 +1,28 @@
+require 'json'
+require 'tempfile'
+
+module SensuCli
+  class Editor
+    def create_stash(create_path)
+      file = temp_file(:path => create_path, :content => { :timestamp => Time.now.to_i })
+      edit(file)
+    end
+
+    def edit(file)
+      editor = ENV['EDITOR'] ? ENV['EDITOR'] : 'vi'
+      system("#{editor} #{file}")
+      begin
+        JSON.parse(File.read(file))
+      rescue JSON::ParserError
+        SensuCli::die(1, 'The stash you created has invalid JSON.')
+      end
+    end
+
+    def temp_file(template)
+      file = Tempfile.new('sensu')
+      file.write(JSON.pretty_generate(template))
+      file.close
+      file.path
+    end
+  end
+end

data/lib/sensu-cli/filter.rb

@@ -0,0 +1,39 @@
+module SensuCli
+  class Filter
+    attr_reader :filter
+
+    def initialize(filter_data)
+      filter_split(filter_data)
+    end
+
+    def filter_split(filter)
+      @filter = filter.sub(' ', '').split(',')
+    end
+
+    def match?(data)
+      data.to_s.include? filter[1]
+    end
+
+    def inspect_hash(data)
+      data.any? do |key, value|
+        if value.is_a?(Array)
+          match?(value) if key == filter[0]
+        elsif value.is_a?(Hash)
+          process(value)
+        else
+          match?(value) if key == filter[0]
+        end
+      end
+    end
+
+    def process(data)
+      if data.is_a?(Array)
+        data.select do |value|
+          process(value)
+        end
+      elsif data.is_a?(Hash)
+        inspect_hash(data)
+      end
+    end
+  end
+end

data/lib/sensu-cli/path.rb

@@ -0,0 +1,96 @@
+module SensuCli
+  class PathCreator
+    def clients(cli)
+      path = '/clients'
+      path << "/#{cli[:fields][:name]}" if cli[:fields][:name]
+      path << '/history' if cli[:fields][:history]
+      path << pagination(cli)
+      respond(path)
+    end
+
+    def info(*)
+      path = '/info'
+      respond(path)
+    end
+
+    def health(cli)
+      path = "/health?consumers=#{cli[:fields][:consumers]}&messages=#{cli[:fields][:messages]}"
+      respond(path)
+    end
+
+    def stashes(cli)
+      if cli[:fields][:create]
+        e = Editor.new
+        payload = e.create_stash(cli[:fields][:create_path]).to_json
+      end
+      path = '/stashes'
+      path << "/#{cli[:fields][:path]}" if cli[:fields][:path]
+      path << pagination(cli)
+      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 = '/request'
+      else
+        path = '/checks'
+      end
+      respond(path, payload)
+    end
+
+    def events(cli)
+      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 = '/resolve'
+      respond(path, payload)
+    end
+
+    def silence(cli)
+      content = { :timestamp => Time.now.to_i }
+      content.merge!(:owner => cli[:fields][:owner]) if cli[:fields][:owner]
+      content.merge!(:reason => cli[:fields][:reason]) if cli[:fields][:reason]
+      payload = { :content =>  content }
+      payload.merge!(:expire => cli[:fields][:expire].to_i) if cli[:fields][:expire]
+      silence_path = 'silence'
+      silence_path << "/#{cli[:fields][:client]}" if cli[:fields][:client]
+      silence_path << "/#{cli[:fields][:check]}" if cli[:fields][:check]
+      payload = payload.merge!(:path => silence_path).to_json
+      respond('/stashes', payload)
+    end
+
+    def aggregates(cli)
+      path = '/aggregates'
+      path << "/#{cli[:fields][:check]}" if cli[:fields][:check]
+      path << "/#{cli[:fields][:id]}" if cli[:fields][:id]
+      path << pagination(cli)
+      respond(path)
+    end
+
+    def pagination(cli)
+      if cli[:fields].key?(:limit) && cli[:fields].key?(:offset)
+        "?limit=#{cli[:fields][:limit]}&offset=#{cli[:fields][:offset]}"
+      elsif cli[:fields].key?(:limit)
+        "?limit=#{cli[:fields][:limit]}"
+      else
+        ''
+      end
+    end
+
+    def method_missing(method_name, *_args)
+      puts "Path method: #{method_name} does not exist. "
+    end
+
+    def respond(path, payload = false)
+      { :path => path, :payload => payload }
+    end
+  end
+end

data/lib/sensu-cli/pretty.rb

@@ -0,0 +1,136 @@
+require 'rainbow/ext/string'
+require 'hirb'
+require 'json'
+require 'erubis'
+
+module SensuCli
+  class Pretty
+    class << self
+      def print(res, endpoint = nil)
+        return no_values if res.empty?
+        case endpoint
+        when 'events'
+          template = File.read(File.expand_path(File.join(File.dirname(__FILE__), 'templates/event.erb')))
+          renderer = Erubis::Eruby.new(template)
+          res.each do |event|
+            puts renderer.result(event)
+          end
+          return
+        end
+        if res.is_a?(Hash)
+          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)
+            if item.is_a?(Hash)
+              item.each do |key, value|
+                puts "#{key}:  ".color(:cyan) + "#{value}".color(:green)
+              end
+            else
+              puts item.to_s.color(:cyan)
+            end
+          end
+        end
+      end
+
+      def json(res)
+        puts JSON.pretty_generate(res)
+      end
+
+      def count(res)
+        res.is_a?(Hash) ? count = res.length : count = res.count
+        puts "#{count} total items".color(:yellow) if count
+      end
+
+      def clean(thing)
+        thing = thing.gsub("\n", '/\n') if thing.is_a?(String)
+        thing
+      end
+
+      def no_values
+        puts 'no values for this request'.color(:cyan)
+      end
+
+      def single(res, endpoint = nil)
+        return no_values if res.empty?
+        case endpoint
+        when 'events'
+          res = event_data(res)
+        end
+        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?(' ') }
+        end
+
+        # Find max value lengths
+        value_lengths = {}
+        keys.each do |key|
+          max_value_length = res.map { |item| item[key].to_s.length }.max
+          value_lengths[key] = [max_value_length, key.length].max
+        end
+
+        # Print header
+        lengths = keys.map { |key| "%-#{value_lengths[key]}s" }.join(' ')
+        puts format(lengths, *keys)
+
+        # Print value rows
+        res.each do |item|
+          if item.is_a?(Hash)
+            values = keys.map { |key| item[key] }
+            puts format(lengths, *values)
+          else
+            puts item.to_s.color(:cyan)
+          end
+        end
+      end
+
+      def parse_fields(fields)
+        fields.split(',')
+      end
+
+      def event_data(res)
+        events = []
+        res.each do |event|
+          events << {
+            'client' => event['client']['name'],
+            'address' => event['client']['address'],
+            'check' => event['check']['name'],
+            'interval' => event['check']['interval'],
+            'occurrences' => event['occurrences'],
+            'status' => event['check']['status'],
+            'handlers' => event['check']['handlers'],
+            'issued' => event['check']['issued'],
+            'executed' => event['check']['executed'],
+            'output' => event['check']['output'].rstrip
+          }
+        end
+        events
+      end
+
+      def table(res, endpoint = nil, fields = nil)
+        return no_values if res.empty?
+        case endpoint
+        when 'events'
+          keys = %w(check client address interval occurrences status handlers issued executed output)
+          render_table(event_data(res), keys)
+        else
+          if fields
+            keys = parse_fields(fields)
+          else
+            keys = res.map { |item| item.keys }.flatten.uniq
+          end
+          render_table(res, keys)
+        end
+      end
+
+      def render_table(data, keys)
+        terminal_size = Hirb::Util.detect_terminal_size
+        puts Hirb::Helpers::AutoTable.render(data, :max_width => terminal_size[0], :fields => keys)
+      end
+    end
+  end
+end

data/lib/sensu-cli/settings.rb

@@ -0,0 +1,21 @@
+require 'fileutils'
+require 'mixlib/config'
+require 'rainbow/ext/string'
+
+module SensuCli
+  class Settings
+    def file?(file)
+      !File.readable?(file) ? false : true # rubocop:disable FavorUnlessOverNegatedIf
+    end
+
+    def create(directory, file)
+      FileUtils.mkdir_p(directory) unless File.directory?(directory)
+      FileUtils.cp(File.join(File.dirname(__FILE__), '../../settings.example.rb'), file)
+      SensuCli::die(0, "We created the configuration file for you at #{file}.  You can also place this in /etc/sensu/sensu-cli/settings.rb. Edit the settings as needed.".color(:red))
+    end
+  end
+
+  class Config
+    extend(Mixlib::Config)
+  end
+end

data/lib/sensu-cli/templates/event.erb

@@ -0,0 +1,20 @@
+<%= "-------".color(:yellow) %>
+<%= "id:".color(:blue).bright %> <%= id.to_s.color(:green) %>
+<%= "client name:".color(:blue).bright %> <%= client['name'].to_s.color(:green) %>
+  <%= "address:".color(:cyan) %> <%= client['address'].to_s.color(:green) %>
+  <%= "subscriptions:".color(:cyan) %> <%= client['subscriptions'].to_s.color(:green) %>
+  <%= "version:".color(:cyan) %> <%= client['version'].to_s.color(:green) %>
+  <%= "timestamp:".color(:cyan) %> <%= client['timestamp'].to_s.color(:green) %>
+<%= "check name:".color(:blue).bright %> <%= check['name'].to_s.color(:green) %>
+  <%= "command:".color(:cyan) %> <%= check['command'].to_s.color(:green) %>
+  <%= "handlers:".color(:cyan) %> <%= check['handlers'].to_s.color(:green) %>
+  <%= "interval:".color(:cyan) %> <%= check['interval'].to_s.color(:green) %>
+  <%= "subscribers:".color(:cyan) %> <%= check['subscribers'].to_s.color(:green) %>
+  <%= "issued:".color(:cyan) %> <%= check['issued'].to_s.color(:green) %>
+  <%= "executed:".color(:cyan) %> <%= check['executed'].to_s.color(:green) %>
+  <%= "duration:".color(:cyan) %> <%= check['duration'].to_s.color(:green) %>
+  <%= "output:".color(:cyan) %> <%= check['output'].rstrip.to_s.color(:green) %>
+  <%= "status:".color(:cyan) %> <%= check['status'].to_s.color(:green) %>
+  <%= "history:".color(:cyan) %> <%= check['history'].to_s.color(:green) %>
+<%= "occurrences:".color(:blue).bright %> <%= occurrences.to_s.color(:green) %>
+<%= "action:".color(:blue).bright %> <%= action.to_s.color(:green) %>

data/lib/sensu-cli/version.rb

@@ -0,0 +1,3 @@
+module SensuCli
+  VERSION = '0.6.3.2'
+end

data/sensu-cli.gemspec

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), 'lib', 'sensu-cli', 'version')
+
+Gem::Specification.new do |s|
+  s.name        = 'sensu-cli-compat'
+  s.version     = SensuCli::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.summary     = 'A command line utility for Sensu.'
+  s.description = 'A command line utility for interacting with the Sensu api.'
+  s.authors     = ['Bryan Brandau', 'Rob Thomas']
+  s.email       = ['agent462@gmail.com', 'xrobau@gmail.com']
+  s.has_rdoc    = false
+  s.licenses    = %w(MIT APACHE)
+  s.homepage    = 'http://github.com/xrobau/sensu-cli'
+
+  s.add_dependency('rainbow', '1.99.2')
+  s.add_dependency('trollop', '2.0')
+  s.add_dependency('mixlib-config', '2.1.0')
+  s.add_dependency('hirb', '0.7.1')
+  s.add_dependency('erubis', '2.7.0')
+  s.add_dependency('json', '1.8.1')
+
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('rubocop')
+
+  s.files         = Dir.glob('{bin,lib}/**/*') + %w(sensu-cli.gemspec README.md settings.example.rb)
+  s.executables   = Dir.glob('bin/**/*').map { |file| File.basename(file) }
+  s.require_paths = ['lib']
+end

data/settings.example.rb

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

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: sensu-cli-compat
+version: !ruby/object:Gem::Version 
+  version: 0.6.3.2
+platform: ruby
+authors: 
+- Bryan Brandau
+- Rob Thomas
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-12-04 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rainbow
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.99.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: trollop
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mixlib-config
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: hirb
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.7.1
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: erubis
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 2.7.0
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.8.1
+  type: :runtime
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id008 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rubocop
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    requirements: 
+    - *id008
+  type: :development
+  version_requirements: *id009
+description: A command line utility for interacting with the Sensu api.
+email: 
+- agent462@gmail.com
+- xrobau@gmail.com
+executables: 
+- sensu
+- sensu-cli
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- bin/sensu
+- bin/sensu-cli
+- lib/sensu-cli.rb
+- lib/sensu-cli/api.rb
+- lib/sensu-cli/base.rb
+- lib/sensu-cli/cli.rb
+- lib/sensu-cli/editor.rb
+- lib/sensu-cli/filter.rb
+- lib/sensu-cli/path.rb
+- lib/sensu-cli/pretty.rb
+- lib/sensu-cli/settings.rb
+- lib/sensu-cli/templates/event.erb
+- lib/sensu-cli/version.rb
+- sensu-cli.gemspec
+- settings.example.rb
+homepage: http://github.com/xrobau/sensu-cli
+licenses: 
+- MIT
+- APACHE
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id008
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id008
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A command line utility for Sensu.
+test_files: []
+