microwave 0.1006.33 → 1.0.0

data/lib/chef/client.rb

@@ -1,295 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Christopher Walters (<cw@opscode.com>)
-# Author:: Christopher Brown (<cb@opscode.com>)
-# Author:: Tim Hinderliter (<tim@opscode.com>)
-# Copyright:: Copyright (c) 2008-2011 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/mixin/params_validate'
-require 'chef/log'
-require 'chef/platform'
-require 'chef/node'
-require 'chef/role'
-require 'chef/file_cache'
-require 'chef/run_context'
-require 'chef/runner'
-require 'chef/run_status'
-require 'chef/cookbook/cookbook_collection'
-require 'chef/cookbook/file_vendor'
-require 'chef/cookbook/file_system_file_vendor'
-require 'chef/version'
-
-class Chef
-  # == Chef::Client
-  # The main object in a Chef run. Preps a Chef::Node and Chef::RunContext,
-  # syncs cookbooks if necessary, and triggers convergence.
-  class Client
-
-    SANE_PATHS = %w[/usr/local/sbin /usr/local/bin /usr/sbin /usr/bin /sbin /bin]
-
-    # Clears all notifications for client run status events.
-    # Primarily for testing purposes.
-    def self.clear_notifications
-      @run_start_notifications = nil
-      @run_completed_successfully_notifications = nil
-      @run_failed_notifications = nil
-    end
-
-    # The list of notifications to be run when the client run starts.
-    def self.run_start_notifications
-      @run_start_notifications ||= []
-    end
-
-    # The list of notifications to be run when the client run completes
-    # successfully.
-    def self.run_completed_successfully_notifications
-      @run_completed_successfully_notifications ||= []
-    end
-
-    # The list of notifications to be run when the client run fails.
-    def self.run_failed_notifications
-      @run_failed_notifications ||= []
-    end
-
-    # Add a notification for the 'client run started' event. The notification
-    # is provided as a block. The current Chef::RunStatus object will be passed
-    # to the notification_block when the event is triggered.
-    def self.when_run_starts(&notification_block)
-      run_start_notifications << notification_block
-    end
-
-    # Add a notification for the 'client run success' event. The notification
-    # is provided as a block. The current Chef::RunStatus object will be passed
-    # to the notification_block when the event is triggered.
-    def self.when_run_completes_successfully(&notification_block)
-      run_completed_successfully_notifications << notification_block
-    end
-
-    # Add a notification for the 'client run failed' event. The notification
-    # is provided as a block. The current Chef::RunStatus is passed to the
-    # notification_block when the event is triggered.
-    def self.when_run_fails(&notification_block)
-      run_failed_notifications << notification_block
-    end
-
-    # Callback to fire notifications that the Chef run is starting
-    def run_started
-      self.class.run_start_notifications.each do |notification|
-        notification.call(run_status)
-      end
-    end
-
-    # Callback to fire notifications that the run completed successfully
-    def run_completed_successfully
-      self.class.run_completed_successfully_notifications.each do |notification|
-        notification.call(run_status)
-      end
-    end
-
-    # Callback to fire notifications that the Chef run failed
-    def run_failed
-      self.class.run_failed_notifications.each do |notification|
-        notification.call(run_status)
-      end
-    end
-
-    attr_accessor :node
-    attr_accessor :rest
-    attr_accessor :runner
-
-    attr_reader :run_status
-
-    # Creates a new Chef::Client.
-    def initialize
-      @node = nil
-      @run_status = nil
-      @runner = nil
-    end
-
-    # Do a full run for this Chef::Client.  Calls:
-    #
-    #  * build_node - Get the last known state, merge with local changes
-    #  * register - If not in solo mode, make sure the server knows about this client
-    #  * sync_cookbooks - If not in solo mode, populate the local cache with the node's cookbooks
-    #  * converge - Bring this system up to date
-    #
-    # === Returns
-    # true:: Always returns true.
-    def run
-      run_context = nil
-
-      Chef::Log.info("*** Chef #{Chef::VERSION} ***") unless Chef::Config[:quiet_logging]
-      enforce_path_sanity
-      build_node
-
-      begin
-
-        run_status.start_clock
-        Chef::Log.info("Starting Chef Run for #{node.name}") unless Chef::Config[:quiet_logging]
-        run_started
-
-        run_context = setup_run_context
-        converge(run_context)
-        save_updated_node
-
-        run_status.stop_clock
-        Chef::Log.info("Chef Run complete in #{run_status.elapsed_time} seconds") unless Chef::Config[:quiet_logging]
-        run_completed_successfully
-        true
-      rescue Exception => e
-        run_status.stop_clock
-        run_status.exception = e
-        run_failed
-        Chef::Log.debug("Re-raising exception: #{e.class} - #{e.message}\n#{e.backtrace.join("\n  ")}")
-        raise
-      ensure
-        run_status = nil
-      end
-      true
-    end
-
-
-    # Configures the Chef::Cookbook::FileVendor class to fetch file from the
-    # server or disk as appropriate, creates the run context for this run, and
-    # sanity checks the cookbook collection.
-    #===Returns
-    # Chef::RunContext:: the run context for this run.
-    def setup_run_context
-      Chef::Cookbook::FileVendor.on_create { |manifest| Chef::Cookbook::FileSystemFileVendor.new(manifest, Chef::Config[:cookbook_path]) }
-      run_context = Chef::RunContext.new(node, Chef::CookbookCollection.new(Chef::CookbookLoader.new(Chef::Config[:cookbook_path])))
-      run_status.run_context = run_context
-      run_context.load(@run_list_expansion)
-      assert_cookbook_path_not_empty(run_context)
-      run_context
-    end
-
-    def save_updated_node
-    end
-
-    def node_name
-      name = Chef::Config[:node_name]
-      Chef::Config[:node_name] = name
-
-      unless name
-        msg = "Unable to determine node name: configure node_name or configure the system's hostname and fqdn"
-        raise Chef::Exceptions::CannotDetermineNodeName, msg
-      end
-
-      name
-    end
-
-    # Builds a new node object for this client.  Starts with querying for the FQDN of the current
-    # host (unless it is supplied).
-    #
-    # === Returns
-    # node<Chef::Node>:: Returns the created node object, also stored in @node
-    def build_node
-      Chef::Log.debug("Building node object for #{node_name}")
-
-      @node = Chef::Node.build(node_name)
-
-      # Allow user to override the environment of a node by specifying
-      # a config parameter.
-      if Chef::Config[:environment] && !Chef::Config[:environment].chop.empty?
-        @node.chef_environment(Chef::Config[:environment])
-      end
-
-      # tom: no longer using json_attribs with consume_external_attrs,
-      # preferring to load from a node.rb
-      #
-      # consume_external_attrs may add items to the run_list. Save the
-      # expanded run_list, which we will pass to the server later to
-      # determine which versions of cookbooks to use.
-      @node.reset_defaults_and_overrides
-      @node.find_file(node_name)
-      @run_list_expansion = @node.expand!('disk')
-
-      # @run_list_expansion is a RunListExpansion.
-      #
-      # Convert @expanded_run_list, which is an
-      # Array of Hashes of the form
-      #   {:name => NAME, :version_constraint => Chef::VersionConstraint },
-      # into @expanded_run_list_with_versions, an
-      # Array of Strings of the form
-      #   "#{NAME}@#{VERSION}"
-      @expanded_run_list_with_versions = @run_list_expansion.recipes.with_version_constraints_strings
-
-      Chef::Log.info("Run List is [#{@node.run_list}]") unless Chef::Config[:quiet_logging]
-      Chef::Log.info("Run List expands to [#{@expanded_run_list_with_versions.join(', ')}]") unless Chef::Config[:quiet_logging]
-
-      @run_status = Chef::RunStatus.new(@node)
-
-      @node
-    end
-
-    # Converges the node.
-    #
-    # === Returns
-    # true:: Always returns true
-    def converge(run_context)
-      Chef::Log.debug("Converging node #{node_name}")
-      @runner = Chef::Runner.new(run_context)
-      runner.converge
-      true
-    end
-
-    def enforce_path_sanity(env=ENV)
-      if Chef::Config[:enforce_path_sanity] && RUBY_PLATFORM !~ /mswin|mingw32|windows/
-        existing_paths = env["PATH"].split(':')
-        SANE_PATHS.each do |sane_path|
-          unless existing_paths.include?(sane_path)
-            env_path = env["PATH"].dup
-            env_path << ':' unless env["PATH"].empty?
-            env_path << sane_path
-            env["PATH"] = env_path
-          end
-        end
-      end
-    end
-
-    private
-
-    def directory_not_empty?(path)
-      File.exists?(path) && (Dir.entries(path).size > 2)
-    end
-
-    def is_last_element?(index, object)
-      object.kind_of?(Array) ? index == object.size - 1 : true
-    end
-
-    def assert_cookbook_path_not_empty(run_context)
-      # Check for cookbooks in the path given
-      # Chef::Config[:cookbook_path] can be a string or an array
-      # if it's an array, go through it and check each one, raise error at the last one if no files are found
-      Chef::Log.debug "Loading from cookbook_path: #{Array(Chef::Config[:cookbook_path]).map { |path| File.expand_path(path) }.join(', ')}"
-      Array(Chef::Config[:cookbook_path]).each_with_index do |cookbook_path, index|
-        if directory_not_empty?(cookbook_path)
-          break
-        else
-          msg = "No cookbook found in #{Chef::Config[:cookbook_path].inspect}, make sure cookbook_path is set correctly."
-          Chef::Log.fatal(msg)
-          raise Chef::Exceptions::CookbookNotFound, msg if is_last_element?(index, Chef::Config[:cookbook_path])
-        end
-      end
-    end
-  end
-end
-
-# HACK cannot load this first, but it must be loaded.
-require 'chef/cookbook_loader'
-require 'chef/cookbook_version'
-

