vagrant-chefconfig 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c980079fd5c2c530dedcc73e25dd65d5990bfb6
-  data.tar.gz: bdea236f19e96c7696ec82b1fd0e6948ac5cd2e0
+  metadata.gz: f509a14e5ea7178235cdbe28f7f5795532e4155b
+  data.tar.gz: d33cdfa17892f30c543554d46b0c177acb05bd95
 SHA512:
-  metadata.gz: 9188a96baa8a07b7dd5f1aa71d7980897e9cad1366828ce157f37018ee39b21e2c30221e157c432e24d55a353fc1944a6f20a102fcb49080dc7c697c980116d1
-  data.tar.gz: c5b3275fb47b4e86f4e2ba9fb92d7b946826de41cb65b2bae2e6fbf2ba091ce0df249bc44d88193dd4f7d6eb2c8befee50dd04c3e7c3900e43f9a5598c8144e3
+  metadata.gz: f2f953660d958c572f1b79ebfbb0ec3d2b4d9226f797530a3356e90ebd063dc4263510038d6cead17fa597b9f7ff522cca619042e1d36b501529806543e42bc6
+  data.tar.gz: f249315e7323e2bd3dd99a805f3f6de46b72ecabf015f5db6b798b8716bc01d253bb4b8df487d7b204b488f284d86366a887bb0d41ba041bc3f2fcd8895c32ab

data/Gemfile

@@ -7,7 +7,7 @@ group :development do
   # We depend on Vagrant for development, but we don't add it as a
   # gem dependency because we expect to be installed within the
   # Vagrant environment itself using `vagrant plugin`.
-  gem "vagrant", :github => 'mitchellh/vagrant'
+  gem "vagrant", :git => "https://github.com/mitchellh/vagrant.git"
 end
 
 # This group is read by Vagrant for plugin development

data/README.md

@@ -21,14 +21,33 @@ end
 
 The plugin will automatically configure the following Vagrant chef-client provisioner attributes from your knife.rb.
 
-Vagrant chef-client attribute -> knife config attribute
---------------------------------------------------------
-* `chef_server_url` - same
-* `log_level` - same
-* `validation_key_path` - maps to `validation_key`
-* `validation_client_name` - same
-* `environment` - maps to `vagrant_environment`, this is a non-standard knife config key.
-* `encrypted_data_bag_secret_key_path` - maps to `encrypted_data_bag_secret`
+## Vagrant chef-client attribute -> knife config attribute
+<table>
+  <tr>
+    <th>Vagrant attribute name</th>
+    <th>Knife attribute name</th>
+  </tr>
+  <tr>
+    <td>chef_server_url</td>
+    <td>chef_server_url</td>
+  </tr>
+  <tr>
+    <td>log_level</td>
+    <td>log_level</td>
+  </tr>
+  <tr>
+    <td>validation_key_path</td>
+    <td>validation_key</td>
+  </tr>
+  <tr>
+    <td>environment</td>
+    <td>vagrant_environment</td>
+  </tr>
+  <tr>
+    <td>encrypted_data_bag_secret_key_path</td>
+    <td>encrypted_data_bag_secret</td>
+  </tr>
+</table>
 
 Values specified directly in the Vagrantfile override any configured values found in your knife configuration file.
 
