runa-chef 0.8.0.1

data/lib/chef/runner.rb

@@ -0,0 +1,130 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# 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 'chef/mixin/params_validate'
+require 'chef/node'
+require 'chef/resource_collection'
+require 'chef/platform'
+
+class Chef
+  class Runner
+    
+    include Chef::Mixin::ParamsValidate
+    
+    def initialize(node, collection, definitions={}, cookbook_loader=nil)
+      validate(
+        {
+          :node => node,
+          :collection => collection,
+        },
+        {
+          :node => {
+            :kind_of => Chef::Node,
+          },
+          :collection => {
+            :kind_of => Chef::ResourceCollection,
+          },
+        }
+      )
+      @node = node
+      @collection = collection
+      @definitions = definitions
+      @cookbook_loader = cookbook_loader
+    end
+    
+    def build_provider(resource)
+      provider_klass = resource.provider
+      provider_klass ||= Chef::Platform.find_provider_for_node(@node, resource)
+      Chef::Log.debug("#{resource} using #{provider_klass.to_s}")
+      provider = provider_klass.new(@node, resource, @collection, @definitions, @cookbook_loader)
+      provider.load_current_resource
+      provider
+    end
+
+    def run_action(resource, ra)
+      provider = build_provider(resource)
+      provider.send("action_#{ra}")
+
+      if resource.updated
+        resource.actions.each_key do |action|
+          if resource.actions[action].has_key?(:immediate)
+            resource.actions[action][:immediate].each do |r|
+              Chef::Log.info("#{resource} sending #{action} action to #{r} (immediate)")
+              run_action(r, action)
+            end
+          end
+          if resource.actions[action].has_key?(:delayed)
+            resource.actions[action][:delayed].each do |r|
+              @delayed_actions[r] = Hash.new unless @delayed_actions.has_key?(r)
+              @delayed_actions[r][action] = Array.new unless @delayed_actions[r].has_key?(action)
+              @delayed_actions[r][action] << lambda {
+                Chef::Log.info("#{resource} sending #{action} action to #{r} (delayed)")
+              } 
+            end
+          end
+        end
+      end
+    end
+
+    def converge
+
+      @delayed_actions = Hash.new
+      
+      @collection.execute_each_resource do |resource|
+        begin
+          Chef::Log.debug("Processing #{resource}")
+          
+          # Check if this resource has an only_if block - if it does, skip it.
+          if resource.only_if
+            unless Chef::Mixin::Command.only_if(resource.only_if)
+              Chef::Log.debug("Skipping #{resource} due to only_if")
+              next
+            end
+          end
+          
+          # Check if this resource has a not_if block - if it does, skip it.
+          if resource.not_if
+            unless Chef::Mixin::Command.not_if(resource.not_if)
+              Chef::Log.debug("Skipping #{resource} due to not_if")
+              next
+            end
+          end
+          
+          # Walk the actions for this resource, building the provider and running each.
+          action_list = resource.action.kind_of?(Array) ? resource.action : [ resource.action ]
+          action_list.each do |ra|
+            run_action(resource, ra)
+          end
+        rescue => e
+          Chef::Log.error("#{resource} (#{resource.source_line}) had an error:\n#{e}\n#{e.backtrace.join("\n")}")
+          raise e unless resource.ignore_failure
+        end
+      end
+      
+      # Run all our :delayed actions
+      @delayed_actions.each do |resource, action_hash| 
+        action_hash.each do |action, log_array|
+          log_array.each { |l| l.call } # Call each log message
+          run_action(resource, action)
+        end
+      end
+
+      true
+    end
+  end
+end

data/lib/chef/search/query.rb

