cheffish 0.4.1 → 0.5.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 119b0502e35e57dd3580bcbeb00dba88f64be3f5
+  data.tar.gz: eb28bbbc909edce3f303cf9783a591fd957c35c9
+SHA512:
+  metadata.gz: c7cce6bb368c8c1efcabcd26f315d4b7cbee59f5956370efa2e60331086b3d0c6d0236c4585d5d3915dc1c37ece13d12b50a2543d72c04b7cde4f213ea49e2f1
+  data.tar.gz: 6e6522c74eee08367fd73d063af1d57b18ec2d017617a1ef62bbaccf87b18decf3e75788f6c3743847ee7f1eaf720f2df84e8ad8bdeb217c4c382f09a9cfcb5a

data/lib/chef/provider/chef_data_bag_item.rb

@@ -152,12 +152,12 @@ class Chef::Provider::ChefDataBagItem < Cheffish::ChefProviderBase
   end
 
   def encrypt(json, secret, version)
-    old_version = Chef::Config[:data_bag_encrypt_version]
-    Chef::Config[:data_bag_encrypt_version] = version
+    old_version = run_context.config[:data_bag_encrypt_version]
+    run_context.config[:data_bag_encrypt_version] = version
     begin
       Chef::EncryptedDataBagItem.encrypt_data_bag_item(json, secret)
     ensure
-      Chef::Config[:data_bag_encrypt_version] = old_version
+      run_context.config[:data_bag_encrypt_version] = old_version
     end
   end
 
@@ -270,4 +270,4 @@ class Chef::Provider::ChefDataBagItem < Cheffish::ChefProviderBase
     FakeEntry.new("#{new_resource.id}.json", FakeEntry.new(new_resource.data_bag))
   end
 
-end
+end

data/lib/chef/provider/private_key.rb

@@ -14,8 +14,8 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
 
   action :delete do
     if Array(current_resource.action) == [ :create ]
-      converge_by "delete private key #{new_resource.path}" do
-        ::File.unlink(new_resource.path)
+      converge_by "delete private key #{new_path}" do
+        ::File.unlink(new_path)
       end
     end
   end
@@ -27,15 +27,21 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
   end
 
   def create_key(regenerate, action)
+    if @should_create_directory
+      Cheffish.inline_resource(self, action) do
+        directory run_context.config[:private_key_write_path]
+      end
+    end
+
     final_private_key = nil
     if new_source_key
       #
       # Create private key from source
       #
       desired_output = encode_private_key(new_source_key)
-      if Array(current_resource.action) == [ :delete ] || desired_output != IO.read(new_resource.path)
-        converge_by "reformat key at #{new_resource.source_key_path} to #{new_resource.format} private key #{new_resource.path} (#{new_resource.pass_phrase ? ", #{new_resource.cipher} password" : ""})" do
-          IO.write(new_resource.path, desired_output)
+      if Array(current_resource.action) == [ :delete ] || desired_output != IO.read(new_path)
+        converge_by "reformat key at #{new_resource.source_key_path} to #{new_resource.format} private key #{new_path} (#{new_resource.pass_phrase ? ", #{new_resource.cipher} password" : ""})" do
+          IO.write(new_path, desired_output)
         end
       end
 
@@ -50,7 +56,7 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
           (current_resource.size != new_resource.size ||
            current_resource.type != new_resource.type))
         action = (Array(current_resource.action) == [ :delete ]) ? "create" : "overwrite"
-        converge_by "#{action} #{new_resource.type} private key #{new_resource.path} (#{new_resource.size} bits#{new_resource.pass_phrase ? ", #{new_resource.cipher} password" : ""})" do
+        converge_by "#{action} #{new_resource.type} private key #{new_path} (#{new_resource.size} bits#{new_resource.pass_phrase ? ", #{new_resource.cipher} password" : ""})" do
           case new_resource.type
           when :rsa
             if new_resource.exponent
@@ -62,7 +68,7 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
             final_private_key = OpenSSL::PKey::DSA.generate(new_resource.size)
           end
 
-          if new_resource.path != :none
+          if new_path != :none
             write_private_key(final_private_key)
           end
         end
@@ -77,13 +83,13 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
         final_private_key = current_private_key
 
         if current_resource.format != new_resource.format
-          converge_by "change format of #{new_resource.type} private key #{new_resource.path} from #{current_resource.format} to #{new_resource.format}" do
+          converge_by "change format of #{new_resource.type} private key #{new_path} from #{current_resource.format} to #{new_resource.format}" do
             write_private_key(current_private_key)
           end
         elsif (@current_file_mode & 0077) != 0
           new_mode = @current_file_mode & 07700