data/lib/chef/config.rb

@@ -1,104 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Christopher Brown (<cb@opscode.com>)
-# Author:: AJ Christensen (<aj@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/log'
-require 'mixlib/config'
-
-$microwave_root = Dir.pwd
-
-class Chef
-  class Config
-
-    extend Mixlib::Config
-
-    def self.inspect
-      configuration.inspect
-    end
-
-    # Override the config dispatch to set the value of log_location configuration option
-    #
-    # === Parameters
-    # location<IO||String>:: Logging location as either an IO stream or string representing log file path
-    #
-    config_attr_writer :log_location do |location|
-      if location.respond_to? :sync=
-        location.sync = true
-        location
-      elsif location.respond_to? :to_str
-        f = File.new(location.to_str, "a")
-        f.sync = true
-        f
-      end
-    end
-
-    # Turn on "path sanity" by default. See also: http://wiki.opscode.com/display/chef/User+Environment+PATH+Sanity
-    enforce_path_sanity(true)
-
-    # Where the cookbooks are located. Meaning is somewhat context dependent between
-    # chef-client, and chef-solo.
-    cookbook_path [ "#{$microwave_root}/cookbooks" ] + $:.collect {|x| File.join(File.expand_path("..", x), "cookbooks") }.select {|x| File.directory? x }
-
-    # Where cookbook files are stored on the server (by content checksum)
-    checksum_path "#{$microwave_root}/checksums"
-
-    # Where chef's cache files should be stored
-    file_cache_path "#{$microwave_root}/cache"
-
-    # Where backups of chef-managed files should go
-    file_backup_path "#{$microwave_root}/backup"
-
-    interval nil
-    log_level :info
-    log_location STDOUT
-    # toggle info level log items that can create a lot of output
-    verbose_logging true 
-    quiet_logging false
-    node_name nil
-    node_path "#{$microwave_root}/nodes"
-
-    pid_file nil
-
-    run_command_stderr_timeout 120
-    run_command_stdout_timeout 120
-    solo  false
-    splay nil
-
-    # Where should chef-solo look for role files?
-    role_path [ "#{$microwave_root}/roles" ]
-
-    # Report Handlers
-    report_handlers []
-
-    # Exception Handlers
-    exception_handlers []
-
-    # Start handlers
-    start_handlers []
-
-    # Checksum Cache
-    # Uses Moneta on the back-end
-    cache_type "BasicFile"
-    cache_options({ :path => "#{$microwave_root}/cache/checksums", :skip_expires => true })
-
-    # Those lists of regular expressions define what chef considers a
-    # valid user and group name
-    user_valid_regex [ /^([-a-zA-Z0-9_.]+)$/, /^\d+$/ ]
-    group_valid_regex [ /^([-a-zA-Z0-9_.\\ ]+)$/, /^\d+$/ ]
-  end
-end

