microwave 0.1006.33 → 1.0.0

data/VERSION

@@ -1 +0,0 @@
-0.1006.33

data/lib/chef/application.rb

@@ -1,147 +0,0 @@
-#
-# 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 'socket'
-require 'chef/config'
-require 'chef/exceptions'
-require 'chef/log'
-require 'mixlib/cli'
-require 'tmpdir'
-
-class Chef::Application
-  include Mixlib::CLI
-
-  class Wakeup < Exception
-  end
-
-  def initialize
-    super
-
-    trap("TERM") do
-      Chef::Application.fatal!("SIGTERM received, stopping", 1)
-    end
-
-    trap("INT") do
-      Chef::Application.fatal!("SIGINT received, stopping", 2)
-    end
-
-    unless RUBY_PLATFORM =~ /mswin|mingw32|windows/
-      trap("QUIT") do
-        Chef::Log.info("SIGQUIT received, call stack:\n  " + caller.join("\n  "))
-      end
-
-      trap("HUP") do
-        Chef::Log.info("SIGHUP received, reconfiguring")
-        reconfigure
-      end
-    end
-
-    # Always switch to a readable directory. Keeps subsequent Dir.chdir() {}
-    # from failing due to permissions when launched as a less privileged user.
-  end
-
-  # Reconfigure the application. You'll want to override and super this method.
-  def reconfigure
-    configure_chef
-    configure_logging
-  end
-
-  # Get this party started
-  def run
-    reconfigure
-    setup_application
-    run_application
-  end
-
-  # Parse the configuration file
-  def configure_chef
-    parse_options
-
-    begin
-      ::File::open(config[:config_file]) { |f| apply_config(f.path) }
-    rescue SocketError => error
-      Chef::Application.fatal!("Error getting config file #{Chef::Config[:config_file]}", 2)
-    rescue Exception => error
-      Chef::Log.warn("*****************************************")
-      Chef::Log.warn("Can not find config file: #{config[:config_file]}, using defaults.")
-      Chef::Log.warn("#{error.message}")
-      Chef::Log.warn("*****************************************")
-
-      Chef::Config.merge!(config)
-    end
-
-  end
-
-  # Initialize and configure the logger. If the configured log location is not
-  # STDOUT, but stdout is a TTY and we're not daemonizing, we set up a secondary
-  # logger with output to stdout. This way, we magically do the right thing when
-  # the user has configured logging to a file but they're running chef in the
-  # shell to debug something.
-  def configure_logging
-    Chef::Log.init(Chef::Config[:log_location])
-    if ( Chef::Config[:log_location] != STDOUT ) && STDOUT.tty?
-      stdout_logger = Logger.new(STDOUT)
-      STDOUT.sync = true
-      stdout_logger.formatter = Chef::Log.logger.formatter
-      Chef::Log.loggers <<  stdout_logger
-    end
-    Chef::Log.level = Chef::Config[:log_level]
-  end
-
-  # Called prior to starting the application, by the run method
-  def setup_application
-    raise Chef::Exceptions::Application, "#{self.to_s}: you must override setup_application"
-  end
-
-  # Actually run the application
-  def run_application
-    raise Chef::Exceptions::Application, "#{self.to_s}: you must override run_application"
-  end
-
-  private
-
-  def apply_config(config_file_path)
-    Chef::Config.from_file(config_file_path)
-    Chef::Config.merge!(config)
-  end
-
-
-  class << self
-    def debug_stacktrace(e)
-      message = "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
-      chef_stacktrace_out = "Generated at #{Time.now.to_s}\n"
-      chef_stacktrace_out += message
-
-      Chef::FileCache.store("chef-stacktrace.out", chef_stacktrace_out)
-      Chef::Log.fatal("Stacktrace dumped to #{Chef::FileCache.load("chef-stacktrace.out", false)}")
-      Chef::Log.debug(message)
-      true
-    end
-
-    # Log a fatal error message to both STDERR and the Logger, exit the application
-    def fatal!(msg, err = -1)
-      Chef::Log.fatal(msg)
-      Process.exit err
-    end
-
-    def exit!(msg, err = -1)
-      Chef::Log.debug(msg)
-      Process.exit err
-    end
-  end
-
-end