-          converge_by "change mode of private key #{new_resource.path} to #{new_mode.to_s(8)}" do
-            ::File.chmod(new_mode, new_resource.path)
+          converge_by "change mode of private key #{new_path} to #{new_mode.to_s(8)}" do
+            ::File.chmod(new_mode, new_path)
           end
         end
       end
@@ -114,7 +120,7 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
   end
 
   def write_private_key(key)
-    ::File.open(new_resource.path, 'w') do |file|
+    ::File.open(new_path, 'w') do |file|
       file.chmod(0600)
       file.write(encode_private_key(key))
     end
@@ -138,14 +144,26 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
 
   attr_reader :current_private_key
 
+  def new_path
+    path = new_resource.path
+    if path.is_a?(Symbol)
+      path
+    elsif Pathname.new(path).relative? && run_context.config[:private_key_write_path]
+      @should_create_directory = true
+      ::File.join(run_context.config[:private_key_write_path], path)
+    else
+      path
+    end
+  end
+
   def load_current_resource
     resource = Chef::Resource::PrivateKey.new(new_resource.name, run_context)
 
-    if new_resource.path != :none && ::File.exist?(new_resource.path)
-      resource.path new_resource.path
+    if new_path != :none && ::File.exist?(new_path)
+      resource.path new_path
 
       begin
-        key, key_format = Cheffish::KeyFormatter.decode(IO.read(new_resource.path), new_resource.pass_phrase, new_resource.path)
+        key, key_format = Cheffish::KeyFormatter.decode(IO.read(new_path), new_resource.pass_phrase, new_path)
         if key
           @current_private_key = key
           resource.format key_format[:format]
@@ -155,7 +173,7 @@ class Chef::Provider::PrivateKey < Chef::Provider::LWRPBase
           resource.pass_phrase key_format[:pass_phrase]
           resource.cipher key_format[:cipher]
         end
-        @current_file_mode = ::File.stat(new_resource.path).mode
+        @current_file_mode = ::File.stat(new_path).mode
       rescue
         # If there's an error reading, we assume format and type are wrong and don't futz with them
       end

data/lib/chef/resource/chef_data_bag_item.rb

@@ -17,9 +17,9 @@ class Chef::Resource::ChefDataBagItem < Chef::Resource::LWRPBase
     if run_context.cheffish.current_data_bag_item_encryption
       @encrypt = true if run_context.cheffish.current_data_bag_item_encryption[:encrypt_all]
       @secret = run_context.cheffish.current_data_bag_item_encryption[:secret]
-      @secret_path = run_context.cheffish.current_data_bag_item_encryption[:secret_path] || Chef::Config[:encrypted_data_bag_secret]
+      @secret_path = run_context.cheffish.current_data_bag_item_encryption[:secret_path] || run_context.config[:encrypted_data_bag_secret]
       @encryption_cipher = run_context.cheffish.current_data_bag_item_encryption[:encryption_cipher]
-      @encryption_version = run_context.cheffish.current_data_bag_item_encryption[:encryption_version]
+      @encryption_version = run_context.cheffish.current_data_bag_item_encryption[:encryption_version] || run_context.config[:data_bag_encrypt_version]
       @old_secret = run_context.cheffish.current_data_bag_item_encryption[:old_secret]
       @old_secret_path = run_context.cheffish.current_data_bag_item_encryption[:old_secret_path]
     end
@@ -81,7 +81,7 @@ class Chef::Resource::ChefDataBagItem < Chef::Resource::LWRPBase
       @encrypt = true if @encrypt.nil?
     end
   end
-  attribute :encryption_version, :kind_of => Integer, :default => Chef::Config[:data_bag_encrypt_version]
+  attribute :encryption_version, :kind_of => Integer
 
   # Old secret (or secrets) to read the old data bag when we are changing keys and re-encrypting data
   attribute :old_secret, :kind_of => [String, Array]

data/lib/cheffish/basic_chef_client.rb

@@ -6,6 +6,8 @@ require 'chef/node'
 require 'chef/run_context'
 require 'chef/runner'
 require 'forwardable'
+require 'chef/providers'
+require 'chef/resources'
 
 module Cheffish
   class BasicChefClient

data/lib/cheffish/chef_provider_base.rb

@@ -1,12 +1,11 @@
 require 'chef/config'
 require 'chef/run_list'
 require 'chef/provider/lwrp_base'
-require 'cheffish/cheffish_server_api'
 
 module Cheffish
   class ChefProviderBase < Chef::Provider::LWRPBase
     def rest
-      @rest ||= CheffishServerAPI.new(new_resource.chef_server)
+      @rest ||= Cheffish.chef_server_api(new_resource.chef_server, run_context.config)
     end
 
     def current_resource_exists?