@@ -41,14 +60,26 @@ By default the plugin will be enabled and the path to the knife.rb uses the [sta
 
 ## Changelog
 
+### 0.1.0
+
+- Added support for Vagrant 1.7+.
+- Fixed issue 1. Don't read knife.rb if there are no chef-client provisioner blocks in Vagrantfile.
+- Removed dependency upon Chef gem. Handles loading Knife config directly with mixlib-config
+
 ### 0.0.1
 
-Initial release for Vagrant 1.5
+- Initial release for Vagrant 1.5
 
 # Authors
 
 * Shawn Neal (<sneal@sneal.net>)
 
+## Developing
+
+1. Clone repo
+2. `bundle install`
+3. `bundle exec vagrant up`
+
 ## Contributing
 
 1. Fork it

data/Rakefile

@@ -1 +1,3 @@
-require "bundler/gem_tasks"
+require 'rubygems'
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks

data/Vagrantfile

@@ -2,7 +2,7 @@
 # vi: set ft=ruby :
 
 Vagrant.configure('2') do |config|
-  config.vm.box = "opscode_ubuntu-12.04_chef-11.2.0"
+  config.vm.box = 'chef/ubuntu-14.04'
   config.vm.provision :chef_client do |chef|
     chef.node_name = 'vagrant_chefconfig_test_vm'
     chef.run_list = [ 'apt' ]

data/lib/vagrant-chefconfig/chef_client_configurator.rb

@@ -1,6 +1,6 @@
 require 'log4r'
-require 'chef'
-require 'chef/knife'
+require_relative 'knife_config'
+require_relative 'knife_config_locator'
 
 module Vagrant
   module ChefConfig
@@ -12,16 +12,20 @@ module Vagrant
       end
 
       def apply_knife_config()
+        provisioners = chef_client_provisioners
+        return if provisioners.length == 0
+
         load_knife_config()
 
-        chef_client_provisioners.each do |chef_client_provisioner|
-          chef_config = chef_client_provisioner.config
+        provisioners.each do |provisioner|
+          chef_config = provisioner.config
 
-          set_if_default(chef_config, :chef_server_url, :chef_server_url)
-          set_if_default(chef_config, :log_level, :log_level)
-          set_if_default(chef_config, :validation_key_path, :validation_key)
-          set_if_default(chef_config, :validation_client_name, :validation_client_name)
-          set_if_default(chef_config, :environment, :vagrant_environment)
+          #                           vagrant config key                   knife config key
+          set_if_default(chef_config, :chef_server_url,                    :chef_server_url)
+          set_if_default(chef_config, :log_level,                          :log_level)
+          set_if_default(chef_config, :validation_key_path,                :validation_key)
+          set_if_default(chef_config, :validation_client_name,             :validation_client_name)
+          set_if_default(chef_config, :environment,                        :vagrant_environment)
           set_if_default(chef_config, :encrypted_data_bag_secret_key_path, :encrypted_data_bag_secret)
         end
       end
@@ -29,45 +33,54 @@ module Vagrant
 
       private
 
-      def set_if_default(chef_config, config_prop_sym, chef_prop_sym)
+      def set_if_default(chef_config, config_prop_sym, knife_prop_sym)
         config_val = chef_config.send(config_prop_sym)
+        knife_val = KnifeConfig[knife_prop_sym]
 
         @logger.debug("Vagrantfile config val #{config_prop_sym} = #{config_val}")
-        @logger.debug("Knife config val #{config_prop_sym} = #{Chef::Config[chef_prop_sym]}")
+        @logger.debug("Knife config val #{knife_prop_sym} = #{knife_val}")
 
-        if is_default_value(config_prop_sym, config_val)
+        if is_default_vagrant_value(config_prop_sym, config_val)
           @logger.debug("Overwriting '#{config_prop_sym}' in Vagrantfile chef-client " +
-            "provisioner with '#{Chef::Config[chef_prop_sym]}'")
-          chef_config.send("#{config_prop_sym}=", Chef::Config[chef_prop_sym])
+            "provisioner with '#{knife_val}'")
+          chef_config.send("#{config_prop_sym}=", knife_val)
         end
       end
 
-      def is_default_value(config_prop_sym, config_val)
+      def is_default_vagrant_value(config_prop_sym, config_val)
         case config_prop_sym
         when :validation_client_name
           return config_val == 'chef-validator'
-        when :client_key_path
-          return config_val == '/etc/chef/client.pem'
+        when :log_level
+          return config_val == :info
         else
           return config_val.nil?
         end
       end
 
       def chef_client_provisioners()
-        @env[:machine].config.vm.provisioners.select { |prov| prov.name == :chef_client }
+        @env[:machine].config.vm.provisioners.select do |prov|
+          begin
+            prov.type == :chef_client
+          rescue NoMethodError
+            prov.name == :chef_client # support for Vagrant <= 1.6.5
+          end
+        end
       end
 
       def load_knife_config()
         knife_config_path = locate_knife_config_file()
         @logger.debug("Using knife config from '#{knife_config_path}'")
-        Chef::Config.from_file(knife_config_path)
+        KnifeConfig.from_file(knife_config_path)
       end
 
       def locate_knife_config_file()
-        # If the Vagrantfile directly sets the knife.rb path use it, otherwise let
-        # knife find its configuration file
+        # If the Vagrantfile directly sets the knife.rb path use it, otherwise 
+        # default to the .chef directory under the user's home dir
+        # This could be improved to have the same behavior as Chef for finding
+        # the knife.rb relative to the current directory
         knife_config_path = plugin_config().knife_config_path
-        knife_config_path ? knife_config_path : Chef::Knife.locate_config_file()
+        knife_config_path ? knife_config_path : KnifeConfigLocator.new().locate_local_config
       end
 
       def plugin_config()
@@ -76,4 +89,4 @@ module Vagrant
 
     end #ChefClientConfigurator
   end
-end
+end

data/lib/vagrant-chefconfig/knife_config.rb

@@ -0,0 +1,28 @@
+require 'mixlib/config'
+require_relative 'path_helper'
+
+module Vagrant
+  module ChefConfig
+    # Subset of Chef Config class functionality
+    # Matches Chef 12 default behavior
+    class KnifeConfig
+
+      extend Mixlib::Config
+
+      default :chef_server_url, "https://localhost:443"
+      default :log_level, :auto
+      default(:validation_key) { PathHelper.platform_specific_path("/etc/chef/validation.pem") }
+      default :validation_client_name, 'chef-validator'
+      default :vagrant_environment, :dev
+
+      default(:encrypted_data_bag_secret) do
+        key_path = PathHelper.platform_specific_path("/etc/chef/encrypted_data_bag_secret")
+        if File.exist?(key_path)
+          key_path
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-chefconfig/knife_config_locator.rb

