File Manager
Viewing File: ext.rb
#--
# Author:: Daniel DeLeo (<dan@kallistec.com>)
# Copyright:: Copyright 2009-2016, Daniel DeLeo
# License:: Apache License, Version 2.0
#
# 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.
#
require "tempfile"
require "chef/recipe"
require "fileutils"
require "chef/dsl/platform_introspection"
require "chef/version"
require "chef/shell/shell_session"
require "chef/shell/model_wrapper"
require "chef/server_api"
require "chef/json_compat"
module Shell
module Extensions
Help = Struct.new(:cmd, :desc, :explanation)
# Extensions to be included in every 'main' object in chef-shell.
# These objects are extended with this module.
module ObjectCoreExtensions
def ensure_session_select_defined
# irb breaks if you prematurely define IRB::JobMangager
# so these methods need to be defined at the latest possible time.
unless jobs.respond_to?(:select_session_by_context)
def jobs.select_session_by_context(&block) # rubocop:disable Lint/NestedMethodDefinition
@jobs.select { |job| block.call(job[1].context.main) }
end
end
unless jobs.respond_to?(:session_select)
def jobs.select_shell_session(target_context) # rubocop:disable Lint/NestedMethodDefinition
session = if target_context.kind_of?(Class)
select_session_by_context { |main| main.kind_of?(target_context) }
else
select_session_by_context { |main| main.equal?(target_context) }
end
Array(session.first)[1]
end
end
end
def find_or_create_session_for(context_obj)
ensure_session_select_defined
if subsession = jobs.select_shell_session(context_obj)
jobs.switch(subsession)
else
irb(context_obj)
end
end
def help_banner
banner = []
banner << ""
banner << "chef-shell Help"
banner << "".ljust(80, "=")
banner << "| " + "Command".ljust(25) + "| " + "Description"
banner << "".ljust(80, "=")
all_help_descriptions.each do |help_text|
banner << "| " + help_text.cmd.ljust(25) + "| " + help_text.desc
end
banner << "".ljust(80, "=")
banner << "\n"
banner << "Use help(:command) to get detailed help with individual commands"
banner << "\n"
banner.join("\n")
end
def explain_command(method_name)
help = all_help_descriptions.find { |h| h.cmd.to_s == method_name.to_s }
if help
puts ""
puts "Command: #{method_name}"
puts "".ljust(80, "=")
puts help.explanation || help.desc
puts "".ljust(80, "=")
puts ""
else
puts ""
puts "command #{method_name} not found or no help available"
puts ""
end
end
# helpfully returns +:on+ so we can have sugary syntax like `tracing on'
def on
:on
end
# returns +:off+ so you can just do `tracing off'
def off
:off
end
def help_descriptions
@help_descriptions ||= []
end
def all_help_descriptions
help_descriptions
end
def desc(help_text)
@desc = help_text
end
def explain(explain_text)
@explain = explain_text
end
def subcommands(subcommand_help = {})
@subcommand_help = subcommand_help
end
def singleton_method_added(mname)
if @desc
help_descriptions << Help.new(mname.to_s, @desc.to_s, @explain)
@desc, @explain = nil, nil
end
if @subcommand_help
@subcommand_help.each do |subcommand, text|
help_descriptions << Help.new("#{mname}.#{subcommand}", text.to_s, nil)
end
end
@subcommand_help = {}
end
end
module String
def on_off_to_bool
case self
when "on"
true
when "off"
false
else
self
end
end
end
module Symbol
def on_off_to_bool
to_s.on_off_to_bool
end
end
module TrueClass
def to_on_off_str
"on"
end
def on_off_to_bool
self
end
end
module FalseClass
def to_on_off_str
"off"
end
def on_off_to_bool
self
end
end
# Methods that have associated help text need to be dynamically added
# to the main irb objects, so we define them in a proc and later
# instance_eval the proc in the object.
ObjectUIExtensions = Proc.new do
extend Shell::Extensions::ObjectCoreExtensions
desc "prints this help message"
explain(<<-E)
## SUMMARY ##
When called with no argument, +help+ prints a table of all
chef-shell commands. When called with an argument COMMAND, +help+
prints a detailed explanation of the command if available, or the
description if no explanation is available.
E
def help(commmand = nil)
if commmand
explain_command(commmand)
else
puts help_banner
end
:ucanhaz_halp
end
alias :halp :help
desc "prints information about chef"
def version
puts "This is the chef-shell.\n" +
" Chef Version: #{::Chef::VERSION}\n" +
" https://www.chef.io/\n" +
" https://docs.chef.io/"
:ucanhaz_automation
end
alias :shell :version
desc "switch to recipe mode"
def recipe_mode
find_or_create_session_for Shell.session.recipe
:recipe
end
desc "switch to attributes mode"
def attributes_mode
find_or_create_session_for Shell.session.node
:attributes
end
desc "run chef using the current recipe"
def run_chef
Chef::Log.level = :debug
session = Shell.session
runrun = Chef::Runner.new(session.run_context).converge
Chef::Log.level = :info
runrun
end
desc "returns an object to control a paused chef run"
subcommands :resume => "resume the chef run",
:step => "run only the next resource",
:skip_back => "move back in the run list",
:skip_forward => "move forward in the run list"
def chef_run
Shell.session.resource_collection.iterator
end
desc "resets the current recipe"
def reset
Shell.session.reset!
end
desc "assume the identity of another node."
def become_node(node_name)
Shell::DoppelGangerSession.instance.assume_identity(node_name)
:doppelganger
end
alias :doppelganger :become_node
desc "turns printout of return values on or off"
def echo(on_or_off)
conf.echo = on_or_off.on_off_to_bool
end
desc "says if echo is on or off"
def echo?
puts "echo is #{conf.echo.to_on_off_str}"
end
desc "turns on or off tracing of execution. *verbose*"
def tracing(on_or_off)
conf.use_tracer = on_or_off.on_off_to_bool
tracing?
end
alias :trace :tracing
desc "says if tracing is on or off"
def tracing?
puts "tracing is #{conf.use_tracer.to_on_off_str}"
end
alias :trace? :tracing?
desc "simple ls style command"
def ls(directory)
Dir.entries(directory)
end
end
MainContextExtensions = Proc.new do
desc "returns the current node (i.e., this host)"
def node
Shell.session.node
end
desc "pretty print the node's attributes"
def ohai(key = nil)
pp(key ? node.attribute[key] : node.attribute)
end
end
RESTApiExtensions = Proc.new do
desc "edit an object in your EDITOR"
explain(<<-E)
## SUMMARY ##
+edit(object)+ allows you to edit any object that can be converted to JSON.
When finished editing, this method will return the edited object:
new_node = edit(existing_node)
## EDITOR SELECTION ##
chef-shell looks for an editor using the following logic
1. Looks for an EDITOR set by Shell.editor = "EDITOR"
2. Looks for an EDITOR configured in your chef-shell config file
3. Uses the value of the EDITOR environment variable
E
def edit(object)
unless Shell.editor
puts "Please set your editor with Shell.editor = \"vim|emacs|mate|ed\""
return :failburger
end
filename = "chef-shell-edit-#{object.class.name}-"
if object.respond_to?(:name)
filename += object.name
elsif object.respond_to?(:id)
filename += object.id
end
edited_data = Tempfile.open([filename, ".js"]) do |tempfile|
tempfile.sync = true
tempfile.puts Chef::JSONCompat.to_json(object)
system("#{Shell.editor} #{tempfile.path}")
tempfile.rewind
tempfile.read
end
Chef::JSONCompat.from_json(edited_data)
end
desc "Find and edit API clients"
explain(<<-E)
## SUMMARY ##
+clients+ allows you to query you chef server for information about your api
clients.
## LIST ALL CLIENTS ##
To see all clients on the system, use
clients.all #=> [<Chef::ApiClient...>, ...]
If the output from all is too verbose, or you're only interested in a specific
value from each of the objects, you can give a code block to +all+:
clients.all { |client| client.name } #=> [CLIENT1_NAME, CLIENT2_NAME, ...]
## SHOW ONE CLIENT ##
To see a specific client, use
clients.show(CLIENT_NAME)
## SEARCH FOR CLIENTS ##
You can also search for clients using +find+ or +search+. You can use the
familiar string search syntax:
clients.search("KEY:VALUE")
Just as the +all+ subcommand, the +search+ subcommand can use a code block to
filter or transform the information returned from the search:
clients.search("KEY:VALUE") { |c| c.name }
You can also use a Hash based syntax, multiple search conditions will be
joined with AND.
clients.find :KEY => :VALUE, :KEY2 => :VALUE2, ...
## BULK-EDIT CLIENTS ##
**BE CAREFUL, THIS IS DESTRUCTIVE**
You can bulk edit API Clients using the +transform+ subcommand, which requires
a code block. Each client will be saved after the code block is run. If the
code block returns +nil+ or +false+, that client will be skipped:
clients.transform("*:*") do |client|
if client.name =~ /borat/i
client.admin(false)
true
else
nil
end
end
This will strip the admin privileges from any client named after borat.
E
subcommands :all => "list all api clients",
:show => "load an api client by name",
:search => "search for API clients",
:transform => "edit all api clients via a code block and save them"
def clients
@clients ||= Shell::ModelWrapper.new(Chef::ApiClient, :client)
end
desc "Find and edit cookbooks"
subcommands :all => "list all cookbooks",
:show => "load a cookbook by name",
:transform => "edit all cookbooks via a code block and save them"
def cookbooks
@cookbooks ||= Shell::ModelWrapper.new(Chef::CookbookVersion)
end
desc "Find and edit nodes via the API"
explain(<<-E)
## SUMMARY ##
+nodes+ Allows you to query your chef server for information about your nodes.
## LIST ALL NODES ##
You can list all nodes using +all+ or +list+
nodes.all #=> [<Chef::Node...>, <Chef::Node...>, ...]
To limit the information returned for each node, pass a code block to the +all+
subcommand:
nodes.all { |node| node.name } #=> [NODE1_NAME, NODE2_NAME, ...]
## SHOW ONE NODE ##
You can show the data for a single node using the +show+ subcommand:
nodes.show("NODE_NAME") => <Chef::Node @name="NODE_NAME" ...>
## SEARCH FOR NODES ##
You can search for nodes using the +search+ or +find+ subcommands:
nodes.find(:name => "app*") #=> [<Chef::Node @name="app1.example.com" ...>, ...]
Similarly to +all+, you can pass a code block to limit or transform the
information returned:
nodes.find(:name => "app#") { |node| node.ec2 }
## BULK EDIT NODES ##
**BE CAREFUL, THIS OPERATION IS DESTRUCTIVE**
Bulk edit nodes by passing a code block to the +transform+ or +bulk_edit+
subcommand. The block will be applied to each matching node, and then the node
will be saved. If the block returns +nil+ or +false+, that node will be
skipped.
nodes.transform do |node|
if node.fqdn =~ /.*\\.preprod\\.example\\.com/
node.set[:environment] = "preprod"
end
end
This will assign the attribute to every node with a FQDN matching the regex.
E
subcommands :all => "list all nodes",
:show => "load a node by name",
:search => "search for nodes",
:transform => "edit all nodes via a code block and save them"
def nodes
@nodes ||= Shell::ModelWrapper.new(Chef::Node)
end
desc "Find and edit roles via the API"
explain(<<-E)
## SUMMARY ##
+roles+ allows you to query and edit roles on your Chef server.
## SUBCOMMANDS ##
* all (list)
* show (load)
* search (find)
* transform (bulk_edit)
## SEE ALSO ##
See the help for +nodes+ for more information about the subcommands.
E
subcommands :all => "list all roles",
:show => "load a role by name",
:search => "search for roles",
:transform => "edit all roles via a code block and save them"
def roles
@roles ||= Shell::ModelWrapper.new(Chef::Role)
end
desc "Find and edit +databag_name+ via the api"
explain(<<-E)
## SUMMARY ##
+databags(DATABAG_NAME)+ allows you to query and edit data bag items on your
Chef server. Unlike other commands for working with data on the server,
+databags+ requires the databag name as an argument, for example:
databags(:users).all
## SUBCOMMANDS ##
* all (list)
* show (load)
* search (find)
* transform (bulk_edit)
## SEE ALSO ##
See the help for +nodes+ for more information about the subcommands.
E
subcommands :all => "list all items in the data bag",
:show => "load a data bag item by id",
:search => "search for items in the data bag",
:transform => "edit all items via a code block and save them"
def databags(databag_name)
@named_databags_wrappers ||= {}
@named_databags_wrappers[databag_name] ||= Shell::NamedDataBagWrapper.new(databag_name)
end
desc "Find and edit environments via the API"
explain(<<-E)
## SUMMARY ##
+environments+ allows you to query and edit environments on your Chef server.
## SUBCOMMANDS ##
* all (list)
* show (load)
* search (find)
* transform (bulk_edit)
## SEE ALSO ##
See the help for +nodes+ for more information about the subcommands.
E
subcommands :all => "list all environments",
:show => "load an environment by name",
:search => "search for environments",
:transform => "edit all environments via a code block and save them"
def environments
@environments ||= Shell::ModelWrapper.new(Chef::Environment)
end
desc "A REST Client configured to authenticate with the API"
def api
@rest = Chef::ServerAPI.new(Chef::Config[:chef_server_url])
end
end
RecipeUIExtensions = Proc.new do
alias :original_resources :resources
desc "list all the resources on the current recipe"
def resources(*args)
if args.empty?
pp run_context.resource_collection.keys
else
pp resources = original_resources(*args)
resources
end
end
end
def self.extend_context_object(obj)
obj.instance_eval(&ObjectUIExtensions)
obj.instance_eval(&MainContextExtensions)
obj.instance_eval(&RESTApiExtensions)
obj.extend(FileUtils)
obj.extend(Chef::DSL::PlatformIntrospection)
obj.extend(Chef::DSL::DataQuery)
end
def self.extend_context_node(node_obj)
node_obj.instance_eval(&ObjectUIExtensions)
end
def self.extend_context_recipe(recipe_obj)
recipe_obj.instance_eval(&ObjectUIExtensions)
recipe_obj.instance_eval(&RecipeUIExtensions)
end
end
end
class String
include Shell::Extensions::String
end
class Symbol
include Shell::Extensions::Symbol
end
class TrueClass
include Shell::Extensions::TrueClass
end
class FalseClass
include Shell::Extensions::FalseClass
end