data/lib/cheffish/chef_run_data.rb

@@ -3,9 +3,9 @@ require 'cheffish/with_pattern'
 
 module Cheffish
   class ChefRunData
-    def initialize
+    def initialize(config)
       @local_servers = []
-      @current_chef_server = Cheffish.default_chef_server
+      @current_chef_server = Cheffish.default_chef_server(config)
     end
 
     extend Cheffish::WithPattern

data/lib/cheffish/merged_config.rb

@@ -0,0 +1,70 @@
+module Cheffish
+  class MergedConfig
+    def initialize(*configs)
+      @configs = configs
+      @merge_arrays = {}
+    end
+
+    attr_reader :configs
+    def merge_arrays(*symbols)
+      symbols.each do |symbol|
+        @merge_arrays[symbol] = true
+      end
+    end
+
+    def [](name)
+      if @merge_arrays[name]
+        configs.select { |c| !c[name].nil? }.collect_concat { |c| c[name] }
+      else
+        result_configs = []
+        configs.each do |config|
+          value = config[name]
+          if !value.nil?
+            if value.respond_to?(:keys)
+              result_configs << value
+            elsif result_configs.size > 0
+              return result_configs[0]
+            else
+              return value
+            end
+          end
+        end
+        if result_configs.size > 1
+          MergedConfig.new(*result_configs)
+        elsif result_configs.size == 1
+          result_configs[0]
+        else
+          nil
+        end
+      end
+    end
+
+    def method_missing(name)
+      self[name]
+    end
+
+    def has_key?(name)
+      configs.any? { config.has_key?(name) }
+    end
+
+    def keys
+      configs.map { |c| c.keys }.flatten(1).uniq
+    end
+
+    def values
+      keys.map { |key| self[key] }
+    end
+
+    def each_pair(&block)
+      each(&block)
+    end
+
+    def each
+      keys.each do |key|
+        if block_given?
+          yield key, self[key]
+        end
+      end
+    end
+  end
+end

data/lib/cheffish/recipe_dsl.rb

@@ -6,6 +6,8 @@ require 'chef/chef_fs/config'
 require 'cheffish/chef_run_data'
 require 'cheffish/chef_run_listener'
 require 'chef/client'
+require 'chef/config'
+require 'cheffish/merged_config'
 
 class Chef
   module DSL
@@ -41,9 +43,9 @@ class Chef
           %w(acl client cookbook container data_bag environment group node role).each do |type|
             options["#{type}_path".to_sym] ||= begin
               if options[:chef_repo_path].kind_of?(String)
-                Chef::Config.path_join(options[:chef_repo_path], "#{type}s")
+                run_context.config.path_join(options[:chef_repo_path], "#{type}s")
               else
-                options[:chef_repo_path].map { |path| Chef::Config.path_join(path, "#{type}s")}
+                options[:chef_repo_path].map { |path| run_context.config.path_join(path, "#{type}s")}
               end
             end
             # Work around issue in earlier versions of ChefFS where it expects strings for these
@@ -68,14 +70,25 @@ class Chef
     end
   end
 
+  class Config
+    default(:profile) { ENV['CHEF_PROFILE'] || 'default' }
+    configurable(:private_keys)
+    default(:private_key_paths) { [ path_join(config_dir, 'keys'), path_join(user_home, '.ssh') ] }
+    default(:private_key_write_path) { private_key_paths.first }
+  end
+
   class RunContext
     def cheffish
       @cheffish ||= begin
-        run_data = Cheffish::ChefRunData.new
+        run_data = Cheffish::ChefRunData.new(config)
         events.register(Cheffish::ChefRunListener.new(self))
         run_data
       end
     end
+
+    def config
+      @config ||= Cheffish.profiled_config(Chef::Config)
+    end
   end
 
   Chef::Client.when_run_starts do |run_status|

data/lib/cheffish/version.rb

@@ -1,3 +1,3 @@
 module Cheffish
-  VERSION = '0.4.1'
+  VERSION = '0.5.beta'
 end

data/lib/cheffish.rb

@@ -1,5 +1,10 @@
 require 'chef/run_list/run_list_item'
 require 'cheffish/basic_chef_client'
+require 'chef/server_api'
+require 'chef/knife'
+require 'chef/config_fetcher'
+require 'chef/log'
+require 'chef/application'
 
 module Cheffish
   NAME_REGEX = /^[.\-[:alnum:]_]+$/
@@ -8,16 +13,67 @@ module Cheffish
     BasicChefClient.inline_resource(provider, provider_action, &block)
   end
 