data/lib/chef/cookbook/chefignore.rb

@@ -1,66 +0,0 @@
-#--
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2011 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.
-#
-
-class Chef
-  class Cookbook
-    class Chefignore
-
-      COMMENTS_AND_WHITESPACE = /^\w*(?:#.*)?$/
-
-      attr_reader :ignores
-
-      def initialize(ignore_file_or_repo)
-        @ignore_file = find_ignore_file(ignore_file_or_repo)
-        @ignores = parse_ignore_file
-      end
-
-      def remove_ignores_from(file_list)
-        Array(file_list).inject([]) do |unignored, file|
-          ignored?(file) ? unignored : unignored << file
-        end
-      end
-
-      def ignored?(file_name)
-        @ignores.any? {|glob| File.fnmatch?(glob, file_name)}
-      end
-
-      private
-
-      def parse_ignore_file
-        ignore_globs = []
-        if File.exist?(@ignore_file) && File.readable?(@ignore_file)
-          File.foreach(@ignore_file) do |line|
-            ignore_globs << line.strip unless line =~ COMMENTS_AND_WHITESPACE
-          end
-        else
-          Chef::Log.debug("No chefignore file found at #@ignore_file no files will be ignored")
-        end
-        ignore_globs
-      end
-
-      def find_ignore_file(path)
-        if File.basename(path) =~ /chefignore/
-          path
-        else
-          File.join(path, 'chefignore')
-        end
-      end
-    end
-  end
-end
-