@@ -0,0 +1,71 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# 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 'chef/config'
+require 'chef/node'
+require 'chef/role'
+require 'chef/data_bag'
+require 'chef/data_bag_item'
+require 'uri'
+
+class Chef
+  class Search
+    class Query 
+
+      attr_accessor :rest
+
+      def initialize(url=nil)
+        url ||= Chef::Config[:search_url]
+        @rest = Chef::REST.new(url)
+      end
+
+      # Search Solr for objects of a given type, for a given query. If you give
+      # it a block, it will handle the paging for you dynamically.
+      def search(type, query="*:*", sort=nil, start=0, rows=20, &block)
+        unless type.kind_of?(String) || type.kind_of?(Symbol)
+          raise ArgumentError, "Type must be a string or a symbol!" 
+        end
+
+        response = @rest.get_rest("search/#{type}?q=#{escape(query)}&sort=#{escape(sort)}&start=#{escape(start)}&rows=#{escape(rows)}")
+        if block
+          response["rows"].each { |o| block.call(o) unless o.nil?}
+          unless (response["start"] + response["rows"].length) >= response["total"]
+            nstart = response["start"] + rows
+            search(type, query, sort, nstart, rows, &block)
+          end
+          true
+        else
+          [ response["rows"], response["start"], response["total"] ]
+        end
+      end
+      
+      def list_indexes
+        response = @rest.get_rest("search")
+      end 
+
+      private
+        def escape(s)
+          if s
+            URI.escape(s.to_s) 
+          else
+            s
+          end
+        end
+    end
+  end
+end

data/lib/chef/shef.rb

