Class: SensuCli::Cli

Inherits:
Object
  • Object
show all
Defined in:
lib/sensu-cli/cli.rb

Overview

rubocop:disable ClassLength

Constant Summary collapse

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

Instance Method Summary collapse

Instance Method Details

#aggregate ⇒ Object 



263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
 
# File 'lib/sensu-cli/cli.rb', line 263

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

#check ⇒ Object 



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/sensu-cli/cli.rb', line 179

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

#client ⇒ Object

rubocop:disable MethodLength



130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/sensu-cli/cli.rb', line 130

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

#deep_merge(hash_one, hash_two) ⇒ Object 



111
112
113
 
# File 'lib/sensu-cli/cli.rb', line 111

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

#event ⇒ Object 



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
 
# File 'lib/sensu-cli/cli.rb', line 202

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

#explode(opts) ⇒ Object 



105
106
107
108
109
 
# File 'lib/sensu-cli/cli.rb', line 105

def explode(opts)
  Trollop::with_standard_exception_handling opts do
    raise Trollop::HelpNeeded # show help screen
  end
end

#explode_if_empty(opts, command) ⇒ Object 



122
123
124
 
# File 'lib/sensu-cli/cli.rb', line 122

def explode_if_empty(opts, command)
  explode(opts) if ARGV.empty? && command != 'list'
end

#global ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/sensu-cli/cli.rb', line 67

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

#health ⇒ Object 



170
171
172
173
174
175
176
177
 
# File 'lib/sensu-cli/cli.rb', line 170

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

#info ⇒ Object 



164
165
166
167
168
 
# File 'lib/sensu-cli/cli.rb', line 164

def info
  parser('INFO')
  p = Trollop::options
  { :command => 'info', :method => 'Get', :fields => p }
end

#next_argv ⇒ Object 



126
127
128
 
# File 'lib/sensu-cli/cli.rb', line 126

def next_argv
  ARGV.shift
end

#parser(cli) ⇒ Object 



115
116
117
118
119
120
 
# File 'lib/sensu-cli/cli.rb', line 115

def parser(cli)
  Trollop::Parser.new do
    banner Cli.const_get("#{cli}_BANNER")
    stop_on Cli.const_get("#{cli}_COMMANDS")
  end
end

#resolve ⇒ Object 



305
306
307
308
309
310
311
 
# File 'lib/sensu-cli/cli.rb', line 305

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

#silence ⇒ Object 



292
293
294
295
296
297
298
299
300
301
302
303
 
# File 'lib/sensu-cli/cli.rb', line 292

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

#stash ⇒ Object 



231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
 
# File 'lib/sensu-cli/cli.rb', line 231

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