data/lib/chef/application/solo.rb

@@ -1,129 +0,0 @@
-#
-# 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'
-require 'chef/application'
-require 'chef/client'
-require 'chef/config'
-require 'chef/log'
-require 'open-uri'
-require 'fileutils'
-
-class Chef::Application::Solo < Chef::Application
-
-  option :config_file,
-    :short => "-c CONFIG",
-    :long  => "--config CONFIG",
-    :default => "/etc/chef/solo.rb",
-    :description => "The configuration file to use"
-
-  option :log_level,
-    :short        => "-l LEVEL",
-    :long         => "--log_level LEVEL",
-    :description  => "Set the log level (debug, info, warn, error, fatal)",
-    :proc         => lambda { |l| l.to_sym }
-
-  option :log_location,
-    :short        => "-L LOGLOCATION",
-    :long         => "--logfile LOGLOCATION",
-    :description  => "Set the log file location, defaults to STDOUT",
-    :proc         => nil
-
-  option :help,
-    :short        => "-h",
-    :long         => "--help",
-    :description  => "Show this message",
-    :on           => :tail,
-    :boolean      => true,
-    :show_options => true,
-    :exit         => 0
-
-  option :user,
-    :short => "-u USER",
-    :long => "--user USER",
-    :description => "User to set privilege to",
-    :proc => nil
-
-  option :group,
-    :short => "-g GROUP",
-    :long => "--group GROUP",
-    :description => "Group to set privilege to",
-    :proc => nil
-
-  option :node_name,
-    :short => "-N NODE_NAME",
-    :long => "--node-name NODE_NAME",
-    :description => "The node name for this client",
-    :proc => nil
-
-  option :splay,
-    :short => "-s SECONDS",
-    :long => "--splay SECONDS",
-    :description => "The splay time for running at intervals, in seconds",
-    :proc => lambda { |s| s.to_i }
-
-  option :version,
-    :short        => "-v",
-    :long         => "--version",
-    :description  => "Show chef version",
-    :boolean      => true,
-    :proc         => lambda {|v| puts "Chef: #{::Chef::VERSION}"},
-    :exit         => 0
-
-  option :testrun,
-    :short        => "-n",
-    :long         => "--testrun",
-    :description  => "Run chef in testrun mode",
-    :boolean      => true,
-    :proc         => lambda {|n| $testrun = true }
-
-  def initialize
-    super
-    @chef_solo = nil
-  end
-
-  def reconfigure
-    super
-  end
-
-  def setup_application
-  end
-
-  def run_application
-    loop do
-      begin
-        if Chef::Config[:splay]
-          splay = rand Chef::Config[:splay]
-          Chef::Log.debug("Splay sleep #{splay} seconds")
-          sleep splay
-        end
-
-        @chef_solo = Chef::Client.new
-        @chef_solo.run
-        @chef_solo = nil
-        Chef::Application.exit! "Exiting", 0
-      rescue SystemExit => e
-        raise
-      rescue Exception => e
-        Chef::Application.debug_stacktrace(e)
-        Chef::Application.fatal!("#{e.class}: #{e.message}", 1)
-      ensure
-        GC.start
-      end
-    end
-  end
-end

data/lib/chef/applications.rb

@@ -1 +0,0 @@
-require 'chef/application/solo'

data/lib/chef/checksum.rb