@@ -0,0 +1,220 @@
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2009 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 "singleton"
+require "pp"
+require "etc"
+require "mixlib/cli"
+
+require "chef/client"
+require "chef/config"
+
+require "chef/shef/shef_session"
+require "chef/shef/ext"
+
+
+module Shef
+  LEADERS = Hash.new("")
+  LEADERS[Chef::Recipe] = ":recipe"
+  LEADERS[Chef::Node]   = ":attributes"
+  
+  class << self
+    attr_accessor :client_type, :options
+  end
+  
+  # Shef assumes it's running whenever it is defined
+  def self.running?
+    true
+  end
+  
+  # Set the irb_conf object to something other than IRB.conf
+  # usful for testing.
+  def self.irb_conf=(conf_hash)
+    @irb_conf = conf_hash
+  end
+  
+  def self.irb_conf
+    @irb_conf || IRB.conf
+  end
+  
+  def self.configure_irb
+    irb_conf[:HISTORY_FILE] = "~/.shef_history"
+    irb_conf[:SAVE_HISTORY] = 1000
+    
+    irb_conf[:IRB_RC] = lambda do |conf|
+      m = conf.main
+      leader = LEADERS[m.class]
+
+      def m.help
+        shef_help
+      end
+
+      conf.prompt_c       = "chef#{leader} > "
+      conf.return_format  = " => %s \n"
+      conf.prompt_i       = "chef#{leader} > "
+      conf.prompt_n       = "chef#{leader} ?> "
+      conf.prompt_s       = "chef#{leader}%l> "
+    end
+  end
+  
+  def self.session
+    client_type.instance.reset! unless client_type.instance.node_built?
+    client_type.instance
+  end
+  
+  def self.init
+    parse_json
+    configure_irb
+
+    session # trigger ohai run + session load
+    
+    session.node.consume_attributes(@json_attribs)
+
+    greeting = begin
+        " #{Etc.getlogin}@#{Shef.session.node.name}"
+      rescue NameError
+        ""
+      end
+
+    version
+    puts
+
+    puts "run `help' for help, `exit' or ^D to quit."
+    puts
+    puts "Ohai2u#{greeting}!"
+  end
+  
+  def self.parse_json
+    if Chef::Config[:json_attribs]
+      begin
+        json_io = open(Chef::Config[:json_attribs])
+      rescue SocketError => error
+        fatal!("I cannot connect to #{Chef::Config[:json_attribs]}", 2)
+      rescue Errno::ENOENT => error
+        fatal!("I cannot find #{Chef::Config[:json_attribs]}", 2)
+      rescue Errno::EACCES => error
+        fatal!("Permissions are incorrect on #{Chef::Config[:json_attribs]}. Please chmod a+r #{Chef::Config[:json_attribs]}", 2)
+      rescue Exception => error
+        fatal!("Got an unexpected error reading #{Chef::Config[:json_attribs]}: #{error.message}", 2)
+      end
+
+      begin
+        @json_attribs = JSON.parse(json_io.read)
+      rescue JSON::ParserError => error
+        fatal!("Could not parse the provided JSON file (#{Chef::Config[:json_attribs]})!: " + error.message, 2)
+      end
+    end
+  end
+  
+  def self.fatal!(message, exit_status)
+    Chef::Log.fatal(message)
+    exit exit_status
+  end
+  
+  def self.client_type
+    type = Shef::StandAloneSession
+    type = Shef::SoloSession   if Chef::Config[:solo]
+    type = Shef::ClientSession if Chef::Config[:client]
+    type
+  end
+  
+  def self.parse_opts
+    @options = Options.new
+    @options.parse_opts
+  end
+  
+  class Options
+    include Mixlib::CLI
+
+    option :config_file, 
+      :short => "-c CONFIG",
+      :long  => "--config CONFIG",
+      :description => "The configuration file to use"
+
+    option :help,
+      :short        => "-h",
+      :long         => "--help",
+      :description  => "Show this message",
+      :on           => :tail,
+      :boolean      => true,
+      :show_options => true,
+      :exit         => 0
+
+    option :standalone,
+      :short        => "-a",
+      :long         => "--standalone",
+      :description  => "standalone shef session",
+      :default      => true,
+      :boolean      => true
+
+    option :solo,
+      :short        => "-s",
+      :long         => "--solo",
+      :description  => "chef-solo shef session",
+      :boolean      => true
+
+    option :client,
+      :short        => "-z",
+      :long         => "--client",
+      :description  => "chef-client shef session",
+      :boolean      => true
+
+    option :json_attribs,
+      :short => "-j JSON_ATTRIBS",
+      :long => "--json-attributes JSON_ATTRIBS",
+      :description => "Load attributes from a JSON file or URL",
+      :proc => nil
+
+    option :chef_server_url,
+      :short => "-S CHEFSERVERURL",
+      :long => "--server CHEFSERVERURL",
+      :description => "The chef server URL",
+      :proc => nil
+
+    option :version,
+      :short        => "-v",
+      :long         => "--version",
+      :description  => "Show chef version",
+      :boolean      => true,
+      :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
+      :exit         => 0
+
+    def self.setup!
+      self.new.parse_opts
+    end
+
+    def parse_opts
+      parse_options
+      config[:config_file] = config_file_for_shef_mode
+      config_msg = config[:config_file] || "none (standalone shef session)"
+      puts "loading configuration: #{config_msg}"
+      Chef::Config.from_file(config[:config_file]) if !config[:config_file].nil? && File.exists?(config[:config_file]) && File.readable?(config[:config_file])
+      Chef::Config.merge!(config)
+    end
+    
+    private
+    
+    def config_file_for_shef_mode
+      return config[:config_file] if config[:config_file]
+      return "/etc/chef/solo.rb" if config[:solo]
+      return "/etc/chef/client.rb" if config[:client]
+      nil
+    end
+
+  end
+  
+end

data/lib/chef/shef/ext.rb