-  def self.default_chef_server
+  def self.default_chef_server(config = profiled_config)
     {
-      :chef_server_url => Chef::Config[:chef_server_url],
+      :chef_server_url => config[:chef_server_url],
       :options => {
-        :client_name => Chef::Config[:node_name],
-        :signing_key_filename => Chef::Config[:client_key]
+        :client_name => config[:node_name],
+        :signing_key_filename => config[:client_key]
       }
     }
   end
 
+  def self.chef_server_api(chef_server_hash = default_chef_server, config = Chef::Config)
+    Chef::ServerAPI.new(config[:chef_server_url], :client_name => config[:node_name], :signing_key_filename => config[:client_key])
+  end
+
+  def self.profiled_config(config = Chef::Config)
+    if config.profile && config.profiles && config.profiles[config.profile]
+      MergedConfig.new(config.profiles[config.profile], config)
+    else
+      config
+    end
+  end
+
+  def self.load_chef_config(chef_config = Chef::Config)
+    chef_config.config_file = Chef::Knife.locate_config_file
+    config_fetcher = Chef::ConfigFetcher.new(chef_config.config_file, chef_config.config_file_jail)
+    if chef_config.config_file.nil?
+      Chef::Log.warn("No config file found or specified on command line, using command line options.")
+    elsif config_fetcher.config_missing?
+      Chef::Log.warn("Did not find config file: #{chef_config.config_file}, using command line options.")
+    else
+      config_content = config_fetcher.read_config
+      config_file_path = chef_config.config_file
+      begin
+        chef_config.from_string(config_content, config_file_path)
+      rescue Exception => error
+        Chef::Log.fatal("Configuration error #{error.class}: #{error.message}")
+        filtered_trace = error.backtrace.grep(/#{Regexp.escape(config_file_path)}/)
+        filtered_trace.each {|line| Chef::Log.fatal("  " + line )}
+        Chef::Application.fatal!("Aborting due to error in '#{config_file_path}'", 2)
+      end
+    end
+    Cheffish.profiled_config(chef_config)
+  end
+
+  def self.honor_local_mode(local_mode_default = true)
+    if !Chef::Config.has_key?(:local_mode) && !local_mode_default.nil?
+      Chef::Config.local_mode = default
+    end
+    if Chef::Config.local_mode && !Chef::Config.has_key?(:cookbook_path) && !Chef::Config.has_key?(:chef_repo_path)
+      Chef::Config.chef_repo_path = Chef::Config.find_chef_repo_path(Dir.pwd)
+    end
+    Chef::Application.setup_server_connectivity
+    if block_given?
+      begin
+        yield
+      ensure
+        Chef::Application.destroy_server_connectivity
+      end
+    end
+  end
+
   NOT_PASSED=Object.new
 
   def self.node_attributes(klass)

metadata

@@ -1,78 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: cheffish
 version: !ruby/object:Gem::Version
-  version: 0.4.1
-  prerelease: 
+  version: 0.5.beta
 platform: ruby
 authors:
 - John Keiser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-07 00:00:00.000000000 Z
+date: 2014-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: openssl_pkcs8
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A library to manipulate Chef in Chef.
@@ -110,8 +101,8 @@ files:
 - lib/cheffish/chef_provider_base.rb
 - lib/cheffish/chef_run_data.rb
 - lib/cheffish/chef_run_listener.rb
-- lib/cheffish/cheffish_server_api.rb
 - lib/cheffish/key_formatter.rb
+- lib/cheffish/merged_config.rb
 - lib/cheffish/recipe_dsl.rb
 - lib/cheffish/version.rb
 - lib/cheffish/with_pattern.rb
@@ -126,27 +117,26 @@ files:
 - spec/support/spec_support.rb
 homepage: http://wiki.opscode.com/display/chef
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A library to manipulate Chef in Chef.
 test_files: []
 has_rdoc: 

data/lib/cheffish/cheffish_server_api.rb

@@ -1,21 +0,0 @@
-require 'chef/http'
-require 'chef/http/authenticator'
-require 'chef/http/cookie_manager'
-require 'chef/http/decompressor'
-require 'chef/http/json_input'
-require 'chef/http/json_output'
-
-module Cheffish
-  # Just like ServerAPI, except it does not default the server URL or options
-  class CheffishServerAPI < Chef::HTTP
-    def initialize(chef_server)
-      super(chef_server[:chef_server_url], chef_server[:options] || {})
-    end
-
-    use Chef::HTTP::JSONInput
-    use Chef::HTTP::JSONOutput
-    use Chef::HTTP::CookieManager
-    use Chef::HTTP::Decompressor
-    use Chef::HTTP::Authenticator
-  end
-end