@@ -1,103 +0,0 @@
-#
-# Author:: Tim Hinderliter (<tim@opscode.com>)
-# Copyright:: Copyright (c) 2010 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 'chef/checksum/storage'
-require 'uuidtools'
-
-class Chef
-  # == Chef::Checksum
-  # Checksum for an individual file; e.g., used for sandbox/cookbook uploading
-  # to track which files the system already manages.
-  class Checksum
-    attr_accessor :checksum, :create_time
-
-    attr_reader :storage
-
-    # When a Checksum commits a sandboxed file to its final home in the checksum
-    # repo, this attribute will have the original on-disk path where the file
-    # was stored; it will be used if the commit is reverted to restore the sandbox
-    # to the pre-commit state.
-    attr_reader :original_committed_file_location
-    
-    # Creates a new Chef::Checksum object.
-    # === Arguments
-    # checksum::: the MD5 content hash of the file
-    #
-    # === Returns
-    # object<Chef::Checksum>:: Duh. :)
-    def initialize(checksum=nil)
-      @create_time = Time.now.iso8601
-      @checksum = checksum
-      @original_committed_file_location = nil
-      @storage = Storage::Filesystem.new(Chef::Config.checksum_path, checksum)
-    end
-
-    def to_json(*a)
-      result = {
-        :checksum => checksum,
-        :create_time => create_time,
-        :json_class => self.class.name,
-        :chef_type => 'checksum',
-        :name => checksum
-      }
-      result.to_json(*a)
-    end
-
-    def self.json_create(o)
-      checksum = new(o['checksum'])
-      checksum.create_time = o['create_time']
-
-      checksum
-    end
-
-    # Moves the given +sandbox_file+ into the checksum repo using the path
-    # given by +file_location+ and saves the Checksum to the database
-    def commit_sandbox_file(sandbox_file)
-      @original_committed_file_location = sandbox_file
-      Chef::Log.info("Commiting sandbox file: move #{sandbox_file} to #{@storage}")
-      @storage.commit(sandbox_file)
-    end
-
-    # Moves the checksum file back to its pre-commit location and deletes
-    # the checksum object from the database, effectively undoing +commit_sandbox_file+.
-    # Raises Chef::Exceptions::IllegalChecksumRevert if the original file location
-    # is unknown, which is will be the case if commit_sandbox_file was not
-    # previously called
-    def revert_sandbox_file_commit
-      unless original_committed_file_location
-        raise Chef::Exceptions::IllegalChecksumRevert, "Checksum #{self.inspect} cannot be reverted because the original sandbox file location is not known"
-      end
-
-      Chef::Log.warn("Reverting sandbox file commit: moving #{@storage} back to #{original_committed_file_location}")
-      @storage.revert(original_committed_file_location)
-    end
-
-    # Removes the on-disk file backing this checksum object, then removes it
-    # from the database
-    def purge
-      purge_file
-    end
-
-    private
-
-    def purge_file
-      @storage.purge
-    end
-
-  end
-end

data/lib/chef/checksum/storage/filesystem.rb

@@ -1,56 +0,0 @@
-#
-# Author:: Tim Hinderliter (<tim@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 Checksum
-    class Storage
-      class Filesystem
-        def initialize(base_dir, checksum)
-          @base_dir = base_dir
-          @checksum = checksum
-        end
-
-        def file_location
-          File.join(checksum_repo_directory, @checksum)
-        end
-        alias :to_s :file_location
-
-        def checksum_repo_directory
-          File.join(Chef::Config.checksum_path, @checksum[0..1])
-        end
-
-        def commit(sandbox_file)
-          FileUtils.mkdir_p(checksum_repo_directory)
-          File.rename(sandbox_file, file_location)
-        end
-
-        def revert(original_committed_file_location)
-          File.rename(file_location, original_committed_file_location)
-        end
-
-        # Deletes the file backing this checksum from the on-disk repo.
-        # Purging the checksums is how users can get back to a valid state if
-        # they've deleted files, so we silently swallow Errno::ENOENT here.
-        def purge
-          FileUtils.rm(file_location)
-        rescue Errno::ENOENT
-          true
-        end
-      end
-    end
-  end
-end

data/lib/chef/checksum_cache.rb