@@ -0,0 +1,297 @@
+# Author:: Daniel DeLeo (<dan@kallistec.com>)
+# Copyright:: Copyright (c) 2009 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.
+#
+
+module Shef
+  module Extensions
+    
+    # Extensions to be included in object. These are methods that have to be
+    # defined on object but are not part of the user interface. Methods that
+    # are part of the user interface should have help text defined with the
+    # +desc+ macro, and need to be defined directly on Object in ext.rb
+    module Object
+      
+      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)
+            @jobs.select { |job| block.call(job[1].context.main)}
+          end
+        end
+
+        unless jobs.respond_to?(:session_select)
+          def jobs.select_shef_session(target_context)
+            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_shef_session(context_obj)
+          jobs.switch(subsession)
+        else
+          irb(context_obj)
+        end
+      end
+      
+      def help_banner(title=nil)
+        banner = []
+        banner << ""
+        banner << title if title
+        banner << "".ljust(80, "=")
+        banner << "| " + "Command".ljust(25) + "| " + "Description"
+        banner << "".ljust(80, "=")
+        self.class.all_help_descriptions.each do |cmd, description|
+          banner << "| " + cmd.ljust(25) + "| " + description
+        end
+        banner << "".ljust(80, "=")
+        banner << "\n"
+        banner.join("\n")
+      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
+      
+      module ClassMethods
+
+        def help_descriptions
+          @help_descriptions ||= []
+        end
+        
+        def all_help_descriptions
+          if sc = superclass
+            help_descriptions + sc.help_descriptions
+          else
+            help_descriptions
+          end
+        end
+
+        def desc(help_text)
+          @desc = help_text
+        end
+        
+        def subcommands(subcommand_help={})
+          @subcommand_help = subcommand_help
+        end
+
+        def method_added(mname)
+          if @desc
+            help_descriptions << [mname.to_s, @desc.to_s]
+            @desc = nil
+          end
+          if @subcommand_help
+            @subcommand_help.each do |subcommand, text|
+              help_descriptions << ["#{mname}.#{subcommand}", text.to_s]
+            end
+          end
+          @subcommand_help = {}
+        end
+
+      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
+        self.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
+    
+  end
+end
+
+class String
+  include Shef::Extensions::String
+end
+
+class Symbol
+  include Shef::Extensions::Symbol
+end
+
+class TrueClass
+  include Shef::Extensions::TrueClass
+end
+
+class FalseClass
+  include Shef::Extensions::FalseClass
+end
+
+class Object
+  extend Shef::Extensions::Object::ClassMethods
+  include Shef::Extensions::Object
+  include FileUtils
+  
+  desc "prints this help message"
+  def shef_help(title="Help: Shef")
+    #puts Shef::Extensions::Object.help_banner("Shef Help")
+    puts help_banner(title)
+    :ucanhaz_halp
+  end
+  alias :halp :shef_help
+  
+  desc "prints information about chef"
+  def version
+    puts  "This is shef, the Chef shell.\n" + 
+          " Chef Version: #{::Chef::VERSION}\n" +
+          " http://www.opscode.com/chef\n" +
+          " http://wiki.opscode.com/display/chef/Home"
+    :ucanhaz_automation
+  end
+  alias :shef :version
+  
+  desc "switch to recipe mode"
+  def recipe
+    find_or_create_session_for Shef.session.recipe
+    :recipe
+  end
+  
+  desc "switch to attributes mode"
+  def attributes
+    find_or_create_session_for Shef.session.node
+    :attributes
+  end
+  
+  desc "returns the current node (i.e., this host)"
+  def node
+    Shef.session.node
+  end
+  
+  desc "pretty print the node's attributes"
+  def ohai(key=nil)
+    pp(key ? node.attribute[key] : node.attribute)
+  end
+  
+  desc "run chef using the current recipe"
+  def run_chef
+    Chef::Log.level = :debug
+    session = Shef.session
+    session.rebuild_collection
+    runrun = Chef::Runner.new(node, session.collection, session.definitions, session.cookbook_loader).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
+    Shef.session.collection.iterator
+  end
+  
+  desc "resets the current recipe"
+  def reset
+    Shef.session.reset!
+  end
+  
+  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
+
+class Chef
+  class Recipe
+    
+    def shef_help
+      super("Help: Shef/Recipe")
+    end
+    
+    alias :original_resources :resources
+    
+    desc "list all the resources on the current recipe"
+    def resources(*args)
+      if args.empty?
+        pp collection.instance_variable_get(:@resources_by_name).keys
+      else
+        pp resources = original_resources(*args)
+        resources
+      end
+    end
+  end
+end