@@ -0,0 +1,73 @@
+require_relative 'path_helper'
+
+module Vagrant
+  module ChefConfig
+    # Locates the local knife config using the same behavior as Chef 12
+    # Borrowed from Chef WorkstationConfigLoader
+    # Author:: Daniel DeLeo (<dan@getchef.com>)
+    class KnifeConfigLocator
+
+      def initialize()
+        @logger = Log4r::Logger.new("vagrant_chefconfig::knifeconfiglocator") 
+      end
+
+      def locate_local_config
+        candidate_configs = []
+
+        # Look for $KNIFE_HOME/knife.rb (allow multiple knives config on same machine)
+        if ENV['KNIFE_HOME']
+          candidate_configs << File.join(ENV['KNIFE_HOME'], 'config.rb')
+          candidate_configs << File.join(ENV['KNIFE_HOME'], 'knife.rb')
+        end
+        # Look for $PWD/knife.rb
+        if Dir.pwd
+          candidate_configs << File.join(Dir.pwd, 'config.rb')
+          candidate_configs << File.join(Dir.pwd, 'knife.rb')
+        end
+        # Look for $UPWARD/.chef/knife.rb
+        if chef_config_dir
+          candidate_configs << File.join(chef_config_dir, 'config.rb')
+          candidate_configs << File.join(chef_config_dir, 'knife.rb')
+        end
+        # Look for $HOME/.chef/knife.rb
+        candidate_configs << File.join(home_dot_chef_dir, 'config.rb')
+        candidate_configs << File.join(home_dot_chef_dir, 'knife.rb')
+
+        candidate_configs.find do | candidate_config |
+          have_config?(candidate_config)
+        end
+      end
+
+      private
+
+      def chef_config_dir
+        if @chef_config_dir.nil?
+          @chef_config_dir = false
+          full_path = Dir.pwd.split(File::SEPARATOR)
+          (full_path.length - 1).downto(0) do |i|
+            candidate_directory = File.join(full_path[0..i] + [".chef" ])
+            if File.exist?(candidate_directory) && File.directory?(candidate_directory)
+              @chef_config_dir = candidate_directory
+              break
+            end
+          end
+        end
+        @chef_config_dir
+      end
+
+      def home_dot_chef_dir
+        File.join(Dir.home, '.chef')
+      end
+
+      def have_config?(path)
+        if File.exist?(path)
+          @logger.info("Using config at #{path}")
+          true
+        else
+          @logger.debug("Config not found at #{path}, trying next option")
+          false
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-chefconfig/path_helper.rb

@@ -0,0 +1,27 @@
+module Vagrant
+  module ChefConfig
+    # Helper to deal with paths, mainly on Windows
+    # Borrowed from Chef 12 PathHelper class
+    class PathHelper
+      def self.platform_specific_path(path)
+        path = cleanpath(path)
+        if Gem.win_platform?
+          # \etc\chef\client.rb and \var\chef\client.rb -> C:/chef/client.rb
+          if env['SYSTEMDRIVE'] && path[0] == '\\' && path.split('\\')[2] == 'chef'
+            path = File.join(env['SYSTEMDRIVE'], path.split('\\', 3)[2])
+          end
+        end
+        path
+      end
+
+      def self.cleanpath(path)
+        path = Pathname.new(path).cleanpath.to_s
+        # ensure all forward slashes are backslashes
+        if Gem.win_platform?
+          path = path.gsub(File::SEPARATOR, path_separator)
+        end
+        path
+      end
+    end
+  end
+end

data/lib/vagrant-chefconfig/version.rb

@@ -1,5 +1,5 @@
 module Vagrant
   module ChefConfig
-    VERSION = '0.0.2'
+    VERSION = '0.1.0'
   end
 end

data/vagrant-chefconfig.gemspec

@@ -18,9 +18,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "chef", "~> 11"
+  gem.add_runtime_dependency "mixlib-config", "~> 2"
 
   gem.add_development_dependency "rake"
   gem.add_development_dependency "rspec"
-  gem.add_development_dependency "bundler", ">= 1.3"
 end

metadata

@@ -1,71 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-chefconfig
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Shawn Neal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-18 00:00:00.000000000 Z
+date: 2015-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: chef
+  name: mixlib-config
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '11'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '11'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '1.3'
 description: Load Chef gem client config from knife.rb
 email:
 - sneal@sneal.net
@@ -73,8 +59,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -87,6 +73,9 @@ files:
 - lib/vagrant-chefconfig/config.rb
 - lib/vagrant-chefconfig/env.rb
 - lib/vagrant-chefconfig/errors.rb
+- lib/vagrant-chefconfig/knife_config.rb
+- lib/vagrant-chefconfig/knife_config_locator.rb
+- lib/vagrant-chefconfig/path_helper.rb
 - lib/vagrant-chefconfig/plugin.rb
 - lib/vagrant-chefconfig/version.rb
 - vagrant-chefconfig.gemspec
@@ -100,17 +89,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Duplicating Chef client configuration is less than ideal, lets reuse our