@@ -1,189 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright (c) 2009 Opscode, Inc.
-# 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 'set'
-require 'fileutils'
-require 'chef/log'
-require 'chef/config'
-require 'chef/client'
-require 'chef/mixin/convert_to_class_name'
-require 'singleton'
-require 'moneta'
-
-class Chef
-  class ChecksumCache
-    include Chef::Mixin::ConvertToClassName
-    include ::Singleton
-
-    attr_reader :moneta
-
-    def initialize(*args)
-      self.reset!(*args)
-    end
-
-    def reset!(backend=nil, options=nil)
-      backend ||= Chef::Config[:cache_type]
-      options ||= Chef::Config[:cache_options]
-
-      begin
-        require "moneta/#{convert_to_snake_case(backend, 'Moneta')}"
-      rescue LoadError => e
-        Chef::Log.fatal("Could not load Moneta back end #{backend.inspect}")
-        raise e
-      end
-
-      @moneta = Moneta.const_get(backend).new(options)
-    end
-
-    def self.reset_cache_validity
-      @valid_cached_checksums = nil
-    end
-
-    Chef::Client.when_run_starts do |run_status|
-      reset_cache_validity
-    end
-
-    def self.valid_cached_checksums
-      @valid_cached_checksums ||= Set.new
-    end
-
-    def self.validate_checksum(checksum_key)
-      valid_cached_checksums << checksum_key
-    end
-
-    def self.all_cached_checksums
-      all_checksums_with_filenames = {}
-
-      Dir[File.join(Chef::Config[:cache_options][:path], '*')].each do |cksum_file|
-        all_checksums_with_filenames[File.basename(cksum_file)] = cksum_file
-      end
-      all_checksums_with_filenames
-    end
-
-    def self.cleanup_checksum_cache
-      Chef::Log.debug("Cleaning the checksum cache")
-      if (Chef::Config[:cache_type].to_s == "BasicFile")
-        all_cached_checksums.each do |cache_key, cksum_cache_file|
-          unless valid_cached_checksums.include?(cache_key)
-            remove_unused_checksum(cksum_cache_file)
-          end
-        end
-      end
-    end
-
-    Chef::Client.when_run_completes_successfully do |run_status|
-      cleanup_checksum_cache
-    end
-
-    def self.remove_unused_checksum(checksum_file)
-      Chef::Log.debug("Removing unused checksum cache file #{checksum_file}")
-      FileUtils.rm(checksum_file)
-    end
-
-    def self.checksum_for_file(*args)
-      instance.checksum_for_file(*args)
-    end
-
-    def validate_checksum(*args)
-      self.class.validate_checksum(*args)
-    end
-
-    def checksum_for_file(file, key=nil)
-      key ||= generate_key(file)
-      fstat = File.stat(file)
-      lookup_checksum(key, fstat) || generate_checksum(key, file, fstat)
-    end
-
-    def lookup_checksum(key, fstat)
-      cached = fetch(key)
-      if cached && file_unchanged?(cached, fstat)
-        validate_checksum(key)
-        cached["checksum"]
-      else
-        nil
-      end
-    end
-
-    def generate_checksum(key, file, fstat)
-      checksum = checksum_file(file, Digest::SHA256.new)
-      moneta.store(key, {"mtime" => fstat.mtime.to_f, "checksum" => checksum})
-      validate_checksum(key)
-      checksum
-    end
-
-    def generate_key(file, group="chef")
-      "#{group}-file-#{file.gsub(/(#{File::SEPARATOR}|\.)/, '-')}"
-    end
-
-    def self.generate_md5_checksum_for_file(*args)
-      instance.generate_md5_checksum_for_file(*args)
-    end
-
-    def generate_md5_checksum_for_file(file)
-      checksum_file(file, Digest::MD5.new)
-    end
-
-    def generate_md5_checksum(io)
-      checksum_io(io, Digest::MD5.new)
-    end
-
-    private
-
-    def fetch(key)
-      @moneta.fetch(key)
-    rescue ArgumentError => e
-      Log.warn "Error loading cached checksum for key #{key.inspect}"
-      Log.warn(e)
-      repair_checksum_cache
-      nil
-    end
-
-    def repair_checksum_cache
-      Chef::Log.info("Removing invalid checksum cache files")
-      Dir["#{Chef::Config[:cache_options][:path]}/*"].each do |file_path|
-        File.unlink(file_path) unless File.size?(file_path)
-      end
-    end
-
-    def file_unchanged?(cached, fstat)
-      cached["mtime"].to_f == fstat.mtime.to_f
-    end
-
-    def checksum_file(file, digest)
-      File.open(file, 'rb') { |f| checksum_io(f, digest) }
-    end
-
-    def checksum_io(io, digest)
-      while chunk = io.read(1024 * 8)
-        digest.update(chunk)
-      end
-      digest.hexdigest
-    end
-
-  end
-end
-
-module Moneta
-  module Defaults
-    def default
-      nil
-    end
-  end
-end